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 0x01e3 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01e3, 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 0x0102 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0102, 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 0xb88d4fde 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xb88d4fde > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd6492d81 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xd6492d81 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd6492d81 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd6492d81 003A 14 EQ 003B 61 PUSH2 0x053b 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053b, if 0xd6492d81 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd6492d81 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x0551 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0551, 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 0xeeecf85d 0050 14 EQ 0051 61 PUSH2 0x059a 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059a, if 0xeeecf85d == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xeeecf85d == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x05ba 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ba, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x0033, if 0xd6492d81 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xb88d4fde 006B 14 EQ 006C 61 PUSH2 0x04c5 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c5, if 0xb88d4fde == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xbedb86fb 0076 14 EQ 0077 61 PUSH2 0x04e5 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if 0xbedb86fb == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xbedb86fb == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc87b56dd 0081 14 EQ 0082 61 PUSH2 0x0505 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0505, if 0xc87b56dd == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xd5abeb01 008C 14 EQ 008D 61 PUSH2 0x0525 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0525, if 0xd5abeb01 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0028, if 0xb88d4fde > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0x95d89b41 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x95d89b41 > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x95d89b41 00A7 14 EQ 00A8 61 PUSH2 0x0451 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0451, if 0x95d89b41 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xa22cb465 00B2 14 EQ 00B3 61 PUSH2 0x0466 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0466, if 0xa22cb465 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xa79fdbb4 00BD 14 EQ 00BE 61 PUSH2 0x0486 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0486, if 0xa79fdbb4 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xa79fdbb4 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xad3e31b7 00C8 14 EQ 00C9 61 PUSH2 0x04a5 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a5, if 0xad3e31b7 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xad3e31b7 == stack[-1] // Inputs[1] { @00D0 memory[0x00:0x00] } 00CD 60 PUSH1 0x00 00CF 80 DUP1 00D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D0 revert(memory[0x00:0x00]); } // Block terminates label_00D1: // Incoming jump from 0x00A0, if 0x95d89b41 > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x70a08231 00D8 14 EQ 00D9 61 PUSH2 0x03de 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03de, if 0x70a08231 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x70a08231 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x715018a6 00E3 14 EQ 00E4 61 PUSH2 0x03fe 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fe, if 0x715018a6 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x715018a6 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x7d60157b 00EE 14 EQ 00EF 61 PUSH2 0x0413 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0413, if 0x7d60157b == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x7d60157b == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x8da5cb5b 00F9 14 EQ 00FA 61 PUSH2 0x0433 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0433, if 0x8da5cb5b == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0101 memory[0x00:0x00] } 00FE 60 PUSH1 0x00 0100 80 DUP1 0101 FD *REVERT // Stack delta = +0 // Outputs[1] { @0101 revert(memory[0x00:0x00]); } // Block terminates label_0102: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0103 stack[-1] } 0102 5B JUMPDEST 0103 80 DUP1 0104 63 PUSH4 0x3cb963c7 0109 11 GT 010A 61 PUSH2 0x017a 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017a, if 0x3cb963c7 > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x3cb963c7 > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x55f804b3 0114 11 GT 0115 61 PUSH2 0x0149 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0149, if 0x55f804b3 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x55f804b3 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x55f804b3 011F 14 EQ 0120 61 PUSH2 0x036f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036f, if 0x55f804b3 == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5c975abb 012A 14 EQ 012B 61 PUSH2 0x038f 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038f, if 0x5c975abb == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5c975abb == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x6352211e 0135 14 EQ 0136 61 PUSH2 0x03a9 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a9, if 0x6352211e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x6352211e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x6c0360eb 0140 14 EQ 0141 61 PUSH2 0x03c9 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c9, if 0x6c0360eb == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x6c0360eb == stack[-1] // Inputs[1] { @0148 memory[0x00:0x00] } 0145 60 PUSH1 0x00 0147 80 DUP1 0148 FD *REVERT // Stack delta = +0 // Outputs[1] { @0148 revert(memory[0x00:0x00]); } // Block terminates label_0149: // Incoming jump from 0x0118, if 0x55f804b3 > stack[-1] // Inputs[1] { @014A stack[-1] } 0149 5B JUMPDEST 014A 80 DUP1 014B 63 PUSH4 0x3cb963c7 0150 14 EQ 0151 61 PUSH2 0x0311 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x3cb963c7 == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x3cb963c7 == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x3ccfd60b 015B 14 EQ 015C 61 PUSH2 0x0327 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0327, if 0x3ccfd60b == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x42842e0e 0166 14 EQ 0167 61 PUSH2 0x032f 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032f, if 0x42842e0e == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x42842e0e == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x44b09cc2 0171 14 EQ 0172 61 PUSH2 0x034f 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034f, if 0x44b09cc2 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x44b09cc2 == stack[-1] // Inputs[1] { @0179 memory[0x00:0x00] } 0176 60 PUSH1 0x00 0178 80 DUP1 0179 FD *REVERT // Stack delta = +0 // Outputs[1] { @0179 revert(memory[0x00:0x00]); } // Block terminates label_017A: // Incoming jump from 0x010D, if 0x3cb963c7 > stack[-1] // Inputs[1] { @017B stack[-1] } 017A 5B JUMPDEST 017B 80 DUP1 017C 63 PUSH4 0x0dc28efe 0181 11 GT 0182 61 PUSH2 0x01b6 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b6, if 0x0dc28efe > stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x0dc28efe > stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x0dc28efe 018C 14 EQ 018D 61 PUSH2 0x0299 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0299, if 0x0dc28efe == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x0dc28efe == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x1249c58b 0197 14 EQ 0198 61 PUSH2 0x02b9 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b9, if 0x1249c58b == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x1249c58b == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x18160ddd 01A2 14 EQ 01A3 61 PUSH2 0x02ce 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ce, if 0x18160ddd == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x18160ddd == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x23b872dd 01AD 14 EQ 01AE 61 PUSH2 0x02f1 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f1, if 0x23b872dd == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x23b872dd == stack[-1] // Inputs[1] { @01B5 memory[0x00:0x00] } 01B2 60 PUSH1 0x00 01B4 80 DUP1 01B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B5 revert(memory[0x00:0x00]); } // Block terminates label_01B6: // Incoming jump from 0x0185, if 0x0dc28efe > stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B6 5B JUMPDEST 01B7 80 DUP1 01B8 63 PUSH4 0x01ffc9a7 01BD 14 EQ 01BE 61 PUSH2 0x01e8 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e8, if 0x01ffc9a7 == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C2 80 DUP1 01C3 63 PUSH4 0x06fdde03 01C8 14 EQ 01C9 61 PUSH2 0x021d 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021d, if 0x06fdde03 == stack[-1] label_01CD: // Incoming jump from 0x01CC, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01CD stack[-1] } 01CD 80 DUP1 01CE 63 PUSH4 0x081812fc 01D3 14 EQ 01D4 61 PUSH2 0x023f 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x081812fc == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x081812fc == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x095ea7b3 01DE 14 EQ 01DF 61 PUSH2 0x0277 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x095ea7b3 == stack[-1] label_01E3: // Incoming jump from 0x0FB8, if !stack[-1] // Incoming jump from 0x01E2, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @01E7 memory[0x00:0x00] } 01E3 5B JUMPDEST 01E4 60 PUSH1 0x00 01E6 80 DUP1 01E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E7 revert(memory[0x00:0x00]); } // Block terminates label_01E8: // Incoming jump from 0x01C1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E9 msg.value } 01E8 5B JUMPDEST 01E9 34 CALLVALUE 01EA 80 DUP1 01EB 15 ISZERO 01EC 61 PUSH2 0x01f4 01EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E9 stack[0] = msg.value } // Block ends with conditional jump to 0x01f4, if !msg.value label_01F0: // Incoming jump from 0x01EF, if not !msg.value // Inputs[1] { @01F3 memory[0x00:0x00] } 01F0 60 PUSH1 0x00 01F2 80 DUP1 01F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F3 revert(memory[0x00:0x00]); } // Block terminates label_01F4: // Incoming jump from 0x01EF, if !msg.value // Inputs[1] { @01FC msg.data.length } 01F4 5B JUMPDEST 01F5 50 POP 01F6 61 PUSH2 0x0208 01F9 61 PUSH2 0x0203 01FC 36 CALLDATASIZE 01FD 60 PUSH1 0x04 01FF 61 PUSH2 0x1b56 0202 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01F6 stack[-1] = 0x0208 // @01F9 stack[0] = 0x0203 // @01FC stack[1] = msg.data.length // @01FD stack[2] = 0x04 // } // Block ends with call to 0x1b56, returns to 0x0203 label_0203: // Incoming return from call to 0x1B56 at 0x0202 0203 5B JUMPDEST 0204 61 PUSH2 0x05da 0207 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05da label_0208: // Incoming jump from 0x03A8 // Incoming return from call to 0x0203 at 0x0202 // Incoming jump from 0x04A4 // Inputs[2] // { // @020B memory[0x40:0x60] // @020C stack[-1] // } 0208 5B JUMPDEST 0209 60 PUSH1 0x40 020B 51 MLOAD 020C 90 SWAP1 020D 15 ISZERO 020E 15 ISZERO 020F 81 DUP2 0210 52 MSTORE 0211 60 PUSH1 0x20 0213 01 ADD // Stack delta = +0 // Outputs[2] // { // @0210 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0213 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0214: // Incoming jump from 0x02F0 // Incoming jump from 0x0276 // Incoming jump from 0x0213 // Inputs[3] // { // @0217 memory[0x40:0x60] // @0219 stack[-1] // @021C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0214 5B JUMPDEST 0215 60 PUSH1 0x40 0217 51 MLOAD 0218 80 DUP1 0219 91 SWAP2 021A 03 SUB 021B 90 SWAP1 021C F3 *RETURN // Stack delta = -1 // Outputs[1] { @021C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_021D: // Incoming jump from 0x01CC, if 0x06fdde03 == stack[-1] // Inputs[1] { @021E msg.value } 021D 5B JUMPDEST 021E 34 CALLVALUE 021F 80 DUP1 0220 15 ISZERO 0221 61 PUSH2 0x0229 0224 57 *JUMPI // Stack delta = +1 // Outputs[1] { @021E stack[0] = msg.value } // Block ends with conditional jump to 0x0229, if !msg.value label_0225: // Incoming jump from 0x0224, if not !msg.value // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming jump from 0x0224, if !msg.value 0229 5B JUMPDEST 022A 50 POP 022B 61 PUSH2 0x0232 022E 61 PUSH2 0x0677 0231 56 *JUMP // Stack delta = +0 // Outputs[1] { @022B stack[-1] = 0x0232 } // Block ends with call to 0x0677, returns to 0x0232 label_0232: // Incoming return from call to 0x0CF2 at 0x03DD // Incoming return from call to 0x10B7 at 0x0465 // Incoming return from call to 0x0677 at 0x0231 // Inputs[2] // { // @0235 memory[0x40:0x60] // @0239 stack[-1] // } 0232 5B JUMPDEST 0233 60 PUSH1 0x40 0235 51 MLOAD 0236 61 PUSH2 0x0214 0239 91 SWAP2 023A 90 SWAP1 023B 61 PUSH2 0x1c8d 023E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0239 stack[-1] = 0x0214 // @023A stack[1] = memory[0x40:0x60] // @023A stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1c8d label_023F: // Incoming jump from 0x01D7, if 0x081812fc == stack[-1] // Inputs[1] { @0240 msg.value } 023F 5B JUMPDEST 0240 34 CALLVALUE 0241 80 DUP1 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0240 stack[0] = msg.value } // Block ends with conditional jump to 0x024b, if !msg.value label_0247: // Incoming jump from 0x0246, if not !msg.value // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0246, if !msg.value // Inputs[1] { @0253 msg.data.length } 024B 5B JUMPDEST 024C 50 POP 024D 61 PUSH2 0x025f 0250 61 PUSH2 0x025a 0253 36 CALLDATASIZE 0254 60 PUSH1 0x04 0256 61 PUSH2 0x1b3e 0259 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @024D stack[-1] = 0x025f // @0250 stack[0] = 0x025a // @0253 stack[1] = msg.data.length // @0254 stack[2] = 0x04 // } // Block ends with call to 0x1b3e, returns to 0x025A label_025A: // Incoming return from call to 0x1B3E at 0x0259 025A 5B JUMPDEST 025B 61 PUSH2 0x0709 025E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0709 label_025F: // Incoming return from call to 0x03C4 at 0x03C3 // Incoming jump from 0x0450 // Incoming return from call to 0x025A at 0x0259 // Inputs[2] // { // @0262 memory[0x40:0x60] // @026C stack[-1] // } 025F 5B JUMPDEST 0260 60 PUSH1 0x40 0262 51 MLOAD 0263 60 PUSH1 0x01 0265 60 PUSH1 0x01 0267 60 PUSH1 0xa0 0269 1B SHL 026A 03 SUB 026B 90 SWAP1 026C 91 SWAP2 026D 16 AND 026E 81 DUP2 026F 52 MSTORE 0270 60 PUSH1 0x20 0272 01 ADD 0273 61 PUSH2 0x0214 0276 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @026F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0272 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_0277: // Incoming jump from 0x01E2, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0278 msg.value } 0277 5B JUMPDEST 0278 34 CALLVALUE 0279 80 DUP1 027A 15 ISZERO 027B 61 PUSH2 0x0283 027E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0278 stack[0] = msg.value } // Block ends with conditional jump to 0x0283, if !msg.value label_027F: // Incoming jump from 0x027E, if not !msg.value // Inputs[1] { @0282 memory[0x00:0x00] } 027F 60 PUSH1 0x00 0281 80 DUP1 0282 FD *REVERT // Stack delta = +0 // Outputs[1] { @0282 revert(memory[0x00:0x00]); } // Block terminates label_0283: // Incoming jump from 0x027E, if !msg.value // Inputs[1] { @028B msg.data.length } 0283 5B JUMPDEST 0284 50 POP 0285 61 PUSH2 0x0297 0288 61 PUSH2 0x0292 028B 36 CALLDATASIZE 028C 60 PUSH1 0x04 028E 61 PUSH2 0x1a8b 0291 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0285 stack[-1] = 0x0297 // @0288 stack[0] = 0x0292 // @028B stack[1] = msg.data.length // @028C stack[2] = 0x04 // } // Block ends with call to 0x1a8b, returns to 0x0292 label_0292: // Incoming return from call to 0x1A8B at 0x0291 0292 5B JUMPDEST 0293 61 PUSH2 0x0766 0296 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0766 label_0297: // Incoming return from call to 0x0C71 at 0x032E // Incoming return from call to 0x030C at 0x030B // Incoming return from call to 0x0292 at 0x0291 // Incoming return from call to 0x05B5 at 0x05B4 // Incoming return from call to 0x08B0 at 0x02CD // Incoming return from call to 0x036A at 0x0369 // Incoming return from call to 0x0500 at 0x04FF // Incoming return from call to 0x042E at 0x042D // Incoming return from call to 0x04E0 at 0x04DF // Incoming return from call to 0x04C0 at 0x04BF 0297 5B JUMPDEST 0298 00 *STOP // Stack delta = +0 // Outputs[1] { @0298 stop(); } // Block terminates label_0299: // Incoming jump from 0x0190, if 0x0dc28efe == stack[-1] // Inputs[1] { @029A msg.value } 0299 5B JUMPDEST 029A 34 CALLVALUE 029B 80 DUP1 029C 15 ISZERO 029D 61 PUSH2 0x02a5 02A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @029A stack[0] = msg.value } // Block ends with conditional jump to 0x02a5, if !msg.value label_02A1: // Incoming jump from 0x02A0, if not !msg.value // Inputs[1] { @02A4 memory[0x00:0x00] } 02A1 60 PUSH1 0x00 02A3 80 DUP1 02A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A4 revert(memory[0x00:0x00]); } // Block terminates label_02A5: // Incoming jump from 0x02A0, if !msg.value // Inputs[1] { @02AD msg.data.length } 02A5 5B JUMPDEST 02A6 50 POP 02A7 61 PUSH2 0x0297 02AA 61 PUSH2 0x02b4 02AD 36 CALLDATASIZE 02AE 60 PUSH1 0x04 02B0 61 PUSH2 0x1bd4 02B3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A7 stack[-1] = 0x0297 // @02AA stack[0] = 0x02b4 // @02AD stack[1] = msg.data.length // @02AE stack[2] = 0x04 // } // Block ends with call to 0x1bd4, returns to 0x02B4 label_02B4: // Incoming return from call to 0x1BD4 at 0x02B3 02B4 5B JUMPDEST 02B5 61 PUSH2 0x082c 02B8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x082c label_02B9: // Incoming jump from 0x019B, if 0x1249c58b == stack[-1] // Inputs[1] { @02BA msg.value } 02B9 5B JUMPDEST 02BA 34 CALLVALUE 02BB 80 DUP1 02BC 15 ISZERO 02BD 61 PUSH2 0x02c5 02C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BA stack[0] = msg.value } // Block ends with conditional jump to 0x02c5, if !msg.value label_02C1: // Incoming jump from 0x02C0, if not !msg.value // Inputs[1] { @02C4 memory[0x00:0x00] } 02C1 60 PUSH1 0x00 02C3 80 DUP1 02C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C4 revert(memory[0x00:0x00]); } // Block terminates label_02C5: // Incoming jump from 0x02C0, if !msg.value 02C5 5B JUMPDEST 02C6 50 POP 02C7 61 PUSH2 0x0297 02CA 61 PUSH2 0x08b0 02CD 56 *JUMP // Stack delta = +0 // Outputs[1] { @02C7 stack[-1] = 0x0297 } // Block ends with call to 0x08b0, returns to 0x0297 label_02CE: // Incoming jump from 0x01A6, if 0x18160ddd == stack[-1] // Inputs[1] { @02CF msg.value } 02CE 5B JUMPDEST 02CF 34 CALLVALUE 02D0 80 DUP1 02D1 15 ISZERO 02D2 61 PUSH2 0x02da 02D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CF stack[0] = msg.value } // Block ends with conditional jump to 0x02da, if !msg.value label_02D6: // Incoming jump from 0x02D5, if not !msg.value // Inputs[1] { @02D9 memory[0x00:0x00] } 02D6 60 PUSH1 0x00 02D8 80 DUP1 02D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D9 revert(memory[0x00:0x00]); } // Block terminates label_02DA: // Incoming jump from 0x02D5, if !msg.value // Inputs[2] // { // @02DE storage[0x02] // @02E1 storage[0x01] // } 02DA 5B JUMPDEST 02DB 50 POP 02DC 60 PUSH1 0x02 02DE 54 SLOAD 02DF 60 PUSH1 0x01 02E1 54 SLOAD 02E2 03 SUB // Stack delta = +0 // Outputs[1] { @02E2 stack[-1] = storage[0x01] - storage[0x02] } // Block continues label_02E3: // Incoming jump from 0x0326 // Incoming jump from 0x0550 // Incoming jump from 0x02E2 // Incoming return from call to 0x03F9 at 0x03F8 // Incoming jump from 0x053A // Inputs[2] // { // @02E6 memory[0x40:0x60] // @02E7 stack[-1] // } 02E3 5B JUMPDEST 02E4 60 PUSH1 0x40 02E6 51 MLOAD 02E7 90 SWAP1 02E8 81 DUP2 02E9 52 MSTORE 02EA 60 PUSH1 0x20 02EC 01 ADD 02ED 61 PUSH2 0x0214 02F0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02EC stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_02F1: // Incoming jump from 0x01B1, if 0x23b872dd == stack[-1] // Inputs[1] { @02F2 msg.value } 02F1 5B JUMPDEST 02F2 34 CALLVALUE 02F3 80 DUP1 02F4 15 ISZERO 02F5 61 PUSH2 0x02fd 02F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F2 stack[0] = msg.value } // Block ends with conditional jump to 0x02fd, if !msg.value label_02F9: // Incoming jump from 0x02F8, if not !msg.value // Inputs[1] { @02FC memory[0x00:0x00] } 02F9 60 PUSH1 0x00 02FB 80 DUP1 02FC FD *REVERT // Stack delta = +0 // Outputs[1] { @02FC revert(memory[0x00:0x00]); } // Block terminates label_02FD: // Incoming jump from 0x02F8, if !msg.value // Inputs[1] { @0305 msg.data.length } 02FD 5B JUMPDEST 02FE 50 POP 02FF 61 PUSH2 0x0297 0302 61 PUSH2 0x030c 0305 36 CALLDATASIZE 0306 60 PUSH1 0x04 0308 61 PUSH2 0x19ae 030B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FF stack[-1] = 0x0297 // @0302 stack[0] = 0x030c // @0305 stack[1] = msg.data.length // @0306 stack[2] = 0x04 // } // Block ends with call to 0x19ae, returns to 0x030C label_030C: // Incoming return from call to 0x19AE at 0x030B 030C 5B JUMPDEST 030D 61 PUSH2 0x0a94 0310 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a94 label_0311: // Incoming jump from 0x0154, if 0x3cb963c7 == stack[-1] // Inputs[1] { @0312 msg.value } 0311 5B JUMPDEST 0312 34 CALLVALUE 0313 80 DUP1 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0312 stack[0] = msg.value } // Block ends with conditional jump to 0x031d, if !msg.value label_0319: // Incoming jump from 0x0318, if not !msg.value // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming jump from 0x0318, if !msg.value // Inputs[1] { @0324 storage[0x0e] } 031D 5B JUMPDEST 031E 50 POP 031F 61 PUSH2 0x02e3 0322 60 PUSH1 0x0e 0324 54 SLOAD 0325 81 DUP2 0326 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @031F stack[-1] = 0x02e3 // @0324 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x02e3 label_0327: // Incoming jump from 0x015F, if 0x3ccfd60b == stack[-1] 0327 5B JUMPDEST 0328 61 PUSH2 0x0297 032B 61 PUSH2 0x0c71 032E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0328 stack[0] = 0x0297 } // Block ends with call to 0x0c71, returns to 0x0297 label_032F: // Incoming jump from 0x016A, if 0x42842e0e == stack[-1] // Inputs[1] { @0330 msg.value } 032F 5B JUMPDEST 0330 34 CALLVALUE 0331 80 DUP1 0332 15 ISZERO 0333 61 PUSH2 0x033b 0336 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0330 stack[0] = msg.value } // Block ends with conditional jump to 0x033b, if !msg.value label_0337: // Incoming jump from 0x0336, if not !msg.value // Inputs[1] { @033A memory[0x00:0x00] } 0337 60 PUSH1 0x00 0339 80 DUP1 033A FD *REVERT // Stack delta = +0 // Outputs[1] { @033A revert(memory[0x00:0x00]); } // Block terminates label_033B: // Incoming jump from 0x0336, if !msg.value // Inputs[1] { @0343 msg.data.length } 033B 5B JUMPDEST 033C 50 POP 033D 61 PUSH2 0x0297 0340 61 PUSH2 0x034a 0343 36 CALLDATASIZE 0344 60 PUSH1 0x04 0346 61 PUSH2 0x19ae 0349 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @033D stack[-1] = 0x0297 // @0340 stack[0] = 0x034a // @0343 stack[1] = msg.data.length // @0344 stack[2] = 0x04 // } // Block ends with call to 0x19ae, returns to 0x034A label_034A: // Incoming return from call to 0x19AE at 0x0349 034A 5B JUMPDEST 034B 61 PUSH2 0x0c9f 034E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c9f label_034F: // Incoming jump from 0x0175, if 0x44b09cc2 == stack[-1] // Inputs[1] { @0350 msg.value } 034F 5B JUMPDEST 0350 34 CALLVALUE 0351 80 DUP1 0352 15 ISZERO 0353 61 PUSH2 0x035b 0356 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0350 stack[0] = msg.value } // Block ends with conditional jump to 0x035b, if !msg.value label_0357: // Incoming jump from 0x0356, if not !msg.value // Inputs[1] { @035A memory[0x00:0x00] } 0357 60 PUSH1 0x00 0359 80 DUP1 035A FD *REVERT // Stack delta = +0 // Outputs[1] { @035A revert(memory[0x00:0x00]); } // Block terminates label_035B: // Incoming jump from 0x0356, if !msg.value // Inputs[1] { @0363 msg.data.length } 035B 5B JUMPDEST 035C 50 POP 035D 61 PUSH2 0x0297 0360 61 PUSH2 0x036a 0363 36 CALLDATASIZE 0364 60 PUSH1 0x04 0366 61 PUSH2 0x1b3e 0369 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035D stack[-1] = 0x0297 // @0360 stack[0] = 0x036a // @0363 stack[1] = msg.data.length // @0364 stack[2] = 0x04 // } // Block ends with call to 0x1b3e, returns to 0x036A label_036A: // Incoming return from call to 0x1B3E at 0x0369 036A 5B JUMPDEST 036B 61 PUSH2 0x0cbf 036E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cbf label_036F: // Incoming jump from 0x0123, if 0x55f804b3 == stack[-1] // Inputs[1] { @0370 msg.value } 036F 5B JUMPDEST 0370 34 CALLVALUE 0371 80 DUP1 0372 15 ISZERO 0373 61 PUSH2 0x037b 0376 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0370 stack[0] = msg.value } // Block ends with conditional jump to 0x037b, if !msg.value label_0377: // Incoming jump from 0x0376, if not !msg.value // Inputs[1] { @037A memory[0x00:0x00] } 0377 60 PUSH1 0x00 0379 80 DUP1 037A FD *REVERT // Stack delta = +0 // Outputs[1] { @037A revert(memory[0x00:0x00]); } // Block terminates label_037B: // Incoming jump from 0x0376, if !msg.value // Inputs[1] { @0383 msg.data.length } 037B 5B JUMPDEST 037C 50 POP 037D 61 PUSH2 0x0297 0380 61 PUSH2 0x038a 0383 36 CALLDATASIZE 0384 60 PUSH1 0x04 0386 61 PUSH2 0x1b8e 0389 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037D stack[-1] = 0x0297 // @0380 stack[0] = 0x038a // @0383 stack[1] = msg.data.length // @0384 stack[2] = 0x04 // } // Block ends with call to 0x1b8e, returns to 0x038A label_038A: // Incoming return from call to 0x1B8E at 0x0389 038A 5B JUMPDEST 038B 61 PUSH2 0x0ccc 038E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ccc label_038F: // Incoming jump from 0x012E, if 0x5c975abb == stack[-1] // Inputs[1] { @0390 msg.value } 038F 5B JUMPDEST 0390 34 CALLVALUE 0391 80 DUP1 0392 15 ISZERO 0393 61 PUSH2 0x039b 0396 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0390 stack[0] = msg.value } // Block ends with conditional jump to 0x039b, if !msg.value label_0397: // Incoming jump from 0x0396, if not !msg.value // Inputs[1] { @039A memory[0x00:0x00] } 0397 60 PUSH1 0x00 0399 80 DUP1 039A FD *REVERT // Stack delta = +0 // Outputs[1] { @039A revert(memory[0x00:0x00]); } // Block terminates label_039B: // Incoming jump from 0x0396, if !msg.value // Inputs[1] { @039F storage[0x0b] } 039B 5B JUMPDEST 039C 50 POP 039D 60 PUSH1 0x0b 039F 54 SLOAD 03A0 61 PUSH2 0x0208 03A3 90 SWAP1 03A4 60 PUSH1 0xff 03A6 16 AND 03A7 81 DUP2 03A8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03A3 stack[-1] = 0x0208 // @03A6 stack[0] = 0xff & storage[0x0b] // } // Block ends with unconditional jump to 0x0208 label_03A9: // Incoming jump from 0x0139, if 0x6352211e == stack[-1] // Inputs[1] { @03AA msg.value } 03A9 5B JUMPDEST 03AA 34 CALLVALUE 03AB 80 DUP1 03AC 15 ISZERO 03AD 61 PUSH2 0x03b5 03B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AA stack[0] = msg.value } // Block ends with conditional jump to 0x03b5, if !msg.value label_03B1: // Incoming jump from 0x03B0, if not !msg.value // Inputs[1] { @03B4 memory[0x00:0x00] } 03B1 60 PUSH1 0x00 03B3 80 DUP1 03B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B4 revert(memory[0x00:0x00]); } // Block terminates label_03B5: // Incoming jump from 0x03B0, if !msg.value // Inputs[1] { @03BD msg.data.length } 03B5 5B JUMPDEST 03B6 50 POP 03B7 61 PUSH2 0x025f 03BA 61 PUSH2 0x03c4 03BD 36 CALLDATASIZE 03BE 60 PUSH1 0x04 03C0 61 PUSH2 0x1b3e 03C3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B7 stack[-1] = 0x025f // @03BA stack[0] = 0x03c4 // @03BD stack[1] = msg.data.length // @03BE stack[2] = 0x04 // } // Block ends with call to 0x1b3e, returns to 0x03C4 label_03C4: // Incoming return from call to 0x1B3E at 0x03C3 03C4 5B JUMPDEST 03C5 61 PUSH2 0x0ce7 03C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce7 label_03C9: // Incoming jump from 0x0144, if 0x6c0360eb == stack[-1] // Inputs[1] { @03CA msg.value } 03C9 5B JUMPDEST 03CA 34 CALLVALUE 03CB 80 DUP1 03CC 15 ISZERO 03CD 61 PUSH2 0x03d5 03D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CA stack[0] = msg.value } // Block ends with conditional jump to 0x03d5, if !msg.value label_03D1: // Incoming jump from 0x03D0, if not !msg.value // Inputs[1] { @03D4 memory[0x00:0x00] } 03D1 60 PUSH1 0x00 03D3 80 DUP1 03D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D4 revert(memory[0x00:0x00]); } // Block terminates label_03D5: // Incoming jump from 0x03D0, if !msg.value 03D5 5B JUMPDEST 03D6 50 POP 03D7 61 PUSH2 0x0232 03DA 61 PUSH2 0x0cf2 03DD 56 *JUMP // Stack delta = +0 // Outputs[1] { @03D7 stack[-1] = 0x0232 } // Block ends with call to 0x0cf2, returns to 0x0232 label_03DE: // Incoming jump from 0x00DC, if 0x70a08231 == stack[-1] // Inputs[1] { @03DF msg.value } 03DE 5B JUMPDEST 03DF 34 CALLVALUE 03E0 80 DUP1 03E1 15 ISZERO 03E2 61 PUSH2 0x03ea 03E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03DF stack[0] = msg.value } // Block ends with conditional jump to 0x03ea, if !msg.value label_03E6: // Incoming jump from 0x03E5, if not !msg.value // Inputs[1] { @03E9 memory[0x00:0x00] } 03E6 60 PUSH1 0x00 03E8 80 DUP1 03E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E9 revert(memory[0x00:0x00]); } // Block terminates label_03EA: // Incoming jump from 0x03E5, if !msg.value // Inputs[1] { @03F2 msg.data.length } 03EA 5B JUMPDEST 03EB 50 POP 03EC 61 PUSH2 0x02e3 03EF 61 PUSH2 0x03f9 03F2 36 CALLDATASIZE 03F3 60 PUSH1 0x04 03F5 61 PUSH2 0x1962 03F8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03EC stack[-1] = 0x02e3 // @03EF stack[0] = 0x03f9 // @03F2 stack[1] = msg.data.length // @03F3 stack[2] = 0x04 // } // Block ends with call to 0x1962, returns to 0x03F9 label_03F9: // Incoming return from call to 0x1962 at 0x03F8 03F9 5B JUMPDEST 03FA 61 PUSH2 0x0d80 03FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d80 label_03FE: // Incoming jump from 0x00E7, if 0x715018a6 == stack[-1] // Inputs[1] { @03FF msg.value } 03FE 5B JUMPDEST 03FF 34 CALLVALUE 0400 80 DUP1 0401 15 ISZERO 0402 61 PUSH2 0x040a 0405 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FF stack[0] = msg.value } // Block ends with conditional jump to 0x040a, if !msg.value label_0406: // Incoming jump from 0x0405, if not !msg.value // Inputs[1] { @0409 memory[0x00:0x00] } 0406 60 PUSH1 0x00 0408 80 DUP1 0409 FD *REVERT // Stack delta = +0 // Outputs[1] { @0409 revert(memory[0x00:0x00]); } // Block terminates label_040A: // Incoming jump from 0x0405, if !msg.value 040A 5B JUMPDEST 040B 50 POP 040C 61 PUSH2 0x0297 040F 61 PUSH2 0x0de8 0412 56 *JUMP // Stack delta = +0 // Outputs[1] { @040C stack[-1] = 0x0297 } // Block ends with unconditional jump to 0x0de8 label_0413: // Incoming jump from 0x00F2, if 0x7d60157b == stack[-1] // Inputs[1] { @0414 msg.value } 0413 5B JUMPDEST 0414 34 CALLVALUE 0415 80 DUP1 0416 15 ISZERO 0417 61 PUSH2 0x041f 041A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0414 stack[0] = msg.value } // Block ends with conditional jump to 0x041f, if !msg.value label_041B: // Incoming jump from 0x041A, if not !msg.value // Inputs[1] { @041E memory[0x00:0x00] } 041B 60 PUSH1 0x00 041D 80 DUP1 041E FD *REVERT // Stack delta = +0 // Outputs[1] { @041E revert(memory[0x00:0x00]); } // Block terminates label_041F: // Incoming jump from 0x041A, if !msg.value // Inputs[1] { @0427 msg.data.length } 041F 5B JUMPDEST 0420 50 POP 0421 61 PUSH2 0x0297 0424 61 PUSH2 0x042e 0427 36 CALLDATASIZE 0428 60 PUSH1 0x04 042A 61 PUSH2 0x1ab4 042D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0421 stack[-1] = 0x0297 // @0424 stack[0] = 0x042e // @0427 stack[1] = msg.data.length // @0428 stack[2] = 0x04 // } // Block ends with call to 0x1ab4, returns to 0x042E label_042E: // Incoming return from call to 0x1AB4 at 0x042D 042E 5B JUMPDEST 042F 61 PUSH2 0x0dfa 0432 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dfa label_0433: // Incoming jump from 0x00FD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0434 msg.value } 0433 5B JUMPDEST 0434 34 CALLVALUE 0435 80 DUP1 0436 15 ISZERO 0437 61 PUSH2 0x043f 043A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0434 stack[0] = msg.value } // Block ends with conditional jump to 0x043f, if !msg.value label_043B: // Incoming jump from 0x043A, if not !msg.value // Inputs[1] { @043E memory[0x00:0x00] } 043B 60 PUSH1 0x00 043D 80 DUP1 043E FD *REVERT // Stack delta = +0 // Outputs[1] { @043E revert(memory[0x00:0x00]); } // Block terminates label_043F: // Incoming jump from 0x043A, if !msg.value // Inputs[1] { @0443 storage[0x00] } 043F 5B JUMPDEST 0440 50 POP 0441 60 PUSH1 0x00 0443 54 SLOAD 0444 60 PUSH1 0x01 0446 60 PUSH1 0x01 0448 60 PUSH1 0xa0 044A 1B SHL 044B 03 SUB 044C 16 AND 044D 61 PUSH2 0x025f 0450 56 *JUMP // Stack delta = +0 // Outputs[1] { @044C stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x025f label_0451: // Incoming jump from 0x00AB, if 0x95d89b41 == stack[-1] // Inputs[1] { @0452 msg.value } 0451 5B JUMPDEST 0452 34 CALLVALUE 0453 80 DUP1 0454 15 ISZERO 0455 61 PUSH2 0x045d 0458 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0452 stack[0] = msg.value } // Block ends with conditional jump to 0x045d, if !msg.value label_0459: // Incoming jump from 0x0458, if not !msg.value // Inputs[1] { @045C memory[0x00:0x00] } 0459 60 PUSH1 0x00 045B 80 DUP1 045C FD *REVERT // Stack delta = +0 // Outputs[1] { @045C revert(memory[0x00:0x00]); } // Block terminates label_045D: // Incoming jump from 0x0458, if !msg.value 045D 5B JUMPDEST 045E 50 POP 045F 61 PUSH2 0x0232 0462 61 PUSH2 0x10b7 0465 56 *JUMP // Stack delta = +0 // Outputs[1] { @045F stack[-1] = 0x0232 } // Block ends with call to 0x10b7, returns to 0x0232 label_0466: // Incoming jump from 0x00B6, if 0xa22cb465 == stack[-1] // Inputs[1] { @0467 msg.value } 0466 5B JUMPDEST 0467 34 CALLVALUE 0468 80 DUP1 0469 15 ISZERO 046A 61 PUSH2 0x0472 046D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0467 stack[0] = msg.value } // Block ends with conditional jump to 0x0472, if !msg.value label_046E: // Incoming jump from 0x046D, if not !msg.value // Inputs[1] { @0471 memory[0x00:0x00] } 046E 60 PUSH1 0x00 0470 80 DUP1 0471 FD *REVERT // Stack delta = +0 // Outputs[1] { @0471 revert(memory[0x00:0x00]); } // Block terminates label_0472: // Incoming jump from 0x046D, if !msg.value // Inputs[1] { @047A msg.data.length } 0472 5B JUMPDEST 0473 50 POP 0474 61 PUSH2 0x0297 0477 61 PUSH2 0x0481 047A 36 CALLDATASIZE 047B 60 PUSH1 0x04 047D 61 PUSH2 0x1a62 0480 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0474 stack[-1] = 0x0297 // @0477 stack[0] = 0x0481 // @047A stack[1] = msg.data.length // @047B stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a62 0481 5B JUMPDEST 0482 61 PUSH2 0x10c6 0485 56 *JUMP label_0486: // Incoming jump from 0x00C1, if 0xa79fdbb4 == stack[-1] // Inputs[1] { @0487 msg.value } 0486 5B JUMPDEST 0487 34 CALLVALUE 0488 80 DUP1 0489 15 ISZERO 048A 61 PUSH2 0x0492 048D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0487 stack[0] = msg.value } // Block ends with conditional jump to 0x0492, if !msg.value label_048E: // Incoming jump from 0x048D, if not !msg.value // Inputs[1] { @0491 memory[0x00:0x00] } 048E 60 PUSH1 0x00 0490 80 DUP1 0491 FD *REVERT // Stack delta = +0 // Outputs[1] { @0491 revert(memory[0x00:0x00]); } // Block terminates label_0492: // Incoming jump from 0x048D, if !msg.value // Inputs[1] { @0496 storage[0x0b] } 0492 5B JUMPDEST 0493 50 POP 0494 60 PUSH1 0x0b 0496 54 SLOAD 0497 61 PUSH2 0x0208 049A 90 SWAP1 049B 61 PUSH2 0x0100 049E 90 SWAP1 049F 04 DIV 04A0 60 PUSH1 0xff 04A2 16 AND 04A3 81 DUP2 04A4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @049A stack[-1] = 0x0208 // @04A2 stack[0] = 0xff & storage[0x0b] / 0x0100 // } // Block ends with unconditional jump to 0x0208 label_04A5: // Incoming jump from 0x00CC, if 0xad3e31b7 == stack[-1] // Inputs[1] { @04A6 msg.value } 04A5 5B JUMPDEST 04A6 34 CALLVALUE 04A7 80 DUP1 04A8 15 ISZERO 04A9 61 PUSH2 0x04b1 04AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A6 stack[0] = msg.value } // Block ends with conditional jump to 0x04b1, if !msg.value label_04AD: // Incoming jump from 0x04AC, if not !msg.value // Inputs[1] { @04B0 memory[0x00:0x00] } 04AD 60 PUSH1 0x00 04AF 80 DUP1 04B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B0 revert(memory[0x00:0x00]); } // Block terminates label_04B1: // Incoming jump from 0x04AC, if !msg.value // Inputs[1] { @04B9 msg.data.length } 04B1 5B JUMPDEST 04B2 50 POP 04B3 61 PUSH2 0x0297 04B6 61 PUSH2 0x04c0 04B9 36 CALLDATASIZE 04BA 60 PUSH1 0x04 04BC 61 PUSH2 0x1b3e 04BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B3 stack[-1] = 0x0297 // @04B6 stack[0] = 0x04c0 // @04B9 stack[1] = msg.data.length // @04BA stack[2] = 0x04 // } // Block ends with call to 0x1b3e, returns to 0x04C0 label_04C0: // Incoming return from call to 0x1B3E at 0x04BF 04C0 5B JUMPDEST 04C1 61 PUSH2 0x1175 04C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1175 label_04C5: // Incoming jump from 0x006F, if 0xb88d4fde == stack[-1] // Inputs[1] { @04C6 msg.value } 04C5 5B JUMPDEST 04C6 34 CALLVALUE 04C7 80 DUP1 04C8 15 ISZERO 04C9 61 PUSH2 0x04d1 04CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C6 stack[0] = msg.value } // Block ends with conditional jump to 0x04d1, if !msg.value label_04CD: // Incoming jump from 0x04CC, if not !msg.value // Inputs[1] { @04D0 memory[0x00:0x00] } 04CD 60 PUSH1 0x00 04CF 80 DUP1 04D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D0 revert(memory[0x00:0x00]); } // Block terminates label_04D1: // Incoming jump from 0x04CC, if !msg.value // Inputs[1] { @04D9 msg.data.length } 04D1 5B JUMPDEST 04D2 50 POP 04D3 61 PUSH2 0x0297 04D6 61 PUSH2 0x04e0 04D9 36 CALLDATASIZE 04DA 60 PUSH1 0x04 04DC 61 PUSH2 0x19e9 04DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D3 stack[-1] = 0x0297 // @04D6 stack[0] = 0x04e0 // @04D9 stack[1] = msg.data.length // @04DA stack[2] = 0x04 // } // Block ends with call to 0x19e9, returns to 0x04E0 label_04E0: // Incoming return from call to 0x19E9 at 0x04DF 04E0 5B JUMPDEST 04E1 61 PUSH2 0x1182 04E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1182 label_04E5: // Incoming jump from 0x007A, if 0xbedb86fb == 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 0x0297 04F6 61 PUSH2 0x0500 04F9 36 CALLDATASIZE 04FA 60 PUSH1 0x04 04FC 61 PUSH2 0x1b24 04FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F3 stack[-1] = 0x0297 // @04F6 stack[0] = 0x0500 // @04F9 stack[1] = msg.data.length // @04FA stack[2] = 0x04 // } // Block ends with call to 0x1b24, returns to 0x0500 label_0500: // Incoming return from call to 0x1B24 at 0x04FF 0500 5B JUMPDEST 0501 61 PUSH2 0x11cc 0504 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11cc label_0505: // Incoming jump from 0x0085, if 0xc87b56dd == 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 0x0232 0516 61 PUSH2 0x0520 0519 36 CALLDATASIZE 051A 60 PUSH1 0x04 051C 61 PUSH2 0x1b3e 051F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0513 stack[-1] = 0x0232 // @0516 stack[0] = 0x0520 // @0519 stack[1] = msg.data.length // @051A stack[2] = 0x04 // } // Block ends with call to 0x1b3e, returns to 0x0520 label_0520: // Incoming return from call to 0x1B3E at 0x051F 0520 5B JUMPDEST 0521 61 PUSH2 0x11e7 0524 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11e7 label_0525: // Incoming jump from 0x0090, if 0xd5abeb01 == stack[-1] // Inputs[1] { @0526 msg.value } 0525 5B JUMPDEST 0526 34 CALLVALUE 0527 80 DUP1 0528 15 ISZERO 0529 61 PUSH2 0x0531 052C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0526 stack[0] = msg.value } // Block ends with conditional jump to 0x0531, if !msg.value label_052D: // Incoming jump from 0x052C, if not !msg.value // Inputs[1] { @0530 memory[0x00:0x00] } 052D 60 PUSH1 0x00 052F 80 DUP1 0530 FD *REVERT // Stack delta = +0 // Outputs[1] { @0530 revert(memory[0x00:0x00]); } // Block terminates label_0531: // Incoming jump from 0x052C, if !msg.value // Inputs[1] { @0538 storage[0x0a] } 0531 5B JUMPDEST 0532 50 POP 0533 61 PUSH2 0x02e3 0536 60 PUSH1 0x0a 0538 54 SLOAD 0539 81 DUP2 053A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0533 stack[-1] = 0x02e3 // @0538 stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x02e3 label_053B: // Incoming jump from 0x003E, if 0xd6492d81 == 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] { @054E storage[0x0f] } 0547 5B JUMPDEST 0548 50 POP 0549 61 PUSH2 0x02e3 054C 60 PUSH1 0x0f 054E 54 SLOAD 054F 81 DUP2 0550 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0549 stack[-1] = 0x02e3 // @054E stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x02e3 label_0551: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0552 msg.value } 0551 5B JUMPDEST 0552 34 CALLVALUE 0553 80 DUP1 0554 15 ISZERO 0555 61 PUSH2 0x055d 0558 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0552 stack[0] = msg.value } // Block ends with conditional jump to 0x055d, if !msg.value label_0559: // Incoming jump from 0x0558, if not !msg.value // Inputs[1] { @055C memory[0x00:0x00] } 0559 60 PUSH1 0x00 055B 80 DUP1 055C FD *REVERT // Stack delta = +0 // Outputs[1] { @055C revert(memory[0x00:0x00]); } // Block terminates label_055D: // Incoming jump from 0x0558, if !msg.value // Inputs[1] { @0565 msg.data.length } 055D 5B JUMPDEST 055E 50 POP 055F 61 PUSH2 0x0208 0562 61 PUSH2 0x056c 0565 36 CALLDATASIZE 0566 60 PUSH1 0x04 0568 61 PUSH2 0x197c 056B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055F stack[-1] = 0x0208 // @0562 stack[0] = 0x056c // @0565 stack[1] = msg.data.length // @0566 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x197c label_056C: // Incoming call from 0x0B1B, returns to 0x0B1C // Incoming call from 0x078C, returns to 0x078D // Inputs[6] // { // @0575 stack[-2] // @0588 memory[0x00:0x40] // @0589 stack[-1] // @0593 memory[0x00:0x40] // @0594 storage[keccak256(memory[0x00:0x40])] // @0598 stack[-3] // } 056C 5B JUMPDEST 056D 60 PUSH1 0x01 056F 60 PUSH1 0x01 0571 60 PUSH1 0xa0 0573 1B SHL 0574 03 SUB 0575 91 SWAP2 0576 82 DUP3 0577 16 AND 0578 60 PUSH1 0x00 057A 90 SWAP1 057B 81 DUP2 057C 52 MSTORE 057D 60 PUSH1 0x08 057F 60 PUSH1 0x20 0581 90 SWAP1 0582 81 DUP2 0583 52 MSTORE 0584 60 PUSH1 0x40 0586 80 DUP1 0587 83 DUP4 0588 20 SHA3 0589 93 SWAP4 058A 90 SWAP1 058B 94 SWAP5 058C 16 AND 058D 82 DUP3 058E 52 MSTORE 058F 91 SWAP2 0590 90 SWAP1 0591 91 SWAP2 0592 52 MSTORE 0593 20 SHA3 0594 54 SLOAD 0595 60 PUSH1 0xff 0597 16 AND 0598 90 SWAP1 0599 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @057C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0583 memory[0x20:0x40] = 0x08 // @058E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0592 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0598 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_059A: // Incoming jump from 0x0054, if 0xeeecf85d == stack[-1] // Inputs[1] { @059B msg.value } 059A 5B JUMPDEST 059B 34 CALLVALUE 059C 80 DUP1 059D 15 ISZERO 059E 61 PUSH2 0x05a6 05A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @059B stack[0] = msg.value } // Block ends with conditional jump to 0x05a6, if !msg.value label_05A2: // Incoming jump from 0x05A1, if not !msg.value // Inputs[1] { @05A5 memory[0x00:0x00] } 05A2 60 PUSH1 0x00 05A4 80 DUP1 05A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A5 revert(memory[0x00:0x00]); } // Block terminates label_05A6: // Incoming jump from 0x05A1, if !msg.value // Inputs[1] { @05AE msg.data.length } 05A6 5B JUMPDEST 05A7 50 POP 05A8 61 PUSH2 0x0297 05AB 61 PUSH2 0x05b5 05AE 36 CALLDATASIZE 05AF 60 PUSH1 0x04 05B1 61 PUSH2 0x1b24 05B4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A8 stack[-1] = 0x0297 // @05AB stack[0] = 0x05b5 // @05AE stack[1] = msg.data.length // @05AF stack[2] = 0x04 // } // Block ends with call to 0x1b24, returns to 0x05B5 label_05B5: // Incoming return from call to 0x1B24 at 0x05B4 05B5 5B JUMPDEST 05B6 61 PUSH2 0x1285 05B9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1285 label_05BA: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @05BB msg.value } 05BA 5B JUMPDEST 05BB 34 CALLVALUE 05BC 80 DUP1 05BD 15 ISZERO 05BE 61 PUSH2 0x05c6 05C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BB stack[0] = msg.value } // Block ends with conditional jump to 0x05c6, if !msg.value label_05C2: // Incoming jump from 0x05C1, if not !msg.value // Inputs[1] { @05C5 memory[0x00:0x00] } 05C2 60 PUSH1 0x00 05C4 80 DUP1 05C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C5 revert(memory[0x00:0x00]); } // Block terminates label_05C6: // Incoming jump from 0x05C1, if !msg.value // Inputs[1] { @05CE msg.data.length } 05C6 5B JUMPDEST 05C7 50 POP 05C8 61 PUSH2 0x0297 05CB 61 PUSH2 0x05d5 05CE 36 CALLDATASIZE 05CF 60 PUSH1 0x04 05D1 61 PUSH2 0x1962 05D4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C8 stack[-1] = 0x0297 // @05CB stack[0] = 0x05d5 // @05CE stack[1] = msg.data.length // @05CF stack[2] = 0x04 // } // Block ends with call to 0x1962, returns to 0x05D5 label_05D5: // Incoming return from call to 0x1962 at 0x05D4 05D5 5B JUMPDEST 05D6 61 PUSH2 0x12a7 05D9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12a7 label_05DA: // Incoming jump from 0x0207 // Inputs[1] { @0607 stack[-1] } 05DA 5B JUMPDEST 05DB 60 PUSH1 0x00 05DD 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 05FE 60 PUSH1 0x01 0600 60 PUSH1 0x01 0602 60 PUSH1 0xe0 0604 1B SHL 0605 03 SUB 0606 19 NOT 0607 83 DUP4 0608 16 AND 0609 14 EQ 060A 80 DUP1 060B 61 PUSH2 0x063d 060E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05DB stack[0] = 0x00 // @0609 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x063d, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 label_060F: // Incoming jump from 0x060E, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // Inputs[1] { @063A stack[-3] } 060F 50 POP 0610 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 0631 60 PUSH1 0x01 0633 60 PUSH1 0x01 0635 60 PUSH1 0xe0 0637 1B SHL 0638 03 SUB 0639 19 NOT 063A 83 DUP4 063B 16 AND 063C 14 EQ 063D 5B JUMPDEST 063E 80 DUP1 063F 61 PUSH2 0x0671 0642 57 *JUMPI // Stack delta = +0 // Outputs[1] { @063C stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0671, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 label_0643: // Incoming jump from 0x0642, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0642, if not stack[-1] // Inputs[1] { @066E stack[-3] } 0643 50 POP 0644 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 0665 60 PUSH1 0x01 0667 60 PUSH1 0x01 0669 60 PUSH1 0xe0 066B 1B SHL 066C 03 SUB 066D 19 NOT 066E 83 DUP4 066F 16 AND 0670 14 EQ // Stack delta = +0 // Outputs[1] { @0670 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f00000000000000000000000000000000000000000000000000000000 } // Block continues label_0671: // Incoming jump from 0x0670 // Incoming jump from 0x1344, if !(stack[-1] < storage[0x01]) // Incoming jump from 0x0642, if stack[-1] // Incoming return from call to 0x13D3 at 0x0CF1 // Incoming jump from 0x0642, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Inputs[3] // { // @0672 stack[-4] // @0672 stack[-1] // @0673 stack[-3] // } 0671 5B JUMPDEST 0672 92 SWAP3 0673 91 SWAP2 0674 50 POP 0675 50 POP 0676 56 *JUMP // Stack delta = -3 // Outputs[1] { @0672 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0677: // Incoming call from 0x0231, returns to 0x0232 // Inputs[1] { @067D storage[0x03] } 0677 5B JUMPDEST 0678 60 PUSH1 0x60 067A 60 PUSH1 0x03 067C 80 DUP1 067D 54 SLOAD 067E 61 PUSH2 0x0686 0681 90 SWAP1 0682 61 PUSH2 0x1ce4 0685 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0678 stack[0] = 0x60 // @067A stack[1] = 0x03 // @0681 stack[2] = 0x0686 // @0681 stack[3] = storage[0x03] // } // Block ends with call to 0x1ce4, returns to 0x0686 label_0686: // Incoming return from call to 0x1CE4 at 0x15C6 // Incoming return from call to 0x1CE4 at 0x0685 // Incoming return from call to 0x1CE4 at 0x10C5 // Inputs[4] // { // @0687 stack[-1] // @0696 memory[0x40:0x60] // @069E stack[-2] // @06A9 storage[stack[-2]] // } 0686 5B JUMPDEST 0687 80 DUP1 0688 60 PUSH1 0x1f 068A 01 ADD 068B 60 PUSH1 0x20 068D 80 DUP1 068E 91 SWAP2 068F 04 DIV 0690 02 MUL 0691 60 PUSH1 0x20 0693 01 ADD 0694 60 PUSH1 0x40 0696 51 MLOAD 0697 90 SWAP1 0698 81 DUP2 0699 01 ADD 069A 60 PUSH1 0x40 069C 52 MSTORE 069D 80 DUP1 069E 92 SWAP3 069F 91 SWAP2 06A0 90 SWAP1 06A1 81 DUP2 06A2 81 DUP2 06A3 52 MSTORE 06A4 60 PUSH1 0x20 06A6 01 ADD 06A7 82 DUP3 06A8 80 DUP1 06A9 54 SLOAD 06AA 61 PUSH2 0x06b2 06AD 90 SWAP1 06AE 61 PUSH2 0x1ce4 06B1 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @069C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @069E stack[-2] = memory[0x40:0x60] // @069F stack[-1] = stack[-2] // @06A0 stack[0] = stack[-1] // @06A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06A6 stack[1] = 0x20 + memory[0x40:0x60] // @06A7 stack[2] = stack[-2] // @06AD stack[4] = storage[stack[-2]] // @06AD stack[3] = 0x06b2 // } // Block ends with call to 0x1ce4, returns to 0x06B2 label_06B2: // Incoming return from call to 0x1CE4 at 0x06B1 // Inputs[1] { @06B3 stack[-1] } 06B2 5B JUMPDEST 06B3 80 DUP1 06B4 15 ISZERO 06B5 61 PUSH2 0x06ff 06B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ff, if !stack[-1] label_06B9: // Incoming jump from 0x06B8, if not !stack[-1] // Inputs[1] { @06B9 stack[-1] } 06B9 80 DUP1 06BA 60 PUSH1 0x1f 06BC 10 LT 06BD 61 PUSH2 0x06d4 06C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d4, if 0x1f < stack[-1] label_06C1: // Incoming jump from 0x06C0, if not 0x1f < stack[-1] // Inputs[4] // { // @06C5 stack[-2] // @06C6 storage[stack[-2]] // @06C9 stack[-3] // @06CB stack[-1] // } 06C1 61 PUSH2 0x0100 06C4 80 DUP1 06C5 83 DUP4 06C6 54 SLOAD 06C7 04 DIV 06C8 02 MUL 06C9 83 DUP4 06CA 52 MSTORE 06CB 91 SWAP2 06CC 60 PUSH1 0x20 06CE 01 ADD 06CF 91 SWAP2 06D0 61 PUSH2 0x06ff 06D3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06CA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06CF stack[-1] = stack[-1] // @06CF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06ff label_06D4: // Incoming jump from 0x06C0, if 0x1f < stack[-1] // Inputs[5] // { // @06D5 stack[-3] // @06D6 stack[-1] // @06D8 stack[-2] // @06E0 memory[0x00:0x20] // @06E4 storage[keccak256(memory[0x00:0x20])] // } 06D4 5B JUMPDEST 06D5 82 DUP3 06D6 01 ADD 06D7 91 SWAP2 06D8 90 SWAP1 06D9 60 PUSH1 0x00 06DB 52 MSTORE 06DC 60 PUSH1 0x20 06DE 60 PUSH1 0x00 06E0 20 SHA3 06E1 90 SWAP1 06E2 5B JUMPDEST 06E3 81 DUP2 06E4 54 SLOAD 06E5 81 DUP2 06E6 52 MSTORE 06E7 90 SWAP1 06E8 60 PUSH1 0x01 06EA 01 ADD 06EB 90 SWAP1 06EC 60 PUSH1 0x20 06EE 01 ADD 06EF 80 DUP1 06F0 83 DUP4 06F1 11 GT 06F2 61 PUSH2 0x06e2 06F5 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06D7 stack[-3] = stack[-3] + stack[-1] // @06DB memory[0x00:0x20] = stack[-2] // @06E6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06EB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06EE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06e2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06F6: // Incoming jump from 0x06F5, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x06F5, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @06F6 stack[-3] // @06F7 stack[-1] // } 06F6 82 DUP3 06F7 90 SWAP1 06F8 03 SUB 06F9 60 PUSH1 0x1f 06FB 16 AND 06FC 82 DUP3 06FD 01 ADD 06FE 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06FE stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06FE stack[-1] = stack[-3] // } // Block continues label_06FF: // Incoming jump from 0x06B8, if !stack[-1] // Incoming jump from 0x06D3 // Incoming jump from 0x06FE // Inputs[3] // { // @0705 stack[-7] // @0705 stack[-6] // @0707 stack[-8] // } 06FF 5B JUMPDEST 0700 50 POP 0701 50 POP 0702 50 POP 0703 50 POP 0704 50 POP 0705 90 SWAP1 0706 50 POP 0707 90 SWAP1 0708 56 *JUMP // Stack delta = -7 // Outputs[1] { @0707 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0709: // Incoming jump from 0x025E // Inputs[1] { @070F stack[-1] } 0709 5B JUMPDEST 070A 60 PUSH1 0x00 070C 61 PUSH2 0x0714 070F 82 DUP3 0710 61 PUSH2 0x1337 0713 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @070A stack[0] = 0x00 // @070C stack[1] = 0x0714 // @070F stack[2] = stack[-1] // } // Block ends with call to 0x1337, returns to 0x0714 label_0714: // Incoming return from call to 0x1337 at 0x0713 // Inputs[1] { @0718 stack[-1] } 0714 5B JUMPDEST 0715 61 PUSH2 0x074a 0718 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x074a, if stack[-1] label_0719: // Incoming jump from 0x0718, if not stack[-1] // Inputs[3] // { // @071B memory[0x40:0x60] // @0744 memory[0x40:0x60] // @0749 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0719 60 PUSH1 0x40 071B 51 MLOAD 071C 7F PUSH32 0xcf4700e400000000000000000000000000000000000000000000000000000000 073D 81 DUP2 073E 52 MSTORE 073F 60 PUSH1 0x04 0741 01 ADD 0742 60 PUSH1 0x40 0744 51 MLOAD 0745 80 DUP1 0746 91 SWAP2 0747 03 SUB 0748 90 SWAP1 0749 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @073E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcf4700e400000000000000000000000000000000000000000000000000000000 // @0749 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_074A: // Incoming jump from 0x0718, if stack[-1] // Inputs[4] // { // @074E stack[-2] // @0759 memory[0x00:0x40] // @075A storage[keccak256(memory[0x00:0x40])] // @0764 stack[-3] // } 074A 5B JUMPDEST 074B 50 POP 074C 60 PUSH1 0x00 074E 90 SWAP1 074F 81 DUP2 0750 52 MSTORE 0751 60 PUSH1 0x07 0753 60 PUSH1 0x20 0755 52 MSTORE 0756 60 PUSH1 0x40 0758 90 SWAP1 0759 20 SHA3 075A 54 SLOAD 075B 60 PUSH1 0x01 075D 60 PUSH1 0x01 075F 60 PUSH1 0xa0 0761 1B SHL 0762 03 SUB 0763 16 AND 0764 90 SWAP1 0765 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0750 memory[0x00:0x20] = stack[-2] // @0755 memory[0x20:0x40] = 0x07 // @0764 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0766: // Incoming jump from 0x0296 // Inputs[1] { @076C stack[-1] } 0766 5B JUMPDEST 0767 60 PUSH1 0x00 0769 61 PUSH2 0x0771 076C 82 DUP3 076D 61 PUSH2 0x0ce7 0770 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0767 stack[0] = 0x00 // @0769 stack[1] = 0x0771 // @076C stack[2] = stack[-1] // } // Block ends with call to 0x0ce7, returns to 0x0771 label_0771: // Incoming return from call to 0x0CE7 at 0x0770 // Inputs[3] // { // @0772 stack[-2] // @0772 stack[-1] // @0774 msg.sender // } 0771 5B JUMPDEST 0772 90 SWAP1 0773 50 POP 0774 33 CALLER 0775 60 PUSH1 0x01 0777 60 PUSH1 0x01 0779 60 PUSH1 0xa0 077B 1B SHL 077C 03 SUB 077D 82 DUP3 077E 16 AND 077F 14 EQ 0780 61 PUSH2 0x07c3 0783 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0772 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07c3, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0784: // Incoming jump from 0x0783, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0787 stack[-1] // @0788 msg.sender // } 0784 61 PUSH2 0x078d 0787 81 DUP2 0788 33 CALLER 0789 61 PUSH2 0x056c 078C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0784 stack[0] = 0x078d // @0787 stack[1] = stack[-1] // @0788 stack[2] = msg.sender // } // Block ends with call to 0x056c, returns to 0x078D label_078D: // Incoming return from call to 0x056C at 0x078C // Inputs[1] { @0791 stack[-1] } 078D 5B JUMPDEST 078E 61 PUSH2 0x07c3 0791 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07c3, if stack[-1] label_0792: // Incoming jump from 0x0791, if not stack[-1] // Inputs[3] // { // @0794 memory[0x40:0x60] // @07BD memory[0x40:0x60] // @07C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0792 60 PUSH1 0x40 0794 51 MLOAD 0795 7F PUSH32 0xcfb3b94200000000000000000000000000000000000000000000000000000000 07B6 81 DUP2 07B7 52 MSTORE 07B8 60 PUSH1 0x04 07BA 01 ADD 07BB 60 PUSH1 0x40 07BD 51 MLOAD 07BE 80 DUP1 07BF 91 SWAP2 07C0 03 SUB 07C1 90 SWAP1 07C2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @07B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcfb3b94200000000000000000000000000000000000000000000000000000000 // @07C2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07C3: // Incoming jump from 0x0791, if stack[-1] // Incoming jump from 0x0783, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[8] // { // @07C6 stack[-2] // @07D2 memory[0x00:0x40] // @07D4 storage[keccak256(memory[0x00:0x40])] // @07F4 stack[-3] // @07FE memory[0x40:0x60] // @0802 stack[-1] // @0827 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @082B stack[-4] // } 07C3 5B JUMPDEST 07C4 60 PUSH1 0x00 07C6 82 DUP3 07C7 81 DUP2 07C8 52 MSTORE 07C9 60 PUSH1 0x07 07CB 60 PUSH1 0x20 07CD 52 MSTORE 07CE 60 PUSH1 0x40 07D0 80 DUP1 07D1 82 DUP3 07D2 20 SHA3 07D3 80 DUP1 07D4 54 SLOAD 07D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07EA 19 NOT 07EB 16 AND 07EC 60 PUSH1 0x01 07EE 60 PUSH1 0x01 07F0 60 PUSH1 0xa0 07F2 1B SHL 07F3 03 SUB 07F4 87 DUP8 07F5 81 DUP2 07F6 16 AND 07F7 91 SWAP2 07F8 82 DUP3 07F9 17 OR 07FA 90 SWAP1 07FB 92 SWAP3 07FC 55 SSTORE 07FD 91 SWAP2 07FE 51 MLOAD 07FF 85 DUP6 0800 93 SWAP4 0801 91 SWAP2 0802 85 DUP6 0803 16 AND 0804 91 SWAP2 0805 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0826 91 SWAP2 0827 A4 LOG4 0828 50 POP 0829 50 POP 082A 50 POP 082B 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @07C8 memory[0x00:0x20] = stack[-2] // @07CD memory[0x20:0x40] = 0x07 // @07FC storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @0827 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_082C: // Incoming jump from 0x02B8 082C 5B JUMPDEST 082D 61 PUSH2 0x0834 0830 61 PUSH2 0x135f 0833 56 *JUMP // Stack delta = +1 // Outputs[1] { @082D stack[0] = 0x0834 } // Block ends with call to 0x135f, returns to 0x0834 label_0834: // Incoming return from call to 0x135F at 0x0833 // Inputs[4] // { // @0837 storage[0x0a] // @0838 stack[-2] // @083E storage[0x02] // @0841 storage[0x01] // } 0834 5B JUMPDEST 0835 60 PUSH1 0x0a 0837 54 SLOAD 0838 82 DUP3 0839 61 PUSH2 0x0845 083C 60 PUSH1 0x02 083E 54 SLOAD 083F 60 PUSH1 0x01 0841 54 SLOAD 0842 03 SUB 0843 90 SWAP1 0844 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0837 stack[0] = storage[0x0a] // @0838 stack[1] = stack[-2] // @0843 stack[2] = storage[0x01] - storage[0x02] // } // Block ends with unconditional jump to 0x0845 label_0845: // Incoming jump from 0x0844 // Inputs[2] // { // @0849 stack[-2] // @084A stack[-1] // } 0845 5B JUMPDEST 0846 61 PUSH2 0x084f 0849 91 SWAP2 084A 90 SWAP1 084B 61 PUSH2 0x1ca0 084E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0849 stack[-2] = 0x084f // @084A stack[-1] = stack[-2] // @084A stack[0] = stack[-1] // } // Block ends with call to 0x1ca0, returns to 0x084F label_084F: // Incoming return from call to 0x1CA0 at 0x084E // Inputs[2] // { // @0850 stack[-2] // @0850 stack[-1] // } 084F 5B JUMPDEST 0850 11 GT 0851 15 ISZERO 0852 61 PUSH2 0x08a2 0855 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x08a2, if !(stack[-1] > stack[-2]) label_0856: // Incoming jump from 0x0855, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0858 memory[0x40:0x60] } 0856 60 PUSH1 0x40 0858 51 MLOAD 0859 62 PUSH3 0x461bcd 085D 60 PUSH1 0xe5 085F 1B SHL 0860 81 DUP2 0861 52 MSTORE 0862 60 PUSH1 0x20 0864 60 PUSH1 0x04 0866 82 DUP3 0867 01 ADD 0868 52 MSTORE 0869 60 PUSH1 0x16 086B 60 PUSH1 0x24 086D 82 DUP3 086E 01 ADD 086F 52 MSTORE 0870 7F PUSH32 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 0891 60 PUSH1 0x44 0893 82 DUP3 0894 01 ADD 0895 52 MSTORE 0896 60 PUSH1 0x64 0898 01 ADD // Stack delta = +1 // Outputs[5] // { // @0861 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0868 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @086F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @0895 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 // @0898 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0899: // Incoming jump from 0x107C // Incoming jump from 0x132A // Incoming jump from 0x0EE8 // Incoming jump from 0x13B8 // Incoming jump from 0x0943 // Incoming jump from 0x0A5C // Incoming jump from 0x0996 // Incoming jump from 0x0898 // Incoming jump from 0x0902 // Incoming jump from 0x09FF // Incoming jump from 0x1013 // Incoming jump from 0x0E4C // Incoming jump from 0x0E8B // Inputs[3] // { // @089C memory[0x40:0x60] // @089E stack[-1] // @08A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0899 5B JUMPDEST 089A 60 PUSH1 0x40 089C 51 MLOAD 089D 80 DUP1 089E 91 SWAP2 089F 03 SUB 08A0 90 SWAP1 08A1 FD *REVERT // Stack delta = -1 // Outputs[1] { @08A1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_08A2: // Incoming jump from 0x0855, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @08A6 stack[-1] // @08A7 stack[-2] // } 08A2 5B JUMPDEST 08A3 61 PUSH2 0x08ac 08A6 81 DUP2 08A7 83 DUP4 08A8 61 PUSH2 0x13b9 08AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08A3 stack[0] = 0x08ac // @08A6 stack[1] = stack[-1] // @08A7 stack[2] = stack[-2] // } // Block ends with call to 0x13b9, returns to 0x08AC label_08AC: // Incoming return from call to 0x1609 at 0x13D2 // Incoming return from call to 0x13B9 at 0x08AB // Inputs[1] { @08AF stack[-3] } 08AC 5B JUMPDEST 08AD 50 POP 08AE 50 POP 08AF 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_08B0: // Incoming call from 0x02CD, returns to 0x0297 // Inputs[1] { @08B5 storage[0x09] } 08B0 5B JUMPDEST 08B1 60 PUSH1 0x02 08B3 60 PUSH1 0x09 08B5 54 SLOAD 08B6 14 EQ 08B7 15 ISZERO 08B8 61 PUSH2 0x0903 08BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0903, if !(storage[0x09] == 0x02) label_08BC: // Incoming jump from 0x08BB, if not !(storage[0x09] == 0x02) // Inputs[1] { @08BE memory[0x40:0x60] } 08BC 60 PUSH1 0x40 08BE 51 MLOAD 08BF 62 PUSH3 0x461bcd 08C3 60 PUSH1 0xe5 08C5 1B SHL 08C6 81 DUP2 08C7 52 MSTORE 08C8 60 PUSH1 0x20 08CA 60 PUSH1 0x04 08CC 82 DUP3 08CD 01 ADD 08CE 52 MSTORE 08CF 60 PUSH1 0x1f 08D1 60 PUSH1 0x24 08D3 82 DUP3 08D4 01 ADD 08D5 52 MSTORE 08D6 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 08F7 60 PUSH1 0x44 08F9 82 DUP3 08FA 01 ADD 08FB 52 MSTORE 08FC 60 PUSH1 0x64 08FE 01 ADD 08FF 61 PUSH2 0x0899 0902 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @08C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08D5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @08FB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @08FE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0903: // Incoming jump from 0x08BB, if !(storage[0x09] == 0x02) // Inputs[2] // { // @090B tx.origin // @090C msg.sender // } 0903 5B JUMPDEST 0904 60 PUSH1 0x02 0906 60 PUSH1 0x09 0908 55 SSTORE 0909 60 PUSH1 0x01 090B 32 ORIGIN 090C 33 CALLER 090D 14 EQ 090E 61 PUSH2 0x0944 0911 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0908 storage[0x09] = 0x02 // @0909 stack[0] = 0x01 // } // Block ends with conditional jump to 0x0944, if msg.sender == tx.origin label_0912: // Incoming jump from 0x0911, if not msg.sender == tx.origin // Inputs[1] { @0914 memory[0x40:0x60] } 0912 60 PUSH1 0x40 0914 51 MLOAD 0915 62 PUSH3 0x461bcd 0919 60 PUSH1 0xe5 091B 1B SHL 091C 81 DUP2 091D 52 MSTORE 091E 60 PUSH1 0x20 0920 60 PUSH1 0x04 0922 82 DUP3 0923 01 ADD 0924 52 MSTORE 0925 60 PUSH1 0x08 0927 60 PUSH1 0x24 0929 82 DUP3 092A 01 ADD 092B 52 MSTORE 092C 67 PUSH8 0x4f6e6c7920454f41 0935 60 PUSH1 0xc0 0937 1B SHL 0938 60 PUSH1 0x44 093A 82 DUP3 093B 01 ADD 093C 52 MSTORE 093D 60 PUSH1 0x64 093F 01 ADD 0940 61 PUSH2 0x0899 0943 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @091D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0924 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @092B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @093C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c7920454f41 << 0xc0 // @093F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0944: // Incoming jump from 0x0911, if msg.sender == tx.origin // Inputs[1] { @0947 storage[0x0b] } 0944 5B JUMPDEST 0945 60 PUSH1 0x0b 0947 54 SLOAD 0948 60 PUSH1 0xff 094A 16 AND 094B 15 ISZERO 094C 61 PUSH2 0x0997 094F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0997, if !(0xff & storage[0x0b]) label_0950: // Incoming jump from 0x094F, if not !(0xff & storage[0x0b]) // Inputs[1] { @0952 memory[0x40:0x60] } 0950 60 PUSH1 0x40 0952 51 MLOAD 0953 62 PUSH3 0x461bcd 0957 60 PUSH1 0xe5 0959 1B SHL 095A 81 DUP2 095B 52 MSTORE 095C 60 PUSH1 0x20 095E 60 PUSH1 0x04 0960 82 DUP3 0961 01 ADD 0962 52 MSTORE 0963 60 PUSH1 0x15 0965 60 PUSH1 0x24 0967 82 DUP3 0968 01 ADD 0969 52 MSTORE 096A 7F PUSH32 0x5075626c69632073616c65206973207061757365640000000000000000000000 098B 60 PUSH1 0x44 098D 82 DUP3 098E 01 ADD 098F 52 MSTORE 0990 60 PUSH1 0x64 0992 01 ADD 0993 61 PUSH2 0x0899 0996 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @095B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0962 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0969 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @098F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c69632073616c65206973207061757365640000000000000000000000 // @0992 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0997: // Incoming jump from 0x094F, if !(0xff & storage[0x0b]) // Inputs[4] // { // @099A storage[0x0a] // @099B stack[-1] // @09A1 storage[0x02] // @09A4 storage[0x01] // } 0997 5B JUMPDEST 0998 60 PUSH1 0x0a 099A 54 SLOAD 099B 81 DUP2 099C 61 PUSH2 0x09a8 099F 60 PUSH1 0x02 09A1 54 SLOAD 09A2 60 PUSH1 0x01 09A4 54 SLOAD 09A5 03 SUB 09A6 90 SWAP1 09A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @099A stack[0] = storage[0x0a] // @099B stack[1] = stack[-1] // @09A6 stack[2] = storage[0x01] - storage[0x02] // } // Block ends with unconditional jump to 0x09a8 label_09A8: // Incoming jump from 0x09A7 // Inputs[2] // { // @09AC stack[-2] // @09AD stack[-1] // } 09A8 5B JUMPDEST 09A9 61 PUSH2 0x09b2 09AC 91 SWAP2 09AD 90 SWAP1 09AE 61 PUSH2 0x1ca0 09B1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @09AC stack[-2] = 0x09b2 // @09AD stack[-1] = stack[-2] // @09AD stack[0] = stack[-1] // } // Block ends with call to 0x1ca0, returns to 0x09B2 label_09B2: // Incoming return from call to 0x1CA0 at 0x09B1 // Inputs[2] // { // @09B3 stack[-1] // @09B3 stack[-2] // } 09B2 5B JUMPDEST 09B3 11 GT 09B4 15 ISZERO 09B5 61 PUSH2 0x0a00 09B8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0a00, if !(stack[-1] > stack[-2]) label_09B9: // Incoming jump from 0x09B8, if not !(stack[-1] > stack[-2]) // Inputs[1] { @09BB memory[0x40:0x60] } 09B9 60 PUSH1 0x40 09BB 51 MLOAD 09BC 62 PUSH3 0x461bcd 09C0 60 PUSH1 0xe5 09C2 1B SHL 09C3 81 DUP2 09C4 52 MSTORE 09C5 60 PUSH1 0x20 09C7 60 PUSH1 0x04 09C9 82 DUP3 09CA 01 ADD 09CB 52 MSTORE 09CC 60 PUSH1 0x16 09CE 60 PUSH1 0x24 09D0 82 DUP3 09D1 01 ADD 09D2 52 MSTORE 09D3 7F PUSH32 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 09F4 60 PUSH1 0x44 09F6 82 DUP3 09F7 01 ADD 09F8 52 MSTORE 09F9 60 PUSH1 0x64 09FB 01 ADD 09FC 61 PUSH2 0x0899 09FF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09CB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09D2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @09F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 // @09FB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0A00: // Incoming jump from 0x09B8, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @0A01 msg.sender // @0A0F memory[0x00:0x40] // @0A10 storage[keccak256(memory[0x00:0x40])] // } 0A00 5B JUMPDEST 0A01 33 CALLER 0A02 60 PUSH1 0x00 0A04 90 SWAP1 0A05 81 DUP2 0A06 52 MSTORE 0A07 60 PUSH1 0x10 0A09 60 PUSH1 0x20 0A0B 52 MSTORE 0A0C 60 PUSH1 0x40 0A0E 90 SWAP1 0A0F 20 SHA3 0A10 54 SLOAD 0A11 15 ISZERO 0A12 61 PUSH2 0x0a5d 0A15 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A06 memory[0x00:0x20] = msg.sender // @0A0B memory[0x20:0x40] = 0x10 // } // Block ends with conditional jump to 0x0a5d, if !storage[keccak256(memory[0x00:0x40])] label_0A16: // Incoming jump from 0x0A15, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A18 memory[0x40:0x60] } 0A16 60 PUSH1 0x40 0A18 51 MLOAD 0A19 62 PUSH3 0x461bcd 0A1D 60 PUSH1 0xe5 0A1F 1B SHL 0A20 81 DUP2 0A21 52 MSTORE 0A22 60 PUSH1 0x20 0A24 60 PUSH1 0x04 0A26 82 DUP3 0A27 01 ADD 0A28 52 MSTORE 0A29 60 PUSH1 0x18 0A2B 60 PUSH1 0x24 0A2D 82 DUP3 0A2E 01 ADD 0A2F 52 MSTORE 0A30 7F PUSH32 0x596f75206861766520616c7265616479206d696e746564210000000000000000 0A51 60 PUSH1 0x44 0A53 82 DUP3 0A54 01 ADD 0A55 52 MSTORE 0A56 60 PUSH1 0x64 0A58 01 ADD 0A59 61 PUSH2 0x0899 0A5C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A28 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A2F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @0A55 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f75206861766520616c7265616479206d696e746564210000000000000000 // @0A58 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0A5D: // Incoming jump from 0x0A15, if !storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0A5E msg.sender // @0A6C memory[0x00:0x40] // @0A6E storage[keccak256(memory[0x00:0x40])] // @0A6F stack[-1] // } 0A5D 5B JUMPDEST 0A5E 33 CALLER 0A5F 60 PUSH1 0x00 0A61 90 SWAP1 0A62 81 DUP2 0A63 52 MSTORE 0A64 60 PUSH1 0x10 0A66 60 PUSH1 0x20 0A68 52 MSTORE 0A69 60 PUSH1 0x40 0A6B 81 DUP2 0A6C 20 SHA3 0A6D 80 DUP1 0A6E 54 SLOAD 0A6F 83 DUP4 0A70 92 SWAP3 0A71 90 SWAP1 0A72 61 PUSH2 0x0a7c 0A75 90 SWAP1 0A76 84 DUP5 0A77 90 SWAP1 0A78 61 PUSH2 0x1ca0 0A7B 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0A63 memory[0x00:0x20] = msg.sender // @0A68 memory[0x20:0x40] = 0x10 // @0A6C stack[1] = keccak256(memory[0x00:0x40]) // @0A70 stack[0] = stack[-1] // @0A71 stack[2] = 0x00 // @0A75 stack[3] = 0x0a7c // @0A77 stack[4] = stack[-1] // @0A77 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1ca0, returns to 0x0A7C label_0A7C: // Incoming return from call to 0x1CA0 at 0x0A7B // Inputs[6] // { // @0A7D stack[-2] // @0A7D stack[-1] // @0A7E stack[-3] // @0A84 stack[-4] // @0A86 msg.sender // @0A87 stack[-5] // } 0A7C 5B JUMPDEST 0A7D 90 SWAP1 0A7E 91 SWAP2 0A7F 55 SSTORE 0A80 50 POP 0A81 61 PUSH2 0x0a8c 0A84 90 SWAP1 0A85 50 POP 0A86 33 CALLER 0A87 82 DUP3 0A88 61 PUSH2 0x13b9 0A8B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0A7F storage[stack[-3]] = stack[-1] // @0A84 stack[-4] = 0x0a8c // @0A86 stack[-3] = msg.sender // @0A87 stack[-2] = stack[-5] // } // Block ends with call to 0x13b9, returns to 0x0A8C label_0A8C: // Incoming return from call to 0x13B9 at 0x0A8B // Inputs[1] { @0A93 stack[-2] } 0A8C 5B JUMPDEST 0A8D 50 POP 0A8E 60 PUSH1 0x01 0A90 60 PUSH1 0x09 0A92 55 SSTORE 0A93 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A92 storage[0x09] = 0x01 } // Block ends with unconditional jump to stack[-2] label_0A94: // Incoming jump from 0x0310 // Incoming call from 0x118C, returns to 0x118D // Inputs[1] { @0A9A stack[-1] } 0A94 5B JUMPDEST 0A95 60 PUSH1 0x00 0A97 61 PUSH2 0x0a9f 0A9A 82 DUP3 0A9B 61 PUSH2 0x13d3 0A9E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A95 stack[0] = 0x00 // @0A97 stack[1] = 0x0a9f // @0A9A stack[2] = stack[-1] // } // Block ends with call to 0x13d3, returns to 0x0A9F label_0A9F: // Incoming return from call to 0x13D3 at 0x0A9E // Inputs[3] // { // @0AA0 stack[-1] // @0AA0 stack[-2] // @0AA2 stack[-5] // } 0A9F 5B JUMPDEST 0AA0 90 SWAP1 0AA1 50 POP 0AA2 83 DUP4 0AA3 60 PUSH1 0x01 0AA5 60 PUSH1 0x01 0AA7 60 PUSH1 0xa0 0AA9 1B SHL 0AAA 03 SUB 0AAB 16 AND 0AAC 81 DUP2 0AAD 60 PUSH1 0x01 0AAF 60 PUSH1 0x01 0AB1 60 PUSH1 0xa0 0AB3 1B SHL 0AB4 03 SUB 0AB5 16 AND 0AB6 14 EQ 0AB7 61 PUSH2 0x0aec 0ABA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0AA0 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0aec, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0ABB: // Incoming jump from 0x0ABA, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0ABD memory[0x40:0x60] // @0AE6 memory[0x40:0x60] // @0AEB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ABB 60 PUSH1 0x40 0ABD 51 MLOAD 0ABE 7F PUSH32 0xa114810000000000000000000000000000000000000000000000000000000000 0ADF 81 DUP2 0AE0 52 MSTORE 0AE1 60 PUSH1 0x04 0AE3 01 ADD 0AE4 60 PUSH1 0x40 0AE6 51 MLOAD 0AE7 80 DUP1 0AE8 91 SWAP2 0AE9 03 SUB 0AEA 90 SWAP1 0AEB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa114810000000000000000000000000000000000000000000000000000000000 // @0AEB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AEC: // Incoming jump from 0x0ABA, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @0AEF stack[-2] // @0AFA memory[0x00:0x40] // @0AFC storage[keccak256(memory[0x00:0x40])] // @0AFD msg.sender // @0B09 stack[-4] // } 0AEC 5B JUMPDEST 0AED 60 PUSH1 0x00 0AEF 82 DUP3 0AF0 81 DUP2 0AF1 52 MSTORE 0AF2 60 PUSH1 0x07 0AF4 60 PUSH1 0x20 0AF6 52 MSTORE 0AF7 60 PUSH1 0x40 0AF9 90 SWAP1 0AFA 20 SHA3 0AFB 80 DUP1 0AFC 54 SLOAD 0AFD 33 CALLER 0AFE 80 DUP1 0AFF 82 DUP3 0B00 14 EQ 0B01 60 PUSH1 0x01 0B03 60 PUSH1 0x01 0B05 60 PUSH1 0xa0 0B07 1B SHL 0B08 03 SUB 0B09 88 DUP9 0B0A 16 AND 0B0B 90 SWAP1 0B0C 91 SWAP2 0B0D 14 EQ 0B0E 17 OR 0B0F 61 PUSH2 0x0b52 0B12 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0AF1 memory[0x00:0x20] = stack[-2] // @0AF6 memory[0x20:0x40] = 0x07 // @0AFA stack[0] = keccak256(memory[0x00:0x40]) // @0AFC stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0b52, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_0B13: // Incoming jump from 0x0B12, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @0B16 stack[-6] // @0B17 msg.sender // } 0B13 61 PUSH2 0x0b1c 0B16 86 DUP7 0B17 33 CALLER 0B18 61 PUSH2 0x056c 0B1B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B13 stack[0] = 0x0b1c // @0B16 stack[1] = stack[-6] // @0B17 stack[2] = msg.sender // } // Block ends with call to 0x056c, returns to 0x0B1C label_0B1C: // Incoming return from call to 0x056C at 0x0B1B // Inputs[1] { @0B20 stack[-1] } 0B1C 5B JUMPDEST 0B1D 61 PUSH2 0x0b52 0B20 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b52, if stack[-1] label_0B21: // Incoming jump from 0x0B20, if not stack[-1] // Inputs[3] // { // @0B23 memory[0x40:0x60] // @0B4C memory[0x40:0x60] // @0B51 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B21 60 PUSH1 0x40 0B23 51 MLOAD 0B24 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 0B45 81 DUP2 0B46 52 MSTORE 0B47 60 PUSH1 0x04 0B49 01 ADD 0B4A 60 PUSH1 0x40 0B4C 51 MLOAD 0B4D 80 DUP1 0B4E 91 SWAP2 0B4F 03 SUB 0B50 90 SWAP1 0B51 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @0B51 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B52: // Incoming jump from 0x0B12, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Incoming jump from 0x0B20, if stack[-1] // Inputs[1] { @0B5B stack[-5] } 0B52 5B JUMPDEST 0B53 60 PUSH1 0x01 0B55 60 PUSH1 0x01 0B57 60 PUSH1 0xa0 0B59 1B SHL 0B5A 03 SUB 0B5B 85 DUP6 0B5C 16 AND 0B5D 61 PUSH2 0x0b92 0B60 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b92, if stack[-5] & (0x01 << 0xa0) - 0x01 label_0B61: // Incoming jump from 0x0B60, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B63 memory[0x40:0x60] // @0B8C memory[0x40:0x60] // @0B91 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B61 60 PUSH1 0x40 0B63 51 MLOAD 0B64 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 0B85 81 DUP2 0B86 52 MSTORE 0B87 60 PUSH1 0x04 0B89 01 ADD 0B8A 60 PUSH1 0x40 0B8C 51 MLOAD 0B8D 80 DUP1 0B8E 91 SWAP2 0B8F 03 SUB 0B90 90 SWAP1 0B91 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @0B91 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B92: // Incoming jump from 0x0B60, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B93 stack[-1] } 0B92 5B JUMPDEST 0B93 80 DUP1 0B94 15 ISZERO 0B95 61 PUSH2 0x0b9d 0B98 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b9d, if !stack[-1] label_0B99: // Incoming jump from 0x0B98, if not !stack[-1] // Inputs[11] // { // @0B9B stack[-2] // @0BA6 stack[-6] // @0BB7 memory[0x00:0x40] // @0BB9 storage[keccak256(memory[0x00:0x40])] // @0BC1 stack[-5] // @0BC8 memory[0x00:0x40] // @0BCA storage[keccak256(memory[0x00:0x40])] // @0BD0 block.timestamp // @0BDD stack[-4] // @0BE8 memory[0x00:0x40] // @0BEF stack[-3] // } 0B99 60 PUSH1 0x00 0B9B 82 DUP3 0B9C 55 SSTORE 0B9D 5B JUMPDEST 0B9E 60 PUSH1 0x01 0BA0 60 PUSH1 0x01 0BA2 60 PUSH1 0xa0 0BA4 1B SHL 0BA5 03 SUB 0BA6 86 DUP7 0BA7 81 DUP2 0BA8 16 AND 0BA9 60 PUSH1 0x00 0BAB 90 SWAP1 0BAC 81 DUP2 0BAD 52 MSTORE 0BAE 60 PUSH1 0x06 0BB0 60 PUSH1 0x20 0BB2 52 MSTORE 0BB3 60 PUSH1 0x40 0BB5 80 DUP1 0BB6 82 DUP3 0BB7 20 SHA3 0BB8 80 DUP1 0BB9 54 SLOAD 0BBA 60 PUSH1 0x00 0BBC 19 NOT 0BBD 01 ADD 0BBE 90 SWAP1 0BBF 55 SSTORE 0BC0 91 SWAP2 0BC1 87 DUP8 0BC2 16 AND 0BC3 80 DUP1 0BC4 82 DUP3 0BC5 52 MSTORE 0BC6 91 SWAP2 0BC7 90 SWAP1 0BC8 20 SHA3 0BC9 80 DUP1 0BCA 54 SLOAD 0BCB 60 PUSH1 0x01 0BCD 01 ADD 0BCE 90 SWAP1 0BCF 55 SSTORE 0BD0 42 TIMESTAMP 0BD1 60 PUSH1 0xa0 0BD3 1B SHL 0BD4 17 OR 0BD5 60 PUSH1 0x01 0BD7 60 PUSH1 0xe1 0BD9 1B SHL 0BDA 17 OR 0BDB 60 PUSH1 0x00 0BDD 85 DUP6 0BDE 81 DUP2 0BDF 52 MSTORE 0BE0 60 PUSH1 0x05 0BE2 60 PUSH1 0x20 0BE4 52 MSTORE 0BE5 60 PUSH1 0x40 0BE7 90 SWAP1 0BE8 20 SHA3 0BE9 55 SSTORE 0BEA 60 PUSH1 0x01 0BEC 60 PUSH1 0xe1 0BEE 1B SHL 0BEF 83 DUP4 0BF0 16 AND 0BF1 61 PUSH2 0x0c28 0BF4 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0B9C storage[stack[-2]] = 0x00 // @0BAD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0BB2 memory[0x20:0x40] = 0x06 // @0BBF storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @0BC5 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0BCF storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0BDF memory[0x00:0x20] = stack[-4] // @0BE4 memory[0x20:0x40] = 0x05 // @0BE9 storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x0c28, if stack[-3] & (0x01 << 0xe1) label_0BF5: // Incoming jump from 0x0BF4, if not stack[-3] & (0x01 << 0xe1) // Incoming jump from 0x0BF4, if not stack[-3] & (0x01 << 0xe1) // Inputs[3] // { // @0BF7 stack[-4] // @0C06 memory[0x00:0x40] // @0C07 storage[keccak256(memory[0x00:0x40])] // } 0BF5 60 PUSH1 0x01 0BF7 84 DUP5 0BF8 01 ADD 0BF9 60 PUSH1 0x00 0BFB 81 DUP2 0BFC 81 DUP2 0BFD 52 MSTORE 0BFE 60 PUSH1 0x05 0C00 60 PUSH1 0x20 0C02 52 MSTORE 0C03 60 PUSH1 0x40 0C05 90 SWAP1 0C06 20 SHA3 0C07 54 SLOAD 0C08 61 PUSH2 0x0c26 0C0B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0BF8 stack[0] = stack[-4] + 0x01 // @0BFD memory[0x00:0x20] = stack[-4] + 0x01 // @0C02 memory[0x20:0x40] = 0x05 // } // Block ends with conditional jump to 0x0c26, if storage[keccak256(memory[0x00:0x40])] label_0C0C: // Incoming jump from 0x0C0B, if not storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0C0E storage[0x01] // @0C0F stack[-1] // } 0C0C 60 PUSH1 0x01 0C0E 54 SLOAD 0C0F 81 DUP2 0C10 14 EQ 0C11 61 PUSH2 0x0c26 0C14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c26, if stack[-1] == storage[0x01] label_0C15: // Incoming jump from 0x0C14, if not stack[-1] == storage[0x01] // Inputs[3] // { // @0C17 stack[-1] // @0C22 memory[0x00:0x40] // @0C23 stack[-4] // } 0C15 60 PUSH1 0x00 0C17 81 DUP2 0C18 81 DUP2 0C19 52 MSTORE 0C1A 60 PUSH1 0x05 0C1C 60 PUSH1 0x20 0C1E 52 MSTORE 0C1F 60 PUSH1 0x40 0C21 90 SWAP1 0C22 20 SHA3 0C23 84 DUP5 0C24 90 SWAP1 0C25 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @0C19 memory[0x00:0x20] = stack[-1] // @0C1E memory[0x20:0x40] = 0x05 // @0C25 storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_0C26: // Incoming jump from 0x0C14, if stack[-1] == storage[0x01] // Incoming jump from 0x0C0B, if storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0C25 0C26 5B JUMPDEST 0C27 50 POP // Stack delta = -1 // Block continues label_0C28: // Incoming jump from 0x0BF4, if stack[-3] & (0x01 << 0xe1) // Incoming jump from 0x0C27 // Incoming jump from 0x0BF4, if stack[-3] & (0x01 << 0xe1) // Inputs[7] // { // @0C29 stack[-4] // @0C2A stack[-5] // @0C34 stack[-6] // @0C61 memory[0x40:0x60] // @0C64 memory[0x40:0x60] // @0C69 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0C70 stack[-7] // } 0C28 5B JUMPDEST 0C29 83 DUP4 0C2A 85 DUP6 0C2B 60 PUSH1 0x01 0C2D 60 PUSH1 0x01 0C2F 60 PUSH1 0xa0 0C31 1B SHL 0C32 03 SUB 0C33 16 AND 0C34 87 DUP8 0C35 60 PUSH1 0x01 0C37 60 PUSH1 0x01 0C39 60 PUSH1 0xa0 0C3B 1B SHL 0C3C 03 SUB 0C3D 16 AND 0C3E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0C5F 60 PUSH1 0x40 0C61 51 MLOAD 0C62 60 PUSH1 0x40 0C64 51 MLOAD 0C65 80 DUP1 0C66 91 SWAP2 0C67 03 SUB 0C68 90 SWAP1 0C69 A4 LOG4 0C6A 50 POP 0C6B 50 POP 0C6C 50 POP 0C6D 50 POP 0C6E 50 POP 0C6F 50 POP 0C70 56 *JUMP // Stack delta = -7 // Outputs[1] { @0C69 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_0C71: // Incoming call from 0x032E, returns to 0x0297 0C71 5B JUMPDEST 0C72 61 PUSH2 0x0c79 0C75 61 PUSH2 0x135f 0C78 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C72 stack[0] = 0x0c79 } // Block ends with call to 0x135f, returns to 0x0C79 label_0C79: // Incoming return from call to 0x135F at 0x0C78 // Inputs[6] // { // @0C7C memory[0x40:0x60] // @0C7D msg.sender // @0C7F address(this).balance // @0C7F address(this) // @0C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0C8F address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0C79 5B JUMPDEST 0C7A 60 PUSH1 0x40 0C7C 51 MLOAD 0C7D 33 CALLER 0C7E 90 SWAP1 0C7F 47 SELFBALANCE 0C80 80 DUP1 0C81 15 ISZERO 0C82 61 PUSH2 0x08fc 0C85 02 MUL 0C86 91 SWAP2 0C87 60 PUSH1 0x00 0C89 81 DUP2 0C8A 81 DUP2 0C8B 81 DUP2 0C8C 85 DUP6 0C8D 88 DUP9 0C8E 88 DUP9 0C8F F1 CALL 0C90 93 SWAP4 0C91 50 POP 0C92 50 POP 0C93 50 POP 0C94 50 POP 0C95 61 PUSH2 0x0c9d 0C98 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) } // Block ends with conditional jump to 0x0c9d, if address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0C99: // Incoming jump from 0x0C98, if not address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @0C9C memory[0x00:0x00] } 0C99 60 PUSH1 0x00 0C9B 80 DUP1 0C9C FD *REVERT // Stack delta = +0 // Outputs[1] { @0C9C revert(memory[0x00:0x00]); } // Block terminates label_0C9D: // Incoming jump from 0x0C98, if address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x1371, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Incoming return from call to 0x144D at 0x0DF9 // Inputs[1] { @0C9E stack[-1] } 0C9D 5B JUMPDEST 0C9E 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C9F: // Incoming jump from 0x034E // Inputs[4] // { // @0CA3 stack[-3] // @0CA4 stack[-2] // @0CA5 stack[-1] // @0CA8 memory[0x40:0x60] // } 0C9F 5B JUMPDEST 0CA0 61 PUSH2 0x0cba 0CA3 83 DUP4 0CA4 83 DUP4 0CA5 83 DUP4 0CA6 60 PUSH1 0x40 0CA8 51 MLOAD 0CA9 80 DUP1 0CAA 60 PUSH1 0x20 0CAC 01 ADD 0CAD 60 PUSH1 0x40 0CAF 52 MSTORE 0CB0 80 DUP1 0CB1 60 PUSH1 0x00 0CB3 81 DUP2 0CB4 52 MSTORE 0CB5 50 POP 0CB6 61 PUSH2 0x1182 0CB9 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0CA0 stack[0] = 0x0cba // @0CA3 stack[1] = stack[-3] // @0CA4 stack[2] = stack[-2] // @0CA5 stack[3] = stack[-1] // @0CA8 stack[4] = memory[0x40:0x60] // @0CAF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1182, returns to 0x0CBA label_0CBA: // Incoming return from call to 0x1182 at 0x0CB9 // Incoming jump from 0x1623, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0CBE stack[-4] } 0CBA 5B JUMPDEST 0CBB 50 POP 0CBC 50 POP 0CBD 50 POP 0CBE 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0CBF: // Incoming jump from 0x036E 0CBF 5B JUMPDEST 0CC0 61 PUSH2 0x0cc7 0CC3 61 PUSH2 0x135f 0CC6 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC0 stack[0] = 0x0cc7 } // Block ends with call to 0x135f, returns to 0x0CC7 label_0CC7: // Incoming return from call to 0x135F at 0x0CC6 // Inputs[2] // { // @0CCA stack[-1] // @0CCB stack[-2] // } 0CC7 5B JUMPDEST 0CC8 60 PUSH1 0x0e 0CCA 55 SSTORE 0CCB 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CCA storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0CCC: // Incoming jump from 0x038E 0CCC 5B JUMPDEST 0CCD 61 PUSH2 0x0cd4 0CD0 61 PUSH2 0x135f 0CD3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CCD stack[0] = 0x0cd4 } // Block ends with call to 0x135f, returns to 0x0CD4 label_0CD4: // Incoming return from call to 0x135F at 0x0CD3 // Inputs[2] // { // @0CD5 stack[-1] // @0CD6 memory[stack[-1]:stack[-1] + 0x20] // } 0CD4 5B JUMPDEST 0CD5 80 DUP1 0CD6 51 MLOAD 0CD7 61 PUSH2 0x08ac 0CDA 90 SWAP1 0CDB 60 PUSH1 0x0c 0CDD 90 SWAP1 0CDE 60 PUSH1 0x20 0CE0 84 DUP5 0CE1 01 ADD 0CE2 90 SWAP1 0CE3 61 PUSH2 0x1827 0CE6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CDA stack[0] = 0x08ac // @0CDD stack[1] = 0x0c // @0CE2 stack[2] = stack[-1] + 0x20 // @0CE2 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1827 label_0CE7: // Incoming jump from 0x03C8 // Incoming call from 0x0770, returns to 0x0771 // Inputs[1] { @0CED stack[-1] } 0CE7 5B JUMPDEST 0CE8 60 PUSH1 0x00 0CEA 61 PUSH2 0x0671 0CED 82 DUP3 0CEE 61 PUSH2 0x13d3 0CF1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CE8 stack[0] = 0x00 // @0CEA stack[1] = 0x0671 // @0CED stack[2] = stack[-1] // } // Block ends with call to 0x13d3, returns to 0x0671 label_0CF2: // Incoming call from 0x03DD, returns to 0x0232 // Inputs[1] { @0CF6 storage[0x0c] } 0CF2 5B JUMPDEST 0CF3 60 PUSH1 0x0c 0CF5 80 DUP1 0CF6 54 SLOAD 0CF7 61 PUSH2 0x0cff 0CFA 90 SWAP1 0CFB 61 PUSH2 0x1ce4 0CFE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CF3 stack[0] = 0x0c // @0CFA stack[1] = 0x0cff // @0CFA stack[2] = storage[0x0c] // } // Block ends with call to 0x1ce4, returns to 0x0CFF label_0CFF: // Incoming return from call to 0x1CE4 at 0x0CFE // Inputs[4] // { // @0D00 stack[-1] // @0D0F memory[0x40:0x60] // @0D17 stack[-2] // @0D22 storage[stack[-2]] // } 0CFF 5B JUMPDEST 0D00 80 DUP1 0D01 60 PUSH1 0x1f 0D03 01 ADD 0D04 60 PUSH1 0x20 0D06 80 DUP1 0D07 91 SWAP2 0D08 04 DIV 0D09 02 MUL 0D0A 60 PUSH1 0x20 0D0C 01 ADD 0D0D 60 PUSH1 0x40 0D0F 51 MLOAD 0D10 90 SWAP1 0D11 81 DUP2 0D12 01 ADD 0D13 60 PUSH1 0x40 0D15 52 MSTORE 0D16 80 DUP1 0D17 92 SWAP3 0D18 91 SWAP2 0D19 90 SWAP1 0D1A 81 DUP2 0D1B 81 DUP2 0D1C 52 MSTORE 0D1D 60 PUSH1 0x20 0D1F 01 ADD 0D20 82 DUP3 0D21 80 DUP1 0D22 54 SLOAD 0D23 61 PUSH2 0x0d2b 0D26 90 SWAP1 0D27 61 PUSH2 0x1ce4 0D2A 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0D15 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0D17 stack[-2] = memory[0x40:0x60] // @0D18 stack[-1] = stack[-2] // @0D19 stack[0] = stack[-1] // @0D1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D1F stack[1] = 0x20 + memory[0x40:0x60] // @0D20 stack[2] = stack[-2] // @0D26 stack[4] = storage[stack[-2]] // @0D26 stack[3] = 0x0d2b // } // Block ends with call to 0x1ce4, returns to 0x0D2B label_0D2B: // Incoming return from call to 0x1CE4 at 0x0D2A // Inputs[1] { @0D2C stack[-1] } 0D2B 5B JUMPDEST 0D2C 80 DUP1 0D2D 15 ISZERO 0D2E 61 PUSH2 0x0d78 0D31 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d78, if !stack[-1] label_0D32: // Incoming jump from 0x0D31, if not !stack[-1] // Inputs[1] { @0D32 stack[-1] } 0D32 80 DUP1 0D33 60 PUSH1 0x1f 0D35 10 LT 0D36 61 PUSH2 0x0d4d 0D39 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d4d, if 0x1f < stack[-1] label_0D3A: // Incoming jump from 0x0D39, if not 0x1f < stack[-1] // Inputs[4] // { // @0D3E stack[-2] // @0D3F storage[stack[-2]] // @0D42 stack[-3] // @0D44 stack[-1] // } 0D3A 61 PUSH2 0x0100 0D3D 80 DUP1 0D3E 83 DUP4 0D3F 54 SLOAD 0D40 04 DIV 0D41 02 MUL 0D42 83 DUP4 0D43 52 MSTORE 0D44 91 SWAP2 0D45 60 PUSH1 0x20 0D47 01 ADD 0D48 91 SWAP2 0D49 61 PUSH2 0x0d78 0D4C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D43 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D48 stack[-1] = stack[-1] // @0D48 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0d78 label_0D4D: // Incoming jump from 0x0D39, if 0x1f < stack[-1] // Inputs[5] // { // @0D4E stack[-3] // @0D4F stack[-1] // @0D51 stack[-2] // @0D59 memory[0x00:0x20] // @0D5D storage[keccak256(memory[0x00:0x20])] // } 0D4D 5B JUMPDEST 0D4E 82 DUP3 0D4F 01 ADD 0D50 91 SWAP2 0D51 90 SWAP1 0D52 60 PUSH1 0x00 0D54 52 MSTORE 0D55 60 PUSH1 0x20 0D57 60 PUSH1 0x00 0D59 20 SHA3 0D5A 90 SWAP1 0D5B 5B JUMPDEST 0D5C 81 DUP2 0D5D 54 SLOAD 0D5E 81 DUP2 0D5F 52 MSTORE 0D60 90 SWAP1 0D61 60 PUSH1 0x01 0D63 01 ADD 0D64 90 SWAP1 0D65 60 PUSH1 0x20 0D67 01 ADD 0D68 80 DUP1 0D69 83 DUP4 0D6A 11 GT 0D6B 61 PUSH2 0x0d5b 0D6E 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0D50 stack[-3] = stack[-3] + stack[-1] // @0D54 memory[0x00:0x20] = stack[-2] // @0D5F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0D64 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0D67 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0d5b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0D6F: // Incoming jump from 0x0D6E, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0D6E, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0D6F stack[-3] // @0D70 stack[-1] // } 0D6F 82 DUP3 0D70 90 SWAP1 0D71 03 SUB 0D72 60 PUSH1 0x1f 0D74 16 AND 0D75 82 DUP3 0D76 01 ADD 0D77 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0D77 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0D77 stack[-1] = stack[-3] // } // Block continues label_0D78: // Incoming jump from 0x0D77 // Incoming jump from 0x0D31, if !stack[-1] // Incoming jump from 0x0D4C // Inputs[1] { @0D7E stack[-7] } 0D78 5B JUMPDEST 0D79 50 POP 0D7A 50 POP 0D7B 50 POP 0D7C 50 POP 0D7D 50 POP 0D7E 81 DUP2 0D7F 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0D80: // Incoming jump from 0x03FD // Inputs[1] { @0D8B stack[-1] } 0D80 5B JUMPDEST 0D81 60 PUSH1 0x00 0D83 60 PUSH1 0x01 0D85 60 PUSH1 0x01 0D87 60 PUSH1 0xa0 0D89 1B SHL 0D8A 03 SUB 0D8B 82 DUP3 0D8C 16 AND 0D8D 61 PUSH2 0x0dc2 0D90 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D81 stack[0] = 0x00 } // Block ends with conditional jump to 0x0dc2, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0D91: // Incoming jump from 0x0D90, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0D93 memory[0x40:0x60] // @0DBC memory[0x40:0x60] // @0DC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D91 60 PUSH1 0x40 0D93 51 MLOAD 0D94 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 0DB5 81 DUP2 0DB6 52 MSTORE 0DB7 60 PUSH1 0x04 0DB9 01 ADD 0DBA 60 PUSH1 0x40 0DBC 51 MLOAD 0DBD 80 DUP1 0DBE 91 SWAP2 0DBF 03 SUB 0DC0 90 SWAP1 0DC1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @0DC1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DC2: // Incoming jump from 0x0D90, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0DCC stack[-2] // @0DDA memory[0x00:0x40] // @0DDB storage[keccak256(memory[0x00:0x40])] // @0DE6 stack[-3] // } 0DC2 5B JUMPDEST 0DC3 50 POP 0DC4 60 PUSH1 0x01 0DC6 60 PUSH1 0x01 0DC8 60 PUSH1 0xa0 0DCA 1B SHL 0DCB 03 SUB 0DCC 16 AND 0DCD 60 PUSH1 0x00 0DCF 90 SWAP1 0DD0 81 DUP2 0DD1 52 MSTORE 0DD2 60 PUSH1 0x06 0DD4 60 PUSH1 0x20 0DD6 52 MSTORE 0DD7 60 PUSH1 0x40 0DD9 90 SWAP1 0DDA 20 SHA3 0DDB 54 SLOAD 0DDC 67 PUSH8 0xffffffffffffffff 0DE5 16 AND 0DE6 90 SWAP1 0DE7 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0DD1 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0DD6 memory[0x20:0x40] = 0x06 // @0DE6 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0DE8: // Incoming jump from 0x0412 0DE8 5B JUMPDEST 0DE9 61 PUSH2 0x0df0 0DEC 61 PUSH2 0x135f 0DEF 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DE9 stack[0] = 0x0df0 } // Block ends with call to 0x135f, returns to 0x0DF0 label_0DF0: // Incoming return from call to 0x135F at 0x0DEF 0DF0 5B JUMPDEST 0DF1 61 PUSH2 0x0c9d 0DF4 60 PUSH1 0x00 0DF6 61 PUSH2 0x144d 0DF9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DF1 stack[0] = 0x0c9d // @0DF4 stack[1] = 0x00 // } // Block ends with call to 0x144d, returns to 0x0C9D label_0DFA: // Incoming jump from 0x0432 // Inputs[1] { @0DFF storage[0x09] } 0DFA 5B JUMPDEST 0DFB 60 PUSH1 0x02 0DFD 60 PUSH1 0x09 0DFF 54 SLOAD 0E00 14 EQ 0E01 15 ISZERO 0E02 61 PUSH2 0x0e4d 0E05 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e4d, if !(storage[0x09] == 0x02) label_0E06: // Incoming jump from 0x0E05, if not !(storage[0x09] == 0x02) // Inputs[1] { @0E08 memory[0x40:0x60] } 0E06 60 PUSH1 0x40 0E08 51 MLOAD 0E09 62 PUSH3 0x461bcd 0E0D 60 PUSH1 0xe5 0E0F 1B SHL 0E10 81 DUP2 0E11 52 MSTORE 0E12 60 PUSH1 0x20 0E14 60 PUSH1 0x04 0E16 82 DUP3 0E17 01 ADD 0E18 52 MSTORE 0E19 60 PUSH1 0x1f 0E1B 60 PUSH1 0x24 0E1D 82 DUP3 0E1E 01 ADD 0E1F 52 MSTORE 0E20 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0E41 60 PUSH1 0x44 0E43 82 DUP3 0E44 01 ADD 0E45 52 MSTORE 0E46 60 PUSH1 0x64 0E48 01 ADD 0E49 61 PUSH2 0x0899 0E4C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E11 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E18 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E1F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0E45 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0E48 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0E4D: // Incoming jump from 0x0E05, if !(storage[0x09] == 0x02) // Inputs[2] // { // @0E53 tx.origin // @0E54 msg.sender // } 0E4D 5B JUMPDEST 0E4E 60 PUSH1 0x02 0E50 60 PUSH1 0x09 0E52 55 SSTORE 0E53 32 ORIGIN 0E54 33 CALLER 0E55 14 EQ 0E56 61 PUSH2 0x0e8c 0E59 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E52 storage[0x09] = 0x02 } // Block ends with conditional jump to 0x0e8c, if msg.sender == tx.origin label_0E5A: // Incoming jump from 0x0E59, if not msg.sender == tx.origin // Inputs[1] { @0E5C memory[0x40:0x60] } 0E5A 60 PUSH1 0x40 0E5C 51 MLOAD 0E5D 62 PUSH3 0x461bcd 0E61 60 PUSH1 0xe5 0E63 1B SHL 0E64 81 DUP2 0E65 52 MSTORE 0E66 60 PUSH1 0x20 0E68 60 PUSH1 0x04 0E6A 82 DUP3 0E6B 01 ADD 0E6C 52 MSTORE 0E6D 60 PUSH1 0x08 0E6F 60 PUSH1 0x24 0E71 82 DUP3 0E72 01 ADD 0E73 52 MSTORE 0E74 67 PUSH8 0x4f6e6c7920454f41 0E7D 60 PUSH1 0xc0 0E7F 1B SHL 0E80 60 PUSH1 0x44 0E82 82 DUP3 0E83 01 ADD 0E84 52 MSTORE 0E85 60 PUSH1 0x64 0E87 01 ADD 0E88 61 PUSH2 0x0899 0E8B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E6C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E73 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0E84 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c7920454f41 << 0xc0 // @0E87 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0E8C: // Incoming jump from 0x0E59, if msg.sender == tx.origin // Inputs[3] // { // @0E8D msg.sender // @0E9B memory[0x00:0x40] // @0E9C storage[keccak256(memory[0x00:0x40])] // } 0E8C 5B JUMPDEST 0E8D 33 CALLER 0E8E 60 PUSH1 0x00 0E90 90 SWAP1 0E91 81 DUP2 0E92 52 MSTORE 0E93 60 PUSH1 0x11 0E95 60 PUSH1 0x20 0E97 52 MSTORE 0E98 60 PUSH1 0x40 0E9A 90 SWAP1 0E9B 20 SHA3 0E9C 54 SLOAD 0E9D 15 ISZERO 0E9E 61 PUSH2 0x0ee9 0EA1 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E92 memory[0x00:0x20] = msg.sender // @0E97 memory[0x20:0x40] = 0x11 // } // Block ends with conditional jump to 0x0ee9, if !storage[keccak256(memory[0x00:0x40])] label_0EA2: // Incoming jump from 0x0EA1, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0EA4 memory[0x40:0x60] } 0EA2 60 PUSH1 0x40 0EA4 51 MLOAD 0EA5 62 PUSH3 0x461bcd 0EA9 60 PUSH1 0xe5 0EAB 1B SHL 0EAC 81 DUP2 0EAD 52 MSTORE 0EAE 60 PUSH1 0x20 0EB0 60 PUSH1 0x04 0EB2 82 DUP3 0EB3 01 ADD 0EB4 81 DUP2 0EB5 90 SWAP1 0EB6 52 MSTORE 0EB7 60 PUSH1 0x24 0EB9 82 DUP3 0EBA 01 ADD 0EBB 52 MSTORE 0EBC 7F PUSH32 0x557365722068617320616c72656164792070726573616c65206d696e74656421 0EDD 60 PUSH1 0x44 0EDF 82 DUP3 0EE0 01 ADD 0EE1 52 MSTORE 0EE2 60 PUSH1 0x64 0EE4 01 ADD 0EE5 61 PUSH2 0x0899 0EE8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EB6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EBB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0EE1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x557365722068617320616c72656164792070726573616c65206d696e74656421 // @0EE4 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_0EE9: // Incoming jump from 0x0EA1, if !storage[keccak256(memory[0x00:0x40])] // Inputs[10] // { // @0EEC memory[0x40:0x60] // @0EFB msg.sender // @0F0D memory[0x40:0x60] // @0F1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0F20 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @0F28 stack[-2] // @0F29 stack[-1] // @0F34 memory[0x40:0x60] // @0F4E msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @0F5B storage[0x0e] // } 0EE9 5B JUMPDEST 0EEA 60 PUSH1 0x40 0EEC 51 MLOAD 0EED 6B PUSH12 0xffffffffffffffffffffffff 0EFA 19 NOT 0EFB 33 CALLER 0EFC 60 PUSH1 0x60 0EFE 1B SHL 0EFF 16 AND 0F00 60 PUSH1 0x20 0F02 82 DUP3 0F03 01 ADD 0F04 52 MSTORE 0F05 60 PUSH1 0x00 0F07 90 SWAP1 0F08 60 PUSH1 0x34 0F0A 01 ADD 0F0B 60 PUSH1 0x40 0F0D 51 MLOAD 0F0E 60 PUSH1 0x20 0F10 81 DUP2 0F11 83 DUP4 0F12 03 SUB 0F13 03 SUB 0F14 81 DUP2 0F15 52 MSTORE 0F16 90 SWAP1 0F17 60 PUSH1 0x40 0F19 52 MSTORE 0F1A 80 DUP1 0F1B 51 MLOAD 0F1C 90 SWAP1 0F1D 60 PUSH1 0x20 0F1F 01 ADD 0F20 20 SHA3 0F21 90 SWAP1 0F22 50 POP 0F23 60 PUSH1 0x00 0F25 61 PUSH2 0x0f65 0F28 84 DUP5 0F29 84 DUP5 0F2A 80 DUP1 0F2B 80 DUP1 0F2C 60 PUSH1 0x20 0F2E 02 MUL 0F2F 60 PUSH1 0x20 0F31 01 ADD 0F32 60 PUSH1 0x40 0F34 51 MLOAD 0F35 90 SWAP1 0F36 81 DUP2 0F37 01 ADD 0F38 60 PUSH1 0x40 0F3A 52 MSTORE 0F3B 80 DUP1 0F3C 93 SWAP4 0F3D 92 SWAP3 0F3E 91 SWAP2 0F3F 90 SWAP1 0F40 81 DUP2 0F41 81 DUP2 0F42 52 MSTORE 0F43 60 PUSH1 0x20 0F45 01 ADD 0F46 83 DUP4 0F47 83 DUP4 0F48 60 PUSH1 0x20 0F4A 02 MUL 0F4B 80 DUP1 0F4C 82 DUP3 0F4D 84 DUP5 0F4E 37 CALLDATACOPY 0F4F 60 PUSH1 0x00 0F51 92 SWAP3 0F52 01 ADD 0F53 91 SWAP2 0F54 90 SWAP1 0F55 91 SWAP2 0F56 52 MSTORE 0F57 50 POP 0F58 50 POP 0F59 60 PUSH1 0x0e 0F5B 54 SLOAD 0F5C 91 SWAP2 0F5D 50 POP 0F5E 85 DUP6 0F5F 90 SWAP1 0F60 50 POP 0F61 61 PUSH2 0x14aa 0F64 56 *JUMP // Stack delta = +6 // Outputs[13] // { // @0F04 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @0F15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @0F19 memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @0F21 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @0F23 stack[1] = 0x00 // @0F25 stack[2] = 0x0f65 // @0F3A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // @0F3C stack[3] = memory[0x40:0x60] // @0F42 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0F4E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @0F56 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-1]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1] + 0x20] = 0x00 // @0F5C stack[4] = storage[0x0e] // @0F5F stack[5] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x14aa, returns to 0x0F65 label_0F65: // Incoming return from call to 0x14AA at 0x0F64 // Inputs[1] { @0F66 stack[-1] } 0F65 5B JUMPDEST 0F66 15 ISZERO 0F67 61 PUSH2 0x0f72 0F6A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f72, if !stack[-1] label_0F6B: // Incoming jump from 0x0F6A, if not !stack[-1] 0F6B 50 POP 0F6C 60 PUSH1 0x03 0F6E 61 PUSH2 0x0fbc 0F71 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F6C stack[-1] = 0x03 } // Block ends with unconditional jump to 0x0fbc label_0F72: // Incoming jump from 0x0F6A, if !stack[-1] // Inputs[6] // { // @0F76 stack[-4] // @0F77 stack[-3] // @0F82 memory[0x40:0x60] // @0F9C msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @0FA9 storage[0x0f] // @0FAC stack[-2] // } 0F72 5B JUMPDEST 0F73 61 PUSH2 0x0fb3 0F76 84 DUP5 0F77 84 DUP5 0F78 80 DUP1 0F79 80 DUP1 0F7A 60 PUSH1 0x20 0F7C 02 MUL 0F7D 60 PUSH1 0x20 0F7F 01 ADD 0F80 60 PUSH1 0x40 0F82 51 MLOAD 0F83 90 SWAP1 0F84 81 DUP2 0F85 01 ADD 0F86 60 PUSH1 0x40 0F88 52 MSTORE 0F89 80 DUP1 0F8A 93 SWAP4 0F8B 92 SWAP3 0F8C 91 SWAP2 0F8D 90 SWAP1 0F8E 81 DUP2 0F8F 81 DUP2 0F90 52 MSTORE 0F91 60 PUSH1 0x20 0F93 01 ADD 0F94 83 DUP4 0F95 83 DUP4 0F96 60 PUSH1 0x20 0F98 02 MUL 0F99 80 DUP1 0F9A 82 DUP3 0F9B 84 DUP5 0F9C 37 CALLDATACOPY 0F9D 60 PUSH1 0x00 0F9F 92 SWAP3 0FA0 01 ADD 0FA1 91 SWAP2 0FA2 90 SWAP1 0FA3 91 SWAP2 0FA4 52 MSTORE 0FA5 50 POP 0FA6 50 POP 0FA7 60 PUSH1 0x0f 0FA9 54 SLOAD 0FAA 91 SWAP2 0FAB 50 POP 0FAC 85 DUP6 0FAD 90 SWAP1 0FAE 50 POP 0FAF 61 PUSH2 0x14aa 0FB2 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0F73 stack[0] = 0x0fb3 // @0F88 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-3] // @0F8A stack[1] = memory[0x40:0x60] // @0F90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0F9C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3]] = msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @0FA4 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-3]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3] + 0x20] = 0x00 // @0FAA stack[2] = storage[0x0f] // @0FAD stack[3] = stack[-2] // } // Block ends with call to 0x14aa, returns to 0x0FB3 label_0FB3: // Incoming return from call to 0x14AA at 0x0FB2 // Inputs[1] { @0FB4 stack[-1] } 0FB3 5B JUMPDEST 0FB4 15 ISZERO 0FB5 61 PUSH2 0x01e3 0FB8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01e3, if !stack[-1] label_0FB9: // Incoming jump from 0x0FB8, if not !stack[-1] 0FB9 50 POP 0FBA 60 PUSH1 0x02 // Stack delta = +0 // Outputs[1] { @0FBA stack[-1] = 0x02 } // Block continues label_0FBC: // Incoming jump from 0x0F71 // Incoming jump from 0x0FBA // Inputs[1] { @0FBF storage[0x0b] } 0FBC 5B JUMPDEST 0FBD 60 PUSH1 0x0b 0FBF 54 SLOAD 0FC0 61 PUSH2 0x0100 0FC3 90 SWAP1 0FC4 04 DIV 0FC5 60 PUSH1 0xff 0FC7 16 AND 0FC8 15 ISZERO 0FC9 61 PUSH2 0x1014 0FCC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1014, if !(0xff & storage[0x0b] / 0x0100) label_0FCD: // Incoming jump from 0x0FCC, if not !(0xff & storage[0x0b] / 0x0100) // Inputs[1] { @0FCF memory[0x40:0x60] } 0FCD 60 PUSH1 0x40 0FCF 51 MLOAD 0FD0 62 PUSH3 0x461bcd 0FD4 60 PUSH1 0xe5 0FD6 1B SHL 0FD7 81 DUP2 0FD8 52 MSTORE 0FD9 60 PUSH1 0x20 0FDB 60 PUSH1 0x04 0FDD 82 DUP3 0FDE 01 ADD 0FDF 52 MSTORE 0FE0 60 PUSH1 0x11 0FE2 60 PUSH1 0x24 0FE4 82 DUP3 0FE5 01 ADD 0FE6 52 MSTORE 0FE7 7F PUSH32 0x50726573616c6520697320706175736564000000000000000000000000000000 1008 60 PUSH1 0x44 100A 82 DUP3 100B 01 ADD 100C 52 MSTORE 100D 60 PUSH1 0x64 100F 01 ADD 1010 61 PUSH2 0x0899 1013 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FDF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FE6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @100C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50726573616c6520697320706175736564000000000000000000000000000000 // @100F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_1014: // Incoming jump from 0x0FCC, if !(0xff & storage[0x0b] / 0x0100) // Inputs[4] // { // @1017 storage[0x0a] // @1018 stack[-1] // @101E storage[0x02] // @1021 storage[0x01] // } 1014 5B JUMPDEST 1015 60 PUSH1 0x0a 1017 54 SLOAD 1018 81 DUP2 1019 61 PUSH2 0x1025 101C 60 PUSH1 0x02 101E 54 SLOAD 101F 60 PUSH1 0x01 1021 54 SLOAD 1022 03 SUB 1023 90 SWAP1 1024 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1017 stack[0] = storage[0x0a] // @1018 stack[1] = stack[-1] // @1023 stack[2] = storage[0x01] - storage[0x02] // } // Block ends with unconditional jump to 0x1025 label_1025: // Incoming jump from 0x1024 // Inputs[2] // { // @1029 stack[-2] // @102A stack[-1] // } 1025 5B JUMPDEST 1026 61 PUSH2 0x102f 1029 91 SWAP2 102A 90 SWAP1 102B 61 PUSH2 0x1ca0 102E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1029 stack[-2] = 0x102f // @102A stack[-1] = stack[-2] // @102A stack[0] = stack[-1] // } // Block ends with call to 0x1ca0, returns to 0x102F label_102F: // Incoming return from call to 0x1CA0 at 0x102E // Inputs[2] // { // @1030 stack[-2] // @1030 stack[-1] // } 102F 5B JUMPDEST 1030 11 GT 1031 15 ISZERO 1032 61 PUSH2 0x107d 1035 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x107d, if !(stack[-1] > stack[-2]) label_1036: // Incoming jump from 0x1035, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1038 memory[0x40:0x60] } 1036 60 PUSH1 0x40 1038 51 MLOAD 1039 62 PUSH3 0x461bcd 103D 60 PUSH1 0xe5 103F 1B SHL 1040 81 DUP2 1041 52 MSTORE 1042 60 PUSH1 0x20 1044 60 PUSH1 0x04 1046 82 DUP3 1047 01 ADD 1048 52 MSTORE 1049 60 PUSH1 0x16 104B 60 PUSH1 0x24 104D 82 DUP3 104E 01 ADD 104F 52 MSTORE 1050 7F PUSH32 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 1071 60 PUSH1 0x44 1073 82 DUP3 1074 01 ADD 1075 52 MSTORE 1076 60 PUSH1 0x64 1078 01 ADD 1079 61 PUSH2 0x0899 107C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1041 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1048 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @104F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @1075 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f20656e6f75676874206d696e7473206c6566742e00000000000000000000 // @1078 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_107D: // Incoming jump from 0x1035, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @107E msg.sender // @108C memory[0x00:0x40] // @108E storage[keccak256(memory[0x00:0x40])] // @108F stack[-1] // } 107D 5B JUMPDEST 107E 33 CALLER 107F 60 PUSH1 0x00 1081 90 SWAP1 1082 81 DUP2 1083 52 MSTORE 1084 60 PUSH1 0x11 1086 60 PUSH1 0x20 1088 52 MSTORE 1089 60 PUSH1 0x40 108B 81 DUP2 108C 20 SHA3 108D 80 DUP1 108E 54 SLOAD 108F 83 DUP4 1090 92 SWAP3 1091 90 SWAP1 1092 61 PUSH2 0x109c 1095 90 SWAP1 1096 84 DUP5 1097 90 SWAP1 1098 61 PUSH2 0x1ca0 109B 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1083 memory[0x00:0x20] = msg.sender // @1088 memory[0x20:0x40] = 0x11 // @108C stack[1] = keccak256(memory[0x00:0x40]) // @1090 stack[0] = stack[-1] // @1091 stack[2] = 0x00 // @1095 stack[3] = 0x109c // @1097 stack[4] = stack[-1] // @1097 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1ca0, returns to 0x109C label_109C: // Incoming return from call to 0x1CA0 at 0x109B // Inputs[6] // { // @109D stack[-2] // @109D stack[-1] // @109E stack[-3] // @10A4 stack[-4] // @10A6 msg.sender // @10A7 stack[-5] // } 109C 5B JUMPDEST 109D 90 SWAP1 109E 91 SWAP2 109F 55 SSTORE 10A0 50 POP 10A1 61 PUSH2 0x10ac 10A4 90 SWAP1 10A5 50 POP 10A6 33 CALLER 10A7 82 DUP3 10A8 61 PUSH2 0x13b9 10AB 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @109F storage[stack[-3]] = stack[-1] // @10A4 stack[-4] = 0x10ac // @10A6 stack[-3] = msg.sender // @10A7 stack[-2] = stack[-5] // } // Block ends with call to 0x13b9, returns to 0x10AC label_10AC: // Incoming return from call to 0x13B9 at 0x10AB // Inputs[1] { @10B6 stack[-5] } 10AC 5B JUMPDEST 10AD 50 POP 10AE 50 POP 10AF 60 PUSH1 0x01 10B1 60 PUSH1 0x09 10B3 55 SSTORE 10B4 50 POP 10B5 50 POP 10B6 56 *JUMP // Stack delta = -5 // Outputs[1] { @10B3 storage[0x09] = 0x01 } // Block ends with unconditional jump to stack[-5] label_10B7: // Incoming call from 0x0465, returns to 0x0232 // Inputs[1] { @10BD storage[0x04] } 10B7 5B JUMPDEST 10B8 60 PUSH1 0x60 10BA 60 PUSH1 0x04 10BC 80 DUP1 10BD 54 SLOAD 10BE 61 PUSH2 0x0686 10C1 90 SWAP1 10C2 61 PUSH2 0x1ce4 10C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10B8 stack[0] = 0x60 // @10BA stack[1] = 0x04 // @10C1 stack[2] = 0x0686 // @10C1 stack[3] = storage[0x04] // } // Block ends with call to 0x1ce4, returns to 0x0686 10C6 5B JUMPDEST 10C7 60 PUSH1 0x01 10C9 60 PUSH1 0x01 10CB 60 PUSH1 0xa0 10CD 1B SHL 10CE 03 SUB 10CF 82 DUP3 10D0 16 AND 10D1 33 CALLER 10D2 14 EQ 10D3 15 ISZERO 10D4 61 PUSH2 0x1109 10D7 57 *JUMPI 10D8 60 PUSH1 0x40 10DA 51 MLOAD 10DB 7F PUSH32 0xb06307db00000000000000000000000000000000000000000000000000000000 10FC 81 DUP2 10FD 52 MSTORE 10FE 60 PUSH1 0x04 1100 01 ADD 1101 60 PUSH1 0x40 1103 51 MLOAD 1104 80 DUP1 1105 91 SWAP2 1106 03 SUB 1107 90 SWAP1 1108 FD *REVERT 1109 5B JUMPDEST 110A 33 CALLER 110B 60 PUSH1 0x00 110D 81 DUP2 110E 81 DUP2 110F 52 MSTORE 1110 60 PUSH1 0x08 1112 60 PUSH1 0x20 1114 90 SWAP1 1115 81 DUP2 1116 52 MSTORE 1117 60 PUSH1 0x40 1119 80 DUP1 111A 83 DUP4 111B 20 SHA3 111C 60 PUSH1 0x01 111E 60 PUSH1 0x01 1120 60 PUSH1 0xa0 1122 1B SHL 1123 03 SUB 1124 87 DUP8 1125 16 AND 1126 80 DUP1 1127 85 DUP6 1128 52 MSTORE 1129 90 SWAP1 112A 83 DUP4 112B 52 MSTORE 112C 92 SWAP3 112D 81 DUP2 112E 90 SWAP1 112F 20 SHA3 1130 80 DUP1 1131 54 SLOAD 1132 60 PUSH1 0xff 1134 19 NOT 1135 16 AND 1136 86 DUP7 1137 15 ISZERO 1138 15 ISZERO 1139 90 SWAP1 113A 81 DUP2 113B 17 OR 113C 90 SWAP1 113D 91 SWAP2 113E 55 SSTORE 113F 90 SWAP1 1140 51 MLOAD 1141 90 SWAP1 1142 81 DUP2 1143 52 MSTORE 1144 91 SWAP2 1145 92 SWAP3 1146 91 SWAP2 1147 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1168 91 SWAP2 1169 01 ADD 116A 60 PUSH1 0x40 116C 51 MLOAD 116D 80 DUP1 116E 91 SWAP2 116F 03 SUB 1170 90 SWAP1 1171 A3 LOG3 1172 50 POP 1173 50 POP 1174 56 *JUMP label_1175: // Incoming jump from 0x04C4 1175 5B JUMPDEST 1176 61 PUSH2 0x117d 1179 61 PUSH2 0x135f 117C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1176 stack[0] = 0x117d } // Block ends with call to 0x135f, returns to 0x117D label_117D: // Incoming return from call to 0x135F at 0x117C // Inputs[2] // { // @1180 stack[-1] // @1181 stack[-2] // } 117D 5B JUMPDEST 117E 60 PUSH1 0x0f 1180 55 SSTORE 1181 56 *JUMP // Stack delta = -2 // Outputs[1] { @1180 storage[0x0f] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1182: // Incoming call from 0x0CB9, returns to 0x0CBA // Incoming jump from 0x04E4 // Inputs[3] // { // @1186 stack[-4] // @1187 stack[-3] // @1188 stack[-2] // } 1182 5B JUMPDEST 1183 61 PUSH2 0x118d 1186 84 DUP5 1187 84 DUP5 1188 84 DUP5 1189 61 PUSH2 0x0a94 118C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1183 stack[0] = 0x118d // @1186 stack[1] = stack[-4] // @1187 stack[2] = stack[-3] // @1188 stack[3] = stack[-2] // } // Block ends with call to 0x0a94, returns to 0x118D label_118D: // Incoming return from call to 0x0A94 at 0x118C // Inputs[2] // { // @1196 stack[-3] // @1198 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 118D 5B JUMPDEST 118E 60 PUSH1 0x01 1190 60 PUSH1 0x01 1192 60 PUSH1 0xa0 1194 1B SHL 1195 03 SUB 1196 83 DUP4 1197 16 AND 1198 3B EXTCODESIZE 1199 15 ISZERO 119A 61 PUSH2 0x11c6 119D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c6, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_119E: // Incoming jump from 0x119D, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @11A1 stack[-4] // @11A2 stack[-3] // @11A3 stack[-2] // @11A4 stack[-1] // } 119E 61 PUSH2 0x11a9 11A1 84 DUP5 11A2 84 DUP5 11A3 84 DUP5 11A4 84 DUP5 11A5 61 PUSH2 0x14c0 11A8 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @119E stack[0] = 0x11a9 // @11A1 stack[1] = stack[-4] // @11A2 stack[2] = stack[-3] // @11A3 stack[3] = stack[-2] // @11A4 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x14c0 11A9 5B JUMPDEST 11AA 61 PUSH2 0x11c6 11AD 57 *JUMPI 11AE 60 PUSH1 0x40 11B0 51 MLOAD 11B1 63 PUSH4 0x68d2bf6b 11B6 60 PUSH1 0xe1 11B8 1B SHL 11B9 81 DUP2 11BA 52 MSTORE 11BB 60 PUSH1 0x04 11BD 01 ADD 11BE 60 PUSH1 0x40 11C0 51 MLOAD 11C1 80 DUP1 11C2 91 SWAP2 11C3 03 SUB 11C4 90 SWAP1 11C5 FD *REVERT label_11C6: // Incoming jump from 0x1CDB, if !(stack[-1] > stack[-4]) // Incoming jump from 0x119D, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @11CB stack[-5] } 11C6 5B JUMPDEST 11C7 50 POP 11C8 50 POP 11C9 50 POP 11CA 50 POP 11CB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_11CC: // Incoming jump from 0x0504 11CC 5B JUMPDEST 11CD 61 PUSH2 0x11d4 11D0 61 PUSH2 0x135f 11D3 56 *JUMP // Stack delta = +1 // Outputs[1] { @11CD stack[0] = 0x11d4 } // Block ends with call to 0x135f, returns to 0x11D4 label_11D4: // Incoming return from call to 0x135F at 0x11D3 // Inputs[3] // { // @11D8 storage[0x0b] // @11DD stack[-1] // @11E6 stack[-2] // } 11D4 5B JUMPDEST 11D5 60 PUSH1 0x0b 11D7 80 DUP1 11D8 54 SLOAD 11D9 60 PUSH1 0xff 11DB 19 NOT 11DC 16 AND 11DD 91 SWAP2 11DE 15 ISZERO 11DF 15 ISZERO 11E0 91 SWAP2 11E1 90 SWAP1 11E2 91 SWAP2 11E3 17 OR 11E4 90 SWAP1 11E5 55 SSTORE 11E6 56 *JUMP // Stack delta = -2 // Outputs[1] { @11E5 storage[0x0b] = !!stack[-1] | (~0xff & storage[0x0b]) } // Block ends with unconditional jump to stack[-2] label_11E7: // Incoming jump from 0x0524 // Inputs[1] { @11ED stack[-1] } 11E7 5B JUMPDEST 11E8 60 PUSH1 0x60 11EA 61 PUSH2 0x11f2 11ED 82 DUP3 11EE 61 PUSH2 0x1337 11F1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11E8 stack[0] = 0x60 // @11EA stack[1] = 0x11f2 // @11ED stack[2] = stack[-1] // } // Block ends with call to 0x1337, returns to 0x11F2 label_11F2: // Incoming return from call to 0x1337 at 0x11F1 // Inputs[1] { @11F6 stack[-1] } 11F2 5B JUMPDEST 11F3 61 PUSH2 0x1228 11F6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1228, if stack[-1] label_11F7: // Incoming jump from 0x11F6, if not stack[-1] // Inputs[3] // { // @11F9 memory[0x40:0x60] // @1222 memory[0x40:0x60] // @1227 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11F7 60 PUSH1 0x40 11F9 51 MLOAD 11FA 7F PUSH32 0xa14c4b5000000000000000000000000000000000000000000000000000000000 121B 81 DUP2 121C 52 MSTORE 121D 60 PUSH1 0x04 121F 01 ADD 1220 60 PUSH1 0x40 1222 51 MLOAD 1223 80 DUP1 1224 91 SWAP2 1225 03 SUB 1226 90 SWAP1 1227 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @121C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa14c4b5000000000000000000000000000000000000000000000000000000000 // @1227 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1228: // Incoming jump from 0x11F6, if stack[-1] 1228 5B JUMPDEST 1229 60 PUSH1 0x00 122B 61 PUSH2 0x1232 122E 61 PUSH2 0x15b8 1231 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1229 stack[0] = 0x00 // @122B stack[1] = 0x1232 // } // Block ends with unconditional jump to 0x15b8 1232 5B JUMPDEST 1233 90 SWAP1 1234 50 POP 1235 80 DUP1 1236 51 MLOAD 1237 60 PUSH1 0x00 1239 14 EQ 123A 15 ISZERO 123B 61 PUSH2 0x1253 123E 57 *JUMPI 123F 60 PUSH1 0x40 1241 51 MLOAD 1242 80 DUP1 1243 60 PUSH1 0x20 1245 01 ADD 1246 60 PUSH1 0x40 1248 52 MSTORE 1249 80 DUP1 124A 60 PUSH1 0x00 124C 81 DUP2 124D 52 MSTORE 124E 50 POP 124F 61 PUSH2 0x127e 1252 56 *JUMP 1253 5B JUMPDEST 1254 80 DUP1 1255 61 PUSH2 0x125d 1258 84 DUP5 1259 61 PUSH2 0x15c7 125C 56 *JUMP 125D 5B JUMPDEST 125E 60 PUSH1 0x40 1260 51 MLOAD 1261 60 PUSH1 0x20 1263 01 ADD 1264 61 PUSH2 0x126e 1267 92 SWAP3 1268 91 SWAP2 1269 90 SWAP1 126A 61 PUSH2 0x1c22 126D 56 *JUMP 126E 5B JUMPDEST 126F 60 PUSH1 0x40 1271 51 MLOAD 1272 60 PUSH1 0x20 1274 81 DUP2 1275 83 DUP4 1276 03 SUB 1277 03 SUB 1278 81 DUP2 1279 52 MSTORE 127A 90 SWAP1 127B 60 PUSH1 0x40 127D 52 MSTORE label_127E: // Incoming jump from 0x1400, if stack[-1] // Incoming return from call to 0x1BF6 at 0x1C9F // Incoming return from call to 0x1952 at 0x1B3D // Incoming return from call to 0x1936 at 0x197B // Incoming return from call to 0x1D66 at 0x1B8D // Incoming jump from 0x1816 // Incoming return from call to 0x1D66 at 0x1B71 // Inputs[3] // { // @127F stack[-5] // @127F stack[-1] // @1280 stack[-4] // } 127E 5B JUMPDEST 127F 93 SWAP4 1280 92 SWAP3 1281 50 POP 1282 50 POP 1283 50 POP 1284 56 *JUMP // Stack delta = -4 // Outputs[1] { @127F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1285: // Incoming jump from 0x05B9 1285 5B JUMPDEST 1286 61 PUSH2 0x128d 1289 61 PUSH2 0x135f 128C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1286 stack[0] = 0x128d } // Block ends with call to 0x135f, returns to 0x128D label_128D: // Incoming return from call to 0x135F at 0x128C // Inputs[3] // { // @1291 storage[0x0b] // @1292 stack[-1] // @12A6 stack[-2] // } 128D 5B JUMPDEST 128E 60 PUSH1 0x0b 1290 80 DUP1 1291 54 SLOAD 1292 91 SWAP2 1293 15 ISZERO 1294 15 ISZERO 1295 61 PUSH2 0x0100 1298 02 MUL 1299 61 PUSH2 0xff00 129C 19 NOT 129D 90 SWAP1 129E 92 SWAP3 129F 16 AND 12A0 91 SWAP2 12A1 90 SWAP1 12A2 91 SWAP2 12A3 17 OR 12A4 90 SWAP1 12A5 55 SSTORE 12A6 56 *JUMP // Stack delta = -2 // Outputs[1] { @12A5 storage[0x0b] = (storage[0x0b] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_12A7: // Incoming jump from 0x05D9 12A7 5B JUMPDEST 12A8 61 PUSH2 0x12af 12AB 61 PUSH2 0x135f 12AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @12A8 stack[0] = 0x12af } // Block ends with call to 0x135f, returns to 0x12AF label_12AF: // Incoming return from call to 0x135F at 0x12AE // Inputs[1] { @12B8 stack[-1] } 12AF 5B JUMPDEST 12B0 60 PUSH1 0x01 12B2 60 PUSH1 0x01 12B4 60 PUSH1 0xa0 12B6 1B SHL 12B7 03 SUB 12B8 81 DUP2 12B9 16 AND 12BA 61 PUSH2 0x132b 12BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x132b, if stack[-1] & (0x01 << 0xa0) - 0x01 label_12BE: // Incoming jump from 0x12BD, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12C0 memory[0x40:0x60] } 12BE 60 PUSH1 0x40 12C0 51 MLOAD 12C1 62 PUSH3 0x461bcd 12C5 60 PUSH1 0xe5 12C7 1B SHL 12C8 81 DUP2 12C9 52 MSTORE 12CA 60 PUSH1 0x20 12CC 60 PUSH1 0x04 12CE 82 DUP3 12CF 01 ADD 12D0 52 MSTORE 12D1 60 PUSH1 0x26 12D3 60 PUSH1 0x24 12D5 82 DUP3 12D6 01 ADD 12D7 52 MSTORE 12D8 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 12F9 60 PUSH1 0x44 12FB 82 DUP3 12FC 01 ADD 12FD 52 MSTORE 12FE 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 131F 60 PUSH1 0x64 1321 82 DUP3 1322 01 ADD 1323 52 MSTORE 1324 60 PUSH1 0x84 1326 01 ADD 1327 61 PUSH2 0x0899 132A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12D0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12D7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @12FD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1323 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1326 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_132B: // Incoming jump from 0x12BD, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @132F stack[-1] } 132B 5B JUMPDEST 132C 61 PUSH2 0x1334 132F 81 DUP2 1330 61 PUSH2 0x144d 1333 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @132C stack[0] = 0x1334 // @132F stack[1] = stack[-1] // } // Block ends with call to 0x144d, returns to 0x1334 label_1334: // Incoming jump from 0x1D77, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x144D at 0x1333 // Inputs[1] { @1336 stack[-2] } 1334 5B JUMPDEST 1335 50 POP 1336 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1337: // Incoming call from 0x0713, returns to 0x0714 // Incoming call from 0x11F1, returns to 0x11F2 // Inputs[2] // { // @133C storage[0x01] // @133D stack[-1] // } 1337 5B JUMPDEST 1338 60 PUSH1 0x00 133A 60 PUSH1 0x01 133C 54 SLOAD 133D 82 DUP3 133E 10 LT 133F 80 DUP1 1340 15 ISZERO 1341 61 PUSH2 0x0671 1344 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1338 stack[0] = 0x00 // @133E stack[1] = stack[-1] < storage[0x01] // } // Block ends with conditional jump to 0x0671, if !(stack[-1] < storage[0x01]) label_1345: // Incoming jump from 0x1344, if not !(stack[-1] < storage[0x01]) // Inputs[4] // { // @1349 stack[-3] // @1354 memory[0x00:0x40] // @1355 storage[keccak256(memory[0x00:0x40])] // @135D stack[-4] // } 1345 50 POP 1346 50 POP 1347 60 PUSH1 0x00 1349 90 SWAP1 134A 81 DUP2 134B 52 MSTORE 134C 60 PUSH1 0x05 134E 60 PUSH1 0x20 1350 52 MSTORE 1351 60 PUSH1 0x40 1353 90 SWAP1 1354 20 SHA3 1355 54 SLOAD 1356 60 PUSH1 0x01 1358 60 PUSH1 0xe0 135A 1B SHL 135B 16 AND 135C 15 ISZERO 135D 90 SWAP1 135E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @134B memory[0x00:0x20] = stack[-3] // @1350 memory[0x20:0x40] = 0x05 // @135D stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_135F: // Incoming call from 0x11D3, returns to 0x11D4 // Incoming call from 0x0CC6, returns to 0x0CC7 // Incoming call from 0x0833, returns to 0x0834 // Incoming call from 0x0CD3, returns to 0x0CD4 // Incoming call from 0x0C78, returns to 0x0C79 // Incoming call from 0x128C, returns to 0x128D // Incoming call from 0x117C, returns to 0x117D // Incoming call from 0x12AE, returns to 0x12AF // Incoming call from 0x0DEF, returns to 0x0DF0 // Inputs[2] // { // @1362 storage[0x00] // @136C msg.sender // } 135F 5B JUMPDEST 1360 60 PUSH1 0x00 1362 54 SLOAD 1363 60 PUSH1 0x01 1365 60 PUSH1 0x01 1367 60 PUSH1 0xa0 1369 1B SHL 136A 03 SUB 136B 16 AND 136C 33 CALLER 136D 14 EQ 136E 61 PUSH2 0x0c9d 1371 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c9d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_1372: // Incoming jump from 0x1371, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @1374 memory[0x40:0x60] } 1372 60 PUSH1 0x40 1374 51 MLOAD 1375 62 PUSH3 0x461bcd 1379 60 PUSH1 0xe5 137B 1B SHL 137C 81 DUP2 137D 52 MSTORE 137E 60 PUSH1 0x20 1380 60 PUSH1 0x04 1382 82 DUP3 1383 01 ADD 1384 81 DUP2 1385 90 SWAP1 1386 52 MSTORE 1387 60 PUSH1 0x24 1389 82 DUP3 138A 01 ADD 138B 52 MSTORE 138C 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 13AD 60 PUSH1 0x44 13AF 82 DUP3 13B0 01 ADD 13B1 52 MSTORE 13B2 60 PUSH1 0x64 13B4 01 ADD 13B5 61 PUSH2 0x0899 13B8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @137D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1386 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @138B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @13B1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @13B4 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0899 label_13B9: // Incoming call from 0x0A8B, returns to 0x0A8C // Incoming call from 0x08AB, returns to 0x08AC // Incoming call from 0x10AB, returns to 0x10AC // Inputs[3] // { // @13BD stack[-2] // @13BE stack[-1] // @13C1 memory[0x40:0x60] // } 13B9 5B JUMPDEST 13BA 61 PUSH2 0x08ac 13BD 82 DUP3 13BE 82 DUP3 13BF 60 PUSH1 0x40 13C1 51 MLOAD 13C2 80 DUP1 13C3 60 PUSH1 0x20 13C5 01 ADD 13C6 60 PUSH1 0x40 13C8 52 MSTORE 13C9 80 DUP1 13CA 60 PUSH1 0x00 13CC 81 DUP2 13CD 52 MSTORE 13CE 50 POP 13CF 61 PUSH2 0x1609 13D2 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @13BA stack[0] = 0x08ac // @13BD stack[1] = stack[-2] // @13BE stack[2] = stack[-1] // @13C1 stack[3] = memory[0x40:0x60] // @13C8 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @13CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1609, returns to 0x08AC label_13D3: // Incoming call from 0x0CF1, returns to 0x0671 // Incoming call from 0x0A9E, returns to 0x0A9F // Inputs[2] // { // @13D6 stack[-1] // @13D9 storage[0x01] // } 13D3 5B JUMPDEST 13D4 60 PUSH1 0x00 13D6 81 DUP2 13D7 60 PUSH1 0x01 13D9 54 SLOAD 13DA 81 DUP2 13DB 10 LT 13DC 15 ISZERO 13DD 61 PUSH2 0x141b 13E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13D4 stack[0] = 0x00 // @13D6 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x141b, if !(stack[-1] < storage[0x01]) label_13E1: // Incoming jump from 0x13E0, if not !(stack[-1] < storage[0x01]) // Inputs[3] // { // @13E3 stack[-1] // @13EE memory[0x00:0x40] // @13EF storage[keccak256(memory[0x00:0x40])] // } 13E1 60 PUSH1 0x00 13E3 81 DUP2 13E4 81 DUP2 13E5 52 MSTORE 13E6 60 PUSH1 0x05 13E8 60 PUSH1 0x20 13EA 52 MSTORE 13EB 60 PUSH1 0x40 13ED 90 SWAP1 13EE 20 SHA3 13EF 54 SLOAD 13F0 60 PUSH1 0x01 13F2 60 PUSH1 0xe0 13F4 1B SHL 13F5 81 DUP2 13F6 16 AND 13F7 61 PUSH2 0x1419 13FA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @13E5 memory[0x00:0x20] = stack[-1] // @13EA memory[0x20:0x40] = 0x05 // @13EF stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1419, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0) label_13FB: // Incoming jump from 0x1418 // Incoming jump from 0x13FA, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0) // Inputs[1] { @13FC stack[-1] } 13FB 5B JUMPDEST 13FC 80 DUP1 13FD 61 PUSH2 0x127e 1400 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x127e, if stack[-1] label_1401: // Incoming jump from 0x1400, if not stack[-1] // Inputs[3] // { // @1405 stack[-2] // @1413 memory[0x00:0x40] // @1414 storage[keccak256(memory[0x00:0x40])] // } 1401 50 POP 1402 60 PUSH1 0x00 1404 19 NOT 1405 01 ADD 1406 60 PUSH1 0x00 1408 81 DUP2 1409 81 DUP2 140A 52 MSTORE 140B 60 PUSH1 0x05 140D 60 PUSH1 0x20 140F 52 MSTORE 1410 60 PUSH1 0x40 1412 90 SWAP1 1413 20 SHA3 1414 54 SLOAD 1415 61 PUSH2 0x13fb 1418 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1405 stack[-2] = ~0x00 + stack[-2] // @140A memory[0x00:0x20] = ~0x00 + stack[-2] // @140F memory[0x20:0x40] = 0x05 // @1414 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x13fb label_1419: // Incoming jump from 0x13FA, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0) 1419 5B JUMPDEST 141A 50 POP // Stack delta = -1 // Block continues label_141B: // Incoming jump from 0x13E0, if !(stack[-1] < storage[0x01]) // Incoming jump from 0x141A // Inputs[3] // { // @141E memory[0x40:0x60] // @1447 memory[0x40:0x60] // @144C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 141B 5B JUMPDEST 141C 60 PUSH1 0x40 141E 51 MLOAD 141F 7F PUSH32 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 1440 81 DUP2 1441 52 MSTORE 1442 60 PUSH1 0x04 1444 01 ADD 1445 60 PUSH1 0x40 1447 51 MLOAD 1448 80 DUP1 1449 91 SWAP2 144A 03 SUB 144B 90 SWAP1 144C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1441 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 // @144C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_144D: // Incoming call from 0x0DF9, returns to 0x0C9D // Incoming call from 0x1333, returns to 0x1334 // Inputs[5] // { // @1451 storage[0x00] // @145A stack[-1] // @147B memory[0x40:0x60] // @14A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @14A9 stack[-2] // } 144D 5B JUMPDEST 144E 60 PUSH1 0x00 1450 80 DUP1 1451 54 SLOAD 1452 60 PUSH1 0x01 1454 60 PUSH1 0x01 1456 60 PUSH1 0xa0 1458 1B SHL 1459 03 SUB 145A 83 DUP4 145B 81 DUP2 145C 16 AND 145D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1472 19 NOT 1473 83 DUP4 1474 16 AND 1475 81 DUP2 1476 17 OR 1477 84 DUP5 1478 55 SSTORE 1479 60 PUSH1 0x40 147B 51 MLOAD 147C 91 SWAP2 147D 90 SWAP1 147E 92 SWAP3 147F 16 AND 1480 92 SWAP3 1481 83 DUP4 1482 91 SWAP2 1483 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 14A4 91 SWAP2 14A5 90 SWAP1 14A6 A3 LOG3 14A7 50 POP 14A8 50 POP 14A9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1478 storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff) // @14A6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_14AA: // Incoming call from 0x0FB2, returns to 0x0FB3 // Incoming call from 0x0F64, returns to 0x0F65 // Inputs[3] // { // @14AD stack[-2] // @14B1 stack[-3] // @14B2 stack[-1] // } 14AA 5B JUMPDEST 14AB 60 PUSH1 0x00 14AD 82 DUP3 14AE 61 PUSH2 0x14b7 14B1 85 DUP6 14B2 84 DUP5 14B3 61 PUSH2 0x1676 14B6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @14AB stack[0] = 0x00 // @14AD stack[1] = stack[-2] // @14AE stack[2] = 0x14b7 // @14B1 stack[3] = stack[-3] // @14B2 stack[4] = stack[-1] // } // Block ends with call to 0x1676, returns to 0x14B7 label_14B7: // Incoming return from call to 0x1676 at 0x14B6 // Inputs[4] // { // @14B8 stack[-1] // @14B8 stack[-2] // @14B9 stack[-7] // @14BA stack[-6] // } 14B7 5B JUMPDEST 14B8 14 EQ 14B9 94 SWAP5 14BA 93 SWAP4 14BB 50 POP 14BC 50 POP 14BD 50 POP 14BE 50 POP 14BF 56 *JUMP // Stack delta = -6 // Outputs[1] { @14B9 stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_14C0: // Incoming jump from 0x163C // Incoming jump from 0x11A8 // Inputs[6] // { // @14C3 memory[0x40:0x60] // @14D9 stack[-3] // @14E6 msg.sender // @14E8 stack[-4] // @14EA stack[-2] // @14EC stack[-1] // } 14C0 5B JUMPDEST 14C1 60 PUSH1 0x40 14C3 51 MLOAD 14C4 63 PUSH4 0x0a85bd01 14C9 60 PUSH1 0xe1 14CB 1B SHL 14CC 81 DUP2 14CD 52 MSTORE 14CE 60 PUSH1 0x00 14D0 90 SWAP1 14D1 60 PUSH1 0x01 14D3 60 PUSH1 0x01 14D5 60 PUSH1 0xa0 14D7 1B SHL 14D8 03 SUB 14D9 85 DUP6 14DA 16 AND 14DB 90 SWAP1 14DC 63 PUSH4 0x150b7a02 14E1 90 SWAP1 14E2 61 PUSH2 0x14f5 14E5 90 SWAP1 14E6 33 CALLER 14E7 90 SWAP1 14E8 89 DUP10 14E9 90 SWAP1 14EA 88 DUP9 14EB 90 SWAP1 14EC 88 DUP9 14ED 90 SWAP1 14EE 60 PUSH1 0x04 14F0 01 ADD 14F1 61 PUSH2 0x1c51 14F4 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @14CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @14D0 stack[0] = 0x00 // @14DB stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @14E1 stack[2] = 0x150b7a02 // @14E5 stack[3] = 0x14f5 // @14E7 stack[4] = msg.sender // @14E9 stack[5] = stack[-4] // @14EB stack[6] = stack[-2] // @14ED stack[7] = stack[-1] // @14F0 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c51, returns to 0x14F5 label_14F5: // Incoming return from call to 0x1C51 at 0x14F4 // Inputs[4] // { // @14FA memory[0x40:0x60] // @14FC stack[-1] // @1501 stack[-3] // @1503 address(stack[-3]).code.length // } 14F5 5B JUMPDEST 14F6 60 PUSH1 0x20 14F8 60 PUSH1 0x40 14FA 51 MLOAD 14FB 80 DUP1 14FC 83 DUP4 14FD 03 SUB 14FE 81 DUP2 14FF 60 PUSH1 0x00 1501 87 DUP8 1502 80 DUP1 1503 3B EXTCODESIZE 1504 15 ISZERO 1505 80 DUP1 1506 15 ISZERO 1507 61 PUSH2 0x150f 150A 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @14F6 stack[0] = 0x20 // @14FA stack[1] = memory[0x40:0x60] // @14FD stack[2] = stack[-1] - memory[0x40:0x60] // @14FE stack[3] = memory[0x40:0x60] // @14FF stack[4] = 0x00 // @1501 stack[5] = stack[-3] // @1504 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x150f, if !!address(stack[-3]).code.length label_150B: // Incoming jump from 0x150A, if not !!address(stack[-3]).code.length // Inputs[1] { @150E memory[0x00:0x00] } 150B 60 PUSH1 0x00 150D 80 DUP1 150E FD *REVERT // Stack delta = +0 // Outputs[1] { @150E revert(memory[0x00:0x00]); } // Block terminates label_150F: // Incoming jump from 0x150A, if !!address(stack[-3]).code.length // Inputs[10] // { // @1511 msg.gas // @1512 stack[-6] // @1512 stack[-7] // @1512 stack[-3] // @1512 stack[-4] // @1512 memory[stack[-4]:stack[-4] + stack[-5]] // @1512 stack[-5] // @1512 stack[-2] // @1512 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1513 stack[-10] // } 150F 5B JUMPDEST 1510 50 POP 1511 5A GAS 1512 F1 CALL 1513 92 SWAP3 1514 50 POP 1515 50 POP 1516 50 POP 1517 80 DUP1 1518 15 ISZERO 1519 61 PUSH2 0x153f 151C 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1512 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1513 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x153f, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_151D: // Incoming jump from 0x151C, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1521 memory[0x40:0x60] // @1524 returndata.length // } 151D 50 POP 151E 60 PUSH1 0x40 1520 80 DUP1 1521 51 MLOAD 1522 60 PUSH1 0x1f 1524 3D RETURNDATASIZE 1525 90 SWAP1 1526 81 DUP2 1527 01 ADD 1528 60 PUSH1 0x1f 152A 19 NOT 152B 16 AND 152C 82 DUP3 152D 01 ADD 152E 90 SWAP1 152F 92 SWAP3 1530 52 MSTORE 1531 61 PUSH2 0x153c 1534 91 SWAP2 1535 81 DUP2 1536 01 ADD 1537 90 SWAP1 1538 61 PUSH2 0x1b72 153B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1530 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1534 stack[-1] = 0x153c // @1537 stack[1] = memory[0x40:0x60] // @1537 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1b72 153C 5B JUMPDEST 153D 60 PUSH1 0x01 label_153F: // Incoming jump from 0x151C, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1543 stack[-1] } 153F 5B JUMPDEST 1540 61 PUSH2 0x159a 1543 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x159a, if stack[-1] label_1544: // Incoming jump from 0x1543, if not stack[-1] // Inputs[1] { @1544 returndata.length } 1544 3D RETURNDATASIZE 1545 80 DUP1 1546 80 DUP1 1547 15 ISZERO 1548 61 PUSH2 0x156d 154B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1544 stack[0] = returndata.length // @1545 stack[1] = returndata.length // } // Block ends with conditional jump to 0x156d, if !returndata.length label_154C: // Incoming jump from 0x154B, if not !returndata.length // Inputs[6] // { // @154E memory[0x40:0x60] // @154F stack[-2] // @1556 returndata.length // @155E returndata.length // @1561 returndata.length // @1568 returndata[0x00:0x00 + returndata.length] // } 154C 60 PUSH1 0x40 154E 51 MLOAD 154F 91 SWAP2 1550 50 POP 1551 60 PUSH1 0x1f 1553 19 NOT 1554 60 PUSH1 0x3f 1556 3D RETURNDATASIZE 1557 01 ADD 1558 16 AND 1559 82 DUP3 155A 01 ADD 155B 60 PUSH1 0x40 155D 52 MSTORE 155E 3D RETURNDATASIZE 155F 82 DUP3 1560 52 MSTORE 1561 3D RETURNDATASIZE 1562 60 PUSH1 0x00 1564 60 PUSH1 0x20 1566 84 DUP5 1567 01 ADD 1568 3E RETURNDATACOPY 1569 61 PUSH2 0x1572 156C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @154F stack[-2] = memory[0x40:0x60] // @155D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1560 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1568 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1572 label_156D: // Incoming jump from 0x154B, if !returndata.length // Inputs[2] // { // @1570 stack[-2] // @1575 memory[0x60:0x80] // } 156D 5B JUMPDEST 156E 60 PUSH1 0x60 1570 91 SWAP2 1571 50 POP 1572 5B JUMPDEST 1573 50 POP 1574 80 DUP1 1575 51 MLOAD 1576 61 PUSH2 0x1592 1579 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1570 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1592, if memory[0x60:0x80] label_157A: // Incoming jump from 0x1579, if not memory[0x60:0x80] // Incoming jump from 0x1579, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @157C memory[0x40:0x60] // @158C memory[0x40:0x60] // @1591 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 157A 60 PUSH1 0x40 157C 51 MLOAD 157D 63 PUSH4 0x68d2bf6b 1582 60 PUSH1 0xe1 1584 1B SHL 1585 81 DUP2 1586 52 MSTORE 1587 60 PUSH1 0x04 1589 01 ADD 158A 60 PUSH1 0x40 158C 51 MLOAD 158D 80 DUP1 158E 91 SWAP2 158F 03 SUB 1590 90 SWAP1 1591 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1586 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1591 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1592: // Incoming jump from 0x1579, if memory[0x60:0x80] // Incoming jump from 0x1579, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1593 stack[-1] // @1594 memory[stack[-1]:stack[-1] + 0x20] // @1599 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1592 5B JUMPDEST 1593 80 DUP1 1594 51 MLOAD 1595 81 DUP2 1596 60 PUSH1 0x20 1598 01 ADD 1599 FD *REVERT // Stack delta = +0 // Outputs[1] { @1599 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_159A: // Incoming jump from 0x1543, if stack[-1] // Inputs[2] // { // @15A4 stack[-1] // @15AE stack[-2] // } 159A 5B JUMPDEST 159B 60 PUSH1 0x01 159D 60 PUSH1 0x01 159F 60 PUSH1 0xe0 15A1 1B SHL 15A2 03 SUB 15A3 19 NOT 15A4 16 AND 15A5 63 PUSH4 0x0a85bd01 15AA 60 PUSH1 0xe1 15AC 1B SHL 15AD 14 EQ 15AE 90 SWAP1 15AF 50 POP // Stack delta = -1 // Outputs[1] { @15AE stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_15B0: // Incoming jump from 0x15AF // Incoming return from call to 0x18C0 at 0x1BD3 // Inputs[3] // { // @15B1 stack[-6] // @15B1 stack[-1] // @15B2 stack[-5] // } 15B0 5B JUMPDEST 15B1 94 SWAP5 15B2 93 SWAP4 15B3 50 POP 15B4 50 POP 15B5 50 POP 15B6 50 POP 15B7 56 *JUMP // Stack delta = -5 // Outputs[1] { @15B1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_15B8: // Incoming jump from 0x1231 // Inputs[1] { @15BE storage[0x0c] } 15B8 5B JUMPDEST 15B9 60 PUSH1 0x60 15BB 60 PUSH1 0x0c 15BD 80 DUP1 15BE 54 SLOAD 15BF 61 PUSH2 0x0686 15C2 90 SWAP1 15C3 61 PUSH2 0x1ce4 15C6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15B9 stack[0] = 0x60 // @15BB stack[1] = 0x0c // @15C2 stack[2] = 0x0686 // @15C2 stack[3] = storage[0x0c] // } // Block ends with call to 0x1ce4, returns to 0x0686 15C7 5B JUMPDEST 15C8 60 PUSH1 0x40 15CA 80 DUP1 15CB 51 MLOAD 15CC 60 PUSH1 0x80 15CE 01 ADD 15CF 90 SWAP1 15D0 81 DUP2 15D1 90 SWAP1 15D2 52 MSTORE 15D3 80 DUP1 15D4 82 DUP3 15D5 5B JUMPDEST 15D6 60 PUSH1 0x01 15D8 83 DUP4 15D9 03 SUB 15DA 92 SWAP3 15DB 50 POP 15DC 60 PUSH1 0x0a 15DE 81 DUP2 15DF 06 MOD 15E0 60 PUSH1 0x30 15E2 01 ADD 15E3 83 DUP4 15E4 53 MSTORE8 15E5 60 PUSH1 0x0a 15E7 90 SWAP1 15E8 04 DIV 15E9 80 DUP1 15EA 61 PUSH2 0x15f2 15ED 57 *JUMPI 15EE 61 PUSH2 0x15f7 15F1 56 *JUMP 15F2 5B JUMPDEST 15F3 61 PUSH2 0x15d5 15F6 56 *JUMP 15F7 5B JUMPDEST 15F8 50 POP 15F9 81 DUP2 15FA 90 SWAP1 15FB 03 SUB 15FC 60 PUSH1 0x1f 15FE 19 NOT 15FF 90 SWAP1 1600 91 SWAP2 1601 01 ADD 1602 90 SWAP1 1603 81 DUP2 1604 52 MSTORE 1605 91 SWAP2 1606 90 SWAP1 1607 50 POP 1608 56 *JUMP label_1609: // Incoming call from 0x13D2, returns to 0x08AC // Inputs[2] // { // @160D stack[-3] // @160E stack[-2] // } 1609 5B JUMPDEST 160A 61 PUSH2 0x1613 160D 83 DUP4 160E 83 DUP4 160F 61 PUSH2 0x16d1 1612 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @160A stack[0] = 0x1613 // @160D stack[1] = stack[-3] // @160E stack[2] = stack[-2] // } // Block ends with call to 0x16d1, returns to 0x1613 label_1613: // Incoming return from call to 0x16D1 at 0x1612 // Inputs[2] // { // @161C stack[-3] // @161E address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1613 5B JUMPDEST 1614 60 PUSH1 0x01 1616 60 PUSH1 0x01 1618 60 PUSH1 0xa0 161A 1B SHL 161B 03 SUB 161C 83 DUP4 161D 16 AND 161E 3B EXTCODESIZE 161F 15 ISZERO 1620 61 PUSH2 0x0cba 1623 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cba, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1624: // Incoming jump from 0x1623, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @1626 storage[0x01] // @1627 stack[-2] // @1630 stack[-3] // @1638 stack[-1] // } 1624 60 PUSH1 0x01 1626 54 SLOAD 1627 82 DUP3 1628 81 DUP2 1629 03 SUB 162A 5B JUMPDEST 162B 61 PUSH2 0x163d 162E 60 PUSH1 0x00 1630 86 DUP7 1631 83 DUP4 1632 80 DUP1 1633 60 PUSH1 0x01 1635 01 ADD 1636 94 SWAP5 1637 50 POP 1638 86 DUP7 1639 61 PUSH2 0x14c0 163C 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1626 stack[0] = storage[0x01] // @162B stack[2] = 0x163d // @162E stack[3] = 0x00 // @1630 stack[4] = stack[-3] // @1631 stack[5] = storage[0x01] - stack[-2] // @1636 stack[1] = 0x01 + (storage[0x01] - stack[-2]) // @1638 stack[6] = stack[-1] // } // Block ends with unconditional jump to 0x14c0 163D 5B JUMPDEST 163E 61 PUSH2 0x165a 1641 57 *JUMPI 1642 60 PUSH1 0x40 1644 51 MLOAD 1645 63 PUSH4 0x68d2bf6b 164A 60 PUSH1 0xe1 164C 1B SHL 164D 81 DUP2 164E 52 MSTORE 164F 60 PUSH1 0x04 1651 01 ADD 1652 60 PUSH1 0x40 1654 51 MLOAD 1655 80 DUP1 1656 91 SWAP2 1657 03 SUB 1658 90 SWAP1 1659 FD *REVERT 165A 5B JUMPDEST 165B 81 DUP2 165C 81 DUP2 165D 10 LT 165E 61 PUSH2 0x162a 1661 57 *JUMPI 1662 81 DUP2 1663 60 PUSH1 0x01 1665 54 SLOAD 1666 14 EQ 1667 61 PUSH2 0x166f 166A 57 *JUMPI 166B 60 PUSH1 0x00 166D 80 DUP1 166E FD *REVERT 166F 5B JUMPDEST 1670 50 POP 1671 50 POP 1672 50 POP 1673 50 POP 1674 50 POP 1675 56 *JUMP label_1676: // Incoming call from 0x14B6, returns to 0x14B7 // Inputs[3] // { // @1679 stack[-1] // @167C stack[-2] // @167D memory[stack[-2]:stack[-2] + 0x20] // } 1676 5B JUMPDEST 1677 60 PUSH1 0x00 1679 81 DUP2 167A 81 DUP2 167B 5B JUMPDEST 167C 84 DUP5 167D 51 MLOAD 167E 81 DUP2 167F 10 LT 1680 15 ISZERO 1681 61 PUSH2 0x16c9 1684 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1677 stack[0] = 0x00 // @1679 stack[1] = stack[-1] // @167A stack[2] = 0x00 // } // Block ends with conditional jump to 0x16c9, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1685: // Incoming jump from 0x1684, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1684, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @1688 stack[-2] // @1689 stack[-5] // @168A stack[-1] // @168C memory[stack[-5]:stack[-5] + 0x20] // } 1685 61 PUSH2 0x16b5 1688 82 DUP3 1689 86 DUP7 168A 83 DUP4 168B 81 DUP2 168C 51 MLOAD 168D 81 DUP2 168E 10 LT 168F 61 PUSH2 0x16a8 1692 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1685 stack[0] = 0x16b5 // @1688 stack[1] = stack[-2] // @1689 stack[2] = stack[-5] // @168A stack[3] = stack[-1] // } // Block ends with conditional call to 0x16a8, returns to 0x16B5, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1693: // Incoming jump from 0x1692, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @16A7 memory[0x00:0x24] } 1693 63 PUSH4 0x4e487b71 1698 60 PUSH1 0xe0 169A 1B SHL 169B 60 PUSH1 0x00 169D 52 MSTORE 169E 60 PUSH1 0x32 16A0 60 PUSH1 0x04 16A2 52 MSTORE 16A3 60 PUSH1 0x24 16A5 60 PUSH1 0x00 16A7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @169D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @16A2 memory[0x04:0x24] = 0x32 // @16A7 revert(memory[0x00:0x24]); // } // Block terminates label_16A8: // Incoming call from 0x1692, returns to 0x16B5, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @16AB stack[-1] // @16AF stack[-2] // @16B0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 16A8 5B JUMPDEST 16A9 60 PUSH1 0x20 16AB 02 MUL 16AC 60 PUSH1 0x20 16AE 01 ADD 16AF 01 ADD 16B0 51 MLOAD 16B1 61 PUSH2 0x17fb 16B4 56 *JUMP // Stack delta = -1 // Outputs[1] { @16B0 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x17fb label_16B5: // Incoming return from call to 0x16A8 at 0x1692 // Inputs[3] // { // @16B6 stack[-1] // @16B6 stack[-3] // @16B8 stack[-2] // } 16B5 5B JUMPDEST 16B6 91 SWAP2 16B7 50 POP 16B8 80 DUP1 16B9 61 PUSH2 0x16c1 16BC 81 DUP2 16BD 61 PUSH2 0x1d1f 16C0 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @16B6 stack[-3] = stack[-1] // @16B8 stack[-1] = stack[-2] // @16B9 stack[0] = 0x16c1 // @16BC stack[1] = stack[-2] // } // Block ends with call to 0x1d1f, returns to 0x16C1 label_16C1: // Incoming return from call to 0x1D1F at 0x16C0 // Inputs[2] // { // @16C2 stack[-1] // @16C2 stack[-3] // } 16C1 5B JUMPDEST 16C2 91 SWAP2 16C3 50 POP 16C4 50 POP 16C5 61 PUSH2 0x167b 16C8 56 *JUMP // Stack delta = -2 // Outputs[1] { @16C2 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x167b label_16C9: // Incoming jump from 0x1684, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1684, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @16CB stack[-6] // @16CB stack[-2] // @16CC stack[-5] // } 16C9 5B JUMPDEST 16CA 50 POP 16CB 93 SWAP4 16CC 92 SWAP3 16CD 50 POP 16CE 50 POP 16CF 50 POP 16D0 56 *JUMP // Stack delta = -5 // Outputs[1] { @16CB stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_16D1: // Incoming call from 0x1612, returns to 0x1613 // Inputs[2] // { // @16D4 storage[0x01] // @16D5 stack[-1] // } 16D1 5B JUMPDEST 16D2 60 PUSH1 0x01 16D4 54 SLOAD 16D5 81 DUP2 16D6 61 PUSH2 0x170b 16D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16D4 stack[0] = storage[0x01] } // Block ends with conditional jump to 0x170b, if stack[-1] label_16DA: // Incoming jump from 0x16D9, if not stack[-1] // Inputs[3] // { // @16DC memory[0x40:0x60] // @1705 memory[0x40:0x60] // @170A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16DA 60 PUSH1 0x40 16DC 51 MLOAD 16DD 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 16FE 81 DUP2 16FF 52 MSTORE 1700 60 PUSH1 0x04 1702 01 ADD 1703 60 PUSH1 0x40 1705 51 MLOAD 1706 80 DUP1 1707 91 SWAP2 1708 03 SUB 1709 90 SWAP1 170A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @170A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_170B: // Incoming jump from 0x16D9, if stack[-1] // Inputs[8] // { // @1714 stack[-3] // @1726 memory[0x00:0x40] // @1728 storage[keccak256(memory[0x00:0x40])] // @1733 stack[-2] // @1738 stack[-1] // @1741 memory[0x00:0x40] // @1749 block.timestamp // @177D memory[0x00:0x00] // } 170B 5B JUMPDEST 170C 60 PUSH1 0x01 170E 60 PUSH1 0x01 1710 60 PUSH1 0xa0 1712 1B SHL 1713 03 SUB 1714 83 DUP4 1715 16 AND 1716 60 PUSH1 0x00 1718 81 DUP2 1719 81 DUP2 171A 52 MSTORE 171B 60 PUSH1 0x06 171D 60 PUSH1 0x20 171F 90 SWAP1 1720 81 DUP2 1721 52 MSTORE 1722 60 PUSH1 0x40 1724 80 DUP1 1725 83 DUP4 1726 20 SHA3 1727 80 DUP1 1728 54 SLOAD 1729 68 PUSH9 0x010000000000000001 1733 88 DUP9 1734 02 MUL 1735 01 ADD 1736 90 SWAP1 1737 55 SSTORE 1738 84 DUP5 1739 83 DUP4 173A 52 MSTORE 173B 60 PUSH1 0x05 173D 90 SWAP1 173E 91 SWAP2 173F 52 MSTORE 1740 81 DUP2 1741 20 SHA3 1742 60 PUSH1 0x01 1744 85 DUP6 1745 14 EQ 1746 60 PUSH1 0xe1 1748 1B SHL 1749 42 TIMESTAMP 174A 60 PUSH1 0xa0 174C 1B SHL 174D 17 OR 174E 83 DUP4 174F 17 OR 1750 90 SWAP1 1751 55 SSTORE 1752 82 DUP3 1753 84 DUP5 1754 01 ADD 1755 90 SWAP1 1756 83 DUP4 1757 90 SWAP1 1758 83 DUP4 1759 90 SWAP1 175A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 177B 81 DUP2 177C 80 DUP1 177D A4 LOG4 177E 60 PUSH1 0x01 1780 83 DUP4 1781 01 ADD 1782 5B JUMPDEST 1783 81 DUP2 1784 81 DUP2 1785 14 EQ 1786 61 PUSH2 0x17ba 1789 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @1715 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @171A memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1721 memory[0x20:0x40] = 0x06 // @1737 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @173A memory[0x00:0x20] = stack[-1] // @173F memory[0x20:0x40] = 0x05 // @1751 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @1755 stack[1] = stack[-2] + stack[-1] // @177D log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @1781 stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x17ba, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_178A: // Incoming jump from 0x1789, if not stack[-1] == stack[-2] // Incoming jump from 0x1789, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[3] // { // @178A stack[-1] // @178B stack[-3] // @17B2 memory[0x00:0x00] // } 178A 80 DUP1 178B 83 DUP4 178C 60 PUSH1 0x00 178E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 17AF 60 PUSH1 0x00 17B1 80 DUP1 17B2 A4 LOG4 17B3 60 PUSH1 0x01 17B5 01 ADD 17B6 61 PUSH2 0x1782 17B9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17B2 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @17B5 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1782 label_17BA: // Incoming jump from 0x1789, if stack[-1] == stack[-2] // Incoming jump from 0x1789, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[1] { @17BC stack[-3] } 17BA 5B JUMPDEST 17BB 50 POP 17BC 81 DUP2 17BD 61 PUSH2 0x17f2 17C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17f2, if stack[-3] label_17C1: // Incoming jump from 0x17C0, if not stack[-3] // Inputs[3] // { // @17C3 memory[0x40:0x60] // @17EC memory[0x40:0x60] // @17F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 17C1 60 PUSH1 0x40 17C3 51 MLOAD 17C4 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 17E5 81 DUP2 17E6 52 MSTORE 17E7 60 PUSH1 0x04 17E9 01 ADD 17EA 60 PUSH1 0x40 17EC 51 MLOAD 17ED 80 DUP1 17EE 91 SWAP2 17EF 03 SUB 17F0 90 SWAP1 17F1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @17F1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17F2: // Incoming jump from 0x17C0, if stack[-3] // Inputs[2] // { // @17F5 stack[-1] // @17FA stack[-6] // } 17F2 5B JUMPDEST 17F3 60 PUSH1 0x01 17F5 55 SSTORE 17F6 50 POP 17F7 50 POP 17F8 50 POP 17F9 50 POP 17FA 56 *JUMP // Stack delta = -6 // Outputs[1] { @17F5 storage[0x01] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_17FB: // Incoming jump from 0x16B4 // Inputs[2] // { // @17FE stack[-1] // @17FF stack[-2] // } 17FB 5B JUMPDEST 17FC 60 PUSH1 0x00 17FE 81 DUP2 17FF 83 DUP4 1800 10 LT 1801 61 PUSH2 0x1817 1804 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17FC stack[0] = 0x00 } // Block ends with conditional jump to 0x1817, if stack[-2] < stack[-1] label_1805: // Incoming jump from 0x1804, if not stack[-2] < stack[-1] // Inputs[3] // { // @1807 stack[-2] // @180C stack[-3] // @1812 memory[0x00:0x40] // } 1805 60 PUSH1 0x00 1807 82 DUP3 1808 81 DUP2 1809 52 MSTORE 180A 60 PUSH1 0x20 180C 84 DUP5 180D 90 SWAP1 180E 52 MSTORE 180F 60 PUSH1 0x40 1811 90 SWAP1 1812 20 SHA3 1813 61 PUSH2 0x127e 1816 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1809 memory[0x00:0x20] = stack[-2] // @180E memory[0x20:0x40] = stack[-3] // @1812 stack[0] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x127e label_1817: // Incoming jump from 0x1804, if stack[-2] < stack[-1] // Inputs[4] // { // @181B stack[-3] // @1820 stack[-2] // @1824 memory[0x00:0x40] // @1825 stack[-4] // } 1817 5B JUMPDEST 1818 50 POP 1819 60 PUSH1 0x00 181B 91 SWAP2 181C 82 DUP3 181D 52 MSTORE 181E 60 PUSH1 0x20 1820 52 MSTORE 1821 60 PUSH1 0x40 1823 90 SWAP1 1824 20 SHA3 1825 90 SWAP1 1826 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @181D memory[0x00:0x20] = stack[-3] // @1820 memory[0x20:0x40] = stack[-2] // @1825 stack[-4] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-4] label_1827: // Incoming jump from 0x0CE6 // Inputs[2] // { // @1828 stack[-3] // @182A storage[stack[-3]] // } 1827 5B JUMPDEST 1828 82 DUP3 1829 80 DUP1 182A 54 SLOAD 182B 61 PUSH2 0x1833 182E 90 SWAP1 182F 61 PUSH2 0x1ce4 1832 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1828 stack[0] = stack[-3] // @182E stack[1] = 0x1833 // @182E stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1ce4, returns to 0x1833 label_1833: // Incoming return from call to 0x1CE4 at 0x1832 // Inputs[5] // { // @1834 stack[-2] // @1834 stack[-1] // @183C memory[0x00:0x20] // @1847 stack[-4] // @1848 stack[-3] // } 1833 5B JUMPDEST 1834 90 SWAP1 1835 60 PUSH1 0x00 1837 52 MSTORE 1838 60 PUSH1 0x20 183A 60 PUSH1 0x00 183C 20 SHA3 183D 90 SWAP1 183E 60 PUSH1 0x1f 1840 01 ADD 1841 60 PUSH1 0x20 1843 90 SWAP1 1844 04 DIV 1845 81 DUP2 1846 01 ADD 1847 92 SWAP3 1848 82 DUP3 1849 61 PUSH2 0x1855 184C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1837 memory[0x00:0x20] = stack[-2] // @183D stack[-2] = keccak256(memory[0x00:0x20]) // @1847 stack[-1] = stack[-4] // @1847 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1855, if stack[-3] label_184D: // Incoming jump from 0x184C, if not stack[-3] // Inputs[1] { @184F stack[-5] } 184D 60 PUSH1 0x00 184F 85 DUP6 1850 55 SSTORE 1851 61 PUSH2 0x189b 1854 56 *JUMP // Stack delta = +0 // Outputs[1] { @1850 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x189b label_1855: // Incoming jump from 0x184C, if stack[-3] // Inputs[1] { @1856 stack[-3] } 1855 5B JUMPDEST 1856 82 DUP3 1857 60 PUSH1 0x1f 1859 10 LT 185A 61 PUSH2 0x186e 185D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x186e, if 0x1f < stack[-3] label_185E: // Incoming jump from 0x185D, if not 0x1f < stack[-3] // Inputs[4] // { // @185E stack[-1] // @185F memory[stack[-1]:stack[-1] + 0x20] // @1864 stack[-3] // @1868 stack[-5] // } 185E 80 DUP1 185F 51 MLOAD 1860 60 PUSH1 0xff 1862 19 NOT 1863 16 AND 1864 83 DUP4 1865 80 DUP1 1866 01 ADD 1867 17 OR 1868 85 DUP6 1869 55 SSTORE 186A 61 PUSH2 0x189b 186D 56 *JUMP // Stack delta = +0 // Outputs[1] { @1869 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x189b label_186E: // Incoming jump from 0x185D, if 0x1f < stack[-3] // Inputs[2] // { // @186F stack[-3] // @1875 stack[-5] // } 186E 5B JUMPDEST 186F 82 DUP3 1870 80 DUP1 1871 01 ADD 1872 60 PUSH1 0x01 1874 01 ADD 1875 85 DUP6 1876 55 SSTORE 1877 82 DUP3 1878 15 ISZERO 1879 61 PUSH2 0x189b 187C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1876 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x189b, if !stack[-3] label_187D: // Incoming jump from 0x187C, if not !stack[-3] // Inputs[2] // { // @187D stack[-1] // @187D stack[-3] // } 187D 91 SWAP2 187E 82 DUP3 187F 01 ADD 1880 5B JUMPDEST 1881 82 DUP3 1882 81 DUP2 1883 11 GT 1884 15 ISZERO 1885 61 PUSH2 0x189b 1888 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @187D stack[-3] = stack[-1] // @187F stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x189b, if !(stack[-1] + stack[-3] > stack[-1]) label_1889: // Incoming jump from 0x1888, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1888, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1889 stack[-3] // @188A memory[stack[-3]:stack[-3] + 0x20] // @188B stack[-2] // @188D stack[-1] // } 1889 82 DUP3 188A 51 MLOAD 188B 82 DUP3 188C 55 SSTORE 188D 91 SWAP2 188E 60 PUSH1 0x20 1890 01 ADD 1891 91 SWAP2 1892 90 SWAP1 1893 60 PUSH1 0x01 1895 01 ADD 1896 90 SWAP1 1897 61 PUSH2 0x1880 189A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @188C storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1891 stack[-3] = 0x20 + stack[-3] // @1896 stack[-2] = 0x01 + stack[-2] // @1896 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1880 label_189B: // Incoming jump from 0x187C, if !stack[-3] // Incoming jump from 0x186D // Incoming jump from 0x1854 // Incoming jump from 0x1888, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1888, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @18A0 stack[-4] // @18A1 stack[-3] // } 189B 5B JUMPDEST 189C 50 POP 189D 61 PUSH2 0x18a7 18A0 92 SWAP3 18A1 91 SWAP2 18A2 50 POP 18A3 61 PUSH2 0x18ab 18A6 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @18A0 stack[-4] = 0x18a7 // @18A1 stack[-3] = stack[-4] // } // Block ends with call to 0x18ab, returns to 0x18A7 label_18A7: // Incoming jump from 0x18B4, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x18AB at 0x18A6 // Incoming jump from 0x18B4, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @18A9 stack[-2] // @18A9 stack[-3] // } 18A7 5B JUMPDEST 18A8 50 POP 18A9 90 SWAP1 18AA 56 *JUMP // Stack delta = -2 // Outputs[1] { @18A9 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_18AB: // Incoming call from 0x18A6, returns to 0x18A7 // Inputs[2] // { // @18AD stack[-1] // @18AE stack[-2] // } 18AB 5B JUMPDEST 18AC 5B JUMPDEST 18AD 80 DUP1 18AE 82 DUP3 18AF 11 GT 18B0 15 ISZERO 18B1 61 PUSH2 0x18a7 18B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18a7, if !(stack[-2] > stack[-1]) label_18B5: // Incoming jump from 0x18B4, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x18B4, if not !(stack[-2] > stack[-1]) // Inputs[1] { @18B7 stack[-1] } 18B5 60 PUSH1 0x00 18B7 81 DUP2 18B8 55 SSTORE 18B9 60 PUSH1 0x01 18BB 01 ADD 18BC 61 PUSH2 0x18ac 18BF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18B8 storage[stack[-1]] = 0x00 // @18BB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x18ac label_18C0: // Incoming call from 0x1A55, returns to 0x1A56 // Incoming call from 0x1BD3, returns to 0x15B0 // Inputs[1] { @18CD stack[-2] } 18C0 5B JUMPDEST 18C1 60 PUSH1 0x00 18C3 67 PUSH8 0xffffffffffffffff 18CC 80 DUP1 18CD 84 DUP5 18CE 11 GT 18CF 15 ISZERO 18D0 61 PUSH2 0x18db 18D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18C1 stack[0] = 0x00 // @18C3 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x18db, if !(stack[-2] > 0xffffffffffffffff) label_18D4: // Incoming jump from 0x18D3, if not !(stack[-2] > 0xffffffffffffffff) 18D4 61 PUSH2 0x18db 18D7 61 PUSH2 0x1d50 18DA 56 *JUMP // Stack delta = +1 // Outputs[1] { @18D4 stack[0] = 0x18db } // Block ends with unconditional jump to 0x1d50 label_18DB: // Incoming jump from 0x18D3, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @18DE memory[0x40:0x60] // @18E1 stack[-4] // @18F0 stack[-1] // } 18DB 5B JUMPDEST 18DC 60 PUSH1 0x40 18DE 51 MLOAD 18DF 60 PUSH1 0x1f 18E1 85 DUP6 18E2 01 ADD 18E3 60 PUSH1 0x1f 18E5 19 NOT 18E6 90 SWAP1 18E7 81 DUP2 18E8 16 AND 18E9 60 PUSH1 0x3f 18EB 01 ADD 18EC 16 AND 18ED 81 DUP2 18EE 01 ADD 18EF 90 SWAP1 18F0 82 DUP3 18F1 82 DUP3 18F2 11 GT 18F3 81 DUP2 18F4 83 DUP4 18F5 10 LT 18F6 17 OR 18F7 15 ISZERO 18F8 61 PUSH2 0x1903 18FB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18EF stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @18EF stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1903, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_18FC: // Incoming jump from 0x18FB, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 18FC 61 PUSH2 0x1903 18FF 61 PUSH2 0x1d50 1902 56 *JUMP // Stack delta = +1 // Outputs[1] { @18FC stack[0] = 0x1903 } // Block ends with unconditional jump to 0x1d50 label_1903: // Incoming jump from 0x18FB, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @1904 stack[-2] // @1908 stack[-1] // @1909 stack[-4] // @190B stack[-6] // @190E stack[-7] // @1910 stack[-5] // } 1903 5B JUMPDEST 1904 81 DUP2 1905 60 PUSH1 0x40 1907 52 MSTORE 1908 80 DUP1 1909 93 SWAP4 190A 50 POP 190B 85 DUP6 190C 81 DUP2 190D 52 MSTORE 190E 86 DUP7 190F 86 DUP7 1910 86 DUP7 1911 01 ADD 1912 11 GT 1913 15 ISZERO 1914 61 PUSH2 0x191c 1917 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1907 memory[0x40:0x60] = stack[-2] // @1909 stack[-4] = stack[-1] // @190D memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x191c, if !(stack[-5] + stack[-6] > stack[-7]) label_1918: // Incoming jump from 0x1917, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @191B memory[0x00:0x00] } 1918 60 PUSH1 0x00 191A 80 DUP1 191B FD *REVERT // Stack delta = +0 // Outputs[1] { @191B revert(memory[0x00:0x00]); } // Block terminates label_191C: // Incoming jump from 0x1917, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @191D stack[-6] // @191E stack[-5] // @1921 stack[-1] // @1923 msg.data[stack[-5]:stack[-5] + stack[-6]] // @1930 stack[-8] // @1930 stack[-4] // @1931 stack[-7] // } 191C 5B JUMPDEST 191D 85 DUP6 191E 85 DUP6 191F 60 PUSH1 0x20 1921 83 DUP4 1922 01 ADD 1923 37 CALLDATACOPY 1924 60 PUSH1 0x00 1926 60 PUSH1 0x20 1928 87 DUP8 1929 83 DUP4 192A 01 ADD 192B 01 ADD 192C 52 MSTORE 192D 50 POP 192E 50 POP 192F 50 POP 1930 93 SWAP4 1931 92 SWAP3 1932 50 POP 1933 50 POP 1934 50 POP 1935 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1923 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @192C memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @1930 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_1936: // Incoming call from 0x19D8, returns to 0x19D9 // Incoming call from 0x19A4, returns to 0x19A5 // Incoming call from 0x1A06, returns to 0x1A07 // Incoming call from 0x1A14, returns to 0x1A15 // Incoming call from 0x1A7C, returns to 0x1A7D // Incoming call from 0x1996, returns to 0x1997 // Incoming call from 0x197B, returns to 0x127E // Incoming call from 0x19CA, returns to 0x19CB // Incoming call from 0x1AA5, returns to 0x1AA6 // Incoming call from 0x1BF5, returns to 0x19A5 // Inputs[2] // { // @1937 stack[-1] // @1938 msg.data[stack[-1]:stack[-1] + 0x20] // } 1936 5B JUMPDEST 1937 80 DUP1 1938 35 CALLDATALOAD 1939 60 PUSH1 0x01 193B 60 PUSH1 0x01 193D 60 PUSH1 0xa0 193F 1B SHL 1940 03 SUB 1941 81 DUP2 1942 16 AND 1943 81 DUP2 1944 14 EQ 1945 61 PUSH2 0x194d 1948 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1938 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x194d, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1949: // Incoming jump from 0x1948, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @194C memory[0x00:0x00] } 1949 60 PUSH1 0x00 194B 80 DUP1 194C FD *REVERT // Stack delta = +0 // Outputs[1] { @194C revert(memory[0x00:0x00]); } // Block terminates label_194D: // Incoming jump from 0x1948, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x195D, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @194E stack[-1] // @194E stack[-3] // @194F stack[-2] // } 194D 5B JUMPDEST 194E 91 SWAP2 194F 90 SWAP1 1950 50 POP 1951 56 *JUMP // Stack delta = -2 // Outputs[1] { @194E stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1952: // Incoming call from 0x1B3D, returns to 0x127E // Incoming call from 0x1A8A, returns to 0x19A5 // Inputs[2] // { // @1953 stack[-1] // @1954 msg.data[stack[-1]:stack[-1] + 0x20] // } 1952 5B JUMPDEST 1953 80 DUP1 1954 35 CALLDATALOAD 1955 80 DUP1 1956 15 ISZERO 1957 15 ISZERO 1958 81 DUP2 1959 14 EQ 195A 61 PUSH2 0x194d 195D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1954 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x194d, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_195E: // Incoming jump from 0x195D, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1961 memory[0x00:0x00] } 195E 60 PUSH1 0x00 1960 80 DUP1 1961 FD *REVERT // Stack delta = +0 // Outputs[1] { @1961 revert(memory[0x00:0x00]); } // Block terminates label_1962: // Incoming call from 0x03F8, returns to 0x03F9 // Incoming call from 0x05D4, returns to 0x05D5 // Inputs[2] // { // @1967 stack[-1] // @1968 stack[-2] // } 1962 5B JUMPDEST 1963 60 PUSH1 0x00 1965 60 PUSH1 0x20 1967 82 DUP3 1968 84 DUP5 1969 03 SUB 196A 12 SLT 196B 15 ISZERO 196C 61 PUSH2 0x1973 196F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1963 stack[0] = 0x00 } // Block ends with conditional jump to 0x1973, if !(stack[-2] - stack[-1] i< 0x20) label_1970: // Incoming jump from 0x196F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1970 stack[-1] // @1972 memory[stack[-1]:stack[-1] + stack[-1]] // } 1970 80 DUP1 1971 81 DUP2 1972 FD *REVERT // Stack delta = +0 // Outputs[1] { @1972 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1973: // Incoming jump from 0x196F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1977 stack[-2] } 1973 5B JUMPDEST 1974 61 PUSH2 0x127e 1977 82 DUP3 1978 61 PUSH2 0x1936 197B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1974 stack[0] = 0x127e // @1977 stack[1] = stack[-2] // } // Block ends with call to 0x1936, returns to 0x127E label_197C: // Incoming jump from 0x056B // Inputs[2] // { // @1982 stack[-1] // @1983 stack[-2] // } 197C 5B JUMPDEST 197D 60 PUSH1 0x00 197F 80 DUP1 1980 60 PUSH1 0x40 1982 83 DUP4 1983 85 DUP6 1984 03 SUB 1985 12 SLT 1986 15 ISZERO 1987 61 PUSH2 0x198e 198A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @197D stack[0] = 0x00 // @197F stack[1] = 0x00 // } // Block ends with conditional jump to 0x198e, if !(stack[-2] - stack[-1] i< 0x40) label_198B: // Incoming jump from 0x198A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @198B stack[-1] // @198D memory[stack[-1]:stack[-1] + stack[-1]] // } 198B 80 DUP1 198C 81 DUP2 198D FD *REVERT // Stack delta = +0 // Outputs[1] { @198D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_198E: // Incoming jump from 0x198A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1992 stack[-3] } 198E 5B JUMPDEST 198F 61 PUSH2 0x1997 1992 83 DUP4 1993 61 PUSH2 0x1936 1996 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @198F stack[0] = 0x1997 // @1992 stack[1] = stack[-3] // } // Block ends with call to 0x1936, returns to 0x1997 label_1997: // Incoming return from call to 0x1936 at 0x1996 // Inputs[3] // { // @1998 stack[-3] // @1998 stack[-1] // @199F stack[-4] // } 1997 5B JUMPDEST 1998 91 SWAP2 1999 50 POP 199A 61 PUSH2 0x19a5 199D 60 PUSH1 0x20 199F 84 DUP5 19A0 01 ADD 19A1 61 PUSH2 0x1936 19A4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1998 stack[-3] = stack[-1] // @199A stack[-1] = 0x19a5 // @19A0 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1936, returns to 0x19A5 label_19A5: // Incoming return from call to 0x1936 at 0x19A4 // Incoming return from call to 0x1952 at 0x1A8A // Incoming return from call to 0x1936 at 0x1BF5 // Inputs[6] // { // @19A6 stack[-1] // @19A6 stack[-2] // @19A8 stack[-5] // @19AA stack[-6] // @19AA stack[-3] // @19AB stack[-4] // } 19A5 5B JUMPDEST 19A6 90 SWAP1 19A7 50 POP 19A8 92 SWAP3 19A9 50 POP 19AA 92 SWAP3 19AB 90 SWAP1 19AC 50 POP 19AD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @19A8 stack[-5] = stack[-1] // @19AA stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_19AE: // Incoming call from 0x0349, returns to 0x034A // Incoming call from 0x030B, returns to 0x030C // Inputs[2] // { // @19B6 stack[-1] // @19B7 stack[-2] // } 19AE 5B JUMPDEST 19AF 60 PUSH1 0x00 19B1 80 DUP1 19B2 60 PUSH1 0x00 19B4 60 PUSH1 0x60 19B6 84 DUP5 19B7 86 DUP7 19B8 03 SUB 19B9 12 SLT 19BA 15 ISZERO 19BB 61 PUSH2 0x19c2 19BE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @19AF stack[0] = 0x00 // @19B1 stack[1] = 0x00 // @19B2 stack[2] = 0x00 // } // Block ends with conditional jump to 0x19c2, if !(stack[-2] - stack[-1] i< 0x60) label_19BF: // Incoming jump from 0x19BE, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @19BF stack[-1] // @19C1 memory[stack[-1]:stack[-1] + stack[-1]] // } 19BF 80 DUP1 19C0 81 DUP2 19C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @19C1 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_19C2: // Incoming jump from 0x19BE, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @19C6 stack[-4] } 19C2 5B JUMPDEST 19C3 61 PUSH2 0x19cb 19C6 84 DUP5 19C7 61 PUSH2 0x1936 19CA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19C3 stack[0] = 0x19cb // @19C6 stack[1] = stack[-4] // } // Block ends with call to 0x1936, returns to 0x19CB label_19CB: // Incoming return from call to 0x1936 at 0x19CA // Inputs[3] // { // @19CC stack[-1] // @19CC stack[-4] // @19D3 stack[-5] // } 19CB 5B JUMPDEST 19CC 92 SWAP3 19CD 50 POP 19CE 61 PUSH2 0x19d9 19D1 60 PUSH1 0x20 19D3 85 DUP6 19D4 01 ADD 19D5 61 PUSH2 0x1936 19D8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @19CC stack[-4] = stack[-1] // @19CE stack[-1] = 0x19d9 // @19D4 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1936, returns to 0x19D9 label_19D9: // Incoming return from call to 0x1936 at 0x19D8 // Inputs[8] // { // @19DA stack[-3] // @19DA stack[-1] // @19DE stack[-5] // @19E0 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @19E1 stack[-2] // @19E5 stack[-6] // @19E7 stack[-4] // @19E7 stack[-7] // } 19D9 5B JUMPDEST 19DA 91 SWAP2 19DB 50 POP 19DC 60 PUSH1 0x40 19DE 84 DUP5 19DF 01 ADD 19E0 35 CALLDATALOAD 19E1 90 SWAP1 19E2 50 POP 19E3 92 SWAP3 19E4 50 POP 19E5 92 SWAP3 19E6 50 POP 19E7 92 SWAP3 19E8 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @19E3 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @19E5 stack[-6] = stack[-1] // @19E7 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_19E9: // Incoming call from 0x04DF, returns to 0x04E0 // Inputs[2] // { // @19F2 stack[-1] // @19F3 stack[-2] // } 19E9 5B JUMPDEST 19EA 60 PUSH1 0x00 19EC 80 DUP1 19ED 60 PUSH1 0x00 19EF 80 DUP1 19F0 60 PUSH1 0x80 19F2 85 DUP6 19F3 87 DUP8 19F4 03 SUB 19F5 12 SLT 19F6 15 ISZERO 19F7 61 PUSH2 0x19fe 19FA 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @19EA stack[0] = 0x00 // @19EC stack[1] = 0x00 // @19ED stack[2] = 0x00 // @19EF stack[3] = 0x00 // } // Block ends with conditional jump to 0x19fe, if !(stack[-2] - stack[-1] i< 0x80) label_19FB: // Incoming jump from 0x19FA, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @19FB stack[-1] // @19FD memory[stack[-1]:stack[-1] + stack[-1]] // } 19FB 80 DUP1 19FC 81 DUP2 19FD FD *REVERT // Stack delta = +0 // Outputs[1] { @19FD revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_19FE: // Incoming jump from 0x19FA, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1A02 stack[-5] } 19FE 5B JUMPDEST 19FF 61 PUSH2 0x1a07 1A02 85 DUP6 1A03 61 PUSH2 0x1936 1A06 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19FF stack[0] = 0x1a07 // @1A02 stack[1] = stack[-5] // } // Block ends with call to 0x1936, returns to 0x1A07 label_1A07: // Incoming return from call to 0x1936 at 0x1A06 // Inputs[3] // { // @1A08 stack[-1] // @1A08 stack[-5] // @1A0F stack[-6] // } 1A07 5B JUMPDEST 1A08 93 SWAP4 1A09 50 POP 1A0A 61 PUSH2 0x1a15 1A0D 60 PUSH1 0x20 1A0F 86 DUP7 1A10 01 ADD 1A11 61 PUSH2 0x1936 1A14 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1A08 stack[-5] = stack[-1] // @1A0A stack[-1] = 0x1a15 // @1A10 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1936, returns to 0x1A15 label_1A15: // Incoming return from call to 0x1936 at 0x1A14 // Inputs[6] // { // @1A16 stack[-1] // @1A16 stack[-4] // @1A1A stack[-6] // @1A1C msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1A1D stack[-3] // @1A23 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1A15 5B JUMPDEST 1A16 92 SWAP3 1A17 50 POP 1A18 60 PUSH1 0x40 1A1A 85 DUP6 1A1B 01 ADD 1A1C 35 CALLDATALOAD 1A1D 91 SWAP2 1A1E 50 POP 1A1F 60 PUSH1 0x60 1A21 85 DUP6 1A22 01 ADD 1A23 35 CALLDATALOAD 1A24 67 PUSH8 0xffffffffffffffff 1A2D 81 DUP2 1A2E 11 GT 1A2F 15 ISZERO 1A30 61 PUSH2 0x1a37 1A33 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1A16 stack[-4] = stack[-1] // @1A1D stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1A23 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1a37, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1A34: // Incoming jump from 0x1A33, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1A34 stack[-2] // @1A36 memory[stack[-2]:stack[-2] + stack[-2]] // } 1A34 81 DUP2 1A35 82 DUP3 1A36 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A36 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A37: // Incoming jump from 0x1A33, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1A38 stack[-6] // @1A39 stack[-1] // @1A3E stack[-7] // } 1A37 5B JUMPDEST 1A38 85 DUP6 1A39 01 ADD 1A3A 60 PUSH1 0x1f 1A3C 81 DUP2 1A3D 01 ADD 1A3E 87 DUP8 1A3F 13 SGT 1A40 61 PUSH2 0x1a47 1A43 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A39 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1a47, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1A44: // Incoming jump from 0x1A43, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @1A44 stack[-2] // @1A46 memory[stack[-2]:stack[-2] + stack[-2]] // } 1A44 81 DUP2 1A45 82 DUP3 1A46 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A46 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A47: // Incoming jump from 0x1A43, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1A4B stack[-7] // @1A4C stack[-1] // @1A4D msg.data[stack[-1]:stack[-1] + 0x20] // } 1A47 5B JUMPDEST 1A48 61 PUSH2 0x1a56 1A4B 87 DUP8 1A4C 82 DUP3 1A4D 35 CALLDATALOAD 1A4E 60 PUSH1 0x20 1A50 84 DUP5 1A51 01 ADD 1A52 61 PUSH2 0x18c0 1A55 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A48 stack[0] = 0x1a56 // @1A4B stack[1] = stack[-7] // @1A4D stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1A51 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x18c0, returns to 0x1A56 label_1A56: // Incoming return from call to 0x18C0 at 0x1A55 // Inputs[8] // { // @1A57 stack[-3] // @1A57 stack[-1] // @1A5A stack[-6] // @1A5B stack[-9] // @1A5C stack[-5] // @1A5D stack[-8] // @1A5F stack[-4] // @1A5F stack[-7] // } 1A56 5B JUMPDEST 1A57 91 SWAP2 1A58 50 POP 1A59 50 POP 1A5A 92 SWAP3 1A5B 95 SWAP6 1A5C 91 SWAP2 1A5D 94 SWAP5 1A5E 50 POP 1A5F 92 SWAP3 1A60 50 POP 1A61 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1A5A stack[-6] = stack[-1] // @1A5B stack[-9] = stack[-6] // @1A5D stack[-8] = stack[-5] // @1A5F stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1A62: // Incoming jump from 0x0480 // Inputs[2] // { // @1A68 stack[-1] // @1A69 stack[-2] // } 1A62 5B JUMPDEST 1A63 60 PUSH1 0x00 1A65 80 DUP1 1A66 60 PUSH1 0x40 1A68 83 DUP4 1A69 85 DUP6 1A6A 03 SUB 1A6B 12 SLT 1A6C 15 ISZERO 1A6D 61 PUSH2 0x1a74 1A70 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A63 stack[0] = 0x00 // @1A65 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a74, if !(stack[-2] - stack[-1] i< 0x40) label_1A71: // Incoming jump from 0x1A70, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1A71 stack[-2] // @1A73 memory[stack[-2]:stack[-2] + stack[-2]] // } 1A71 81 DUP2 1A72 82 DUP3 1A73 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A73 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A74: // Incoming jump from 0x1A70, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A78 stack[-3] } 1A74 5B JUMPDEST 1A75 61 PUSH2 0x1a7d 1A78 83 DUP4 1A79 61 PUSH2 0x1936 1A7C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A75 stack[0] = 0x1a7d // @1A78 stack[1] = stack[-3] // } // Block ends with call to 0x1936, returns to 0x1A7D label_1A7D: // Incoming return from call to 0x1936 at 0x1A7C // Inputs[3] // { // @1A7E stack[-3] // @1A7E stack[-1] // @1A85 stack[-4] // } 1A7D 5B JUMPDEST 1A7E 91 SWAP2 1A7F 50 POP 1A80 61 PUSH2 0x19a5 1A83 60 PUSH1 0x20 1A85 84 DUP5 1A86 01 ADD 1A87 61 PUSH2 0x1952 1A8A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1A7E stack[-3] = stack[-1] // @1A80 stack[-1] = 0x19a5 // @1A86 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1952, returns to 0x19A5 label_1A8B: // Incoming call from 0x0291, returns to 0x0292 // Inputs[2] // { // @1A91 stack[-1] // @1A92 stack[-2] // } 1A8B 5B JUMPDEST 1A8C 60 PUSH1 0x00 1A8E 80 DUP1 1A8F 60 PUSH1 0x40 1A91 83 DUP4 1A92 85 DUP6 1A93 03 SUB 1A94 12 SLT 1A95 15 ISZERO 1A96 61 PUSH2 0x1a9d 1A99 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A8C stack[0] = 0x00 // @1A8E stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a9d, if !(stack[-2] - stack[-1] i< 0x40) label_1A9A: // Incoming jump from 0x1A99, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1A9A stack[-2] // @1A9C memory[stack[-2]:stack[-2] + stack[-2]] // } 1A9A 81 DUP2 1A9B 82 DUP3 1A9C FD *REVERT // Stack delta = +0 // Outputs[1] { @1A9C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A9D: // Incoming jump from 0x1A99, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1AA1 stack[-3] } 1A9D 5B JUMPDEST 1A9E 61 PUSH2 0x1aa6 1AA1 83 DUP4 1AA2 61 PUSH2 0x1936 1AA5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A9E stack[0] = 0x1aa6 // @1AA1 stack[1] = stack[-3] // } // Block ends with call to 0x1936, returns to 0x1AA6 label_1AA6: // Incoming return from call to 0x1936 at 0x1AA5 // Inputs[5] // { // @1AA7 stack[-1] // @1AA7 stack[-6] // @1AAA stack[-4] // @1AAE msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1AAF stack[-5] // } 1AA6 5B JUMPDEST 1AA7 94 SWAP5 1AA8 60 PUSH1 0x20 1AAA 93 SWAP4 1AAB 90 SWAP1 1AAC 93 SWAP4 1AAD 01 ADD 1AAE 35 CALLDATALOAD 1AAF 93 SWAP4 1AB0 50 POP 1AB1 50 POP 1AB2 50 POP 1AB3 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1AA7 stack[-6] = stack[-1] // @1AAF stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1AB4: // Incoming call from 0x042D, returns to 0x042E // Inputs[2] // { // @1ABA stack[-1] // @1ABB stack[-2] // } 1AB4 5B JUMPDEST 1AB5 60 PUSH1 0x00 1AB7 80 DUP1 1AB8 60 PUSH1 0x20 1ABA 83 DUP4 1ABB 85 DUP6 1ABC 03 SUB 1ABD 12 SLT 1ABE 15 ISZERO 1ABF 61 PUSH2 0x1ac6 1AC2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AB5 stack[0] = 0x00 // @1AB7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ac6, if !(stack[-2] - stack[-1] i< 0x20) label_1AC3: // Incoming jump from 0x1AC2, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1AC3 stack[-2] // @1AC5 memory[stack[-2]:stack[-2] + stack[-2]] // } 1AC3 81 DUP2 1AC4 82 DUP3 1AC5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC5 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1AC6: // Incoming jump from 0x1AC2, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1AC7 stack[-3] // @1AC8 msg.data[stack[-3]:stack[-3] + 0x20] // } 1AC6 5B JUMPDEST 1AC7 82 DUP3 1AC8 35 CALLDATALOAD 1AC9 67 PUSH8 0xffffffffffffffff 1AD2 80 DUP1 1AD3 82 DUP3 1AD4 11 GT 1AD5 15 ISZERO 1AD6 61 PUSH2 0x1add 1AD9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AC8 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1AC9 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1add, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1ADA: // Incoming jump from 0x1AD9, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1ADA stack[-4] // @1ADC memory[stack[-4]:stack[-4] + stack[-4]] // } 1ADA 83 DUP4 1ADB 84 DUP5 1ADC FD *REVERT // Stack delta = +0 // Outputs[1] { @1ADC revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1ADD: // Incoming jump from 0x1AD9, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1ADE stack[-2] // @1ADF stack[-5] // @1AE3 stack[-6] // } 1ADD 5B JUMPDEST 1ADE 81 DUP2 1ADF 85 DUP6 1AE0 01 ADD 1AE1 91 SWAP2 1AE2 50 POP 1AE3 85 DUP6 1AE4 60 PUSH1 0x1f 1AE6 83 DUP4 1AE7 01 ADD 1AE8 12 SLT 1AE9 61 PUSH2 0x1af0 1AEC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1AE1 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1af0, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1AED: // Incoming jump from 0x1AEC, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1AED stack[-4] // @1AEF memory[stack[-4]:stack[-4] + stack[-4]] // } 1AED 83 DUP4 1AEE 84 DUP5 1AEF FD *REVERT // Stack delta = +0 // Outputs[1] { @1AEF revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1AF0: // Incoming jump from 0x1AEC, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1AF1 stack[-2] // @1AF2 msg.data[stack[-2]:stack[-2] + 0x20] // @1AF3 stack[-1] // } 1AF0 5B JUMPDEST 1AF1 81 DUP2 1AF2 35 CALLDATALOAD 1AF3 81 DUP2 1AF4 81 DUP2 1AF5 11 GT 1AF6 15 ISZERO 1AF7 61 PUSH2 0x1afe 1AFA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AF2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1afe, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1AFB: // Incoming jump from 0x1AFA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @1AFB stack[-5] // @1AFD memory[stack[-5]:stack[-5] + stack[-5]] // } 1AFB 84 DUP5 1AFC 85 DUP6 1AFD FD *REVERT // Stack delta = +0 // Outputs[1] { @1AFD revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_1AFE: // Incoming jump from 0x1AFA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1AFF stack[-7] // @1B02 stack[-1] // @1B06 stack[-3] // } 1AFE 5B JUMPDEST 1AFF 86 DUP7 1B00 60 PUSH1 0x20 1B02 82 DUP3 1B03 60 PUSH1 0x05 1B05 1B SHL 1B06 85 DUP6 1B07 01 ADD 1B08 01 ADD 1B09 11 GT 1B0A 15 ISZERO 1B0B 61 PUSH2 0x1b12 1B0E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b12, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) label_1B0F: // Incoming jump from 0x1B0E, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[2] // { // @1B0F stack[-5] // @1B11 memory[stack[-5]:stack[-5] + stack[-5]] // } 1B0F 84 DUP5 1B10 85 DUP6 1B11 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B11 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_1B12: // Incoming jump from 0x1B0E, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[6] // { // @1B15 stack[-3] // @1B16 stack[-1] // @1B19 stack[-8] // @1B1B stack[-7] // @1B1D stack[-2] // @1B1E stack[-6] // } 1B12 5B JUMPDEST 1B13 60 PUSH1 0x20 1B15 92 SWAP3 1B16 90 SWAP1 1B17 92 SWAP3 1B18 01 ADD 1B19 96 SWAP7 1B1A 91 SWAP2 1B1B 95 SWAP6 1B1C 50 POP 1B1D 90 SWAP1 1B1E 93 SWAP4 1B1F 50 POP 1B20 50 POP 1B21 50 POP 1B22 50 POP 1B23 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1B19 stack[-8] = 0x20 + stack[-3] // @1B1B stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_1B24: // Incoming call from 0x04FF, returns to 0x0500 // Incoming call from 0x05B4, returns to 0x05B5 // Inputs[2] // { // @1B29 stack[-1] // @1B2A stack[-2] // } 1B24 5B JUMPDEST 1B25 60 PUSH1 0x00 1B27 60 PUSH1 0x20 1B29 82 DUP3 1B2A 84 DUP5 1B2B 03 SUB 1B2C 12 SLT 1B2D 15 ISZERO 1B2E 61 PUSH2 0x1b35 1B31 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B25 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b35, if !(stack[-2] - stack[-1] i< 0x20) label_1B32: // Incoming jump from 0x1B31, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B32 stack[-1] // @1B34 memory[stack[-1]:stack[-1] + stack[-1]] // } 1B32 80 DUP1 1B33 81 DUP2 1B34 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B34 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B35: // Incoming jump from 0x1B31, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B39 stack[-2] } 1B35 5B JUMPDEST 1B36 61 PUSH2 0x127e 1B39 82 DUP3 1B3A 61 PUSH2 0x1952 1B3D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B36 stack[0] = 0x127e // @1B39 stack[1] = stack[-2] // } // Block ends with call to 0x1952, returns to 0x127E label_1B3E: // Incoming call from 0x0369, returns to 0x036A // Incoming call from 0x051F, returns to 0x0520 // Incoming call from 0x03C3, returns to 0x03C4 // Incoming call from 0x0259, returns to 0x025A // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[2] // { // @1B43 stack[-1] // @1B44 stack[-2] // } 1B3E 5B JUMPDEST 1B3F 60 PUSH1 0x00 1B41 60 PUSH1 0x20 1B43 82 DUP3 1B44 84 DUP5 1B45 03 SUB 1B46 12 SLT 1B47 15 ISZERO 1B48 61 PUSH2 0x1b4f 1B4B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B3F stack[0] = 0x00 } // Block ends with conditional jump to 0x1b4f, if !(stack[-2] - stack[-1] i< 0x20) label_1B4C: // Incoming jump from 0x1B4B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B4C stack[-1] // @1B4E memory[stack[-1]:stack[-1] + stack[-1]] // } 1B4C 80 DUP1 1B4D 81 DUP2 1B4E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B4E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B4F: // Incoming jump from 0x1B4B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1B51 msg.data[stack[-2]:stack[-2] + 0x20] // @1B51 stack[-2] // @1B52 stack[-4] // @1B53 stack[-3] // } 1B4F 5B JUMPDEST 1B50 50 POP 1B51 35 CALLDATALOAD 1B52 91 SWAP2 1B53 90 SWAP1 1B54 50 POP 1B55 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B52 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1B56: // Incoming call from 0x0202, returns to 0x0203 // Inputs[2] // { // @1B5B stack[-1] // @1B5C stack[-2] // } 1B56 5B JUMPDEST 1B57 60 PUSH1 0x00 1B59 60 PUSH1 0x20 1B5B 82 DUP3 1B5C 84 DUP5 1B5D 03 SUB 1B5E 12 SLT 1B5F 15 ISZERO 1B60 61 PUSH2 0x1b67 1B63 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B57 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b67, if !(stack[-2] - stack[-1] i< 0x20) label_1B64: // Incoming jump from 0x1B63, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B64 stack[-1] // @1B66 memory[stack[-1]:stack[-1] + stack[-1]] // } 1B64 80 DUP1 1B65 81 DUP2 1B66 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B66 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B67: // Incoming jump from 0x1B63, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B68 stack[-2] // @1B69 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B67 5B JUMPDEST 1B68 81 DUP2 1B69 35 CALLDATALOAD 1B6A 61 PUSH2 0x127e 1B6D 81 DUP2 1B6E 61 PUSH2 0x1d66 1B71 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B69 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B6A stack[1] = 0x127e // @1B6D stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1d66, returns to 0x127E label_1B72: // Incoming jump from 0x153B // Inputs[2] // { // @1B77 stack[-1] // @1B78 stack[-2] // } 1B72 5B JUMPDEST 1B73 60 PUSH1 0x00 1B75 60 PUSH1 0x20 1B77 82 DUP3 1B78 84 DUP5 1B79 03 SUB 1B7A 12 SLT 1B7B 15 ISZERO 1B7C 61 PUSH2 0x1b83 1B7F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B73 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b83, if !(stack[-2] - stack[-1] i< 0x20) label_1B80: // Incoming jump from 0x1B7F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B80 stack[-1] // @1B82 memory[stack[-1]:stack[-1] + stack[-1]] // } 1B80 80 DUP1 1B81 81 DUP2 1B82 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B82 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B83: // Incoming jump from 0x1B7F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B84 stack[-2] // @1B85 memory[stack[-2]:stack[-2] + 0x20] // } 1B83 5B JUMPDEST 1B84 81 DUP2 1B85 51 MLOAD 1B86 61 PUSH2 0x127e 1B89 81 DUP2 1B8A 61 PUSH2 0x1d66 1B8D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B85 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1B86 stack[1] = 0x127e // @1B89 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1d66, returns to 0x127E label_1B8E: // Incoming call from 0x0389, returns to 0x038A // Inputs[2] // { // @1B93 stack[-1] // @1B94 stack[-2] // } 1B8E 5B JUMPDEST 1B8F 60 PUSH1 0x00 1B91 60 PUSH1 0x20 1B93 82 DUP3 1B94 84 DUP5 1B95 03 SUB 1B96 12 SLT 1B97 15 ISZERO 1B98 61 PUSH2 0x1b9f 1B9B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B8F stack[0] = 0x00 } // Block ends with conditional jump to 0x1b9f, if !(stack[-2] - stack[-1] i< 0x20) label_1B9C: // Incoming jump from 0x1B9B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B9C stack[-1] // @1B9E memory[stack[-1]:stack[-1] + stack[-1]] // } 1B9C 80 DUP1 1B9D 81 DUP2 1B9E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B9E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B9F: // Incoming jump from 0x1B9B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1BA0 stack[-2] // @1BA1 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B9F 5B JUMPDEST 1BA0 81 DUP2 1BA1 35 CALLDATALOAD 1BA2 67 PUSH8 0xffffffffffffffff 1BAB 81 DUP2 1BAC 11 GT 1BAD 15 ISZERO 1BAE 61 PUSH2 0x1bb5 1BB1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BA1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1bb5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1BB2: // Incoming jump from 0x1BB1, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1BB2 stack[-2] // @1BB4 memory[stack[-2]:stack[-2] + stack[-2]] // } 1BB2 81 DUP2 1BB3 82 DUP3 1BB4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BB4 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1BB5: // Incoming jump from 0x1BB1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1BB6 stack[-3] // @1BB7 stack[-1] // @1BBC stack[-4] // } 1BB5 5B JUMPDEST 1BB6 82 DUP3 1BB7 01 ADD 1BB8 60 PUSH1 0x1f 1BBA 81 DUP2 1BBB 01 ADD 1BBC 84 DUP5 1BBD 13 SGT 1BBE 61 PUSH2 0x1bc5 1BC1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BB7 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1bc5, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1BC2: // Incoming jump from 0x1BC1, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @1BC2 stack[-2] // @1BC4 memory[stack[-2]:stack[-2] + stack[-2]] // } 1BC2 81 DUP2 1BC3 82 DUP3 1BC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BC4 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1BC5: // Incoming jump from 0x1BC1, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1BC9 stack[-4] // @1BCA stack[-1] // @1BCB msg.data[stack[-1]:stack[-1] + 0x20] // } 1BC5 5B JUMPDEST 1BC6 61 PUSH2 0x15b0 1BC9 84 DUP5 1BCA 82 DUP3 1BCB 35 CALLDATALOAD 1BCC 60 PUSH1 0x20 1BCE 84 DUP5 1BCF 01 ADD 1BD0 61 PUSH2 0x18c0 1BD3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BC6 stack[0] = 0x15b0 // @1BC9 stack[1] = stack[-4] // @1BCB stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1BCF stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x18c0, returns to 0x15B0 label_1BD4: // Incoming call from 0x02B3, returns to 0x02B4 // Inputs[2] // { // @1BDA stack[-1] // @1BDB stack[-2] // } 1BD4 5B JUMPDEST 1BD5 60 PUSH1 0x00 1BD7 80 DUP1 1BD8 60 PUSH1 0x40 1BDA 83 DUP4 1BDB 85 DUP6 1BDC 03 SUB 1BDD 12 SLT 1BDE 15 ISZERO 1BDF 61 PUSH2 0x1be6 1BE2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BD5 stack[0] = 0x00 // @1BD7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1be6, if !(stack[-2] - stack[-1] i< 0x40) label_1BE3: // Incoming jump from 0x1BE2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1BE3 stack[-2] // @1BE5 memory[stack[-2]:stack[-2] + stack[-2]] // } 1BE3 81 DUP2 1BE4 82 DUP3 1BE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BE5 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1BE6: // Incoming jump from 0x1BE2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @1BE7 stack[-3] // @1BE8 msg.data[stack[-3]:stack[-3] + 0x20] // @1BE9 stack[-2] // } 1BE6 5B JUMPDEST 1BE7 82 DUP3 1BE8 35 CALLDATALOAD 1BE9 91 SWAP2 1BEA 50 POP 1BEB 61 PUSH2 0x19a5 1BEE 60 PUSH1 0x20 1BF0 84 DUP5 1BF1 01 ADD 1BF2 61 PUSH2 0x1936 1BF5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1BE9 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @1BEB stack[0] = 0x19a5 // @1BF1 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x1936, returns to 0x19A5 label_1BF6: // Incoming call from 0x1C9F, returns to 0x127E // Incoming call from 0x1C82, returns to 0x1C83 // Inputs[3] // { // @1BF9 stack[-1] // @1BFA memory[stack[-1]:stack[-1] + 0x20] // @1BFC stack[-2] // } 1BF6 5B JUMPDEST 1BF7 60 PUSH1 0x00 1BF9 81 DUP2 1BFA 51 MLOAD 1BFB 80 DUP1 1BFC 84 DUP5 1BFD 52 MSTORE 1BFE 61 PUSH2 0x1c0e 1C01 81 DUP2 1C02 60 PUSH1 0x20 1C04 86 DUP7 1C05 01 ADD 1C06 60 PUSH1 0x20 1C08 86 DUP7 1C09 01 ADD 1C0A 61 PUSH2 0x1cb8 1C0D 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1BF7 stack[0] = 0x00 // @1BFA stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1BFD memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1BFE stack[2] = 0x1c0e // @1C01 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1C05 stack[4] = stack[-2] + 0x20 // @1C09 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1cb8, returns to 0x1C0E label_1C0E: // Incoming return from call to 0x1CB8 at 0x1C0D // Inputs[4] // { // @1C11 stack[-1] // @1C16 stack[-4] // @1C17 stack[-2] // @1C1D stack[-5] // } 1C0E 5B JUMPDEST 1C0F 60 PUSH1 0x1f 1C11 01 ADD 1C12 60 PUSH1 0x1f 1C14 19 NOT 1C15 16 AND 1C16 92 SWAP3 1C17 90 SWAP1 1C18 92 SWAP3 1C19 01 ADD 1C1A 60 PUSH1 0x20 1C1C 01 ADD 1C1D 92 SWAP3 1C1E 91 SWAP2 1C1F 50 POP 1C20 50 POP 1C21 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C1D stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 1C22 5B JUMPDEST 1C23 60 PUSH1 0x00 1C25 83 DUP4 1C26 51 MLOAD 1C27 61 PUSH2 0x1c34 1C2A 81 DUP2 1C2B 84 DUP5 1C2C 60 PUSH1 0x20 1C2E 88 DUP9 1C2F 01 ADD 1C30 61 PUSH2 0x1cb8 1C33 56 *JUMP 1C34 5B JUMPDEST 1C35 83 DUP4 1C36 51 MLOAD 1C37 90 SWAP1 1C38 83 DUP4 1C39 01 ADD 1C3A 90 SWAP1 1C3B 61 PUSH2 0x1c48 1C3E 81 DUP2 1C3F 83 DUP4 1C40 60 PUSH1 0x20 1C42 88 DUP9 1C43 01 ADD 1C44 61 PUSH2 0x1cb8 1C47 56 *JUMP 1C48 5B JUMPDEST 1C49 01 ADD 1C4A 94 SWAP5 1C4B 93 SWAP4 1C4C 50 POP 1C4D 50 POP 1C4E 50 POP 1C4F 50 POP 1C50 56 *JUMP label_1C51: // Incoming call from 0x14F4, returns to 0x14F5 // Inputs[5] // { // @1C5D stack[-5] // @1C5F stack[-1] // @1C62 stack[-4] // @1C6A stack[-3] // @1C7E stack[-2] // } 1C51 5B JUMPDEST 1C52 60 PUSH1 0x00 1C54 60 PUSH1 0x01 1C56 60 PUSH1 0x01 1C58 60 PUSH1 0xa0 1C5A 1B SHL 1C5B 03 SUB 1C5C 80 DUP1 1C5D 87 DUP8 1C5E 16 AND 1C5F 83 DUP4 1C60 52 MSTORE 1C61 80 DUP1 1C62 86 DUP7 1C63 16 AND 1C64 60 PUSH1 0x20 1C66 84 DUP5 1C67 01 ADD 1C68 52 MSTORE 1C69 50 POP 1C6A 83 DUP4 1C6B 60 PUSH1 0x40 1C6D 83 DUP4 1C6E 01 ADD 1C6F 52 MSTORE 1C70 60 PUSH1 0x80 1C72 60 PUSH1 0x60 1C74 83 DUP4 1C75 01 ADD 1C76 52 MSTORE 1C77 61 PUSH2 0x1c83 1C7A 60 PUSH1 0x80 1C7C 83 DUP4 1C7D 01 ADD 1C7E 84 DUP5 1C7F 61 PUSH2 0x1bf6 1C82 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1C52 stack[0] = 0x00 // @1C60 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1C68 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1C6F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1C76 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1C77 stack[1] = 0x1c83 // @1C7D stack[2] = stack[-1] + 0x80 // @1C7E stack[3] = stack[-2] // } // Block ends with call to 0x1bf6, returns to 0x1C83 label_1C83: // Incoming return from call to 0x1BF6 at 0x1C82 // Inputs[3] // { // @1C84 stack[-1] // @1C84 stack[-8] // @1C85 stack[-7] // } 1C83 5B JUMPDEST 1C84 96 SWAP7 1C85 95 SWAP6 1C86 50 POP 1C87 50 POP 1C88 50 POP 1C89 50 POP 1C8A 50 POP 1C8B 50 POP 1C8C 56 *JUMP // Stack delta = -7 // Outputs[1] { @1C84 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1C8D: // Incoming jump from 0x023E // Inputs[2] // { // @1C90 stack[-1] // @1C9B stack[-2] // } 1C8D 5B JUMPDEST 1C8E 60 PUSH1 0x20 1C90 81 DUP2 1C91 52 MSTORE 1C92 60 PUSH1 0x00 1C94 61 PUSH2 0x127e 1C97 60 PUSH1 0x20 1C99 83 DUP4 1C9A 01 ADD 1C9B 84 DUP5 1C9C 61 PUSH2 0x1bf6 1C9F 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1C91 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1C92 stack[0] = 0x00 // @1C94 stack[1] = 0x127e // @1C9A stack[2] = stack[-1] + 0x20 // @1C9B stack[3] = stack[-2] // } // Block ends with call to 0x1bf6, returns to 0x127E label_1CA0: // Incoming call from 0x09B1, returns to 0x09B2 // Incoming call from 0x084E, returns to 0x084F // Incoming call from 0x102E, returns to 0x102F // Incoming call from 0x109B, returns to 0x109C // Incoming call from 0x0A7B, returns to 0x0A7C // Inputs[2] // { // @1CA3 stack[-2] // @1CA5 stack[-1] // } 1CA0 5B JUMPDEST 1CA1 60 PUSH1 0x00 1CA3 82 DUP3 1CA4 19 NOT 1CA5 82 DUP3 1CA6 11 GT 1CA7 15 ISZERO 1CA8 61 PUSH2 0x1cb3 1CAB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CA1 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cb3, if !(stack[-1] > ~stack[-2]) label_1CAC: // Incoming jump from 0x1CAB, if not !(stack[-1] > ~stack[-2]) 1CAC 61 PUSH2 0x1cb3 1CAF 61 PUSH2 0x1d3a 1CB2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CAC stack[0] = 0x1cb3 } // Block ends with unconditional jump to 0x1d3a label_1CB3: // Incoming jump from 0x1CAB, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1CB5 stack[-3] // @1CB5 stack[-2] // @1CB6 stack[-4] // } 1CB3 5B JUMPDEST 1CB4 50 POP 1CB5 01 ADD 1CB6 90 SWAP1 1CB7 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CB6 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1CB8: // Incoming call from 0x1C0D, returns to 0x1C0E // Inputs[1] { @1CBC stack[-3] } 1CB8 5B JUMPDEST 1CB9 60 PUSH1 0x00 1CBB 5B JUMPDEST 1CBC 83 DUP4 1CBD 81 DUP2 1CBE 10 LT 1CBF 15 ISZERO 1CC0 61 PUSH2 0x1cd3 1CC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CB9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cd3, if !(0x00 < stack[-3]) label_1CC4: // Incoming jump from 0x1CC3, if not !(0x00 < stack[-3]) // Incoming jump from 0x1CC3, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1CC4 stack[-2] // @1CC5 stack[-1] // @1CC7 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1CC8 stack[-3] // } 1CC4 81 DUP2 1CC5 81 DUP2 1CC6 01 ADD 1CC7 51 MLOAD 1CC8 83 DUP4 1CC9 82 DUP3 1CCA 01 ADD 1CCB 52 MSTORE 1CCC 60 PUSH1 0x20 1CCE 01 ADD 1CCF 61 PUSH2 0x1cbb 1CD2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1CCB memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1CCE stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1cbb label_1CD3: // Incoming jump from 0x1CC3, if !(0x00 < stack[-3]) // Incoming jump from 0x1CC3, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1CD4 stack[-4] // @1CD5 stack[-1] // } 1CD3 5B JUMPDEST 1CD4 83 DUP4 1CD5 81 DUP2 1CD6 11 GT 1CD7 15 ISZERO 1CD8 61 PUSH2 0x11c6 1CDB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c6, if !(stack[-1] > stack[-4]) label_1CDC: // Incoming jump from 0x1CDB, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1CE0 stack[-4] // @1CE1 stack[-3] // @1CE3 stack[-5] // } 1CDC 50 POP 1CDD 50 POP 1CDE 60 PUSH1 0x00 1CE0 91 SWAP2 1CE1 01 ADD 1CE2 52 MSTORE 1CE3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1CE2 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1CE4: // Incoming call from 0x15C6, returns to 0x0686 // Incoming call from 0x0685, returns to 0x0686 // Incoming call from 0x0D2A, returns to 0x0D2B // Incoming call from 0x06B1, returns to 0x06B2 // Incoming call from 0x1832, returns to 0x1833 // Incoming call from 0x10C5, returns to 0x0686 // Incoming call from 0x0CFE, returns to 0x0CFF // Inputs[1] { @1CE7 stack[-1] } 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x01 1CE7 81 DUP2 1CE8 81 DUP2 1CE9 1C SHR 1CEA 90 SWAP1 1CEB 82 DUP3 1CEC 16 AND 1CED 80 DUP1 1CEE 61 PUSH2 0x1cf8 1CF1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CEA stack[0] = stack[-1] >> 0x01 // @1CEC stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1cf8, if stack[-1] & 0x01 label_1CF2: // Incoming jump from 0x1CF1, if not stack[-1] & 0x01 // Inputs[2] // { // @1CF4 stack[-2] // @1CFD stack[-1] // } 1CF2 60 PUSH1 0x7f 1CF4 82 DUP3 1CF5 16 AND 1CF6 91 SWAP2 1CF7 50 POP 1CF8 5B JUMPDEST 1CF9 60 PUSH1 0x20 1CFB 82 DUP3 1CFC 10 LT 1CFD 81 DUP2 1CFE 14 EQ 1CFF 15 ISZERO 1D00 61 PUSH2 0x1d19 1D03 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CF6 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1d19, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1D04: // Incoming jump from 0x1D03, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1D03, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @1D18 memory[0x00:0x24] } 1D04 63 PUSH4 0x4e487b71 1D09 60 PUSH1 0xe0 1D0B 1B SHL 1D0C 60 PUSH1 0x00 1D0E 52 MSTORE 1D0F 60 PUSH1 0x22 1D11 60 PUSH1 0x04 1D13 52 MSTORE 1D14 60 PUSH1 0x24 1D16 60 PUSH1 0x00 1D18 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1D0E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1D13 memory[0x04:0x24] = 0x22 // @1D18 revert(memory[0x00:0x24]); // } // Block terminates label_1D19: // Incoming jump from 0x1D03, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1D03, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1D1B stack[-4] // @1D1B stack[-2] // @1D1C stack[-3] // } 1D19 5B JUMPDEST 1D1A 50 POP 1D1B 91 SWAP2 1D1C 90 SWAP1 1D1D 50 POP 1D1E 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D1B stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1D1F: // Incoming call from 0x16C0, returns to 0x16C1 // Inputs[1] { @1D25 stack[-1] } 1D1F 5B JUMPDEST 1D20 60 PUSH1 0x00 1D22 60 PUSH1 0x00 1D24 19 NOT 1D25 82 DUP3 1D26 14 EQ 1D27 15 ISZERO 1D28 61 PUSH2 0x1d33 1D2B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D20 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d33, if !(stack[-1] == ~0x00) label_1D2C: // Incoming jump from 0x1D2B, if not !(stack[-1] == ~0x00) 1D2C 61 PUSH2 0x1d33 1D2F 61 PUSH2 0x1d3a 1D32 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D2C stack[0] = 0x1d33 } // Block ends with unconditional jump to 0x1d3a label_1D33: // Incoming jump from 0x1D2B, if !(stack[-1] == ~0x00) // Inputs[2] // { // @1D37 stack[-2] // @1D38 stack[-3] // } 1D33 5B JUMPDEST 1D34 50 POP 1D35 60 PUSH1 0x01 1D37 01 ADD 1D38 90 SWAP1 1D39 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D38 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1D3A: // Incoming jump from 0x1CB2 // Incoming jump from 0x1D32 // Inputs[1] { @1D4F memory[0x00:0x24] } 1D3A 5B JUMPDEST 1D3B 63 PUSH4 0x4e487b71 1D40 60 PUSH1 0xe0 1D42 1B SHL 1D43 60 PUSH1 0x00 1D45 52 MSTORE 1D46 60 PUSH1 0x11 1D48 60 PUSH1 0x04 1D4A 52 MSTORE 1D4B 60 PUSH1 0x24 1D4D 60 PUSH1 0x00 1D4F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1D45 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1D4A memory[0x04:0x24] = 0x11 // @1D4F revert(memory[0x00:0x24]); // } // Block terminates label_1D50: // Incoming jump from 0x1902 // Incoming jump from 0x18DA // Inputs[1] { @1D65 memory[0x00:0x24] } 1D50 5B JUMPDEST 1D51 63 PUSH4 0x4e487b71 1D56 60 PUSH1 0xe0 1D58 1B SHL 1D59 60 PUSH1 0x00 1D5B 52 MSTORE 1D5C 60 PUSH1 0x41 1D5E 60 PUSH1 0x04 1D60 52 MSTORE 1D61 60 PUSH1 0x24 1D63 60 PUSH1 0x00 1D65 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1D5B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1D60 memory[0x04:0x24] = 0x41 // @1D65 revert(memory[0x00:0x24]); // } // Block terminates label_1D66: // Incoming call from 0x1B8D, returns to 0x127E // Incoming call from 0x1B71, returns to 0x127E // Inputs[1] { @1D70 stack[-1] } 1D66 5B JUMPDEST 1D67 60 PUSH1 0x01 1D69 60 PUSH1 0x01 1D6B 60 PUSH1 0xe0 1D6D 1B SHL 1D6E 03 SUB 1D6F 19 NOT 1D70 81 DUP2 1D71 16 AND 1D72 81 DUP2 1D73 14 EQ 1D74 61 PUSH2 0x1334 1D77 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1334, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1D78: // Incoming jump from 0x1D77, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1D7B memory[0x00:0x00] } 1D78 60 PUSH1 0x00 1D7A 80 DUP1 1D7B FD *REVERT // Stack delta = +0 // Outputs[1] { @1D7B revert(memory[0x00:0x00]); } // Block terminates 1D7C FE *ASSERT 1D7D A2 LOG2 1D7E 64 PUSH5 0x6970667358 1D84 22 22 1D85 12 SLT 1D86 20 SHA3 1D87 C1 C1 1D88 7D PUSH30 0x0e6af2f77ca39f54e38d24664ea8c4778e6f32140521088bd47830b498cd 1DA7 64 PUSH5 0x736f6c6343 1DAD 00 *STOP 1DAE 08 ADDMOD 1DAF 04 DIV 1DB0 00 *STOP 1DB1 33 CALLER