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 0x01f9 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01f9, 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 0x70a08231 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xad6d9a44 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0xad6d9a44 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xad6d9a44 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xca800144 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xca800144 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xca800144 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xca800144 003A 14 EQ 003B 61 PUSH2 0x058e 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058e, if 0xca800144 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xca800144 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x05ae 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ae, 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 0xeabe09ad 0050 14 EQ 0051 61 PUSH2 0x05f7 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f7, if 0xeabe09ad == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xeabe09ad == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x0617 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0617, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf382367b 0066 14 EQ 0067 61 PUSH2 0x0637 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0637, if 0xf382367b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf382367b == stack[-1] 006B 61 PUSH2 0x01f9 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_006F: // Incoming jump from 0x0033, if 0xca800144 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xad6d9a44 0076 14 EQ 0077 61 PUSH2 0x0505 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0505, if 0xad6d9a44 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xad6d9a44 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xb88d4fde 0081 14 EQ 0082 61 PUSH2 0x053b 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053b, 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 0xc4d216ee 008C 14 EQ 008D 61 PUSH2 0x055b 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055b, if 0xc4d216ee == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc4d216ee == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x056e 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056e, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] 009C 61 PUSH2 0x01f9 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_00A0: // Incoming jump from 0x0028, if 0xad6d9a44 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x8de38f98 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x8de38f98 > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8de38f98 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8de38f98 00B2 14 EQ 00B3 61 PUSH2 0x049a 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049a, if 0x8de38f98 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8de38f98 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 14 EQ 00BE 61 PUSH2 0x04ba 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ba, if 0x95d89b41 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa035b1fe 00C8 14 EQ 00C9 61 PUSH2 0x04cf 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cf, if 0xa035b1fe == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa035b1fe == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa22cb465 00D3 14 EQ 00D4 61 PUSH2 0x04e5 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if 0xa22cb465 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa22cb465 == stack[-1] 00D8 61 PUSH2 0x01f9 00DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_00DC: // Incoming jump from 0x00AB, if 0x8de38f98 > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x70a08231 00E3 14 EQ 00E4 61 PUSH2 0x0427 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0427, if 0x70a08231 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x70a08231 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x715018a6 00EE 14 EQ 00EF 61 PUSH2 0x0447 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0447, if 0x715018a6 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x85352058 00F9 14 EQ 00FA 61 PUSH2 0x045c 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045c, if 0x85352058 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x85352058 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x8da5cb5b 0104 14 EQ 0105 61 PUSH2 0x047c 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047c, if 0x8da5cb5b == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x8da5cb5b == stack[-1] 0109 61 PUSH2 0x01f9 010C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_010D: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x2f745c59 0114 11 GT 0115 61 PUSH2 0x0190 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x2f745c59 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x4f6ccce7 011F 11 GT 0120 61 PUSH2 0x015f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x4f6ccce7 > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x4f6ccce7 012A 14 EQ 012B 61 PUSH2 0x039c 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039c, if 0x4f6ccce7 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x55f804b3 0135 14 EQ 0136 61 PUSH2 0x03bc 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bc, if 0x55f804b3 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x55f804b3 == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x603f4d52 0140 14 EQ 0141 61 PUSH2 0x03dc 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03dc, if 0x603f4d52 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x603f4d52 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6352211e 014B 14 EQ 014C 61 PUSH2 0x03f2 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f2, if 0x6352211e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6352211e == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x6c0360eb 0156 14 EQ 0157 61 PUSH2 0x0412 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0412, if 0x6c0360eb == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x6c0360eb == stack[-1] 015B 61 PUSH2 0x01f9 015E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_015F: // Incoming jump from 0x0123, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @0160 stack[-1] } 015F 5B JUMPDEST 0160 80 DUP1 0161 63 PUSH4 0x2f745c59 0166 14 EQ 0167 61 PUSH2 0x0334 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0334, if 0x2f745c59 == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x2f745c59 == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x3ccfd60b 0171 14 EQ 0172 61 PUSH2 0x0354 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0354, if 0x3ccfd60b == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x41339da9 017C 14 EQ 017D 61 PUSH2 0x0369 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0369, if 0x41339da9 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x41339da9 == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x42842e0e 0187 14 EQ 0188 61 PUSH2 0x037c 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037c, if 0x42842e0e == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x42842e0e == stack[-1] 018C 61 PUSH2 0x01f9 018F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_0190: // Incoming jump from 0x0118, if 0x2f745c59 > stack[-1] // Inputs[1] { @0191 stack[-1] } 0190 5B JUMPDEST 0191 80 DUP1 0192 63 PUSH4 0x095ea7b3 0197 11 GT 0198 61 PUSH2 0x01cc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if 0x095ea7b3 > stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x095ea7b3 01A2 14 EQ 01A3 61 PUSH2 0x02a5 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a5, if 0x095ea7b3 == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x12fb92e0 01AD 14 EQ 01AE 61 PUSH2 0x02c5 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x12fb92e0 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x12fb92e0 == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x18160ddd 01B8 14 EQ 01B9 61 PUSH2 0x02ff 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ff, if 0x18160ddd == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x18160ddd == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x23b872dd 01C3 14 EQ 01C4 61 PUSH2 0x0314 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0314, if 0x23b872dd == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x23b872dd == stack[-1] 01C8 61 PUSH2 0x01f9 01CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f9 label_01CC: // Incoming jump from 0x019B, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01CD stack[-1] } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 63 PUSH4 0x01ffc9a7 01D3 14 EQ 01D4 61 PUSH2 0x01fe 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fe, if 0x01ffc9a7 == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x06fdde03 01DE 14 EQ 01DF 61 PUSH2 0x0234 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0234, if 0x06fdde03 == stack[-1] label_01E3: // Incoming jump from 0x01E2, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01E3 stack[-1] } 01E3 80 DUP1 01E4 63 PUSH4 0x081812fc 01E9 14 EQ 01EA 61 PUSH2 0x0256 01ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0256, if 0x081812fc == stack[-1] label_01EE: // Incoming jump from 0x01ED, if not 0x081812fc == stack[-1] // Inputs[1] { @01EE stack[-1] } 01EE 80 DUP1 01EF 63 PUSH4 0x084c4088 01F4 14 EQ 01F5 61 PUSH2 0x0283 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0283, if 0x084c4088 == stack[-1] label_01F9: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x010C // Incoming jump from 0x006E // Incoming jump from 0x018F // Incoming jump from 0x015E // Incoming jump from 0x01F8, if not 0x084c4088 == stack[-1] // Incoming jump from 0x00DB // Incoming jump from 0x01CB // Incoming jump from 0x009F // Inputs[1] { @01FD memory[0x00:0x00] } 01F9 5B JUMPDEST 01FA 60 PUSH1 0x00 01FC 80 DUP1 01FD FD *REVERT // Stack delta = +0 // Outputs[1] { @01FD revert(memory[0x00:0x00]); } // Block terminates label_01FE: // Incoming jump from 0x01D7, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01FF msg.value } 01FE 5B JUMPDEST 01FF 34 CALLVALUE 0200 80 DUP1 0201 15 ISZERO 0202 61 PUSH2 0x020a 0205 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01FF stack[0] = msg.value } // Block ends with conditional jump to 0x020a, if !msg.value label_0206: // Incoming jump from 0x0205, if not !msg.value // Inputs[1] { @0209 memory[0x00:0x00] } 0206 60 PUSH1 0x00 0208 80 DUP1 0209 FD *REVERT // Stack delta = +0 // Outputs[1] { @0209 revert(memory[0x00:0x00]); } // Block terminates label_020A: // Incoming jump from 0x0205, if !msg.value // Inputs[1] { @0212 msg.data.length } 020A 5B JUMPDEST 020B 50 POP 020C 61 PUSH2 0x021e 020F 61 PUSH2 0x0219 0212 36 CALLDATASIZE 0213 60 PUSH1 0x04 0215 61 PUSH2 0x1d3d 0218 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @020C stack[-1] = 0x021e // @020F stack[0] = 0x0219 // @0212 stack[1] = msg.data.length // @0213 stack[2] = 0x04 // } // Block ends with call to 0x1d3d, returns to 0x0219 label_0219: // Incoming return from call to 0x1D3D at 0x0218 0219 5B JUMPDEST 021A 61 PUSH2 0x0657 021D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0657 021E 5B JUMPDEST 021F 60 PUSH1 0x40 0221 51 MLOAD 0222 61 PUSH2 0x022b 0225 91 SWAP2 0226 90 SWAP1 0227 61 PUSH2 0x24da 022A 56 *JUMP label_022B: // Incoming return from call to 0x2669 at 0x02FE // Incoming return from call to 0x24E8 at 0x0255 // Inputs[3] // { // @022E memory[0x40:0x60] // @0230 stack[-1] // @0233 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 022B 5B JUMPDEST 022C 60 PUSH1 0x40 022E 51 MLOAD 022F 80 DUP1 0230 91 SWAP2 0231 03 SUB 0232 90 SWAP1 0233 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0233 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0234: // Incoming jump from 0x01E2, if 0x06fdde03 == stack[-1] // Inputs[1] { @0235 msg.value } 0234 5B JUMPDEST 0235 34 CALLVALUE 0236 80 DUP1 0237 15 ISZERO 0238 61 PUSH2 0x0240 023B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0235 stack[0] = msg.value } // Block ends with conditional jump to 0x0240, if !msg.value label_023C: // Incoming jump from 0x023B, if not !msg.value // Inputs[1] { @023F memory[0x00:0x00] } 023C 60 PUSH1 0x00 023E 80 DUP1 023F FD *REVERT // Stack delta = +0 // Outputs[1] { @023F revert(memory[0x00:0x00]); } // Block terminates label_0240: // Incoming jump from 0x023B, if !msg.value 0240 5B JUMPDEST 0241 50 POP 0242 61 PUSH2 0x0249 0245 61 PUSH2 0x066a 0248 56 *JUMP // Stack delta = +0 // Outputs[1] { @0242 stack[-1] = 0x0249 } // Block ends with call to 0x066a, returns to 0x0249 label_0249: // Incoming return from call to 0x0B25 at 0x0426 // Incoming return from call to 0x0CC7 at 0x04CE // Incoming return from call to 0x066A at 0x0248 // Inputs[2] // { // @024C memory[0x40:0x60] // @0250 stack[-1] // } 0249 5B JUMPDEST 024A 60 PUSH1 0x40 024C 51 MLOAD 024D 61 PUSH2 0x022b 0250 91 SWAP2 0251 90 SWAP1 0252 61 PUSH2 0x24e8 0255 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0250 stack[-1] = 0x022b // @0251 stack[1] = memory[0x40:0x60] // @0251 stack[0] = stack[-1] // } // Block ends with call to 0x24e8, returns to 0x022B label_0256: // Incoming jump from 0x01ED, if 0x081812fc == stack[-1] // Inputs[1] { @0257 msg.value } 0256 5B JUMPDEST 0257 34 CALLVALUE 0258 80 DUP1 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0257 stack[0] = msg.value } // Block ends with conditional jump to 0x0262, if !msg.value label_025E: // Incoming jump from 0x025D, if not !msg.value // Inputs[1] { @0261 memory[0x00:0x00] } 025E 60 PUSH1 0x00 0260 80 DUP1 0261 FD *REVERT // Stack delta = +0 // Outputs[1] { @0261 revert(memory[0x00:0x00]); } // Block terminates label_0262: // Incoming jump from 0x025D, if !msg.value // Inputs[1] { @026A msg.data.length } 0262 5B JUMPDEST 0263 50 POP 0264 61 PUSH2 0x0276 0267 61 PUSH2 0x0271 026A 36 CALLDATASIZE 026B 60 PUSH1 0x04 026D 61 PUSH2 0x1dae 0270 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0264 stack[-1] = 0x0276 // @0267 stack[0] = 0x0271 // @026A stack[1] = msg.data.length // @026B stack[2] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x0271 label_0271: // Incoming return from call to 0x1DAE at 0x0270 0271 5B JUMPDEST 0272 61 PUSH2 0x06fc 0275 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06fc label_0276: // Incoming jump from 0x04B9 // Incoming return from call to 0x040D at 0x040C // Incoming jump from 0x0499 // Incoming jump from 0x0616 // Incoming return from call to 0x0271 at 0x0270 // Inputs[2] // { // @0279 memory[0x40:0x60] // @027D stack[-1] // } 0276 5B JUMPDEST 0277 60 PUSH1 0x40 0279 51 MLOAD 027A 61 PUSH2 0x022b 027D 91 SWAP2 027E 90 SWAP1 027F 61 PUSH2 0x2488 0282 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @027D stack[-1] = 0x022b // @027E stack[1] = memory[0x40:0x60] // @027E stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2488 label_0283: // Incoming jump from 0x01F8, if 0x084c4088 == stack[-1] // Inputs[1] { @0284 msg.value } 0283 5B JUMPDEST 0284 34 CALLVALUE 0285 80 DUP1 0286 15 ISZERO 0287 61 PUSH2 0x028f 028A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0284 stack[0] = msg.value } // Block ends with conditional jump to 0x028f, if !msg.value label_028B: // Incoming jump from 0x028A, if not !msg.value // Inputs[1] { @028E memory[0x00:0x00] } 028B 60 PUSH1 0x00 028D 80 DUP1 028E FD *REVERT // Stack delta = +0 // Outputs[1] { @028E revert(memory[0x00:0x00]); } // Block terminates label_028F: // Incoming jump from 0x028A, if !msg.value // Inputs[1] { @0297 msg.data.length } 028F 5B JUMPDEST 0290 50 POP 0291 61 PUSH2 0x02a3 0294 61 PUSH2 0x029e 0297 36 CALLDATASIZE 0298 60 PUSH1 0x04 029A 61 PUSH2 0x1dae 029D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0291 stack[-1] = 0x02a3 // @0294 stack[0] = 0x029e // @0297 stack[1] = msg.data.length // @0298 stack[2] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x029E label_029E: // Incoming return from call to 0x1DAE at 0x029D 029E 5B JUMPDEST 029F 61 PUSH2 0x0755 02A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0755 label_02A3: // Incoming return from call to 0x029E at 0x029D // Incoming return from call to 0x0BF7 at 0x045B // Incoming return from call to 0x0477 at 0x0476 // Incoming return from call to 0x0890 at 0x0368 02A3 5B JUMPDEST 02A4 00 *STOP // Stack delta = +0 // Outputs[1] { @02A4 stop(); } // Block terminates label_02A5: // Incoming jump from 0x01A6, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02A6 msg.value } 02A5 5B JUMPDEST 02A6 34 CALLVALUE 02A7 80 DUP1 02A8 15 ISZERO 02A9 61 PUSH2 0x02b1 02AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A6 stack[0] = msg.value } // Block ends with conditional jump to 0x02b1, if !msg.value label_02AD: // Incoming jump from 0x02AC, if not !msg.value // Inputs[1] { @02B0 memory[0x00:0x00] } 02AD 60 PUSH1 0x00 02AF 80 DUP1 02B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B0 revert(memory[0x00:0x00]); } // Block terminates label_02B1: // Incoming jump from 0x02AC, if !msg.value // Inputs[1] { @02B9 msg.data.length } 02B1 5B JUMPDEST 02B2 50 POP 02B3 61 PUSH2 0x02a3 02B6 61 PUSH2 0x02c0 02B9 36 CALLDATASIZE 02BA 60 PUSH1 0x04 02BC 61 PUSH2 0x1cb9 02BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B3 stack[-1] = 0x02a3 // @02B6 stack[0] = 0x02c0 // @02B9 stack[1] = msg.data.length // @02BA stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cb9 02C0 5B JUMPDEST 02C1 61 PUSH2 0x0784 02C4 56 *JUMP label_02C5: // Incoming jump from 0x01B1, if 0x12fb92e0 == stack[-1] // Inputs[1] { @02C6 msg.value } 02C5 5B JUMPDEST 02C6 34 CALLVALUE 02C7 80 DUP1 02C8 15 ISZERO 02C9 61 PUSH2 0x02d1 02CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C6 stack[0] = msg.value } // Block ends with conditional jump to 0x02d1, if !msg.value label_02CD: // Incoming jump from 0x02CC, if not !msg.value // Inputs[1] { @02D0 memory[0x00:0x00] } 02CD 60 PUSH1 0x00 02CF 80 DUP1 02D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D0 revert(memory[0x00:0x00]); } // Block terminates label_02D1: // Incoming jump from 0x02CC, if !msg.value // Inputs[1] { @02D9 msg.data.length } 02D1 5B JUMPDEST 02D2 50 POP 02D3 61 PUSH2 0x02f2 02D6 61 PUSH2 0x02e0 02D9 36 CALLDATASIZE 02DA 60 PUSH1 0x04 02DC 61 PUSH2 0x1b6b 02DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D3 stack[-1] = 0x02f2 // @02D6 stack[0] = 0x02e0 // @02D9 stack[1] = msg.data.length // @02DA stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b6b 02E0 5B JUMPDEST 02E1 60 PUSH1 0x10 02E3 60 PUSH1 0x20 02E5 52 MSTORE 02E6 60 PUSH1 0x00 02E8 90 SWAP1 02E9 81 DUP2 02EA 52 MSTORE 02EB 60 PUSH1 0x40 02ED 90 SWAP1 02EE 20 SHA3 02EF 54 SLOAD 02F0 81 DUP2 02F1 56 *JUMP label_02F2: // Incoming jump from 0x03F1 // Incoming jump from 0x0313 // Incoming return from call to 0x03B7 at 0x03B6 // Incoming jump from 0x04E4 // Inputs[2] // { // @02F5 memory[0x40:0x60] // @02F9 stack[-1] // } 02F2 5B JUMPDEST 02F3 60 PUSH1 0x40 02F5 51 MLOAD 02F6 61 PUSH2 0x022b 02F9 91 SWAP2 02FA 90 SWAP1 02FB 61 PUSH2 0x2669 02FE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02F9 stack[-1] = 0x022b // @02FA stack[1] = memory[0x40:0x60] // @02FA stack[0] = stack[-1] // } // Block ends with call to 0x2669, returns to 0x022B label_02FF: // Incoming jump from 0x01BC, if 0x18160ddd == stack[-1] // Inputs[1] { @0300 msg.value } 02FF 5B JUMPDEST 0300 34 CALLVALUE 0301 80 DUP1 0302 15 ISZERO 0303 61 PUSH2 0x030b 0306 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0300 stack[0] = msg.value } // Block ends with conditional jump to 0x030b, if !msg.value label_0307: // Incoming jump from 0x0306, if not !msg.value // Inputs[1] { @030A memory[0x00:0x00] } 0307 60 PUSH1 0x00 0309 80 DUP1 030A FD *REVERT // Stack delta = +0 // Outputs[1] { @030A revert(memory[0x00:0x00]); } // Block terminates label_030B: // Incoming jump from 0x0306, if !msg.value // Inputs[1] { @030F storage[0x08] } 030B 5B JUMPDEST 030C 50 POP 030D 60 PUSH1 0x08 030F 54 SLOAD 0310 61 PUSH2 0x02f2 0313 56 *JUMP // Stack delta = +0 // Outputs[1] { @030F stack[-1] = storage[0x08] } // Block ends with unconditional jump to 0x02f2 label_0314: // Incoming jump from 0x01C7, if 0x23b872dd == stack[-1] // Inputs[1] { @0315 msg.value } 0314 5B JUMPDEST 0315 34 CALLVALUE 0316 80 DUP1 0317 15 ISZERO 0318 61 PUSH2 0x0320 031B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0315 stack[0] = msg.value } // Block ends with conditional jump to 0x0320, if !msg.value label_031C: // Incoming jump from 0x031B, if not !msg.value // Inputs[1] { @031F memory[0x00:0x00] } 031C 60 PUSH1 0x00 031E 80 DUP1 031F FD *REVERT // Stack delta = +0 // Outputs[1] { @031F revert(memory[0x00:0x00]); } // Block terminates label_0320: // Incoming jump from 0x031B, if !msg.value // Inputs[1] { @0328 msg.data.length } 0320 5B JUMPDEST 0321 50 POP 0322 61 PUSH2 0x02a3 0325 61 PUSH2 0x032f 0328 36 CALLDATASIZE 0329 60 PUSH1 0x04 032B 61 PUSH2 0x1bc3 032E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0322 stack[-1] = 0x02a3 // @0325 stack[0] = 0x032f // @0328 stack[1] = msg.data.length // @0329 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1bc3 032F 5B JUMPDEST 0330 61 PUSH2 0x080a 0333 56 *JUMP label_0334: // Incoming jump from 0x016A, if 0x2f745c59 == stack[-1] // Inputs[1] { @0335 msg.value } 0334 5B JUMPDEST 0335 34 CALLVALUE 0336 80 DUP1 0337 15 ISZERO 0338 61 PUSH2 0x0340 033B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0335 stack[0] = msg.value } // Block ends with conditional jump to 0x0340, if !msg.value label_033C: // Incoming jump from 0x033B, if not !msg.value // Inputs[1] { @033F memory[0x00:0x00] } 033C 60 PUSH1 0x00 033E 80 DUP1 033F FD *REVERT // Stack delta = +0 // Outputs[1] { @033F revert(memory[0x00:0x00]); } // Block terminates label_0340: // Incoming jump from 0x033B, if !msg.value // Inputs[1] { @0348 msg.data.length } 0340 5B JUMPDEST 0341 50 POP 0342 61 PUSH2 0x02f2 0345 61 PUSH2 0x034f 0348 36 CALLDATASIZE 0349 60 PUSH1 0x04 034B 61 PUSH2 0x1cb9 034E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0342 stack[-1] = 0x02f2 // @0345 stack[0] = 0x034f // @0348 stack[1] = msg.data.length // @0349 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cb9 034F 5B JUMPDEST 0350 61 PUSH2 0x083b 0353 56 *JUMP label_0354: // Incoming jump from 0x0175, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0355 msg.value } 0354 5B JUMPDEST 0355 34 CALLVALUE 0356 80 DUP1 0357 15 ISZERO 0358 61 PUSH2 0x0360 035B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0355 stack[0] = msg.value } // Block ends with conditional jump to 0x0360, if !msg.value label_035C: // Incoming jump from 0x035B, if not !msg.value // Inputs[1] { @035F memory[0x00:0x00] } 035C 60 PUSH1 0x00 035E 80 DUP1 035F FD *REVERT // Stack delta = +0 // Outputs[1] { @035F revert(memory[0x00:0x00]); } // Block terminates label_0360: // Incoming jump from 0x035B, if !msg.value 0360 5B JUMPDEST 0361 50 POP 0362 61 PUSH2 0x02a3 0365 61 PUSH2 0x0890 0368 56 *JUMP // Stack delta = +0 // Outputs[1] { @0362 stack[-1] = 0x02a3 } // Block ends with call to 0x0890, returns to 0x02A3 label_0369: // Incoming jump from 0x0180, if 0x41339da9 == stack[-1] // Inputs[1] { @0370 msg.data.length } 0369 5B JUMPDEST 036A 61 PUSH2 0x02a3 036D 61 PUSH2 0x0377 0370 36 CALLDATASIZE 0371 60 PUSH1 0x04 0373 61 PUSH2 0x1dae 0376 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036A stack[0] = 0x02a3 // @036D stack[1] = 0x0377 // @0370 stack[2] = msg.data.length // @0371 stack[3] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x0377 label_0377: // Incoming return from call to 0x1DAE at 0x0376 0377 5B JUMPDEST 0378 61 PUSH2 0x094a 037B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x094a label_037C: // Incoming jump from 0x018B, if 0x42842e0e == stack[-1] // Inputs[1] { @037D msg.value } 037C 5B JUMPDEST 037D 34 CALLVALUE 037E 80 DUP1 037F 15 ISZERO 0380 61 PUSH2 0x0388 0383 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037D stack[0] = msg.value } // Block ends with conditional jump to 0x0388, if !msg.value label_0384: // Incoming jump from 0x0383, if not !msg.value // Inputs[1] { @0387 memory[0x00:0x00] } 0384 60 PUSH1 0x00 0386 80 DUP1 0387 FD *REVERT // Stack delta = +0 // Outputs[1] { @0387 revert(memory[0x00:0x00]); } // Block terminates label_0388: // Incoming jump from 0x0383, if !msg.value // Inputs[1] { @0390 msg.data.length } 0388 5B JUMPDEST 0389 50 POP 038A 61 PUSH2 0x02a3 038D 61 PUSH2 0x0397 0390 36 CALLDATASIZE 0391 60 PUSH1 0x04 0393 61 PUSH2 0x1bc3 0396 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @038A stack[-1] = 0x02a3 // @038D stack[0] = 0x0397 // @0390 stack[1] = msg.data.length // @0391 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1bc3 0397 5B JUMPDEST 0398 61 PUSH2 0x0a3c 039B 56 *JUMP label_039C: // Incoming jump from 0x012E, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @039D msg.value } 039C 5B JUMPDEST 039D 34 CALLVALUE 039E 80 DUP1 039F 15 ISZERO 03A0 61 PUSH2 0x03a8 03A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039D stack[0] = msg.value } // Block ends with conditional jump to 0x03a8, if !msg.value label_03A4: // Incoming jump from 0x03A3, if not !msg.value // Inputs[1] { @03A7 memory[0x00:0x00] } 03A4 60 PUSH1 0x00 03A6 80 DUP1 03A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A7 revert(memory[0x00:0x00]); } // Block terminates label_03A8: // Incoming jump from 0x03A3, if !msg.value // Inputs[1] { @03B0 msg.data.length } 03A8 5B JUMPDEST 03A9 50 POP 03AA 61 PUSH2 0x02f2 03AD 61 PUSH2 0x03b7 03B0 36 CALLDATASIZE 03B1 60 PUSH1 0x04 03B3 61 PUSH2 0x1dae 03B6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03AA stack[-1] = 0x02f2 // @03AD stack[0] = 0x03b7 // @03B0 stack[1] = msg.data.length // @03B1 stack[2] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x03B7 label_03B7: // Incoming return from call to 0x1DAE at 0x03B6 03B7 5B JUMPDEST 03B8 61 PUSH2 0x0a57 03BB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a57 label_03BC: // Incoming jump from 0x0139, if 0x55f804b3 == stack[-1] // Inputs[1] { @03BD msg.value } 03BC 5B JUMPDEST 03BD 34 CALLVALUE 03BE 80 DUP1 03BF 15 ISZERO 03C0 61 PUSH2 0x03c8 03C3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03BD stack[0] = msg.value } // Block ends with conditional jump to 0x03c8, if !msg.value label_03C4: // Incoming jump from 0x03C3, if not !msg.value // Inputs[1] { @03C7 memory[0x00:0x00] } 03C4 60 PUSH1 0x00 03C6 80 DUP1 03C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C7 revert(memory[0x00:0x00]); } // Block terminates label_03C8: // Incoming jump from 0x03C3, if !msg.value // Inputs[1] { @03D0 msg.data.length } 03C8 5B JUMPDEST 03C9 50 POP 03CA 61 PUSH2 0x02a3 03CD 61 PUSH2 0x03d7 03D0 36 CALLDATASIZE 03D1 60 PUSH1 0x04 03D3 61 PUSH2 0x1d79 03D6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03CA stack[-1] = 0x02a3 // @03CD stack[0] = 0x03d7 // @03D0 stack[1] = msg.data.length // @03D1 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1d79 03D7 5B JUMPDEST 03D8 61 PUSH2 0x0ab3 03DB 56 *JUMP label_03DC: // Incoming jump from 0x0144, if 0x603f4d52 == stack[-1] // Inputs[1] { @03DD msg.value } 03DC 5B JUMPDEST 03DD 34 CALLVALUE 03DE 80 DUP1 03DF 15 ISZERO 03E0 61 PUSH2 0x03e8 03E3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03DD stack[0] = msg.value } // Block ends with conditional jump to 0x03e8, if !msg.value label_03E4: // Incoming jump from 0x03E3, if not !msg.value // Inputs[1] { @03E7 memory[0x00:0x00] } 03E4 60 PUSH1 0x00 03E6 80 DUP1 03E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E7 revert(memory[0x00:0x00]); } // Block terminates label_03E8: // Incoming jump from 0x03E3, if !msg.value // Inputs[1] { @03EF storage[0x0d] } 03E8 5B JUMPDEST 03E9 50 POP 03EA 61 PUSH2 0x02f2 03ED 60 PUSH1 0x0d 03EF 54 SLOAD 03F0 81 DUP2 03F1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03EA stack[-1] = 0x02f2 // @03EF stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x02f2 label_03F2: // Incoming jump from 0x014F, if 0x6352211e == stack[-1] // Inputs[1] { @03F3 msg.value } 03F2 5B JUMPDEST 03F3 34 CALLVALUE 03F4 80 DUP1 03F5 15 ISZERO 03F6 61 PUSH2 0x03fe 03F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F3 stack[0] = msg.value } // Block ends with conditional jump to 0x03fe, if !msg.value label_03FA: // Incoming jump from 0x03F9, if not !msg.value // Inputs[1] { @03FD memory[0x00:0x00] } 03FA 60 PUSH1 0x00 03FC 80 DUP1 03FD FD *REVERT // Stack delta = +0 // Outputs[1] { @03FD revert(memory[0x00:0x00]); } // Block terminates label_03FE: // Incoming jump from 0x03F9, if !msg.value // Inputs[1] { @0406 msg.data.length } 03FE 5B JUMPDEST 03FF 50 POP 0400 61 PUSH2 0x0276 0403 61 PUSH2 0x040d 0406 36 CALLDATASIZE 0407 60 PUSH1 0x04 0409 61 PUSH2 0x1dae 040C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0400 stack[-1] = 0x0276 // @0403 stack[0] = 0x040d // @0406 stack[1] = msg.data.length // @0407 stack[2] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x040D label_040D: // Incoming return from call to 0x1DAE at 0x040C 040D 5B JUMPDEST 040E 61 PUSH2 0x0af0 0411 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0af0 label_0412: // Incoming jump from 0x015A, if 0x6c0360eb == stack[-1] // Inputs[1] { @0413 msg.value } 0412 5B JUMPDEST 0413 34 CALLVALUE 0414 80 DUP1 0415 15 ISZERO 0416 61 PUSH2 0x041e 0419 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0413 stack[0] = msg.value } // Block ends with conditional jump to 0x041e, if !msg.value label_041A: // Incoming jump from 0x0419, if not !msg.value // Inputs[1] { @041D memory[0x00:0x00] } 041A 60 PUSH1 0x00 041C 80 DUP1 041D FD *REVERT // Stack delta = +0 // Outputs[1] { @041D revert(memory[0x00:0x00]); } // Block terminates label_041E: // Incoming jump from 0x0419, if !msg.value 041E 5B JUMPDEST 041F 50 POP 0420 61 PUSH2 0x0249 0423 61 PUSH2 0x0b25 0426 56 *JUMP // Stack delta = +0 // Outputs[1] { @0420 stack[-1] = 0x0249 } // Block ends with call to 0x0b25, returns to 0x0249 label_0427: // Incoming jump from 0x00E7, if 0x70a08231 == stack[-1] // Inputs[1] { @0428 msg.value } 0427 5B JUMPDEST 0428 34 CALLVALUE 0429 80 DUP1 042A 15 ISZERO 042B 61 PUSH2 0x0433 042E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0428 stack[0] = msg.value } // Block ends with conditional jump to 0x0433, if !msg.value label_042F: // Incoming jump from 0x042E, if not !msg.value // Inputs[1] { @0432 memory[0x00:0x00] } 042F 60 PUSH1 0x00 0431 80 DUP1 0432 FD *REVERT // Stack delta = +0 // Outputs[1] { @0432 revert(memory[0x00:0x00]); } // Block terminates label_0433: // Incoming jump from 0x042E, if !msg.value // Inputs[1] { @043B msg.data.length } 0433 5B JUMPDEST 0434 50 POP 0435 61 PUSH2 0x02f2 0438 61 PUSH2 0x0442 043B 36 CALLDATASIZE 043C 60 PUSH1 0x04 043E 61 PUSH2 0x1b6b 0441 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0435 stack[-1] = 0x02f2 // @0438 stack[0] = 0x0442 // @043B stack[1] = msg.data.length // @043C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b6b 0442 5B JUMPDEST 0443 61 PUSH2 0x0bb3 0446 56 *JUMP label_0447: // Incoming jump from 0x00F2, if 0x715018a6 == stack[-1] // Inputs[1] { @0448 msg.value } 0447 5B JUMPDEST 0448 34 CALLVALUE 0449 80 DUP1 044A 15 ISZERO 044B 61 PUSH2 0x0453 044E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0448 stack[0] = msg.value } // Block ends with conditional jump to 0x0453, if !msg.value label_044F: // Incoming jump from 0x044E, if not !msg.value // Inputs[1] { @0452 memory[0x00:0x00] } 044F 60 PUSH1 0x00 0451 80 DUP1 0452 FD *REVERT // Stack delta = +0 // Outputs[1] { @0452 revert(memory[0x00:0x00]); } // Block terminates label_0453: // Incoming jump from 0x044E, if !msg.value 0453 5B JUMPDEST 0454 50 POP 0455 61 PUSH2 0x02a3 0458 61 PUSH2 0x0bf7 045B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0455 stack[-1] = 0x02a3 } // Block ends with call to 0x0bf7, returns to 0x02A3 label_045C: // Incoming jump from 0x00FD, if 0x85352058 == stack[-1] // Inputs[1] { @045D msg.value } 045C 5B JUMPDEST 045D 34 CALLVALUE 045E 80 DUP1 045F 15 ISZERO 0460 61 PUSH2 0x0468 0463 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045D stack[0] = msg.value } // Block ends with conditional jump to 0x0468, if !msg.value label_0464: // Incoming jump from 0x0463, if not !msg.value // Inputs[1] { @0467 memory[0x00:0x00] } 0464 60 PUSH1 0x00 0466 80 DUP1 0467 FD *REVERT // Stack delta = +0 // Outputs[1] { @0467 revert(memory[0x00:0x00]); } // Block terminates label_0468: // Incoming jump from 0x0463, if !msg.value // Inputs[1] { @0470 msg.data.length } 0468 5B JUMPDEST 0469 50 POP 046A 61 PUSH2 0x02a3 046D 61 PUSH2 0x0477 0470 36 CALLDATASIZE 0471 60 PUSH1 0x04 0473 61 PUSH2 0x1d07 0476 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @046A stack[-1] = 0x02a3 // @046D stack[0] = 0x0477 // @0470 stack[1] = msg.data.length // @0471 stack[2] = 0x04 // } // Block ends with call to 0x1d07, returns to 0x0477 label_0477: // Incoming return from call to 0x1D07 at 0x0476 0477 5B JUMPDEST 0478 61 PUSH2 0x0c2d 047B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c2d label_047C: // Incoming jump from 0x0108, if 0x8da5cb5b == stack[-1] // Inputs[1] { @047D msg.value } 047C 5B JUMPDEST 047D 34 CALLVALUE 047E 80 DUP1 047F 15 ISZERO 0480 61 PUSH2 0x0488 0483 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047D stack[0] = msg.value } // Block ends with conditional jump to 0x0488, if !msg.value label_0484: // Incoming jump from 0x0483, if not !msg.value // Inputs[1] { @0487 memory[0x00:0x00] } 0484 60 PUSH1 0x00 0486 80 DUP1 0487 FD *REVERT // Stack delta = +0 // Outputs[1] { @0487 revert(memory[0x00:0x00]); } // Block terminates label_0488: // Incoming jump from 0x0483, if !msg.value // Inputs[1] { @048C storage[0x0a] } 0488 5B JUMPDEST 0489 50 POP 048A 60 PUSH1 0x0a 048C 54 SLOAD 048D 60 PUSH1 0x01 048F 60 PUSH1 0x01 0491 60 PUSH1 0xa0 0493 1B SHL 0494 03 SUB 0495 16 AND 0496 61 PUSH2 0x0276 0499 56 *JUMP // Stack delta = +0 // Outputs[1] { @0495 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0a] } // Block ends with unconditional jump to 0x0276 label_049A: // Incoming jump from 0x00B6, if 0x8de38f98 == stack[-1] // Inputs[1] { @049B msg.value } 049A 5B JUMPDEST 049B 34 CALLVALUE 049C 80 DUP1 049D 15 ISZERO 049E 61 PUSH2 0x04a6 04A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049B stack[0] = msg.value } // Block ends with conditional jump to 0x04a6, if !msg.value label_04A2: // Incoming jump from 0x04A1, if not !msg.value // Inputs[1] { @04A5 memory[0x00:0x00] } 04A2 60 PUSH1 0x00 04A4 80 DUP1 04A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A5 revert(memory[0x00:0x00]); } // Block terminates label_04A6: // Incoming jump from 0x04A1, if !msg.value // Inputs[1] { @04AA storage[0x0f] } 04A6 5B JUMPDEST 04A7 50 POP 04A8 60 PUSH1 0x0f 04AA 54 SLOAD 04AB 61 PUSH2 0x0276 04AE 90 SWAP1 04AF 60 PUSH1 0x01 04B1 60 PUSH1 0x01 04B3 60 PUSH1 0xa0 04B5 1B SHL 04B6 03 SUB 04B7 16 AND 04B8 81 DUP2 04B9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04AE stack[-1] = 0x0276 // @04B7 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // } // Block ends with unconditional jump to 0x0276 label_04BA: // Incoming jump from 0x00C1, if 0x95d89b41 == stack[-1] // Inputs[1] { @04BB msg.value } 04BA 5B JUMPDEST 04BB 34 CALLVALUE 04BC 80 DUP1 04BD 15 ISZERO 04BE 61 PUSH2 0x04c6 04C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04BB stack[0] = msg.value } // Block ends with conditional jump to 0x04c6, if !msg.value label_04C2: // Incoming jump from 0x04C1, if not !msg.value // Inputs[1] { @04C5 memory[0x00:0x00] } 04C2 60 PUSH1 0x00 04C4 80 DUP1 04C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C5 revert(memory[0x00:0x00]); } // Block terminates label_04C6: // Incoming jump from 0x04C1, if !msg.value 04C6 5B JUMPDEST 04C7 50 POP 04C8 61 PUSH2 0x0249 04CB 61 PUSH2 0x0cc7 04CE 56 *JUMP // Stack delta = +0 // Outputs[1] { @04C8 stack[-1] = 0x0249 } // Block ends with call to 0x0cc7, returns to 0x0249 label_04CF: // Incoming jump from 0x00CC, if 0xa035b1fe == stack[-1] // Inputs[1] { @04D0 msg.value } 04CF 5B JUMPDEST 04D0 34 CALLVALUE 04D1 80 DUP1 04D2 15 ISZERO 04D3 61 PUSH2 0x04db 04D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D0 stack[0] = msg.value } // Block ends with conditional jump to 0x04db, if !msg.value label_04D7: // Incoming jump from 0x04D6, if not !msg.value // Inputs[1] { @04DA memory[0x00:0x00] } 04D7 60 PUSH1 0x00 04D9 80 DUP1 04DA FD *REVERT // Stack delta = +0 // Outputs[1] { @04DA revert(memory[0x00:0x00]); } // Block terminates label_04DB: // Incoming jump from 0x04D6, if !msg.value // Inputs[1] { @04E2 storage[0x0c] } 04DB 5B JUMPDEST 04DC 50 POP 04DD 61 PUSH2 0x02f2 04E0 60 PUSH1 0x0c 04E2 54 SLOAD 04E3 81 DUP2 04E4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04DD stack[-1] = 0x02f2 // @04E2 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x02f2 label_04E5: // Incoming jump from 0x00D7, if 0xa22cb465 == stack[-1] // Inputs[1] { @04E6 msg.value } 04E5 5B JUMPDEST 04E6 34 CALLVALUE 04E7 80 DUP1 04E8 15 ISZERO 04E9 61 PUSH2 0x04f1 04EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E6 stack[0] = msg.value } // Block ends with conditional jump to 0x04f1, if !msg.value label_04ED: // Incoming jump from 0x04EC, if not !msg.value // Inputs[1] { @04F0 memory[0x00:0x00] } 04ED 60 PUSH1 0x00 04EF 80 DUP1 04F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F0 revert(memory[0x00:0x00]); } // Block terminates label_04F1: // Incoming jump from 0x04EC, if !msg.value // Inputs[1] { @04F9 msg.data.length } 04F1 5B JUMPDEST 04F2 50 POP 04F3 61 PUSH2 0x02a3 04F6 61 PUSH2 0x0500 04F9 36 CALLDATASIZE 04FA 60 PUSH1 0x04 04FC 61 PUSH2 0x1c89 04FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F3 stack[-1] = 0x02a3 // @04F6 stack[0] = 0x0500 // @04F9 stack[1] = msg.data.length // @04FA stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c89 0500 5B JUMPDEST 0501 61 PUSH2 0x0cd6 0504 56 *JUMP label_0505: // Incoming jump from 0x007A, if 0xad6d9a44 == stack[-1] // Inputs[1] { @0506 msg.value } 0505 5B JUMPDEST 0506 34 CALLVALUE 0507 80 DUP1 0508 15 ISZERO 0509 61 PUSH2 0x0511 050C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0506 stack[0] = msg.value } // Block ends with conditional jump to 0x0511, if !msg.value label_050D: // Incoming jump from 0x050C, if not !msg.value // Inputs[1] { @0510 memory[0x00:0x00] } 050D 60 PUSH1 0x00 050F 80 DUP1 0510 FD *REVERT // Stack delta = +0 // Outputs[1] { @0510 revert(memory[0x00:0x00]); } // Block terminates label_0511: // Incoming jump from 0x050C, if !msg.value // Inputs[1] { @0519 msg.data.length } 0511 5B JUMPDEST 0512 50 POP 0513 61 PUSH2 0x02f2 0516 61 PUSH2 0x0520 0519 36 CALLDATASIZE 051A 60 PUSH1 0x04 051C 61 PUSH2 0x1b6b 051F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0513 stack[-1] = 0x02f2 // @0516 stack[0] = 0x0520 // @0519 stack[1] = msg.data.length // @051A stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b6b 0520 5B JUMPDEST 0521 60 PUSH1 0x01 0523 60 PUSH1 0x01 0525 60 PUSH1 0xa0 0527 1B SHL 0528 03 SUB 0529 16 AND 052A 60 PUSH1 0x00 052C 90 SWAP1 052D 81 DUP2 052E 52 MSTORE 052F 60 PUSH1 0x10 0531 60 PUSH1 0x20 0533 52 MSTORE 0534 60 PUSH1 0x40 0536 90 SWAP1 0537 20 SHA3 0538 54 SLOAD 0539 90 SWAP1 053A 56 *JUMP label_053B: // Incoming jump from 0x0085, if 0xb88d4fde == stack[-1] // Inputs[1] { @053C msg.value } 053B 5B JUMPDEST 053C 34 CALLVALUE 053D 80 DUP1 053E 15 ISZERO 053F 61 PUSH2 0x0547 0542 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053C stack[0] = msg.value } // Block ends with conditional jump to 0x0547, if !msg.value label_0543: // Incoming jump from 0x0542, if not !msg.value // Inputs[1] { @0546 memory[0x00:0x00] } 0543 60 PUSH1 0x00 0545 80 DUP1 0546 FD *REVERT // Stack delta = +0 // Outputs[1] { @0546 revert(memory[0x00:0x00]); } // Block terminates label_0547: // Incoming jump from 0x0542, if !msg.value // Inputs[1] { @054F msg.data.length } 0547 5B JUMPDEST 0548 50 POP 0549 61 PUSH2 0x02a3 054C 61 PUSH2 0x0556 054F 36 CALLDATASIZE 0550 60 PUSH1 0x04 0552 61 PUSH2 0x1c10 0555 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0549 stack[-1] = 0x02a3 // @054C stack[0] = 0x0556 // @054F stack[1] = msg.data.length // @0550 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c10 0556 5B JUMPDEST 0557 61 PUSH2 0x0d74 055A 56 *JUMP label_055B: // Incoming jump from 0x0090, if 0xc4d216ee == stack[-1] // Inputs[1] { @0562 msg.data.length } 055B 5B JUMPDEST 055C 61 PUSH2 0x02a3 055F 61 PUSH2 0x0569 0562 36 CALLDATASIZE 0563 60 PUSH1 0x04 0565 61 PUSH2 0x1dae 0568 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @055C stack[0] = 0x02a3 // @055F stack[1] = 0x0569 // @0562 stack[2] = msg.data.length // @0563 stack[3] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x0569 label_0569: // Incoming return from call to 0x1DAE at 0x0568 0569 5B JUMPDEST 056A 61 PUSH2 0x0dac 056D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dac label_056E: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @056F msg.value } 056E 5B JUMPDEST 056F 34 CALLVALUE 0570 80 DUP1 0571 15 ISZERO 0572 61 PUSH2 0x057a 0575 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056F stack[0] = msg.value } // Block ends with conditional jump to 0x057a, if !msg.value label_0576: // Incoming jump from 0x0575, if not !msg.value // Inputs[1] { @0579 memory[0x00:0x00] } 0576 60 PUSH1 0x00 0578 80 DUP1 0579 FD *REVERT // Stack delta = +0 // Outputs[1] { @0579 revert(memory[0x00:0x00]); } // Block terminates label_057A: // Incoming jump from 0x0575, if !msg.value // Inputs[1] { @0582 msg.data.length } 057A 5B JUMPDEST 057B 50 POP 057C 61 PUSH2 0x0249 057F 61 PUSH2 0x0589 0582 36 CALLDATASIZE 0583 60 PUSH1 0x04 0585 61 PUSH2 0x1dae 0588 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @057C stack[-1] = 0x0249 // @057F stack[0] = 0x0589 // @0582 stack[1] = msg.data.length // @0583 stack[2] = 0x04 // } // Block ends with call to 0x1dae, returns to 0x0589 label_0589: // Incoming return from call to 0x1DAE at 0x0588 0589 5B JUMPDEST 058A 61 PUSH2 0x0e29 058D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e29 label_058E: // Incoming jump from 0x003E, if 0xca800144 == stack[-1] // Inputs[1] { @058F msg.value } 058E 5B JUMPDEST 058F 34 CALLVALUE 0590 80 DUP1 0591 15 ISZERO 0592 61 PUSH2 0x059a 0595 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058F stack[0] = msg.value } // Block ends with conditional jump to 0x059a, if !msg.value label_0596: // Incoming jump from 0x0595, if not !msg.value // Inputs[1] { @0599 memory[0x00:0x00] } 0596 60 PUSH1 0x00 0598 80 DUP1 0599 FD *REVERT // Stack delta = +0 // Outputs[1] { @0599 revert(memory[0x00:0x00]); } // Block terminates label_059A: // Incoming jump from 0x0595, if !msg.value // Inputs[1] { @05A2 msg.data.length } 059A 5B JUMPDEST 059B 50 POP 059C 61 PUSH2 0x02a3 059F 61 PUSH2 0x05a9 05A2 36 CALLDATASIZE 05A3 60 PUSH1 0x04 05A5 61 PUSH2 0x1cb9 05A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @059C stack[-1] = 0x02a3 // @059F stack[0] = 0x05a9 // @05A2 stack[1] = msg.data.length // @05A3 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cb9 05A9 5B JUMPDEST 05AA 61 PUSH2 0x0ebc 05AD 56 *JUMP label_05AE: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05AF msg.value } 05AE 5B JUMPDEST 05AF 34 CALLVALUE 05B0 80 DUP1 05B1 15 ISZERO 05B2 61 PUSH2 0x05ba 05B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AF stack[0] = msg.value } // Block ends with conditional jump to 0x05ba, if !msg.value label_05B6: // Incoming jump from 0x05B5, if not !msg.value // Inputs[1] { @05B9 memory[0x00:0x00] } 05B6 60 PUSH1 0x00 05B8 80 DUP1 05B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B9 revert(memory[0x00:0x00]); } // Block terminates label_05BA: // Incoming jump from 0x05B5, if !msg.value // Inputs[1] { @05C2 msg.data.length } 05BA 5B JUMPDEST 05BB 50 POP 05BC 61 PUSH2 0x021e 05BF 61 PUSH2 0x05c9 05C2 36 CALLDATASIZE 05C3 60 PUSH1 0x04 05C5 61 PUSH2 0x1b89 05C8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05BC stack[-1] = 0x021e // @05BF stack[0] = 0x05c9 // @05C2 stack[1] = msg.data.length // @05C3 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b89 05C9 5B JUMPDEST 05CA 60 PUSH1 0x01 05CC 60 PUSH1 0x01 05CE 60 PUSH1 0xa0 05D0 1B SHL 05D1 03 SUB 05D2 91 SWAP2 05D3 82 DUP3 05D4 16 AND 05D5 60 PUSH1 0x00 05D7 90 SWAP1 05D8 81 DUP2 05D9 52 MSTORE 05DA 60 PUSH1 0x05 05DC 60 PUSH1 0x20 05DE 90 SWAP1 05DF 81 DUP2 05E0 52 MSTORE 05E1 60 PUSH1 0x40 05E3 80 DUP1 05E4 83 DUP4 05E5 20 SHA3 05E6 93 SWAP4 05E7 90 SWAP1 05E8 94 SWAP5 05E9 16 AND 05EA 82 DUP3 05EB 52 MSTORE 05EC 91 SWAP2 05ED 90 SWAP1 05EE 91 SWAP2 05EF 52 MSTORE 05F0 20 SHA3 05F1 54 SLOAD 05F2 60 PUSH1 0xff 05F4 16 AND 05F5 90 SWAP1 05F6 56 *JUMP label_05F7: // Incoming jump from 0x0054, if 0xeabe09ad == stack[-1] // Inputs[1] { @05F8 msg.value } 05F7 5B JUMPDEST 05F8 34 CALLVALUE 05F9 80 DUP1 05FA 15 ISZERO 05FB 61 PUSH2 0x0603 05FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0603, if !msg.value label_05FF: // Incoming jump from 0x05FE, if not !msg.value // Inputs[1] { @0602 memory[0x00:0x00] } 05FF 60 PUSH1 0x00 0601 80 DUP1 0602 FD *REVERT // Stack delta = +0 // Outputs[1] { @0602 revert(memory[0x00:0x00]); } // Block terminates label_0603: // Incoming jump from 0x05FE, if !msg.value // Inputs[1] { @0607 storage[0x0e] } 0603 5B JUMPDEST 0604 50 POP 0605 60 PUSH1 0x0e 0607 54 SLOAD 0608 61 PUSH2 0x0276 060B 90 SWAP1 060C 60 PUSH1 0x01 060E 60 PUSH1 0x01 0610 60 PUSH1 0xa0 0612 1B SHL 0613 03 SUB 0614 16 AND 0615 81 DUP2 0616 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @060B stack[-1] = 0x0276 // @0614 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // } // Block ends with unconditional jump to 0x0276 label_0617: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @0618 msg.value } 0617 5B JUMPDEST 0618 34 CALLVALUE 0619 80 DUP1 061A 15 ISZERO 061B 61 PUSH2 0x0623 061E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0618 stack[0] = msg.value } // Block ends with conditional jump to 0x0623, if !msg.value label_061F: // Incoming jump from 0x061E, if not !msg.value // Inputs[1] { @0622 memory[0x00:0x00] } 061F 60 PUSH1 0x00 0621 80 DUP1 0622 FD *REVERT // Stack delta = +0 // Outputs[1] { @0622 revert(memory[0x00:0x00]); } // Block terminates label_0623: // Incoming jump from 0x061E, if !msg.value // Inputs[1] { @062B msg.data.length } 0623 5B JUMPDEST 0624 50 POP 0625 61 PUSH2 0x02a3 0628 61 PUSH2 0x0632 062B 36 CALLDATASIZE 062C 60 PUSH1 0x04 062E 61 PUSH2 0x1b6b 0631 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0625 stack[-1] = 0x02a3 // @0628 stack[0] = 0x0632 // @062B stack[1] = msg.data.length // @062C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b6b 0632 5B JUMPDEST 0633 61 PUSH2 0x0ef0 0636 56 *JUMP label_0637: // Incoming jump from 0x006A, if 0xf382367b == stack[-1] // Inputs[1] { @0638 msg.value } 0637 5B JUMPDEST 0638 34 CALLVALUE 0639 80 DUP1 063A 15 ISZERO 063B 61 PUSH2 0x0643 063E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0638 stack[0] = msg.value } // Block ends with conditional jump to 0x0643, if !msg.value label_063F: // Incoming jump from 0x063E, if not !msg.value // Inputs[1] { @0642 memory[0x00:0x00] } 063F 60 PUSH1 0x00 0641 80 DUP1 0642 FD *REVERT // Stack delta = +0 // Outputs[1] { @0642 revert(memory[0x00:0x00]); } // Block terminates label_0643: // Incoming jump from 0x063E, if !msg.value // Inputs[1] { @064B msg.data.length } 0643 5B JUMPDEST 0644 50 POP 0645 61 PUSH2 0x02a3 0648 61 PUSH2 0x0652 064B 36 CALLDATASIZE 064C 60 PUSH1 0x04 064E 61 PUSH2 0x1ce9 0651 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0645 stack[-1] = 0x02a3 // @0648 stack[0] = 0x0652 // @064B stack[1] = msg.data.length // @064C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1ce9 0652 5B JUMPDEST 0653 61 PUSH2 0x0f49 0656 56 *JUMP label_0657: // Incoming jump from 0x021D // Inputs[1] { @065D stack[-1] } 0657 5B JUMPDEST 0658 60 PUSH1 0x00 065A 61 PUSH2 0x0662 065D 82 DUP3 065E 61 PUSH2 0x0fa8 0661 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0658 stack[0] = 0x00 // @065A stack[1] = 0x0662 // @065D stack[2] = stack[-1] // } // Block ends with call to 0x0fa8, returns to 0x0662 label_0662: // Incoming return from call to 0x1430 at 0x0FCC // Incoming jump from 0x147F // Incoming return from call to 0x2399 at 0x2658 // Incoming jump from 0x1466, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1466, if stack[-1] // Incoming return from call to 0x2321 at 0x2638 // Incoming return from call to 0x1FE5 at 0x2578 // Incoming jump from 0x0B0D, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming return from call to 0x2257 at 0x2608 // Incoming return from call to 0x21DF at 0x25E8 // Incoming jump from 0x2770 // Incoming return from call to 0x22A3 at 0x2618 // Incoming return from call to 0x2164 at 0x25C8 // Incoming return from call to 0x211E at 0x25B8 // Incoming return from call to 0x1EAA at 0x2528 // Incoming jump from 0x0FC3, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x20D7 at 0x25A8 // Incoming return from call to 0x1E37 at 0x2508 // Incoming return from call to 0x23CD at 0x2668 // Incoming return from call to 0x0FA8 at 0x0661 // Incoming return from call to 0x1F3C at 0x2548 // Incoming return from call to 0x2196 at 0x25D8 // Inputs[4] // { // @0663 stack[-2] // @0663 stack[-1] // @0666 stack[-4] // @0667 stack[-3] // } 0662 5B JUMPDEST 0663 90 SWAP1 0664 50 POP 0665 5B JUMPDEST 0666 91 SWAP2 0667 90 SWAP1 0668 50 POP 0669 56 *JUMP // Stack delta = -3 // Outputs[1] { @0666 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_066A: // Incoming call from 0x0248, returns to 0x0249 // Inputs[1] { @0670 storage[0x00] } 066A 5B JUMPDEST 066B 60 PUSH1 0x60 066D 60 PUSH1 0x00 066F 80 DUP1 0670 54 SLOAD 0671 61 PUSH2 0x0679 0674 90 SWAP1 0675 61 PUSH2 0x27a9 0678 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @066B stack[0] = 0x60 // @066D stack[1] = 0x00 // @0674 stack[2] = 0x0679 // @0674 stack[3] = storage[0x00] // } // Block ends with call to 0x27a9, returns to 0x0679 label_0679: // Incoming return from call to 0x27A9 at 0x0CD5 // Incoming return from call to 0x27A9 at 0x142F // Incoming return from call to 0x27A9 at 0x0678 // Inputs[4] // { // @067A stack[-1] // @0689 memory[0x40:0x60] // @0691 stack[-2] // @069C storage[stack[-2]] // } 0679 5B JUMPDEST 067A 80 DUP1 067B 60 PUSH1 0x1f 067D 01 ADD 067E 60 PUSH1 0x20 0680 80 DUP1 0681 91 SWAP2 0682 04 DIV 0683 02 MUL 0684 60 PUSH1 0x20 0686 01 ADD 0687 60 PUSH1 0x40 0689 51 MLOAD 068A 90 SWAP1 068B 81 DUP2 068C 01 ADD 068D 60 PUSH1 0x40 068F 52 MSTORE 0690 80 DUP1 0691 92 SWAP3 0692 91 SWAP2 0693 90 SWAP1 0694 81 DUP2 0695 81 DUP2 0696 52 MSTORE 0697 60 PUSH1 0x20 0699 01 ADD 069A 82 DUP3 069B 80 DUP1 069C 54 SLOAD 069D 61 PUSH2 0x06a5 06A0 90 SWAP1 06A1 61 PUSH2 0x27a9 06A4 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @068F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0691 stack[-2] = memory[0x40:0x60] // @0692 stack[-1] = stack[-2] // @0693 stack[0] = stack[-1] // @0696 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0699 stack[1] = 0x20 + memory[0x40:0x60] // @069A stack[2] = stack[-2] // @06A0 stack[4] = storage[stack[-2]] // @06A0 stack[3] = 0x06a5 // } // Block ends with call to 0x27a9, returns to 0x06A5 label_06A5: // Incoming return from call to 0x27A9 at 0x06A4 // Inputs[1] { @06A6 stack[-1] } 06A5 5B JUMPDEST 06A6 80 DUP1 06A7 15 ISZERO 06A8 61 PUSH2 0x06f2 06AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f2, if !stack[-1] label_06AC: // Incoming jump from 0x06AB, if not !stack[-1] // Inputs[1] { @06AC stack[-1] } 06AC 80 DUP1 06AD 60 PUSH1 0x1f 06AF 10 LT 06B0 61 PUSH2 0x06c7 06B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c7, if 0x1f < stack[-1] label_06B4: // Incoming jump from 0x06B3, if not 0x1f < stack[-1] // Inputs[4] // { // @06B8 stack[-2] // @06B9 storage[stack[-2]] // @06BC stack[-3] // @06BE stack[-1] // } 06B4 61 PUSH2 0x0100 06B7 80 DUP1 06B8 83 DUP4 06B9 54 SLOAD 06BA 04 DIV 06BB 02 MUL 06BC 83 DUP4 06BD 52 MSTORE 06BE 91 SWAP2 06BF 60 PUSH1 0x20 06C1 01 ADD 06C2 91 SWAP2 06C3 61 PUSH2 0x06f2 06C6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06BD memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06C2 stack[-1] = stack[-1] // @06C2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06f2 label_06C7: // Incoming jump from 0x06B3, if 0x1f < stack[-1] // Inputs[5] // { // @06C8 stack[-3] // @06C9 stack[-1] // @06CB stack[-2] // @06D3 memory[0x00:0x20] // @06D7 storage[keccak256(memory[0x00:0x20])] // } 06C7 5B JUMPDEST 06C8 82 DUP3 06C9 01 ADD 06CA 91 SWAP2 06CB 90 SWAP1 06CC 60 PUSH1 0x00 06CE 52 MSTORE 06CF 60 PUSH1 0x20 06D1 60 PUSH1 0x00 06D3 20 SHA3 06D4 90 SWAP1 06D5 5B JUMPDEST 06D6 81 DUP2 06D7 54 SLOAD 06D8 81 DUP2 06D9 52 MSTORE 06DA 90 SWAP1 06DB 60 PUSH1 0x01 06DD 01 ADD 06DE 90 SWAP1 06DF 60 PUSH1 0x20 06E1 01 ADD 06E2 80 DUP1 06E3 83 DUP4 06E4 11 GT 06E5 61 PUSH2 0x06d5 06E8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06CA stack[-3] = stack[-3] + stack[-1] // @06CE memory[0x00:0x20] = stack[-2] // @06D9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06DE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06E1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06d5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06E9: // Incoming jump from 0x06E8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x06E8, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @06E9 stack[-3] // @06EA stack[-1] // } 06E9 82 DUP3 06EA 90 SWAP1 06EB 03 SUB 06EC 60 PUSH1 0x1f 06EE 16 AND 06EF 82 DUP3 06F0 01 ADD 06F1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06F1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06F1 stack[-1] = stack[-3] // } // Block continues label_06F2: // Incoming jump from 0x06C6 // Incoming jump from 0x06AB, if !stack[-1] // Incoming jump from 0x06F1 // Inputs[3] // { // @06F8 stack[-6] // @06F8 stack[-7] // @06FA stack[-8] // } 06F2 5B JUMPDEST 06F3 50 POP 06F4 50 POP 06F5 50 POP 06F6 50 POP 06F7 50 POP 06F8 90 SWAP1 06F9 50 POP 06FA 90 SWAP1 06FB 56 *JUMP // Stack delta = -7 // Outputs[1] { @06FA stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06FC: // Incoming jump from 0x0275 // Inputs[3] // { // @06FF stack[-1] // @070A memory[0x00:0x40] // @070B storage[keccak256(memory[0x00:0x40])] // } 06FC 5B JUMPDEST 06FD 60 PUSH1 0x00 06FF 81 DUP2 0700 81 DUP2 0701 52 MSTORE 0702 60 PUSH1 0x02 0704 60 PUSH1 0x20 0706 52 MSTORE 0707 60 PUSH1 0x40 0709 81 DUP2 070A 20 SHA3 070B 54 SLOAD 070C 60 PUSH1 0x01 070E 60 PUSH1 0x01 0710 60 PUSH1 0xa0 0712 1B SHL 0713 03 SUB 0714 16 AND 0715 61 PUSH2 0x0739 0718 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @06FD stack[0] = 0x00 // @0701 memory[0x00:0x20] = stack[-1] // @0706 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0739, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0719: // Incoming jump from 0x0718, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @071B memory[0x40:0x60] } 0719 60 PUSH1 0x40 071B 51 MLOAD 071C 62 PUSH3 0x461bcd 0720 60 PUSH1 0xe5 0722 1B SHL 0723 81 DUP2 0724 52 MSTORE 0725 60 PUSH1 0x04 0727 01 ADD 0728 61 PUSH2 0x0730 072B 90 SWAP1 072C 61 PUSH2 0x25c9 072F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0724 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @072B stack[0] = 0x0730 // @072B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25c9 label_0730: // Incoming return from call to 0x25D9 at 0x0C56 // Incoming return from call to 0x25D9 at 0x077E // Incoming return from call to 0x25D9 at 0x08B9 // Incoming return from call to 0x25D9 at 0x0C20 // Inputs[3] // { // @0733 memory[0x40:0x60] // @0735 stack[-1] // @0738 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0730 5B JUMPDEST 0731 60 PUSH1 0x40 0733 51 MLOAD 0734 80 DUP1 0735 91 SWAP2 0736 03 SUB 0737 90 SWAP1 0738 FD *REVERT // Stack delta = -1 // Outputs[1] { @0738 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0739: // Incoming jump from 0x0718, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @073D stack[-2] // @0748 memory[0x00:0x40] // @0749 storage[keccak256(memory[0x00:0x40])] // @0753 stack[-3] // } 0739 5B JUMPDEST 073A 50 POP 073B 60 PUSH1 0x00 073D 90 SWAP1 073E 81 DUP2 073F 52 MSTORE 0740 60 PUSH1 0x04 0742 60 PUSH1 0x20 0744 52 MSTORE 0745 60 PUSH1 0x40 0747 90 SWAP1 0748 20 SHA3 0749 54 SLOAD 074A 60 PUSH1 0x01 074C 60 PUSH1 0x01 074E 60 PUSH1 0xa0 0750 1B SHL 0751 03 SUB 0752 16 AND 0753 90 SWAP1 0754 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @073F memory[0x00:0x20] = stack[-2] // @0744 memory[0x20:0x40] = 0x04 // @0753 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0755: // Incoming jump from 0x02A2 // Inputs[2] // { // @0758 storage[0x0a] // @0762 msg.sender // } 0755 5B JUMPDEST 0756 60 PUSH1 0x0a 0758 54 SLOAD 0759 60 PUSH1 0x01 075B 60 PUSH1 0x01 075D 60 PUSH1 0xa0 075F 1B SHL 0760 03 SUB 0761 16 AND 0762 33 CALLER 0763 14 EQ 0764 61 PUSH2 0x077f 0767 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x077f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0768: // Incoming jump from 0x0767, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @076A memory[0x40:0x60] } 0768 60 PUSH1 0x40 076A 51 MLOAD 076B 62 PUSH3 0x461bcd 076F 60 PUSH1 0xe5 0771 1B SHL 0772 81 DUP2 0773 52 MSTORE 0774 60 PUSH1 0x04 0776 01 ADD 0777 61 PUSH2 0x0730 077A 90 SWAP1 077B 61 PUSH2 0x25d9 077E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0773 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @077A stack[0] = 0x0730 // @077A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25d9, returns to 0x0730 label_077F: // Incoming jump from 0x0767, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[2] // { // @0782 stack[-1] // @0783 stack[-2] // } 077F 5B JUMPDEST 0780 60 PUSH1 0x0d 0782 55 SSTORE 0783 56 *JUMP // Stack delta = -2 // Outputs[1] { @0782 storage[0x0d] = stack[-1] } // Block ends with unconditional jump to stack[-2] 0784 5B JUMPDEST 0785 60 PUSH1 0x00 0787 61 PUSH2 0x078f 078A 82 DUP3 078B 61 PUSH2 0x0af0 078E 56 *JUMP 078F 5B JUMPDEST 0790 90 SWAP1 0791 50 POP 0792 80 DUP1 0793 60 PUSH1 0x01 0795 60 PUSH1 0x01 0797 60 PUSH1 0xa0 0799 1B SHL 079A 03 SUB 079B 16 AND 079C 83 DUP4 079D 60 PUSH1 0x01 079F 60 PUSH1 0x01 07A1 60 PUSH1 0xa0 07A3 1B SHL 07A4 03 SUB 07A5 16 AND 07A6 14 EQ 07A7 15 ISZERO 07A8 61 PUSH2 0x07c3 07AB 57 *JUMPI 07AC 60 PUSH1 0x40 07AE 51 MLOAD 07AF 62 PUSH3 0x461bcd 07B3 60 PUSH1 0xe5 07B5 1B SHL 07B6 81 DUP2 07B7 52 MSTORE 07B8 60 PUSH1 0x04 07BA 01 ADD 07BB 61 PUSH2 0x0730 07BE 90 SWAP1 07BF 61 PUSH2 0x2619 07C2 56 *JUMP 07C3 5B JUMPDEST 07C4 33 CALLER 07C5 60 PUSH1 0x01 07C7 60 PUSH1 0x01 07C9 60 PUSH1 0xa0 07CB 1B SHL 07CC 03 SUB 07CD 82 DUP3 07CE 16 AND 07CF 14 EQ 07D0 80 DUP1 07D1 61 PUSH2 0x07df 07D4 57 *JUMPI 07D5 50 POP 07D6 61 PUSH2 0x07df 07D9 81 DUP2 07DA 33 CALLER 07DB 61 PUSH2 0x05c9 07DE 56 *JUMP 07DF 5B JUMPDEST 07E0 61 PUSH2 0x07fb 07E3 57 *JUMPI 07E4 60 PUSH1 0x40 07E6 51 MLOAD 07E7 62 PUSH3 0x461bcd 07EB 60 PUSH1 0xe5 07ED 1B SHL 07EE 81 DUP2 07EF 52 MSTORE 07F0 60 PUSH1 0x04 07F2 01 ADD 07F3 61 PUSH2 0x0730 07F6 90 SWAP1 07F7 61 PUSH2 0x2589 07FA 56 *JUMP 07FB 5B JUMPDEST 07FC 61 PUSH2 0x0805 07FF 83 DUP4 0800 83 DUP4 0801 61 PUSH2 0x0fcd 0804 56 *JUMP label_0805: // Incoming jump from 0x168A, if stack[-1] // Incoming return from call to 0x15B2 at 0x148A // Incoming jump from 0x0C63, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1665, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming jump from 0x0945, if address(storage[0x0f] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x1818 at 0x166E // Incoming jump from 0x164B // Incoming jump from 0x0C63, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @0809 stack[-4] } 0805 5B JUMPDEST 0806 50 POP 0807 50 POP 0808 50 POP 0809 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 080A 5B JUMPDEST 080B 61 PUSH2 0x0814 080E 33 CALLER 080F 82 DUP3 0810 61 PUSH2 0x103b 0813 56 *JUMP 0814 5B JUMPDEST 0815 61 PUSH2 0x0830 0818 57 *JUMPI 0819 60 PUSH1 0x40 081B 51 MLOAD 081C 62 PUSH3 0x461bcd 0820 60 PUSH1 0xe5 0822 1B SHL 0823 81 DUP2 0824 52 MSTORE 0825 60 PUSH1 0x04 0827 01 ADD 0828 61 PUSH2 0x0730 082B 90 SWAP1 082C 61 PUSH2 0x2639 082F 56 *JUMP 0830 5B JUMPDEST 0831 61 PUSH2 0x0805 0834 83 DUP4 0835 83 DUP4 0836 83 DUP4 0837 61 PUSH2 0x10ed 083A 56 *JUMP 083B 5B JUMPDEST 083C 60 PUSH1 0x00 083E 61 PUSH2 0x0846 0841 83 DUP4 0842 61 PUSH2 0x0bb3 0845 56 *JUMP 0846 5B JUMPDEST 0847 82 DUP3 0848 10 LT 0849 61 PUSH2 0x0864 084C 57 *JUMPI 084D 60 PUSH1 0x40 084F 51 MLOAD 0850 62 PUSH3 0x461bcd 0854 60 PUSH1 0xe5 0856 1B SHL 0857 81 DUP2 0858 52 MSTORE 0859 60 PUSH1 0x04 085B 01 ADD 085C 61 PUSH2 0x0730 085F 90 SWAP1 0860 61 PUSH2 0x2509 0863 56 *JUMP 0864 5B JUMPDEST 0865 50 POP 0866 60 PUSH1 0x01 0868 60 PUSH1 0x01 086A 60 PUSH1 0xa0 086C 1B SHL 086D 03 SUB 086E 82 DUP3 086F 16 AND 0870 60 PUSH1 0x00 0872 90 SWAP1 0873 81 DUP2 0874 52 MSTORE 0875 60 PUSH1 0x06 0877 60 PUSH1 0x20 0879 90 SWAP1 087A 81 DUP2 087B 52 MSTORE 087C 60 PUSH1 0x40 087E 80 DUP1 087F 83 DUP4 0880 20 SHA3 0881 84 DUP5 0882 84 DUP5 0883 52 MSTORE 0884 90 SWAP1 0885 91 SWAP2 0886 52 MSTORE 0887 90 SWAP1 0888 20 SHA3 0889 54 SLOAD label_088A: // Incoming return from call to 0x28AF at 0x1B6A // Incoming return from call to 0x289F at 0x1B33 // Incoming return from call to 0x2416 at 0x2676 // Inputs[3] // { // @088B stack[-4] // @088B stack[-1] // @088C stack[-3] // } 088A 5B JUMPDEST 088B 92 SWAP3 088C 91 SWAP2 088D 50 POP 088E 50 POP 088F 56 *JUMP // Stack delta = -3 // Outputs[1] { @088B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0890: // Incoming call from 0x0368, returns to 0x02A3 // Inputs[2] // { // @0893 storage[0x0a] // @089D msg.sender // } 0890 5B JUMPDEST 0891 60 PUSH1 0x0a 0893 54 SLOAD 0894 60 PUSH1 0x01 0896 60 PUSH1 0x01 0898 60 PUSH1 0xa0 089A 1B SHL 089B 03 SUB 089C 16 AND 089D 33 CALLER 089E 14 EQ 089F 61 PUSH2 0x08ba 08A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ba, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_08A3: // Incoming jump from 0x08A2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @08A5 memory[0x40:0x60] } 08A3 60 PUSH1 0x40 08A5 51 MLOAD 08A6 62 PUSH3 0x461bcd 08AA 60 PUSH1 0xe5 08AC 1B SHL 08AD 81 DUP2 08AE 52 MSTORE 08AF 60 PUSH1 0x04 08B1 01 ADD 08B2 61 PUSH2 0x0730 08B5 90 SWAP1 08B6 61 PUSH2 0x25d9 08B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08B5 stack[0] = 0x0730 // @08B5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25d9, returns to 0x0730 label_08BA: // Incoming jump from 0x08A2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[2] // { // @08C2 address(this) // @08C2 address(this).balance // } 08BA 5B JUMPDEST 08BB 60 PUSH1 0x00 08BD 61 PUSH2 0x08c7 08C0 60 PUSH1 0x64 08C2 47 SELFBALANCE 08C3 61 PUSH2 0x2716 08C6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08BB stack[0] = 0x00 // @08BD stack[1] = 0x08c7 // @08C0 stack[2] = 0x64 // @08C2 stack[3] = address(this).balance // } // Block ends with call to 0x2716, returns to 0x08C7 label_08C7: // Incoming return from call to 0x2716 at 0x08C6 // Inputs[2] // { // @08C8 stack[-2] // @08C8 stack[-1] // } 08C7 5B JUMPDEST 08C8 90 SWAP1 08C9 50 POP 08CA 60 PUSH1 0x00 08CC 61 PUSH2 0x08d6 08CF 82 DUP3 08D0 60 PUSH1 0x5a 08D2 61 PUSH2 0x272a 08D5 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @08C8 stack[-2] = stack[-1] // @08CA stack[-1] = 0x00 // @08CC stack[0] = 0x08d6 // @08CF stack[1] = stack[-1] // @08D0 stack[2] = 0x5a // } // Block ends with call to 0x272a, returns to 0x08D6 label_08D6: // Incoming return from call to 0x272A at 0x08D5 // Inputs[3] // { // @08D7 stack[-2] // @08D7 stack[-1] // @08DE stack[-3] // } 08D6 5B JUMPDEST 08D7 90 SWAP1 08D8 50 POP 08D9 60 PUSH1 0x00 08DB 61 PUSH2 0x08e5 08DE 83 DUP4 08DF 60 PUSH1 0x0a 08E1 61 PUSH2 0x272a 08E4 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @08D7 stack[-2] = stack[-1] // @08D9 stack[-1] = 0x00 // @08DB stack[0] = 0x08e5 // @08DE stack[1] = stack[-3] // @08DF stack[2] = 0x0a // } // Block ends with call to 0x272a, returns to 0x08E5 label_08E5: // Incoming return from call to 0x272A at 0x08E4 // Inputs[7] // { // @08E8 storage[0x0e] // @08EB memory[0x40:0x60] // @08EC stack[-1] // @08ED stack[-2] // @08F9 stack[-3] // @090A address((0x01 << 0xa0) - 0x01 & storage[0x0e]).call.gas(0x08fc * !stack[-3]).value(stack[-3])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @090A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 08E5 5B JUMPDEST 08E6 60 PUSH1 0x0e 08E8 54 SLOAD 08E9 60 PUSH1 0x40 08EB 51 MLOAD 08EC 91 SWAP2 08ED 92 SWAP3 08EE 50 POP 08EF 60 PUSH1 0x01 08F1 60 PUSH1 0x01 08F3 60 PUSH1 0xa0 08F5 1B SHL 08F6 03 SUB 08F7 16 AND 08F8 90 SWAP1 08F9 83 DUP4 08FA 15 ISZERO 08FB 61 PUSH2 0x08fc 08FE 02 MUL 08FF 90 SWAP1 0900 84 DUP5 0901 90 SWAP1 0902 60 PUSH1 0x00 0904 81 DUP2 0905 81 DUP2 0906 81 DUP2 0907 85 DUP6 0908 88 DUP9 0909 88 DUP9 090A F1 CALL 090B 93 SWAP4 090C 50 POP 090D 50 POP 090E 50 POP 090F 50 POP 0910 61 PUSH2 0x0918 0913 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @08ED stack[-2] = stack[-1] // @090A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x0e]).call.gas(0x08fc * !stack[-3]).value(stack[-3])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0918, if address((0x01 << 0xa0) - 0x01 & storage[0x0e]).call.gas(0x08fc * !stack[-3]).value(stack[-3])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0914: // Incoming jump from 0x0913, if not address((0x01 << 0xa0) - 0x01 & storage[0x0e]).call.gas(0x08fc * !stack[-3]).value(stack[-3])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @0917 memory[0x00:0x00] } 0914 60 PUSH1 0x00 0916 80 DUP1 0917 FD *REVERT // Stack delta = +0 // Outputs[1] { @0917 revert(memory[0x00:0x00]); } // Block terminates label_0918: // Incoming jump from 0x0913, if address((0x01 << 0xa0) - 0x01 & storage[0x0e]).call.gas(0x08fc * !stack[-3]).value(stack[-3])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[5] // { // @091B storage[0x0f] // @091E memory[0x40:0x60] // @092B stack[-1] // @093C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @093C address(storage[0x0f] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0918 5B JUMPDEST 0919 60 PUSH1 0x0f 091B 54 SLOAD 091C 60 PUSH1 0x40 091E 51 MLOAD 091F 60 PUSH1 0x01 0921 60 PUSH1 0x01 0923 60 PUSH1 0xa0 0925 1B SHL 0926 03 SUB 0927 90 SWAP1 0928 91 SWAP2 0929 16 AND 092A 90 SWAP1 092B 82 DUP3 092C 15 ISZERO 092D 61 PUSH2 0x08fc 0930 02 MUL 0931 90 SWAP1 0932 83 DUP4 0933 90 SWAP1 0934 60 PUSH1 0x00 0936 81 DUP2 0937 81 DUP2 0938 81 DUP2 0939 85 DUP6 093A 88 DUP9 093B 88 DUP9 093C F1 CALL 093D 93 SWAP4 093E 50 POP 093F 50 POP 0940 50 POP 0941 50 POP 0942 61 PUSH2 0x0805 0945 57 *JUMPI // Stack delta = +0 // Outputs[1] { @093C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x0f] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) } // Block ends with conditional jump to 0x0805, if address(storage[0x0f] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0946: // Incoming jump from 0x0945, if not address(storage[0x0f] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @0949 memory[0x00:0x00] } 0946 60 PUSH1 0x00 0948 80 DUP1 0949 FD *REVERT // Stack delta = +0 // Outputs[1] { @0949 revert(memory[0x00:0x00]); } // Block terminates label_094A: // Incoming jump from 0x037B // Inputs[1] { @094F storage[0x0d] } 094A 5B JUMPDEST 094B 60 PUSH1 0x00 094D 60 PUSH1 0x0d 094F 54 SLOAD 0950 11 GT 0951 61 PUSH2 0x096c 0954 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x096c, if storage[0x0d] > 0x00 label_0955: // Incoming jump from 0x0954, if not storage[0x0d] > 0x00 // Inputs[1] { @0957 memory[0x40:0x60] } 0955 60 PUSH1 0x40 0957 51 MLOAD 0958 62 PUSH3 0x461bcd 095C 60 PUSH1 0xe5 095E 1B SHL 095F 81 DUP2 0960 52 MSTORE 0961 60 PUSH1 0x04 0963 01 ADD 0964 61 PUSH2 0x0730 0967 90 SWAP1 0968 61 PUSH2 0x24f9 096B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0960 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0967 stack[0] = 0x0730 // @0967 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24f9 label_096C: // Incoming jump from 0x0954, if storage[0x0d] > 0x00 // Inputs[3] // { // @096D msg.sender // @097B memory[0x00:0x40] // @097C storage[keccak256(memory[0x00:0x40])] // } 096C 5B JUMPDEST 096D 33 CALLER 096E 60 PUSH1 0x00 0970 90 SWAP1 0971 81 DUP2 0972 52 MSTORE 0973 60 PUSH1 0x10 0975 60 PUSH1 0x20 0977 52 MSTORE 0978 60 PUSH1 0x40 097A 90 SWAP1 097B 20 SHA3 097C 54 SLOAD 097D 80 DUP1 097E 61 PUSH2 0x0999 0981 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0972 memory[0x00:0x20] = msg.sender // @0977 memory[0x20:0x40] = 0x10 // @097C stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0999, if storage[keccak256(memory[0x00:0x40])] label_0982: // Incoming jump from 0x0981, if not storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0984 memory[0x40:0x60] } 0982 60 PUSH1 0x40 0984 51 MLOAD 0985 62 PUSH3 0x461bcd 0989 60 PUSH1 0xe5 098B 1B SHL 098C 81 DUP2 098D 52 MSTORE 098E 60 PUSH1 0x04 0990 01 ADD 0991 61 PUSH2 0x0730 0994 90 SWAP1 0995 61 PUSH2 0x2649 0998 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @098D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0994 stack[0] = 0x0730 // @0994 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2649 label_0999: // Incoming jump from 0x0981, if storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @099A stack[-1] // @099B stack[-2] // } 0999 5B JUMPDEST 099A 80 DUP1 099B 82 DUP3 099C 11 GT 099D 15 ISZERO 099E 61 PUSH2 0x09a6 09A1 82 DUP3 09A2 61 PUSH2 0x121a 09A5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @099D stack[0] = !(stack[-2] > stack[-1]) // @099E stack[1] = 0x09a6 // @09A1 stack[2] = stack[-1] // } // Block ends with call to 0x121a, returns to 0x09A6 label_09A6: // Incoming return from call to 0x121A at 0x09A5 // Inputs[2] // { // @09A9 memory[0x40:0x60] // @09B0 stack[-1] // } 09A6 5B JUMPDEST 09A7 60 PUSH1 0x40 09A9 51 MLOAD 09AA 60 PUSH1 0x20 09AC 01 ADD 09AD 61 PUSH2 0x09b6 09B0 91 SWAP2 09B1 90 SWAP1 09B2 61 PUSH2 0x2434 09B5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09B0 stack[-1] = 0x09b6 // @09B1 stack[1] = 0x20 + memory[0x40:0x60] // @09B1 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2434 09B6 5B JUMPDEST 09B7 60 PUSH1 0x40 09B9 51 MLOAD 09BA 60 PUSH1 0x20 09BC 81 DUP2 09BD 83 DUP4 09BE 03 SUB 09BF 03 SUB 09C0 81 DUP2 09C1 52 MSTORE 09C2 90 SWAP1 09C3 60 PUSH1 0x40 09C5 52 MSTORE 09C6 90 SWAP1 09C7 61 PUSH2 0x09e3 09CA 57 *JUMPI 09CB 60 PUSH1 0x40 09CD 51 MLOAD 09CE 62 PUSH3 0x461bcd 09D2 60 PUSH1 0xe5 09D4 1B SHL 09D5 81 DUP2 09D6 52 MSTORE 09D7 60 PUSH1 0x04 09D9 01 ADD 09DA 61 PUSH2 0x0730 09DD 91 SWAP2 09DE 90 SWAP1 09DF 61 PUSH2 0x24e8 09E2 56 *JUMP 09E3 5B JUMPDEST 09E4 50 POP 09E5 81 DUP2 09E6 60 PUSH1 0x0c 09E8 54 SLOAD 09E9 61 PUSH2 0x09f2 09EC 91 SWAP2 09ED 90 SWAP1 09EE 61 PUSH2 0x272a 09F1 56 *JUMP 09F2 5B JUMPDEST 09F3 34 CALLVALUE 09F4 10 LT 09F5 15 ISZERO 09F6 61 PUSH2 0x0a11 09F9 57 *JUMPI 09FA 60 PUSH1 0x40 09FC 51 MLOAD 09FD 62 PUSH3 0x461bcd 0A01 60 PUSH1 0xe5 0A03 1B SHL 0A04 81 DUP2 0A05 52 MSTORE 0A06 60 PUSH1 0x04 0A08 01 ADD 0A09 61 PUSH2 0x0730 0A0C 90 SWAP1 0A0D 61 PUSH2 0x2629 0A10 56 *JUMP 0A11 5B JUMPDEST 0A12 61 PUSH2 0x0a1b 0A15 82 DUP3 0A16 82 DUP3 0A17 61 PUSH2 0x2749 0A1A 56 *JUMP 0A1B 5B JUMPDEST 0A1C 33 CALLER 0A1D 60 PUSH1 0x00 0A1F 81 DUP2 0A20 81 DUP2 0A21 52 MSTORE 0A22 60 PUSH1 0x10 0A24 60 PUSH1 0x20 0A26 52 MSTORE 0A27 60 PUSH1 0x40 0A29 90 SWAP1 0A2A 20 SHA3 0A2B 91 SWAP2 0A2C 90 SWAP1 0A2D 91 SWAP2 0A2E 55 SSTORE 0A2F 61 PUSH2 0x0a38 0A32 90 SWAP1 0A33 83 DUP4 0A34 61 PUSH2 0x1335 0A37 56 *JUMP label_0A38: // Incoming return from call to 0x166F at 0x14A4 // Inputs[1] { @0A3B stack[-3] } 0A38 5B JUMPDEST 0A39 50 POP 0A3A 50 POP 0A3B 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] 0A3C 5B JUMPDEST 0A3D 61 PUSH2 0x0805 0A40 83 DUP4 0A41 83 DUP4 0A42 83 DUP4 0A43 60 PUSH1 0x40 0A45 51 MLOAD 0A46 80 DUP1 0A47 60 PUSH1 0x20 0A49 01 ADD 0A4A 60 PUSH1 0x40 0A4C 52 MSTORE 0A4D 80 DUP1 0A4E 60 PUSH1 0x00 0A50 81 DUP2 0A51 52 MSTORE 0A52 50 POP 0A53 61 PUSH2 0x0d74 0A56 56 *JUMP label_0A57: // Incoming jump from 0x03BB // Inputs[1] { @0A5F storage[0x08] } 0A57 5B JUMPDEST 0A58 60 PUSH1 0x00 0A5A 61 PUSH2 0x0a62 0A5D 60 PUSH1 0x08 0A5F 54 SLOAD 0A60 90 SWAP1 0A61 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A58 stack[0] = 0x00 // @0A60 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0a62 label_0A62: // Incoming jump from 0x0A61 // Inputs[2] // { // @0A63 stack[-3] // @0A64 stack[-1] // } 0A62 5B JUMPDEST 0A63 82 DUP3 0A64 10 LT 0A65 61 PUSH2 0x0a80 0A68 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a80, if stack[-3] < stack[-1] label_0A69: // Incoming jump from 0x0A68, if not stack[-3] < stack[-1] // Inputs[1] { @0A6B memory[0x40:0x60] } 0A69 60 PUSH1 0x40 0A6B 51 MLOAD 0A6C 62 PUSH3 0x461bcd 0A70 60 PUSH1 0xe5 0A72 1B SHL 0A73 81 DUP2 0A74 52 MSTORE 0A75 60 PUSH1 0x04 0A77 01 ADD 0A78 61 PUSH2 0x0730 0A7B 90 SWAP1 0A7C 61 PUSH2 0x2659 0A7F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A7B stack[0] = 0x0730 // @0A7B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2659 label_0A80: // Incoming jump from 0x0A68, if stack[-3] < stack[-1] // Inputs[2] // { // @0A83 stack[-2] // @0A85 storage[0x08] // } 0A80 5B JUMPDEST 0A81 60 PUSH1 0x08 0A83 82 DUP3 0A84 81 DUP2 0A85 54 SLOAD 0A86 81 DUP2 0A87 10 LT 0A88 61 PUSH2 0x0aa1 0A8B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0A81 stack[0] = 0x08 // @0A83 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0aa1, if stack[-2] < storage[0x08] label_0A8C: // Incoming jump from 0x0A8B, if not stack[-2] < storage[0x08] // Inputs[1] { @0AA0 memory[0x00:0x24] } 0A8C 63 PUSH4 0x4e487b71 0A91 60 PUSH1 0xe0 0A93 1B SHL 0A94 60 PUSH1 0x00 0A96 52 MSTORE 0A97 60 PUSH1 0x32 0A99 60 PUSH1 0x04 0A9B 52 MSTORE 0A9C 60 PUSH1 0x24 0A9E 60 PUSH1 0x00 0AA0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0A96 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0A9B memory[0x04:0x24] = 0x32 // @0AA0 revert(memory[0x00:0x24]); // } // Block terminates label_0AA1: // Incoming jump from 0x0A8B, if stack[-2] < storage[0x08] // Inputs[7] // { // @0AA2 stack[-1] // @0AA2 stack[-2] // @0AAA memory[0x00:0x20] // @0AAC storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0AAD stack[-3] // @0AAF stack[-5] // @0AB0 stack[-4] // } 0AA1 5B JUMPDEST 0AA2 90 SWAP1 0AA3 60 PUSH1 0x00 0AA5 52 MSTORE 0AA6 60 PUSH1 0x20 0AA8 60 PUSH1 0x00 0AAA 20 SHA3 0AAB 01 ADD 0AAC 54 SLOAD 0AAD 90 SWAP1 0AAE 50 POP 0AAF 91 SWAP2 0AB0 90 SWAP1 0AB1 50 POP 0AB2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0AA5 memory[0x00:0x20] = stack[-2] // @0AAF stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] 0AB3 5B JUMPDEST 0AB4 60 PUSH1 0x0a 0AB6 54 SLOAD 0AB7 60 PUSH1 0x01 0AB9 60 PUSH1 0x01 0ABB 60 PUSH1 0xa0 0ABD 1B SHL 0ABE 03 SUB 0ABF 16 AND 0AC0 33 CALLER 0AC1 14 EQ 0AC2 61 PUSH2 0x0add 0AC5 57 *JUMPI 0AC6 60 PUSH1 0x40 0AC8 51 MLOAD 0AC9 62 PUSH3 0x461bcd 0ACD 60 PUSH1 0xe5 0ACF 1B SHL 0AD0 81 DUP2 0AD1 52 MSTORE 0AD2 60 PUSH1 0x04 0AD4 01 ADD 0AD5 61 PUSH2 0x0730 0AD8 90 SWAP1 0AD9 61 PUSH2 0x25d9 0ADC 56 *JUMP 0ADD 5B JUMPDEST 0ADE 80 DUP1 0ADF 51 MLOAD 0AE0 61 PUSH2 0x0a38 0AE3 90 SWAP1 0AE4 60 PUSH1 0x0b 0AE6 90 SWAP1 0AE7 60 PUSH1 0x20 0AE9 84 DUP5 0AEA 01 ADD 0AEB 90 SWAP1 0AEC 61 PUSH2 0x194a 0AEF 56 *JUMP label_0AF0: // Incoming jump from 0x0411 // Inputs[3] // { // @0AF3 stack[-1] // @0AFE memory[0x00:0x40] // @0AFF storage[keccak256(memory[0x00:0x40])] // } 0AF0 5B JUMPDEST 0AF1 60 PUSH1 0x00 0AF3 81 DUP2 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 60 PUSH1 0x02 0AF8 60 PUSH1 0x20 0AFA 52 MSTORE 0AFB 60 PUSH1 0x40 0AFD 81 DUP2 0AFE 20 SHA3 0AFF 54 SLOAD 0B00 60 PUSH1 0x01 0B02 60 PUSH1 0x01 0B04 60 PUSH1 0xa0 0B06 1B SHL 0B07 03 SUB 0B08 16 AND 0B09 80 DUP1 0B0A 61 PUSH2 0x0662 0B0D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0AF1 stack[0] = 0x00 // @0AF5 memory[0x00:0x20] = stack[-1] // @0AFA memory[0x20:0x40] = 0x02 // @0B08 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0662, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0B0E: // Incoming jump from 0x0B0D, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0B10 memory[0x40:0x60] } 0B0E 60 PUSH1 0x40 0B10 51 MLOAD 0B11 62 PUSH3 0x461bcd 0B15 60 PUSH1 0xe5 0B17 1B SHL 0B18 81 DUP2 0B19 52 MSTORE 0B1A 60 PUSH1 0x04 0B1C 01 ADD 0B1D 61 PUSH2 0x0730 0B20 90 SWAP1 0B21 61 PUSH2 0x25a9 0B24 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B20 stack[0] = 0x0730 // @0B20 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25a9 label_0B25: // Incoming call from 0x0426, returns to 0x0249 // Inputs[1] { @0B29 storage[0x0b] } 0B25 5B JUMPDEST 0B26 60 PUSH1 0x0b 0B28 80 DUP1 0B29 54 SLOAD 0B2A 61 PUSH2 0x0b32 0B2D 90 SWAP1 0B2E 61 PUSH2 0x27a9 0B31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B26 stack[0] = 0x0b // @0B2D stack[1] = 0x0b32 // @0B2D stack[2] = storage[0x0b] // } // Block ends with call to 0x27a9, returns to 0x0B32 label_0B32: // Incoming return from call to 0x27A9 at 0x0B31 // Inputs[4] // { // @0B33 stack[-1] // @0B42 memory[0x40:0x60] // @0B4A stack[-2] // @0B55 storage[stack[-2]] // } 0B32 5B JUMPDEST 0B33 80 DUP1 0B34 60 PUSH1 0x1f 0B36 01 ADD 0B37 60 PUSH1 0x20 0B39 80 DUP1 0B3A 91 SWAP2 0B3B 04 DIV 0B3C 02 MUL 0B3D 60 PUSH1 0x20 0B3F 01 ADD 0B40 60 PUSH1 0x40 0B42 51 MLOAD 0B43 90 SWAP1 0B44 81 DUP2 0B45 01 ADD 0B46 60 PUSH1 0x40 0B48 52 MSTORE 0B49 80 DUP1 0B4A 92 SWAP3 0B4B 91 SWAP2 0B4C 90 SWAP1 0B4D 81 DUP2 0B4E 81 DUP2 0B4F 52 MSTORE 0B50 60 PUSH1 0x20 0B52 01 ADD 0B53 82 DUP3 0B54 80 DUP1 0B55 54 SLOAD 0B56 61 PUSH2 0x0b5e 0B59 90 SWAP1 0B5A 61 PUSH2 0x27a9 0B5D 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0B48 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0B4A stack[-2] = memory[0x40:0x60] // @0B4B stack[-1] = stack[-2] // @0B4C stack[0] = stack[-1] // @0B4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B52 stack[1] = 0x20 + memory[0x40:0x60] // @0B53 stack[2] = stack[-2] // @0B59 stack[4] = storage[stack[-2]] // @0B59 stack[3] = 0x0b5e // } // Block ends with call to 0x27a9, returns to 0x0B5E label_0B5E: // Incoming return from call to 0x27A9 at 0x0B5D // Inputs[1] { @0B5F stack[-1] } 0B5E 5B JUMPDEST 0B5F 80 DUP1 0B60 15 ISZERO 0B61 61 PUSH2 0x0bab 0B64 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bab, if !stack[-1] label_0B65: // Incoming jump from 0x0B64, if not !stack[-1] // Inputs[1] { @0B65 stack[-1] } 0B65 80 DUP1 0B66 60 PUSH1 0x1f 0B68 10 LT 0B69 61 PUSH2 0x0b80 0B6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b80, if 0x1f < stack[-1] label_0B6D: // Incoming jump from 0x0B6C, if not 0x1f < stack[-1] // Inputs[4] // { // @0B71 stack[-2] // @0B72 storage[stack[-2]] // @0B75 stack[-3] // @0B77 stack[-1] // } 0B6D 61 PUSH2 0x0100 0B70 80 DUP1 0B71 83 DUP4 0B72 54 SLOAD 0B73 04 DIV 0B74 02 MUL 0B75 83 DUP4 0B76 52 MSTORE 0B77 91 SWAP2 0B78 60 PUSH1 0x20 0B7A 01 ADD 0B7B 91 SWAP2 0B7C 61 PUSH2 0x0bab 0B7F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B76 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B7B stack[-1] = stack[-1] // @0B7B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0bab label_0B80: // Incoming jump from 0x0B6C, if 0x1f < stack[-1] // Inputs[5] // { // @0B81 stack[-3] // @0B82 stack[-1] // @0B84 stack[-2] // @0B8C memory[0x00:0x20] // @0B90 storage[keccak256(memory[0x00:0x20])] // } 0B80 5B JUMPDEST 0B81 82 DUP3 0B82 01 ADD 0B83 91 SWAP2 0B84 90 SWAP1 0B85 60 PUSH1 0x00 0B87 52 MSTORE 0B88 60 PUSH1 0x20 0B8A 60 PUSH1 0x00 0B8C 20 SHA3 0B8D 90 SWAP1 0B8E 5B JUMPDEST 0B8F 81 DUP2 0B90 54 SLOAD 0B91 81 DUP2 0B92 52 MSTORE 0B93 90 SWAP1 0B94 60 PUSH1 0x01 0B96 01 ADD 0B97 90 SWAP1 0B98 60 PUSH1 0x20 0B9A 01 ADD 0B9B 80 DUP1 0B9C 83 DUP4 0B9D 11 GT 0B9E 61 PUSH2 0x0b8e 0BA1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B83 stack[-3] = stack[-3] + stack[-1] // @0B87 memory[0x00:0x20] = stack[-2] // @0B92 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B97 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B9A stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b8e, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0BA2: // Incoming jump from 0x0BA1, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0BA1, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0BA2 stack[-3] // @0BA3 stack[-1] // } 0BA2 82 DUP3 0BA3 90 SWAP1 0BA4 03 SUB 0BA5 60 PUSH1 0x1f 0BA7 16 AND 0BA8 82 DUP3 0BA9 01 ADD 0BAA 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0BAA stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0BAA stack[-1] = stack[-3] // } // Block continues label_0BAB: // Incoming jump from 0x0B7F // Incoming jump from 0x0BAA // Incoming jump from 0x0B64, if !stack[-1] // Inputs[1] { @0BB1 stack[-7] } 0BAB 5B JUMPDEST 0BAC 50 POP 0BAD 50 POP 0BAE 50 POP 0BAF 50 POP 0BB0 50 POP 0BB1 81 DUP2 0BB2 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0BB3: // Incoming call from 0x16AE, returns to 0x16AF // Incoming call from 0x1822, returns to 0x1823 // Inputs[1] { @0BBE stack[-1] } 0BB3 5B JUMPDEST 0BB4 60 PUSH1 0x00 0BB6 60 PUSH1 0x01 0BB8 60 PUSH1 0x01 0BBA 60 PUSH1 0xa0 0BBC 1B SHL 0BBD 03 SUB 0BBE 82 DUP3 0BBF 16 AND 0BC0 61 PUSH2 0x0bdb 0BC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BB4 stack[0] = 0x00 } // Block ends with conditional jump to 0x0bdb, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0BC4: // Incoming jump from 0x0BC3, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0BC6 memory[0x40:0x60] } 0BC4 60 PUSH1 0x40 0BC6 51 MLOAD 0BC7 62 PUSH3 0x461bcd 0BCB 60 PUSH1 0xe5 0BCD 1B SHL 0BCE 81 DUP2 0BCF 52 MSTORE 0BD0 60 PUSH1 0x04 0BD2 01 ADD 0BD3 61 PUSH2 0x0730 0BD6 90 SWAP1 0BD7 61 PUSH2 0x2599 0BDA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BD6 stack[0] = 0x0730 // @0BD6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2599 label_0BDB: // Incoming jump from 0x0BC3, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0BE5 stack[-2] // @0BF3 memory[0x00:0x40] // @0BF4 storage[keccak256(memory[0x00:0x40])] // @0BF5 stack[-3] // } 0BDB 5B JUMPDEST 0BDC 50 POP 0BDD 60 PUSH1 0x01 0BDF 60 PUSH1 0x01 0BE1 60 PUSH1 0xa0 0BE3 1B SHL 0BE4 03 SUB 0BE5 16 AND 0BE6 60 PUSH1 0x00 0BE8 90 SWAP1 0BE9 81 DUP2 0BEA 52 MSTORE 0BEB 60 PUSH1 0x03 0BED 60 PUSH1 0x20 0BEF 52 MSTORE 0BF0 60 PUSH1 0x40 0BF2 90 SWAP1 0BF3 20 SHA3 0BF4 54 SLOAD 0BF5 90 SWAP1 0BF6 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0BEA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0BEF memory[0x20:0x40] = 0x03 // @0BF5 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0BF7: // Incoming call from 0x045B, returns to 0x02A3 // Inputs[2] // { // @0BFA storage[0x0a] // @0C04 msg.sender // } 0BF7 5B JUMPDEST 0BF8 60 PUSH1 0x0a 0BFA 54 SLOAD 0BFB 60 PUSH1 0x01 0BFD 60 PUSH1 0x01 0BFF 60 PUSH1 0xa0 0C01 1B SHL 0C02 03 SUB 0C03 16 AND 0C04 33 CALLER 0C05 14 EQ 0C06 61 PUSH2 0x0c21 0C09 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c21, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0C0A: // Incoming jump from 0x0C09, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0C0C memory[0x40:0x60] } 0C0A 60 PUSH1 0x40 0C0C 51 MLOAD 0C0D 62 PUSH3 0x461bcd 0C11 60 PUSH1 0xe5 0C13 1B SHL 0C14 81 DUP2 0C15 52 MSTORE 0C16 60 PUSH1 0x04 0C18 01 ADD 0C19 61 PUSH2 0x0730 0C1C 90 SWAP1 0C1D 61 PUSH2 0x25d9 0C20 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C1C stack[0] = 0x0730 // @0C1C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25d9, returns to 0x0730 label_0C21: // Incoming jump from 0x0C09, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] 0C21 5B JUMPDEST 0C22 61 PUSH2 0x0c2b 0C25 60 PUSH1 0x00 0C27 61 PUSH2 0x139c 0C2A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C22 stack[0] = 0x0c2b // @0C25 stack[1] = 0x00 // } // Block ends with call to 0x139c, returns to 0x0C2B label_0C2B: // Incoming return from call to 0x139C at 0x0C2A // Inputs[1] { @0C2C stack[-1] } 0C2B 5B JUMPDEST 0C2C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C2D: // Incoming jump from 0x047B // Inputs[2] // { // @0C30 storage[0x0a] // @0C3A msg.sender // } 0C2D 5B JUMPDEST 0C2E 60 PUSH1 0x0a 0C30 54 SLOAD 0C31 60 PUSH1 0x01 0C33 60 PUSH1 0x01 0C35 60 PUSH1 0xa0 0C37 1B SHL 0C38 03 SUB 0C39 16 AND 0C3A 33 CALLER 0C3B 14 EQ 0C3C 61 PUSH2 0x0c57 0C3F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c57, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_0C40: // Incoming jump from 0x0C3F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0C42 memory[0x40:0x60] } 0C40 60 PUSH1 0x40 0C42 51 MLOAD 0C43 62 PUSH3 0x461bcd 0C47 60 PUSH1 0xe5 0C49 1B SHL 0C4A 81 DUP2 0C4B 52 MSTORE 0C4C 60 PUSH1 0x04 0C4E 01 ADD 0C4F 61 PUSH2 0x0730 0C52 90 SWAP1 0C53 61 PUSH2 0x25d9 0C56 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C52 stack[0] = 0x0730 // @0C52 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25d9, returns to 0x0730 label_0C57: // Incoming jump from 0x0C3F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[2] // { // @0C5B stack[-2] // @0C5C memory[stack[-2]:stack[-2] + 0x20] // } 0C57 5B JUMPDEST 0C58 60 PUSH1 0x00 0C5A 5B JUMPDEST 0C5B 82 DUP3 0C5C 51 MLOAD 0C5D 81 DUP2 0C5E 10 LT 0C5F 15 ISZERO 0C60 61 PUSH2 0x0805 0C63 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C58 stack[0] = 0x00 } // Block ends with conditional jump to 0x0805, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0C64: // Incoming jump from 0x0C63, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0C63, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @0C64 stack[-2] // @0C69 stack[-3] // @0C6A stack[-1] // @0C6C memory[stack[-3]:stack[-3] + 0x20] // } 0C64 81 DUP2 0C65 60 PUSH1 0x10 0C67 60 PUSH1 0x00 0C69 85 DUP6 0C6A 84 DUP5 0C6B 81 DUP2 0C6C 51 MLOAD 0C6D 81 DUP2 0C6E 10 LT 0C6F 61 PUSH2 0x0c88 0C72 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0C64 stack[0] = stack[-2] // @0C65 stack[1] = 0x10 // @0C67 stack[2] = 0x00 // @0C69 stack[3] = stack[-3] // @0C6A stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0c88, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0C73: // Incoming jump from 0x0C72, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @0C87 memory[0x00:0x24] } 0C73 63 PUSH4 0x4e487b71 0C78 60 PUSH1 0xe0 0C7A 1B SHL 0C7B 60 PUSH1 0x00 0C7D 52 MSTORE 0C7E 60 PUSH1 0x32 0C80 60 PUSH1 0x04 0C82 52 MSTORE 0C83 60 PUSH1 0x24 0C85 60 PUSH1 0x00 0C87 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C7D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0C82 memory[0x04:0x24] = 0x32 // @0C87 revert(memory[0x00:0x24]); // } // Block terminates label_0C88: // Incoming jump from 0x0C72, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[8] // { // @0C8B stack[-1] // @0C8F stack[-2] // @0C90 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CA3 stack[-3] // @0CA8 stack[-4] // @0CB0 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0CB1 stack[-5] // @0CB5 stack[-6] // } 0C88 5B JUMPDEST 0C89 60 PUSH1 0x20 0C8B 02 MUL 0C8C 60 PUSH1 0x20 0C8E 01 ADD 0C8F 01 ADD 0C90 51 MLOAD 0C91 60 PUSH1 0x01 0C93 60 PUSH1 0x01 0C95 60 PUSH1 0xa0 0C97 1B SHL 0C98 03 SUB 0C99 16 AND 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0xa0 0CA0 1B SHL 0CA1 03 SUB 0CA2 16 AND 0CA3 81 DUP2 0CA4 52 MSTORE 0CA5 60 PUSH1 0x20 0CA7 01 ADD 0CA8 90 SWAP1 0CA9 81 DUP2 0CAA 52 MSTORE 0CAB 60 PUSH1 0x20 0CAD 01 ADD 0CAE 60 PUSH1 0x00 0CB0 20 SHA3 0CB1 81 DUP2 0CB2 90 SWAP1 0CB3 55 SSTORE 0CB4 50 POP 0CB5 80 DUP1 0CB6 80 DUP1 0CB7 61 PUSH2 0x0cbf 0CBA 90 SWAP1 0CBB 61 PUSH2 0x2803 0CBE 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @0CA4 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CAA memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0CB3 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = stack[-5] // @0CB5 stack[-5] = stack[-6] // @0CBA stack[-4] = 0x0cbf // @0CBA stack[-3] = stack[-6] // } // Block ends with call to 0x2803, returns to 0x0CBF label_0CBF: // Incoming return from call to 0x2803 at 0x0CBE // Inputs[2] // { // @0CC0 stack[-1] // @0CC0 stack[-3] // } 0CBF 5B JUMPDEST 0CC0 91 SWAP2 0CC1 50 POP 0CC2 50 POP 0CC3 61 PUSH2 0x0c5a 0CC6 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CC0 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c5a label_0CC7: // Incoming call from 0x04CE, returns to 0x0249 // Inputs[1] { @0CCD storage[0x01] } 0CC7 5B JUMPDEST 0CC8 60 PUSH1 0x60 0CCA 60 PUSH1 0x01 0CCC 80 DUP1 0CCD 54 SLOAD 0CCE 61 PUSH2 0x0679 0CD1 90 SWAP1 0CD2 61 PUSH2 0x27a9 0CD5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CC8 stack[0] = 0x60 // @0CCA stack[1] = 0x01 // @0CD1 stack[2] = 0x0679 // @0CD1 stack[3] = storage[0x01] // } // Block ends with call to 0x27a9, returns to 0x0679 0CD6 5B JUMPDEST 0CD7 60 PUSH1 0x01 0CD9 60 PUSH1 0x01 0CDB 60 PUSH1 0xa0 0CDD 1B SHL 0CDE 03 SUB 0CDF 82 DUP3 0CE0 16 AND 0CE1 33 CALLER 0CE2 14 EQ 0CE3 15 ISZERO 0CE4 61 PUSH2 0x0cff 0CE7 57 *JUMPI 0CE8 60 PUSH1 0x40 0CEA 51 MLOAD 0CEB 62 PUSH3 0x461bcd 0CEF 60 PUSH1 0xe5 0CF1 1B SHL 0CF2 81 DUP2 0CF3 52 MSTORE 0CF4 60 PUSH1 0x04 0CF6 01 ADD 0CF7 61 PUSH2 0x0730 0CFA 90 SWAP1 0CFB 61 PUSH2 0x2559 0CFE 56 *JUMP 0CFF 5B JUMPDEST 0D00 33 CALLER 0D01 60 PUSH1 0x00 0D03 81 DUP2 0D04 81 DUP2 0D05 52 MSTORE 0D06 60 PUSH1 0x05 0D08 60 PUSH1 0x20 0D0A 90 SWAP1 0D0B 81 DUP2 0D0C 52 MSTORE 0D0D 60 PUSH1 0x40 0D0F 80 DUP1 0D10 83 DUP4 0D11 20 SHA3 0D12 60 PUSH1 0x01 0D14 60 PUSH1 0x01 0D16 60 PUSH1 0xa0 0D18 1B SHL 0D19 03 SUB 0D1A 87 DUP8 0D1B 16 AND 0D1C 80 DUP1 0D1D 85 DUP6 0D1E 52 MSTORE 0D1F 92 SWAP3 0D20 52 MSTORE 0D21 90 SWAP1 0D22 91 SWAP2 0D23 20 SHA3 0D24 80 DUP1 0D25 54 SLOAD 0D26 60 PUSH1 0xff 0D28 19 NOT 0D29 16 AND 0D2A 84 DUP5 0D2B 15 ISZERO 0D2C 15 ISZERO 0D2D 17 OR 0D2E 90 SWAP1 0D2F 55 SSTORE 0D30 90 SWAP1 0D31 60 PUSH1 0x01 0D33 60 PUSH1 0x01 0D35 60 PUSH1 0xa0 0D37 1B SHL 0D38 03 SUB 0D39 16 AND 0D3A 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D5B 83 DUP4 0D5C 60 PUSH1 0x40 0D5E 51 MLOAD 0D5F 61 PUSH2 0x0d68 0D62 91 SWAP2 0D63 90 SWAP1 0D64 61 PUSH2 0x24da 0D67 56 *JUMP 0D68 5B JUMPDEST 0D69 60 PUSH1 0x40 0D6B 51 MLOAD 0D6C 80 DUP1 0D6D 91 SWAP2 0D6E 03 SUB 0D6F 90 SWAP1 0D70 A3 LOG3 0D71 50 POP 0D72 50 POP 0D73 56 *JUMP 0D74 5B JUMPDEST 0D75 61 PUSH2 0x0d7e 0D78 33 CALLER 0D79 83 DUP4 0D7A 61 PUSH2 0x103b 0D7D 56 *JUMP 0D7E 5B JUMPDEST 0D7F 61 PUSH2 0x0d9a 0D82 57 *JUMPI 0D83 60 PUSH1 0x40 0D85 51 MLOAD 0D86 62 PUSH3 0x461bcd 0D8A 60 PUSH1 0xe5 0D8C 1B SHL 0D8D 81 DUP2 0D8E 52 MSTORE 0D8F 60 PUSH1 0x04 0D91 01 ADD 0D92 61 PUSH2 0x0730 0D95 90 SWAP1 0D96 61 PUSH2 0x2639 0D99 56 *JUMP 0D9A 5B JUMPDEST 0D9B 61 PUSH2 0x0da6 0D9E 84 DUP5 0D9F 84 DUP5 0DA0 84 DUP5 0DA1 84 DUP5 0DA2 61 PUSH2 0x13ee 0DA5 56 *JUMP label_0DA6: // Incoming jump from 0x1377, if 0x01 > stack[-2] // Incoming jump from 0x1377, if stack[-1] > stack[-3] // Incoming jump from 0x27A0, if !(stack[-1] > stack[-4]) // Inputs[1] { @0DAB stack[-5] } 0DA6 5B JUMPDEST 0DA7 50 POP 0DA8 50 POP 0DA9 50 POP 0DAA 50 POP 0DAB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0DAC: // Incoming jump from 0x056D // Inputs[1] { @0DB1 storage[0x0d] } 0DAC 5B JUMPDEST 0DAD 60 PUSH1 0x01 0DAF 60 PUSH1 0x0d 0DB1 54 SLOAD 0DB2 11 GT 0DB3 61 PUSH2 0x0dce 0DB6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dce, if storage[0x0d] > 0x01 label_0DB7: // Incoming jump from 0x0DB6, if not storage[0x0d] > 0x01 // Inputs[1] { @0DB9 memory[0x40:0x60] } 0DB7 60 PUSH1 0x40 0DB9 51 MLOAD 0DBA 62 PUSH3 0x461bcd 0DBE 60 PUSH1 0xe5 0DC0 1B SHL 0DC1 81 DUP2 0DC2 52 MSTORE 0DC3 60 PUSH1 0x04 0DC5 01 ADD 0DC6 61 PUSH2 0x0730 0DC9 90 SWAP1 0DCA 61 PUSH2 0x24f9 0DCD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DC9 stack[0] = 0x0730 // @0DC9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x24f9 label_0DCE: // Incoming jump from 0x0DB6, if storage[0x0d] > 0x01 // Inputs[1] { @0DD1 stack[-1] } 0DCE 5B JUMPDEST 0DCF 60 PUSH1 0x05 0DD1 81 DUP2 0DD2 11 GT 0DD3 15 ISZERO 0DD4 61 PUSH2 0x0def 0DD7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0def, if !(stack[-1] > 0x05) label_0DD8: // Incoming jump from 0x0DD7, if not !(stack[-1] > 0x05) // Inputs[1] { @0DDA memory[0x40:0x60] } 0DD8 60 PUSH1 0x40 0DDA 51 MLOAD 0DDB 62 PUSH3 0x461bcd 0DDF 60 PUSH1 0xe5 0DE1 1B SHL 0DE2 81 DUP2 0DE3 52 MSTORE 0DE4 60 PUSH1 0x04 0DE6 01 ADD 0DE7 61 PUSH2 0x0730 0DEA 90 SWAP1 0DEB 61 PUSH2 0x2609 0DEE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DEA stack[0] = 0x0730 // @0DEA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2609 label_0DEF: // Incoming jump from 0x0DD7, if !(stack[-1] > 0x05) // Inputs[2] // { // @0DF0 stack[-1] // @0DF3 storage[0x0c] // } 0DEF 5B JUMPDEST 0DF0 80 DUP1 0DF1 60 PUSH1 0x0c 0DF3 54 SLOAD 0DF4 61 PUSH2 0x0dfd 0DF7 91 SWAP2 0DF8 90 SWAP1 0DF9 61 PUSH2 0x272a 0DFC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DF7 stack[0] = 0x0dfd // @0DF8 stack[1] = stack[-1] // @0DF8 stack[2] = storage[0x0c] // } // Block ends with call to 0x272a, returns to 0x0DFD label_0DFD: // Incoming return from call to 0x272A at 0x0DFC // Inputs[2] // { // @0DFE msg.value // @0DFF stack[-1] // } 0DFD 5B JUMPDEST 0DFE 34 CALLVALUE 0DFF 10 LT 0E00 15 ISZERO 0E01 61 PUSH2 0x0e1c 0E04 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e1c, if !(msg.value < stack[-1]) label_0E05: // Incoming jump from 0x0E04, if not !(msg.value < stack[-1]) // Inputs[1] { @0E07 memory[0x40:0x60] } 0E05 60 PUSH1 0x40 0E07 51 MLOAD 0E08 62 PUSH3 0x461bcd 0E0C 60 PUSH1 0xe5 0E0E 1B SHL 0E0F 81 DUP2 0E10 52 MSTORE 0E11 60 PUSH1 0x04 0E13 01 ADD 0E14 61 PUSH2 0x0730 0E17 90 SWAP1 0E18 61 PUSH2 0x2629 0E1B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E17 stack[0] = 0x0730 // @0E17 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2629 label_0E1C: // Incoming jump from 0x0E04, if !(msg.value < stack[-1]) // Inputs[2] // { // @0E20 msg.sender // @0E21 stack[-1] // } 0E1C 5B JUMPDEST 0E1D 61 PUSH2 0x0e26 0E20 33 CALLER 0E21 82 DUP3 0E22 61 PUSH2 0x1335 0E25 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E1D stack[0] = 0x0e26 // @0E20 stack[1] = msg.sender // @0E21 stack[2] = stack[-1] // } // Block ends with call to 0x1335, returns to 0x0E26 label_0E26: // Incoming jump from 0x2892, if stack[-2] == stack[-1] // Incoming return from call to 0x1335 at 0x0E25 // Inputs[1] { @0E28 stack[-2] } 0E26 5B JUMPDEST 0E27 50 POP 0E28 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0E29: // Incoming jump from 0x058D // Inputs[3] // { // @0E2C stack[-1] // @0E37 memory[0x00:0x40] // @0E38 storage[keccak256(memory[0x00:0x40])] // } 0E29 5B JUMPDEST 0E2A 60 PUSH1 0x00 0E2C 81 DUP2 0E2D 81 DUP2 0E2E 52 MSTORE 0E2F 60 PUSH1 0x02 0E31 60 PUSH1 0x20 0E33 52 MSTORE 0E34 60 PUSH1 0x40 0E36 90 SWAP1 0E37 20 SHA3 0E38 54 SLOAD 0E39 60 PUSH1 0x60 0E3B 90 SWAP1 0E3C 60 PUSH1 0x01 0E3E 60 PUSH1 0x01 0E40 60 PUSH1 0xa0 0E42 1B SHL 0E43 03 SUB 0E44 16 AND 0E45 61 PUSH2 0x0e60 0E48 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E2E memory[0x00:0x20] = stack[-1] // @0E33 memory[0x20:0x40] = 0x02 // @0E3B stack[0] = 0x60 // } // Block ends with conditional jump to 0x0e60, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0E49: // Incoming jump from 0x0E48, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0E4B memory[0x40:0x60] } 0E49 60 PUSH1 0x40 0E4B 51 MLOAD 0E4C 62 PUSH3 0x461bcd 0E50 60 PUSH1 0xe5 0E52 1B SHL 0E53 81 DUP2 0E54 52 MSTORE 0E55 60 PUSH1 0x04 0E57 01 ADD 0E58 61 PUSH2 0x0730 0E5B 90 SWAP1 0E5C 61 PUSH2 0x25f9 0E5F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E5B stack[0] = 0x0730 // @0E5B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25f9 label_0E60: // Incoming jump from 0x0E48, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] 0E60 5B JUMPDEST 0E61 60 PUSH1 0x00 0E63 61 PUSH2 0x0e6a 0E66 61 PUSH2 0x1421 0E69 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E61 stack[0] = 0x00 // @0E63 stack[1] = 0x0e6a // } // Block ends with unconditional jump to 0x1421 0E6A 5B JUMPDEST 0E6B 90 SWAP1 0E6C 50 POP 0E6D 60 PUSH1 0x00 0E6F 81 DUP2 0E70 51 MLOAD 0E71 11 GT 0E72 61 PUSH2 0x0e8a 0E75 57 *JUMPI 0E76 60 PUSH1 0x40 0E78 51 MLOAD 0E79 80 DUP1 0E7A 60 PUSH1 0x20 0E7C 01 ADD 0E7D 60 PUSH1 0x40 0E7F 52 MSTORE 0E80 80 DUP1 0E81 60 PUSH1 0x00 0E83 81 DUP2 0E84 52 MSTORE 0E85 50 POP 0E86 61 PUSH2 0x0eb5 0E89 56 *JUMP 0E8A 5B JUMPDEST 0E8B 80 DUP1 0E8C 61 PUSH2 0x0e94 0E8F 84 DUP5 0E90 61 PUSH2 0x121a 0E93 56 *JUMP 0E94 5B JUMPDEST 0E95 60 PUSH1 0x40 0E97 51 MLOAD 0E98 60 PUSH1 0x20 0E9A 01 ADD 0E9B 61 PUSH2 0x0ea5 0E9E 92 SWAP3 0E9F 91 SWAP2 0EA0 90 SWAP1 0EA1 61 PUSH2 0x241c 0EA4 56 *JUMP 0EA5 5B JUMPDEST 0EA6 60 PUSH1 0x40 0EA8 51 MLOAD 0EA9 60 PUSH1 0x20 0EAB 81 DUP2 0EAC 83 DUP4 0EAD 03 SUB 0EAE 03 SUB 0EAF 81 DUP2 0EB0 52 MSTORE 0EB1 90 SWAP1 0EB2 60 PUSH1 0x40 0EB4 52 MSTORE label_0EB5: // Incoming return from call to 0x1DE3 at 0x24F8 // Inputs[3] // { // @0EB6 stack[-5] // @0EB6 stack[-1] // @0EB7 stack[-4] // } 0EB5 5B JUMPDEST 0EB6 93 SWAP4 0EB7 92 SWAP3 0EB8 50 POP 0EB9 50 POP 0EBA 50 POP 0EBB 56 *JUMP // Stack delta = -4 // Outputs[1] { @0EB6 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 0EBC 5B JUMPDEST 0EBD 60 PUSH1 0x0a 0EBF 54 SLOAD 0EC0 60 PUSH1 0x01 0EC2 60 PUSH1 0x01 0EC4 60 PUSH1 0xa0 0EC6 1B SHL 0EC7 03 SUB 0EC8 16 AND 0EC9 33 CALLER 0ECA 14 EQ 0ECB 61 PUSH2 0x0ee6 0ECE 57 *JUMPI 0ECF 60 PUSH1 0x40 0ED1 51 MLOAD 0ED2 62 PUSH3 0x461bcd 0ED6 60 PUSH1 0xe5 0ED8 1B SHL 0ED9 81 DUP2 0EDA 52 MSTORE 0EDB 60 PUSH1 0x04 0EDD 01 ADD 0EDE 61 PUSH2 0x0730 0EE1 90 SWAP1 0EE2 61 PUSH2 0x25d9 0EE5 56 *JUMP 0EE6 5B JUMPDEST 0EE7 61 PUSH2 0x0a38 0EEA 82 DUP3 0EEB 82 DUP3 0EEC 61 PUSH2 0x1335 0EEF 56 *JUMP 0EF0 5B JUMPDEST 0EF1 60 PUSH1 0x0a 0EF3 54 SLOAD 0EF4 60 PUSH1 0x01 0EF6 60 PUSH1 0x01 0EF8 60 PUSH1 0xa0 0EFA 1B SHL 0EFB 03 SUB 0EFC 16 AND 0EFD 33 CALLER 0EFE 14 EQ 0EFF 61 PUSH2 0x0f1a 0F02 57 *JUMPI 0F03 60 PUSH1 0x40 0F05 51 MLOAD 0F06 62 PUSH3 0x461bcd 0F0A 60 PUSH1 0xe5 0F0C 1B SHL 0F0D 81 DUP2 0F0E 52 MSTORE 0F0F 60 PUSH1 0x04 0F11 01 ADD 0F12 61 PUSH2 0x0730 0F15 90 SWAP1 0F16 61 PUSH2 0x25d9 0F19 56 *JUMP 0F1A 5B JUMPDEST 0F1B 60 PUSH1 0x01 0F1D 60 PUSH1 0x01 0F1F 60 PUSH1 0xa0 0F21 1B SHL 0F22 03 SUB 0F23 81 DUP2 0F24 16 AND 0F25 61 PUSH2 0x0f40 0F28 57 *JUMPI 0F29 60 PUSH1 0x40 0F2B 51 MLOAD 0F2C 62 PUSH3 0x461bcd 0F30 60 PUSH1 0xe5 0F32 1B SHL 0F33 81 DUP2 0F34 52 MSTORE 0F35 60 PUSH1 0x04 0F37 01 ADD 0F38 61 PUSH2 0x0730 0F3B 90 SWAP1 0F3C 61 PUSH2 0x2529 0F3F 56 *JUMP 0F40 5B JUMPDEST 0F41 61 PUSH2 0x0e26 0F44 81 DUP2 0F45 61 PUSH2 0x139c 0F48 56 *JUMP 0F49 5B JUMPDEST 0F4A 60 PUSH1 0x0a 0F4C 54 SLOAD 0F4D 60 PUSH1 0x01 0F4F 60 PUSH1 0x01 0F51 60 PUSH1 0xa0 0F53 1B SHL 0F54 03 SUB 0F55 16 AND 0F56 33 CALLER 0F57 14 EQ 0F58 61 PUSH2 0x0f73 0F5B 57 *JUMPI 0F5C 60 PUSH1 0x40 0F5E 51 MLOAD 0F5F 62 PUSH3 0x461bcd 0F63 60 PUSH1 0xe5 0F65 1B SHL 0F66 81 DUP2 0F67 52 MSTORE 0F68 60 PUSH1 0x04 0F6A 01 ADD 0F6B 61 PUSH2 0x0730 0F6E 90 SWAP1 0F6F 61 PUSH2 0x25d9 0F72 56 *JUMP 0F73 5B JUMPDEST 0F74 80 DUP1 0F75 51 MLOAD 0F76 60 PUSH1 0x0e 0F78 80 DUP1 0F79 54 SLOAD 0F7A 60 PUSH1 0x01 0F7C 60 PUSH1 0x01 0F7E 60 PUSH1 0xa0 0F80 1B SHL 0F81 03 SUB 0F82 19 NOT 0F83 90 SWAP1 0F84 81 DUP2 0F85 16 AND 0F86 60 PUSH1 0x01 0F88 60 PUSH1 0x01 0F8A 60 PUSH1 0xa0 0F8C 1B SHL 0F8D 03 SUB 0F8E 93 SWAP4 0F8F 84 DUP5 0F90 16 AND 0F91 17 OR 0F92 90 SWAP1 0F93 91 SWAP2 0F94 55 SSTORE 0F95 60 PUSH1 0x20 0F97 90 SWAP1 0F98 92 SWAP3 0F99 01 ADD 0F9A 51 MLOAD 0F9B 60 PUSH1 0x0f 0F9D 80 DUP1 0F9E 54 SLOAD 0F9F 90 SWAP1 0FA0 93 SWAP4 0FA1 16 AND 0FA2 91 SWAP2 0FA3 16 AND 0FA4 17 OR 0FA5 90 SWAP1 0FA6 55 SSTORE 0FA7 56 *JUMP label_0FA8: // Incoming call from 0x0661, returns to 0x0662 // Inputs[1] { @0FB4 stack[-1] } 0FA8 5B JUMPDEST 0FA9 60 PUSH1 0x00 0FAB 60 PUSH1 0x01 0FAD 60 PUSH1 0x01 0FAF 60 PUSH1 0xe0 0FB1 1B SHL 0FB2 03 SUB 0FB3 19 NOT 0FB4 82 DUP3 0FB5 16 AND 0FB6 63 PUSH4 0x780e9d63 0FBB 60 PUSH1 0xe0 0FBD 1B SHL 0FBE 14 EQ 0FBF 80 DUP1 0FC0 61 PUSH2 0x0662 0FC3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0FA9 stack[0] = 0x00 // @0FBE stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0662, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0FC4: // Incoming jump from 0x0FC3, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0FC8 stack[-3] } 0FC4 50 POP 0FC5 61 PUSH2 0x0662 0FC8 82 DUP3 0FC9 61 PUSH2 0x1430 0FCC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0FC5 stack[-1] = 0x0662 // @0FC8 stack[0] = stack[-3] // } // Block ends with call to 0x1430, returns to 0x0662 0FCD 5B JUMPDEST 0FCE 60 PUSH1 0x00 0FD0 81 DUP2 0FD1 81 DUP2 0FD2 52 MSTORE 0FD3 60 PUSH1 0x04 0FD5 60 PUSH1 0x20 0FD7 52 MSTORE 0FD8 60 PUSH1 0x40 0FDA 90 SWAP1 0FDB 20 SHA3 0FDC 80 DUP1 0FDD 54 SLOAD 0FDE 60 PUSH1 0x01 0FE0 60 PUSH1 0x01 0FE2 60 PUSH1 0xa0 0FE4 1B SHL 0FE5 03 SUB 0FE6 19 NOT 0FE7 16 AND 0FE8 60 PUSH1 0x01 0FEA 60 PUSH1 0x01 0FEC 60 PUSH1 0xa0 0FEE 1B SHL 0FEF 03 SUB 0FF0 84 DUP5 0FF1 16 AND 0FF2 90 SWAP1 0FF3 81 DUP2 0FF4 17 OR 0FF5 90 SWAP1 0FF6 91 SWAP2 0FF7 55 SSTORE 0FF8 81 DUP2 0FF9 90 SWAP1 0FFA 61 PUSH2 0x1002 0FFD 82 DUP3 0FFE 61 PUSH2 0x0af0 1001 56 *JUMP 1002 5B JUMPDEST 1003 60 PUSH1 0x01 1005 60 PUSH1 0x01 1007 60 PUSH1 0xa0 1009 1B SHL 100A 03 SUB 100B 16 AND 100C 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 102D 60 PUSH1 0x40 102F 51 MLOAD 1030 60 PUSH1 0x40 1032 51 MLOAD 1033 80 DUP1 1034 91 SWAP2 1035 03 SUB 1036 90 SWAP1 1037 A4 LOG4 1038 50 POP 1039 50 POP 103A 56 *JUMP 103B 5B JUMPDEST 103C 60 PUSH1 0x00 103E 81 DUP2 103F 81 DUP2 1040 52 MSTORE 1041 60 PUSH1 0x02 1043 60 PUSH1 0x20 1045 52 MSTORE 1046 60 PUSH1 0x40 1048 81 DUP2 1049 20 SHA3 104A 54 SLOAD 104B 60 PUSH1 0x01 104D 60 PUSH1 0x01 104F 60 PUSH1 0xa0 1051 1B SHL 1052 03 SUB 1053 16 AND 1054 61 PUSH2 0x106f 1057 57 *JUMPI 1058 60 PUSH1 0x40 105A 51 MLOAD 105B 62 PUSH3 0x461bcd 105F 60 PUSH1 0xe5 1061 1B SHL 1062 81 DUP2 1063 52 MSTORE 1064 60 PUSH1 0x04 1066 01 ADD 1067 61 PUSH2 0x0730 106A 90 SWAP1 106B 61 PUSH2 0x2579 106E 56 *JUMP 106F 5B JUMPDEST 1070 60 PUSH1 0x00 1072 61 PUSH2 0x107a 1075 83 DUP4 1076 61 PUSH2 0x0af0 1079 56 *JUMP 107A 5B JUMPDEST 107B 90 SWAP1 107C 50 POP 107D 80 DUP1 107E 60 PUSH1 0x01 1080 60 PUSH1 0x01 1082 60 PUSH1 0xa0 1084 1B SHL 1085 03 SUB 1086 16 AND 1087 84 DUP5 1088 60 PUSH1 0x01 108A 60 PUSH1 0x01 108C 60 PUSH1 0xa0 108E 1B SHL 108F 03 SUB 1090 16 AND 1091 14 EQ 1092 80 DUP1 1093 61 PUSH2 0x10b5 1096 57 *JUMPI 1097 50 POP 1098 83 DUP4 1099 60 PUSH1 0x01 109B 60 PUSH1 0x01 109D 60 PUSH1 0xa0 109F 1B SHL 10A0 03 SUB 10A1 16 AND 10A2 61 PUSH2 0x10aa 10A5 84 DUP5 10A6 61 PUSH2 0x06fc 10A9 56 *JUMP 10AA 5B JUMPDEST 10AB 60 PUSH1 0x01 10AD 60 PUSH1 0x01 10AF 60 PUSH1 0xa0 10B1 1B SHL 10B2 03 SUB 10B3 16 AND 10B4 14 EQ 10B5 5B JUMPDEST 10B6 80 DUP1 10B7 61 PUSH2 0x10e5 10BA 57 *JUMPI 10BB 50 POP 10BC 60 PUSH1 0x01 10BE 60 PUSH1 0x01 10C0 60 PUSH1 0xa0 10C2 1B SHL 10C3 03 SUB 10C4 80 DUP1 10C5 82 DUP3 10C6 16 AND 10C7 60 PUSH1 0x00 10C9 90 SWAP1 10CA 81 DUP2 10CB 52 MSTORE 10CC 60 PUSH1 0x05 10CE 60 PUSH1 0x20 10D0 90 SWAP1 10D1 81 DUP2 10D2 52 MSTORE 10D3 60 PUSH1 0x40 10D5 80 DUP1 10D6 83 DUP4 10D7 20 SHA3 10D8 93 SWAP4 10D9 88 DUP9 10DA 16 AND 10DB 83 DUP4 10DC 52 MSTORE 10DD 92 SWAP3 10DE 90 SWAP1 10DF 52 MSTORE 10E0 20 SHA3 10E1 54 SLOAD 10E2 60 PUSH1 0xff 10E4 16 AND label_10E5: // Incoming return from call to 0x1B60 at 0x1DCB // Incoming return from call to 0x1A42 at 0x1B1D // Incoming jump from 0x12C6, if !stack[-7] // Incoming return from call to 0x19E3 at 0x1AFC // Incoming jump from 0x12C6, if !stack[-7] // Incoming return from call to 0x1ADF at 0x1D06 // Incoming return from call to 0x1A9B at 0x1B5F // Incoming return from call to 0x1B3F at 0x1DAD // Incoming jump from 0x12C6, if !stack[-5] // Incoming return from call to 0x1B29 at 0x1D5A // Inputs[3] // { // @10E6 stack[-1] // @10E6 stack[-6] // @10E7 stack[-5] // } 10E5 5B JUMPDEST 10E6 94 SWAP5 10E7 93 SWAP4 10E8 50 POP 10E9 50 POP 10EA 50 POP 10EB 50 POP 10EC 56 *JUMP // Stack delta = -5 // Outputs[1] { @10E6 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 10ED 5B JUMPDEST 10EE 82 DUP3 10EF 60 PUSH1 0x01 10F1 60 PUSH1 0x01 10F3 60 PUSH1 0xa0 10F5 1B SHL 10F6 03 SUB 10F7 16 AND 10F8 61 PUSH2 0x1100 10FB 82 DUP3 10FC 61 PUSH2 0x0af0 10FF 56 *JUMP 1100 5B JUMPDEST 1101 60 PUSH1 0x01 1103 60 PUSH1 0x01 1105 60 PUSH1 0xa0 1107 1B SHL 1108 03 SUB 1109 16 AND 110A 14 EQ 110B 61 PUSH2 0x1126 110E 57 *JUMPI 110F 60 PUSH1 0x40 1111 51 MLOAD 1112 62 PUSH3 0x461bcd 1116 60 PUSH1 0xe5 1118 1B SHL 1119 81 DUP2 111A 52 MSTORE 111B 60 PUSH1 0x04 111D 01 ADD 111E 61 PUSH2 0x0730 1121 90 SWAP1 1122 61 PUSH2 0x25e9 1125 56 *JUMP 1126 5B JUMPDEST 1127 60 PUSH1 0x01 1129 60 PUSH1 0x01 112B 60 PUSH1 0xa0 112D 1B SHL 112E 03 SUB 112F 82 DUP3 1130 16 AND 1131 61 PUSH2 0x114c 1134 57 *JUMPI 1135 60 PUSH1 0x40 1137 51 MLOAD 1138 62 PUSH3 0x461bcd 113C 60 PUSH1 0xe5 113E 1B SHL 113F 81 DUP2 1140 52 MSTORE 1141 60 PUSH1 0x04 1143 01 ADD 1144 61 PUSH2 0x0730 1147 90 SWAP1 1148 61 PUSH2 0x2549 114B 56 *JUMP 114C 5B JUMPDEST 114D 61 PUSH2 0x1157 1150 83 DUP4 1151 83 DUP4 1152 83 DUP4 1153 61 PUSH2 0x1480 1156 56 *JUMP 1157 5B JUMPDEST 1158 61 PUSH2 0x1162 115B 60 PUSH1 0x00 115D 82 DUP3 115E 61 PUSH2 0x0fcd 1161 56 *JUMP 1162 5B JUMPDEST 1163 60 PUSH1 0x01 1165 60 PUSH1 0x01 1167 60 PUSH1 0xa0 1169 1B SHL 116A 03 SUB 116B 83 DUP4 116C 16 AND 116D 60 PUSH1 0x00 116F 90 SWAP1 1170 81 DUP2 1171 52 MSTORE 1172 60 PUSH1 0x03 1174 60 PUSH1 0x20 1176 52 MSTORE 1177 60 PUSH1 0x40 1179 81 DUP2 117A 20 SHA3 117B 80 DUP1 117C 54 SLOAD 117D 60 PUSH1 0x01 117F 92 SWAP3 1180 90 SWAP1 1181 61 PUSH2 0x118b 1184 90 SWAP1 1185 84 DUP5 1186 90 SWAP1 1187 61 PUSH2 0x2749 118A 56 *JUMP 118B 5B JUMPDEST 118C 90 SWAP1 118D 91 SWAP2 118E 55 SSTORE 118F 50 POP 1190 50 POP 1191 60 PUSH1 0x01 1193 60 PUSH1 0x01 1195 60 PUSH1 0xa0 1197 1B SHL 1198 03 SUB 1199 82 DUP3 119A 16 AND 119B 60 PUSH1 0x00 119D 90 SWAP1 119E 81 DUP2 119F 52 MSTORE 11A0 60 PUSH1 0x03 11A2 60 PUSH1 0x20 11A4 52 MSTORE 11A5 60 PUSH1 0x40 11A7 81 DUP2 11A8 20 SHA3 11A9 80 DUP1 11AA 54 SLOAD 11AB 60 PUSH1 0x01 11AD 92 SWAP3 11AE 90 SWAP1 11AF 61 PUSH2 0x11b9 11B2 90 SWAP1 11B3 84 DUP5 11B4 90 SWAP1 11B5 61 PUSH2 0x26fe 11B8 56 *JUMP 11B9 5B JUMPDEST 11BA 90 SWAP1 11BB 91 SWAP2 11BC 55 SSTORE 11BD 50 POP 11BE 50 POP 11BF 60 PUSH1 0x00 11C1 81 DUP2 11C2 81 DUP2 11C3 52 MSTORE 11C4 60 PUSH1 0x02 11C6 60 PUSH1 0x20 11C8 52 MSTORE 11C9 60 PUSH1 0x40 11CB 80 DUP1 11CC 82 DUP3 11CD 20 SHA3 11CE 80 DUP1 11CF 54 SLOAD 11D0 60 PUSH1 0x01 11D2 60 PUSH1 0x01 11D4 60 PUSH1 0xa0 11D6 1B SHL 11D7 03 SUB 11D8 19 NOT 11D9 16 AND 11DA 60 PUSH1 0x01 11DC 60 PUSH1 0x01 11DE 60 PUSH1 0xa0 11E0 1B SHL 11E1 03 SUB 11E2 86 DUP7 11E3 81 DUP2 11E4 16 AND 11E5 91 SWAP2 11E6 82 DUP3 11E7 17 OR 11E8 90 SWAP1 11E9 92 SWAP3 11EA 55 SSTORE 11EB 91 SWAP2 11EC 51 MLOAD 11ED 84 DUP5 11EE 93 SWAP4 11EF 91 SWAP2 11F0 87 DUP8 11F1 16 AND 11F2 91 SWAP2 11F3 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1214 91 SWAP2 1215 A4 LOG4 1216 50 POP 1217 50 POP 1218 50 POP 1219 56 *JUMP label_121A: // Incoming call from 0x09A5, returns to 0x09A6 // Inputs[1] { @121D stack[-1] } 121A 5B JUMPDEST 121B 60 PUSH1 0x60 121D 81 DUP2 121E 61 PUSH2 0x123f 1221 57 *JUMPI // Stack delta = +1 // Outputs[1] { @121B stack[0] = 0x60 } // Block ends with conditional jump to 0x123f, if stack[-1] label_1222: // Incoming jump from 0x1221, if not stack[-1] // Inputs[1] { @1226 memory[0x40:0x60] } 1222 50 POP 1223 60 PUSH1 0x40 1225 80 DUP1 1226 51 MLOAD 1227 80 DUP1 1228 82 DUP3 1229 01 ADD 122A 90 SWAP1 122B 91 SWAP2 122C 52 MSTORE 122D 60 PUSH1 0x01 122F 81 DUP2 1230 52 MSTORE 1231 60 PUSH1 0x03 1233 60 PUSH1 0xfc 1235 1B SHL 1236 60 PUSH1 0x20 1238 82 DUP3 1239 01 ADD 123A 52 MSTORE 123B 61 PUSH2 0x0665 123E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @122B stack[-1] = memory[0x40:0x60] // @122C memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1230 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @123A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // } // Block ends with unconditional jump to 0x0665 label_123F: // Incoming jump from 0x1221, if stack[-1] // Inputs[1] { @1240 stack[-2] } 123F 5B JUMPDEST 1240 81 DUP2 1241 60 PUSH1 0x00 1243 5B JUMPDEST 1244 81 DUP2 1245 15 ISZERO 1246 61 PUSH2 0x1269 1249 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1240 stack[0] = stack[-2] // @1241 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1269, if !stack[-2] label_124A: // Incoming jump from 0x1249, if not !stack[-2] // Incoming jump from 0x1249, if not !stack[-2] // Inputs[1] { @124A stack[-1] } 124A 80 DUP1 124B 61 PUSH2 0x1253 124E 81 DUP2 124F 61 PUSH2 0x2803 1252 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @124A stack[0] = stack[-1] // @124B stack[1] = 0x1253 // @124E stack[2] = stack[-1] // } // Block ends with call to 0x2803, returns to 0x1253 label_1253: // Incoming return from call to 0x2803 at 0x1252 // Inputs[4] // { // @1254 stack[-3] // @1254 stack[-1] // @1259 stack[-2] // @125D stack[-4] // } 1253 5B JUMPDEST 1254 91 SWAP2 1255 50 POP 1256 61 PUSH2 0x1262 1259 90 SWAP1 125A 50 POP 125B 60 PUSH1 0x0a 125D 83 DUP4 125E 61 PUSH2 0x2716 1261 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1254 stack[-3] = stack[-1] // @1259 stack[-2] = 0x1262 // @125B stack[-1] = 0x0a // @125D stack[0] = stack[-4] // } // Block ends with call to 0x2716, returns to 0x1262 label_1262: // Incoming return from call to 0x2716 at 0x1261 // Inputs[2] // { // @1263 stack[-3] // @1263 stack[-1] // } 1262 5B JUMPDEST 1263 91 SWAP2 1264 50 POP 1265 61 PUSH2 0x1243 1268 56 *JUMP // Stack delta = -1 // Outputs[1] { @1263 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1243 label_1269: // Incoming jump from 0x1249, if !stack[-2] // Incoming jump from 0x1249, if !stack[-2] // Inputs[1] { @126C stack[-1] } 1269 5B JUMPDEST 126A 60 PUSH1 0x00 126C 81 DUP2 126D 67 PUSH8 0xffffffffffffffff 1276 81 DUP2 1277 11 GT 1278 15 ISZERO 1279 61 PUSH2 0x1292 127C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @126A stack[0] = 0x00 // @126C stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1292, if !(stack[-1] > 0xffffffffffffffff) label_127D: // Incoming jump from 0x127C, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1291 memory[0x00:0x24] } 127D 63 PUSH4 0x4e487b71 1282 60 PUSH1 0xe0 1284 1B SHL 1285 60 PUSH1 0x00 1287 52 MSTORE 1288 60 PUSH1 0x41 128A 60 PUSH1 0x04 128C 52 MSTORE 128D 60 PUSH1 0x24 128F 60 PUSH1 0x00 1291 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1287 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @128C memory[0x04:0x24] = 0x41 // @1291 revert(memory[0x00:0x24]); // } // Block terminates label_1292: // Incoming jump from 0x127C, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1295 memory[0x40:0x60] // @1296 stack[-1] // } 1292 5B JUMPDEST 1293 60 PUSH1 0x40 1295 51 MLOAD 1296 90 SWAP1 1297 80 DUP1 1298 82 DUP3 1299 52 MSTORE 129A 80 DUP1 129B 60 PUSH1 0x1f 129D 01 ADD 129E 60 PUSH1 0x1f 12A0 19 NOT 12A1 16 AND 12A2 60 PUSH1 0x20 12A4 01 ADD 12A5 82 DUP3 12A6 01 ADD 12A7 60 PUSH1 0x40 12A9 52 MSTORE 12AA 80 DUP1 12AB 15 ISZERO 12AC 61 PUSH2 0x12bc 12AF 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1296 stack[-1] = memory[0x40:0x60] // @1296 stack[0] = stack[-1] // @1299 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @12A9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x12bc, if !stack[-1] label_12B0: // Incoming jump from 0x12AF, if not !stack[-1] // Inputs[6] // { // @12B2 stack[-2] // @12B4 stack[-1] // @12B6 msg.data.length // @12B8 msg.data[msg.data.length:msg.data.length + stack[-1]] // @12BE stack[-3] // @12C1 stack[-7] // } 12B0 60 PUSH1 0x20 12B2 82 DUP3 12B3 01 ADD 12B4 81 DUP2 12B5 80 DUP1 12B6 36 CALLDATASIZE 12B7 83 DUP4 12B8 37 CALLDATACOPY 12B9 01 ADD 12BA 90 SWAP1 12BB 50 POP 12BC 5B JUMPDEST 12BD 50 POP 12BE 90 SWAP1 12BF 50 POP 12C0 5B JUMPDEST 12C1 84 DUP5 12C2 15 ISZERO 12C3 61 PUSH2 0x10e5 12C6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @12B8 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @12BE stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x10e5, if !stack[-7] label_12C7: // Incoming jump from 0x12C6, if not !stack[-7] // Incoming jump from 0x12C6, if not !stack[-7] // Incoming jump from 0x12C6, if not !stack[-5] // Inputs[1] { @12CC stack[-2] } 12C7 61 PUSH2 0x12d1 12CA 60 PUSH1 0x01 12CC 83 DUP4 12CD 61 PUSH2 0x2749 12D0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12C7 stack[0] = 0x12d1 // @12CA stack[1] = 0x01 // @12CC stack[2] = stack[-2] // } // Block ends with call to 0x2749, returns to 0x12D1 label_12D1: // Incoming return from call to 0x2749 at 0x12D0 // Inputs[3] // { // @12D2 stack[-3] // @12D2 stack[-1] // @12D9 stack[-6] // } 12D1 5B JUMPDEST 12D2 91 SWAP2 12D3 50 POP 12D4 61 PUSH2 0x12de 12D7 60 PUSH1 0x0a 12D9 86 DUP7 12DA 61 PUSH2 0x2817 12DD 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @12D2 stack[-3] = stack[-1] // @12D4 stack[-1] = 0x12de // @12D7 stack[0] = 0x0a // @12D9 stack[1] = stack[-6] // } // Block ends with call to 0x2817, returns to 0x12DE label_12DE: // Incoming return from call to 0x2817 at 0x12DD // Inputs[1] { @12E2 stack[-1] } 12DE 5B JUMPDEST 12DF 61 PUSH2 0x12e9 12E2 90 SWAP1 12E3 60 PUSH1 0x30 12E5 61 PUSH2 0x26fe 12E8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12E2 stack[0] = stack[-1] // @12E2 stack[-1] = 0x12e9 // @12E3 stack[1] = 0x30 // } // Block ends with call to 0x26fe, returns to 0x12E9 label_12E9: // Incoming return from call to 0x26FE at 0x12E8 // Inputs[4] // { // @12EC stack[-1] // @12ED stack[-2] // @12EE stack[-3] // @12F0 memory[stack[-2]:stack[-2] + 0x20] // } 12E9 5B JUMPDEST 12EA 60 PUSH1 0xf8 12EC 1B SHL 12ED 81 DUP2 12EE 83 DUP4 12EF 81 DUP2 12F0 51 MLOAD 12F1 81 DUP2 12F2 10 LT 12F3 61 PUSH2 0x130c 12F6 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @12EC stack[-1] = stack[-1] << 0xf8 // @12ED stack[0] = stack[-2] // @12EE stack[1] = stack[-3] // } // Block ends with conditional jump to 0x130c, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_12F7: // Incoming jump from 0x12F6, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @130B memory[0x00:0x24] } 12F7 63 PUSH4 0x4e487b71 12FC 60 PUSH1 0xe0 12FE 1B SHL 12FF 60 PUSH1 0x00 1301 52 MSTORE 1302 60 PUSH1 0x32 1304 60 PUSH1 0x04 1306 52 MSTORE 1307 60 PUSH1 0x24 1309 60 PUSH1 0x00 130B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1301 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1306 memory[0x04:0x24] = 0x32 // @130B revert(memory[0x00:0x24]); // } // Block terminates label_130C: // Incoming jump from 0x12F6, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @130F stack[-1] // @1310 stack[-2] // @1311 stack[-3] // @1329 stack[-8] // } 130C 5B JUMPDEST 130D 60 PUSH1 0x20 130F 01 ADD 1310 01 ADD 1311 90 SWAP1 1312 60 PUSH1 0x01 1314 60 PUSH1 0x01 1316 60 PUSH1 0xf8 1318 1B SHL 1319 03 SUB 131A 19 NOT 131B 16 AND 131C 90 SWAP1 131D 81 DUP2 131E 60 PUSH1 0x00 1320 1A BYTE 1321 90 SWAP1 1322 53 MSTORE8 1323 50 POP 1324 61 PUSH2 0x132e 1327 60 PUSH1 0x0a 1329 86 DUP7 132A 61 PUSH2 0x2716 132D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1322 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1324 stack[-3] = 0x132e // @1327 stack[-2] = 0x0a // @1329 stack[-1] = stack[-8] // } // Block ends with call to 0x2716, returns to 0x132E label_132E: // Incoming return from call to 0x2716 at 0x132D // Inputs[2] // { // @132F stack[-1] // @132F stack[-6] // } 132E 5B JUMPDEST 132F 94 SWAP5 1330 50 POP 1331 61 PUSH2 0x12c0 1334 56 *JUMP // Stack delta = -1 // Outputs[1] { @132F stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x12c0 label_1335: // Incoming call from 0x0E25, returns to 0x0E26 // Inputs[1] { @133D storage[0x08] } 1335 5B JUMPDEST 1336 60 PUSH1 0x00 1338 61 PUSH2 0x1340 133B 60 PUSH1 0x08 133D 54 SLOAD 133E 90 SWAP1 133F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1336 stack[0] = 0x00 // @133E stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x1340 label_1340: // Incoming jump from 0x133F // Inputs[3] // { // @1341 stack[-2] // @1341 stack[-1] // @1349 stack[-3] // } 1340 5B JUMPDEST 1341 90 SWAP1 1342 50 POP 1343 61 PUSH2 0x1388 1346 61 PUSH2 0x134f 1349 83 DUP4 134A 83 DUP4 134B 61 PUSH2 0x26fe 134E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1341 stack[-2] = stack[-1] // @1343 stack[-1] = 0x1388 // @1346 stack[0] = 0x134f // @1349 stack[1] = stack[-3] // @134A stack[2] = stack[-1] // } // Block ends with call to 0x26fe, returns to 0x134F label_134F: // Incoming return from call to 0x26FE at 0x134E // Inputs[2] // { // @1350 stack[-2] // @1350 stack[-1] // } 134F 5B JUMPDEST 1350 11 GT 1351 15 ISZERO 1352 61 PUSH2 0x136d 1355 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x136d, if !(stack[-1] > stack[-2]) label_1356: // Incoming jump from 0x1355, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1358 memory[0x40:0x60] } 1356 60 PUSH1 0x40 1358 51 MLOAD 1359 62 PUSH3 0x461bcd 135D 60 PUSH1 0xe5 135F 1B SHL 1360 81 DUP2 1361 52 MSTORE 1362 60 PUSH1 0x04 1364 01 ADD 1365 61 PUSH2 0x0730 1368 90 SWAP1 1369 61 PUSH2 0x2569 136C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1361 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1368 stack[0] = 0x0730 // @1368 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2569 label_136D: // Incoming jump from 0x1355, if !(stack[-1] > stack[-2]) // Inputs[1] { @1371 stack[-2] } 136D 5B JUMPDEST 136E 60 PUSH1 0x01 1370 5B JUMPDEST 1371 82 DUP3 1372 81 DUP2 1373 11 GT 1374 61 PUSH2 0x0da6 1377 57 *JUMPI // Stack delta = +1 // Outputs[1] { @136E stack[0] = 0x01 } // Block ends with conditional jump to 0x0da6, if 0x01 > stack[-2] label_1378: // Incoming jump from 0x1377, if not stack[-1] > stack[-3] // Incoming jump from 0x1377, if not 0x01 > stack[-2] // Inputs[3] // { // @137B stack[-4] // @137F stack[-1] // @1380 stack[-2] // } 1378 61 PUSH2 0x138a 137B 84 DUP5 137C 61 PUSH2 0x1385 137F 83 DUP4 1380 85 DUP6 1381 61 PUSH2 0x26fe 1384 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1378 stack[0] = 0x138a // @137B stack[1] = stack[-4] // @137C stack[2] = 0x1385 // @137F stack[3] = stack[-1] // @1380 stack[4] = stack[-2] // } // Block ends with call to 0x26fe, returns to 0x1385 label_1385: // Incoming return from call to 0x26FE at 0x1384 1385 5B JUMPDEST 1386 61 PUSH2 0x148b 1389 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x148b label_138A: // Incoming return from call to 0x1385 at 0x1384 // Inputs[1] { @138B stack[-1] } 138A 5B JUMPDEST 138B 80 DUP1 138C 61 PUSH2 0x1394 138F 81 DUP2 1390 61 PUSH2 0x2803 1393 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @138B stack[0] = stack[-1] // @138C stack[1] = 0x1394 // @138F stack[2] = stack[-1] // } // Block ends with call to 0x2803, returns to 0x1394 label_1394: // Incoming return from call to 0x2803 at 0x1393 // Inputs[2] // { // @1395 stack[-3] // @1395 stack[-1] // } 1394 5B JUMPDEST 1395 91 SWAP2 1396 50 POP 1397 50 POP 1398 61 PUSH2 0x1370 139B 56 *JUMP // Stack delta = -2 // Outputs[1] { @1395 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1370 label_139C: // Incoming call from 0x0C2A, returns to 0x0C2B // Inputs[5] // { // @13A0 storage[0x0a] // @13A9 stack[-1] // @13BE memory[0x40:0x60] // @13EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @13ED stack[-2] // } 139C 5B JUMPDEST 139D 60 PUSH1 0x0a 139F 80 DUP1 13A0 54 SLOAD 13A1 60 PUSH1 0x01 13A3 60 PUSH1 0x01 13A5 60 PUSH1 0xa0 13A7 1B SHL 13A8 03 SUB 13A9 83 DUP4 13AA 81 DUP2 13AB 16 AND 13AC 60 PUSH1 0x01 13AE 60 PUSH1 0x01 13B0 60 PUSH1 0xa0 13B2 1B SHL 13B3 03 SUB 13B4 19 NOT 13B5 83 DUP4 13B6 16 AND 13B7 81 DUP2 13B8 17 OR 13B9 90 SWAP1 13BA 93 SWAP4 13BB 55 SSTORE 13BC 60 PUSH1 0x40 13BE 51 MLOAD 13BF 91 SWAP2 13C0 16 AND 13C1 91 SWAP2 13C2 90 SWAP1 13C3 82 DUP3 13C4 90 SWAP1 13C5 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 13E6 90 SWAP1 13E7 60 PUSH1 0x00 13E9 90 SWAP1 13EA A3 LOG3 13EB 50 POP 13EC 50 POP 13ED 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @13BB storage[0x0a] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0a] & ~((0x01 << 0xa0) - 0x01)) // @13EA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 13EE 5B JUMPDEST 13EF 61 PUSH2 0x13f9 13F2 84 DUP5 13F3 84 DUP5 13F4 84 DUP5 13F5 61 PUSH2 0x10ed 13F8 56 *JUMP 13F9 5B JUMPDEST 13FA 61 PUSH2 0x1405 13FD 84 DUP5 13FE 84 DUP5 13FF 84 DUP5 1400 84 DUP5 1401 61 PUSH2 0x14a5 1404 56 *JUMP 1405 5B JUMPDEST 1406 61 PUSH2 0x0da6 1409 57 *JUMPI 140A 60 PUSH1 0x40 140C 51 MLOAD 140D 62 PUSH3 0x461bcd 1411 60 PUSH1 0xe5 1413 1B SHL 1414 81 DUP2 1415 52 MSTORE 1416 60 PUSH1 0x04 1418 01 ADD 1419 61 PUSH2 0x0730 141C 90 SWAP1 141D 61 PUSH2 0x2519 1420 56 *JUMP label_1421: // Incoming jump from 0x0E69 // Inputs[1] { @1427 storage[0x0b] } 1421 5B JUMPDEST 1422 60 PUSH1 0x60 1424 60 PUSH1 0x0b 1426 80 DUP1 1427 54 SLOAD 1428 61 PUSH2 0x0679 142B 90 SWAP1 142C 61 PUSH2 0x27a9 142F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1422 stack[0] = 0x60 // @1424 stack[1] = 0x0b // @142B stack[2] = 0x0679 // @142B stack[3] = storage[0x0b] // } // Block ends with call to 0x27a9, returns to 0x0679 label_1430: // Incoming call from 0x0FCC, returns to 0x0662 // Inputs[1] { @143C stack[-1] } 1430 5B JUMPDEST 1431 60 PUSH1 0x00 1433 60 PUSH1 0x01 1435 60 PUSH1 0x01 1437 60 PUSH1 0xe0 1439 1B SHL 143A 03 SUB 143B 19 NOT 143C 82 DUP3 143D 16 AND 143E 63 PUSH4 0x80ac58cd 1443 60 PUSH1 0xe0 1445 1B SHL 1446 14 EQ 1447 80 DUP1 1448 61 PUSH2 0x1461 144B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1431 stack[0] = 0x00 // @1446 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x1461, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_144C: // Incoming jump from 0x144B, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1456 stack[-3] } 144C 50 POP 144D 60 PUSH1 0x01 144F 60 PUSH1 0x01 1451 60 PUSH1 0xe0 1453 1B SHL 1454 03 SUB 1455 19 NOT 1456 82 DUP3 1457 16 AND 1458 63 PUSH4 0x5b5e139f 145D 60 PUSH1 0xe0 145F 1B SHL 1460 14 EQ 1461 5B JUMPDEST 1462 80 DUP1 1463 61 PUSH2 0x0662 1466 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1460 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0662, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1467: // Incoming jump from 0x1466, if not stack[-1] // Incoming jump from 0x1466, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1479 stack[-3] } 1467 50 POP 1468 63 PUSH4 0x01ffc9a7 146D 60 PUSH1 0xe0 146F 1B SHL 1470 60 PUSH1 0x01 1472 60 PUSH1 0x01 1474 60 PUSH1 0xe0 1476 1B SHL 1477 03 SUB 1478 19 NOT 1479 83 DUP4 147A 16 AND 147B 14 EQ 147C 61 PUSH2 0x0662 147F 56 *JUMP // Stack delta = +0 // Outputs[1] { @147B stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0662 label_1480: // Incoming call from 0x18C2, returns to 0x18C3 // Inputs[3] // { // @1484 stack[-3] // @1485 stack[-2] // @1486 stack[-1] // } 1480 5B JUMPDEST 1481 61 PUSH2 0x0805 1484 83 DUP4 1485 83 DUP4 1486 83 DUP4 1487 61 PUSH2 0x15b2 148A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1481 stack[0] = 0x0805 // @1484 stack[1] = stack[-3] // @1485 stack[2] = stack[-2] // @1486 stack[3] = stack[-1] // } // Block ends with call to 0x15b2, returns to 0x0805 label_148B: // Incoming jump from 0x1389 // Inputs[3] // { // @148F stack[-2] // @1490 stack[-1] // @1493 memory[0x40:0x60] // } 148B 5B JUMPDEST 148C 61 PUSH2 0x0a38 148F 82 DUP3 1490 82 DUP3 1491 60 PUSH1 0x40 1493 51 MLOAD 1494 80 DUP1 1495 60 PUSH1 0x20 1497 01 ADD 1498 60 PUSH1 0x40 149A 52 MSTORE 149B 80 DUP1 149C 60 PUSH1 0x00 149E 81 DUP2 149F 52 MSTORE 14A0 50 POP 14A1 61 PUSH2 0x166f 14A4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @148C stack[0] = 0x0a38 // @148F stack[1] = stack[-2] // @1490 stack[2] = stack[-1] // @1493 stack[3] = memory[0x40:0x60] // @149A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @149F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x166f, returns to 0x0A38 label_14A5: // Incoming call from 0x1685, returns to 0x1686 // Inputs[2] // { // @14B0 stack[-3] // @14B2 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 14A5 5B JUMPDEST 14A6 60 PUSH1 0x00 14A8 60 PUSH1 0x01 14AA 60 PUSH1 0x01 14AC 60 PUSH1 0xa0 14AE 1B SHL 14AF 03 SUB 14B0 84 DUP5 14B1 16 AND 14B2 3B EXTCODESIZE 14B3 15 ISZERO 14B4 61 PUSH2 0x15a7 14B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14A6 stack[0] = 0x00 } // Block ends with conditional jump to 0x15a7, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_14B8: // Incoming jump from 0x14B7, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @14BA memory[0x40:0x60] // @14CD stack[-4] // @14DA msg.sender // @14DC stack[-5] // @14DE stack[-3] // @14E0 stack[-2] // } 14B8 60 PUSH1 0x40 14BA 51 MLOAD 14BB 63 PUSH4 0x0a85bd01 14C0 60 PUSH1 0xe1 14C2 1B SHL 14C3 81 DUP2 14C4 52 MSTORE 14C5 60 PUSH1 0x01 14C7 60 PUSH1 0x01 14C9 60 PUSH1 0xa0 14CB 1B SHL 14CC 03 SUB 14CD 85 DUP6 14CE 16 AND 14CF 90 SWAP1 14D0 63 PUSH4 0x150b7a02 14D5 90 SWAP1 14D6 61 PUSH2 0x14e9 14D9 90 SWAP1 14DA 33 CALLER 14DB 90 SWAP1 14DC 89 DUP10 14DD 90 SWAP1 14DE 88 DUP9 14DF 90 SWAP1 14E0 88 DUP9 14E1 90 SWAP1 14E2 60 PUSH1 0x04 14E4 01 ADD 14E5 61 PUSH2 0x2496 14E8 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @14C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @14CF stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @14D5 stack[1] = 0x150b7a02 // @14D9 stack[2] = 0x14e9 // @14DB stack[3] = msg.sender // @14DD stack[4] = stack[-5] // @14DF stack[5] = stack[-3] // @14E1 stack[6] = stack[-2] // @14E4 stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2496 14E9 5B JUMPDEST 14EA 60 PUSH1 0x20 14EC 60 PUSH1 0x40 14EE 51 MLOAD 14EF 80 DUP1 14F0 83 DUP4 14F1 03 SUB 14F2 81 DUP2 14F3 60 PUSH1 0x00 14F5 87 DUP8 14F6 80 DUP1 14F7 3B EXTCODESIZE 14F8 15 ISZERO 14F9 80 DUP1 14FA 15 ISZERO 14FB 61 PUSH2 0x1503 14FE 57 *JUMPI 14FF 60 PUSH1 0x00 1501 80 DUP1 1502 FD *REVERT 1503 5B JUMPDEST 1504 50 POP 1505 5A GAS 1506 F1 CALL 1507 92 SWAP3 1508 50 POP 1509 50 POP 150A 50 POP 150B 80 DUP1 150C 15 ISZERO 150D 61 PUSH2 0x1533 1510 57 *JUMPI 1511 50 POP 1512 60 PUSH1 0x40 1514 80 DUP1 1515 51 MLOAD 1516 60 PUSH1 0x1f 1518 3D RETURNDATASIZE 1519 90 SWAP1 151A 81 DUP2 151B 01 ADD 151C 60 PUSH1 0x1f 151E 19 NOT 151F 16 AND 1520 82 DUP3 1521 01 ADD 1522 90 SWAP1 1523 92 SWAP3 1524 52 MSTORE 1525 61 PUSH2 0x1530 1528 91 SWAP2 1529 81 DUP2 152A 01 ADD 152B 90 SWAP1 152C 61 PUSH2 0x1d5b 152F 56 *JUMP 1530 5B JUMPDEST 1531 60 PUSH1 0x01 1533 5B JUMPDEST 1534 61 PUSH2 0x158d 1537 57 *JUMPI 1538 3D RETURNDATASIZE 1539 80 DUP1 153A 80 DUP1 153B 15 ISZERO 153C 61 PUSH2 0x1561 153F 57 *JUMPI 1540 60 PUSH1 0x40 1542 51 MLOAD 1543 91 SWAP2 1544 50 POP 1545 60 PUSH1 0x1f 1547 19 NOT 1548 60 PUSH1 0x3f 154A 3D RETURNDATASIZE 154B 01 ADD 154C 16 AND 154D 82 DUP3 154E 01 ADD 154F 60 PUSH1 0x40 1551 52 MSTORE 1552 3D RETURNDATASIZE 1553 82 DUP3 1554 52 MSTORE 1555 3D RETURNDATASIZE 1556 60 PUSH1 0x00 1558 60 PUSH1 0x20 155A 84 DUP5 155B 01 ADD 155C 3E RETURNDATACOPY 155D 61 PUSH2 0x1566 1560 56 *JUMP 1561 5B JUMPDEST 1562 60 PUSH1 0x60 1564 91 SWAP2 1565 50 POP 1566 5B JUMPDEST 1567 50 POP 1568 80 DUP1 1569 51 MLOAD 156A 61 PUSH2 0x1585 156D 57 *JUMPI 156E 60 PUSH1 0x40 1570 51 MLOAD 1571 62 PUSH3 0x461bcd 1575 60 PUSH1 0xe5 1577 1B SHL 1578 81 DUP2 1579 52 MSTORE 157A 60 PUSH1 0x04 157C 01 ADD 157D 61 PUSH2 0x0730 1580 90 SWAP1 1581 61 PUSH2 0x2519 1584 56 *JUMP 1585 5B JUMPDEST 1586 80 DUP1 1587 51 MLOAD 1588 81 DUP2 1589 60 PUSH1 0x20 158B 01 ADD 158C FD *REVERT 158D 5B JUMPDEST 158E 60 PUSH1 0x01 1590 60 PUSH1 0x01 1592 60 PUSH1 0xe0 1594 1B SHL 1595 03 SUB 1596 19 NOT 1597 16 AND 1598 63 PUSH4 0x0a85bd01 159D 60 PUSH1 0xe1 159F 1B SHL 15A0 14 EQ 15A1 90 SWAP1 15A2 50 POP 15A3 61 PUSH2 0x10e5 15A6 56 *JUMP label_15A7: // Incoming jump from 0x14B7, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @15AB stack[-6] // @15AC stack[-5] // } 15A7 5B JUMPDEST 15A8 50 POP 15A9 60 PUSH1 0x01 15AB 94 SWAP5 15AC 93 SWAP4 15AD 50 POP 15AE 50 POP 15AF 50 POP 15B0 50 POP 15B1 56 *JUMP // Stack delta = -5 // Outputs[1] { @15AB stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_15B2: // Incoming call from 0x148A, returns to 0x0805 // Inputs[1] { @15BB stack[-3] } 15B2 5B JUMPDEST 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xa0 15B9 1B SHL 15BA 03 SUB 15BB 83 DUP4 15BC 16 AND 15BD 61 PUSH2 0x160d 15C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x160d, if stack[-3] & (0x01 << 0xa0) - 0x01 label_15C1: // Incoming jump from 0x15C0, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @15C4 stack[-1] // @15C8 storage[0x08] // @15D6 memory[0x00:0x40] // } 15C1 61 PUSH2 0x1608 15C4 81 DUP2 15C5 60 PUSH1 0x08 15C7 80 DUP1 15C8 54 SLOAD 15C9 60 PUSH1 0x00 15CB 83 DUP4 15CC 81 DUP2 15CD 52 MSTORE 15CE 60 PUSH1 0x09 15D0 60 PUSH1 0x20 15D2 52 MSTORE 15D3 60 PUSH1 0x40 15D5 81 DUP2 15D6 20 SHA3 15D7 82 DUP3 15D8 90 SWAP1 15D9 55 SSTORE 15DA 60 PUSH1 0x01 15DC 82 DUP3 15DD 01 ADD 15DE 83 DUP4 15DF 55 SSTORE 15E0 91 SWAP2 15E1 90 SWAP1 15E2 91 SWAP2 15E3 52 MSTORE 15E4 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 1605 01 ADD 1606 55 SSTORE 1607 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @15CD memory[0x00:0x20] = stack[-1] // @15D2 memory[0x20:0x40] = 0x09 // @15D9 storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @15DF storage[0x08] = storage[0x08] + 0x01 // @15E3 memory[0x00:0x20] = 0x08 // @1606 storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x1608 label_1608: // Incoming jump from 0x1607 1608 5B JUMPDEST 1609 61 PUSH2 0x1630 160C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1630 label_160D: // Incoming jump from 0x15C0, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @160E stack[-2] // @1618 stack[-3] // } 160D 5B JUMPDEST 160E 81 DUP2 160F 60 PUSH1 0x01 1611 60 PUSH1 0x01 1613 60 PUSH1 0xa0 1615 1B SHL 1616 03 SUB 1617 16 AND 1618 83 DUP4 1619 60 PUSH1 0x01 161B 60 PUSH1 0x01 161D 60 PUSH1 0xa0 161F 1B SHL 1620 03 SUB 1621 16 AND 1622 14 EQ 1623 61 PUSH2 0x1630 1626 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1630, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_1627: // Incoming jump from 0x1626, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @162A stack[-3] // @162B stack[-1] // } 1627 61 PUSH2 0x1630 162A 83 DUP4 162B 82 DUP3 162C 61 PUSH2 0x16a2 162F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1627 stack[0] = 0x1630 // @162A stack[1] = stack[-3] // @162B stack[2] = stack[-1] // } // Block ends with call to 0x16a2, returns to 0x1630 label_1630: // Incoming jump from 0x1626, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming return from call to 0x16A2 at 0x162F // Incoming jump from 0x160C // Inputs[1] { @1639 stack[-2] } 1630 5B JUMPDEST 1631 60 PUSH1 0x01 1633 60 PUSH1 0x01 1635 60 PUSH1 0xa0 1637 1B SHL 1638 03 SUB 1639 82 DUP3 163A 16 AND 163B 61 PUSH2 0x164c 163E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x164c, if stack[-2] & (0x01 << 0xa0) - 0x01 label_163F: // Incoming jump from 0x163E, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1642 stack[-1] } 163F 61 PUSH2 0x1647 1642 81 DUP2 1643 61 PUSH2 0x173f 1646 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @163F stack[0] = 0x1647 // @1642 stack[1] = stack[-1] // } // Block ends with call to 0x173f, returns to 0x1647 label_1647: // Incoming return from call to 0x173F at 0x1646 1647 5B JUMPDEST 1648 61 PUSH2 0x0805 164B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0805 label_164C: // Incoming jump from 0x163E, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @164D stack[-3] // @1657 stack[-2] // } 164C 5B JUMPDEST 164D 82 DUP3 164E 60 PUSH1 0x01 1650 60 PUSH1 0x01 1652 60 PUSH1 0xa0 1654 1B SHL 1655 03 SUB 1656 16 AND 1657 82 DUP3 1658 60 PUSH1 0x01 165A 60 PUSH1 0x01 165C 60 PUSH1 0xa0 165E 1B SHL 165F 03 SUB 1660 16 AND 1661 14 EQ 1662 61 PUSH2 0x0805 1665 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0805, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_1666: // Incoming jump from 0x1665, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @1669 stack[-2] // @166A stack[-1] // } 1666 61 PUSH2 0x0805 1669 82 DUP3 166A 82 DUP3 166B 61 PUSH2 0x1818 166E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1666 stack[0] = 0x0805 // @1669 stack[1] = stack[-2] // @166A stack[2] = stack[-1] // } // Block ends with call to 0x1818, returns to 0x0805 label_166F: // Incoming call from 0x14A4, returns to 0x0A38 // Inputs[2] // { // @1673 stack[-3] // @1674 stack[-2] // } 166F 5B JUMPDEST 1670 61 PUSH2 0x1679 1673 83 DUP4 1674 83 DUP4 1675 61 PUSH2 0x185c 1678 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1670 stack[0] = 0x1679 // @1673 stack[1] = stack[-3] // @1674 stack[2] = stack[-2] // } // Block ends with call to 0x185c, returns to 0x1679 label_1679: // Incoming return from call to 0x185C at 0x1678 // Inputs[3] // { // @167F stack[-3] // @1680 stack[-2] // @1681 stack[-1] // } 1679 5B JUMPDEST 167A 61 PUSH2 0x1686 167D 60 PUSH1 0x00 167F 84 DUP5 1680 84 DUP5 1681 84 DUP5 1682 61 PUSH2 0x14a5 1685 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @167A stack[0] = 0x1686 // @167D stack[1] = 0x00 // @167F stack[2] = stack[-3] // @1680 stack[3] = stack[-2] // @1681 stack[4] = stack[-1] // } // Block ends with call to 0x14a5, returns to 0x1686 label_1686: // Incoming return from call to 0x14A5 at 0x1685 // Inputs[1] { @168A stack[-1] } 1686 5B JUMPDEST 1687 61 PUSH2 0x0805 168A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0805, if stack[-1] label_168B: // Incoming jump from 0x168A, if not stack[-1] // Inputs[1] { @168D memory[0x40:0x60] } 168B 60 PUSH1 0x40 168D 51 MLOAD 168E 62 PUSH3 0x461bcd 1692 60 PUSH1 0xe5 1694 1B SHL 1695 81 DUP2 1696 52 MSTORE 1697 60 PUSH1 0x04 1699 01 ADD 169A 61 PUSH2 0x0730 169D 90 SWAP1 169E 61 PUSH2 0x2519 16A1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1696 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @169D stack[0] = 0x0730 // @169D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2519 label_16A2: // Incoming call from 0x162F, returns to 0x1630 // Inputs[1] { @16AA stack[-2] } 16A2 5B JUMPDEST 16A3 60 PUSH1 0x00 16A5 60 PUSH1 0x01 16A7 61 PUSH2 0x16af 16AA 84 DUP5 16AB 61 PUSH2 0x0bb3 16AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16A3 stack[0] = 0x00 // @16A5 stack[1] = 0x01 // @16A7 stack[2] = 0x16af // @16AA stack[3] = stack[-2] // } // Block ends with call to 0x0bb3, returns to 0x16AF label_16AF: // Incoming return from call to 0x0BB3 at 0x16AE // Inputs[2] // { // @16B3 stack[-2] // @16B4 stack[-1] // } 16AF 5B JUMPDEST 16B0 61 PUSH2 0x16b9 16B3 91 SWAP2 16B4 90 SWAP1 16B5 61 PUSH2 0x2749 16B8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16B3 stack[-2] = 0x16b9 // @16B4 stack[-1] = stack[-2] // @16B4 stack[0] = stack[-1] // } // Block ends with call to 0x2749, returns to 0x16B9 label_16B9: // Incoming return from call to 0x2749 at 0x16B8 // Inputs[5] // { // @16BC stack[-3] // @16C7 memory[0x00:0x40] // @16C8 storage[keccak256(memory[0x00:0x40])] // @16C9 stack[-1] // @16CA stack[-2] // } 16B9 5B JUMPDEST 16BA 60 PUSH1 0x00 16BC 83 DUP4 16BD 81 DUP2 16BE 52 MSTORE 16BF 60 PUSH1 0x07 16C1 60 PUSH1 0x20 16C3 52 MSTORE 16C4 60 PUSH1 0x40 16C6 90 SWAP1 16C7 20 SHA3 16C8 54 SLOAD 16C9 90 SWAP1 16CA 91 SWAP2 16CB 50 POP 16CC 80 DUP1 16CD 82 DUP3 16CE 14 EQ 16CF 61 PUSH2 0x170c 16D2 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @16BE memory[0x00:0x20] = stack[-3] // @16C3 memory[0x20:0x40] = 0x07 // @16C9 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @16CA stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x170c, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_16D3: // Incoming jump from 0x16D2, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @16DB stack[-4] // @16ED memory[0x00:0x40] // @16EE stack[-2] // @16F5 memory[0x00:0x40] // @16F6 storage[keccak256(memory[0x00:0x40])] // @16F7 stack[-1] // @16FC memory[0x00:0x40] // @1708 memory[0x00:0x40] // @1710 stack[-3] // @171E memory[0x00:0x40] // @1735 memory[0x00:0x40] // @173C memory[0x00:0x40] // @173E stack[-5] // } 16D3 60 PUSH1 0x01 16D5 60 PUSH1 0x01 16D7 60 PUSH1 0xa0 16D9 1B SHL 16DA 03 SUB 16DB 84 DUP5 16DC 16 AND 16DD 60 PUSH1 0x00 16DF 90 SWAP1 16E0 81 DUP2 16E1 52 MSTORE 16E2 60 PUSH1 0x06 16E4 60 PUSH1 0x20 16E6 90 SWAP1 16E7 81 DUP2 16E8 52 MSTORE 16E9 60 PUSH1 0x40 16EB 80 DUP1 16EC 83 DUP4 16ED 20 SHA3 16EE 85 DUP6 16EF 84 DUP5 16F0 52 MSTORE 16F1 82 DUP3 16F2 52 MSTORE 16F3 80 DUP1 16F4 83 DUP4 16F5 20 SHA3 16F6 54 SLOAD 16F7 84 DUP5 16F8 84 DUP5 16F9 52 MSTORE 16FA 81 DUP2 16FB 84 DUP5 16FC 20 SHA3 16FD 81 DUP2 16FE 90 SWAP1 16FF 55 SSTORE 1700 83 DUP4 1701 52 MSTORE 1702 60 PUSH1 0x07 1704 90 SWAP1 1705 91 SWAP2 1706 52 MSTORE 1707 90 SWAP1 1708 20 SHA3 1709 81 DUP2 170A 90 SWAP1 170B 55 SSTORE 170C 5B JUMPDEST 170D 50 POP 170E 60 PUSH1 0x00 1710 91 SWAP2 1711 82 DUP3 1712 52 MSTORE 1713 60 PUSH1 0x07 1715 60 PUSH1 0x20 1717 90 SWAP1 1718 81 DUP2 1719 52 MSTORE 171A 60 PUSH1 0x40 171C 80 DUP1 171D 84 DUP5 171E 20 SHA3 171F 84 DUP5 1720 90 SWAP1 1721 55 SSTORE 1722 60 PUSH1 0x01 1724 60 PUSH1 0x01 1726 60 PUSH1 0xa0 1728 1B SHL 1729 03 SUB 172A 90 SWAP1 172B 94 SWAP5 172C 16 AND 172D 83 DUP4 172E 52 MSTORE 172F 60 PUSH1 0x06 1731 81 DUP2 1732 52 MSTORE 1733 83 DUP4 1734 83 DUP4 1735 20 SHA3 1736 91 SWAP2 1737 83 DUP4 1738 52 MSTORE 1739 52 MSTORE 173A 90 SWAP1 173B 81 DUP2 173C 20 SHA3 173D 55 SSTORE 173E 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @16E1 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @16E8 memory[0x20:0x40] = 0x06 // @16F0 memory[0x00:0x20] = stack[-2] // @16F2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @16F9 memory[0x00:0x20] = stack[-1] // @16FF storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @1701 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @1706 memory[0x20:0x40] = 0x07 // @170B storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1712 memory[0x00:0x20] = stack[-3] // @1719 memory[0x20:0x40] = 0x07 // @1721 storage[keccak256(memory[0x00:0x40])] = 0x00 // @172E memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1732 memory[0x20:0x40] = 0x06 // @1738 memory[0x00:0x20] = stack[-2] // @1739 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @173D storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_173F: // Incoming call from 0x1646, returns to 0x1647 // Inputs[1] { @1742 storage[0x08] } 173F 5B JUMPDEST 1740 60 PUSH1 0x08 1742 54 SLOAD 1743 60 PUSH1 0x00 1745 90 SWAP1 1746 61 PUSH2 0x1751 1749 90 SWAP1 174A 60 PUSH1 0x01 174C 90 SWAP1 174D 61 PUSH2 0x2749 1750 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1745 stack[0] = 0x00 // @1749 stack[1] = 0x1751 // @174C stack[2] = 0x01 // @174C stack[3] = storage[0x08] // } // Block ends with call to 0x2749, returns to 0x1751 label_1751: // Incoming return from call to 0x2749 at 0x1750 // Inputs[6] // { // @1754 stack[-3] // @175F memory[0x00:0x40] // @1760 storage[keccak256(memory[0x00:0x40])] // @1764 storage[0x08] // @1765 stack[-1] // @1766 stack[-2] // } 1751 5B JUMPDEST 1752 60 PUSH1 0x00 1754 83 DUP4 1755 81 DUP2 1756 52 MSTORE 1757 60 PUSH1 0x09 1759 60 PUSH1 0x20 175B 52 MSTORE 175C 60 PUSH1 0x40 175E 81 DUP2 175F 20 SHA3 1760 54 SLOAD 1761 60 PUSH1 0x08 1763 80 DUP1 1764 54 SLOAD 1765 93 SWAP4 1766 94 SWAP5 1767 50 POP 1768 90 SWAP1 1769 92 SWAP3 176A 84 DUP5 176B 90 SWAP1 176C 81 DUP2 176D 10 LT 176E 61 PUSH2 0x1787 1771 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1752 stack[0] = 0x00 // @1756 memory[0x00:0x20] = stack[-3] // @175B memory[0x20:0x40] = 0x09 // @1766 stack[-2] = stack[-1] // @1768 stack[1] = 0x08 // @1769 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @176B stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1787, if stack[-1] < storage[0x08] label_1772: // Incoming jump from 0x1771, if not stack[-1] < storage[0x08] // Inputs[1] { @1786 memory[0x00:0x24] } 1772 63 PUSH4 0x4e487b71 1777 60 PUSH1 0xe0 1779 1B SHL 177A 60 PUSH1 0x00 177C 52 MSTORE 177D 60 PUSH1 0x32 177F 60 PUSH1 0x04 1781 52 MSTORE 1782 60 PUSH1 0x24 1784 60 PUSH1 0x00 1786 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @177C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1781 memory[0x04:0x24] = 0x32 // @1786 revert(memory[0x00:0x24]); // } // Block terminates label_1787: // Incoming jump from 0x1771, if stack[-1] < storage[0x08] // Inputs[7] // { // @1788 stack[-1] // @1788 stack[-2] // @1790 memory[0x00:0x20] // @1792 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1793 stack[-3] // @1798 stack[-4] // @179A storage[0x08] // } 1787 5B JUMPDEST 1788 90 SWAP1 1789 60 PUSH1 0x00 178B 52 MSTORE 178C 60 PUSH1 0x20 178E 60 PUSH1 0x00 1790 20 SHA3 1791 01 ADD 1792 54 SLOAD 1793 90 SWAP1 1794 50 POP 1795 80 DUP1 1796 60 PUSH1 0x08 1798 83 DUP4 1799 81 DUP2 179A 54 SLOAD 179B 81 DUP2 179C 10 LT 179D 61 PUSH2 0x17b6 17A0 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @178B memory[0x00:0x20] = stack[-2] // @1793 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1795 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1796 stack[-1] = 0x08 // @1798 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x17b6, if stack[-4] < storage[0x08] label_17A1: // Incoming jump from 0x17A0, if not stack[-4] < storage[0x08] // Inputs[1] { @17B5 memory[0x00:0x24] } 17A1 63 PUSH4 0x4e487b71 17A6 60 PUSH1 0xe0 17A8 1B SHL 17A9 60 PUSH1 0x00 17AB 52 MSTORE 17AC 60 PUSH1 0x32 17AE 60 PUSH1 0x04 17B0 52 MSTORE 17B1 60 PUSH1 0x24 17B3 60 PUSH1 0x00 17B5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @17AB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @17B0 memory[0x04:0x24] = 0x32 // @17B5 revert(memory[0x00:0x24]); // } // Block terminates label_17B6: // Incoming jump from 0x17A0, if stack[-4] < storage[0x08] // Inputs[10] // { // @17B9 stack[-2] // @17C0 memory[0x00:0x20] // @17C2 stack[-1] // @17C4 stack[-3] // @17C8 stack[-4] // @17D4 memory[0x00:0x40] // @17D5 stack[-5] // @17D8 stack[-7] // @17DC memory[0x00:0x40] // @17E1 storage[0x08] // } 17B6 5B JUMPDEST 17B7 60 PUSH1 0x00 17B9 91 SWAP2 17BA 82 DUP3 17BB 52 MSTORE 17BC 60 PUSH1 0x20 17BE 80 DUP1 17BF 83 DUP4 17C0 20 SHA3 17C1 90 SWAP1 17C2 91 SWAP2 17C3 01 ADD 17C4 92 SWAP3 17C5 90 SWAP1 17C6 92 SWAP3 17C7 55 SSTORE 17C8 82 DUP3 17C9 81 DUP2 17CA 52 MSTORE 17CB 60 PUSH1 0x09 17CD 90 SWAP1 17CE 91 SWAP2 17CF 52 MSTORE 17D0 60 PUSH1 0x40 17D2 80 DUP1 17D3 82 DUP3 17D4 20 SHA3 17D5 84 DUP5 17D6 90 SWAP1 17D7 55 SSTORE 17D8 85 DUP6 17D9 82 DUP3 17DA 52 MSTORE 17DB 81 DUP2 17DC 20 SHA3 17DD 55 SSTORE 17DE 60 PUSH1 0x08 17E0 80 DUP1 17E1 54 SLOAD 17E2 80 DUP1 17E3 61 PUSH2 0x17fc 17E6 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @17BB memory[0x00:0x20] = stack[-2] // @17C7 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @17CA memory[0x00:0x20] = stack[-4] // @17CF memory[0x20:0x40] = 0x09 // @17D7 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @17DA memory[0x00:0x20] = stack[-7] // @17DD storage[keccak256(memory[0x00:0x40])] = 0x00 // @17DE stack[-3] = 0x08 // @17E1 stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x17fc, if storage[0x08] label_17E7: // Incoming jump from 0x17E6, if not storage[0x08] // Inputs[1] { @17FB memory[0x00:0x24] } 17E7 63 PUSH4 0x4e487b71 17EC 60 PUSH1 0xe0 17EE 1B SHL 17EF 60 PUSH1 0x00 17F1 52 MSTORE 17F2 60 PUSH1 0x31 17F4 60 PUSH1 0x04 17F6 52 MSTORE 17F7 60 PUSH1 0x24 17F9 60 PUSH1 0x00 17FB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @17F1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @17F6 memory[0x04:0x24] = 0x31 // @17FB revert(memory[0x00:0x24]); // } // Block terminates label_17FC: // Incoming jump from 0x17E6, if storage[0x08] // Inputs[4] // { // @17FF stack[-1] // @1801 stack[-2] // @180B memory[0x00:0x20] // @1817 stack[-7] // } 17FC 5B JUMPDEST 17FD 60 PUSH1 0x01 17FF 90 SWAP1 1800 03 SUB 1801 81 DUP2 1802 81 DUP2 1803 90 SWAP1 1804 60 PUSH1 0x00 1806 52 MSTORE 1807 60 PUSH1 0x20 1809 60 PUSH1 0x00 180B 20 SHA3 180C 01 ADD 180D 60 PUSH1 0x00 180F 90 SWAP1 1810 55 SSTORE 1811 90 SWAP1 1812 55 SSTORE 1813 50 POP 1814 50 POP 1815 50 POP 1816 50 POP 1817 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1806 memory[0x00:0x20] = stack[-2] // @1810 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @1812 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_1818: // Incoming call from 0x166E, returns to 0x0805 // Inputs[1] { @181E stack[-2] } 1818 5B JUMPDEST 1819 60 PUSH1 0x00 181B 61 PUSH2 0x1823 181E 83 DUP4 181F 61 PUSH2 0x0bb3 1822 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1819 stack[0] = 0x00 // @181B stack[1] = 0x1823 // @181E stack[2] = stack[-2] // } // Block ends with call to 0x0bb3, returns to 0x1823 label_1823: // Incoming return from call to 0x0BB3 at 0x1822 // Inputs[8] // { // @182C stack[-1] // @182D stack[-4] // @183F memory[0x00:0x40] // @1847 memory[0x00:0x40] // @1848 stack[-3] // @1853 stack[-2] // @1855 memory[0x00:0x40] // @185B stack[-5] // } 1823 5B JUMPDEST 1824 60 PUSH1 0x01 1826 60 PUSH1 0x01 1828 60 PUSH1 0xa0 182A 1B SHL 182B 03 SUB 182C 90 SWAP1 182D 93 SWAP4 182E 16 AND 182F 60 PUSH1 0x00 1831 90 SWAP1 1832 81 DUP2 1833 52 MSTORE 1834 60 PUSH1 0x06 1836 60 PUSH1 0x20 1838 90 SWAP1 1839 81 DUP2 183A 52 MSTORE 183B 60 PUSH1 0x40 183D 80 DUP1 183E 83 DUP4 183F 20 SHA3 1840 86 DUP7 1841 84 DUP5 1842 52 MSTORE 1843 82 DUP3 1844 52 MSTORE 1845 80 DUP1 1846 83 DUP4 1847 20 SHA3 1848 85 DUP6 1849 90 SWAP1 184A 55 SSTORE 184B 93 SWAP4 184C 82 DUP3 184D 52 MSTORE 184E 60 PUSH1 0x07 1850 90 SWAP1 1851 52 MSTORE 1852 91 SWAP2 1853 90 SWAP1 1854 91 SWAP2 1855 20 SHA3 1856 91 SWAP2 1857 90 SWAP1 1858 91 SWAP2 1859 55 SSTORE 185A 50 POP 185B 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @1833 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @183A memory[0x20:0x40] = 0x06 // @1842 memory[0x00:0x20] = stack[-1] // @1844 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @184A storage[keccak256(memory[0x00:0x40])] = stack[-3] // @184D memory[0x00:0x20] = stack[-3] // @1851 memory[0x20:0x40] = 0x07 // @1859 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_185C: // Incoming call from 0x1678, returns to 0x1679 // Inputs[1] { @1865 stack[-2] } 185C 5B JUMPDEST 185D 60 PUSH1 0x01 185F 60 PUSH1 0x01 1861 60 PUSH1 0xa0 1863 1B SHL 1864 03 SUB 1865 82 DUP3 1866 16 AND 1867 61 PUSH2 0x1882 186A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1882, if stack[-2] & (0x01 << 0xa0) - 0x01 label_186B: // Incoming jump from 0x186A, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @186D memory[0x40:0x60] } 186B 60 PUSH1 0x40 186D 51 MLOAD 186E 62 PUSH3 0x461bcd 1872 60 PUSH1 0xe5 1874 1B SHL 1875 81 DUP2 1876 52 MSTORE 1877 60 PUSH1 0x04 1879 01 ADD 187A 61 PUSH2 0x0730 187D 90 SWAP1 187E 61 PUSH2 0x25b9 1881 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1876 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @187D stack[0] = 0x0730 // @187D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x25b9 label_1882: // Incoming jump from 0x186A, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1885 stack[-1] // @1890 memory[0x00:0x40] // @1891 storage[keccak256(memory[0x00:0x40])] // } 1882 5B JUMPDEST 1883 60 PUSH1 0x00 1885 81 DUP2 1886 81 DUP2 1887 52 MSTORE 1888 60 PUSH1 0x02 188A 60 PUSH1 0x20 188C 52 MSTORE 188D 60 PUSH1 0x40 188F 90 SWAP1 1890 20 SHA3 1891 54 SLOAD 1892 60 PUSH1 0x01 1894 60 PUSH1 0x01 1896 60 PUSH1 0xa0 1898 1B SHL 1899 03 SUB 189A 16 AND 189B 15 ISZERO 189C 61 PUSH2 0x18b7 189F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1887 memory[0x00:0x20] = stack[-1] // @188C memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x18b7, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_18A0: // Incoming jump from 0x189F, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @18A2 memory[0x40:0x60] } 18A0 60 PUSH1 0x40 18A2 51 MLOAD 18A3 62 PUSH3 0x461bcd 18A7 60 PUSH1 0xe5 18A9 1B SHL 18AA 81 DUP2 18AB 52 MSTORE 18AC 60 PUSH1 0x04 18AE 01 ADD 18AF 61 PUSH2 0x0730 18B2 90 SWAP1 18B3 61 PUSH2 0x2539 18B6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18B2 stack[0] = 0x0730 // @18B2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2539 label_18B7: // Incoming jump from 0x189F, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @18BD stack[-2] // @18BE stack[-1] // } 18B7 5B JUMPDEST 18B8 61 PUSH2 0x18c3 18BB 60 PUSH1 0x00 18BD 83 DUP4 18BE 83 DUP4 18BF 61 PUSH2 0x1480 18C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18B8 stack[0] = 0x18c3 // @18BB stack[1] = 0x00 // @18BD stack[2] = stack[-2] // @18BE stack[3] = stack[-1] // } // Block ends with call to 0x1480, returns to 0x18C3 label_18C3: // Incoming return from call to 0x1480 at 0x18C2 // Inputs[3] // { // @18CC stack[-2] // @18DB memory[0x00:0x40] // @18DD storage[keccak256(memory[0x00:0x40])] // } 18C3 5B JUMPDEST 18C4 60 PUSH1 0x01 18C6 60 PUSH1 0x01 18C8 60 PUSH1 0xa0 18CA 1B SHL 18CB 03 SUB 18CC 82 DUP3 18CD 16 AND 18CE 60 PUSH1 0x00 18D0 90 SWAP1 18D1 81 DUP2 18D2 52 MSTORE 18D3 60 PUSH1 0x03 18D5 60 PUSH1 0x20 18D7 52 MSTORE 18D8 60 PUSH1 0x40 18DA 81 DUP2 18DB 20 SHA3 18DC 80 DUP1 18DD 54 SLOAD 18DE 60 PUSH1 0x01 18E0 92 SWAP3 18E1 90 SWAP1 18E2 61 PUSH2 0x18ec 18E5 90 SWAP1 18E6 84 DUP5 18E7 90 SWAP1 18E8 61 PUSH2 0x26fe 18EB 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @18D2 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @18D7 memory[0x20:0x40] = 0x03 // @18DB stack[1] = keccak256(memory[0x00:0x40]) // @18E0 stack[0] = 0x01 // @18E1 stack[2] = 0x00 // @18E5 stack[3] = 0x18ec // @18E7 stack[4] = 0x01 // @18E7 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x26fe, returns to 0x18EC label_18EC: // Incoming return from call to 0x26FE at 0x18EB // Inputs[10] // { // @18ED stack[-2] // @18ED stack[-1] // @18EE stack[-3] // @18F4 stack[-5] // @1900 memory[0x00:0x40] // @1902 storage[keccak256(memory[0x00:0x40])] // @1915 stack[-6] // @191E memory[0x40:0x60] // @1946 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1949 stack[-7] // } 18EC 5B JUMPDEST 18ED 90 SWAP1 18EE 91 SWAP2 18EF 55 SSTORE 18F0 50 POP 18F1 50 POP 18F2 60 PUSH1 0x00 18F4 81 DUP2 18F5 81 DUP2 18F6 52 MSTORE 18F7 60 PUSH1 0x02 18F9 60 PUSH1 0x20 18FB 52 MSTORE 18FC 60 PUSH1 0x40 18FE 80 DUP1 18FF 82 DUP3 1900 20 SHA3 1901 80 DUP1 1902 54 SLOAD 1903 60 PUSH1 0x01 1905 60 PUSH1 0x01 1907 60 PUSH1 0xa0 1909 1B SHL 190A 03 SUB 190B 19 NOT 190C 16 AND 190D 60 PUSH1 0x01 190F 60 PUSH1 0x01 1911 60 PUSH1 0xa0 1913 1B SHL 1914 03 SUB 1915 86 DUP7 1916 16 AND 1917 90 SWAP1 1918 81 DUP2 1919 17 OR 191A 90 SWAP1 191B 91 SWAP2 191C 55 SSTORE 191D 90 SWAP1 191E 51 MLOAD 191F 83 DUP4 1920 92 SWAP3 1921 90 SWAP1 1922 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1943 90 SWAP1 1944 82 DUP3 1945 90 SWAP1 1946 A4 LOG4 1947 50 POP 1948 50 POP 1949 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @18EF storage[stack[-3]] = stack[-1] // @18F6 memory[0x00:0x20] = stack[-5] // @18FB memory[0x20:0x40] = 0x02 // @191C storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1946 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] 194A 5B JUMPDEST 194B 82 DUP3 194C 80 DUP1 194D 54 SLOAD 194E 61 PUSH2 0x1956 1951 90 SWAP1 1952 61 PUSH2 0x27a9 1955 56 *JUMP 1956 5B JUMPDEST 1957 90 SWAP1 1958 60 PUSH1 0x00 195A 52 MSTORE 195B 60 PUSH1 0x20 195D 60 PUSH1 0x00 195F 20 SHA3 1960 90 SWAP1 1961 60 PUSH1 0x1f 1963 01 ADD 1964 60 PUSH1 0x20 1966 90 SWAP1 1967 04 DIV 1968 81 DUP2 1969 01 ADD 196A 92 SWAP3 196B 82 DUP3 196C 61 PUSH2 0x1978 196F 57 *JUMPI 1970 60 PUSH1 0x00 1972 85 DUP6 1973 55 SSTORE 1974 61 PUSH2 0x19be 1977 56 *JUMP 1978 5B JUMPDEST 1979 82 DUP3 197A 60 PUSH1 0x1f 197C 10 LT 197D 61 PUSH2 0x1991 1980 57 *JUMPI 1981 80 DUP1 1982 51 MLOAD 1983 60 PUSH1 0xff 1985 19 NOT 1986 16 AND 1987 83 DUP4 1988 80 DUP1 1989 01 ADD 198A 17 OR 198B 85 DUP6 198C 55 SSTORE 198D 61 PUSH2 0x19be 1990 56 *JUMP 1991 5B JUMPDEST 1992 82 DUP3 1993 80 DUP1 1994 01 ADD 1995 60 PUSH1 0x01 1997 01 ADD 1998 85 DUP6 1999 55 SSTORE 199A 82 DUP3 199B 15 ISZERO 199C 61 PUSH2 0x19be 199F 57 *JUMPI 19A0 91 SWAP2 19A1 82 DUP3 19A2 01 ADD 19A3 5B JUMPDEST 19A4 82 DUP3 19A5 81 DUP2 19A6 11 GT 19A7 15 ISZERO 19A8 61 PUSH2 0x19be 19AB 57 *JUMPI 19AC 82 DUP3 19AD 51 MLOAD 19AE 82 DUP3 19AF 55 SSTORE 19B0 91 SWAP2 19B1 60 PUSH1 0x20 19B3 01 ADD 19B4 91 SWAP2 19B5 90 SWAP1 19B6 60 PUSH1 0x01 19B8 01 ADD 19B9 90 SWAP1 19BA 61 PUSH2 0x19a3 19BD 56 *JUMP 19BE 5B JUMPDEST 19BF 50 POP 19C0 61 PUSH2 0x19ca 19C3 92 SWAP3 19C4 91 SWAP2 19C5 50 POP 19C6 61 PUSH2 0x19ce 19C9 56 *JUMP 19CA 5B JUMPDEST 19CB 50 POP 19CC 90 SWAP1 19CD 56 *JUMP 19CE 5B JUMPDEST 19CF 5B JUMPDEST 19D0 80 DUP1 19D1 82 DUP3 19D2 11 GT 19D3 15 ISZERO 19D4 61 PUSH2 0x19ca 19D7 57 *JUMPI 19D8 60 PUSH1 0x00 19DA 81 DUP2 19DB 55 SSTORE 19DC 60 PUSH1 0x01 19DE 01 ADD 19DF 61 PUSH2 0x19cf 19E2 56 *JUMP label_19E3: // Incoming call from 0x1AFC, returns to 0x10E5 // Inputs[1] { @19EC stack[-2] } 19E3 5B JUMPDEST 19E4 60 PUSH1 0x00 19E6 61 PUSH2 0x19f6 19E9 61 PUSH2 0x19f1 19EC 84 DUP5 19ED 61 PUSH2 0x268e 19F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19E4 stack[0] = 0x00 // @19E6 stack[1] = 0x19f6 // @19E9 stack[2] = 0x19f1 // @19EC stack[3] = stack[-2] // } // Block ends with call to 0x268e, returns to 0x19F1 label_19F1: // Incoming return from call to 0x26D3 at 0x1AA8 // Incoming return from call to 0x26AF at 0x1A4F // Incoming return from call to 0x268E at 0x19F0 19F1 5B JUMPDEST 19F2 61 PUSH2 0x2677 19F5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2677 label_19F6: // Incoming return from call to 0x19F1 at 0x19F0 // Inputs[5] // { // @19F7 stack[-1] // @19F7 stack[-2] // @19FA stack[-3] // @19FB stack[-5] // @19FE stack[-4] // } 19F6 5B JUMPDEST 19F7 90 SWAP1 19F8 50 POP 19F9 80 DUP1 19FA 82 DUP3 19FB 85 DUP6 19FC 60 PUSH1 0x20 19FE 86 DUP7 19FF 02 MUL 1A00 82 DUP3 1A01 01 ADD 1A02 11 GT 1A03 15 ISZERO 1A04 61 PUSH2 0x1a0c 1A07 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @19F7 stack[-2] = stack[-1] // @19F9 stack[-1] = stack[-1] // @19FA stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1a0c, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_1A08: // Incoming jump from 0x1A07, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1A0B memory[0x00:0x00] } 1A08 60 PUSH1 0x00 1A0A 80 DUP1 1A0B FD *REVERT // Stack delta = +0 // Outputs[1] { @1A0B revert(memory[0x00:0x00]); } // Block terminates label_1A0C: // Incoming jump from 0x1A07, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1A10 stack[-5] } 1A0C 5B JUMPDEST 1A0D 60 PUSH1 0x00 1A0F 5B JUMPDEST 1A10 85 DUP6 1A11 81 DUP2 1A12 10 LT 1A13 15 ISZERO 1A14 61 PUSH2 0x1a38 1A17 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A0D stack[0] = 0x00 } // Block ends with conditional jump to 0x1a38, if !(0x00 < stack[-5]) label_1A18: // Incoming jump from 0x1A17, if not !(0x00 < stack[-5]) // Inputs[2] // { // @1A18 stack[-2] // @1A1C stack[-7] // } 1A18 81 DUP2 1A19 61 PUSH2 0x1a22 1A1C 88 DUP9 1A1D 82 DUP3 1A1E 61 PUSH2 0x1ad4 1A21 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A18 stack[0] = stack[-2] // @1A19 stack[1] = 0x1a22 // @1A1C stack[2] = stack[-7] // @1A1D stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1ad4 1A22 5B JUMPDEST 1A23 84 DUP5 1A24 52 MSTORE 1A25 50 POP 1A26 60 PUSH1 0x20 1A28 92 SWAP3 1A29 83 DUP4 1A2A 01 ADD 1A2B 92 SWAP3 1A2C 91 SWAP2 1A2D 90 SWAP1 1A2E 91 SWAP2 1A2F 01 ADD 1A30 90 SWAP1 1A31 60 PUSH1 0x01 1A33 01 ADD 1A34 61 PUSH2 0x1a0f 1A37 56 *JUMP label_1A38: // Incoming jump from 0x1A7A, if !(0x00 < stack[-5]) // Incoming jump from 0x1A17, if !(0x00 < stack[-5]) // Inputs[3] // { // @1A3C stack[-8] // @1A3C stack[-4] // @1A3D stack[-7] // } 1A38 5B JUMPDEST 1A39 50 POP 1A3A 50 POP 1A3B 50 POP 1A3C 93 SWAP4 1A3D 92 SWAP3 1A3E 50 POP 1A3F 50 POP 1A40 50 POP 1A41 56 *JUMP // Stack delta = -7 // Outputs[1] { @1A3C stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_1A42: // Incoming call from 0x1B1D, returns to 0x10E5 // Inputs[1] { @1A4B stack[-2] } 1A42 5B JUMPDEST 1A43 60 PUSH1 0x00 1A45 61 PUSH2 0x1a50 1A48 61 PUSH2 0x19f1 1A4B 84 DUP5 1A4C 61 PUSH2 0x26af 1A4F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A43 stack[0] = 0x00 // @1A45 stack[1] = 0x1a50 // @1A48 stack[2] = 0x19f1 // @1A4B stack[3] = stack[-2] // } // Block ends with call to 0x26af, returns to 0x19F1 label_1A50: // Incoming return from call to 0x19F1 at 0x1A4F // Inputs[5] // { // @1A51 stack[-2] // @1A51 stack[-1] // @1A54 stack[-4] // @1A5D stack[-3] // @1A5E stack[-5] // } 1A50 5B JUMPDEST 1A51 90 SWAP1 1A52 50 POP 1A53 80 DUP1 1A54 83 DUP4 1A55 82 DUP3 1A56 52 MSTORE 1A57 60 PUSH1 0x20 1A59 82 DUP3 1A5A 01 ADD 1A5B 90 SWAP1 1A5C 50 POP 1A5D 82 DUP3 1A5E 85 DUP6 1A5F 60 PUSH1 0x20 1A61 86 DUP7 1A62 02 MUL 1A63 82 DUP3 1A64 01 ADD 1A65 11 GT 1A66 15 ISZERO 1A67 61 PUSH2 0x1a6f 1A6A 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1A51 stack[-2] = stack[-1] // @1A56 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1A5B stack[-1] = stack[-1] + 0x20 // @1A5D stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1a6f, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_1A6B: // Incoming jump from 0x1A6A, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1A6E memory[0x00:0x00] } 1A6B 60 PUSH1 0x00 1A6D 80 DUP1 1A6E FD *REVERT // Stack delta = +0 // Outputs[1] { @1A6E revert(memory[0x00:0x00]); } // Block terminates label_1A6F: // Incoming jump from 0x1A6A, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @1A73 stack[-5] } 1A6F 5B JUMPDEST 1A70 60 PUSH1 0x00 1A72 5B JUMPDEST 1A73 85 DUP6 1A74 81 DUP2 1A75 10 LT 1A76 15 ISZERO 1A77 61 PUSH2 0x1a38 1A7A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A70 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a38, if !(0x00 < stack[-5]) label_1A7B: // Incoming jump from 0x1A7A, if not !(0x00 < stack[-5]) // Inputs[2] // { // @1A7B stack[-2] // @1A7F stack[-7] // } 1A7B 81 DUP2 1A7C 61 PUSH2 0x1a85 1A7F 88 DUP9 1A80 82 DUP3 1A81 61 PUSH2 0x1ad4 1A84 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A7B stack[0] = stack[-2] // @1A7C stack[1] = 0x1a85 // @1A7F stack[2] = stack[-7] // @1A80 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1ad4 1A85 5B JUMPDEST 1A86 84 DUP5 1A87 52 MSTORE 1A88 50 POP 1A89 60 PUSH1 0x20 1A8B 92 SWAP3 1A8C 83 DUP4 1A8D 01 ADD 1A8E 92 SWAP3 1A8F 91 SWAP2 1A90 90 SWAP1 1A91 91 SWAP2 1A92 01 ADD 1A93 90 SWAP1 1A94 60 PUSH1 0x01 1A96 01 ADD 1A97 61 PUSH2 0x1a72 1A9A 56 *JUMP label_1A9B: // Incoming call from 0x1B5F, returns to 0x10E5 // Inputs[1] { @1AA4 stack[-2] } 1A9B 5B JUMPDEST 1A9C 60 PUSH1 0x00 1A9E 61 PUSH2 0x1aa9 1AA1 61 PUSH2 0x19f1 1AA4 84 DUP5 1AA5 61 PUSH2 0x26d3 1AA8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A9C stack[0] = 0x00 // @1A9E stack[1] = 0x1aa9 // @1AA1 stack[2] = 0x19f1 // @1AA4 stack[3] = stack[-2] // } // Block ends with call to 0x26d3, returns to 0x19F1 label_1AA9: // Incoming return from call to 0x19F1 at 0x1AA8 // Inputs[5] // { // @1AAA stack[-1] // @1AAA stack[-2] // @1AAC stack[-4] // @1AB3 stack[-5] // @1AB5 stack[-3] // } 1AA9 5B JUMPDEST 1AAA 90 SWAP1 1AAB 50 POP 1AAC 82 DUP3 1AAD 81 DUP2 1AAE 52 MSTORE 1AAF 60 PUSH1 0x20 1AB1 81 DUP2 1AB2 01 ADD 1AB3 84 DUP5 1AB4 84 DUP5 1AB5 84 DUP5 1AB6 01 ADD 1AB7 11 GT 1AB8 15 ISZERO 1AB9 61 PUSH2 0x1ac1 1ABC 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1AAA stack[-2] = stack[-1] // @1AAE memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1AB2 stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1ac1, if !(stack[-3] + stack[-4] > stack[-5]) label_1ABD: // Incoming jump from 0x1ABC, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1AC0 memory[0x00:0x00] } 1ABD 60 PUSH1 0x00 1ABF 80 DUP1 1AC0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC0 revert(memory[0x00:0x00]); } // Block terminates label_1AC1: // Incoming jump from 0x1ABC, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @1AC5 stack[-4] // @1AC6 stack[-1] // @1AC7 stack[-3] // } 1AC1 5B JUMPDEST 1AC2 61 PUSH2 0x1acc 1AC5 84 DUP5 1AC6 82 DUP3 1AC7 85 DUP6 1AC8 61 PUSH2 0x2771 1ACB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AC2 stack[0] = 0x1acc // @1AC5 stack[1] = stack[-4] // @1AC6 stack[2] = stack[-1] // @1AC7 stack[3] = stack[-3] // } // Block ends with call to 0x2771, returns to 0x1ACC label_1ACC: // Incoming return from call to 0x2771 at 0x1ACB // Inputs[3] // { // @1ACE stack[-6] // @1ACE stack[-2] // @1ACF stack[-5] // } 1ACC 5B JUMPDEST 1ACD 50 POP 1ACE 93 SWAP4 1ACF 92 SWAP3 1AD0 50 POP 1AD1 50 POP 1AD2 50 POP 1AD3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1ACE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1AD4: // Incoming jump from 0x1A21 // Incoming jump from 0x1CD7 // Incoming jump from 0x1A84 // Incoming jump from 0x1C31 // Incoming jump from 0x1B88 // Incoming jump from 0x1BA7 // Incoming jump from 0x1CA7 // Incoming jump from 0x1BE3 // Inputs[2] // { // @1AD5 stack[-1] // @1AD6 msg.data[stack[-1]:stack[-1] + 0x20] // } 1AD4 5B JUMPDEST 1AD5 80 DUP1 1AD6 35 CALLDATALOAD 1AD7 61 PUSH2 0x088a 1ADA 81 DUP2 1ADB 61 PUSH2 0x2883 1ADE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AD6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AD7 stack[1] = 0x088a // @1ADA stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2883 label_1ADF: // Incoming call from 0x1D06, returns to 0x10E5 // Inputs[2] // { // @1AE2 stack[-2] // @1AE5 stack[-1] // } 1ADF 5B JUMPDEST 1AE0 60 PUSH1 0x00 1AE2 82 DUP3 1AE3 60 PUSH1 0x1f 1AE5 83 DUP4 1AE6 01 ADD 1AE7 12 SLT 1AE8 61 PUSH2 0x1af0 1AEB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AE0 stack[0] = 0x00 } // Block ends with conditional jump to 0x1af0, if stack[-1] + 0x1f i< stack[-2] label_1AEC: // Incoming jump from 0x1AEB, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1AEF memory[0x00:0x00] } 1AEC 60 PUSH1 0x00 1AEE 80 DUP1 1AEF FD *REVERT // Stack delta = +0 // Outputs[1] { @1AEF revert(memory[0x00:0x00]); } // Block terminates label_1AF0: // Incoming jump from 0x1AEB, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1AF6 stack[-3] // @1AF8 stack[-2] // } 1AF0 5B JUMPDEST 1AF1 60 PUSH1 0x02 1AF3 61 PUSH2 0x10e5 1AF6 84 DUP5 1AF7 82 DUP3 1AF8 85 DUP6 1AF9 61 PUSH2 0x19e3 1AFC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1AF1 stack[0] = 0x02 // @1AF3 stack[1] = 0x10e5 // @1AF6 stack[2] = stack[-3] // @1AF7 stack[3] = 0x02 // @1AF8 stack[4] = stack[-2] // } // Block ends with call to 0x19e3, returns to 0x10E5 label_1AFD: // Incoming call from 0x1D3C, returns to 0x1CD8 // Inputs[2] // { // @1B00 stack[-2] // @1B03 stack[-1] // } 1AFD 5B JUMPDEST 1AFE 60 PUSH1 0x00 1B00 82 DUP3 1B01 60 PUSH1 0x1f 1B03 83 DUP4 1B04 01 ADD 1B05 12 SLT 1B06 61 PUSH2 0x1b0e 1B09 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AFE stack[0] = 0x00 } // Block ends with conditional jump to 0x1b0e, if stack[-1] + 0x1f i< stack[-2] label_1B0A: // Incoming jump from 0x1B09, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1B0D memory[0x00:0x00] } 1B0A 60 PUSH1 0x00 1B0C 80 DUP1 1B0D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B0D revert(memory[0x00:0x00]); } // Block terminates label_1B0E: // Incoming jump from 0x1B09, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1B0F stack[-2] // @1B10 msg.data[stack[-2]:stack[-2] + 0x20] // @1B14 stack[-3] // } 1B0E 5B JUMPDEST 1B0F 81 DUP2 1B10 35 CALLDATALOAD 1B11 61 PUSH2 0x10e5 1B14 84 DUP5 1B15 82 DUP3 1B16 60 PUSH1 0x20 1B18 86 DUP7 1B19 01 ADD 1B1A 61 PUSH2 0x1a42 1B1D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1B10 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B11 stack[1] = 0x10e5 // @1B14 stack[2] = stack[-3] // @1B15 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B19 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1a42, returns to 0x10E5 1B1E 5B JUMPDEST 1B1F 80 DUP1 1B20 35 CALLDATALOAD 1B21 61 PUSH2 0x088a 1B24 81 DUP2 1B25 61 PUSH2 0x2897 1B28 56 *JUMP label_1B29: // Incoming call from 0x1D5A, returns to 0x10E5 // Inputs[2] // { // @1B2A stack[-1] // @1B2B msg.data[stack[-1]:stack[-1] + 0x20] // } 1B29 5B JUMPDEST 1B2A 80 DUP1 1B2B 35 CALLDATALOAD 1B2C 61 PUSH2 0x088a 1B2F 81 DUP2 1B30 61 PUSH2 0x289f 1B33 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B2B stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1B2C stack[1] = 0x088a // @1B2F stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x289f, returns to 0x088A 1B34 5B JUMPDEST 1B35 80 DUP1 1B36 51 MLOAD 1B37 61 PUSH2 0x088a 1B3A 81 DUP2 1B3B 61 PUSH2 0x289f 1B3E 56 *JUMP label_1B3F: // Incoming call from 0x1DAD, returns to 0x10E5 // Inputs[2] // { // @1B42 stack[-2] // @1B45 stack[-1] // } 1B3F 5B JUMPDEST 1B40 60 PUSH1 0x00 1B42 82 DUP3 1B43 60 PUSH1 0x1f 1B45 83 DUP4 1B46 01 ADD 1B47 12 SLT 1B48 61 PUSH2 0x1b50 1B4B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B40 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b50, if stack[-1] + 0x1f i< stack[-2] label_1B4C: // Incoming jump from 0x1B4B, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1B4F memory[0x00:0x00] } 1B4C 60 PUSH1 0x00 1B4E 80 DUP1 1B4F FD *REVERT // Stack delta = +0 // Outputs[1] { @1B4F revert(memory[0x00:0x00]); } // Block terminates label_1B50: // Incoming jump from 0x1B4B, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1B51 stack[-2] // @1B52 msg.data[stack[-2]:stack[-2] + 0x20] // @1B56 stack[-3] // } 1B50 5B JUMPDEST 1B51 81 DUP2 1B52 35 CALLDATALOAD 1B53 61 PUSH2 0x10e5 1B56 84 DUP5 1B57 82 DUP3 1B58 60 PUSH1 0x20 1B5A 86 DUP7 1B5B 01 ADD 1B5C 61 PUSH2 0x1a9b 1B5F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1B52 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B53 stack[1] = 0x10e5 // @1B56 stack[2] = stack[-3] // @1B57 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B5B stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1a9b, returns to 0x10E5 label_1B60: // Incoming call from 0x1DCB, returns to 0x10E5 // Incoming call from 0x1CE8, returns to 0x1BB9 // Inputs[2] // { // @1B61 stack[-1] // @1B62 msg.data[stack[-1]:stack[-1] + 0x20] // } 1B60 5B JUMPDEST 1B61 80 DUP1 1B62 35 CALLDATALOAD 1B63 61 PUSH2 0x088a 1B66 81 DUP2 1B67 61 PUSH2 0x28af 1B6A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B62 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1B63 stack[1] = 0x088a // @1B66 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x28af, returns to 0x088A label_1B6B: // Incoming jump from 0x02DF // Incoming jump from 0x051F // Incoming jump from 0x0631 // Incoming jump from 0x0441 // Inputs[2] // { // @1B70 stack[-1] // @1B71 stack[-2] // } 1B6B 5B JUMPDEST 1B6C 60 PUSH1 0x00 1B6E 60 PUSH1 0x20 1B70 82 DUP3 1B71 84 DUP5 1B72 03 SUB 1B73 12 SLT 1B74 15 ISZERO 1B75 61 PUSH2 0x1b7d 1B78 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B6C stack[0] = 0x00 } // Block ends with conditional jump to 0x1b7d, if !(stack[-2] - stack[-1] i< 0x20) label_1B79: // Incoming jump from 0x1B78, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B7C memory[0x00:0x00] } 1B79 60 PUSH1 0x00 1B7B 80 DUP1 1B7C FD *REVERT // Stack delta = +0 // Outputs[1] { @1B7C revert(memory[0x00:0x00]); } // Block terminates label_1B7D: // Incoming jump from 0x1B78, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B83 stack[-3] // @1B84 stack[-2] // } 1B7D 5B JUMPDEST 1B7E 60 PUSH1 0x00 1B80 61 PUSH2 0x10e5 1B83 84 DUP5 1B84 84 DUP5 1B85 61 PUSH2 0x1ad4 1B88 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B7E stack[0] = 0x00 // @1B80 stack[1] = 0x10e5 // @1B83 stack[2] = stack[-3] // @1B84 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1ad4 label_1B89: // Incoming jump from 0x05C8 // Inputs[2] // { // @1B8F stack[-1] // @1B90 stack[-2] // } 1B89 5B JUMPDEST 1B8A 60 PUSH1 0x00 1B8C 80 DUP1 1B8D 60 PUSH1 0x40 1B8F 83 DUP4 1B90 85 DUP6 1B91 03 SUB 1B92 12 SLT 1B93 15 ISZERO 1B94 61 PUSH2 0x1b9c 1B97 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B8A stack[0] = 0x00 // @1B8C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b9c, if !(stack[-2] - stack[-1] i< 0x40) label_1B98: // Incoming jump from 0x1B97, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B9B memory[0x00:0x00] } 1B98 60 PUSH1 0x00 1B9A 80 DUP1 1B9B FD *REVERT // Stack delta = +0 // Outputs[1] { @1B9B revert(memory[0x00:0x00]); } // Block terminates label_1B9C: // Incoming jump from 0x1B97, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1BA2 stack[-4] // @1BA3 stack[-3] // } 1B9C 5B JUMPDEST 1B9D 60 PUSH1 0x00 1B9F 61 PUSH2 0x1ba8 1BA2 85 DUP6 1BA3 85 DUP6 1BA4 61 PUSH2 0x1ad4 1BA7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B9D stack[0] = 0x00 // @1B9F stack[1] = 0x1ba8 // @1BA2 stack[2] = stack[-4] // @1BA3 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1ad4 1BA8 5B JUMPDEST 1BA9 92 SWAP3 1BAA 50 POP 1BAB 50 POP 1BAC 60 PUSH1 0x20 1BAE 61 PUSH2 0x1bb9 1BB1 85 DUP6 1BB2 82 DUP3 1BB3 86 DUP7 1BB4 01 ADD 1BB5 61 PUSH2 0x1ad4 1BB8 56 *JUMP label_1BB9: // Incoming return from call to 0x1B60 at 0x1CE8 // Inputs[6] // { // @1BBA stack[-3] // @1BBA stack[-1] // @1BBD stack[-6] // @1BBF stack[-7] // @1BBF stack[-4] // @1BC0 stack[-5] // } 1BB9 5B JUMPDEST 1BBA 91 SWAP2 1BBB 50 POP 1BBC 50 POP 1BBD 92 SWAP3 1BBE 50 POP 1BBF 92 SWAP3 1BC0 90 SWAP1 1BC1 50 POP 1BC2 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1BBD stack[-6] = stack[-1] // @1BBF stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1BC3: // Incoming jump from 0x032E // Incoming jump from 0x0396 // Inputs[2] // { // @1BCB stack[-1] // @1BCC stack[-2] // } 1BC3 5B JUMPDEST 1BC4 60 PUSH1 0x00 1BC6 80 DUP1 1BC7 60 PUSH1 0x00 1BC9 60 PUSH1 0x60 1BCB 84 DUP5 1BCC 86 DUP7 1BCD 03 SUB 1BCE 12 SLT 1BCF 15 ISZERO 1BD0 61 PUSH2 0x1bd8 1BD3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1BC4 stack[0] = 0x00 // @1BC6 stack[1] = 0x00 // @1BC7 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1bd8, if !(stack[-2] - stack[-1] i< 0x60) label_1BD4: // Incoming jump from 0x1BD3, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1BD7 memory[0x00:0x00] } 1BD4 60 PUSH1 0x00 1BD6 80 DUP1 1BD7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BD7 revert(memory[0x00:0x00]); } // Block terminates label_1BD8: // Incoming jump from 0x1BD3, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1BDE stack[-5] // @1BDF stack[-4] // } 1BD8 5B JUMPDEST 1BD9 60 PUSH1 0x00 1BDB 61 PUSH2 0x1be4 1BDE 86 DUP7 1BDF 86 DUP7 1BE0 61 PUSH2 0x1ad4 1BE3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BD9 stack[0] = 0x00 // @1BDB stack[1] = 0x1be4 // @1BDE stack[2] = stack[-5] // @1BDF stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1ad4 1BE4 5B JUMPDEST 1BE5 93 SWAP4 1BE6 50 POP 1BE7 50 POP 1BE8 60 PUSH1 0x20 1BEA 61 PUSH2 0x1bf5 1BED 86 DUP7 1BEE 82 DUP3 1BEF 87 DUP8 1BF0 01 ADD 1BF1 61 PUSH2 0x1ad4 1BF4 56 *JUMP 1BF5 5B JUMPDEST 1BF6 92 SWAP3 1BF7 50 POP 1BF8 50 POP 1BF9 60 PUSH1 0x40 1BFB 61 PUSH2 0x1c06 1BFE 86 DUP7 1BFF 82 DUP3 1C00 87 DUP8 1C01 01 ADD 1C02 61 PUSH2 0x1b60 1C05 56 *JUMP 1C06 5B JUMPDEST 1C07 91 SWAP2 1C08 50 POP 1C09 50 POP 1C0A 92 SWAP3 1C0B 50 POP 1C0C 92 SWAP3 1C0D 50 POP 1C0E 92 SWAP3 1C0F 56 *JUMP label_1C10: // Incoming jump from 0x0555 // Inputs[2] // { // @1C19 stack[-1] // @1C1A stack[-2] // } 1C10 5B JUMPDEST 1C11 60 PUSH1 0x00 1C13 80 DUP1 1C14 60 PUSH1 0x00 1C16 80 DUP1 1C17 60 PUSH1 0x80 1C19 85 DUP6 1C1A 87 DUP8 1C1B 03 SUB 1C1C 12 SLT 1C1D 15 ISZERO 1C1E 61 PUSH2 0x1c26 1C21 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1C11 stack[0] = 0x00 // @1C13 stack[1] = 0x00 // @1C14 stack[2] = 0x00 // @1C16 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1c26, if !(stack[-2] - stack[-1] i< 0x80) label_1C22: // Incoming jump from 0x1C21, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1C25 memory[0x00:0x00] } 1C22 60 PUSH1 0x00 1C24 80 DUP1 1C25 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C25 revert(memory[0x00:0x00]); } // Block terminates label_1C26: // Incoming jump from 0x1C21, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1C2C stack[-6] // @1C2D stack[-5] // } 1C26 5B JUMPDEST 1C27 60 PUSH1 0x00 1C29 61 PUSH2 0x1c32 1C2C 87 DUP8 1C2D 87 DUP8 1C2E 61 PUSH2 0x1ad4 1C31 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C27 stack[0] = 0x00 // @1C29 stack[1] = 0x1c32 // @1C2C stack[2] = stack[-6] // @1C2D stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1ad4 1C32 5B JUMPDEST 1C33 94 SWAP5 1C34 50 POP 1C35 50 POP 1C36 60 PUSH1 0x20 1C38 61 PUSH2 0x1c43 1C3B 87 DUP8 1C3C 82 DUP3 1C3D 88 DUP9 1C3E 01 ADD 1C3F 61 PUSH2 0x1ad4 1C42 56 *JUMP 1C43 5B JUMPDEST 1C44 93 SWAP4 1C45 50 POP 1C46 50 POP 1C47 60 PUSH1 0x40 1C49 61 PUSH2 0x1c54 1C4C 87 DUP8 1C4D 82 DUP3 1C4E 88 DUP9 1C4F 01 ADD 1C50 61 PUSH2 0x1b60 1C53 56 *JUMP 1C54 5B JUMPDEST 1C55 92 SWAP3 1C56 50 POP 1C57 50 POP 1C58 60 PUSH1 0x60 1C5A 85 DUP6 1C5B 01 ADD 1C5C 35 CALLDATALOAD 1C5D 67 PUSH8 0xffffffffffffffff 1C66 81 DUP2 1C67 11 GT 1C68 15 ISZERO 1C69 61 PUSH2 0x1c71 1C6C 57 *JUMPI 1C6D 60 PUSH1 0x00 1C6F 80 DUP1 1C70 FD *REVERT 1C71 5B JUMPDEST 1C72 61 PUSH2 0x1c7d 1C75 87 DUP8 1C76 82 DUP3 1C77 88 DUP9 1C78 01 ADD 1C79 61 PUSH2 0x1b3f 1C7C 56 *JUMP 1C7D 5B JUMPDEST 1C7E 91 SWAP2 1C7F 50 POP 1C80 50 POP 1C81 92 SWAP3 1C82 95 SWAP6 1C83 91 SWAP2 1C84 94 SWAP5 1C85 50 POP 1C86 92 SWAP3 1C87 50 POP 1C88 56 *JUMP label_1C89: // Incoming jump from 0x04FF // Inputs[2] // { // @1C8F stack[-1] // @1C90 stack[-2] // } 1C89 5B JUMPDEST 1C8A 60 PUSH1 0x00 1C8C 80 DUP1 1C8D 60 PUSH1 0x40 1C8F 83 DUP4 1C90 85 DUP6 1C91 03 SUB 1C92 12 SLT 1C93 15 ISZERO 1C94 61 PUSH2 0x1c9c 1C97 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C8A stack[0] = 0x00 // @1C8C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c9c, if !(stack[-2] - stack[-1] i< 0x40) label_1C98: // Incoming jump from 0x1C97, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1C9B memory[0x00:0x00] } 1C98 60 PUSH1 0x00 1C9A 80 DUP1 1C9B FD *REVERT // Stack delta = +0 // Outputs[1] { @1C9B revert(memory[0x00:0x00]); } // Block terminates label_1C9C: // Incoming jump from 0x1C97, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1CA2 stack[-4] // @1CA3 stack[-3] // } 1C9C 5B JUMPDEST 1C9D 60 PUSH1 0x00 1C9F 61 PUSH2 0x1ca8 1CA2 85 DUP6 1CA3 85 DUP6 1CA4 61 PUSH2 0x1ad4 1CA7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C9D stack[0] = 0x00 // @1C9F stack[1] = 0x1ca8 // @1CA2 stack[2] = stack[-4] // @1CA3 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1ad4 1CA8 5B JUMPDEST 1CA9 92 SWAP3 1CAA 50 POP 1CAB 50 POP 1CAC 60 PUSH1 0x20 1CAE 61 PUSH2 0x1bb9 1CB1 85 DUP6 1CB2 82 DUP3 1CB3 86 DUP7 1CB4 01 ADD 1CB5 61 PUSH2 0x1b1e 1CB8 56 *JUMP label_1CB9: // Incoming jump from 0x02BF // Incoming jump from 0x034E // Incoming jump from 0x05A8 // Inputs[2] // { // @1CBF stack[-1] // @1CC0 stack[-2] // } 1CB9 5B JUMPDEST 1CBA 60 PUSH1 0x00 1CBC 80 DUP1 1CBD 60 PUSH1 0x40 1CBF 83 DUP4 1CC0 85 DUP6 1CC1 03 SUB 1CC2 12 SLT 1CC3 15 ISZERO 1CC4 61 PUSH2 0x1ccc 1CC7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CBA stack[0] = 0x00 // @1CBC stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ccc, if !(stack[-2] - stack[-1] i< 0x40) label_1CC8: // Incoming jump from 0x1CC7, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1CCB memory[0x00:0x00] } 1CC8 60 PUSH1 0x00 1CCA 80 DUP1 1CCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CCB revert(memory[0x00:0x00]); } // Block terminates label_1CCC: // Incoming jump from 0x1CC7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1CD2 stack[-4] // @1CD3 stack[-3] // } 1CCC 5B JUMPDEST 1CCD 60 PUSH1 0x00 1CCF 61 PUSH2 0x1cd8 1CD2 85 DUP6 1CD3 85 DUP6 1CD4 61 PUSH2 0x1ad4 1CD7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CCD stack[0] = 0x00 // @1CCF stack[1] = 0x1cd8 // @1CD2 stack[2] = stack[-4] // @1CD3 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1ad4 label_1CD8: // Incoming return from call to 0x1AFD at 0x1D3C // Inputs[4] // { // @1CD9 stack[-1] // @1CD9 stack[-4] // @1CE1 stack[-6] // @1CE3 stack[-5] // } 1CD8 5B JUMPDEST 1CD9 92 SWAP3 1CDA 50 POP 1CDB 50 POP 1CDC 60 PUSH1 0x20 1CDE 61 PUSH2 0x1bb9 1CE1 85 DUP6 1CE2 82 DUP3 1CE3 86 DUP7 1CE4 01 ADD 1CE5 61 PUSH2 0x1b60 1CE8 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1CD9 stack[-4] = stack[-1] // @1CDC stack[-2] = 0x20 // @1CDE stack[-1] = 0x1bb9 // @1CE1 stack[0] = stack[-6] // @1CE4 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1b60, returns to 0x1BB9 label_1CE9: // Incoming jump from 0x0651 // Inputs[2] // { // @1CEE stack[-1] // @1CEF stack[-2] // } 1CE9 5B JUMPDEST 1CEA 60 PUSH1 0x00 1CEC 60 PUSH1 0x40 1CEE 82 DUP3 1CEF 84 DUP5 1CF0 03 SUB 1CF1 12 SLT 1CF2 15 ISZERO 1CF3 61 PUSH2 0x1cfb 1CF6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CEA stack[0] = 0x00 } // Block ends with conditional jump to 0x1cfb, if !(stack[-2] - stack[-1] i< 0x40) label_1CF7: // Incoming jump from 0x1CF6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1CFA memory[0x00:0x00] } 1CF7 60 PUSH1 0x00 1CF9 80 DUP1 1CFA FD *REVERT // Stack delta = +0 // Outputs[1] { @1CFA revert(memory[0x00:0x00]); } // Block terminates label_1CFB: // Incoming jump from 0x1CF6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D01 stack[-3] // @1D02 stack[-2] // } 1CFB 5B JUMPDEST 1CFC 60 PUSH1 0x00 1CFE 61 PUSH2 0x10e5 1D01 84 DUP5 1D02 84 DUP5 1D03 61 PUSH2 0x1adf 1D06 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CFC stack[0] = 0x00 // @1CFE stack[1] = 0x10e5 // @1D01 stack[2] = stack[-3] // @1D02 stack[3] = stack[-2] // } // Block ends with call to 0x1adf, returns to 0x10E5 label_1D07: // Incoming call from 0x0476, returns to 0x0477 // Inputs[2] // { // @1D0D stack[-1] // @1D0E stack[-2] // } 1D07 5B JUMPDEST 1D08 60 PUSH1 0x00 1D0A 80 DUP1 1D0B 60 PUSH1 0x40 1D0D 83 DUP4 1D0E 85 DUP6 1D0F 03 SUB 1D10 12 SLT 1D11 15 ISZERO 1D12 61 PUSH2 0x1d1a 1D15 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D08 stack[0] = 0x00 // @1D0A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d1a, if !(stack[-2] - stack[-1] i< 0x40) label_1D16: // Incoming jump from 0x1D15, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D19 memory[0x00:0x00] } 1D16 60 PUSH1 0x00 1D18 80 DUP1 1D19 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D19 revert(memory[0x00:0x00]); } // Block terminates label_1D1A: // Incoming jump from 0x1D15, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D1B stack[-3] // @1D1C msg.data[stack[-3]:stack[-3] + 0x20] // } 1D1A 5B JUMPDEST 1D1B 82 DUP3 1D1C 35 CALLDATALOAD 1D1D 67 PUSH8 0xffffffffffffffff 1D26 81 DUP2 1D27 11 GT 1D28 15 ISZERO 1D29 61 PUSH2 0x1d31 1D2C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D1C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1d31, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1D2D: // Incoming jump from 0x1D2C, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1D30 memory[0x00:0x00] } 1D2D 60 PUSH1 0x00 1D2F 80 DUP1 1D30 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D30 revert(memory[0x00:0x00]); } // Block terminates label_1D31: // Incoming jump from 0x1D2C, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D35 stack[-5] // @1D36 stack[-1] // @1D37 stack[-4] // } 1D31 5B JUMPDEST 1D32 61 PUSH2 0x1cd8 1D35 85 DUP6 1D36 82 DUP3 1D37 86 DUP7 1D38 01 ADD 1D39 61 PUSH2 0x1afd 1D3C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D32 stack[0] = 0x1cd8 // @1D35 stack[1] = stack[-5] // @1D38 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1afd, returns to 0x1CD8 label_1D3D: // Incoming call from 0x0218, returns to 0x0219 // Inputs[2] // { // @1D42 stack[-1] // @1D43 stack[-2] // } 1D3D 5B JUMPDEST 1D3E 60 PUSH1 0x00 1D40 60 PUSH1 0x20 1D42 82 DUP3 1D43 84 DUP5 1D44 03 SUB 1D45 12 SLT 1D46 15 ISZERO 1D47 61 PUSH2 0x1d4f 1D4A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D3E stack[0] = 0x00 } // Block ends with conditional jump to 0x1d4f, if !(stack[-2] - stack[-1] i< 0x20) label_1D4B: // Incoming jump from 0x1D4A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D4E memory[0x00:0x00] } 1D4B 60 PUSH1 0x00 1D4D 80 DUP1 1D4E FD *REVERT // Stack delta = +0 // Outputs[1] { @1D4E revert(memory[0x00:0x00]); } // Block terminates label_1D4F: // Incoming jump from 0x1D4A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D55 stack[-3] // @1D56 stack[-2] // } 1D4F 5B JUMPDEST 1D50 60 PUSH1 0x00 1D52 61 PUSH2 0x10e5 1D55 84 DUP5 1D56 84 DUP5 1D57 61 PUSH2 0x1b29 1D5A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D50 stack[0] = 0x00 // @1D52 stack[1] = 0x10e5 // @1D55 stack[2] = stack[-3] // @1D56 stack[3] = stack[-2] // } // Block ends with call to 0x1b29, returns to 0x10E5 1D5B 5B JUMPDEST 1D5C 60 PUSH1 0x00 1D5E 60 PUSH1 0x20 1D60 82 DUP3 1D61 84 DUP5 1D62 03 SUB 1D63 12 SLT 1D64 15 ISZERO 1D65 61 PUSH2 0x1d6d 1D68 57 *JUMPI 1D69 60 PUSH1 0x00 1D6B 80 DUP1 1D6C FD *REVERT 1D6D 5B JUMPDEST 1D6E 60 PUSH1 0x00 1D70 61 PUSH2 0x10e5 1D73 84 DUP5 1D74 84 DUP5 1D75 61 PUSH2 0x1b34 1D78 56 *JUMP label_1D79: // Incoming jump from 0x03D6 // Inputs[2] // { // @1D7E stack[-1] // @1D7F stack[-2] // } 1D79 5B JUMPDEST 1D7A 60 PUSH1 0x00 1D7C 60 PUSH1 0x20 1D7E 82 DUP3 1D7F 84 DUP5 1D80 03 SUB 1D81 12 SLT 1D82 15 ISZERO 1D83 61 PUSH2 0x1d8b 1D86 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D7A stack[0] = 0x00 } // Block ends with conditional jump to 0x1d8b, if !(stack[-2] - stack[-1] i< 0x20) label_1D87: // Incoming jump from 0x1D86, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D8A memory[0x00:0x00] } 1D87 60 PUSH1 0x00 1D89 80 DUP1 1D8A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D8A revert(memory[0x00:0x00]); } // Block terminates label_1D8B: // Incoming jump from 0x1D86, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D8C stack[-2] // @1D8D msg.data[stack[-2]:stack[-2] + 0x20] // } 1D8B 5B JUMPDEST 1D8C 81 DUP2 1D8D 35 CALLDATALOAD 1D8E 67 PUSH8 0xffffffffffffffff 1D97 81 DUP2 1D98 11 GT 1D99 15 ISZERO 1D9A 61 PUSH2 0x1da2 1D9D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D8D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1da2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1D9E: // Incoming jump from 0x1D9D, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1DA1 memory[0x00:0x00] } 1D9E 60 PUSH1 0x00 1DA0 80 DUP1 1DA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA1 revert(memory[0x00:0x00]); } // Block terminates label_1DA2: // Incoming jump from 0x1D9D, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1DA6 stack[-4] // @1DA7 stack[-1] // @1DA8 stack[-3] // } 1DA2 5B JUMPDEST 1DA3 61 PUSH2 0x10e5 1DA6 84 DUP5 1DA7 82 DUP3 1DA8 85 DUP6 1DA9 01 ADD 1DAA 61 PUSH2 0x1b3f 1DAD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DA3 stack[0] = 0x10e5 // @1DA6 stack[1] = stack[-4] // @1DA9 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1b3f, returns to 0x10E5 label_1DAE: // Incoming call from 0x029D, returns to 0x029E // Incoming call from 0x0588, returns to 0x0589 // Incoming call from 0x03B6, returns to 0x03B7 // Incoming call from 0x040C, returns to 0x040D // Incoming call from 0x0376, returns to 0x0377 // Incoming call from 0x0568, returns to 0x0569 // Incoming call from 0x0270, returns to 0x0271 // Inputs[2] // { // @1DB3 stack[-1] // @1DB4 stack[-2] // } 1DAE 5B JUMPDEST 1DAF 60 PUSH1 0x00 1DB1 60 PUSH1 0x20 1DB3 82 DUP3 1DB4 84 DUP5 1DB5 03 SUB 1DB6 12 SLT 1DB7 15 ISZERO 1DB8 61 PUSH2 0x1dc0 1DBB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DAF stack[0] = 0x00 } // Block ends with conditional jump to 0x1dc0, if !(stack[-2] - stack[-1] i< 0x20) label_1DBC: // Incoming jump from 0x1DBB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DBF memory[0x00:0x00] } 1DBC 60 PUSH1 0x00 1DBE 80 DUP1 1DBF FD *REVERT // Stack delta = +0 // Outputs[1] { @1DBF revert(memory[0x00:0x00]); } // Block terminates label_1DC0: // Incoming jump from 0x1DBB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DC6 stack[-3] // @1DC7 stack[-2] // } 1DC0 5B JUMPDEST 1DC1 60 PUSH1 0x00 1DC3 61 PUSH2 0x10e5 1DC6 84 DUP5 1DC7 84 DUP5 1DC8 61 PUSH2 0x1b60 1DCB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DC1 stack[0] = 0x00 // @1DC3 stack[1] = 0x10e5 // @1DC6 stack[2] = stack[-3] // @1DC7 stack[3] = stack[-2] // } // Block ends with call to 0x1b60, returns to 0x10E5 label_1DCC: // Incoming jump from 0x24A3 // Incoming jump from 0x2495 // Inputs[1] { @1DD0 stack[-1] } 1DCC 5B JUMPDEST 1DCD 61 PUSH2 0x1dd5 1DD0 81 DUP2 1DD1 61 PUSH2 0x2760 1DD4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DCD stack[0] = 0x1dd5 // @1DD0 stack[1] = stack[-1] // } // Block ends with call to 0x2760, returns to 0x1DD5 label_1DD5: // Incoming jump from 0x241B // Incoming return from call to 0x2760 at 0x1DD4 // Inputs[3] // { // @1DD6 stack[-3] // @1DD7 stack[-1] // @1DDA stack[-4] // } 1DD5 5B JUMPDEST 1DD6 82 DUP3 1DD7 52 MSTORE 1DD8 50 POP 1DD9 50 POP 1DDA 56 *JUMP // Stack delta = -4 // Outputs[1] { @1DD7 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] 1DDB 5B JUMPDEST 1DDC 80 DUP1 1DDD 15 ISZERO 1DDE 15 ISZERO 1DDF 61 PUSH2 0x1dd5 1DE2 56 *JUMP label_1DE3: // Incoming call from 0x24F8, returns to 0x0EB5 // Inputs[2] // { // @1DE9 stack[-1] // @1DEA memory[stack[-1]:stack[-1] + 0x20] // } 1DE3 5B JUMPDEST 1DE4 60 PUSH1 0x00 1DE6 61 PUSH2 0x1ded 1DE9 82 DUP3 1DEA 51 MLOAD 1DEB 90 SWAP1 1DEC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DE4 stack[0] = 0x00 // @1DEB stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ded label_1DED: // Incoming jump from 0x1DEC // Inputs[3] // { // @1DEE stack[-1] // @1DEF stack[-4] // @1DFE stack[-3] // } 1DED 5B JUMPDEST 1DEE 80 DUP1 1DEF 84 DUP5 1DF0 52 MSTORE 1DF1 60 PUSH1 0x20 1DF3 84 DUP5 1DF4 01 ADD 1DF5 93 SWAP4 1DF6 50 POP 1DF7 61 PUSH2 0x1e04 1DFA 81 DUP2 1DFB 85 DUP6 1DFC 60 PUSH1 0x20 1DFE 86 DUP7 1DFF 01 ADD 1E00 61 PUSH2 0x277d 1E03 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1DF0 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1DF5 stack[-4] = stack[-4] + 0x20 // @1DF7 stack[0] = 0x1e04 // @1DFA stack[1] = stack[-1] // @1DFB stack[2] = stack[-4] + 0x20 // @1DFF stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x277d, returns to 0x1E04 label_1E04: // Incoming return from call to 0x277D at 0x1E03 // Inputs[4] // { // @1E07 stack[-1] // @1E0C stack[-4] // @1E0D stack[-2] // @1E10 stack[-5] // } 1E04 5B JUMPDEST 1E05 60 PUSH1 0x1f 1E07 01 ADD 1E08 60 PUSH1 0x1f 1E0A 19 NOT 1E0B 16 AND 1E0C 92 SWAP3 1E0D 90 SWAP1 1E0E 92 SWAP3 1E0F 01 ADD 1E10 92 SWAP3 1E11 91 SWAP2 1E12 50 POP 1E13 50 POP 1E14 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E10 stack[-5] = (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1E15: // Incoming call from 0x247C, returns to 0x247D // Inputs[2] // { // @1E1B stack[-1] // @1E1C memory[stack[-1]:stack[-1] + 0x20] // } 1E15 5B JUMPDEST 1E16 60 PUSH1 0x00 1E18 61 PUSH2 0x1e1f 1E1B 82 DUP3 1E1C 51 MLOAD 1E1D 90 SWAP1 1E1E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E16 stack[0] = 0x00 // @1E1D stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1e1f label_1E1F: // Incoming jump from 0x1E1E // Inputs[3] // { // @1E23 stack[-1] // @1E24 stack[-4] // @1E27 stack[-3] // } 1E1F 5B JUMPDEST 1E20 61 PUSH2 0x1e2d 1E23 81 DUP2 1E24 85 DUP6 1E25 60 PUSH1 0x20 1E27 86 DUP7 1E28 01 ADD 1E29 61 PUSH2 0x277d 1E2C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E20 stack[0] = 0x1e2d // @1E23 stack[1] = stack[-1] // @1E24 stack[2] = stack[-4] // @1E28 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x277d, returns to 0x1E2D label_1E2D: // Incoming return from call to 0x277D at 0x1E2C // Inputs[4] // { // @1E2E stack[-4] // @1E2E stack[-1] // @1E2F stack[-2] // @1E32 stack[-5] // } 1E2D 5B JUMPDEST 1E2E 92 SWAP3 1E2F 90 SWAP1 1E30 92 SWAP3 1E31 01 ADD 1E32 92 SWAP3 1E33 91 SWAP2 1E34 50 POP 1E35 50 POP 1E36 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E32 stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1E37: // Incoming call from 0x2508, returns to 0x0662 // Inputs[1] { @1E3A stack[-1] } 1E37 5B JUMPDEST 1E38 60 PUSH1 0x0e 1E3A 81 DUP2 1E3B 52 MSTORE 1E3C 60 PUSH1 0x00 1E3E 60 PUSH1 0x20 1E40 82 DUP3 1E41 01 ADD 1E42 6D PUSH14 0x14d85b19481a5cc818db1bdcd959 1E51 60 PUSH1 0x92 1E53 1B SHL 1E54 81 DUP2 1E55 52 MSTORE 1E56 91 SWAP2 1E57 50 POP // Stack delta = +1 // Outputs[4] // { // @1E3B memory[stack[-1]:stack[-1] + 0x20] = 0x0e // @1E3C stack[0] = 0x00 // @1E55 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14d85b19481a5cc818db1bdcd959 << 0x92 // @1E56 stack[-1] = stack[-1] + 0x20 // } // Block continues label_1E58: // Incoming jump from 0x234A // Incoming jump from 0x2195 // Incoming jump from 0x23CC // Incoming jump from 0x1E57 // Incoming jump from 0x1F6F // Incoming jump from 0x2210 // Inputs[2] // { // @1E5C stack[-2] // @1E5D stack[-3] // } 1E58 5B JUMPDEST 1E59 50 POP 1E5A 60 PUSH1 0x20 1E5C 01 ADD 1E5D 90 SWAP1 1E5E 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E5D stack[-3] = 0x20 + stack[-2] } // Block ends with unconditional jump to stack[-3] 1E5F 5B JUMPDEST 1E60 60 PUSH1 0x2b 1E62 81 DUP2 1E63 52 MSTORE 1E64 60 PUSH1 0x00 1E66 60 PUSH1 0x20 1E68 82 DUP3 1E69 01 ADD 1E6A 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 1E8B 81 DUP2 1E8C 52 MSTORE 1E8D 6A PUSH11 0x74206f6620626f756e6473 1E99 60 PUSH1 0xa8 1E9B 1B SHL 1E9C 60 PUSH1 0x20 1E9E 82 DUP3 1E9F 01 ADD 1EA0 52 MSTORE 1EA1 91 SWAP2 1EA2 50 POP label_1EA3: // Incoming jump from 0x21DE // Incoming jump from 0x211D // Incoming jump from 0x2163 // Incoming jump from 0x22E2 // Incoming jump from 0x2022 // Incoming jump from 0x2415 // Incoming jump from 0x1EF8 // Incoming jump from 0x22A2 // Inputs[2] // { // @1EA7 stack[-2] // @1EA8 stack[-3] // } 1EA3 5B JUMPDEST 1EA4 50 POP 1EA5 60 PUSH1 0x40 1EA7 01 ADD 1EA8 90 SWAP1 1EA9 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EA8 stack[-3] = 0x40 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1EAA: // Incoming call from 0x2528, returns to 0x0662 // Inputs[1] { @1EAD stack[-1] } 1EAA 5B JUMPDEST 1EAB 60 PUSH1 0x32 1EAD 81 DUP2 1EAE 52 MSTORE 1EAF 60 PUSH1 0x00 1EB1 60 PUSH1 0x20 1EB3 82 DUP3 1EB4 01 ADD 1EB5 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1ED6 81 DUP2 1ED7 52 MSTORE 1ED8 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 1EEB 60 PUSH1 0x71 1EED 1B SHL 1EEE 60 PUSH1 0x20 1EF0 82 DUP3 1EF1 01 ADD 1EF2 52 MSTORE 1EF3 91 SWAP2 1EF4 50 POP 1EF5 61 PUSH2 0x1ea3 1EF8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1EAE memory[stack[-1]:stack[-1] + 0x20] = 0x32 // @1EAF stack[0] = 0x00 // @1ED7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @1EF2 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x71 // @1EF3 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 1EF9 5B JUMPDEST 1EFA 60 PUSH1 0x26 1EFC 81 DUP2 1EFD 52 MSTORE 1EFE 60 PUSH1 0x00 1F00 60 PUSH1 0x20 1F02 82 DUP3 1F03 01 ADD 1F04 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1F25 81 DUP2 1F26 52 MSTORE 1F27 65 PUSH6 0x646472657373 1F2E 60 PUSH1 0xd0 1F30 1B SHL 1F31 60 PUSH1 0x20 1F33 82 DUP3 1F34 01 ADD 1F35 52 MSTORE 1F36 91 SWAP2 1F37 50 POP 1F38 61 PUSH2 0x1ea3 1F3B 56 *JUMP label_1F3C: // Incoming call from 0x2548, returns to 0x0662 // Inputs[1] { @1F3F stack[-1] } 1F3C 5B JUMPDEST 1F3D 60 PUSH1 0x1c 1F3F 81 DUP2 1F40 52 MSTORE 1F41 60 PUSH1 0x00 1F43 60 PUSH1 0x20 1F45 82 DUP3 1F46 01 ADD 1F47 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 1F68 81 DUP2 1F69 52 MSTORE 1F6A 91 SWAP2 1F6B 50 POP 1F6C 61 PUSH2 0x1e58 1F6F 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1F40 memory[stack[-1]:stack[-1] + 0x20] = 0x1c // @1F41 stack[0] = 0x00 // @1F69 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @1F6A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e58 1F70 5B JUMPDEST 1F71 60 PUSH1 0x24 1F73 81 DUP2 1F74 52 MSTORE 1F75 60 PUSH1 0x00 1F77 60 PUSH1 0x20 1F79 82 DUP3 1F7A 01 ADD 1F7B 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1F9C 81 DUP2 1F9D 52 MSTORE 1F9E 63 PUSH4 0x72657373 1FA3 60 PUSH1 0xe0 1FA5 1B SHL 1FA6 60 PUSH1 0x20 1FA8 82 DUP3 1FA9 01 ADD 1FAA 52 MSTORE 1FAB 91 SWAP2 1FAC 50 POP 1FAD 61 PUSH2 0x1ea3 1FB0 56 *JUMP 1FB1 5B JUMPDEST 1FB2 60 PUSH1 0x19 1FB4 81 DUP2 1FB5 52 MSTORE 1FB6 60 PUSH1 0x00 1FB8 60 PUSH1 0x20 1FBA 82 DUP3 1FBB 01 ADD 1FBC 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1FDD 81 DUP2 1FDE 52 MSTORE 1FDF 91 SWAP2 1FE0 50 POP 1FE1 61 PUSH2 0x1e58 1FE4 56 *JUMP label_1FE5: // Incoming call from 0x2578, returns to 0x0662 // Inputs[1] { @1FE8 stack[-1] } 1FE5 5B JUMPDEST 1FE6 60 PUSH1 0x21 1FE8 81 DUP2 1FE9 52 MSTORE 1FEA 60 PUSH1 0x00 1FEC 60 PUSH1 0x20 1FEE 82 DUP3 1FEF 01 ADD 1FF0 7F PUSH32 0x4d6178696d756d20536c696d486f6f647320737570706c792065786365656465 2011 81 DUP2 2012 52 MSTORE 2013 60 PUSH1 0x19 2015 60 PUSH1 0xfa 2017 1B SHL 2018 60 PUSH1 0x20 201A 82 DUP3 201B 01 ADD 201C 52 MSTORE 201D 91 SWAP2 201E 50 POP 201F 61 PUSH2 0x1ea3 2022 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1FE9 memory[stack[-1]:stack[-1] + 0x20] = 0x21 // @1FEA stack[0] = 0x00 // @2012 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4d6178696d756d20536c696d486f6f647320737570706c792065786365656465 // @201C memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x19 << 0xfa // @201D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 2023 5B JUMPDEST 2024 60 PUSH1 0x2c 2026 81 DUP2 2027 52 MSTORE 2028 60 PUSH1 0x00 202A 60 PUSH1 0x20 202C 82 DUP3 202D 01 ADD 202E 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 204F 81 DUP2 2050 52 MSTORE 2051 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 205E 60 PUSH1 0xa1 2060 1B SHL 2061 60 PUSH1 0x20 2063 82 DUP3 2064 01 ADD 2065 52 MSTORE 2066 91 SWAP2 2067 50 POP 2068 61 PUSH2 0x1ea3 206B 56 *JUMP label_206C: // Incoming jump from 0x2487 // Inputs[1] { @2072 stack[-1] } 206C 5B JUMPDEST 206D 60 PUSH1 0x29 206F 60 PUSH1 0xf8 2071 1B SHL 2072 81 DUP2 2073 52 MSTORE 2074 60 PUSH1 0x00 // Stack delta = +1 // Outputs[2] // { // @2073 memory[stack[-1]:stack[-1] + 0x20] = 0x29 << 0xf8 // @2074 stack[0] = 0x00 // } // Block continues label_2076: // Incoming jump from 0x280F, if !(stack[-1] == ~0x00) // Incoming jump from 0x2074 // Inputs[2] // { // @207A stack[-2] // @207B stack[-3] // } 2076 5B JUMPDEST 2077 50 POP 2078 60 PUSH1 0x01 207A 01 ADD 207B 90 SWAP1 207C 56 *JUMP // Stack delta = -2 // Outputs[1] { @207B stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 207D 5B JUMPDEST 207E 60 PUSH1 0x38 2080 81 DUP2 2081 52 MSTORE 2082 60 PUSH1 0x00 2084 60 PUSH1 0x20 2086 82 DUP3 2087 01 ADD 2088 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 20A9 81 DUP2 20AA 52 MSTORE 20AB 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 20CC 60 PUSH1 0x20 20CE 82 DUP3 20CF 01 ADD 20D0 52 MSTORE 20D1 91 SWAP2 20D2 50 POP 20D3 61 PUSH2 0x1ea3 20D6 56 *JUMP label_20D7: // Incoming call from 0x25A8, returns to 0x0662 // Inputs[1] { @20DA stack[-1] } 20D7 5B JUMPDEST 20D8 60 PUSH1 0x2a 20DA 81 DUP2 20DB 52 MSTORE 20DC 60 PUSH1 0x00 20DE 60 PUSH1 0x20 20E0 82 DUP3 20E1 01 ADD 20E2 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 2103 81 DUP2 2104 52 MSTORE 2105 69 PUSH10 0x726f2061646472657373 2110 60 PUSH1 0xb0 2112 1B SHL 2113 60 PUSH1 0x20 2115 82 DUP3 2116 01 ADD 2117 52 MSTORE 2118 91 SWAP2 2119 50 POP 211A 61 PUSH2 0x1ea3 211D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @20DB memory[stack[-1]:stack[-1] + 0x20] = 0x2a // @20DC stack[0] = 0x00 // @2104 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @2117 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x726f2061646472657373 << 0xb0 // @2118 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 label_211E: // Incoming call from 0x25B8, returns to 0x0662 // Inputs[1] { @2121 stack[-1] } 211E 5B JUMPDEST 211F 60 PUSH1 0x29 2121 81 DUP2 2122 52 MSTORE 2123 60 PUSH1 0x00 2125 60 PUSH1 0x20 2127 82 DUP3 2128 01 ADD 2129 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 214A 81 DUP2 214B 52 MSTORE 214C 68 PUSH9 0x32b73a103a37b5b2b7 2156 60 PUSH1 0xb9 2158 1B SHL 2159 60 PUSH1 0x20 215B 82 DUP3 215C 01 ADD 215D 52 MSTORE 215E 91 SWAP2 215F 50 POP 2160 61 PUSH2 0x1ea3 2163 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2122 memory[stack[-1]:stack[-1] + 0x20] = 0x29 // @2123 stack[0] = 0x00 // @214B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @215D memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @215E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 label_2164: // Incoming call from 0x25C8, returns to 0x0662 // Inputs[1] { @2168 stack[-1] } 2164 5B JUMPDEST 2165 60 PUSH1 0x20 2167 80 DUP1 2168 82 DUP3 2169 52 MSTORE 216A 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 218B 91 SWAP2 218C 01 ADD 218D 90 SWAP1 218E 81 DUP2 218F 52 MSTORE 2190 60 PUSH1 0x00 2192 61 PUSH2 0x1e58 2195 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2169 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @218D stack[-1] = stack[-1] + 0x20 // @218F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @2190 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x1e58 label_2196: // Incoming call from 0x25D8, returns to 0x0662 // Inputs[1] { @2199 stack[-1] } 2196 5B JUMPDEST 2197 60 PUSH1 0x2c 2199 81 DUP2 219A 52 MSTORE 219B 60 PUSH1 0x00 219D 60 PUSH1 0x20 219F 82 DUP3 21A0 01 ADD 21A1 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 21C2 81 DUP2 21C3 52 MSTORE 21C4 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 21D1 60 PUSH1 0xa1 21D3 1B SHL 21D4 60 PUSH1 0x20 21D6 82 DUP3 21D7 01 ADD 21D8 52 MSTORE 21D9 91 SWAP2 21DA 50 POP 21DB 61 PUSH2 0x1ea3 21DE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @219A memory[stack[-1]:stack[-1] + 0x20] = 0x2c // @219B stack[0] = 0x00 // @21C3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @21D8 memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @21D9 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 label_21DF: // Incoming call from 0x25E8, returns to 0x0662 // Inputs[1] { @21E3 stack[-1] } 21DF 5B JUMPDEST 21E0 60 PUSH1 0x20 21E2 80 DUP1 21E3 82 DUP3 21E4 52 MSTORE 21E5 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2206 91 SWAP2 2207 01 ADD 2208 90 SWAP1 2209 81 DUP2 220A 52 MSTORE 220B 60 PUSH1 0x00 220D 61 PUSH2 0x1e58 2210 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @21E4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2208 stack[-1] = stack[-1] + 0x20 // @220A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @220B stack[0] = 0x00 // } // Block ends with unconditional jump to 0x1e58 2211 5B JUMPDEST 2212 60 PUSH1 0x29 2214 81 DUP2 2215 52 MSTORE 2216 60 PUSH1 0x00 2218 60 PUSH1 0x20 221A 82 DUP3 221B 01 ADD 221C 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 223D 81 DUP2 223E 52 MSTORE 223F 68 PUSH9 0x39903737ba1037bbb7 2249 60 PUSH1 0xb9 224B 1B SHL 224C 60 PUSH1 0x20 224E 82 DUP3 224F 01 ADD 2250 52 MSTORE 2251 91 SWAP2 2252 50 POP 2253 61 PUSH2 0x1ea3 2256 56 *JUMP label_2257: // Incoming call from 0x2608, returns to 0x0662 // Inputs[1] { @225A stack[-1] } 2257 5B JUMPDEST 2258 60 PUSH1 0x2f 225A 81 DUP2 225B 52 MSTORE 225C 60 PUSH1 0x00 225E 60 PUSH1 0x20 2260 82 DUP3 2261 01 ADD 2262 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 2283 81 DUP2 2284 52 MSTORE 2285 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 2295 60 PUSH1 0x89 2297 1B SHL 2298 60 PUSH1 0x20 229A 82 DUP3 229B 01 ADD 229C 52 MSTORE 229D 91 SWAP2 229E 50 POP 229F 61 PUSH2 0x1ea3 22A2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @225B memory[stack[-1]:stack[-1] + 0x20] = 0x2f // @225C stack[0] = 0x00 // @2284 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @229C memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @229D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 label_22A3: // Incoming call from 0x2618, returns to 0x0662 // Inputs[1] { @22A6 stack[-1] } 22A3 5B JUMPDEST 22A4 60 PUSH1 0x23 22A6 81 DUP2 22A7 52 MSTORE 22A8 60 PUSH1 0x00 22AA 60 PUSH1 0x20 22AC 82 DUP3 22AD 01 ADD 22AE 7F PUSH32 0x596f752063616e206f6e6c79206d696e742035206f72206c657373206174206f 22CF 81 DUP2 22D0 52 MSTORE 22D1 62 PUSH3 0x6e6365 22D5 60 PUSH1 0xe8 22D7 1B SHL 22D8 60 PUSH1 0x20 22DA 82 DUP3 22DB 01 ADD 22DC 52 MSTORE 22DD 91 SWAP2 22DE 50 POP 22DF 61 PUSH2 0x1ea3 22E2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @22A7 memory[stack[-1]:stack[-1] + 0x20] = 0x23 // @22A8 stack[0] = 0x00 // @22D0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x596f752063616e206f6e6c79206d696e742035206f72206c657373206174206f // @22DC memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x6e6365 << 0xe8 // @22DD stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 22E3 5B JUMPDEST 22E4 60 PUSH1 0x21 22E6 81 DUP2 22E7 52 MSTORE 22E8 60 PUSH1 0x00 22EA 60 PUSH1 0x20 22EC 82 DUP3 22ED 01 ADD 22EE 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 230F 81 DUP2 2310 52 MSTORE 2311 60 PUSH1 0x39 2313 60 PUSH1 0xf9 2315 1B SHL 2316 60 PUSH1 0x20 2318 82 DUP3 2319 01 ADD 231A 52 MSTORE 231B 91 SWAP2 231C 50 POP 231D 61 PUSH2 0x1ea3 2320 56 *JUMP label_2321: // Incoming call from 0x2638, returns to 0x0662 // Inputs[1] { @2324 stack[-1] } 2321 5B JUMPDEST 2322 60 PUSH1 0x13 2324 81 DUP2 2325 52 MSTORE 2326 60 PUSH1 0x00 2328 60 PUSH1 0x20 232A 82 DUP3 232B 01 ADD 232C 72 PUSH19 0x125b9cdd59999a58da595b9d08185b5bdd5b9d 2340 60 PUSH1 0x6a 2342 1B SHL 2343 81 DUP2 2344 52 MSTORE 2345 91 SWAP2 2346 50 POP 2347 61 PUSH2 0x1e58 234A 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2325 memory[stack[-1]:stack[-1] + 0x20] = 0x13 // @2326 stack[0] = 0x00 // @2344 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x125b9cdd59999a58da595b9d08185b5bdd5b9d << 0x6a // @2345 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e58 234B 5B JUMPDEST 234C 60 PUSH1 0x31 234E 81 DUP2 234F 52 MSTORE 2350 60 PUSH1 0x00 2352 60 PUSH1 0x20 2354 82 DUP3 2355 01 ADD 2356 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2377 81 DUP2 2378 52 MSTORE 2379 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 238B 60 PUSH1 0x7a 238D 1B SHL 238E 60 PUSH1 0x20 2390 82 DUP3 2391 01 ADD 2392 52 MSTORE 2393 91 SWAP2 2394 50 POP 2395 61 PUSH2 0x1ea3 2398 56 *JUMP label_2399: // Incoming call from 0x2658, returns to 0x0662 // Inputs[1] { @239C stack[-1] } 2399 5B JUMPDEST 239A 60 PUSH1 0x1c 239C 81 DUP2 239D 52 MSTORE 239E 60 PUSH1 0x00 23A0 60 PUSH1 0x20 23A2 82 DUP3 23A3 01 ADD 23A4 7F PUSH32 0x4e6f20726573657276656420686f6f647320666f722077616c6c657400000000 23C5 81 DUP2 23C6 52 MSTORE 23C7 91 SWAP2 23C8 50 POP 23C9 61 PUSH2 0x1e58 23CC 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @239D memory[stack[-1]:stack[-1] + 0x20] = 0x1c // @239E stack[0] = 0x00 // @23C6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4e6f20726573657276656420686f6f647320666f722077616c6c657400000000 // @23C7 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1e58 label_23CD: // Incoming call from 0x2668, returns to 0x0662 // Inputs[1] { @23D0 stack[-1] } 23CD 5B JUMPDEST 23CE 60 PUSH1 0x2c 23D0 81 DUP2 23D1 52 MSTORE 23D2 60 PUSH1 0x00 23D4 60 PUSH1 0x20 23D6 82 DUP3 23D7 01 ADD 23D8 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 23F9 81 DUP2 23FA 52 MSTORE 23FB 6B PUSH12 0x7574206f6620626f756e6473 2408 60 PUSH1 0xa0 240A 1B SHL 240B 60 PUSH1 0x20 240D 82 DUP3 240E 01 ADD 240F 52 MSTORE 2410 91 SWAP2 2411 50 POP 2412 61 PUSH2 0x1ea3 2415 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @23D1 memory[stack[-1]:stack[-1] + 0x20] = 0x2c // @23D2 stack[0] = 0x00 // @23FA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @240F memory[stack[-1] + 0x20 + 0x20:stack[-1] + 0x20 + 0x20 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @2410 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1ea3 label_2416: // Incoming call from 0x2676, returns to 0x088A // Inputs[1] { @2417 stack[-1] } 2416 5B JUMPDEST 2417 80 DUP1 2418 61 PUSH2 0x1dd5 241B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2417 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x1dd5 241C 5B JUMPDEST 241D 60 PUSH1 0x00 241F 61 PUSH2 0x2428 2422 82 DUP3 2423 85 DUP6 2424 61 PUSH2 0x1e15 2427 56 *JUMP 2428 5B JUMPDEST 2429 91 SWAP2 242A 50 POP 242B 61 PUSH2 0x10e5 242E 82 DUP3 242F 84 DUP5 2430 61 PUSH2 0x1e15 2433 56 *JUMP label_2434: // Incoming jump from 0x09B5 // Inputs[2] // { // @2456 stack[-1] // @2478 stack[-2] // } 2434 5B JUMPDEST 2435 7F PUSH32 0x43616e2774206d696e74206d6f7265207468616e207265736572766564207072 2456 81 DUP2 2457 52 MSTORE 2458 6D PUSH14 0x0cae6c2d8ca40c2dadeeadce8405 2467 60 PUSH1 0x93 2469 1B SHL 246A 60 PUSH1 0x20 246C 82 DUP3 246D 01 ADD 246E 52 MSTORE 246F 60 PUSH1 0x2e 2471 01 ADD 2472 60 PUSH1 0x00 2474 61 PUSH2 0x247d 2477 82 DUP3 2478 84 DUP5 2479 61 PUSH2 0x1e15 247C 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @2457 memory[stack[-1]:stack[-1] + 0x20] = 0x43616e2774206d696e74206d6f7265207468616e207265736572766564207072 // @246E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0cae6c2d8ca40c2dadeeadce8405 << 0x93 // @2471 stack[-1] = 0x2e + stack[-1] // @2472 stack[0] = 0x00 // @2474 stack[1] = 0x247d // @2477 stack[2] = 0x2e + stack[-1] // @2478 stack[3] = stack[-2] // } // Block ends with call to 0x1e15, returns to 0x247D label_247D: // Incoming return from call to 0x1E15 at 0x247C // Inputs[2] // { // @247E stack[-3] // @247E stack[-1] // } 247D 5B JUMPDEST 247E 91 SWAP2 247F 50 POP 2480 61 PUSH2 0x0eb5 2483 82 DUP3 2484 61 PUSH2 0x206c 2487 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @247E stack[-3] = stack[-1] // @2480 stack[-1] = 0x0eb5 // @2483 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x206c label_2488: // Incoming jump from 0x0282 // Inputs[2] // { // @248B stack[-1] // @2491 stack[-2] // } 2488 5B JUMPDEST 2489 60 PUSH1 0x20 248B 81 DUP2 248C 01 ADD 248D 61 PUSH2 0x088a 2490 82 DUP3 2491 84 DUP5 2492 61 PUSH2 0x1dcc 2495 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @248C stack[0] = stack[-1] + 0x20 // @248D stack[1] = 0x088a // @2490 stack[2] = stack[-1] // @2491 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1dcc label_2496: // Incoming jump from 0x14E8 // Inputs[2] // { // @2499 stack[-1] // @249F stack[-5] // } 2496 5B JUMPDEST 2497 60 PUSH1 0x80 2499 81 DUP2 249A 01 ADD 249B 61 PUSH2 0x24a4 249E 82 DUP3 249F 87 DUP8 24A0 61 PUSH2 0x1dcc 24A3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @249A stack[0] = stack[-1] + 0x80 // @249B stack[1] = 0x24a4 // @249E stack[2] = stack[-1] // @249F stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1dcc 24A4 5B JUMPDEST 24A5 61 PUSH2 0x24b1 24A8 60 PUSH1 0x20 24AA 83 DUP4 24AB 01 ADD 24AC 86 DUP7 24AD 61 PUSH2 0x1dcc 24B0 56 *JUMP 24B1 5B JUMPDEST 24B2 61 PUSH2 0x24be 24B5 60 PUSH1 0x40 24B7 83 DUP4 24B8 01 ADD 24B9 85 DUP6 24BA 61 PUSH2 0x2416 24BD 56 *JUMP 24BE 5B JUMPDEST 24BF 81 DUP2 24C0 81 DUP2 24C1 03 SUB 24C2 60 PUSH1 0x60 24C4 83 DUP4 24C5 01 ADD 24C6 52 MSTORE 24C7 61 PUSH2 0x24d0 24CA 81 DUP2 24CB 84 DUP5 24CC 61 PUSH2 0x1de3 24CF 56 *JUMP 24D0 5B JUMPDEST 24D1 96 SWAP7 24D2 95 SWAP6 24D3 50 POP 24D4 50 POP 24D5 50 POP 24D6 50 POP 24D7 50 POP 24D8 50 POP 24D9 56 *JUMP 24DA 5B JUMPDEST 24DB 60 PUSH1 0x20 24DD 81 DUP2 24DE 01 ADD 24DF 61 PUSH2 0x088a 24E2 82 DUP3 24E3 84 DUP5 24E4 61 PUSH2 0x1ddb 24E7 56 *JUMP label_24E8: // Incoming call from 0x0255, returns to 0x022B // Inputs[2] // { // @24EC stack[-1] // @24F4 stack[-2] // } 24E8 5B JUMPDEST 24E9 60 PUSH1 0x20 24EB 80 DUP1 24EC 82 DUP3 24ED 52 MSTORE 24EE 81 DUP2 24EF 01 ADD 24F0 61 PUSH2 0x0eb5 24F3 81 DUP2 24F4 84 DUP5 24F5 61 PUSH2 0x1de3 24F8 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @24ED memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24EF stack[0] = stack[-1] + 0x20 // @24F0 stack[1] = 0x0eb5 // @24F3 stack[2] = stack[-1] + 0x20 // @24F4 stack[3] = stack[-2] // } // Block ends with call to 0x1de3, returns to 0x0EB5 label_24F9: // Incoming jump from 0x0DCD // Incoming jump from 0x096B // Inputs[1] { @24FD stack[-1] } 24F9 5B JUMPDEST 24FA 60 PUSH1 0x20 24FC 80 DUP1 24FD 82 DUP3 24FE 52 MSTORE 24FF 81 DUP2 2500 01 ADD 2501 61 PUSH2 0x0662 2504 81 DUP2 2505 61 PUSH2 0x1e37 2508 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24FE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2500 stack[0] = stack[-1] + 0x20 // @2501 stack[1] = 0x0662 // @2504 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1e37, returns to 0x0662 2509 5B JUMPDEST 250A 60 PUSH1 0x20 250C 80 DUP1 250D 82 DUP3 250E 52 MSTORE 250F 81 DUP2 2510 01 ADD 2511 61 PUSH2 0x0662 2514 81 DUP2 2515 61 PUSH2 0x1e5f 2518 56 *JUMP label_2519: // Incoming jump from 0x16A1 // Inputs[1] { @251D stack[-1] } 2519 5B JUMPDEST 251A 60 PUSH1 0x20 251C 80 DUP1 251D 82 DUP3 251E 52 MSTORE 251F 81 DUP2 2520 01 ADD 2521 61 PUSH2 0x0662 2524 81 DUP2 2525 61 PUSH2 0x1eaa 2528 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @251E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2520 stack[0] = stack[-1] + 0x20 // @2521 stack[1] = 0x0662 // @2524 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1eaa, returns to 0x0662 2529 5B JUMPDEST 252A 60 PUSH1 0x20 252C 80 DUP1 252D 82 DUP3 252E 52 MSTORE 252F 81 DUP2 2530 01 ADD 2531 61 PUSH2 0x0662 2534 81 DUP2 2535 61 PUSH2 0x1ef9 2538 56 *JUMP label_2539: // Incoming jump from 0x18B6 // Inputs[1] { @253D stack[-1] } 2539 5B JUMPDEST 253A 60 PUSH1 0x20 253C 80 DUP1 253D 82 DUP3 253E 52 MSTORE 253F 81 DUP2 2540 01 ADD 2541 61 PUSH2 0x0662 2544 81 DUP2 2545 61 PUSH2 0x1f3c 2548 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @253E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2540 stack[0] = stack[-1] + 0x20 // @2541 stack[1] = 0x0662 // @2544 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1f3c, returns to 0x0662 2549 5B JUMPDEST 254A 60 PUSH1 0x20 254C 80 DUP1 254D 82 DUP3 254E 52 MSTORE 254F 81 DUP2 2550 01 ADD 2551 61 PUSH2 0x0662 2554 81 DUP2 2555 61 PUSH2 0x1f70 2558 56 *JUMP 2559 5B JUMPDEST 255A 60 PUSH1 0x20 255C 80 DUP1 255D 82 DUP3 255E 52 MSTORE 255F 81 DUP2 2560 01 ADD 2561 61 PUSH2 0x0662 2564 81 DUP2 2565 61 PUSH2 0x1fb1 2568 56 *JUMP label_2569: // Incoming jump from 0x136C // Inputs[1] { @256D stack[-1] } 2569 5B JUMPDEST 256A 60 PUSH1 0x20 256C 80 DUP1 256D 82 DUP3 256E 52 MSTORE 256F 81 DUP2 2570 01 ADD 2571 61 PUSH2 0x0662 2574 81 DUP2 2575 61 PUSH2 0x1fe5 2578 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @256E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2570 stack[0] = stack[-1] + 0x20 // @2571 stack[1] = 0x0662 // @2574 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1fe5, returns to 0x0662 2579 5B JUMPDEST 257A 60 PUSH1 0x20 257C 80 DUP1 257D 82 DUP3 257E 52 MSTORE 257F 81 DUP2 2580 01 ADD 2581 61 PUSH2 0x0662 2584 81 DUP2 2585 61 PUSH2 0x2023 2588 56 *JUMP 2589 5B JUMPDEST 258A 60 PUSH1 0x20 258C 80 DUP1 258D 82 DUP3 258E 52 MSTORE 258F 81 DUP2 2590 01 ADD 2591 61 PUSH2 0x0662 2594 81 DUP2 2595 61 PUSH2 0x207d 2598 56 *JUMP label_2599: // Incoming jump from 0x0BDA // Inputs[1] { @259D stack[-1] } 2599 5B JUMPDEST 259A 60 PUSH1 0x20 259C 80 DUP1 259D 82 DUP3 259E 52 MSTORE 259F 81 DUP2 25A0 01 ADD 25A1 61 PUSH2 0x0662 25A4 81 DUP2 25A5 61 PUSH2 0x20d7 25A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @259E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25A0 stack[0] = stack[-1] + 0x20 // @25A1 stack[1] = 0x0662 // @25A4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x20d7, returns to 0x0662 label_25A9: // Incoming jump from 0x0B24 // Inputs[1] { @25AD stack[-1] } 25A9 5B JUMPDEST 25AA 60 PUSH1 0x20 25AC 80 DUP1 25AD 82 DUP3 25AE 52 MSTORE 25AF 81 DUP2 25B0 01 ADD 25B1 61 PUSH2 0x0662 25B4 81 DUP2 25B5 61 PUSH2 0x211e 25B8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25AE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25B0 stack[0] = stack[-1] + 0x20 // @25B1 stack[1] = 0x0662 // @25B4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x211e, returns to 0x0662 label_25B9: // Incoming jump from 0x1881 // Inputs[1] { @25BD stack[-1] } 25B9 5B JUMPDEST 25BA 60 PUSH1 0x20 25BC 80 DUP1 25BD 82 DUP3 25BE 52 MSTORE 25BF 81 DUP2 25C0 01 ADD 25C1 61 PUSH2 0x0662 25C4 81 DUP2 25C5 61 PUSH2 0x2164 25C8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25BE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25C0 stack[0] = stack[-1] + 0x20 // @25C1 stack[1] = 0x0662 // @25C4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2164, returns to 0x0662 label_25C9: // Incoming jump from 0x072F // Inputs[1] { @25CD stack[-1] } 25C9 5B JUMPDEST 25CA 60 PUSH1 0x20 25CC 80 DUP1 25CD 82 DUP3 25CE 52 MSTORE 25CF 81 DUP2 25D0 01 ADD 25D1 61 PUSH2 0x0662 25D4 81 DUP2 25D5 61 PUSH2 0x2196 25D8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25CE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25D0 stack[0] = stack[-1] + 0x20 // @25D1 stack[1] = 0x0662 // @25D4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2196, returns to 0x0662 label_25D9: // Incoming call from 0x0C56, returns to 0x0730 // Incoming call from 0x077E, returns to 0x0730 // Incoming call from 0x08B9, returns to 0x0730 // Incoming call from 0x0C20, returns to 0x0730 // Inputs[1] { @25DD stack[-1] } 25D9 5B JUMPDEST 25DA 60 PUSH1 0x20 25DC 80 DUP1 25DD 82 DUP3 25DE 52 MSTORE 25DF 81 DUP2 25E0 01 ADD 25E1 61 PUSH2 0x0662 25E4 81 DUP2 25E5 61 PUSH2 0x21df 25E8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25DE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25E0 stack[0] = stack[-1] + 0x20 // @25E1 stack[1] = 0x0662 // @25E4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x21df, returns to 0x0662 25E9 5B JUMPDEST 25EA 60 PUSH1 0x20 25EC 80 DUP1 25ED 82 DUP3 25EE 52 MSTORE 25EF 81 DUP2 25F0 01 ADD 25F1 61 PUSH2 0x0662 25F4 81 DUP2 25F5 61 PUSH2 0x2211 25F8 56 *JUMP label_25F9: // Incoming jump from 0x0E5F // Inputs[1] { @25FD stack[-1] } 25F9 5B JUMPDEST 25FA 60 PUSH1 0x20 25FC 80 DUP1 25FD 82 DUP3 25FE 52 MSTORE 25FF 81 DUP2 2600 01 ADD 2601 61 PUSH2 0x0662 2604 81 DUP2 2605 61 PUSH2 0x2257 2608 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25FE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2600 stack[0] = stack[-1] + 0x20 // @2601 stack[1] = 0x0662 // @2604 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2257, returns to 0x0662 label_2609: // Incoming jump from 0x0DEE // Inputs[1] { @260D stack[-1] } 2609 5B JUMPDEST 260A 60 PUSH1 0x20 260C 80 DUP1 260D 82 DUP3 260E 52 MSTORE 260F 81 DUP2 2610 01 ADD 2611 61 PUSH2 0x0662 2614 81 DUP2 2615 61 PUSH2 0x22a3 2618 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @260E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2610 stack[0] = stack[-1] + 0x20 // @2611 stack[1] = 0x0662 // @2614 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x22a3, returns to 0x0662 2619 5B JUMPDEST 261A 60 PUSH1 0x20 261C 80 DUP1 261D 82 DUP3 261E 52 MSTORE 261F 81 DUP2 2620 01 ADD 2621 61 PUSH2 0x0662 2624 81 DUP2 2625 61 PUSH2 0x22e3 2628 56 *JUMP label_2629: // Incoming jump from 0x0E1B // Inputs[1] { @262D stack[-1] } 2629 5B JUMPDEST 262A 60 PUSH1 0x20 262C 80 DUP1 262D 82 DUP3 262E 52 MSTORE 262F 81 DUP2 2630 01 ADD 2631 61 PUSH2 0x0662 2634 81 DUP2 2635 61 PUSH2 0x2321 2638 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @262E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2630 stack[0] = stack[-1] + 0x20 // @2631 stack[1] = 0x0662 // @2634 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2321, returns to 0x0662 2639 5B JUMPDEST 263A 60 PUSH1 0x20 263C 80 DUP1 263D 82 DUP3 263E 52 MSTORE 263F 81 DUP2 2640 01 ADD 2641 61 PUSH2 0x0662 2644 81 DUP2 2645 61 PUSH2 0x234b 2648 56 *JUMP label_2649: // Incoming jump from 0x0998 // Inputs[1] { @264D stack[-1] } 2649 5B JUMPDEST 264A 60 PUSH1 0x20 264C 80 DUP1 264D 82 DUP3 264E 52 MSTORE 264F 81 DUP2 2650 01 ADD 2651 61 PUSH2 0x0662 2654 81 DUP2 2655 61 PUSH2 0x2399 2658 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @264E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2650 stack[0] = stack[-1] + 0x20 // @2651 stack[1] = 0x0662 // @2654 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2399, returns to 0x0662 label_2659: // Incoming jump from 0x0A7F // Inputs[1] { @265D stack[-1] } 2659 5B JUMPDEST 265A 60 PUSH1 0x20 265C 80 DUP1 265D 82 DUP3 265E 52 MSTORE 265F 81 DUP2 2660 01 ADD 2661 61 PUSH2 0x0662 2664 81 DUP2 2665 61 PUSH2 0x23cd 2668 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @265E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2660 stack[0] = stack[-1] + 0x20 // @2661 stack[1] = 0x0662 // @2664 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x23cd, returns to 0x0662 label_2669: // Incoming call from 0x02FE, returns to 0x022B // Inputs[2] // { // @266C stack[-1] // @2672 stack[-2] // } 2669 5B JUMPDEST 266A 60 PUSH1 0x20 266C 81 DUP2 266D 01 ADD 266E 61 PUSH2 0x088a 2671 82 DUP3 2672 84 DUP5 2673 61 PUSH2 0x2416 2676 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @266D stack[0] = stack[-1] + 0x20 // @266E stack[1] = 0x088a // @2671 stack[2] = stack[-1] // @2672 stack[3] = stack[-2] // } // Block ends with call to 0x2416, returns to 0x088A label_2677: // Incoming jump from 0x19F5 // Inputs[1] { @267F memory[0x40:0x60] } 2677 5B JUMPDEST 2678 60 PUSH1 0x00 267A 61 PUSH2 0x2682 267D 60 PUSH1 0x40 267F 51 MLOAD 2680 90 SWAP1 2681 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2678 stack[0] = 0x00 // @2680 stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2682 label_2682: // Incoming jump from 0x2681 // Inputs[3] // { // @2683 stack[-2] // @2683 stack[-1] // @2688 stack[-3] // } 2682 5B JUMPDEST 2683 90 SWAP1 2684 50 POP 2685 61 PUSH2 0x0665 2688 82 DUP3 2689 82 DUP3 268A 61 PUSH2 0x27d6 268D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2683 stack[-2] = stack[-1] // @2685 stack[-1] = 0x0665 // @2688 stack[0] = stack[-3] // @2689 stack[1] = stack[-1] // } // Block ends with call to 0x27d6, returns to 0x0665 label_268E: // Incoming call from 0x19F0, returns to 0x19F1 // Inputs[1] { @269A stack[-1] } 268E 5B JUMPDEST 268F 60 PUSH1 0x00 2691 67 PUSH8 0xffffffffffffffff 269A 82 DUP3 269B 11 GT 269C 15 ISZERO 269D 61 PUSH2 0x26a8 26A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @268F stack[0] = 0x00 } // Block ends with conditional jump to 0x26a8, if !(stack[-1] > 0xffffffffffffffff) label_26A1: // Incoming jump from 0x26A0, if not !(stack[-1] > 0xffffffffffffffff) 26A1 61 PUSH2 0x26a8 26A4 61 PUSH2 0x286d 26A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @26A1 stack[0] = 0x26a8 } // Block ends with unconditional jump to 0x286d label_26A8: // Incoming jump from 0x26A0, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @26AC stack[-2] // @26AD stack[-3] // } 26A8 5B JUMPDEST 26A9 50 POP 26AA 60 PUSH1 0x20 26AC 02 MUL 26AD 90 SWAP1 26AE 56 *JUMP // Stack delta = -2 // Outputs[1] { @26AD stack[-3] = 0x20 * stack[-2] } // Block ends with unconditional jump to stack[-3] label_26AF: // Incoming call from 0x1A4F, returns to 0x19F1 // Inputs[1] { @26BB stack[-1] } 26AF 5B JUMPDEST 26B0 60 PUSH1 0x00 26B2 67 PUSH8 0xffffffffffffffff 26BB 82 DUP3 26BC 11 GT 26BD 15 ISZERO 26BE 61 PUSH2 0x26c9 26C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26B0 stack[0] = 0x00 } // Block ends with conditional jump to 0x26c9, if !(stack[-1] > 0xffffffffffffffff) label_26C2: // Incoming jump from 0x26C1, if not !(stack[-1] > 0xffffffffffffffff) 26C2 61 PUSH2 0x26c9 26C5 61 PUSH2 0x286d 26C8 56 *JUMP // Stack delta = +1 // Outputs[1] { @26C2 stack[0] = 0x26c9 } // Block ends with unconditional jump to 0x286d label_26C9: // Incoming jump from 0x26C1, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @26CD stack[-2] // @26D1 stack[-3] // } 26C9 5B JUMPDEST 26CA 50 POP 26CB 60 PUSH1 0x20 26CD 90 SWAP1 26CE 81 DUP2 26CF 02 MUL 26D0 01 ADD 26D1 90 SWAP1 26D2 56 *JUMP // Stack delta = -2 // Outputs[1] { @26D1 stack[-3] = 0x20 * stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_26D3: // Incoming call from 0x1AA8, returns to 0x19F1 // Inputs[1] { @26DF stack[-1] } 26D3 5B JUMPDEST 26D4 60 PUSH1 0x00 26D6 67 PUSH8 0xffffffffffffffff 26DF 82 DUP3 26E0 11 GT 26E1 15 ISZERO 26E2 61 PUSH2 0x26ed 26E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26D4 stack[0] = 0x00 } // Block ends with conditional jump to 0x26ed, if !(stack[-1] > 0xffffffffffffffff) label_26E6: // Incoming jump from 0x26E5, if not !(stack[-1] > 0xffffffffffffffff) 26E6 61 PUSH2 0x26ed 26E9 61 PUSH2 0x286d 26EC 56 *JUMP // Stack delta = +1 // Outputs[1] { @26E6 stack[0] = 0x26ed } // Block ends with unconditional jump to 0x286d label_26ED: // Incoming jump from 0x26E5, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @26F3 stack[-2] // @26F9 stack[-3] // } 26ED 5B JUMPDEST 26EE 60 PUSH1 0x1f 26F0 19 NOT 26F1 60 PUSH1 0x1f 26F3 83 DUP4 26F4 01 ADD 26F5 16 AND 26F6 60 PUSH1 0x20 26F8 01 ADD 26F9 92 SWAP3 26FA 91 SWAP2 26FB 50 POP 26FC 50 POP 26FD 56 *JUMP // Stack delta = -2 // Outputs[1] { @26F9 stack[-3] = 0x20 + (stack[-2] + 0x1f & ~0x1f) } // Block ends with unconditional jump to stack[-3] label_26FE: // Incoming call from 0x12E8, returns to 0x12E9 // Incoming call from 0x18EB, returns to 0x18EC // Incoming call from 0x1384, returns to 0x1385 // Incoming call from 0x134E, returns to 0x134F // Inputs[2] // { // @2701 stack[-2] // @2703 stack[-1] // } 26FE 5B JUMPDEST 26FF 60 PUSH1 0x00 2701 82 DUP3 2702 19 NOT 2703 82 DUP3 2704 11 GT 2705 15 ISZERO 2706 61 PUSH2 0x2711 2709 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26FF stack[0] = 0x00 } // Block ends with conditional jump to 0x2711, if !(stack[-1] > ~stack[-2]) label_270A: // Incoming jump from 0x2709, if not !(stack[-1] > ~stack[-2]) 270A 61 PUSH2 0x2711 270D 61 PUSH2 0x282b 2710 56 *JUMP // Stack delta = +1 // Outputs[1] { @270A stack[0] = 0x2711 } // Block ends with unconditional jump to 0x282b label_2711: // Incoming jump from 0x2709, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2713 stack[-2] // @2713 stack[-3] // @2714 stack[-4] // } 2711 5B JUMPDEST 2712 50 POP 2713 01 ADD 2714 90 SWAP1 2715 56 *JUMP // Stack delta = -3 // Outputs[1] { @2714 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2716: // Incoming call from 0x08C6, returns to 0x08C7 // Incoming call from 0x132D, returns to 0x132E // Incoming call from 0x1261, returns to 0x1262 // Inputs[1] { @2719 stack[-2] } 2716 5B JUMPDEST 2717 60 PUSH1 0x00 2719 82 DUP3 271A 61 PUSH2 0x2725 271D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2717 stack[0] = 0x00 } // Block ends with conditional jump to 0x2725, if stack[-2] label_271E: // Incoming jump from 0x271D, if not stack[-2] 271E 61 PUSH2 0x2725 2721 61 PUSH2 0x2841 2724 56 *JUMP // Stack delta = +1 // Outputs[1] { @271E stack[0] = 0x2725 } // Block ends with unconditional jump to 0x2841 label_2725: // Incoming jump from 0x271D, if stack[-2] // Inputs[3] // { // @2727 stack[-3] // @2727 stack[-2] // @2728 stack[-4] // } 2725 5B JUMPDEST 2726 50 POP 2727 04 DIV 2728 90 SWAP1 2729 56 *JUMP // Stack delta = -3 // Outputs[1] { @2728 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_272A: // Incoming call from 0x08D5, returns to 0x08D6 // Incoming call from 0x0DFC, returns to 0x0DFD // Incoming call from 0x08E4, returns to 0x08E5 // Inputs[2] // { // @272D stack[-1] // @2732 stack[-2] // } 272A 5B JUMPDEST 272B 60 PUSH1 0x00 272D 81 DUP2 272E 60 PUSH1 0x00 2730 19 NOT 2731 04 DIV 2732 83 DUP4 2733 11 GT 2734 82 DUP3 2735 15 ISZERO 2736 15 ISZERO 2737 16 AND 2738 15 ISZERO 2739 61 PUSH2 0x2744 273C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @272B stack[0] = 0x00 } // Block ends with conditional jump to 0x2744, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_273D: // Incoming jump from 0x273C, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 273D 61 PUSH2 0x2744 2740 61 PUSH2 0x282b 2743 56 *JUMP // Stack delta = +1 // Outputs[1] { @273D stack[0] = 0x2744 } // Block ends with unconditional jump to 0x282b label_2744: // Incoming jump from 0x273C, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2746 stack[-3] // @2746 stack[-2] // @2747 stack[-4] // } 2744 5B JUMPDEST 2745 50 POP 2746 02 MUL 2747 90 SWAP1 2748 56 *JUMP // Stack delta = -3 // Outputs[1] { @2747 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2749: // Incoming call from 0x1750, returns to 0x1751 // Incoming call from 0x16B8, returns to 0x16B9 // Incoming call from 0x12D0, returns to 0x12D1 // Inputs[2] // { // @274C stack[-2] // @274D stack[-1] // } 2749 5B JUMPDEST 274A 60 PUSH1 0x00 274C 82 DUP3 274D 82 DUP3 274E 10 LT 274F 15 ISZERO 2750 61 PUSH2 0x275b 2753 57 *JUMPI // Stack delta = +1 // Outputs[1] { @274A stack[0] = 0x00 } // Block ends with conditional jump to 0x275b, if !(stack[-1] < stack[-2]) label_2754: // Incoming jump from 0x2753, if not !(stack[-1] < stack[-2]) 2754 61 PUSH2 0x275b 2757 61 PUSH2 0x282b 275A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2754 stack[0] = 0x275b } // Block ends with unconditional jump to 0x282b label_275B: // Incoming jump from 0x2753, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @275D stack[-3] // @275D stack[-2] // @275E stack[-4] // } 275B 5B JUMPDEST 275C 50 POP 275D 03 SUB 275E 90 SWAP1 275F 56 *JUMP // Stack delta = -3 // Outputs[1] { @275E stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2760: // Incoming call from 0x288B, returns to 0x288C // Incoming call from 0x1DD4, returns to 0x1DD5 // Inputs[1] { @276B stack[-1] } 2760 5B JUMPDEST 2761 60 PUSH1 0x00 2763 60 PUSH1 0x01 2765 60 PUSH1 0x01 2767 60 PUSH1 0xa0 2769 1B SHL 276A 03 SUB 276B 82 DUP3 276C 16 AND 276D 61 PUSH2 0x0662 2770 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2761 stack[0] = 0x00 // @276C stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0662 label_2771: // Incoming call from 0x1ACB, returns to 0x1ACC // Inputs[5] // { // @2772 stack[-3] // @2773 stack[-1] // @2774 stack[-2] // @2775 msg.data[stack[-1]:stack[-1] + stack[-3]] // @277C stack[-4] // } 2771 5B JUMPDEST 2772 82 DUP3 2773 81 DUP2 2774 83 DUP4 2775 37 CALLDATACOPY 2776 50 POP 2777 60 PUSH1 0x00 2779 91 SWAP2 277A 01 ADD 277B 52 MSTORE 277C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2775 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @277B memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_277D: // Incoming call from 0x1E2C, returns to 0x1E2D // Incoming call from 0x1E03, returns to 0x1E04 // Inputs[1] { @2781 stack[-3] } 277D 5B JUMPDEST 277E 60 PUSH1 0x00 2780 5B JUMPDEST 2781 83 DUP4 2782 81 DUP2 2783 10 LT 2784 15 ISZERO 2785 61 PUSH2 0x2798 2788 57 *JUMPI // Stack delta = +1 // Outputs[1] { @277E stack[0] = 0x00 } // Block ends with conditional jump to 0x2798, if !(0x00 < stack[-3]) label_2789: // Incoming jump from 0x2788, if not !(0x00 < stack[-3]) // Incoming jump from 0x2788, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2789 stack[-2] // @278A stack[-1] // @278C memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @278D stack[-3] // } 2789 81 DUP2 278A 81 DUP2 278B 01 ADD 278C 51 MLOAD 278D 83 DUP4 278E 82 DUP3 278F 01 ADD 2790 52 MSTORE 2791 60 PUSH1 0x20 2793 01 ADD 2794 61 PUSH2 0x2780 2797 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2790 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2793 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2780 label_2798: // Incoming jump from 0x2788, if !(0x00 < stack[-3]) // Incoming jump from 0x2788, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2799 stack[-4] // @279A stack[-1] // } 2798 5B JUMPDEST 2799 83 DUP4 279A 81 DUP2 279B 11 GT 279C 15 ISZERO 279D 61 PUSH2 0x0da6 27A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da6, if !(stack[-1] > stack[-4]) label_27A1: // Incoming jump from 0x27A0, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @27A5 stack[-4] // @27A6 stack[-3] // @27A8 stack[-5] // } 27A1 50 POP 27A2 50 POP 27A3 60 PUSH1 0x00 27A5 91 SWAP2 27A6 01 ADD 27A7 52 MSTORE 27A8 56 *JUMP // Stack delta = -5 // Outputs[1] { @27A7 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_27A9: // Incoming call from 0x0B31, returns to 0x0B32 // Incoming call from 0x0CD5, returns to 0x0679 // Incoming call from 0x142F, returns to 0x0679 // Incoming call from 0x06A4, returns to 0x06A5 // Incoming call from 0x0B5D, returns to 0x0B5E // Incoming call from 0x0678, returns to 0x0679 // Inputs[1] { @27AC stack[-1] } 27A9 5B JUMPDEST 27AA 60 PUSH1 0x02 27AC 81 DUP2 27AD 04 DIV 27AE 60 PUSH1 0x01 27B0 82 DUP3 27B1 16 AND 27B2 80 DUP1 27B3 61 PUSH2 0x27bd 27B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27AD stack[0] = stack[-1] / 0x02 // @27B1 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x27bd, if stack[-1] & 0x01 label_27B7: // Incoming jump from 0x27B6, if not stack[-1] & 0x01 // Inputs[2] // { // @27B9 stack[-2] // @27C2 stack[-1] // } 27B7 60 PUSH1 0x7f 27B9 82 DUP3 27BA 16 AND 27BB 91 SWAP2 27BC 50 POP 27BD 5B JUMPDEST 27BE 60 PUSH1 0x20 27C0 82 DUP3 27C1 10 LT 27C2 81 DUP2 27C3 14 EQ 27C4 15 ISZERO 27C5 61 PUSH2 0x27d0 27C8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27BB stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x27d0, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_27C9: // Incoming jump from 0x27C8, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x27C8, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 27C9 61 PUSH2 0x27d0 27CC 61 PUSH2 0x2857 27CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @27C9 stack[0] = 0x27d0 } // Block ends with unconditional jump to 0x2857 label_27D0: // Incoming jump from 0x27C8, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x27C8, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @27D2 stack[-4] // @27D2 stack[-2] // @27D3 stack[-3] // } 27D0 5B JUMPDEST 27D1 50 POP 27D2 91 SWAP2 27D3 90 SWAP1 27D4 50 POP 27D5 56 *JUMP // Stack delta = -3 // Outputs[1] { @27D2 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_27D6: // Incoming call from 0x268D, returns to 0x0665 // Inputs[2] // { // @27DC stack[-2] // @27DF stack[-1] // } 27D6 5B JUMPDEST 27D7 60 PUSH1 0x1f 27D9 19 NOT 27DA 60 PUSH1 0x1f 27DC 83 DUP4 27DD 01 ADD 27DE 16 AND 27DF 81 DUP2 27E0 01 ADD 27E1 81 DUP2 27E2 81 DUP2 27E3 10 LT 27E4 67 PUSH8 0xffffffffffffffff 27ED 82 DUP3 27EE 11 GT 27EF 17 OR 27F0 15 ISZERO 27F1 61 PUSH2 0x27fc 27F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27E0 stack[0] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x27fc, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) label_27F5: // Incoming jump from 0x27F4, if not !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) 27F5 61 PUSH2 0x27fc 27F8 61 PUSH2 0x286d 27FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @27F5 stack[0] = 0x27fc } // Block ends with unconditional jump to 0x286d label_27FC: // Incoming jump from 0x27F4, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) // Inputs[2] // { // @27FF stack[-1] // @2802 stack[-4] // } 27FC 5B JUMPDEST 27FD 60 PUSH1 0x40 27FF 52 MSTORE 2800 50 POP 2801 50 POP 2802 56 *JUMP // Stack delta = -4 // Outputs[1] { @27FF memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2803: // Incoming call from 0x1393, returns to 0x1394 // Incoming call from 0x1252, returns to 0x1253 // Incoming call from 0x0CBE, returns to 0x0CBF // Inputs[1] { @2809 stack[-1] } 2803 5B JUMPDEST 2804 60 PUSH1 0x00 2806 60 PUSH1 0x00 2808 19 NOT 2809 82 DUP3 280A 14 EQ 280B 15 ISZERO 280C 61 PUSH2 0x2076 280F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2804 stack[0] = 0x00 } // Block ends with conditional jump to 0x2076, if !(stack[-1] == ~0x00) label_2810: // Incoming jump from 0x280F, if not !(stack[-1] == ~0x00) 2810 61 PUSH2 0x2076 2813 61 PUSH2 0x282b 2816 56 *JUMP // Stack delta = +1 // Outputs[1] { @2810 stack[0] = 0x2076 } // Block ends with unconditional jump to 0x282b label_2817: // Incoming call from 0x12DD, returns to 0x12DE // Inputs[1] { @281A stack[-2] } 2817 5B JUMPDEST 2818 60 PUSH1 0x00 281A 82 DUP3 281B 61 PUSH2 0x2826 281E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2818 stack[0] = 0x00 } // Block ends with conditional jump to 0x2826, if stack[-2] label_281F: // Incoming jump from 0x281E, if not stack[-2] 281F 61 PUSH2 0x2826 2822 61 PUSH2 0x2841 2825 56 *JUMP // Stack delta = +1 // Outputs[1] { @281F stack[0] = 0x2826 } // Block ends with unconditional jump to 0x2841 label_2826: // Incoming jump from 0x281E, if stack[-2] // Inputs[3] // { // @2828 stack[-3] // @2828 stack[-2] // @2829 stack[-4] // } 2826 5B JUMPDEST 2827 50 POP 2828 06 MOD 2829 90 SWAP1 282A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2829 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_282B: // Incoming jump from 0x2743 // Incoming jump from 0x2710 // Incoming jump from 0x275A // Incoming jump from 0x2816 // Inputs[1] { @2840 memory[0x00:0x24] } 282B 5B JUMPDEST 282C 63 PUSH4 0x4e487b71 2831 60 PUSH1 0xe0 2833 1B SHL 2834 60 PUSH1 0x00 2836 52 MSTORE 2837 60 PUSH1 0x11 2839 60 PUSH1 0x04 283B 52 MSTORE 283C 60 PUSH1 0x24 283E 60 PUSH1 0x00 2840 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2836 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @283B memory[0x04:0x24] = 0x11 // @2840 revert(memory[0x00:0x24]); // } // Block terminates label_2841: // Incoming jump from 0x2825 // Incoming jump from 0x2724 // Inputs[1] { @2856 memory[0x00:0x24] } 2841 5B JUMPDEST 2842 63 PUSH4 0x4e487b71 2847 60 PUSH1 0xe0 2849 1B SHL 284A 60 PUSH1 0x00 284C 52 MSTORE 284D 60 PUSH1 0x12 284F 60 PUSH1 0x04 2851 52 MSTORE 2852 60 PUSH1 0x24 2854 60 PUSH1 0x00 2856 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @284C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2851 memory[0x04:0x24] = 0x12 // @2856 revert(memory[0x00:0x24]); // } // Block terminates label_2857: // Incoming jump from 0x27CF // Inputs[1] { @286C memory[0x00:0x24] } 2857 5B JUMPDEST 2858 63 PUSH4 0x4e487b71 285D 60 PUSH1 0xe0 285F 1B SHL 2860 60 PUSH1 0x00 2862 52 MSTORE 2863 60 PUSH1 0x22 2865 60 PUSH1 0x04 2867 52 MSTORE 2868 60 PUSH1 0x24 286A 60 PUSH1 0x00 286C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2862 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2867 memory[0x04:0x24] = 0x22 // @286C revert(memory[0x00:0x24]); // } // Block terminates label_286D: // Incoming jump from 0x26EC // Incoming jump from 0x26C8 // Incoming jump from 0x26A7 // Incoming jump from 0x27FB // Inputs[1] { @2882 memory[0x00:0x24] } 286D 5B JUMPDEST 286E 63 PUSH4 0x4e487b71 2873 60 PUSH1 0xe0 2875 1B SHL 2876 60 PUSH1 0x00 2878 52 MSTORE 2879 60 PUSH1 0x41 287B 60 PUSH1 0x04 287D 52 MSTORE 287E 60 PUSH1 0x24 2880 60 PUSH1 0x00 2882 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2878 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @287D memory[0x04:0x24] = 0x41 // @2882 revert(memory[0x00:0x24]); // } // Block terminates label_2883: // Incoming jump from 0x1ADE // Inputs[1] { @2887 stack[-1] } 2883 5B JUMPDEST 2884 61 PUSH2 0x288c 2887 81 DUP2 2888 61 PUSH2 0x2760 288B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2884 stack[0] = 0x288c // @2887 stack[1] = stack[-1] // } // Block ends with call to 0x2760, returns to 0x288C label_288C: // Incoming jump from 0x28AE // Incoming jump from 0x28B4 // Incoming return from call to 0x2760 at 0x288B // Inputs[2] // { // @288D stack[-2] // @288E stack[-1] // } 288C 5B JUMPDEST 288D 81 DUP2 288E 14 EQ 288F 61 PUSH2 0x0e26 2892 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e26, if stack[-2] == stack[-1] label_2893: // Incoming jump from 0x2892, if not stack[-2] == stack[-1] // Inputs[1] { @2896 memory[0x00:0x00] } 2893 60 PUSH1 0x00 2895 80 DUP1 2896 FD *REVERT // Stack delta = +0 // Outputs[1] { @2896 revert(memory[0x00:0x00]); } // Block terminates 2897 5B JUMPDEST 2898 80 DUP1 2899 15 ISZERO 289A 15 ISZERO 289B 61 PUSH2 0x288c 289E 56 *JUMP label_289F: // Incoming call from 0x1B33, returns to 0x088A // Inputs[1] { @28A9 stack[-1] } 289F 5B JUMPDEST 28A0 60 PUSH1 0x01 28A2 60 PUSH1 0x01 28A4 60 PUSH1 0xe0 28A6 1B SHL 28A7 03 SUB 28A8 19 NOT 28A9 81 DUP2 28AA 16 AND 28AB 61 PUSH2 0x288c 28AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @28AA stack[0] = stack[-1] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to 0x288c label_28AF: // Incoming call from 0x1B6A, returns to 0x088A // Inputs[1] { @28B0 stack[-1] } 28AF 5B JUMPDEST 28B0 80 DUP1 28B1 61 PUSH2 0x288c 28B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @28B0 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x288c 28B5 FE *ASSERT 28B6 A2 LOG2 28B7 64 PUSH5 0x6970667358 28BD 22 22 28BE 12 SLT 28BF 20 SHA3 28C0 61 PUSH2 0x4ffc 28C3 17 OR 28C4 6C PUSH13 0x76e3c4594eea6b5ffc3ee411bd 28D2 DA DA 28D3 78 PUSH25 0x55d7bd51f435138b024621bb64736f6c63430008020033