Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x01cf 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cf, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x0104 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0104, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xc87b56dd 0031 11 GT 0032 61 PUSH2 0x00a2 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xc87b56dd > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xc87b56dd > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe985e9c5 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe985e9c5 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x03a1 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf2fde38b 0052 14 EQ 0053 61 PUSH2 0x03b7 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b7, if 0xf2fde38b == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf46eccc4 005D 14 EQ 005E 61 PUSH2 0x03ca 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0xf46eccc4 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf46eccc4 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf7ea7a3d 0068 14 EQ 0069 61 PUSH2 0x03ed 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ed, if 0xf7ea7a3d == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf7ea7a3d == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xc87b56dd 0078 14 EQ 0079 61 PUSH2 0x0366 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0366, if 0xc87b56dd == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xc87b56dd == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xce4098c9 0083 14 EQ 0084 61 PUSH2 0x0379 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0379, if 0xce4098c9 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xce4098c9 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xd547cfb7 008E 14 EQ 008F 61 PUSH2 0x0386 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if 0xd547cfb7 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xd547cfb7 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xd6efa3b7 0099 14 EQ 009A 61 PUSH2 0x038e 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038e, if 0xd6efa3b7 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xd6efa3b7 == stack[-1] // Inputs[1] { @00A1 memory[0x00:0x00] } 009E 60 PUSH1 0x00 00A0 80 DUP1 00A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A1 revert(memory[0x00:0x00]); } // Block terminates label_00A2: // Incoming jump from 0x0035, if 0xc87b56dd > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x95d89b41 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x95d89b41 > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x95d89b41 00B4 14 EQ 00B5 61 PUSH2 0x032a 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032a, if 0x95d89b41 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x9d76ea58 00BF 14 EQ 00C0 61 PUSH2 0x0332 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0332, if 0x9d76ea58 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x9d76ea58 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa22cb465 00CA 14 EQ 00CB 61 PUSH2 0x0345 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0345, if 0xa22cb465 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xb88d4fde 00D5 14 EQ 00D6 61 PUSH2 0x0353 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0353, if 0xb88d4fde == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00DD memory[0x00:0x00] } 00DA 60 PUSH1 0x00 00DC 80 DUP1 00DD FD *REVERT // Stack delta = +0 // Outputs[1] { @00DD revert(memory[0x00:0x00]); } // Block terminates label_00DE: // Incoming jump from 0x00AD, if 0x95d89b41 > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x70a08231 00E5 14 EQ 00E6 61 PUSH2 0x02fe 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fe, if 0x70a08231 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x70a08231 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x715018a6 00F0 14 EQ 00F1 61 PUSH2 0x0311 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x715018a6 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x8da5cb5b 00FB 14 EQ 00FC 61 PUSH2 0x0319 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0319, if 0x8da5cb5b == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0103 memory[0x00:0x00] } 0100 60 PUSH1 0x00 0102 80 DUP1 0103 FD *REVERT // Stack delta = +0 // Outputs[1] { @0103 revert(memory[0x00:0x00]); } // Block terminates label_0104: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0105 stack[-1] } 0104 5B JUMPDEST 0105 80 DUP1 0106 63 PUSH4 0x40c10f19 010B 11 GT 010C 61 PUSH2 0x0171 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0171, if 0x40c10f19 > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x40c10f19 > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x4980e1be 0116 11 GT 0117 61 PUSH2 0x014b 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014b, if 0x4980e1be > stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x4980e1be > stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x4980e1be 0121 14 EQ 0122 61 PUSH2 0x02bd 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bd, if 0x4980e1be == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x4980e1be == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x55f804b3 012C 14 EQ 012D 61 PUSH2 0x02c5 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x55f804b3 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x6352211e 0137 14 EQ 0138 61 PUSH2 0x02d8 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d8, if 0x6352211e == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x6352211e == stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x66eb399f 0142 14 EQ 0143 61 PUSH2 0x02eb 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02eb, if 0x66eb399f == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x66eb399f == stack[-1] // Inputs[1] { @014A memory[0x00:0x00] } 0147 60 PUSH1 0x00 0149 80 DUP1 014A FD *REVERT // Stack delta = +0 // Outputs[1] { @014A revert(memory[0x00:0x00]); } // Block terminates label_014B: // Incoming jump from 0x011A, if 0x4980e1be > stack[-1] // Inputs[1] { @014C stack[-1] } 014B 5B JUMPDEST 014C 80 DUP1 014D 63 PUSH4 0x40c10f19 0152 14 EQ 0153 61 PUSH2 0x0284 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0284, if 0x40c10f19 == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x40c10f19 == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x42842e0e 015D 14 EQ 015E 61 PUSH2 0x0297 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0297, if 0x42842e0e == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x42842e0e == stack[-1] // Inputs[1] { @0162 stack[-1] } 0162 80 DUP1 0163 63 PUSH4 0x44a9945e 0168 14 EQ 0169 61 PUSH2 0x02aa 016C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0x44a9945e == stack[-1] label_016D: // Incoming jump from 0x016C, if not 0x44a9945e == stack[-1] // Inputs[1] { @0170 memory[0x00:0x00] } 016D 60 PUSH1 0x00 016F 80 DUP1 0170 FD *REVERT // Stack delta = +0 // Outputs[1] { @0170 revert(memory[0x00:0x00]); } // Block terminates label_0171: // Incoming jump from 0x010F, if 0x40c10f19 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0171 5B JUMPDEST 0172 80 DUP1 0173 63 PUSH4 0x095ea7b3 0178 11 GT 0179 61 PUSH2 0x01ad 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ad, if 0x095ea7b3 > stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x095ea7b3 0183 14 EQ 0184 61 PUSH2 0x023d 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023d, if 0x095ea7b3 == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x18160ddd 018E 14 EQ 018F 61 PUSH2 0x0252 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0252, if 0x18160ddd == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x18160ddd == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x23b872dd 0199 14 EQ 019A 61 PUSH2 0x0268 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0268, if 0x23b872dd == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x23b872dd == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x3eaaf86b 01A4 14 EQ 01A5 61 PUSH2 0x027b 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027b, if 0x3eaaf86b == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x3eaaf86b == stack[-1] // Inputs[1] { @01AC memory[0x00:0x00] } 01A9 60 PUSH1 0x00 01AB 80 DUP1 01AC FD *REVERT // Stack delta = +0 // Outputs[1] { @01AC revert(memory[0x00:0x00]); } // Block terminates label_01AD: // Incoming jump from 0x017C, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01AE stack[-1] } 01AD 5B JUMPDEST 01AE 80 DUP1 01AF 63 PUSH4 0x01ffc9a7 01B4 14 EQ 01B5 61 PUSH2 0x01d4 01B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d4, if 0x01ffc9a7 == stack[-1] label_01B9: // Incoming jump from 0x01B8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01B9 stack[-1] } 01B9 80 DUP1 01BA 63 PUSH4 0x06fdde03 01BF 14 EQ 01C0 61 PUSH2 0x01fc 01C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fc, if 0x06fdde03 == stack[-1] label_01C4: // Incoming jump from 0x01C3, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01C4 stack[-1] } 01C4 80 DUP1 01C5 63 PUSH4 0x081812fc 01CA 14 EQ 01CB 61 PUSH2 0x0211 01CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0211, if 0x081812fc == stack[-1] label_01CF: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x01CE, if not 0x081812fc == stack[-1] // Inputs[1] { @01D3 memory[0x00:0x00] } 01CF 5B JUMPDEST 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming jump from 0x01B8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01DB msg.data.length } 01D4 5B JUMPDEST 01D5 61 PUSH2 0x01e7 01D8 61 PUSH2 0x01e2 01DB 36 CALLDATASIZE 01DC 60 PUSH1 0x04 01DE 61 PUSH2 0x0c34 01E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D5 stack[0] = 0x01e7 // @01D8 stack[1] = 0x01e2 // @01DB stack[2] = msg.data.length // @01DC stack[3] = 0x04 // } // Block ends with call to 0x0c34, returns to 0x01E2 label_01E2: // Incoming return from call to 0x0C34 at 0x01E1 01E2 5B JUMPDEST 01E3 61 PUSH2 0x0400 01E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0400 label_01E7: // Incoming return from call to 0x01E2 at 0x01E1 // Incoming return from call to 0x03AF at 0x03AE // Incoming jump from 0x0385 // Inputs[4] // { // @01EA memory[0x40:0x60] // @01EB stack[-1] // @01F6 memory[0x40:0x60] // @01FB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01E7 5B JUMPDEST 01E8 60 PUSH1 0x40 01EA 51 MLOAD 01EB 90 SWAP1 01EC 15 ISZERO 01ED 15 ISZERO 01EE 81 DUP2 01EF 52 MSTORE 01F0 60 PUSH1 0x20 01F2 01 ADD 01F3 5B JUMPDEST 01F4 60 PUSH1 0x40 01F6 51 MLOAD 01F7 80 DUP1 01F8 91 SWAP2 01F9 03 SUB 01FA 90 SWAP1 01FB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01FB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01FC: // Incoming jump from 0x01C3, if 0x06fdde03 == stack[-1] 01FC 5B JUMPDEST 01FD 61 PUSH2 0x0204 0200 61 PUSH2 0x0452 0203 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FD stack[0] = 0x0204 } // Block ends with call to 0x0452, returns to 0x0204 label_0204: // Incoming return from call to 0x07AB at 0x02C4 // Incoming return from call to 0x0452 at 0x0203 // Incoming return from call to 0x0374 at 0x0373 // Incoming return from call to 0x09D3 at 0x038D // Incoming return from call to 0x0980 at 0x0331 // Inputs[2] // { // @0207 memory[0x40:0x60] // @020B stack[-1] // } 0204 5B JUMPDEST 0205 60 PUSH1 0x40 0207 51 MLOAD 0208 61 PUSH2 0x01f3 020B 91 SWAP2 020C 90 SWAP1 020D 61 PUSH2 0x0c89 0210 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @020B stack[-1] = 0x01f3 // @020C stack[1] = memory[0x40:0x60] // @020C stack[0] = stack[-1] // } // Block ends with call to 0x0c89, returns to 0x01F3 label_0211: // Incoming jump from 0x01CE, if 0x081812fc == stack[-1] // Inputs[1] { @0218 msg.data.length } 0211 5B JUMPDEST 0212 61 PUSH2 0x0225 0215 61 PUSH2 0x021f 0218 36 CALLDATASIZE 0219 60 PUSH1 0x04 021B 61 PUSH2 0x0cbc 021E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0212 stack[0] = 0x0225 // @0215 stack[1] = 0x021f // @0218 stack[2] = msg.data.length // @0219 stack[3] = 0x04 // } // Block ends with call to 0x0cbc, returns to 0x021F label_021F: // Incoming return from call to 0x0CBC at 0x021E // Inputs[1] { @0223 stack[-2] } 021F 5B JUMPDEST 0220 50 POP 0221 60 PUSH1 0x00 0223 90 SWAP1 0224 56 *JUMP // Stack delta = -1 // Outputs[1] { @0223 stack[-2] = 0x00 } // Block ends with unconditional jump to stack[-2] label_0225: // Incoming jump from 0x0329 // Incoming return from call to 0x021F at 0x021E // Incoming jump from 0x0344 // Inputs[2] // { // @0228 memory[0x40:0x60] // @0232 stack[-1] // } 0225 5B JUMPDEST 0226 60 PUSH1 0x40 0228 51 MLOAD 0229 60 PUSH1 0x01 022B 60 PUSH1 0x01 022D 60 PUSH1 0xa0 022F 1B SHL 0230 03 SUB 0231 90 SWAP1 0232 91 SWAP2 0233 16 AND 0234 81 DUP2 0235 52 MSTORE 0236 60 PUSH1 0x20 0238 01 ADD 0239 61 PUSH2 0x01f3 023C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0235 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0238 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01f3 label_023D: // Incoming jump from 0x0187, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0244 msg.data.length } 023D 5B JUMPDEST 023E 61 PUSH2 0x0250 0241 61 PUSH2 0x024b 0244 36 CALLDATASIZE 0245 60 PUSH1 0x04 0247 61 PUSH2 0x0cea 024A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023E stack[0] = 0x0250 // @0241 stack[1] = 0x024b // @0244 stack[2] = msg.data.length // @0245 stack[3] = 0x04 // } // Block ends with call to 0x0cea, returns to 0x024B label_024B: // Incoming return from call to 0x0F03 at 0x0352 // Incoming return from call to 0x0CEA at 0x024A 024B 5B JUMPDEST 024C 61 PUSH2 0x04e0 024F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04e0 label_0250: // Incoming return from call to 0x02F9 at 0x02F8 // Incoming return from call to 0x03FB at 0x03FA // Incoming return from call to 0x0292 at 0x0291 // Incoming return from call to 0x02B8 at 0x02B7 // Incoming return from call to 0x02D3 at 0x02D2 0250 5B JUMPDEST 0251 00 *STOP // Stack delta = +0 // Outputs[1] { @0251 stop(); } // Block terminates label_0252: // Incoming jump from 0x0192, if 0x18160ddd == stack[-1] 0252 5B JUMPDEST 0253 61 PUSH2 0x025a 0256 61 PUSH2 0x0520 0259 56 *JUMP // Stack delta = +1 // Outputs[1] { @0253 stack[0] = 0x025a } // Block ends with call to 0x0520, returns to 0x025A label_025A: // Incoming return from call to 0x0520 at 0x0259 // Incoming return from call to 0x0520 at 0x0259 // Incoming jump from 0x0283 // Inputs[2] // { // @025D memory[0x40:0x60] // @025E stack[-1] // } 025A 5B JUMPDEST 025B 60 PUSH1 0x40 025D 51 MLOAD 025E 90 SWAP1 025F 81 DUP2 0260 52 MSTORE 0261 60 PUSH1 0x20 0263 01 ADD 0264 61 PUSH2 0x01f3 0267 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0260 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0263 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01f3 label_0268: // Incoming jump from 0x019D, if 0x23b872dd == stack[-1] // Inputs[1] { @026F msg.data.length } 0268 5B JUMPDEST 0269 61 PUSH2 0x0250 026C 61 PUSH2 0x0276 026F 36 CALLDATASIZE 0270 60 PUSH1 0x04 0272 61 PUSH2 0x0d16 0275 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0269 stack[0] = 0x0250 // @026C stack[1] = 0x0276 // @026F stack[2] = msg.data.length // @0270 stack[3] = 0x04 // } // Block ends with call to 0x0d16, returns to 0x0276 label_0276: // Incoming return from call to 0x0D16 at 0x0275 0276 5B JUMPDEST 0277 61 PUSH2 0x05af 027A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05af label_027B: // Incoming jump from 0x01A8, if 0x3eaaf86b == stack[-1] // Inputs[1] { @0281 storage[0x05] } 027B 5B JUMPDEST 027C 61 PUSH2 0x025a 027F 60 PUSH1 0x05 0281 54 SLOAD 0282 81 DUP2 0283 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @027C stack[0] = 0x025a // @0281 stack[1] = storage[0x05] // } // Block ends with unconditional jump to 0x025a label_0284: // Incoming jump from 0x0156, if 0x40c10f19 == stack[-1] // Inputs[1] { @028B msg.data.length } 0284 5B JUMPDEST 0285 61 PUSH2 0x0250 0288 61 PUSH2 0x0292 028B 36 CALLDATASIZE 028C 60 PUSH1 0x04 028E 61 PUSH2 0x0cea 0291 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0285 stack[0] = 0x0250 // @0288 stack[1] = 0x0292 // @028B stack[2] = msg.data.length // @028C stack[3] = 0x04 // } // Block ends with call to 0x0cea, returns to 0x0292 label_0292: // Incoming return from call to 0x0CEA at 0x0291 0292 5B JUMPDEST 0293 61 PUSH2 0x064a 0296 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x064a label_0297: // Incoming jump from 0x0161, if 0x42842e0e == stack[-1] // Inputs[1] { @029E msg.data.length } 0297 5B JUMPDEST 0298 61 PUSH2 0x0250 029B 61 PUSH2 0x02a5 029E 36 CALLDATASIZE 029F 60 PUSH1 0x04 02A1 61 PUSH2 0x0d16 02A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0298 stack[0] = 0x0250 // @029B stack[1] = 0x02a5 // @029E stack[2] = msg.data.length // @029F stack[3] = 0x04 // } // Block ends with call to 0x0d16, returns to 0x02A5 label_02A5: // Incoming return from call to 0x0D16 at 0x02A4 02A5 5B JUMPDEST 02A6 61 PUSH2 0x06d4 02A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06d4 label_02AA: // Incoming jump from 0x016C, if 0x44a9945e == stack[-1] // Inputs[1] { @02B1 msg.data.length } 02AA 5B JUMPDEST 02AB 61 PUSH2 0x0250 02AE 61 PUSH2 0x02b8 02B1 36 CALLDATASIZE 02B2 60 PUSH1 0x04 02B4 61 PUSH2 0x0d9e 02B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AB stack[0] = 0x0250 // @02AE stack[1] = 0x02b8 // @02B1 stack[2] = msg.data.length // @02B2 stack[3] = 0x04 // } // Block ends with call to 0x0d9e, returns to 0x02B8 label_02B8: // Incoming return from call to 0x0D9E at 0x02B7 02B8 5B JUMPDEST 02B9 61 PUSH2 0x06e4 02BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06e4 label_02BD: // Incoming jump from 0x0125, if 0x4980e1be == stack[-1] 02BD 5B JUMPDEST 02BE 61 PUSH2 0x0204 02C1 61 PUSH2 0x07ab 02C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02BE stack[0] = 0x0204 } // Block ends with call to 0x07ab, returns to 0x0204 label_02C5: // Incoming jump from 0x0130, if 0x55f804b3 == stack[-1] // Inputs[1] { @02CC msg.data.length } 02C5 5B JUMPDEST 02C6 61 PUSH2 0x0250 02C9 61 PUSH2 0x02d3 02CC 36 CALLDATASIZE 02CD 60 PUSH1 0x04 02CF 61 PUSH2 0x0e59 02D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C6 stack[0] = 0x0250 // @02C9 stack[1] = 0x02d3 // @02CC stack[2] = msg.data.length // @02CD stack[3] = 0x04 // } // Block ends with call to 0x0e59, returns to 0x02D3 label_02D3: // Incoming return from call to 0x0E59 at 0x02D2 02D3 5B JUMPDEST 02D4 61 PUSH2 0x07ca 02D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07ca label_02D8: // Incoming jump from 0x013B, if 0x6352211e == stack[-1] // Inputs[1] { @02DF msg.data.length } 02D8 5B JUMPDEST 02D9 61 PUSH2 0x0225 02DC 61 PUSH2 0x02e6 02DF 36 CALLDATASIZE 02E0 60 PUSH1 0x04 02E2 61 PUSH2 0x0cbc 02E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D9 stack[0] = 0x0225 // @02DC stack[1] = 0x02e6 // @02DF stack[2] = msg.data.length // @02E0 stack[3] = 0x04 // } // Block ends with call to 0x0cbc, returns to 0x02E6 label_02E6: // Incoming return from call to 0x0CBC at 0x02E5 02E6 5B JUMPDEST 02E7 61 PUSH2 0x07de 02EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07de label_02EB: // Incoming jump from 0x0146, if 0x66eb399f == stack[-1] // Inputs[1] { @02F2 msg.data.length } 02EB 5B JUMPDEST 02EC 61 PUSH2 0x0250 02EF 61 PUSH2 0x02f9 02F2 36 CALLDATASIZE 02F3 60 PUSH1 0x04 02F5 61 PUSH2 0x0f03 02F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EC stack[0] = 0x0250 // @02EF stack[1] = 0x02f9 // @02F2 stack[2] = msg.data.length // @02F3 stack[3] = 0x04 // } // Block ends with call to 0x0f03, returns to 0x02F9 label_02F9: // Incoming return from call to 0x0F03 at 0x02F8 02F9 5B JUMPDEST 02FA 61 PUSH2 0x08ca 02FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ca label_02FE: // Incoming jump from 0x00E9, if 0x70a08231 == stack[-1] // Inputs[1] { @0305 msg.data.length } 02FE 5B JUMPDEST 02FF 61 PUSH2 0x025a 0302 61 PUSH2 0x030c 0305 36 CALLDATASIZE 0306 60 PUSH1 0x04 0308 61 PUSH2 0x0f38 030B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FF stack[0] = 0x025a // @0302 stack[1] = 0x030c // @0305 stack[2] = msg.data.length // @0306 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x0f38 030C 5B JUMPDEST 030D 61 PUSH2 0x08fd 0310 56 *JUMP label_0311: // Incoming jump from 0x00F4, if 0x715018a6 == stack[-1] 0311 5B JUMPDEST 0312 61 PUSH2 0x0250 0315 61 PUSH2 0x096c 0318 56 *JUMP // Stack delta = +1 // Outputs[1] { @0312 stack[0] = 0x0250 } // Block ends with unconditional jump to 0x096c label_0319: // Incoming jump from 0x00FF, if 0x8da5cb5b == stack[-1] // Inputs[1] { @031C storage[0x00] } 0319 5B JUMPDEST 031A 60 PUSH1 0x00 031C 54 SLOAD 031D 60 PUSH1 0x01 031F 60 PUSH1 0x01 0321 60 PUSH1 0xa0 0323 1B SHL 0324 03 SUB 0325 16 AND 0326 61 PUSH2 0x0225 0329 56 *JUMP // Stack delta = +1 // Outputs[1] { @0325 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x0225 label_032A: // Incoming jump from 0x00B8, if 0x95d89b41 == stack[-1] 032A 5B JUMPDEST 032B 61 PUSH2 0x0204 032E 61 PUSH2 0x0980 0331 56 *JUMP // Stack delta = +1 // Outputs[1] { @032B stack[0] = 0x0204 } // Block ends with call to 0x0980, returns to 0x0204 label_0332: // Incoming jump from 0x00C3, if 0x9d76ea58 == stack[-1] // Inputs[1] { @0335 storage[0x03] } 0332 5B JUMPDEST 0333 60 PUSH1 0x03 0335 54 SLOAD 0336 61 PUSH2 0x0225 0339 90 SWAP1 033A 60 PUSH1 0x01 033C 60 PUSH1 0x01 033E 60 PUSH1 0xa0 0340 1B SHL 0341 03 SUB 0342 16 AND 0343 81 DUP2 0344 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0339 stack[0] = 0x0225 // @0342 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // } // Block ends with unconditional jump to 0x0225 label_0345: // Incoming jump from 0x00CE, if 0xa22cb465 == stack[-1] // Inputs[1] { @034C msg.data.length } 0345 5B JUMPDEST 0346 61 PUSH2 0x0250 0349 61 PUSH2 0x024b 034C 36 CALLDATASIZE 034D 60 PUSH1 0x04 034F 61 PUSH2 0x0f03 0352 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0346 stack[0] = 0x0250 // @0349 stack[1] = 0x024b // @034C stack[2] = msg.data.length // @034D stack[3] = 0x04 // } // Block ends with call to 0x0f03, returns to 0x024B label_0353: // Incoming jump from 0x00D9, if 0xb88d4fde == stack[-1] // Inputs[1] { @035A msg.data.length } 0353 5B JUMPDEST 0354 61 PUSH2 0x0250 0357 61 PUSH2 0x0361 035A 36 CALLDATASIZE 035B 60 PUSH1 0x04 035D 61 PUSH2 0x0f55 0360 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0354 stack[0] = 0x0250 // @0357 stack[1] = 0x0361 // @035A stack[2] = msg.data.length // @035B stack[3] = 0x04 // } // Block ends with call to 0x0f55, returns to 0x0361 label_0361: // Incoming return from call to 0x0F55 at 0x0360 0361 5B JUMPDEST 0362 61 PUSH2 0x098d 0365 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x098d label_0366: // Incoming jump from 0x007C, if 0xc87b56dd == stack[-1] // Inputs[1] { @036D msg.data.length } 0366 5B JUMPDEST 0367 61 PUSH2 0x0204 036A 61 PUSH2 0x0374 036D 36 CALLDATASIZE 036E 60 PUSH1 0x04 0370 61 PUSH2 0x0cbc 0373 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0367 stack[0] = 0x0204 // @036A stack[1] = 0x0374 // @036D stack[2] = msg.data.length // @036E stack[3] = 0x04 // } // Block ends with call to 0x0cbc, returns to 0x0374 label_0374: // Incoming return from call to 0x0CBC at 0x0373 0374 5B JUMPDEST 0375 61 PUSH2 0x099f 0378 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x099f label_0379: // Incoming jump from 0x0087, if 0xce4098c9 == stack[-1] // Inputs[1] { @037C storage[0x06] } 0379 5B JUMPDEST 037A 60 PUSH1 0x06 037C 54 SLOAD 037D 61 PUSH2 0x01e7 0380 90 SWAP1 0381 60 PUSH1 0xff 0383 16 AND 0384 81 DUP2 0385 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0380 stack[0] = 0x01e7 // @0383 stack[1] = 0xff & storage[0x06] // } // Block ends with unconditional jump to 0x01e7 label_0386: // Incoming jump from 0x0092, if 0xd547cfb7 == stack[-1] 0386 5B JUMPDEST 0387 61 PUSH2 0x0204 038A 61 PUSH2 0x09d3 038D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0387 stack[0] = 0x0204 } // Block ends with call to 0x09d3, returns to 0x0204 label_038E: // Incoming jump from 0x009D, if 0xd6efa3b7 == stack[-1] // Inputs[1] { @0395 msg.data.length } 038E 5B JUMPDEST 038F 61 PUSH2 0x0250 0392 61 PUSH2 0x039c 0395 36 CALLDATASIZE 0396 60 PUSH1 0x04 0398 61 PUSH2 0x0ff4 039B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038F stack[0] = 0x0250 // @0392 stack[1] = 0x039c // @0395 stack[2] = msg.data.length // @0396 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x0ff4 039C 5B JUMPDEST 039D 61 PUSH2 0x09e0 03A0 56 *JUMP label_03A1: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @03A8 msg.data.length } 03A1 5B JUMPDEST 03A2 61 PUSH2 0x01e7 03A5 61 PUSH2 0x03af 03A8 36 CALLDATASIZE 03A9 60 PUSH1 0x04 03AB 61 PUSH2 0x100f 03AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A2 stack[0] = 0x01e7 // @03A5 stack[1] = 0x03af // @03A8 stack[2] = msg.data.length // @03A9 stack[3] = 0x04 // } // Block ends with call to 0x100f, returns to 0x03AF label_03AF: // Incoming return from call to 0x100F at 0x03AE // Inputs[2] // { // @03B2 stack[-3] // @03B3 stack[-2] // } 03AF 5B JUMPDEST 03B0 60 PUSH1 0x00 03B2 92 SWAP3 03B3 91 SWAP2 03B4 50 POP 03B5 50 POP 03B6 56 *JUMP // Stack delta = -2 // Outputs[1] { @03B2 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_03B7: // Incoming jump from 0x0056, if 0xf2fde38b == stack[-1] // Inputs[1] { @03BE msg.data.length } 03B7 5B JUMPDEST 03B8 61 PUSH2 0x0250 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x0f38 03C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B8 stack[0] = 0x0250 // @03BB stack[1] = 0x03c5 // @03BE stack[2] = msg.data.length // @03BF stack[3] = 0x04 // } // Block ends with unconditional jump to 0x0f38 03C5 5B JUMPDEST 03C6 61 PUSH2 0x09fb 03C9 56 *JUMP label_03CA: // Incoming jump from 0x0061, if 0xf46eccc4 == stack[-1] // Inputs[1] { @03D1 msg.data.length } 03CA 5B JUMPDEST 03CB 61 PUSH2 0x01e7 03CE 61 PUSH2 0x03d8 03D1 36 CALLDATASIZE 03D2 60 PUSH1 0x04 03D4 61 PUSH2 0x0f38 03D7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03CB stack[0] = 0x01e7 // @03CE stack[1] = 0x03d8 // @03D1 stack[2] = msg.data.length // @03D2 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x0f38 03D8 5B JUMPDEST 03D9 60 PUSH1 0x07 03DB 60 PUSH1 0x20 03DD 52 MSTORE 03DE 60 PUSH1 0x00 03E0 90 SWAP1 03E1 81 DUP2 03E2 52 MSTORE 03E3 60 PUSH1 0x40 03E5 90 SWAP1 03E6 20 SHA3 03E7 54 SLOAD 03E8 60 PUSH1 0xff 03EA 16 AND 03EB 81 DUP2 03EC 56 *JUMP label_03ED: // Incoming jump from 0x006C, if 0xf7ea7a3d == stack[-1] // Inputs[1] { @03F4 msg.data.length } 03ED 5B JUMPDEST 03EE 61 PUSH2 0x0250 03F1 61 PUSH2 0x03fb 03F4 36 CALLDATASIZE 03F5 60 PUSH1 0x04 03F7 61 PUSH2 0x0cbc 03FA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03EE stack[0] = 0x0250 // @03F1 stack[1] = 0x03fb // @03F4 stack[2] = msg.data.length // @03F5 stack[3] = 0x04 // } // Block ends with call to 0x0cbc, returns to 0x03FB label_03FB: // Incoming return from call to 0x0CBC at 0x03FA 03FB 5B JUMPDEST 03FC 61 PUSH2 0x0a74 03FF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a74 label_0400: // Incoming jump from 0x01E6 // Inputs[1] { @040C stack[-1] } 0400 5B JUMPDEST 0401 60 PUSH1 0x00 0403 60 PUSH1 0x01 0405 60 PUSH1 0x01 0407 60 PUSH1 0xe0 0409 1B SHL 040A 03 SUB 040B 19 NOT 040C 82 DUP3 040D 16 AND 040E 63 PUSH4 0x80ac58cd 0413 60 PUSH1 0xe0 0415 1B SHL 0416 14 EQ 0417 80 DUP1 0418 61 PUSH2 0x0431 041B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0401 stack[0] = 0x00 // @0416 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0431, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_041C: // Incoming jump from 0x041B, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0426 stack[-3] } 041C 50 POP 041D 60 PUSH1 0x01 041F 60 PUSH1 0x01 0421 60 PUSH1 0xe0 0423 1B SHL 0424 03 SUB 0425 19 NOT 0426 82 DUP3 0427 16 AND 0428 63 PUSH4 0x5b5e139f 042D 60 PUSH1 0xe0 042F 1B SHL 0430 14 EQ 0431 5B JUMPDEST 0432 80 DUP1 0433 61 PUSH2 0x044c 0436 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0430 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x044c, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0437: // Incoming jump from 0x0436, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0436, if not stack[-1] // Inputs[2] // { // @0449 stack[-3] // @044D stack[-4] // } 0437 50 POP 0438 63 PUSH4 0x01ffc9a7 043D 60 PUSH1 0xe0 043F 1B SHL 0440 60 PUSH1 0x01 0442 60 PUSH1 0x01 0444 60 PUSH1 0xe0 0446 1B SHL 0447 03 SUB 0448 19 NOT 0449 83 DUP4 044A 16 AND 044B 14 EQ 044C 5B JUMPDEST 044D 92 SWAP3 044E 91 SWAP2 044F 50 POP 0450 50 POP 0451 56 *JUMP // Stack delta = -3 // Outputs[1] { @044D stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_0452: // Incoming call from 0x0203, returns to 0x0204 // Inputs[1] { @0456 storage[0x01] } 0452 5B JUMPDEST 0453 60 PUSH1 0x01 0455 80 DUP1 0456 54 SLOAD 0457 61 PUSH2 0x045f 045A 90 SWAP1 045B 61 PUSH2 0x1048 045E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0453 stack[0] = 0x01 // @045A stack[1] = 0x045f // @045A stack[2] = storage[0x01] // } // Block ends with call to 0x1048, returns to 0x045F label_045F: // Incoming return from call to 0x1048 at 0x045E // Incoming return from call to 0x1048 at 0x098C // Incoming return from call to 0x1048 at 0x09DF // Inputs[4] // { // @0460 stack[-1] // @046F memory[0x40:0x60] // @0477 stack[-2] // @0482 storage[stack[-2]] // } 045F 5B JUMPDEST 0460 80 DUP1 0461 60 PUSH1 0x1f 0463 01 ADD 0464 60 PUSH1 0x20 0466 80 DUP1 0467 91 SWAP2 0468 04 DIV 0469 02 MUL 046A 60 PUSH1 0x20 046C 01 ADD 046D 60 PUSH1 0x40 046F 51 MLOAD 0470 90 SWAP1 0471 81 DUP2 0472 01 ADD 0473 60 PUSH1 0x40 0475 52 MSTORE 0476 80 DUP1 0477 92 SWAP3 0478 91 SWAP2 0479 90 SWAP1 047A 81 DUP2 047B 81 DUP2 047C 52 MSTORE 047D 60 PUSH1 0x20 047F 01 ADD 0480 82 DUP3 0481 80 DUP1 0482 54 SLOAD 0483 61 PUSH2 0x048b 0486 90 SWAP1 0487 61 PUSH2 0x1048 048A 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0475 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0477 stack[-2] = memory[0x40:0x60] // @0478 stack[-1] = stack[-2] // @0479 stack[0] = stack[-1] // @047C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @047F stack[1] = 0x20 + memory[0x40:0x60] // @0480 stack[2] = stack[-2] // @0486 stack[4] = storage[stack[-2]] // @0486 stack[3] = 0x048b // } // Block ends with call to 0x1048, returns to 0x048B label_048B: // Incoming return from call to 0x1048 at 0x048A // Inputs[1] { @048C stack[-1] } 048B 5B JUMPDEST 048C 80 DUP1 048D 15 ISZERO 048E 61 PUSH2 0x04d8 0491 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d8, if !stack[-1] label_0492: // Incoming jump from 0x0491, if not !stack[-1] // Inputs[1] { @0492 stack[-1] } 0492 80 DUP1 0493 60 PUSH1 0x1f 0495 10 LT 0496 61 PUSH2 0x04ad 0499 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ad, if 0x1f < stack[-1] label_049A: // Incoming jump from 0x0499, if not 0x1f < stack[-1] // Inputs[4] // { // @049E stack[-2] // @049F storage[stack[-2]] // @04A2 stack[-3] // @04A4 stack[-1] // } 049A 61 PUSH2 0x0100 049D 80 DUP1 049E 83 DUP4 049F 54 SLOAD 04A0 04 DIV 04A1 02 MUL 04A2 83 DUP4 04A3 52 MSTORE 04A4 91 SWAP2 04A5 60 PUSH1 0x20 04A7 01 ADD 04A8 91 SWAP2 04A9 61 PUSH2 0x04d8 04AC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04A3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04A8 stack[-1] = stack[-1] // @04A8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04d8 label_04AD: // Incoming jump from 0x0499, if 0x1f < stack[-1] // Inputs[5] // { // @04AE stack[-3] // @04AF stack[-1] // @04B1 stack[-2] // @04B9 memory[0x00:0x20] // @04BD storage[keccak256(memory[0x00:0x20])] // } 04AD 5B JUMPDEST 04AE 82 DUP3 04AF 01 ADD 04B0 91 SWAP2 04B1 90 SWAP1 04B2 60 PUSH1 0x00 04B4 52 MSTORE 04B5 60 PUSH1 0x20 04B7 60 PUSH1 0x00 04B9 20 SHA3 04BA 90 SWAP1 04BB 5B JUMPDEST 04BC 81 DUP2 04BD 54 SLOAD 04BE 81 DUP2 04BF 52 MSTORE 04C0 90 SWAP1 04C1 60 PUSH1 0x01 04C3 01 ADD 04C4 90 SWAP1 04C5 60 PUSH1 0x20 04C7 01 ADD 04C8 80 DUP1 04C9 83 DUP4 04CA 11 GT 04CB 61 PUSH2 0x04bb 04CE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04B0 stack[-3] = stack[-3] + stack[-1] // @04B4 memory[0x00:0x20] = stack[-2] // @04BF memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04C4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04C7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04bb, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04CF: // Incoming jump from 0x04CE, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04CE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04CF stack[-3] // @04D0 stack[-1] // } 04CF 82 DUP3 04D0 90 SWAP1 04D1 03 SUB 04D2 60 PUSH1 0x1f 04D4 16 AND 04D5 82 DUP3 04D6 01 ADD 04D7 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04D7 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04D7 stack[-1] = stack[-3] // } // Block continues label_04D8: // Incoming jump from 0x0491, if !stack[-1] // Incoming jump from 0x04D7 // Incoming jump from 0x04AC // Inputs[1] { @04DE stack[-7] } 04D8 5B JUMPDEST 04D9 50 POP 04DA 50 POP 04DB 50 POP 04DC 50 POP 04DD 50 POP 04DE 81 DUP2 04DF 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_04E0: // Incoming jump from 0x024F // Inputs[1] { @04E3 memory[0x40:0x60] } 04E0 5B JUMPDEST 04E1 60 PUSH1 0x40 04E3 51 MLOAD 04E4 62 PUSH3 0x461bcd 04E8 60 PUSH1 0xe5 04EA 1B SHL 04EB 81 DUP2 04EC 52 MSTORE 04ED 60 PUSH1 0x20 04EF 60 PUSH1 0x04 04F1 82 DUP3 04F2 01 ADD 04F3 52 MSTORE 04F4 60 PUSH1 0x0c 04F6 60 PUSH1 0x24 04F8 82 DUP3 04F9 01 ADD 04FA 52 MSTORE 04FB 6B PUSH12 0x574f4e5420415050524f5645 0508 60 PUSH1 0xa0 050A 1B SHL 050B 60 PUSH1 0x44 050D 82 DUP3 050E 01 ADD 050F 52 MSTORE 0510 60 PUSH1 0x64 0512 01 ADD // Stack delta = +1 // Outputs[5] // { // @04EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04F3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04FA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @050F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x574f4e5420415050524f5645 << 0xa0 // @0512 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0513: // Incoming jump from 0x0512 // Incoming jump from 0x0731 // Incoming jump from 0x0ADA // Incoming jump from 0x0697 // Inputs[3] // { // @0516 memory[0x40:0x60] // @0518 stack[-1] // @051B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0513 5B JUMPDEST 0514 60 PUSH1 0x40 0516 51 MLOAD 0517 80 DUP1 0518 91 SWAP2 0519 03 SUB 051A 90 SWAP1 051B FD *REVERT // Stack delta = -1 // Outputs[1] { @051B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_051C: // Incoming return from call to 0x112E at 0x07DD // Inputs[1] { @051F stack[-3] } 051C 5B JUMPDEST 051D 50 POP 051E 50 POP 051F 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0520: // Incoming call from 0x0259, returns to 0x025A // Inputs[1] { @0525 storage[0x05] } 0520 5B JUMPDEST 0521 60 PUSH1 0x00 0523 60 PUSH1 0x05 0525 54 SLOAD 0526 60 PUSH1 0x00 0528 03 SUB 0529 61 PUSH2 0x05a8 052C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0521 stack[0] = 0x00 } // Block ends with conditional jump to 0x05a8, if 0x00 - storage[0x05] label_052D: // Incoming jump from 0x052C, if not 0x00 - storage[0x05] // Inputs[6] // { // @0532 storage[0x03] // @0553 memory[0x40:0x60] // @0567 memory[0x40:0x60] // @056D msg.gas // @056E address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @056E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 052D 60 PUSH1 0x03 052F 60 PUSH1 0x00 0531 90 SWAP1 0532 54 SLOAD 0533 90 SWAP1 0534 61 PUSH2 0x0100 0537 0A EXP 0538 90 SWAP1 0539 04 DIV 053A 60 PUSH1 0x01 053C 60 PUSH1 0x01 053E 60 PUSH1 0xa0 0540 1B SHL 0541 03 SUB 0542 16 AND 0543 60 PUSH1 0x01 0545 60 PUSH1 0x01 0547 60 PUSH1 0xa0 0549 1B SHL 054A 03 SUB 054B 16 AND 054C 63 PUSH4 0x18160ddd 0551 60 PUSH1 0x40 0553 51 MLOAD 0554 81 DUP2 0555 63 PUSH4 0xffffffff 055A 16 AND 055B 60 PUSH1 0xe0 055D 1B SHL 055E 81 DUP2 055F 52 MSTORE 0560 60 PUSH1 0x04 0562 01 ADD 0563 60 PUSH1 0x20 0565 60 PUSH1 0x40 0567 51 MLOAD 0568 80 DUP1 0569 83 DUP4 056A 03 SUB 056B 81 DUP2 056C 86 DUP7 056D 5A GAS 056E FA STATICCALL 056F 15 ISZERO 0570 80 DUP1 0571 15 ISZERO 0572 61 PUSH2 0x057f 0575 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @054B stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00 // @054C stack[1] = 0x18160ddd // @055F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x18160ddd) << 0xe0 // @0562 stack[2] = 0x04 + memory[0x40:0x60] // @056E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @056F stack[3] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x057f, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0576: // Incoming jump from 0x0575, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0576 returndata.length // @057A returndata[0x00:0x00 + returndata.length] // @057B returndata.length // @057E memory[0x00:0x00 + returndata.length] // } 0576 3D RETURNDATASIZE 0577 60 PUSH1 0x00 0579 80 DUP1 057A 3E RETURNDATACOPY 057B 3D RETURNDATASIZE 057C 60 PUSH1 0x00 057E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @057A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @057E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_057F: // Incoming jump from 0x0575, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x03] / 0x0100 ** 0x00).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @0586 memory[0x40:0x60] // @0587 returndata.length // } 057F 5B JUMPDEST 0580 50 POP 0581 50 POP 0582 50 POP 0583 50 POP 0584 60 PUSH1 0x40 0586 51 MLOAD 0587 3D RETURNDATASIZE 0588 60 PUSH1 0x1f 058A 19 NOT 058B 60 PUSH1 0x1f 058D 82 DUP3 058E 01 ADD 058F 16 AND 0590 82 DUP3 0591 01 ADD 0592 80 DUP1 0593 60 PUSH1 0x40 0595 52 MSTORE 0596 50 POP 0597 81 DUP2 0598 01 ADD 0599 90 SWAP1 059A 61 PUSH2 0x05a3 059D 91 SWAP2 059E 90 SWAP1 059F 61 PUSH2 0x1082 05A2 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0595 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @059D stack[-4] = 0x05a3 // @059E stack[-2] = memory[0x40:0x60] // @059E stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1082, returns to 0x05A3 label_05A3: // Incoming return from call to 0x1082 at 0x05A2 // Inputs[3] // { // @05A4 stack[-2] // @05A4 stack[-1] // @05A6 stack[-3] // } 05A3 5B JUMPDEST 05A4 90 SWAP1 05A5 50 POP 05A6 90 SWAP1 05A7 56 *JUMP // Stack delta = -2 // Outputs[1] { @05A6 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_05A8: // Incoming jump from 0x052C, if 0x00 - storage[0x05] // Inputs[2] // { // @05AC storage[0x05] // @05AD stack[-2] // } 05A8 5B JUMPDEST 05A9 50 POP 05AA 60 PUSH1 0x05 05AC 54 SLOAD 05AD 90 SWAP1 05AE 56 *JUMP // Stack delta = -1 // Outputs[1] { @05AD stack[-2] = storage[0x05] } // Block ends with unconditional jump to stack[-2] label_05AF: // Incoming jump from 0x0997 // Incoming jump from 0x06DE // Incoming jump from 0x027A // Inputs[2] // { // @05B0 stack[-2] // @05BD stack[-1] // } 05AF 5B JUMPDEST 05B0 81 DUP2 05B1 60 PUSH1 0x01 05B3 60 PUSH1 0x01 05B5 60 PUSH1 0xa0 05B7 1B SHL 05B8 03 SUB 05B9 16 AND 05BA 61 PUSH2 0x05c2 05BD 82 DUP3 05BE 61 PUSH2 0x07de 05C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05B9 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05BA stack[1] = 0x05c2 // @05BD stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x07de 05C2 5B JUMPDEST 05C3 60 PUSH1 0x01 05C5 60 PUSH1 0x01 05C7 60 PUSH1 0xa0 05C9 1B SHL 05CA 03 SUB 05CB 16 AND 05CC 14 EQ 05CD 61 PUSH2 0x0604 05D0 57 *JUMPI 05D1 60 PUSH1 0x40 05D3 51 MLOAD 05D4 62 PUSH3 0x461bcd 05D8 60 PUSH1 0xe5 05DA 1B SHL 05DB 81 DUP2 05DC 52 MSTORE 05DD 60 PUSH1 0x20 05DF 60 PUSH1 0x04 05E1 82 DUP3 05E2 01 ADD 05E3 52 MSTORE 05E4 60 PUSH1 0x09 05E6 60 PUSH1 0x24 05E8 82 DUP3 05E9 01 ADD 05EA 52 MSTORE 05EB 68 PUSH9 0x3737ba1037bbb732b9 05F5 60 PUSH1 0xb9 05F7 1B SHL 05F8 60 PUSH1 0x44 05FA 82 DUP3 05FB 01 ADD 05FC 52 MSTORE 05FD 60 PUSH1 0x64 05FF 01 ADD 0600 61 PUSH2 0x0513 0603 56 *JUMP 0604 5B JUMPDEST 0605 80 DUP1 0606 82 DUP3 0607 60 PUSH1 0x01 0609 60 PUSH1 0x01 060B 60 PUSH1 0xa0 060D 1B SHL 060E 03 SUB 060F 16 AND 0610 84 DUP5 0611 60 PUSH1 0x01 0613 60 PUSH1 0x01 0615 60 PUSH1 0xa0 0617 1B SHL 0618 03 SUB 0619 16 AND 061A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 063B 60 PUSH1 0x40 063D 51 MLOAD 063E 60 PUSH1 0x40 0640 51 MLOAD 0641 80 DUP1 0642 91 SWAP2 0643 03 SUB 0644 90 SWAP1 0645 A4 LOG4 0646 50 POP 0647 50 POP 0648 50 POP 0649 56 *JUMP label_064A: // Incoming jump from 0x0296 // Inputs[3] // { // @064B msg.sender // @0659 memory[0x00:0x40] // @065A storage[keccak256(memory[0x00:0x40])] // } 064A 5B JUMPDEST 064B 33 CALLER 064C 60 PUSH1 0x00 064E 90 SWAP1 064F 81 DUP2 0650 52 MSTORE 0651 60 PUSH1 0x07 0653 60 PUSH1 0x20 0655 52 MSTORE 0656 60 PUSH1 0x40 0658 90 SWAP1 0659 20 SHA3 065A 54 SLOAD 065B 60 PUSH1 0xff 065D 16 AND 065E 61 PUSH2 0x0698 0661 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0650 memory[0x00:0x20] = msg.sender // @0655 memory[0x20:0x40] = 0x07 // } // Block ends with conditional jump to 0x0698, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0662: // Incoming jump from 0x0661, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0664 memory[0x40:0x60] } 0662 60 PUSH1 0x40 0664 51 MLOAD 0665 62 PUSH3 0x461bcd 0669 60 PUSH1 0xe5 066B 1B SHL 066C 81 DUP2 066D 52 MSTORE 066E 60 PUSH1 0x20 0670 60 PUSH1 0x04 0672 82 DUP3 0673 01 ADD 0674 52 MSTORE 0675 60 PUSH1 0x0c 0677 60 PUSH1 0x24 0679 82 DUP3 067A 01 ADD 067B 52 MSTORE 067C 6B PUSH12 0x3737ba10309036b4b73a32b9 0689 60 PUSH1 0xa1 068B 1B SHL 068C 60 PUSH1 0x44 068E 82 DUP3 068F 01 ADD 0690 52 MSTORE 0691 60 PUSH1 0x64 0693 01 ADD 0694 61 PUSH2 0x0513 0697 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @066D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0674 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @067B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0690 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x3737ba10309036b4b73a32b9 << 0xa1 // @0693 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0513 label_0698: // Incoming jump from 0x0661, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @069B memory[0x40:0x60] // @069C stack[-1] // @06A6 stack[-2] // @06D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @06D3 stack[-3] // } 0698 5B JUMPDEST 0699 60 PUSH1 0x40 069B 51 MLOAD 069C 81 DUP2 069D 90 SWAP1 069E 60 PUSH1 0x01 06A0 60 PUSH1 0x01 06A2 60 PUSH1 0xa0 06A4 1B SHL 06A5 03 SUB 06A6 84 DUP5 06A7 16 AND 06A8 90 SWAP1 06A9 60 PUSH1 0x00 06AB 90 SWAP1 06AC 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 06CD 90 SWAP1 06CE 82 DUP3 06CF 90 SWAP1 06D0 A4 LOG4 06D1 50 POP 06D2 50 POP 06D3 56 *JUMP // Stack delta = -3 // Outputs[1] { @06D0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_06D4: // Incoming jump from 0x02A9 // Inputs[3] // { // @06D8 stack[-3] // @06D9 stack[-2] // @06DA stack[-1] // } 06D4 5B JUMPDEST 06D5 61 PUSH2 0x06df 06D8 83 DUP4 06D9 83 DUP4 06DA 83 DUP4 06DB 61 PUSH2 0x05af 06DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06D5 stack[0] = 0x06df // @06D8 stack[1] = stack[-3] // @06D9 stack[2] = stack[-2] // @06DA stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x05af label_06DF: // Incoming jump from 0x10E9, if !(stack[-2] > 0x1f) // Incoming jump from 0x073E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x073E, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @06E3 stack[-4] } 06DF 5B JUMPDEST 06E0 50 POP 06E1 50 POP 06E2 50 POP 06E3 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_06E4: // Incoming jump from 0x02BC // Inputs[3] // { // @06E5 msg.sender // @06F3 memory[0x00:0x40] // @06F4 storage[keccak256(memory[0x00:0x40])] // } 06E4 5B JUMPDEST 06E5 33 CALLER 06E6 60 PUSH1 0x00 06E8 90 SWAP1 06E9 81 DUP2 06EA 52 MSTORE 06EB 60 PUSH1 0x07 06ED 60 PUSH1 0x20 06EF 52 MSTORE 06F0 60 PUSH1 0x40 06F2 90 SWAP1 06F3 20 SHA3 06F4 54 SLOAD 06F5 60 PUSH1 0xff 06F7 16 AND 06F8 61 PUSH2 0x0732 06FB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @06EA memory[0x00:0x20] = msg.sender // @06EF memory[0x20:0x40] = 0x07 // } // Block ends with conditional jump to 0x0732, if 0xff & storage[keccak256(memory[0x00:0x40])] label_06FC: // Incoming jump from 0x06FB, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @06FE memory[0x40:0x60] } 06FC 60 PUSH1 0x40 06FE 51 MLOAD 06FF 62 PUSH3 0x461bcd 0703 60 PUSH1 0xe5 0705 1B SHL 0706 81 DUP2 0707 52 MSTORE 0708 60 PUSH1 0x20 070A 60 PUSH1 0x04 070C 82 DUP3 070D 01 ADD 070E 52 MSTORE 070F 60 PUSH1 0x0c 0711 60 PUSH1 0x24 0713 82 DUP3 0714 01 ADD 0715 52 MSTORE 0716 6B PUSH12 0x3737ba10309036b4b73a32b9 0723 60 PUSH1 0xa1 0725 1B SHL 0726 60 PUSH1 0x44 0728 82 DUP3 0729 01 ADD 072A 52 MSTORE 072B 60 PUSH1 0x64 072D 01 ADD 072E 61 PUSH2 0x0513 0731 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0707 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @070E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0715 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @072A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x3737ba10309036b4b73a32b9 << 0xa1 // @072D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0513 label_0732: // Incoming jump from 0x06FB, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0736 stack[-1] // @0737 memory[stack[-1]:stack[-1] + 0x20] // } 0732 5B JUMPDEST 0733 60 PUSH1 0x00 0735 5B JUMPDEST 0736 81 DUP2 0737 51 MLOAD 0738 81 DUP2 0739 10 LT 073A 15 ISZERO 073B 61 PUSH2 0x06df 073E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0733 stack[0] = 0x00 } // Block ends with conditional jump to 0x06df, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_073F: // Incoming jump from 0x073E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x073E, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @073F stack[-2] // @0740 stack[-1] // @0742 memory[stack[-2]:stack[-2] + 0x20] // } 073F 81 DUP2 0740 81 DUP2 0741 81 DUP2 0742 51 MLOAD 0743 81 DUP2 0744 10 LT 0745 61 PUSH2 0x0750 0748 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @073F stack[0] = stack[-2] // @0740 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0750, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0749: // Incoming jump from 0x0748, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0749 61 PUSH2 0x0750 074C 61 PUSH2 0x109b 074F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0749 stack[0] = 0x0750 } // Block ends with unconditional jump to 0x109b label_0750: // Incoming jump from 0x0748, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[8] // { // @0753 stack[-1] // @0757 stack[-2] // @0758 memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20] // @0759 stack[-5] // @0791 memory[0x40:0x60] // @0794 memory[0x40:0x60] // @0799 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @079A stack[-3] // } 0750 5B JUMPDEST 0751 60 PUSH1 0x20 0753 02 MUL 0754 60 PUSH1 0x20 0756 01 ADD 0757 01 ADD 0758 51 MLOAD 0759 83 DUP4 075A 60 PUSH1 0x01 075C 60 PUSH1 0x01 075E 60 PUSH1 0xa0 0760 1B SHL 0761 03 SUB 0762 16 AND 0763 60 PUSH1 0x00 0765 60 PUSH1 0x01 0767 60 PUSH1 0x01 0769 60 PUSH1 0xa0 076B 1B SHL 076C 03 SUB 076D 16 AND 076E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 078F 60 PUSH1 0x40 0791 51 MLOAD 0792 60 PUSH1 0x40 0794 51 MLOAD 0795 80 DUP1 0796 91 SWAP2 0797 03 SUB 0798 90 SWAP1 0799 A4 LOG4 079A 80 DUP1 079B 61 PUSH2 0x07a3 079E 81 DUP2 079F 61 PUSH2 0x10c7 07A2 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0799 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, (0x01 << 0xa0) - 0x01 & 0x00, stack[-5] & (0x01 << 0xa0) - 0x01, memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20]]); // @079A stack[-2] = stack[-3] // @079B stack[-1] = 0x07a3 // @079E stack[0] = stack[-3] // } // Block ends with call to 0x10c7, returns to 0x07A3 label_07A3: // Incoming return from call to 0x10C7 at 0x07A2 // Inputs[2] // { // @07A4 stack[-1] // @07A4 stack[-3] // } 07A3 5B JUMPDEST 07A4 91 SWAP2 07A5 50 POP 07A6 50 POP 07A7 61 PUSH2 0x0735 07AA 56 *JUMP // Stack delta = -2 // Outputs[1] { @07A4 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0735 label_07AB: // Incoming call from 0x02C4, returns to 0x0204 // Inputs[2] // { // @07AE memory[0x40:0x60] // @07C8 stack[-1] // } 07AB 5B JUMPDEST 07AC 60 PUSH1 0x40 07AE 51 MLOAD 07AF 80 DUP1 07B0 61 PUSH2 0x01a0 07B3 01 ADD 07B4 60 PUSH1 0x40 07B6 52 MSTORE 07B7 80 DUP1 07B8 61 PUSH2 0x0169 07BB 81 DUP2 07BC 52 MSTORE 07BD 60 PUSH1 0x20 07BF 01 ADD 07C0 61 PUSH2 0x12f7 07C3 61 PUSH2 0x0169 07C6 91 SWAP2 07C7 39 CODECOPY 07C8 81 DUP2 07C9 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @07AE stack[0] = memory[0x40:0x60] // @07B6 memory[0x40:0x60] = 0x01a0 + memory[0x40:0x60] // @07BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0169 // @07C7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x0169] = code[0x12f7:0x1460] // } // Block ends with unconditional jump to stack[-1] label_07CA: // Incoming jump from 0x02D7 07CA 5B JUMPDEST 07CB 61 PUSH2 0x07d2 07CE 61 PUSH2 0x0a81 07D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @07CB stack[0] = 0x07d2 } // Block ends with call to 0x0a81, returns to 0x07D2 label_07D2: // Incoming return from call to 0x0A81 at 0x07D1 // Inputs[1] { @07D8 stack[-1] } 07D2 5B JUMPDEST 07D3 60 PUSH1 0x04 07D5 61 PUSH2 0x051c 07D8 82 DUP3 07D9 82 DUP3 07DA 61 PUSH2 0x112e 07DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07D3 stack[0] = 0x04 // @07D5 stack[1] = 0x051c // @07D8 stack[2] = stack[-1] // @07D9 stack[3] = 0x04 // } // Block ends with call to 0x112e, returns to 0x051C label_07DE: // Incoming jump from 0x02EA // Incoming jump from 0x05C1 // Inputs[1] { @07E1 storage[0x06] } 07DE 5B JUMPDEST 07DF 60 PUSH1 0x06 07E1 54 SLOAD 07E2 60 PUSH1 0x00 07E4 90 SWAP1 07E5 60 PUSH1 0xff 07E7 16 AND 07E8 61 PUSH2 0x085d 07EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E4 stack[0] = 0x00 } // Block ends with conditional jump to 0x085d, if 0xff & storage[0x06] label_07EC: // Incoming jump from 0x07EB, if not 0xff & storage[0x06] // Inputs[7] // { // @07EE storage[0x03] // @07F1 memory[0x40:0x60] // @0800 stack[-2] // @081C memory[0x40:0x60] // @0822 msg.gas // @0823 address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0823 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07EC 60 PUSH1 0x03 07EE 54 SLOAD 07EF 60 PUSH1 0x40 07F1 51 MLOAD 07F2 63 PUSH4 0x31a9108f 07F7 60 PUSH1 0xe1 07F9 1B SHL 07FA 81 DUP2 07FB 52 MSTORE 07FC 60 PUSH1 0x04 07FE 81 DUP2 07FF 01 ADD 0800 84 DUP5 0801 90 SWAP1 0802 52 MSTORE 0803 60 PUSH1 0x01 0805 60 PUSH1 0x01 0807 60 PUSH1 0xa0 0809 1B SHL 080A 03 SUB 080B 90 SWAP1 080C 91 SWAP2 080D 16 AND 080E 90 SWAP1 080F 63 PUSH4 0x6352211e 0814 90 SWAP1 0815 60 PUSH1 0x24 0817 01 ADD 0818 60 PUSH1 0x20 081A 60 PUSH1 0x40 081C 51 MLOAD 081D 80 DUP1 081E 83 DUP4 081F 03 SUB 0820 81 DUP2 0821 86 DUP7 0822 5A GAS 0823 FA STATICCALL 0824 15 ISZERO 0825 80 DUP1 0826 15 ISZERO 0827 61 PUSH2 0x0834 082A 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @07FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x31a9108f << 0xe1 // @0802 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] // @080E stack[0] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @0814 stack[1] = 0x6352211e // @0817 stack[2] = 0x24 + memory[0x40:0x60] // @0823 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0824 stack[3] = !address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0834, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_082B: // Incoming jump from 0x082A, if not !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @082B returndata.length // @082F returndata[0x00:0x00 + returndata.length] // @0830 returndata.length // @0833 memory[0x00:0x00 + returndata.length] // } 082B 3D RETURNDATASIZE 082C 60 PUSH1 0x00 082E 80 DUP1 082F 3E RETURNDATACOPY 0830 3D RETURNDATASIZE 0831 60 PUSH1 0x00 0833 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @082F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0833 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0834: // Incoming jump from 0x082A, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @083B memory[0x40:0x60] // @083C returndata.length // } 0834 5B JUMPDEST 0835 50 POP 0836 50 POP 0837 50 POP 0838 50 POP 0839 60 PUSH1 0x40 083B 51 MLOAD 083C 3D RETURNDATASIZE 083D 60 PUSH1 0x1f 083F 19 NOT 0840 60 PUSH1 0x1f 0842 82 DUP3 0843 01 ADD 0844 16 AND 0845 82 DUP3 0846 01 ADD 0847 80 DUP1 0848 60 PUSH1 0x40 084A 52 MSTORE 084B 50 POP 084C 81 DUP2 084D 01 ADD 084E 90 SWAP1 084F 61 PUSH2 0x0858 0852 91 SWAP2 0853 90 SWAP1 0854 61 PUSH2 0x11ee 0857 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @084A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0852 stack[-4] = 0x0858 // @0853 stack[-2] = memory[0x40:0x60] // @0853 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x11ee 0858 5B JUMPDEST 0859 61 PUSH2 0x044c 085C 56 *JUMP label_085D: // Incoming jump from 0x07EB, if 0xff & storage[0x06] // Inputs[7] // { // @0860 storage[0x03] // @0863 memory[0x40:0x60] // @0872 stack[-2] // @088E memory[0x40:0x60] // @0894 msg.gas // @0895 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0895 address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 085D 5B JUMPDEST 085E 60 PUSH1 0x03 0860 54 SLOAD 0861 60 PUSH1 0x40 0863 51 MLOAD 0864 63 PUSH4 0x0b02f02d 0869 60 PUSH1 0xe3 086B 1B SHL 086C 81 DUP2 086D 52 MSTORE 086E 60 PUSH1 0x04 0870 81 DUP2 0871 01 ADD 0872 84 DUP5 0873 90 SWAP1 0874 52 MSTORE 0875 60 PUSH1 0x01 0877 60 PUSH1 0x01 0879 60 PUSH1 0xa0 087B 1B SHL 087C 03 SUB 087D 90 SWAP1 087E 91 SWAP2 087F 16 AND 0880 90 SWAP1 0881 63 PUSH4 0x58178168 0886 90 SWAP1 0887 60 PUSH1 0x24 0889 01 ADD 088A 60 PUSH1 0x20 088C 60 PUSH1 0x40 088E 51 MLOAD 088F 80 DUP1 0890 83 DUP4 0891 03 SUB 0892 81 DUP2 0893 86 DUP7 0894 5A GAS 0895 FA STATICCALL 0896 15 ISZERO 0897 80 DUP1 0898 15 ISZERO 0899 61 PUSH2 0x08a6 089C 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @086D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0b02f02d << 0xe3 // @0874 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] // @0880 stack[0] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @0886 stack[1] = 0x58178168 // @0889 stack[2] = 0x24 + memory[0x40:0x60] // @0895 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0896 stack[3] = !address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x08a6, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_089D: // Incoming jump from 0x089C, if not !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @089D returndata.length // @08A1 returndata[0x00:0x00 + returndata.length] // @08A2 returndata.length // @08A5 memory[0x00:0x00 + returndata.length] // } 089D 3D RETURNDATASIZE 089E 60 PUSH1 0x00 08A0 80 DUP1 08A1 3E RETURNDATACOPY 08A2 3D RETURNDATASIZE 08A3 60 PUSH1 0x00 08A5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08A1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08A5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_08A6: // Incoming jump from 0x089C, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @08AD memory[0x40:0x60] // @08AE returndata.length // } 08A6 5B JUMPDEST 08A7 50 POP 08A8 50 POP 08A9 50 POP 08AA 50 POP 08AB 60 PUSH1 0x40 08AD 51 MLOAD 08AE 3D RETURNDATASIZE 08AF 60 PUSH1 0x1f 08B1 19 NOT 08B2 60 PUSH1 0x1f 08B4 82 DUP3 08B5 01 ADD 08B6 16 AND 08B7 82 DUP3 08B8 01 ADD 08B9 80 DUP1 08BA 60 PUSH1 0x40 08BC 52 MSTORE 08BD 50 POP 08BE 81 DUP2 08BF 01 ADD 08C0 90 SWAP1 08C1 61 PUSH2 0x044c 08C4 91 SWAP2 08C5 90 SWAP1 08C6 61 PUSH2 0x11ee 08C9 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @08BC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @08C4 stack[-4] = 0x044c // @08C5 stack[-2] = memory[0x40:0x60] // @08C5 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x11ee label_08CA: // Incoming jump from 0x02FD 08CA 5B JUMPDEST 08CB 61 PUSH2 0x08d2 08CE 61 PUSH2 0x0a81 08D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @08CB stack[0] = 0x08d2 } // Block ends with call to 0x0a81, returns to 0x08D2 label_08D2: // Incoming return from call to 0x0A81 at 0x08D1 // Inputs[5] // { // @08DB stack[-2] // @08DC stack[-1] // @08EC memory[0x00:0x40] // @08EE storage[keccak256(memory[0x00:0x40])] // @08FC stack[-3] // } 08D2 5B JUMPDEST 08D3 60 PUSH1 0x01 08D5 60 PUSH1 0x01 08D7 60 PUSH1 0xa0 08D9 1B SHL 08DA 03 SUB 08DB 91 SWAP2 08DC 90 SWAP1 08DD 91 SWAP2 08DE 16 AND 08DF 60 PUSH1 0x00 08E1 90 SWAP1 08E2 81 DUP2 08E3 52 MSTORE 08E4 60 PUSH1 0x07 08E6 60 PUSH1 0x20 08E8 52 MSTORE 08E9 60 PUSH1 0x40 08EB 90 SWAP1 08EC 20 SHA3 08ED 80 DUP1 08EE 54 SLOAD 08EF 60 PUSH1 0xff 08F1 19 NOT 08F2 16 AND 08F3 91 SWAP2 08F4 15 ISZERO 08F5 15 ISZERO 08F6 91 SWAP2 08F7 90 SWAP1 08F8 91 SWAP2 08F9 17 OR 08FA 90 SWAP1 08FB 55 SSTORE 08FC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @08E3 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @08E8 memory[0x20:0x40] = 0x07 // @08FB storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] 08FD 5B JUMPDEST 08FE 60 PUSH1 0x03 0900 54 SLOAD 0901 60 PUSH1 0x40 0903 51 MLOAD 0904 63 PUSH4 0x70a08231 0909 60 PUSH1 0xe0 090B 1B SHL 090C 81 DUP2 090D 52 MSTORE 090E 60 PUSH1 0x01 0910 60 PUSH1 0x01 0912 60 PUSH1 0xa0 0914 1B SHL 0915 03 SUB 0916 83 DUP4 0917 81 DUP2 0918 16 AND 0919 60 PUSH1 0x04 091B 83 DUP4 091C 01 ADD 091D 52 MSTORE 091E 60 PUSH1 0x00 0920 92 SWAP3 0921 16 AND 0922 90 SWAP1 0923 63 PUSH4 0x70a08231 0928 90 SWAP1 0929 60 PUSH1 0x24 092B 01 ADD 092C 60 PUSH1 0x20 092E 60 PUSH1 0x40 0930 51 MLOAD 0931 80 DUP1 0932 83 DUP4 0933 03 SUB 0934 81 DUP2 0935 86 DUP7 0936 5A GAS 0937 FA STATICCALL 0938 15 ISZERO 0939 80 DUP1 093A 15 ISZERO 093B 61 PUSH2 0x0948 093E 57 *JUMPI 093F 3D RETURNDATASIZE 0940 60 PUSH1 0x00 0942 80 DUP1 0943 3E RETURNDATACOPY 0944 3D RETURNDATASIZE 0945 60 PUSH1 0x00 0947 FD *REVERT 0948 5B JUMPDEST 0949 50 POP 094A 50 POP 094B 50 POP 094C 50 POP 094D 60 PUSH1 0x40 094F 51 MLOAD 0950 3D RETURNDATASIZE 0951 60 PUSH1 0x1f 0953 19 NOT 0954 60 PUSH1 0x1f 0956 82 DUP3 0957 01 ADD 0958 16 AND 0959 82 DUP3 095A 01 ADD 095B 80 DUP1 095C 60 PUSH1 0x40 095E 52 MSTORE 095F 50 POP 0960 81 DUP2 0961 01 ADD 0962 90 SWAP1 0963 61 PUSH2 0x044c 0966 91 SWAP2 0967 90 SWAP1 0968 61 PUSH2 0x1082 096B 56 *JUMP label_096C: // Incoming jump from 0x0318 096C 5B JUMPDEST 096D 61 PUSH2 0x0974 0970 61 PUSH2 0x0a81 0973 56 *JUMP // Stack delta = +1 // Outputs[1] { @096D stack[0] = 0x0974 } // Block ends with call to 0x0a81, returns to 0x0974 label_0974: // Incoming return from call to 0x0A81 at 0x0973 0974 5B JUMPDEST 0975 61 PUSH2 0x097e 0978 60 PUSH1 0x00 097A 61 PUSH2 0x0adb 097D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0975 stack[0] = 0x097e // @0978 stack[1] = 0x00 // } // Block ends with call to 0x0adb, returns to 0x097E label_097E: // Incoming return from call to 0x0ADB at 0x097D // Incoming jump from 0x0A93, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @097F stack[-1] } 097E 5B JUMPDEST 097F 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0980: // Incoming call from 0x0331, returns to 0x0204 // Inputs[1] { @0984 storage[0x02] } 0980 5B JUMPDEST 0981 60 PUSH1 0x02 0983 80 DUP1 0984 54 SLOAD 0985 61 PUSH2 0x045f 0988 90 SWAP1 0989 61 PUSH2 0x1048 098C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0981 stack[0] = 0x02 // @0988 stack[1] = 0x045f // @0988 stack[2] = storage[0x02] // } // Block ends with call to 0x1048, returns to 0x045F label_098D: // Incoming jump from 0x0365 // Inputs[3] // { // @0991 stack[-5] // @0992 stack[-4] // @0993 stack[-3] // } 098D 5B JUMPDEST 098E 61 PUSH2 0x0998 0991 85 DUP6 0992 85 DUP6 0993 85 DUP6 0994 61 PUSH2 0x05af 0997 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @098E stack[0] = 0x0998 // @0991 stack[1] = stack[-5] // @0992 stack[2] = stack[-4] // @0993 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x05af 0998 5B JUMPDEST 0999 50 POP 099A 50 POP 099B 50 POP 099C 50 POP 099D 50 POP 099E 56 *JUMP label_099F: // Incoming jump from 0x0378 // Inputs[1] { @09A7 stack[-1] } 099F 5B JUMPDEST 09A0 60 PUSH1 0x60 09A2 60 PUSH1 0x04 09A4 61 PUSH2 0x09ac 09A7 83 DUP4 09A8 61 PUSH2 0x0b2b 09AB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09A0 stack[0] = 0x60 // @09A2 stack[1] = 0x04 // @09A4 stack[2] = 0x09ac // @09A7 stack[3] = stack[-1] // } // Block ends with call to 0x0b2b, returns to 0x09AC label_09AC: // Incoming return from call to 0x0B2B at 0x09AB // Inputs[3] // { // @09AF memory[0x40:0x60] // @09B6 stack[-2] // @09B7 stack[-1] // } 09AC 5B JUMPDEST 09AD 60 PUSH1 0x40 09AF 51 MLOAD 09B0 60 PUSH1 0x20 09B2 01 ADD 09B3 61 PUSH2 0x09bd 09B6 92 SWAP3 09B7 91 SWAP2 09B8 90 SWAP1 09B9 61 PUSH2 0x120b 09BC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @09B6 stack[-2] = 0x09bd // @09B7 stack[-1] = stack[-2] // @09B8 stack[1] = 0x20 + memory[0x40:0x60] // @09B8 stack[0] = stack[-1] // } // Block ends with call to 0x120b, returns to 0x09BD label_09BD: // Incoming return from call to 0x120B at 0x09BC // Inputs[5] // { // @09C0 memory[0x40:0x60] // @09C4 stack[-1] // @09CD stack[-2] // @09CF stack[-4] // @09D0 stack[-3] // } 09BD 5B JUMPDEST 09BE 60 PUSH1 0x40 09C0 51 MLOAD 09C1 60 PUSH1 0x20 09C3 81 DUP2 09C4 83 DUP4 09C5 03 SUB 09C6 03 SUB 09C7 81 DUP2 09C8 52 MSTORE 09C9 90 SWAP1 09CA 60 PUSH1 0x40 09CC 52 MSTORE 09CD 90 SWAP1 09CE 50 POP 09CF 91 SWAP2 09D0 90 SWAP1 09D1 50 POP 09D2 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @09C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @09CC memory[0x40:0x60] = stack[-1] // @09CF stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_09D3: // Incoming call from 0x038D, returns to 0x0204 // Inputs[1] { @09D7 storage[0x04] } 09D3 5B JUMPDEST 09D4 60 PUSH1 0x04 09D6 80 DUP1 09D7 54 SLOAD 09D8 61 PUSH2 0x045f 09DB 90 SWAP1 09DC 61 PUSH2 0x1048 09DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09D4 stack[0] = 0x04 // @09DB stack[1] = 0x045f // @09DB stack[2] = storage[0x04] // } // Block ends with call to 0x1048, returns to 0x045F 09E0 5B JUMPDEST 09E1 61 PUSH2 0x09e8 09E4 61 PUSH2 0x0a81 09E7 56 *JUMP 09E8 5B JUMPDEST 09E9 60 PUSH1 0x06 09EB 80 DUP1 09EC 54 SLOAD 09ED 60 PUSH1 0xff 09EF 19 NOT 09F0 16 AND 09F1 91 SWAP2 09F2 15 ISZERO 09F3 15 ISZERO 09F4 91 SWAP2 09F5 90 SWAP1 09F6 91 SWAP2 09F7 17 OR 09F8 90 SWAP1 09F9 55 SSTORE 09FA 56 *JUMP 09FB 5B JUMPDEST 09FC 61 PUSH2 0x0a03 09FF 61 PUSH2 0x0a81 0A02 56 *JUMP 0A03 5B JUMPDEST 0A04 60 PUSH1 0x01 0A06 60 PUSH1 0x01 0A08 60 PUSH1 0xa0 0A0A 1B SHL 0A0B 03 SUB 0A0C 81 DUP2 0A0D 16 AND 0A0E 61 PUSH2 0x0a68 0A11 57 *JUMPI 0A12 60 PUSH1 0x40 0A14 51 MLOAD 0A15 62 PUSH3 0x461bcd 0A19 60 PUSH1 0xe5 0A1B 1B SHL 0A1C 81 DUP2 0A1D 52 MSTORE 0A1E 60 PUSH1 0x20 0A20 60 PUSH1 0x04 0A22 82 DUP3 0A23 01 ADD 0A24 52 MSTORE 0A25 60 PUSH1 0x26 0A27 60 PUSH1 0x24 0A29 82 DUP3 0A2A 01 ADD 0A2B 52 MSTORE 0A2C 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0A4D 60 PUSH1 0x44 0A4F 82 DUP3 0A50 01 ADD 0A51 52 MSTORE 0A52 65 PUSH6 0x646472657373 0A59 60 PUSH1 0xd0 0A5B 1B SHL 0A5C 60 PUSH1 0x64 0A5E 82 DUP3 0A5F 01 ADD 0A60 52 MSTORE 0A61 60 PUSH1 0x84 0A63 01 ADD 0A64 61 PUSH2 0x0513 0A67 56 *JUMP 0A68 5B JUMPDEST 0A69 61 PUSH2 0x0a71 0A6C 81 DUP2 0A6D 61 PUSH2 0x0adb 0A70 56 *JUMP label_0A71: // Incoming jump from 0x0CE5, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A73 stack[-2] } 0A71 5B JUMPDEST 0A72 50 POP 0A73 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A74: // Incoming jump from 0x03FF 0A74 5B JUMPDEST 0A75 61 PUSH2 0x0a7c 0A78 61 PUSH2 0x0a81 0A7B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A75 stack[0] = 0x0a7c } // Block ends with call to 0x0a81, returns to 0x0A7C label_0A7C: // Incoming return from call to 0x0A81 at 0x0A7B // Inputs[2] // { // @0A7F stack[-1] // @0A80 stack[-2] // } 0A7C 5B JUMPDEST 0A7D 60 PUSH1 0x05 0A7F 55 SSTORE 0A80 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A7F storage[0x05] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0A81: // Incoming call from 0x08D1, returns to 0x08D2 // Incoming call from 0x0973, returns to 0x0974 // Incoming call from 0x0A7B, returns to 0x0A7C // Incoming call from 0x07D1, returns to 0x07D2 // Inputs[2] // { // @0A84 storage[0x00] // @0A8E msg.sender // } 0A81 5B JUMPDEST 0A82 60 PUSH1 0x00 0A84 54 SLOAD 0A85 60 PUSH1 0x01 0A87 60 PUSH1 0x01 0A89 60 PUSH1 0xa0 0A8B 1B SHL 0A8C 03 SUB 0A8D 16 AND 0A8E 33 CALLER 0A8F 14 EQ 0A90 61 PUSH2 0x097e 0A93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x097e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0A94: // Incoming jump from 0x0A93, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0A96 memory[0x40:0x60] } 0A94 60 PUSH1 0x40 0A96 51 MLOAD 0A97 62 PUSH3 0x461bcd 0A9B 60 PUSH1 0xe5 0A9D 1B SHL 0A9E 81 DUP2 0A9F 52 MSTORE 0AA0 60 PUSH1 0x20 0AA2 60 PUSH1 0x04 0AA4 82 DUP3 0AA5 01 ADD 0AA6 81 DUP2 0AA7 90 SWAP1 0AA8 52 MSTORE 0AA9 60 PUSH1 0x24 0AAB 82 DUP3 0AAC 01 ADD 0AAD 52 MSTORE 0AAE 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0ACF 60 PUSH1 0x44 0AD1 82 DUP3 0AD2 01 ADD 0AD3 52 MSTORE 0AD4 60 PUSH1 0x64 0AD6 01 ADD 0AD7 61 PUSH2 0x0513 0ADA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AA8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AAD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0AD3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0AD6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0513 label_0ADB: // Incoming call from 0x097D, returns to 0x097E // Inputs[5] // { // @0ADF storage[0x00] // @0AE8 stack[-1] // @0AFC memory[0x40:0x60] // @0B27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B2A stack[-2] // } 0ADB 5B JUMPDEST 0ADC 60 PUSH1 0x00 0ADE 80 DUP1 0ADF 54 SLOAD 0AE0 60 PUSH1 0x01 0AE2 60 PUSH1 0x01 0AE4 60 PUSH1 0xa0 0AE6 1B SHL 0AE7 03 SUB 0AE8 83 DUP4 0AE9 81 DUP2 0AEA 16 AND 0AEB 60 PUSH1 0x01 0AED 60 PUSH1 0x01 0AEF 60 PUSH1 0xa0 0AF1 1B SHL 0AF2 03 SUB 0AF3 19 NOT 0AF4 83 DUP4 0AF5 16 AND 0AF6 81 DUP2 0AF7 17 OR 0AF8 84 DUP5 0AF9 55 SSTORE 0AFA 60 PUSH1 0x40 0AFC 51 MLOAD 0AFD 91 SWAP2 0AFE 90 SWAP1 0AFF 92 SWAP3 0B00 16 AND 0B01 92 SWAP3 0B02 83 DUP4 0B03 91 SWAP2 0B04 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0B25 91 SWAP2 0B26 90 SWAP1 0B27 A3 LOG3 0B28 50 POP 0B29 50 POP 0B2A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0AF9 storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @0B27 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_0B2B: // Incoming call from 0x09AB, returns to 0x09AC // Inputs[1] { @0B2E stack[-1] } 0B2B 5B JUMPDEST 0B2C 60 PUSH1 0x60 0B2E 81 DUP2 0B2F 60 PUSH1 0x00 0B31 03 SUB 0B32 61 PUSH2 0x0b52 0B35 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B2C stack[0] = 0x60 } // Block ends with conditional jump to 0x0b52, if 0x00 - stack[-1] label_0B36: // Incoming jump from 0x0B35, if not 0x00 - stack[-1] // Inputs[2] // { // @0B3B memory[0x40:0x60] // @0B50 stack[-3] // } 0B36 50 POP 0B37 50 POP 0B38 60 PUSH1 0x40 0B3A 80 DUP1 0B3B 51 MLOAD 0B3C 80 DUP1 0B3D 82 DUP3 0B3E 01 ADD 0B3F 90 SWAP1 0B40 91 SWAP2 0B41 52 MSTORE 0B42 60 PUSH1 0x01 0B44 81 DUP2 0B45 52 MSTORE 0B46 60 PUSH1 0x03 0B48 60 PUSH1 0xfc 0B4A 1B SHL 0B4B 60 PUSH1 0x20 0B4D 82 DUP3 0B4E 01 ADD 0B4F 52 MSTORE 0B50 90 SWAP1 0B51 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0B41 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0B45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0B4F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @0B50 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_0B52: // Incoming jump from 0x0B35, if 0x00 - stack[-1] // Inputs[1] { @0B53 stack[-2] } 0B52 5B JUMPDEST 0B53 81 DUP2 0B54 60 PUSH1 0x00 0B56 5B JUMPDEST 0B57 81 DUP2 0B58 15 ISZERO 0B59 61 PUSH2 0x0b7c 0B5C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B53 stack[0] = stack[-2] // @0B54 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0b7c, if !stack[-2] label_0B5D: // Incoming jump from 0x0B5C, if not !stack[-2] // Incoming jump from 0x0B5C, if not !stack[-2] // Inputs[1] { @0B5D stack[-1] } 0B5D 80 DUP1 0B5E 61 PUSH2 0x0b66 0B61 81 DUP2 0B62 61 PUSH2 0x10c7 0B65 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B5D stack[0] = stack[-1] // @0B5E stack[1] = 0x0b66 // @0B61 stack[2] = stack[-1] // } // Block ends with call to 0x10c7, returns to 0x0B66 label_0B66: // Incoming return from call to 0x10C7 at 0x0B65 // Inputs[4] // { // @0B67 stack[-3] // @0B67 stack[-1] // @0B6C stack[-2] // @0B70 stack[-4] // } 0B66 5B JUMPDEST 0B67 91 SWAP2 0B68 50 POP 0B69 61 PUSH2 0x0b75 0B6C 90 SWAP1 0B6D 50 POP 0B6E 60 PUSH1 0x0a 0B70 83 DUP4 0B71 61 PUSH2 0x12a8 0B74 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0B67 stack[-3] = stack[-1] // @0B6C stack[-2] = 0x0b75 // @0B6E stack[-1] = 0x0a // @0B70 stack[0] = stack[-4] // } // Block ends with call to 0x12a8, returns to 0x0B75 label_0B75: // Incoming return from call to 0x12A8 at 0x0B74 // Inputs[2] // { // @0B76 stack[-3] // @0B76 stack[-1] // } 0B75 5B JUMPDEST 0B76 91 SWAP2 0B77 50 POP 0B78 61 PUSH2 0x0b56 0B7B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B76 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0b56 label_0B7C: // Incoming jump from 0x0B5C, if !stack[-2] // Incoming jump from 0x0B5C, if !stack[-2] // Inputs[1] { @0B7F stack[-1] } 0B7C 5B JUMPDEST 0B7D 60 PUSH1 0x00 0B7F 81 DUP2 0B80 67 PUSH8 0xffffffffffffffff 0B89 81 DUP2 0B8A 11 GT 0B8B 15 ISZERO 0B8C 61 PUSH2 0x0b97 0B8F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B7D stack[0] = 0x00 // @0B7F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0b97, if !(stack[-1] > 0xffffffffffffffff) label_0B90: // Incoming jump from 0x0B8F, if not !(stack[-1] > 0xffffffffffffffff) 0B90 61 PUSH2 0x0b97 0B93 61 PUSH2 0x0d57 0B96 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B90 stack[0] = 0x0b97 } // Block ends with unconditional jump to 0x0d57 label_0B97: // Incoming jump from 0x0B8F, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0B9A memory[0x40:0x60] // @0B9B stack[-1] // } 0B97 5B JUMPDEST 0B98 60 PUSH1 0x40 0B9A 51 MLOAD 0B9B 90 SWAP1 0B9C 80 DUP1 0B9D 82 DUP3 0B9E 52 MSTORE 0B9F 80 DUP1 0BA0 60 PUSH1 0x1f 0BA2 01 ADD 0BA3 60 PUSH1 0x1f 0BA5 19 NOT 0BA6 16 AND 0BA7 60 PUSH1 0x20 0BA9 01 ADD 0BAA 82 DUP3 0BAB 01 ADD 0BAC 60 PUSH1 0x40 0BAE 52 MSTORE 0BAF 80 DUP1 0BB0 15 ISZERO 0BB1 61 PUSH2 0x0bc1 0BB4 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B9B stack[-1] = memory[0x40:0x60] // @0B9B stack[0] = stack[-1] // @0B9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0BAE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x0bc1, if !stack[-1] label_0BB5: // Incoming jump from 0x0BB4, if not !stack[-1] // Inputs[6] // { // @0BB7 stack[-2] // @0BB9 stack[-1] // @0BBB msg.data.length // @0BBD msg.data[msg.data.length:msg.data.length + stack[-1]] // @0BC3 stack[-3] // @0BC6 stack[-7] // } 0BB5 60 PUSH1 0x20 0BB7 82 DUP3 0BB8 01 ADD 0BB9 81 DUP2 0BBA 80 DUP1 0BBB 36 CALLDATASIZE 0BBC 83 DUP4 0BBD 37 CALLDATACOPY 0BBE 01 ADD 0BBF 90 SWAP1 0BC0 50 POP 0BC1 5B JUMPDEST 0BC2 50 POP 0BC3 90 SWAP1 0BC4 50 POP 0BC5 5B JUMPDEST 0BC6 84 DUP5 0BC7 15 ISZERO 0BC8 61 PUSH2 0x0c2c 0BCB 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0BBD memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @0BC3 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x0c2c, if !stack[-7] label_0BCC: // Incoming jump from 0x0BCB, if not !stack[-7] // Incoming jump from 0x0BCB, if not !stack[-5] // Incoming jump from 0x0BCB, if not !stack[-7] // Inputs[1] { @0BD1 stack[-2] } 0BCC 61 PUSH2 0x0bd6 0BCF 60 PUSH1 0x01 0BD1 83 DUP4 0BD2 61 PUSH2 0x12bc 0BD5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BCC stack[0] = 0x0bd6 // @0BCF stack[1] = 0x01 // @0BD1 stack[2] = stack[-2] // } // Block ends with call to 0x12bc, returns to 0x0BD6 label_0BD6: // Incoming return from call to 0x12BC at 0x0BD5 // Inputs[3] // { // @0BD7 stack[-3] // @0BD7 stack[-1] // @0BDE stack[-6] // } 0BD6 5B JUMPDEST 0BD7 91 SWAP2 0BD8 50 POP 0BD9 61 PUSH2 0x0be3 0BDC 60 PUSH1 0x0a 0BDE 86 DUP7 0BDF 61 PUSH2 0x12cf 0BE2 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0BD7 stack[-3] = stack[-1] // @0BD9 stack[-1] = 0x0be3 // @0BDC stack[0] = 0x0a // @0BDE stack[1] = stack[-6] // } // Block ends with call to 0x12cf, returns to 0x0BE3 label_0BE3: // Incoming return from call to 0x12CF at 0x0BE2 // Inputs[1] { @0BE7 stack[-1] } 0BE3 5B JUMPDEST 0BE4 61 PUSH2 0x0bee 0BE7 90 SWAP1 0BE8 60 PUSH1 0x30 0BEA 61 PUSH2 0x12e3 0BED 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BE7 stack[0] = stack[-1] // @0BE7 stack[-1] = 0x0bee // @0BE8 stack[1] = 0x30 // } // Block ends with call to 0x12e3, returns to 0x0BEE label_0BEE: // Incoming return from call to 0x12E3 at 0x0BED // Inputs[4] // { // @0BF1 stack[-1] // @0BF2 stack[-2] // @0BF3 stack[-3] // @0BF5 memory[stack[-2]:stack[-2] + 0x20] // } 0BEE 5B JUMPDEST 0BEF 60 PUSH1 0xf8 0BF1 1B SHL 0BF2 81 DUP2 0BF3 83 DUP4 0BF4 81 DUP2 0BF5 51 MLOAD 0BF6 81 DUP2 0BF7 10 LT 0BF8 61 PUSH2 0x0c03 0BFB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0BF1 stack[-1] = stack[-1] << 0xf8 // @0BF2 stack[0] = stack[-2] // @0BF3 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0c03, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_0BFC: // Incoming jump from 0x0BFB, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 0BFC 61 PUSH2 0x0c03 0BFF 61 PUSH2 0x109b 0C02 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BFC stack[0] = 0x0c03 } // Block ends with unconditional jump to 0x109b label_0C03: // Incoming jump from 0x0BFB, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @0C06 stack[-1] // @0C07 stack[-2] // @0C08 stack[-3] // @0C20 stack[-8] // } 0C03 5B JUMPDEST 0C04 60 PUSH1 0x20 0C06 01 ADD 0C07 01 ADD 0C08 90 SWAP1 0C09 60 PUSH1 0x01 0C0B 60 PUSH1 0x01 0C0D 60 PUSH1 0xf8 0C0F 1B SHL 0C10 03 SUB 0C11 19 NOT 0C12 16 AND 0C13 90 SWAP1 0C14 81 DUP2 0C15 60 PUSH1 0x00 0C17 1A BYTE 0C18 90 SWAP1 0C19 53 MSTORE8 0C1A 50 POP 0C1B 61 PUSH2 0x0c25 0C1E 60 PUSH1 0x0a 0C20 86 DUP7 0C21 61 PUSH2 0x12a8 0C24 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0C19 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @0C1B stack[-3] = 0x0c25 // @0C1E stack[-2] = 0x0a // @0C20 stack[-1] = stack[-8] // } // Block ends with call to 0x12a8, returns to 0x0C25 label_0C25: // Incoming return from call to 0x12A8 at 0x0C24 // Inputs[2] // { // @0C26 stack[-1] // @0C26 stack[-6] // } 0C25 5B JUMPDEST 0C26 94 SWAP5 0C27 50 POP 0C28 61 PUSH2 0x0bc5 0C2B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C26 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x0bc5 label_0C2C: // Incoming jump from 0x0BCB, if !stack[-7] // Incoming jump from 0x0BCB, if !stack[-5] // Incoming jump from 0x0BCB, if !stack[-7] // Inputs[3] // { // @0C2D stack[-1] // @0C2D stack[-6] // @0C2E stack[-5] // } 0C2C 5B JUMPDEST 0C2D 94 SWAP5 0C2E 93 SWAP4 0C2F 50 POP 0C30 50 POP 0C31 50 POP 0C32 50 POP 0C33 56 *JUMP // Stack delta = -5 // Outputs[1] { @0C2D stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0C34: // Incoming call from 0x01E1, returns to 0x01E2 // Inputs[2] // { // @0C39 stack[-1] // @0C3A stack[-2] // } 0C34 5B JUMPDEST 0C35 60 PUSH1 0x00 0C37 60 PUSH1 0x20 0C39 82 DUP3 0C3A 84 DUP5 0C3B 03 SUB 0C3C 12 SLT 0C3D 15 ISZERO 0C3E 61 PUSH2 0x0c46 0C41 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C35 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c46, if !(stack[-2] - stack[-1] i< 0x20) label_0C42: // Incoming jump from 0x0C41, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0C45 memory[0x00:0x00] } 0C42 60 PUSH1 0x00 0C44 80 DUP1 0C45 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C45 revert(memory[0x00:0x00]); } // Block terminates label_0C46: // Incoming jump from 0x0C41, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0C47 stack[-2] // @0C48 msg.data[stack[-2]:stack[-2] + 0x20] // } 0C46 5B JUMPDEST 0C47 81 DUP2 0C48 35 CALLDATALOAD 0C49 60 PUSH1 0x01 0C4B 60 PUSH1 0x01 0C4D 60 PUSH1 0xe0 0C4F 1B SHL 0C50 03 SUB 0C51 19 NOT 0C52 81 DUP2 0C53 16 AND 0C54 81 DUP2 0C55 14 EQ 0C56 61 PUSH2 0x0c5e 0C59 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C48 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0c5e, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) label_0C5A: // Incoming jump from 0x0C59, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0C5D memory[0x00:0x00] } 0C5A 60 PUSH1 0x00 0C5C 80 DUP1 0C5D FD *REVERT // Stack delta = +0 // Outputs[1] { @0C5D revert(memory[0x00:0x00]); } // Block terminates label_0C5E: // Incoming return from call to 0x0EEE at 0x100E // Incoming return from call to 0x0CD5 at 0x0F54 // Incoming jump from 0x0C59, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x0CD5 at 0x120A // Inputs[3] // { // @0C5F stack[-1] // @0C5F stack[-5] // @0C60 stack[-4] // } 0C5E 5B JUMPDEST 0C5F 93 SWAP4 0C60 92 SWAP3 0C61 50 POP 0C62 50 POP 0C63 50 POP 0C64 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C5F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0C65: // Incoming call from 0x1288, returns to 0x1289 // Incoming call from 0x0CA7, returns to 0x0CA8 // Inputs[1] { @0C69 stack[-3] } 0C65 5B JUMPDEST 0C66 60 PUSH1 0x00 0C68 5B JUMPDEST 0C69 83 DUP4 0C6A 81 DUP2 0C6B 10 LT 0C6C 15 ISZERO 0C6D 61 PUSH2 0x0c80 0C70 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C66 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c80, if !(0x00 < stack[-3]) label_0C71: // Incoming jump from 0x0C70, if not !(0x00 < stack[-3]) // Incoming jump from 0x0C70, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0C71 stack[-2] // @0C72 stack[-1] // @0C74 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0C75 stack[-3] // } 0C71 81 DUP2 0C72 81 DUP2 0C73 01 ADD 0C74 51 MLOAD 0C75 83 DUP4 0C76 82 DUP3 0C77 01 ADD 0C78 52 MSTORE 0C79 60 PUSH1 0x20 0C7B 01 ADD 0C7C 61 PUSH2 0x0c68 0C7F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C78 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0C7B stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0c68 label_0C80: // Incoming jump from 0x0C70, if !(0x00 < stack[-3]) // Incoming jump from 0x0C70, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0C85 stack[-4] // @0C86 stack[-3] // @0C88 stack[-5] // } 0C80 5B JUMPDEST 0C81 50 POP 0C82 50 POP 0C83 60 PUSH1 0x00 0C85 91 SWAP2 0C86 01 ADD 0C87 52 MSTORE 0C88 56 *JUMP // Stack delta = -5 // Outputs[1] { @0C87 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0C89: // Incoming call from 0x0210, returns to 0x01F3 // Inputs[3] // { // @0C8C stack[-1] // @0C90 stack[-2] // @0C91 memory[stack[-2]:stack[-2] + 0x20] // } 0C89 5B JUMPDEST 0C8A 60 PUSH1 0x20 0C8C 81 DUP2 0C8D 52 MSTORE 0C8E 60 PUSH1 0x00 0C90 82 DUP3 0C91 51 MLOAD 0C92 80 DUP1 0C93 60 PUSH1 0x20 0C95 84 DUP5 0C96 01 ADD 0C97 52 MSTORE 0C98 61 PUSH2 0x0ca8 0C9B 81 DUP2 0C9C 60 PUSH1 0x40 0C9E 85 DUP6 0C9F 01 ADD 0CA0 60 PUSH1 0x20 0CA2 87 DUP8 0CA3 01 ADD 0CA4 61 PUSH2 0x0c65 0CA7 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0C8D memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0C8E stack[0] = 0x00 // @0C91 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0C97 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0C98 stack[2] = 0x0ca8 // @0C9B stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0C9F stack[4] = stack[-1] + 0x40 // @0CA3 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x0c65, returns to 0x0CA8 label_0CA8: // Incoming return from call to 0x0C65 at 0x0CA7 // Inputs[5] // { // @0CAB stack[-1] // @0CB0 stack[-3] // @0CB1 stack[-2] // @0CB7 stack[-5] // @0CB8 stack[-4] // } 0CA8 5B JUMPDEST 0CA9 60 PUSH1 0x1f 0CAB 01 ADD 0CAC 60 PUSH1 0x1f 0CAE 19 NOT 0CAF 16 AND 0CB0 91 SWAP2 0CB1 90 SWAP1 0CB2 91 SWAP2 0CB3 01 ADD 0CB4 60 PUSH1 0x40 0CB6 01 ADD 0CB7 92 SWAP3 0CB8 91 SWAP2 0CB9 50 POP 0CBA 50 POP 0CBB 56 *JUMP // Stack delta = -4 // Outputs[1] { @0CB7 stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] label_0CBC: // Incoming call from 0x03FA, returns to 0x03FB // Incoming call from 0x02E5, returns to 0x02E6 // Incoming call from 0x0373, returns to 0x0374 // Incoming call from 0x021E, returns to 0x021F // Inputs[2] // { // @0CC1 stack[-1] // @0CC2 stack[-2] // } 0CBC 5B JUMPDEST 0CBD 60 PUSH1 0x00 0CBF 60 PUSH1 0x20 0CC1 82 DUP3 0CC2 84 DUP5 0CC3 03 SUB 0CC4 12 SLT 0CC5 15 ISZERO 0CC6 61 PUSH2 0x0cce 0CC9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CBD stack[0] = 0x00 } // Block ends with conditional jump to 0x0cce, if !(stack[-2] - stack[-1] i< 0x20) label_0CCA: // Incoming jump from 0x0CC9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0CCD memory[0x00:0x00] } 0CCA 60 PUSH1 0x00 0CCC 80 DUP1 0CCD FD *REVERT // Stack delta = +0 // Outputs[1] { @0CCD revert(memory[0x00:0x00]); } // Block terminates label_0CCE: // Incoming jump from 0x0CC9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @0CD0 msg.data[stack[-2]:stack[-2] + 0x20] // @0CD0 stack[-2] // @0CD1 stack[-4] // @0CD2 stack[-3] // } 0CCE 5B JUMPDEST 0CCF 50 POP 0CD0 35 CALLDATALOAD 0CD1 91 SWAP2 0CD2 90 SWAP1 0CD3 50 POP 0CD4 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CD1 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0CD5: // Incoming call from 0x0F77, returns to 0x0F78 // Incoming call from 0x0DBB, returns to 0x0DBC // Incoming call from 0x0D45, returns to 0x0D46 // Incoming call from 0x0F20, returns to 0x0F21 // Incoming call from 0x0D35, returns to 0x0D36 // Incoming call from 0x103C, returns to 0x103D // Incoming call from 0x0F87, returns to 0x0F88 // Incoming call from 0x120A, returns to 0x0C5E // Incoming call from 0x0D07, returns to 0x0D08 // Incoming call from 0x0F54, returns to 0x0C5E // Incoming call from 0x102C, returns to 0x102D // Inputs[1] { @0CDE stack[-1] } 0CD5 5B JUMPDEST 0CD6 60 PUSH1 0x01 0CD8 60 PUSH1 0x01 0CDA 60 PUSH1 0xa0 0CDC 1B SHL 0CDD 03 SUB 0CDE 81 DUP2 0CDF 16 AND 0CE0 81 DUP2 0CE1 14 EQ 0CE2 61 PUSH2 0x0a71 0CE5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a71, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_0CE6: // Incoming jump from 0x0CE5, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CE9 memory[0x00:0x00] } 0CE6 60 PUSH1 0x00 0CE8 80 DUP1 0CE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CE9 revert(memory[0x00:0x00]); } // Block terminates label_0CEA: // Incoming call from 0x0291, returns to 0x0292 // Incoming call from 0x024A, returns to 0x024B // Inputs[2] // { // @0CF0 stack[-1] // @0CF1 stack[-2] // } 0CEA 5B JUMPDEST 0CEB 60 PUSH1 0x00 0CED 80 DUP1 0CEE 60 PUSH1 0x40 0CF0 83 DUP4 0CF1 85 DUP6 0CF2 03 SUB 0CF3 12 SLT 0CF4 15 ISZERO 0CF5 61 PUSH2 0x0cfd 0CF8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CEB stack[0] = 0x00 // @0CED stack[1] = 0x00 // } // Block ends with conditional jump to 0x0cfd, if !(stack[-2] - stack[-1] i< 0x40) label_0CF9: // Incoming jump from 0x0CF8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0CFC memory[0x00:0x00] } 0CF9 60 PUSH1 0x00 0CFB 80 DUP1 0CFC FD *REVERT // Stack delta = +0 // Outputs[1] { @0CFC revert(memory[0x00:0x00]); } // Block terminates label_0CFD: // Incoming jump from 0x0CF8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0CFE stack[-3] // @0CFF msg.data[stack[-3]:stack[-3] + 0x20] // } 0CFD 5B JUMPDEST 0CFE 82 DUP3 0CFF 35 CALLDATALOAD 0D00 61 PUSH2 0x0d08 0D03 81 DUP2 0D04 61 PUSH2 0x0cd5 0D07 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CFF stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @0D00 stack[1] = 0x0d08 // @0D03 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0D08 label_0D08: // Incoming return from call to 0x0CD5 at 0x0D07 // Inputs[5] // { // @0D09 stack[-6] // @0D09 stack[-1] // @0D0C stack[-4] // @0D10 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @0D11 stack[-5] // } 0D08 5B JUMPDEST 0D09 94 SWAP5 0D0A 60 PUSH1 0x20 0D0C 93 SWAP4 0D0D 90 SWAP1 0D0E 93 SWAP4 0D0F 01 ADD 0D10 35 CALLDATALOAD 0D11 93 SWAP4 0D12 50 POP 0D13 50 POP 0D14 50 POP 0D15 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0D09 stack[-6] = stack[-1] // @0D11 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_0D16: // Incoming call from 0x0275, returns to 0x0276 // Incoming call from 0x02A4, returns to 0x02A5 // Inputs[2] // { // @0D1E stack[-1] // @0D1F stack[-2] // } 0D16 5B JUMPDEST 0D17 60 PUSH1 0x00 0D19 80 DUP1 0D1A 60 PUSH1 0x00 0D1C 60 PUSH1 0x60 0D1E 84 DUP5 0D1F 86 DUP7 0D20 03 SUB 0D21 12 SLT 0D22 15 ISZERO 0D23 61 PUSH2 0x0d2b 0D26 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D17 stack[0] = 0x00 // @0D19 stack[1] = 0x00 // @0D1A stack[2] = 0x00 // } // Block ends with conditional jump to 0x0d2b, if !(stack[-2] - stack[-1] i< 0x60) label_0D27: // Incoming jump from 0x0D26, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @0D2A memory[0x00:0x00] } 0D27 60 PUSH1 0x00 0D29 80 DUP1 0D2A FD *REVERT // Stack delta = +0 // Outputs[1] { @0D2A revert(memory[0x00:0x00]); } // Block terminates label_0D2B: // Incoming jump from 0x0D26, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @0D2C stack[-4] // @0D2D msg.data[stack[-4]:stack[-4] + 0x20] // } 0D2B 5B JUMPDEST 0D2C 83 DUP4 0D2D 35 CALLDATALOAD 0D2E 61 PUSH2 0x0d36 0D31 81 DUP2 0D32 61 PUSH2 0x0cd5 0D35 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D2D stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @0D2E stack[1] = 0x0d36 // @0D31 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0D36 label_0D36: // Incoming return from call to 0x0CD5 at 0x0D35 // Inputs[4] // { // @0D37 stack[-1] // @0D37 stack[-4] // @0D3B stack[-5] // @0D3D msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 0D36 5B JUMPDEST 0D37 92 SWAP3 0D38 50 POP 0D39 60 PUSH1 0x20 0D3B 84 DUP5 0D3C 01 ADD 0D3D 35 CALLDATALOAD 0D3E 61 PUSH2 0x0d46 0D41 81 DUP2 0D42 61 PUSH2 0x0cd5 0D45 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0D37 stack[-4] = stack[-1] // @0D3D stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @0D3E stack[0] = 0x0d46 // @0D41 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0D46 label_0D46: // Incoming return from call to 0x0CD5 at 0x0D45 // Inputs[6] // { // @0D47 stack[-4] // @0D47 stack[-1] // @0D48 stack[-7] // @0D4A stack[-6] // @0D50 stack[-5] // @0D54 msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 0D46 5B JUMPDEST 0D47 92 SWAP3 0D48 95 SWAP6 0D49 92 SWAP3 0D4A 94 SWAP5 0D4B 50 POP 0D4C 50 POP 0D4D 50 POP 0D4E 60 PUSH1 0x40 0D50 91 SWAP2 0D51 90 SWAP1 0D52 91 SWAP2 0D53 01 ADD 0D54 35 CALLDATALOAD 0D55 90 SWAP1 0D56 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0D48 stack[-7] = stack[-4] // @0D4A stack[-6] = stack[-1] // @0D55 stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_0D57: // Incoming jump from 0x0DFF // Incoming jump from 0x0B96 // Incoming jump from 0x0EA9 // Incoming jump from 0x1147 // Incoming jump from 0x0D95 // Inputs[1] { @0D6C memory[0x00:0x24] } 0D57 5B JUMPDEST 0D58 63 PUSH4 0x4e487b71 0D5D 60 PUSH1 0xe0 0D5F 1B SHL 0D60 60 PUSH1 0x00 0D62 52 MSTORE 0D63 60 PUSH1 0x41 0D65 60 PUSH1 0x04 0D67 52 MSTORE 0D68 60 PUSH1 0x24 0D6A 60 PUSH1 0x00 0D6C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0D62 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0D67 memory[0x04:0x24] = 0x41 // @0D6C revert(memory[0x00:0x24]); // } // Block terminates label_0D6D: // Incoming call from 0x0E10, returns to 0x0E11 // Incoming call from 0x0EBB, returns to 0x0EBC // Inputs[2] // { // @0D70 memory[0x40:0x60] // @0D73 stack[-1] // } 0D6D 5B JUMPDEST 0D6E 60 PUSH1 0x40 0D70 51 MLOAD 0D71 60 PUSH1 0x1f 0D73 82 DUP3 0D74 01 ADD 0D75 60 PUSH1 0x1f 0D77 19 NOT 0D78 16 AND 0D79 81 DUP2 0D7A 01 ADD 0D7B 67 PUSH8 0xffffffffffffffff 0D84 81 DUP2 0D85 11 GT 0D86 82 DUP3 0D87 82 DUP3 0D88 10 LT 0D89 17 OR 0D8A 15 ISZERO 0D8B 61 PUSH2 0x0d96 0D8E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D70 stack[0] = memory[0x40:0x60] // @0D7A stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x0d96, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_0D8F: // Incoming jump from 0x0D8E, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 0D8F 61 PUSH2 0x0d96 0D92 61 PUSH2 0x0d57 0D95 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D8F stack[0] = 0x0d96 } // Block ends with unconditional jump to 0x0d57 label_0D96: // Incoming jump from 0x0D8E, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @0D99 stack[-1] // @0D9A stack[-2] // @0D9A stack[-4] // @0D9B stack[-3] // } 0D96 5B JUMPDEST 0D97 60 PUSH1 0x40 0D99 52 MSTORE 0D9A 91 SWAP2 0D9B 90 SWAP1 0D9C 50 POP 0D9D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0D99 memory[0x40:0x60] = stack[-1] // @0D9A stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_0D9E: // Incoming call from 0x02B7, returns to 0x02B8 // Inputs[2] // { // @0DA4 stack[-1] // @0DA5 stack[-2] // } 0D9E 5B JUMPDEST 0D9F 60 PUSH1 0x00 0DA1 80 DUP1 0DA2 60 PUSH1 0x40 0DA4 83 DUP4 0DA5 85 DUP6 0DA6 03 SUB 0DA7 12 SLT 0DA8 15 ISZERO 0DA9 61 PUSH2 0x0db1 0DAC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D9F stack[0] = 0x00 // @0DA1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0db1, if !(stack[-2] - stack[-1] i< 0x40) label_0DAD: // Incoming jump from 0x0DAC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0DB0 memory[0x00:0x00] } 0DAD 60 PUSH1 0x00 0DAF 80 DUP1 0DB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DB0 revert(memory[0x00:0x00]); } // Block terminates label_0DB1: // Incoming jump from 0x0DAC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0DB2 stack[-3] // @0DB3 msg.data[stack[-3]:stack[-3] + 0x20] // } 0DB1 5B JUMPDEST 0DB2 82 DUP3 0DB3 35 CALLDATALOAD 0DB4 61 PUSH2 0x0dbc 0DB7 81 DUP2 0DB8 61 PUSH2 0x0cd5 0DBB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DB3 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @0DB4 stack[1] = 0x0dbc // @0DB7 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0DBC label_0DBC: // Incoming return from call to 0x0CD5 at 0x0DBB // Inputs[4] // { // @0DBD stack[-3] // @0DBD stack[-1] // @0DC1 stack[-4] // @0DC4 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } 0DBC 5B JUMPDEST 0DBD 91 SWAP2 0DBE 50 POP 0DBF 60 PUSH1 0x20 0DC1 83 DUP4 0DC2 81 DUP2 0DC3 01 ADD 0DC4 35 CALLDATALOAD 0DC5 67 PUSH8 0xffffffffffffffff 0DCE 80 DUP1 0DCF 82 DUP3 0DD0 11 GT 0DD1 15 ISZERO 0DD2 61 PUSH2 0x0dda 0DD5 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0DBD stack[-3] = stack[-1] // @0DBF stack[-1] = 0x20 // @0DC4 stack[0] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @0DC5 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0dda, if !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) label_0DD6: // Incoming jump from 0x0DD5, if not !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0DD9 memory[0x00:0x00] } 0DD6 60 PUSH1 0x00 0DD8 80 DUP1 0DD9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DD9 revert(memory[0x00:0x00]); } // Block terminates label_0DDA: // Incoming jump from 0x0DD5, if !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0DDB stack[-2] // @0DDC stack[-6] // @0DE0 stack[-7] // } 0DDA 5B JUMPDEST 0DDB 81 DUP2 0DDC 86 DUP7 0DDD 01 ADD 0DDE 91 SWAP2 0DDF 50 POP 0DE0 86 DUP7 0DE1 60 PUSH1 0x1f 0DE3 83 DUP4 0DE4 01 ADD 0DE5 12 SLT 0DE6 61 PUSH2 0x0dee 0DE9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DDE stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x0dee, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_0DEA: // Incoming jump from 0x0DE9, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @0DED memory[0x00:0x00] } 0DEA 60 PUSH1 0x00 0DEC 80 DUP1 0DED FD *REVERT // Stack delta = +0 // Outputs[1] { @0DED revert(memory[0x00:0x00]); } // Block terminates label_0DEE: // Incoming jump from 0x0DE9, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @0DEF stack[-2] // @0DF0 msg.data[stack[-2]:stack[-2] + 0x20] // @0DF1 stack[-1] // } 0DEE 5B JUMPDEST 0DEF 81 DUP2 0DF0 35 CALLDATALOAD 0DF1 81 DUP2 0DF2 81 DUP2 0DF3 11 GT 0DF4 15 ISZERO 0DF5 61 PUSH2 0x0e00 0DF8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DF0 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0e00, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0DF9: // Incoming jump from 0x0DF8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 0DF9 61 PUSH2 0x0e00 0DFC 61 PUSH2 0x0d57 0DFF 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DF9 stack[0] = 0x0e00 } // Block ends with unconditional jump to 0x0d57 label_0E00: // Incoming jump from 0x0DF8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0E01 stack[-1] // @0E05 stack[-2] // @0E0A stack[-4] // } 0E00 5B JUMPDEST 0E01 80 DUP1 0E02 60 PUSH1 0x05 0E04 1B SHL 0E05 91 SWAP2 0E06 50 POP 0E07 61 PUSH2 0x0e11 0E0A 84 DUP5 0E0B 83 DUP4 0E0C 01 ADD 0E0D 61 PUSH2 0x0d6d 0E10 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E05 stack[-2] = stack[-1] << 0x05 // @0E07 stack[0] = 0x0e11 // @0E0C stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x0d6d, returns to 0x0E11 label_0E11: // Incoming return from call to 0x0D6D at 0x0E10 // Inputs[6] // { // @0E12 stack[-2] // @0E13 stack[-1] // @0E15 stack[-3] // @0E16 stack[-4] // @0E18 stack[-5] // @0E1F stack[-9] // } 0E11 5B JUMPDEST 0E12 81 DUP2 0E13 81 DUP2 0E14 52 MSTORE 0E15 91 SWAP2 0E16 83 DUP4 0E17 01 ADD 0E18 84 DUP5 0E19 01 ADD 0E1A 91 SWAP2 0E1B 84 DUP5 0E1C 81 DUP2 0E1D 01 ADD 0E1E 90 SWAP1 0E1F 89 DUP10 0E20 84 DUP5 0E21 11 GT 0E22 15 ISZERO 0E23 61 PUSH2 0x0e2b 0E26 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0E14 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @0E1A stack[-3] = stack[-5] + stack[-4] + stack[-3] // @0E1E stack[-1] = stack[-1] + stack[-5] // @0E1E stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0e2b, if !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) label_0E27: // Incoming jump from 0x0E26, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) // Inputs[1] { @0E2A memory[0x00:0x00] } 0E27 60 PUSH1 0x00 0E29 80 DUP1 0E2A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E2A revert(memory[0x00:0x00]); } // Block terminates label_0E2B: // Incoming jump from 0x0E26, if !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) // Inputs[4] // { // @0E2C stack[-5] // @0E2C stack[-1] // @0E2D stack[-6] // @0E31 stack[-4] // } 0E2B 5B JUMPDEST 0E2C 93 SWAP4 0E2D 85 DUP6 0E2E 01 ADD 0E2F 93 SWAP4 0E30 5B JUMPDEST 0E31 83 DUP4 0E32 85 DUP6 0E33 10 LT 0E34 15 ISZERO 0E35 61 PUSH2 0x0e49 0E38 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E2F stack[-5] = stack[-6] + stack[-5] // @0E2F stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x0e49, if !(stack[-6] + stack[-5] < stack[-4]) label_0E39: // Incoming jump from 0x0E38, if not !(stack[-5] < stack[-4]) // Incoming jump from 0x0E38, if not !(stack[-6] + stack[-5] < stack[-4]) // Inputs[5] // { // @0E39 stack[-5] // @0E3A msg.data[stack[-5]:stack[-5] + 0x20] // @0E3B stack[-2] // @0E3D stack[-1] // @0E3E stack[-6] // } 0E39 84 DUP5 0E3A 35 CALLDATALOAD 0E3B 82 DUP3 0E3C 52 MSTORE 0E3D 93 SWAP4 0E3E 85 DUP6 0E3F 01 ADD 0E40 93 SWAP4 0E41 90 SWAP1 0E42 85 DUP6 0E43 01 ADD 0E44 90 SWAP1 0E45 61 PUSH2 0x0e30 0E48 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0E3C memory[stack[-2]:stack[-2] + 0x20] = msg.data[stack[-5]:stack[-5] + 0x20] // @0E40 stack[-5] = stack[-6] + stack[-5] // @0E44 stack[-1] = stack[-1] // @0E44 stack[-2] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x0e30 label_0E49: // Incoming jump from 0x0E38, if !(stack[-5] < stack[-4]) // Incoming jump from 0x0E38, if !(stack[-6] + stack[-5] < stack[-4]) // Inputs[6] // { // @0E4A stack[-1] // @0E4B stack[-7] // @0E53 stack[-10] // @0E55 stack[-11] // @0E55 stack[-8] // @0E56 stack[-9] // } 0E49 5B JUMPDEST 0E4A 80 DUP1 0E4B 96 SWAP7 0E4C 50 POP 0E4D 50 POP 0E4E 50 POP 0E4F 50 POP 0E50 50 POP 0E51 50 POP 0E52 50 POP 0E53 92 SWAP3 0E54 50 POP 0E55 92 SWAP3 0E56 90 SWAP1 0E57 50 POP 0E58 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @0E53 stack[-10] = stack[-1] // @0E55 stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_0E59: // Incoming call from 0x02D2, returns to 0x02D3 // Inputs[2] // { // @0E5F stack[-1] // @0E60 stack[-2] // } 0E59 5B JUMPDEST 0E5A 60 PUSH1 0x00 0E5C 60 PUSH1 0x20 0E5E 80 DUP1 0E5F 83 DUP4 0E60 85 DUP6 0E61 03 SUB 0E62 12 SLT 0E63 15 ISZERO 0E64 61 PUSH2 0x0e6c 0E67 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E5A stack[0] = 0x00 // @0E5C stack[1] = 0x20 // } // Block ends with conditional jump to 0x0e6c, if !(stack[-2] - stack[-1] i< 0x20) label_0E68: // Incoming jump from 0x0E67, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0E6B memory[0x00:0x00] } 0E68 60 PUSH1 0x00 0E6A 80 DUP1 0E6B FD *REVERT // Stack delta = +0 // Outputs[1] { @0E6B revert(memory[0x00:0x00]); } // Block terminates label_0E6C: // Incoming jump from 0x0E67, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0E6D stack[-3] // @0E6E msg.data[stack[-3]:stack[-3] + 0x20] // } 0E6C 5B JUMPDEST 0E6D 82 DUP3 0E6E 35 CALLDATALOAD 0E6F 67 PUSH8 0xffffffffffffffff 0E78 80 DUP1 0E79 82 DUP3 0E7A 11 GT 0E7B 15 ISZERO 0E7C 61 PUSH2 0x0e84 0E7F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E6E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @0E6F stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0e84, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_0E80: // Incoming jump from 0x0E7F, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0E83 memory[0x00:0x00] } 0E80 60 PUSH1 0x00 0E82 80 DUP1 0E83 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E83 revert(memory[0x00:0x00]); } // Block terminates label_0E84: // Incoming jump from 0x0E7F, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0E85 stack[-2] // @0E86 stack[-5] // @0E8A stack[-6] // } 0E84 5B JUMPDEST 0E85 81 DUP2 0E86 85 DUP6 0E87 01 ADD 0E88 91 SWAP2 0E89 50 POP 0E8A 85 DUP6 0E8B 60 PUSH1 0x1f 0E8D 83 DUP4 0E8E 01 ADD 0E8F 12 SLT 0E90 61 PUSH2 0x0e98 0E93 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E88 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x0e98, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_0E94: // Incoming jump from 0x0E93, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @0E97 memory[0x00:0x00] } 0E94 60 PUSH1 0x00 0E96 80 DUP1 0E97 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E97 revert(memory[0x00:0x00]); } // Block terminates label_0E98: // Incoming jump from 0x0E93, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @0E99 stack[-2] // @0E9A msg.data[stack[-2]:stack[-2] + 0x20] // @0E9B stack[-1] // } 0E98 5B JUMPDEST 0E99 81 DUP2 0E9A 35 CALLDATALOAD 0E9B 81 DUP2 0E9C 81 DUP2 0E9D 11 GT 0E9E 15 ISZERO 0E9F 61 PUSH2 0x0eaa 0EA2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E9A stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0eaa, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0EA3: // Incoming jump from 0x0EA2, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 0EA3 61 PUSH2 0x0eaa 0EA6 61 PUSH2 0x0d57 0EA9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EA3 stack[0] = 0x0eaa } // Block ends with unconditional jump to 0x0d57 label_0EAA: // Incoming jump from 0x0EA2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @0EB0 stack[-1] // @0EB6 stack[-4] // } 0EAA 5B JUMPDEST 0EAB 61 PUSH2 0x0ebc 0EAE 60 PUSH1 0x1f 0EB0 82 DUP3 0EB1 01 ADD 0EB2 60 PUSH1 0x1f 0EB4 19 NOT 0EB5 16 AND 0EB6 85 DUP6 0EB7 01 ADD 0EB8 61 PUSH2 0x0d6d 0EBB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EAB stack[0] = 0x0ebc // @0EB7 stack[1] = stack[-4] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with call to 0x0d6d, returns to 0x0EBC label_0EBC: // Incoming return from call to 0x0D6D at 0x0EBB // Inputs[6] // { // @0EBD stack[-1] // @0EBD stack[-3] // @0EBF stack[-2] // @0EC2 stack[-8] // @0EC3 stack[-5] // @0EC5 stack[-4] // } 0EBC 5B JUMPDEST 0EBD 91 SWAP2 0EBE 50 POP 0EBF 80 DUP1 0EC0 82 DUP3 0EC1 52 MSTORE 0EC2 86 DUP7 0EC3 84 DUP5 0EC4 82 DUP3 0EC5 85 DUP6 0EC6 01 ADD 0EC7 01 ADD 0EC8 11 GT 0EC9 15 ISZERO 0ECA 61 PUSH2 0x0ed2 0ECD 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0EBD stack[-3] = stack[-1] // @0EC1 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // } // Block ends with conditional jump to 0x0ed2, if !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) label_0ECE: // Incoming jump from 0x0ECD, if not !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) // Inputs[1] { @0ED1 memory[0x00:0x00] } 0ECE 60 PUSH1 0x00 0ED0 80 DUP1 0ED1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0ED1 revert(memory[0x00:0x00]); } // Block terminates label_0ED2: // Incoming jump from 0x0ECD, if !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) // Inputs[7] // { // @0ED3 stack[-1] // @0ED4 stack[-4] // @0ED5 stack[-3] // @0ED8 stack[-2] // @0EDA msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @0EE8 stack[-8] // @0EE9 stack[-7] // } 0ED2 5B JUMPDEST 0ED3 80 DUP1 0ED4 84 DUP5 0ED5 84 DUP5 0ED6 01 ADD 0ED7 85 DUP6 0ED8 84 DUP5 0ED9 01 ADD 0EDA 37 CALLDATACOPY 0EDB 60 PUSH1 0x00 0EDD 90 SWAP1 0EDE 82 DUP3 0EDF 01 ADD 0EE0 90 SWAP1 0EE1 93 SWAP4 0EE2 01 ADD 0EE3 92 SWAP3 0EE4 90 SWAP1 0EE5 92 SWAP3 0EE6 52 MSTORE 0EE7 50 POP 0EE8 93 SWAP4 0EE9 92 SWAP3 0EEA 50 POP 0EEB 50 POP 0EEC 50 POP 0EED 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @0EDA memory[stack[-2] + stack[-4]:stack[-2] + stack[-4] + stack[-1]] = msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @0EE6 memory[stack[-4] + stack[-2] + stack[-1]:stack[-4] + stack[-2] + stack[-1] + 0x20] = 0x00 // @0EE8 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-8] label_0EEE: // Incoming call from 0x100E, returns to 0x0C5E // Incoming call from 0x0F2E, returns to 0x0F2F // Inputs[2] // { // @0EEF stack[-1] // @0EF0 msg.data[stack[-1]:stack[-1] + 0x20] // } 0EEE 5B JUMPDEST 0EEF 80 DUP1 0EF0 35 CALLDATALOAD 0EF1 80 DUP1 0EF2 15 ISZERO 0EF3 15 ISZERO 0EF4 81 DUP2 0EF5 14 EQ 0EF6 61 PUSH2 0x0efe 0EF9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EF0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0efe, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_0EFA: // Incoming jump from 0x0EF9, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0EFD memory[0x00:0x00] } 0EFA 60 PUSH1 0x00 0EFC 80 DUP1 0EFD FD *REVERT // Stack delta = +0 // Outputs[1] { @0EFD revert(memory[0x00:0x00]); } // Block terminates label_0EFE: // Incoming jump from 0x0EF9, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @0EFF stack[-1] // @0EFF stack[-3] // @0F00 stack[-2] // } 0EFE 5B JUMPDEST 0EFF 91 SWAP2 0F00 90 SWAP1 0F01 50 POP 0F02 56 *JUMP // Stack delta = -2 // Outputs[1] { @0EFF stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0F03: // Incoming call from 0x02F8, returns to 0x02F9 // Incoming call from 0x0352, returns to 0x024B // Inputs[2] // { // @0F09 stack[-1] // @0F0A stack[-2] // } 0F03 5B JUMPDEST 0F04 60 PUSH1 0x00 0F06 80 DUP1 0F07 60 PUSH1 0x40 0F09 83 DUP4 0F0A 85 DUP6 0F0B 03 SUB 0F0C 12 SLT 0F0D 15 ISZERO 0F0E 61 PUSH2 0x0f16 0F11 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0F04 stack[0] = 0x00 // @0F06 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0f16, if !(stack[-2] - stack[-1] i< 0x40) label_0F12: // Incoming jump from 0x0F11, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0F15 memory[0x00:0x00] } 0F12 60 PUSH1 0x00 0F14 80 DUP1 0F15 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F15 revert(memory[0x00:0x00]); } // Block terminates label_0F16: // Incoming jump from 0x0F11, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0F17 stack[-3] // @0F18 msg.data[stack[-3]:stack[-3] + 0x20] // } 0F16 5B JUMPDEST 0F17 82 DUP3 0F18 35 CALLDATALOAD 0F19 61 PUSH2 0x0f21 0F1C 81 DUP2 0F1D 61 PUSH2 0x0cd5 0F20 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F18 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @0F19 stack[1] = 0x0f21 // @0F1C stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0F21 label_0F21: // Incoming return from call to 0x0CD5 at 0x0F20 // Inputs[3] // { // @0F22 stack[-3] // @0F22 stack[-1] // @0F29 stack[-4] // } 0F21 5B JUMPDEST 0F22 91 SWAP2 0F23 50 POP 0F24 61 PUSH2 0x0f2f 0F27 60 PUSH1 0x20 0F29 84 DUP5 0F2A 01 ADD 0F2B 61 PUSH2 0x0eee 0F2E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0F22 stack[-3] = stack[-1] // @0F24 stack[-1] = 0x0f2f // @0F2A stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x0eee, returns to 0x0F2F label_0F2F: // Incoming return from call to 0x0EEE at 0x0F2E // Inputs[6] // { // @0F30 stack[-1] // @0F30 stack[-2] // @0F32 stack[-5] // @0F34 stack[-6] // @0F34 stack[-3] // @0F35 stack[-4] // } 0F2F 5B JUMPDEST 0F30 90 SWAP1 0F31 50 POP 0F32 92 SWAP3 0F33 50 POP 0F34 92 SWAP3 0F35 90 SWAP1 0F36 50 POP 0F37 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0F32 stack[-5] = stack[-1] // @0F34 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_0F38: // Incoming jump from 0x03D7 // Incoming jump from 0x03C4 // Incoming jump from 0x030B // Inputs[2] // { // @0F3D stack[-1] // @0F3E stack[-2] // } 0F38 5B JUMPDEST 0F39 60 PUSH1 0x00 0F3B 60 PUSH1 0x20 0F3D 82 DUP3 0F3E 84 DUP5 0F3F 03 SUB 0F40 12 SLT 0F41 15 ISZERO 0F42 61 PUSH2 0x0f4a 0F45 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F39 stack[0] = 0x00 } // Block ends with conditional jump to 0x0f4a, if !(stack[-2] - stack[-1] i< 0x20) label_0F46: // Incoming jump from 0x0F45, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0F49 memory[0x00:0x00] } 0F46 60 PUSH1 0x00 0F48 80 DUP1 0F49 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F49 revert(memory[0x00:0x00]); } // Block terminates label_0F4A: // Incoming jump from 0x0F45, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0F4B stack[-2] // @0F4C msg.data[stack[-2]:stack[-2] + 0x20] // } 0F4A 5B JUMPDEST 0F4B 81 DUP2 0F4C 35 CALLDATALOAD 0F4D 61 PUSH2 0x0c5e 0F50 81 DUP2 0F51 61 PUSH2 0x0cd5 0F54 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F4C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F4D stack[1] = 0x0c5e // @0F50 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0C5E label_0F55: // Incoming call from 0x0360, returns to 0x0361 // Inputs[2] // { // @0F60 stack[-1] // @0F61 stack[-2] // } 0F55 5B JUMPDEST 0F56 60 PUSH1 0x00 0F58 80 DUP1 0F59 60 PUSH1 0x00 0F5B 80 DUP1 0F5C 60 PUSH1 0x00 0F5E 60 PUSH1 0x80 0F60 86 DUP7 0F61 88 DUP9 0F62 03 SUB 0F63 12 SLT 0F64 15 ISZERO 0F65 61 PUSH2 0x0f6d 0F68 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0F56 stack[0] = 0x00 // @0F58 stack[1] = 0x00 // @0F59 stack[2] = 0x00 // @0F5B stack[3] = 0x00 // @0F5C stack[4] = 0x00 // } // Block ends with conditional jump to 0x0f6d, if !(stack[-2] - stack[-1] i< 0x80) label_0F69: // Incoming jump from 0x0F68, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @0F6C memory[0x00:0x00] } 0F69 60 PUSH1 0x00 0F6B 80 DUP1 0F6C FD *REVERT // Stack delta = +0 // Outputs[1] { @0F6C revert(memory[0x00:0x00]); } // Block terminates label_0F6D: // Incoming jump from 0x0F68, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @0F6E stack[-6] // @0F6F msg.data[stack[-6]:stack[-6] + 0x20] // } 0F6D 5B JUMPDEST 0F6E 85 DUP6 0F6F 35 CALLDATALOAD 0F70 61 PUSH2 0x0f78 0F73 81 DUP2 0F74 61 PUSH2 0x0cd5 0F77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F6F stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @0F70 stack[1] = 0x0f78 // @0F73 stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0F78 label_0F78: // Incoming return from call to 0x0CD5 at 0x0F77 // Inputs[4] // { // @0F79 stack[-6] // @0F79 stack[-1] // @0F7D stack[-7] // @0F7F msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 0F78 5B JUMPDEST 0F79 94 SWAP5 0F7A 50 POP 0F7B 60 PUSH1 0x20 0F7D 86 DUP7 0F7E 01 ADD 0F7F 35 CALLDATALOAD 0F80 61 PUSH2 0x0f88 0F83 81 DUP2 0F84 61 PUSH2 0x0cd5 0F87 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0F79 stack[-6] = stack[-1] // @0F7F stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @0F80 stack[0] = 0x0f88 // @0F83 stack[1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0F88 label_0F88: // Incoming return from call to 0x0CD5 at 0x0F87 // Inputs[6] // { // @0F89 stack[-5] // @0F89 stack[-1] // @0F8D stack[-7] // @0F8F msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @0F90 stack[-4] // @0F96 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 0F88 5B JUMPDEST 0F89 93 SWAP4 0F8A 50 POP 0F8B 60 PUSH1 0x40 0F8D 86 DUP7 0F8E 01 ADD 0F8F 35 CALLDATALOAD 0F90 92 SWAP3 0F91 50 POP 0F92 60 PUSH1 0x60 0F94 86 DUP7 0F95 01 ADD 0F96 35 CALLDATALOAD 0F97 67 PUSH8 0xffffffffffffffff 0FA0 80 DUP1 0FA1 82 DUP3 0FA2 11 GT 0FA3 15 ISZERO 0FA4 61 PUSH2 0x0fac 0FA7 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0F89 stack[-5] = stack[-1] // @0F90 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @0F96 stack[-1] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @0F97 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x0fac, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_0FA8: // Incoming jump from 0x0FA7, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0FAB memory[0x00:0x00] } 0FA8 60 PUSH1 0x00 0FAA 80 DUP1 0FAB FD *REVERT // Stack delta = +0 // Outputs[1] { @0FAB revert(memory[0x00:0x00]); } // Block terminates label_0FAC: // Incoming jump from 0x0FA7, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0FAD stack[-2] // @0FAE stack[-8] // @0FB2 stack[-9] // } 0FAC 5B JUMPDEST 0FAD 81 DUP2 0FAE 88 DUP9 0FAF 01 ADD 0FB0 91 SWAP2 0FB1 50 POP 0FB2 88 DUP9 0FB3 60 PUSH1 0x1f 0FB5 83 DUP4 0FB6 01 ADD 0FB7 12 SLT 0FB8 61 PUSH2 0x0fc0 0FBB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0FB0 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x0fc0, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_0FBC: // Incoming jump from 0x0FBB, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @0FBF memory[0x00:0x00] } 0FBC 60 PUSH1 0x00 0FBE 80 DUP1 0FBF FD *REVERT // Stack delta = +0 // Outputs[1] { @0FBF revert(memory[0x00:0x00]); } // Block terminates label_0FC0: // Incoming jump from 0x0FBB, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @0FC1 stack[-2] // @0FC2 msg.data[stack[-2]:stack[-2] + 0x20] // @0FC3 stack[-1] // } 0FC0 5B JUMPDEST 0FC1 81 DUP2 0FC2 35 CALLDATALOAD 0FC3 81 DUP2 0FC4 81 DUP2 0FC5 11 GT 0FC6 15 ISZERO 0FC7 61 PUSH2 0x0fcf 0FCA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FC2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0fcf, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_0FCB: // Incoming jump from 0x0FCA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @0FCE memory[0x00:0x00] } 0FCB 60 PUSH1 0x00 0FCD 80 DUP1 0FCE FD *REVERT // Stack delta = +0 // Outputs[1] { @0FCE revert(memory[0x00:0x00]); } // Block terminates label_0FCF: // Incoming jump from 0x0FCA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @0FD0 stack[-10] // @0FD3 stack[-1] // @0FD4 stack[-3] // } 0FCF 5B JUMPDEST 0FD0 89 DUP10 0FD1 60 PUSH1 0x20 0FD3 82 DUP3 0FD4 85 DUP6 0FD5 01 ADD 0FD6 01 ADD 0FD7 11 GT 0FD8 15 ISZERO 0FD9 61 PUSH2 0x0fe1 0FDC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fe1, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) label_0FDD: // Incoming jump from 0x0FDC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[1] { @0FE0 memory[0x00:0x00] } 0FDD 60 PUSH1 0x00 0FDF 80 DUP1 0FE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FE0 revert(memory[0x00:0x00]); } // Block terminates label_0FE1: // Incoming jump from 0x0FDC, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[9] // { // @0FE2 stack[-8] // @0FE2 stack[-1] // @0FE3 stack[-11] // @0FE4 stack[-7] // @0FE5 stack[-10] // @0FE7 stack[-6] // @0FE7 stack[-2] // @0FE8 stack[-9] // @0FEC stack[-3] // } 0FE1 5B JUMPDEST 0FE2 96 SWAP7 0FE3 99 SWAP10 0FE4 95 SWAP6 0FE5 98 SWAP9 0FE6 50 POP 0FE7 93 SWAP4 0FE8 96 SWAP7 0FE9 50 POP 0FEA 60 PUSH1 0x20 0FEC 01 ADD 0FED 94 SWAP5 0FEE 93 SWAP4 0FEF 92 SWAP3 0FF0 50 POP 0FF1 50 POP 0FF2 50 POP 0FF3 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @0FE3 stack[-11] = stack[-8] // @0FE5 stack[-10] = stack[-7] // @0FE8 stack[-9] = stack[-6] // @0FED stack[-8] = 0x20 + stack[-3] // @0FEE stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_0FF4: // Incoming jump from 0x039B // Inputs[2] // { // @0FF9 stack[-1] // @0FFA stack[-2] // } 0FF4 5B JUMPDEST 0FF5 60 PUSH1 0x00 0FF7 60 PUSH1 0x20 0FF9 82 DUP3 0FFA 84 DUP5 0FFB 03 SUB 0FFC 12 SLT 0FFD 15 ISZERO 0FFE 61 PUSH2 0x1006 1001 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FF5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1006, if !(stack[-2] - stack[-1] i< 0x20) label_1002: // Incoming jump from 0x1001, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1005 memory[0x00:0x00] } 1002 60 PUSH1 0x00 1004 80 DUP1 1005 FD *REVERT // Stack delta = +0 // Outputs[1] { @1005 revert(memory[0x00:0x00]); } // Block terminates label_1006: // Incoming jump from 0x1001, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @100A stack[-2] } 1006 5B JUMPDEST 1007 61 PUSH2 0x0c5e 100A 82 DUP3 100B 61 PUSH2 0x0eee 100E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1007 stack[0] = 0x0c5e // @100A stack[1] = stack[-2] // } // Block ends with call to 0x0eee, returns to 0x0C5E label_100F: // Incoming call from 0x03AE, returns to 0x03AF // Inputs[2] // { // @1015 stack[-1] // @1016 stack[-2] // } 100F 5B JUMPDEST 1010 60 PUSH1 0x00 1012 80 DUP1 1013 60 PUSH1 0x40 1015 83 DUP4 1016 85 DUP6 1017 03 SUB 1018 12 SLT 1019 15 ISZERO 101A 61 PUSH2 0x1022 101D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1010 stack[0] = 0x00 // @1012 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1022, if !(stack[-2] - stack[-1] i< 0x40) label_101E: // Incoming jump from 0x101D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1021 memory[0x00:0x00] } 101E 60 PUSH1 0x00 1020 80 DUP1 1021 FD *REVERT // Stack delta = +0 // Outputs[1] { @1021 revert(memory[0x00:0x00]); } // Block terminates label_1022: // Incoming jump from 0x101D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1023 stack[-3] // @1024 msg.data[stack[-3]:stack[-3] + 0x20] // } 1022 5B JUMPDEST 1023 82 DUP3 1024 35 CALLDATALOAD 1025 61 PUSH2 0x102d 1028 81 DUP2 1029 61 PUSH2 0x0cd5 102C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1024 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1025 stack[1] = 0x102d // @1028 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x102D label_102D: // Incoming return from call to 0x0CD5 at 0x102C // Inputs[4] // { // @102E stack[-3] // @102E stack[-1] // @1032 stack[-4] // @1034 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 102D 5B JUMPDEST 102E 91 SWAP2 102F 50 POP 1030 60 PUSH1 0x20 1032 83 DUP4 1033 01 ADD 1034 35 CALLDATALOAD 1035 61 PUSH2 0x103d 1038 81 DUP2 1039 61 PUSH2 0x0cd5 103C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @102E stack[-3] = stack[-1] // @1034 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1035 stack[0] = 0x103d // @1038 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x103D label_103D: // Incoming return from call to 0x0CD5 at 0x103C // Inputs[6] // { // @103E stack[-1] // @103F stack[-2] // @1042 stack[-5] // @1044 stack[-6] // @1044 stack[-3] // @1045 stack[-4] // } 103D 5B JUMPDEST 103E 80 DUP1 103F 91 SWAP2 1040 50 POP 1041 50 POP 1042 92 SWAP3 1043 50 POP 1044 92 SWAP3 1045 90 SWAP1 1046 50 POP 1047 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1042 stack[-5] = stack[-1] // @1044 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1048: // Incoming call from 0x045E, returns to 0x045F // Incoming call from 0x1218, returns to 0x1219 // Incoming call from 0x1155, returns to 0x1156 // Incoming call from 0x098C, returns to 0x045F // Incoming call from 0x048A, returns to 0x048B // Incoming call from 0x09DF, returns to 0x045F // Inputs[1] { @104B stack[-1] } 1048 5B JUMPDEST 1049 60 PUSH1 0x01 104B 81 DUP2 104C 81 DUP2 104D 1C SHR 104E 90 SWAP1 104F 82 DUP3 1050 16 AND 1051 80 DUP1 1052 61 PUSH2 0x105c 1055 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @104E stack[0] = stack[-1] >> 0x01 // @1050 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x105c, if stack[-1] & 0x01 label_1056: // Incoming jump from 0x1055, if not stack[-1] & 0x01 // Inputs[2] // { // @1058 stack[-2] // @1061 stack[-1] // } 1056 60 PUSH1 0x7f 1058 82 DUP3 1059 16 AND 105A 91 SWAP2 105B 50 POP 105C 5B JUMPDEST 105D 60 PUSH1 0x20 105F 82 DUP3 1060 10 LT 1061 81 DUP2 1062 03 SUB 1063 61 PUSH2 0x107c 1066 57 *JUMPI // Stack delta = +0 // Outputs[1] { @105A stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x107c, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1067: // Incoming jump from 0x1066, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1066, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @107B memory[0x00:0x24] } 1067 63 PUSH4 0x4e487b71 106C 60 PUSH1 0xe0 106E 1B SHL 106F 60 PUSH1 0x00 1071 52 MSTORE 1072 60 PUSH1 0x22 1074 60 PUSH1 0x04 1076 52 MSTORE 1077 60 PUSH1 0x24 1079 60 PUSH1 0x00 107B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1071 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1076 memory[0x04:0x24] = 0x22 // @107B revert(memory[0x00:0x24]); // } // Block terminates label_107C: // Incoming jump from 0x1066, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1066, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @107E stack[-2] // @107E stack[-4] // @107F stack[-3] // } 107C 5B JUMPDEST 107D 50 POP 107E 91 SWAP2 107F 90 SWAP1 1080 50 POP 1081 56 *JUMP // Stack delta = -3 // Outputs[1] { @107E stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1082: // Incoming call from 0x05A2, returns to 0x05A3 // Inputs[2] // { // @1087 stack[-1] // @1088 stack[-2] // } 1082 5B JUMPDEST 1083 60 PUSH1 0x00 1085 60 PUSH1 0x20 1087 82 DUP3 1088 84 DUP5 1089 03 SUB 108A 12 SLT 108B 15 ISZERO 108C 61 PUSH2 0x1094 108F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1083 stack[0] = 0x00 } // Block ends with conditional jump to 0x1094, if !(stack[-2] - stack[-1] i< 0x20) label_1090: // Incoming jump from 0x108F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1093 memory[0x00:0x00] } 1090 60 PUSH1 0x00 1092 80 DUP1 1093 FD *REVERT // Stack delta = +0 // Outputs[1] { @1093 revert(memory[0x00:0x00]); } // Block terminates label_1094: // Incoming jump from 0x108F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1096 memory[stack[-2]:stack[-2] + 0x20] // @1096 stack[-2] // @1097 stack[-4] // @1098 stack[-3] // } 1094 5B JUMPDEST 1095 50 POP 1096 51 MLOAD 1097 91 SWAP2 1098 90 SWAP1 1099 50 POP 109A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1097 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_109B: // Incoming jump from 0x074F // Incoming jump from 0x0C02 // Inputs[1] { @10B0 memory[0x00:0x24] } 109B 5B JUMPDEST 109C 63 PUSH4 0x4e487b71 10A1 60 PUSH1 0xe0 10A3 1B SHL 10A4 60 PUSH1 0x00 10A6 52 MSTORE 10A7 60 PUSH1 0x32 10A9 60 PUSH1 0x04 10AB 52 MSTORE 10AC 60 PUSH1 0x24 10AE 60 PUSH1 0x00 10B0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @10A6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @10AB memory[0x04:0x24] = 0x32 // @10B0 revert(memory[0x00:0x24]); // } // Block terminates label_10B1: // Incoming jump from 0x12CE // Incoming jump from 0x10D8 // Incoming jump from 0x12F5 // Inputs[1] { @10C6 memory[0x00:0x24] } 10B1 5B JUMPDEST 10B2 63 PUSH4 0x4e487b71 10B7 60 PUSH1 0xe0 10B9 1B SHL 10BA 60 PUSH1 0x00 10BC 52 MSTORE 10BD 60 PUSH1 0x11 10BF 60 PUSH1 0x04 10C1 52 MSTORE 10C2 60 PUSH1 0x24 10C4 60 PUSH1 0x00 10C6 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @10BC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @10C1 memory[0x04:0x24] = 0x11 // @10C6 revert(memory[0x00:0x24]); // } // Block terminates label_10C7: // Incoming call from 0x0B65, returns to 0x0B66 // Incoming call from 0x07A2, returns to 0x07A3 // Inputs[1] { @10CC stack[-1] } 10C7 5B JUMPDEST 10C8 60 PUSH1 0x00 10CA 60 PUSH1 0x01 10CC 82 DUP3 10CD 01 ADD 10CE 61 PUSH2 0x10d9 10D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10C8 stack[0] = 0x00 } // Block ends with conditional jump to 0x10d9, if stack[-1] + 0x01 label_10D2: // Incoming jump from 0x10D1, if not stack[-1] + 0x01 10D2 61 PUSH2 0x10d9 10D5 61 PUSH2 0x10b1 10D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @10D2 stack[0] = 0x10d9 } // Block ends with unconditional jump to 0x10b1 label_10D9: // Incoming jump from 0x10D1, if stack[-1] + 0x01 // Inputs[2] // { // @10DD stack[-2] // @10DE stack[-3] // } 10D9 5B JUMPDEST 10DA 50 POP 10DB 60 PUSH1 0x01 10DD 01 ADD 10DE 90 SWAP1 10DF 56 *JUMP // Stack delta = -2 // Outputs[1] { @10DE stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_10E0: // Incoming jump from 0x115B // Inputs[1] { @10E3 stack[-2] } 10E0 5B JUMPDEST 10E1 60 PUSH1 0x1f 10E3 82 DUP3 10E4 11 GT 10E5 15 ISZERO 10E6 61 PUSH2 0x06df 10E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06df, if !(stack[-2] > 0x1f) label_10EA: // Incoming jump from 0x10E9, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @10EC stack[-1] // @10F2 memory[0x00:0x20] // @10F5 stack[-3] // } 10EA 60 PUSH1 0x00 10EC 81 DUP2 10ED 81 DUP2 10EE 52 MSTORE 10EF 60 PUSH1 0x20 10F1 81 DUP2 10F2 20 SHA3 10F3 60 PUSH1 0x1f 10F5 85 DUP6 10F6 01 ADD 10F7 60 PUSH1 0x05 10F9 1C SHR 10FA 81 DUP2 10FB 01 ADD 10FC 60 PUSH1 0x20 10FE 86 DUP7 10FF 10 LT 1100 15 ISZERO 1101 61 PUSH2 0x1107 1104 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @10EA stack[0] = 0x00 // @10EE memory[0x00:0x20] = stack[-1] // @10F2 stack[1] = keccak256(memory[0x00:0x20]) // @10FB stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1107, if !(stack[-3] < 0x20) label_1105: // Incoming jump from 0x1104, if not !(stack[-3] < 0x20) // Inputs[2] // { // @1106 stack[-2] // @110A stack[-5] // } 1105 50 POP 1106 80 DUP1 1107 5B JUMPDEST 1108 60 PUSH1 0x1f 110A 85 DUP6 110B 01 ADD 110C 60 PUSH1 0x05 110E 1C SHR 110F 82 DUP3 1110 01 ADD 1111 91 SWAP2 1112 50 POP 1113 5B JUMPDEST 1114 81 DUP2 1115 81 DUP2 1116 10 LT 1117 15 ISZERO 1118 61 PUSH2 0x1126 111B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1106 stack[-1] = stack[-2] // @1111 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1126, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_111C: // Incoming jump from 0x111B, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x111B, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x111B, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[2] // { // @111C stack[-3] // @111D stack[-1] // } 111C 82 DUP3 111D 81 DUP2 111E 55 SSTORE 111F 60 PUSH1 0x01 1121 01 ADD 1122 61 PUSH2 0x1113 1125 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @111E storage[stack[-1]] = stack[-3] // @1121 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1113 label_1126: // Incoming jump from 0x1190 // Incoming jump from 0x111B, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x1190 // Incoming jump from 0x111B, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x111B, if !(stack[-1] < stack[-2]) // Inputs[1] { @112D stack[-7] } 1126 5B JUMPDEST 1127 50 POP 1128 50 POP 1129 50 POP 112A 50 POP 112B 50 POP 112C 50 POP 112D 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_112E: // Incoming call from 0x07DD, returns to 0x051C // Inputs[2] // { // @112F stack[-2] // @1130 memory[stack[-2]:stack[-2] + 0x20] // } 112E 5B JUMPDEST 112F 81 DUP2 1130 51 MLOAD 1131 67 PUSH8 0xffffffffffffffff 113A 81 DUP2 113B 11 GT 113C 15 ISZERO 113D 61 PUSH2 0x1148 1140 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1130 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1148, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1141: // Incoming jump from 0x1140, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1141 61 PUSH2 0x1148 1144 61 PUSH2 0x0d57 1147 56 *JUMP // Stack delta = +1 // Outputs[1] { @1141 stack[0] = 0x1148 } // Block ends with unconditional jump to 0x0d57 label_1148: // Incoming jump from 0x1140, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @114C stack[-1] // @1150 stack[-2] // @1151 storage[stack[-2]] // } 1148 5B JUMPDEST 1149 61 PUSH2 0x115c 114C 81 DUP2 114D 61 PUSH2 0x1156 1150 84 DUP5 1151 54 SLOAD 1152 61 PUSH2 0x1048 1155 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1149 stack[0] = 0x115c // @114C stack[1] = stack[-1] // @114D stack[2] = 0x1156 // @1151 stack[3] = storage[stack[-2]] // } // Block ends with call to 0x1048, returns to 0x1156 label_1156: // Incoming return from call to 0x1048 at 0x1155 // Inputs[1] { @1157 stack[-5] } 1156 5B JUMPDEST 1157 84 DUP5 1158 61 PUSH2 0x10e0 115B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1157 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x10e0 label_115C: // Incoming return from call to 0x1156 at 0x1155 // Inputs[1] { @1162 stack[-1] } 115C 5B JUMPDEST 115D 60 PUSH1 0x20 115F 80 DUP1 1160 60 PUSH1 0x1f 1162 83 DUP4 1163 11 GT 1164 60 PUSH1 0x01 1166 81 DUP2 1167 14 EQ 1168 61 PUSH2 0x1191 116B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @115D stack[0] = 0x20 // @115F stack[1] = 0x20 // @1163 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x1191, if (stack[-1] > 0x1f) == 0x01 label_116C: // Incoming jump from 0x116B, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @116E stack[-4] } 116C 60 PUSH1 0x00 116E 84 DUP5 116F 15 ISZERO 1170 61 PUSH2 0x1179 1173 57 *JUMPI // Stack delta = +1 // Outputs[1] { @116C stack[0] = 0x00 } // Block ends with conditional jump to 0x1179, if !stack[-4] label_1174: // Incoming jump from 0x1173, if not !stack[-4] // Inputs[5] // { // @1175 stack[-7] // @1176 stack[-4] // @1178 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @117F stack[-5] // @118B stack[-6] // } 1174 50 POP 1175 85 DUP6 1176 83 DUP4 1177 01 ADD 1178 51 MLOAD 1179 5B JUMPDEST 117A 60 PUSH1 0x00 117C 19 NOT 117D 60 PUSH1 0x03 117F 86 DUP7 1180 90 SWAP1 1181 1B SHL 1182 1C SHR 1183 19 NOT 1184 16 AND 1185 60 PUSH1 0x01 1187 85 DUP6 1188 90 SWAP1 1189 1B SHL 118A 17 OR 118B 85 DUP6 118C 55 SSTORE 118D 61 PUSH2 0x1126 1190 56 *JUMP // Stack delta = -1 // Outputs[1] { @118C storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x1126 label_1191: // Incoming jump from 0x116B, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @1194 stack[-5] // @119A memory[0x00:0x20] // @119E stack[-4] // } 1191 5B JUMPDEST 1192 60 PUSH1 0x00 1194 85 DUP6 1195 81 DUP2 1196 52 MSTORE 1197 60 PUSH1 0x20 1199 81 DUP2 119A 20 SHA3 119B 60 PUSH1 0x1f 119D 19 NOT 119E 86 DUP7 119F 16 AND 11A0 91 SWAP2 11A1 5B JUMPDEST 11A2 82 DUP3 11A3 81 DUP2 11A4 10 LT 11A5 15 ISZERO 11A6 61 PUSH2 0x11c0 11A9 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1196 memory[0x00:0x20] = stack[-5] // @119A stack[1] = keccak256(memory[0x00:0x20]) // @11A0 stack[0] = stack[-4] & ~0x1f // @11A0 stack[2] = 0x00 // } // Block ends with conditional jump to 0x11c0, if !(0x00 < stack[-4] & ~0x1f) label_11AA: // Incoming jump from 0x11A9, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x11A9, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @11AA stack[-9] // @11AB stack[-6] // @11AD memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @11AE stack[-2] // @11B0 stack[-1] // @11B1 stack[-5] // } 11AA 88 DUP9 11AB 86 DUP7 11AC 01 ADD 11AD 51 MLOAD 11AE 82 DUP3 11AF 55 SSTORE 11B0 94 SWAP5 11B1 84 DUP5 11B2 01 ADD 11B3 94 SWAP5 11B4 60 PUSH1 0x01 11B6 90 SWAP1 11B7 91 SWAP2 11B8 01 ADD 11B9 90 SWAP1 11BA 84 DUP5 11BB 01 ADD 11BC 61 PUSH2 0x11a1 11BF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @11AF storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @11B3 stack[-6] = stack[-5] + stack[-6] // @11B9 stack[-2] = stack[-2] + 0x01 // @11BB stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x11a1 label_11C0: // Incoming jump from 0x11A9, if !(stack[-1] < stack[-3]) // Incoming jump from 0x11A9, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @11C2 stack[-7] // @11C3 stack[-3] // } 11C0 5B JUMPDEST 11C1 50 POP 11C2 85 DUP6 11C3 82 DUP3 11C4 10 LT 11C5 15 ISZERO 11C6 61 PUSH2 0x11de 11C9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11de, if !(stack[-3] < stack[-7]) label_11CA: // Incoming jump from 0x11C9, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @11CA stack[-8] // @11CB stack[-5] // @11CD memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @11D3 stack[-6] // @11DC stack[-1] // @11EA stack[-7] // @11ED stack[-9] // } 11CA 87 DUP8 11CB 85 DUP6 11CC 01 ADD 11CD 51 MLOAD 11CE 60 PUSH1 0x00 11D0 19 NOT 11D1 60 PUSH1 0x03 11D3 88 DUP9 11D4 90 SWAP1 11D5 1B SHL 11D6 60 PUSH1 0xf8 11D8 16 AND 11D9 1C SHR 11DA 19 NOT 11DB 16 AND 11DC 81 DUP2 11DD 55 SSTORE 11DE 5B JUMPDEST 11DF 50 POP 11E0 50 POP 11E1 50 POP 11E2 50 POP 11E3 50 POP 11E4 60 PUSH1 0x01 11E6 90 SWAP1 11E7 81 DUP2 11E8 1B SHL 11E9 01 ADD 11EA 90 SWAP1 11EB 55 SSTORE 11EC 50 POP 11ED 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @11DD storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @11EB storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_11EE: // Incoming jump from 0x08C9 // Incoming jump from 0x0857 // Inputs[2] // { // @11F3 stack[-1] // @11F4 stack[-2] // } 11EE 5B JUMPDEST 11EF 60 PUSH1 0x00 11F1 60 PUSH1 0x20 11F3 82 DUP3 11F4 84 DUP5 11F5 03 SUB 11F6 12 SLT 11F7 15 ISZERO 11F8 61 PUSH2 0x1200 11FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11EF stack[0] = 0x00 } // Block ends with conditional jump to 0x1200, if !(stack[-2] - stack[-1] i< 0x20) label_11FC: // Incoming jump from 0x11FB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @11FF memory[0x00:0x00] } 11FC 60 PUSH1 0x00 11FE 80 DUP1 11FF FD *REVERT // Stack delta = +0 // Outputs[1] { @11FF revert(memory[0x00:0x00]); } // Block terminates label_1200: // Incoming jump from 0x11FB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1201 stack[-2] // @1202 memory[stack[-2]:stack[-2] + 0x20] // } 1200 5B JUMPDEST 1201 81 DUP2 1202 51 MLOAD 1203 61 PUSH2 0x0c5e 1206 81 DUP2 1207 61 PUSH2 0x0cd5 120A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1202 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1203 stack[1] = 0x0c5e // @1206 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0cd5, returns to 0x0C5E label_120B: // Incoming call from 0x09BC, returns to 0x09BD // Inputs[2] // { // @120F stack[-3] // @1210 storage[stack[-3]] // } 120B 5B JUMPDEST 120C 60 PUSH1 0x00 120E 80 DUP1 120F 84 DUP5 1210 54 SLOAD 1211 61 PUSH2 0x1219 1214 81 DUP2 1215 61 PUSH2 0x1048 1218 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @120C stack[0] = 0x00 // @120E stack[1] = 0x00 // @1210 stack[2] = storage[stack[-3]] // @1211 stack[3] = 0x1219 // @1214 stack[4] = storage[stack[-3]] // } // Block ends with call to 0x1048, returns to 0x1219 label_1219: // Incoming return from call to 0x1048 at 0x1218 // Inputs[1] { @121C stack[-2] } 1219 5B JUMPDEST 121A 60 PUSH1 0x01 121C 82 DUP3 121D 81 DUP2 121E 16 AND 121F 80 DUP1 1220 15 ISZERO 1221 61 PUSH2 0x1231 1224 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @121A stack[0] = 0x01 // @121E stack[1] = 0x01 & stack[-2] // } // Block ends with conditional jump to 0x1231, if !(0x01 & stack[-2]) label_1225: // Incoming jump from 0x1224, if not !(0x01 & stack[-2]) // Inputs[1] { @1227 stack[-1] } 1225 60 PUSH1 0x01 1227 81 DUP2 1228 14 EQ 1229 61 PUSH2 0x1246 122C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1246, if stack[-1] == 0x01 label_122D: // Incoming jump from 0x122C, if not stack[-1] == 0x01 122D 61 PUSH2 0x1275 1230 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1275 label_1231: // Incoming jump from 0x1224, if !(0x01 & stack[-2]) // Inputs[4] // { // @1235 stack[-4] // @1237 stack[-7] // @1239 stack[-3] // @1240 stack[-5] // } 1231 5B JUMPDEST 1232 60 PUSH1 0xff 1234 19 NOT 1235 84 DUP5 1236 16 AND 1237 87 DUP8 1238 52 MSTORE 1239 82 DUP3 123A 15 ISZERO 123B 15 ISZERO 123C 83 DUP4 123D 02 MUL 123E 87 DUP8 123F 01 ADD 1240 94 SWAP5 1241 50 POP 1242 61 PUSH2 0x1275 1245 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1238 memory[stack[-7]:stack[-7] + 0x20] = stack[-4] & ~0xff // @1240 stack[-5] = stack[-7] + stack[-3] * !!stack[-3] // } // Block ends with unconditional jump to 0x1275 label_1246: // Incoming jump from 0x122C, if stack[-1] == 0x01 // Inputs[3] // { // @1247 stack[-9] // @1250 memory[0x00:0x20] // @1254 stack[-3] // } 1246 5B JUMPDEST 1247 88 DUP9 1248 60 PUSH1 0x00 124A 52 MSTORE 124B 60 PUSH1 0x20 124D 80 DUP1 124E 60 PUSH1 0x00 1250 20 SHA3 1251 60 PUSH1 0x00 1253 5B JUMPDEST 1254 85 DUP6 1255 81 DUP2 1256 10 LT 1257 15 ISZERO 1258 61 PUSH2 0x126c 125B 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @124A memory[0x00:0x20] = stack[-9] // @124B stack[0] = 0x20 // @1250 stack[1] = keccak256(memory[0x00:0x20]) // @1251 stack[2] = 0x00 // } // Block ends with conditional jump to 0x126c, if !(0x00 < stack[-3]) label_125C: // Incoming jump from 0x125B, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x125B, if not !(0x00 < stack[-3]) // Inputs[6] // { // @125C stack[-2] // @125D storage[stack[-2]] // @125E stack[-10] // @125F stack[-1] // @1263 stack[-5] // @1266 stack[-3] // } 125C 81 DUP2 125D 54 SLOAD 125E 8A DUP11 125F 82 DUP3 1260 01 ADD 1261 52 MSTORE 1262 90 SWAP1 1263 84 DUP5 1264 01 ADD 1265 90 SWAP1 1266 82 DUP3 1267 01 ADD 1268 61 PUSH2 0x1253 126B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1261 memory[stack[-1] + stack[-10]:stack[-1] + stack[-10] + 0x20] = storage[stack[-2]] // @1265 stack[-2] = stack[-5] + stack[-2] // @1267 stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x1253 label_126C: // Incoming jump from 0x125B, if !(stack[-1] < stack[-6]) // Incoming jump from 0x125B, if !(0x00 < stack[-3]) // Inputs[3] // { // @1270 stack[-6] // @1271 stack[-10] // @1273 stack[-8] // } 126C 5B JUMPDEST 126D 50 POP 126E 50 POP 126F 50 POP 1270 82 DUP3 1271 87 DUP8 1272 01 ADD 1273 94 SWAP5 1274 50 POP // Stack delta = -3 // Outputs[1] { @1273 stack[-8] = stack[-10] + stack[-6] } // Block continues label_1275: // Incoming jump from 0x1245 // Incoming jump from 0x1274 // Incoming jump from 0x1230 // Inputs[3] // { // @127A stack[-8] // @127B memory[stack[-8]:stack[-8] + 0x20] // @1280 stack[-5] // } 1275 5B JUMPDEST 1276 50 POP 1277 50 POP 1278 50 POP 1279 50 POP 127A 83 DUP4 127B 51 MLOAD 127C 61 PUSH2 0x1289 127F 81 DUP2 1280 83 DUP4 1281 60 PUSH1 0x20 1283 88 DUP9 1284 01 ADD 1285 61 PUSH2 0x0c65 1288 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @127B stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @127C stack[-3] = 0x1289 // @127F stack[-2] = memory[stack[-8]:stack[-8] + 0x20] // @1280 stack[-1] = stack[-5] // @1284 stack[0] = stack[-8] + 0x20 // } // Block ends with call to 0x0c65, returns to 0x1289 label_1289: // Incoming return from call to 0x0C65 at 0x1288 // Inputs[4] // { // @128A stack[-1] // @128A stack[-2] // @128B stack[-7] // @128C stack[-6] // } 1289 5B JUMPDEST 128A 01 ADD 128B 94 SWAP5 128C 93 SWAP4 128D 50 POP 128E 50 POP 128F 50 POP 1290 50 POP 1291 56 *JUMP // Stack delta = -6 // Outputs[1] { @128B stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_1292: // Incoming jump from 0x12DD // Incoming jump from 0x12B6 // Inputs[1] { @12A7 memory[0x00:0x24] } 1292 5B JUMPDEST 1293 63 PUSH4 0x4e487b71 1298 60 PUSH1 0xe0 129A 1B SHL 129B 60 PUSH1 0x00 129D 52 MSTORE 129E 60 PUSH1 0x12 12A0 60 PUSH1 0x04 12A2 52 MSTORE 12A3 60 PUSH1 0x24 12A5 60 PUSH1 0x00 12A7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @129D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @12A2 memory[0x04:0x24] = 0x12 // @12A7 revert(memory[0x00:0x24]); // } // Block terminates label_12A8: // Incoming call from 0x0B74, returns to 0x0B75 // Incoming call from 0x0C24, returns to 0x0C25 // Inputs[1] { @12AB stack[-2] } 12A8 5B JUMPDEST 12A9 60 PUSH1 0x00 12AB 82 DUP3 12AC 61 PUSH2 0x12b7 12AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12A9 stack[0] = 0x00 } // Block ends with conditional jump to 0x12b7, if stack[-2] label_12B0: // Incoming jump from 0x12AF, if not stack[-2] 12B0 61 PUSH2 0x12b7 12B3 61 PUSH2 0x1292 12B6 56 *JUMP // Stack delta = +1 // Outputs[1] { @12B0 stack[0] = 0x12b7 } // Block ends with unconditional jump to 0x1292 label_12B7: // Incoming jump from 0x12AF, if stack[-2] // Inputs[3] // { // @12B9 stack[-3] // @12B9 stack[-2] // @12BA stack[-4] // } 12B7 5B JUMPDEST 12B8 50 POP 12B9 04 DIV 12BA 90 SWAP1 12BB 56 *JUMP // Stack delta = -3 // Outputs[1] { @12BA stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_12BC: // Incoming call from 0x0BD5, returns to 0x0BD6 // Inputs[2] // { // @12BD stack[-2] // @12BE stack[-1] // } 12BC 5B JUMPDEST 12BD 81 DUP2 12BE 81 DUP2 12BF 03 SUB 12C0 81 DUP2 12C1 81 DUP2 12C2 11 GT 12C3 15 ISZERO 12C4 61 PUSH2 0x044c 12C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12BF stack[0] = stack[-1] - stack[-2] } // Block ends with conditional jump to 0x044c, if !(stack[-1] - stack[-2] > stack[-1]) label_12C8: // Incoming jump from 0x12C7, if not !(stack[-1] - stack[-2] > stack[-1]) 12C8 61 PUSH2 0x044c 12CB 61 PUSH2 0x10b1 12CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @12C8 stack[0] = 0x044c } // Block ends with unconditional jump to 0x10b1 label_12CF: // Incoming call from 0x0BE2, returns to 0x0BE3 // Inputs[1] { @12D2 stack[-2] } 12CF 5B JUMPDEST 12D0 60 PUSH1 0x00 12D2 82 DUP3 12D3 61 PUSH2 0x12de 12D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x12de, if stack[-2] label_12D7: // Incoming jump from 0x12D6, if not stack[-2] 12D7 61 PUSH2 0x12de 12DA 61 PUSH2 0x1292 12DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @12D7 stack[0] = 0x12de } // Block ends with unconditional jump to 0x1292 label_12DE: // Incoming jump from 0x12D6, if stack[-2] // Inputs[3] // { // @12E0 stack[-3] // @12E0 stack[-2] // @12E1 stack[-4] // } 12DE 5B JUMPDEST 12DF 50 POP 12E0 06 MOD 12E1 90 SWAP1 12E2 56 *JUMP // Stack delta = -3 // Outputs[1] { @12E1 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_12E3: // Incoming call from 0x0BED, returns to 0x0BEE // Inputs[2] // { // @12E4 stack[-1] // @12E5 stack[-2] // } 12E3 5B JUMPDEST 12E4 80 DUP1 12E5 82 DUP3 12E6 01 ADD 12E7 80 DUP1 12E8 82 DUP3 12E9 11 GT 12EA 15 ISZERO 12EB 61 PUSH2 0x044c 12EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12E6 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x044c, if !(stack[-1] > stack[-2] + stack[-1]) label_12EF: // Incoming jump from 0x12EE, if not !(stack[-1] > stack[-2] + stack[-1]) 12EF 61 PUSH2 0x044c 12F2 61 PUSH2 0x10b1 12F5 56 *JUMP // Stack delta = +1 // Outputs[1] { @12EF stack[0] = 0x044c } // Block ends with unconditional jump to 0x10b1 12F6 FE *ASSERT 12F7 46 CHAINID 12F8 6F PUSH16 0x7220537069726974732c207768656e20 1309 74 PUSH21 0x68657920706c656173652c2043616e206569746865 131F 72 PUSH19 0x2073657820617373756d652c206f7220626f74 1333 68 PUSH9 0x3b20736f20736f6674 133D 20 SHA3 133E 41 COINBASE 133F 6E PUSH15 0x6420756e636f6d706f756e64656420 134F 69 PUSH10 0x73207468656972206573 135A 73 PUSH20 0x656e636520707572652c204e6f74207472696564 136F 20 SHA3 1370 6F PUSH16 0x72206d616e61636c6564207769746820 1381 6A PUSH11 0x6f696e74206f72206c696d 138D 62 PUSH3 0x2c204e 1391 6F PUSH16 0x7220666f756e646564206f6e20746865 13A2 20 SHA3 13A3 62 PUSH3 0x726974 13A7 74 PUSH21 0x6c6520737472656e677468206f6620626f6e65732c 13BD 20 SHA3 13BE 4C 4C 13BF 69 PUSH10 0x6b652063756d62726f75 13CA 73 PUSH20 0x20666c6573683b206275742c20696e2077686174 13DF 20 SHA3 13E0 73 PUSH20 0x6861706520746865792063686f6f73652c204469 13F5 6C PUSH13 0x61746564206f7220636f6e6465 1403 6E PUSH15 0x7365642c20627269676874206f7220 1413 6F PUSH16 0x6273637572652c2043616e2065786563 1424 75 PUSH22 0x7465207468656972206169727920707572706f736573 143B 2C 2C 143C 20 SHA3 143D 41 COINBASE 143E 6E PUSH15 0x6420776f726b73206f66206c6f7665 144E 20 SHA3 144F 6F PUSH16 0x7220656e6d6974792066756c66696c2e 1460 A1 LOG1 1461 64 PUSH5 0x736f6c6343 1467 00 *STOP 1468 08 ADDMOD 1469 11 GT 146A 00 *STOP 146B 0A EXP