Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 15 ISZERO 000A 61 PUSH2 0x0012 000D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0012, if !(msg.data.length < 0x04) label_000E: // Incoming jump from 0x000D, if not !(msg.data.length < 0x04) // Inputs[1] { @0011 memory[0x00:0x00] } 000E 60 PUSH1 0x00 0010 80 DUP1 0011 FD *REVERT // Stack delta = +0 // Outputs[1] { @0011 revert(memory[0x00:0x00]); } // Block terminates label_0012: // Incoming jump from 0x000D, if !(msg.data.length < 0x04) // Inputs[1] { @0015 msg.data[0x00:0x20] } 0012 5B JUMPDEST 0013 60 PUSH1 0x00 0015 35 CALLDATALOAD 0016 60 PUSH1 0xe0 0018 1C SHR 0019 80 DUP1 001A 62 PUSH3 0xfdd58e 001E 14 EQ 001F 61 PUSH2 0x01b6 0022 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0018 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x01b6, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 label_0023: // Incoming jump from 0x0022, if not 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0023 stack[-1] } 0023 80 DUP1 0024 63 PUSH4 0x01ffc9a7 0029 14 EQ 002A 61 PUSH2 0x01b1 002D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b1, if 0x01ffc9a7 == stack[-1] label_002E: // Incoming jump from 0x002D, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @002E stack[-1] } 002E 80 DUP1 002F 63 PUSH4 0x0e89341c 0034 14 EQ 0035 61 PUSH2 0x01ac 0038 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ac, if 0x0e89341c == stack[-1] label_0039: // Incoming jump from 0x0038, if not 0x0e89341c == stack[-1] // Inputs[1] { @0039 stack[-1] } 0039 80 DUP1 003A 63 PUSH4 0x18160ddd 003F 14 EQ 0040 61 PUSH2 0x01a7 0043 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a7, if 0x18160ddd == stack[-1] label_0044: // Incoming jump from 0x0043, if not 0x18160ddd == stack[-1] // Inputs[1] { @0044 stack[-1] } 0044 80 DUP1 0045 63 PUSH4 0x2eb2c2d6 004A 14 EQ 004B 61 PUSH2 0x01a2 004E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a2, if 0x2eb2c2d6 == stack[-1] label_004F: // Incoming jump from 0x004E, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @004F stack[-1] } 004F 80 DUP1 0050 63 PUSH4 0x44004cc1 0055 14 EQ 0056 61 PUSH2 0x019d 0059 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019d, if 0x44004cc1 == stack[-1] label_005A: // Incoming jump from 0x0059, if not 0x44004cc1 == stack[-1] // Inputs[1] { @005A stack[-1] } 005A 80 DUP1 005B 63 PUSH4 0x4d81575f 0060 14 EQ 0061 61 PUSH2 0x0198 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0198, if 0x4d81575f == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x4d81575f == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x4e1273f4 006B 14 EQ 006C 61 PUSH2 0x0193 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0193, if 0x4e1273f4 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x4f558e79 0076 14 EQ 0077 61 PUSH2 0x018e 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018e, if 0x4f558e79 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x4f558e79 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x56d3163d 0081 14 EQ 0082 61 PUSH2 0x0189 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0189, if 0x56d3163d == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x56d3163d == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x690d8320 008C 14 EQ 008D 61 PUSH2 0x0184 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0184, if 0x690d8320 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x690d8320 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0x6b20c454 0097 14 EQ 0098 61 PUSH2 0x017f 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017f, if 0x6b20c454 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0x6b20c454 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0x715018a6 00A2 14 EQ 00A3 61 PUSH2 0x017a 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017a, if 0x715018a6 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0x715018a6 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0x8ada6b0f 00AD 14 EQ 00AE 61 PUSH2 0x0175 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x8ada6b0f == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0x8ada6b0f == stack[-1] // Inputs[1] { @00B2 stack[-1] } 00B2 80 DUP1 00B3 63 PUSH4 0x8da5cb5b 00B8 14 EQ 00B9 61 PUSH2 0x0170 00BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0170, if 0x8da5cb5b == stack[-1] label_00BD: // Incoming jump from 0x00BC, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00BD stack[-1] } 00BD 80 DUP1 00BE 63 PUSH4 0x9f224f35 00C3 14 EQ 00C4 61 PUSH2 0x016b 00C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x016b, if 0x9f224f35 == stack[-1] label_00C8: // Incoming jump from 0x00C7, if not 0x9f224f35 == stack[-1] // Inputs[1] { @00C8 stack[-1] } 00C8 80 DUP1 00C9 63 PUSH4 0xa22cb465 00CE 14 EQ 00CF 61 PUSH2 0x0166 00D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0xa22cb465 == stack[-1] label_00D3: // Incoming jump from 0x00D2, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D3 stack[-1] } 00D3 80 DUP1 00D4 63 PUSH4 0xa575c9d6 00D9 14 EQ 00DA 61 PUSH2 0x0161 00DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0161, if 0xa575c9d6 == stack[-1] label_00DE: // Incoming jump from 0x00DD, if not 0xa575c9d6 == stack[-1] // Inputs[1] { @00DE stack[-1] } 00DE 80 DUP1 00DF 63 PUSH4 0xbc31c1c1 00E4 14 EQ 00E5 61 PUSH2 0x015c 00E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015c, if 0xbc31c1c1 == stack[-1] label_00E9: // Incoming jump from 0x00E8, if not 0xbc31c1c1 == stack[-1] // Inputs[1] { @00E9 stack[-1] } 00E9 80 DUP1 00EA 63 PUSH4 0xbd85b039 00EF 14 EQ 00F0 61 PUSH2 0x0157 00F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0157, if 0xbd85b039 == stack[-1] label_00F4: // Incoming jump from 0x00F3, if not 0xbd85b039 == stack[-1] // Inputs[1] { @00F4 stack[-1] } 00F4 80 DUP1 00F5 63 PUSH4 0xc7bc193f 00FA 14 EQ 00FB 61 PUSH2 0x0152 00FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0152, if 0xc7bc193f == stack[-1] label_00FF: // Incoming jump from 0x00FE, if not 0xc7bc193f == stack[-1] // Inputs[1] { @00FF stack[-1] } 00FF 80 DUP1 0100 63 PUSH4 0xe985e9c5 0105 14 EQ 0106 61 PUSH2 0x014d 0109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x014d, if 0xe985e9c5 == stack[-1] label_010A: // Incoming jump from 0x0109, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @010A stack[-1] } 010A 80 DUP1 010B 63 PUSH4 0xec991da9 0110 14 EQ 0111 61 PUSH2 0x0148 0114 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0148, if 0xec991da9 == stack[-1] label_0115: // Incoming jump from 0x0114, if not 0xec991da9 == stack[-1] // Inputs[1] { @0115 stack[-1] } 0115 80 DUP1 0116 63 PUSH4 0xf242432a 011B 14 EQ 011C 61 PUSH2 0x0143 011F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0143, if 0xf242432a == stack[-1] label_0120: // Incoming jump from 0x011F, if not 0xf242432a == stack[-1] // Inputs[1] { @0120 stack[-1] } 0120 80 DUP1 0121 63 PUSH4 0xf2fde38b 0126 14 EQ 0127 61 PUSH2 0x013e 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013e, if 0xf2fde38b == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0130 stack[-1] } 012B 63 PUSH4 0xf5298aca 0130 14 EQ 0131 61 PUSH2 0x0139 0134 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0139, if 0xf5298aca == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0xf5298aca == stack[-1] // Inputs[1] { @0138 memory[0x00:0x00] } 0135 60 PUSH1 0x00 0137 80 DUP1 0138 FD *REVERT // Stack delta = +0 // Outputs[1] { @0138 revert(memory[0x00:0x00]); } // Block terminates label_0139: // Incoming jump from 0x0134, if 0xf5298aca == stack[-1] 0139 5B JUMPDEST 013A 61 PUSH2 0x0fed 013D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fed label_013E: // Incoming jump from 0x012A, if 0xf2fde38b == stack[-1] 013E 5B JUMPDEST 013F 61 PUSH2 0x0f5b 0142 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f5b label_0143: // Incoming jump from 0x011F, if 0xf242432a == stack[-1] 0143 5B JUMPDEST 0144 61 PUSH2 0x0e4d 0147 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e4d label_0148: // Incoming jump from 0x0114, if 0xec991da9 == stack[-1] 0148 5B JUMPDEST 0149 61 PUSH2 0x0e19 014C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e19 label_014D: // Incoming jump from 0x0109, if 0xe985e9c5 == stack[-1] 014D 5B JUMPDEST 014E 61 PUSH2 0x0db1 0151 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0db1 label_0152: // Incoming jump from 0x00FE, if 0xc7bc193f == stack[-1] 0152 5B JUMPDEST 0153 61 PUSH2 0x0d6a 0156 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d6a label_0157: // Incoming jump from 0x00F3, if 0xbd85b039 == stack[-1] 0157 5B JUMPDEST 0158 61 PUSH2 0x0d3e 015B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d3e label_015C: // Incoming jump from 0x00E8, if 0xbc31c1c1 == stack[-1] 015C 5B JUMPDEST 015D 61 PUSH2 0x0d12 0160 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d12 label_0161: // Incoming jump from 0x00DD, if 0xa575c9d6 == stack[-1] 0161 5B JUMPDEST 0162 61 PUSH2 0x0c47 0165 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c47 label_0166: // Incoming jump from 0x00D2, if 0xa22cb465 == stack[-1] 0166 5B JUMPDEST 0167 61 PUSH2 0x0b93 016A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b93 label_016B: // Incoming jump from 0x00C7, if 0x9f224f35 == stack[-1] 016B 5B JUMPDEST 016C 61 PUSH2 0x0b58 016F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b58 label_0170: // Incoming jump from 0x00BC, if 0x8da5cb5b == stack[-1] 0170 5B JUMPDEST 0171 61 PUSH2 0x0b2f 0174 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b2f label_0175: // Incoming jump from 0x00B1, if 0x8ada6b0f == stack[-1] 0175 5B JUMPDEST 0176 61 PUSH2 0x0b06 0179 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b06 label_017A: // Incoming jump from 0x00A6, if 0x715018a6 == stack[-1] 017A 5B JUMPDEST 017B 61 PUSH2 0x0aa8 017E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aa8 label_017F: // Incoming jump from 0x009B, if 0x6b20c454 == stack[-1] 017F 5B JUMPDEST 0180 61 PUSH2 0x09b8 0183 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09b8 label_0184: // Incoming jump from 0x0090, if 0x690d8320 == stack[-1] 0184 5B JUMPDEST 0185 61 PUSH2 0x093d 0188 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x093d label_0189: // Incoming jump from 0x0085, if 0x56d3163d == stack[-1] 0189 5B JUMPDEST 018A 61 PUSH2 0x08f6 018D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08f6 label_018E: // Incoming jump from 0x007A, if 0x4f558e79 == stack[-1] 018E 5B JUMPDEST 018F 61 PUSH2 0x08c8 0192 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08c8 label_0193: // Incoming jump from 0x006F, if 0x4e1273f4 == stack[-1] 0193 5B JUMPDEST 0194 61 PUSH2 0x080b 0197 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x080b label_0198: // Incoming jump from 0x0064, if 0x4d81575f == stack[-1] 0198 5B JUMPDEST 0199 61 PUSH2 0x072f 019C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x072f label_019D: // Incoming jump from 0x0059, if 0x44004cc1 == stack[-1] 019D 5B JUMPDEST 019E 61 PUSH2 0x066d 01A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x066d label_01A2: // Incoming jump from 0x004E, if 0x2eb2c2d6 == stack[-1] 01A2 5B JUMPDEST 01A3 61 PUSH2 0x053f 01A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x053f label_01A7: // Incoming jump from 0x0043, if 0x18160ddd == stack[-1] 01A7 5B JUMPDEST 01A8 61 PUSH2 0x03ed 01AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03ed label_01AC: // Incoming jump from 0x0038, if 0x0e89341c == stack[-1] 01AC 5B JUMPDEST 01AD 61 PUSH2 0x02fe 01B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02fe label_01B1: // Incoming jump from 0x002D, if 0x01ffc9a7 == stack[-1] 01B1 5B JUMPDEST 01B2 61 PUSH2 0x0234 01B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0234 label_01B6: // Incoming jump from 0x0022, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 01B6 5B JUMPDEST 01B7 61 PUSH2 0x01d1 01BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d1 label_01BB: // Incoming call from 0x08BC, returns to 0x08BD // Incoming call from 0x0F77, returns to 0x0F78 // Incoming call from 0x0568, returns to 0x0569 // Incoming call from 0x068B, returns to 0x068C // Incoming call from 0x0699, returns to 0x069A // Incoming call from 0x0912, returns to 0x0913 // Incoming call from 0x0BAF, returns to 0x0BB0 // Incoming call from 0x1009, returns to 0x100A // Incoming call from 0x055C, returns to 0x055D // Incoming call from 0x0959, returns to 0x095A // Incoming call from 0x0E69, returns to 0x0E6A // Incoming call from 0x01F2, returns to 0x01F3 // Incoming call from 0x0E75, returns to 0x0E76 // Incoming call from 0x0DE1, returns to 0x0DE2 // Incoming call from 0x0DD4, returns to 0x0DD5 // Incoming call from 0x09D4, returns to 0x09D5 // Inputs[1] { @01C4 stack[-1] } 01BB 5B JUMPDEST 01BC 60 PUSH1 0x01 01BE 60 PUSH1 0x01 01C0 60 PUSH1 0xa0 01C2 1B SHL 01C3 03 SUB 01C4 81 DUP2 01C5 16 AND 01C6 03 SUB 01C7 61 PUSH2 0x01cc 01CA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cc, if (stack[-1] & (0x01 << 0xa0) - 0x01) - stack[-1] label_01CB: // Incoming jump from 0x01CA, if not (stack[-1] & (0x01 << 0xa0) - 0x01) - stack[-1] // Inputs[1] { @01CB stack[-1] } 01CB 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_01CC: // Incoming jump from 0x082F, if msg.data[0x04:0x24] > 0xffffffffffffffff // Incoming jump from 0x0B98, if msg.value // Incoming jump from 0x01E2, if ~0x03 + msg.data.length i< 0x40 // Incoming jump from 0x0D6F, if msg.value // Incoming jump from 0x0D4F, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0550, if ~0x03 + msg.data.length i< 0xa0 // Incoming jump from 0x09E8, if msg.data[0x24:0x44] > 0xffffffffffffffff // Incoming jump from 0x0303, if msg.value // Incoming jump from 0x0E88, if msg.data[0x84:0xa4] > 0xffffffffffffffff // Incoming jump from 0x0B5D, if msg.value // Incoming jump from 0x0DB6, if msg.value // Incoming jump from 0x0F6C, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0B17, if ~0x03 + msg.data.length i< 0x00 // Incoming jump from 0x0C9B, if msg.data[0x44:0x64] > stack[-3] // Incoming jump from 0x0488, if !(stack[-1] + 0x1f i< stack[-2]) // Incoming jump from 0x0232, if (stack[-1] & ~((0x01 << 0xe0) - 0x01)) - stack[-1] // Incoming jump from 0x083A, if !(stack[-2] + 0x23 i< msg.data.length) // Incoming jump from 0x0FF2, if msg.value // Incoming jump from 0x01D6, if msg.value // Incoming jump from 0x0E5E, if ~0x03 + msg.data.length i< 0xa0 // Incoming jump from 0x0B34, if msg.value // Incoming jump from 0x0888, if msg.data[0x24:0x44] > stack[-5] // Incoming jump from 0x0D23, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0871, if stack[-1] + (stack[-2] << 0x05) + 0x24 > msg.data.length // Incoming jump from 0x0245, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x05AD, if msg.data[0x84:0xa4] > stack[-4] // Incoming jump from 0x0810, if msg.value // Incoming jump from 0x0B91, if !!stack[-1] - stack[-1] // Incoming jump from 0x030F, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0AAD, if msg.value // Incoming jump from 0x03F2, if msg.value // Incoming jump from 0x03FE, if ~0x03 + msg.data.length i< 0x00 // Incoming jump from 0x0C4C, if msg.value // Incoming jump from 0x0E1E, if msg.value // Incoming jump from 0x067E, if ~0x03 + msg.data.length i< 0x60 // Incoming jump from 0x0C58, if ~0x03 + msg.data.length i< 0x60 // Incoming jump from 0x01CA, if (stack[-1] & (0x01 << 0xa0) - 0x01) - stack[-1] // Incoming jump from 0x0B0B, if msg.value // Incoming jump from 0x0503, if !(stack[-1] + 0x1f i< stack[-2]) // Incoming jump from 0x052B, if stack[-2] + stack[-3] + 0x20 > stack[-1] // Incoming jump from 0x0595, if msg.data[0x64:0x84] > stack[-3] // Incoming jump from 0x0A01, if msg.data[0x44:0x64] > stack[-2] // Incoming jump from 0x0C83, if msg.data[0x24:0x44] > stack[-2] // Incoming jump from 0x0B69, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x073B, if ~0x03 + msg.data.length i< 0x60 // Incoming jump from 0x0D43, if msg.value // Incoming jump from 0x094E, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0E52, if msg.value // Incoming jump from 0x0D7B, if ~0x03 + msg.data.length i< 0x40 // Incoming jump from 0x09C9, if ~0x03 + msg.data.length i< 0x60 // Incoming jump from 0x08CD, if msg.value // Incoming jump from 0x09BD, if msg.value // Incoming jump from 0x08D9, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0FFE, if ~0x03 + msg.data.length i< 0x60 // Incoming jump from 0x04BA, if stack[-1] + (stack[-2] << 0x05) + 0x20 > stack[-3] // Incoming jump from 0x081C, if ~0x03 + msg.data.length i< 0x40 // Incoming jump from 0x0F60, if msg.value // Incoming jump from 0x0239, if msg.value // Incoming jump from 0x0B40, if ~0x03 + msg.data.length i< 0x00 // Incoming jump from 0x0E2A, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x08FB, if msg.value // Incoming jump from 0x0D17, if msg.value // Incoming jump from 0x0BA4, if ~0x03 + msg.data.length i< 0x40 // Incoming jump from 0x0544, if msg.value // Incoming jump from 0x0907, if ~0x03 + msg.data.length i< 0x20 // Incoming jump from 0x0C6B, if msg.data[0x04:0x24] > 0xffffffffffffffff // Incoming jump from 0x0DC2, if ~0x03 + msg.data.length i< 0x40 // Incoming jump from 0x057D, if msg.data[0x44:0x64] > 0xffffffffffffffff // Incoming jump from 0x0672, if msg.value // Incoming jump from 0x0942, if msg.value // Inputs[1] { @01D0 memory[0x00:0x00] } 01CC 5B JUMPDEST 01CD 60 PUSH1 0x00 01CF 80 DUP1 01D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D0 revert(memory[0x00:0x00]); } // Block terminates label_01D1: // Incoming jump from 0x01BA // Inputs[1] { @01D2 msg.value } 01D1 5B JUMPDEST 01D2 34 CALLVALUE 01D3 61 PUSH2 0x01cc 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_01D7: // Incoming jump from 0x01D6, if not msg.value // Inputs[1] { @01D9 msg.data.length } 01D7 60 PUSH1 0x40 01D9 36 CALLDATASIZE 01DA 60 PUSH1 0x03 01DC 19 NOT 01DD 01 ADD 01DE 12 SLT 01DF 61 PUSH2 0x01cc 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x40 label_01E3: // Incoming jump from 0x01E2, if not ~0x03 + msg.data.length i< 0x40 // Inputs[1] { @01EA msg.data[0x04:0x24] } 01E3 60 PUSH1 0x20 01E5 61 PUSH2 0x0219 01E8 60 PUSH1 0x04 01EA 35 CALLDATALOAD 01EB 61 PUSH2 0x01f3 01EE 81 DUP2 01EF 61 PUSH2 0x01bb 01F2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @01E3 stack[0] = 0x20 // @01E5 stack[1] = 0x0219 // @01EA stack[2] = msg.data[0x04:0x24] // @01EB stack[3] = 0x01f3 // @01EE stack[4] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x01F3 label_01F3: // Incoming return from call to 0x01BB at 0x01F2 // Inputs[6] // { // @01F6 msg.data[0x24:0x44] // @01FC stack[-3] // @0202 memory[0x00:0x40] // @0203 stack[-1] // @0216 memory[0x00:0x40] // @0217 stack[-2] // } 01F3 5B JUMPDEST 01F4 60 PUSH1 0x24 01F6 35 CALLDATALOAD 01F7 60 PUSH1 0x00 01F9 52 MSTORE 01FA 60 PUSH1 0x00 01FC 83 DUP4 01FD 52 MSTORE 01FE 60 PUSH1 0x40 0200 60 PUSH1 0x00 0202 20 SHA3 0203 90 SWAP1 0204 60 PUSH1 0x01 0206 80 DUP1 0207 60 PUSH1 0xa0 0209 1B SHL 020A 03 SUB 020B 16 AND 020C 60 PUSH1 0x00 020E 52 MSTORE 020F 60 PUSH1 0x20 0211 52 MSTORE 0212 60 PUSH1 0x40 0214 60 PUSH1 0x00 0216 20 SHA3 0217 90 SWAP1 0218 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @01F9 memory[0x00:0x20] = msg.data[0x24:0x44] // @01FD memory[stack[-3]:stack[-3] + 0x20] = 0x00 // @020E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0211 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0217 stack[-2] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-2] label_0219: // Incoming return from call to 0x01F3 at 0x01F2 // Inputs[5] // { // @021A stack[-1] // @021A storage[stack[-1]] // @021D memory[0x40:0x60] // @0221 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2]] // @0221 stack[-2] // } 0219 5B JUMPDEST 021A 54 SLOAD 021B 60 PUSH1 0x40 021D 51 MLOAD 021E 90 SWAP1 021F 81 DUP2 0220 52 MSTORE 0221 F3 *RETURN // Stack delta = -2 // Outputs[2] // { // @0220 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[stack[-1]] // @0221 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2]]; // } // Block terminates label_0222: // Incoming call from 0x0252, returns to 0x0253 // Inputs[1] { @022C stack[-1] } 0222 5B JUMPDEST 0223 60 PUSH1 0x01 0225 60 PUSH1 0x01 0227 60 PUSH1 0xe0 0229 1B SHL 022A 03 SUB 022B 19 NOT 022C 81 DUP2 022D 16 AND 022E 03 SUB 022F 61 PUSH2 0x01cc 0232 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cc, if (stack[-1] & ~((0x01 << 0xe0) - 0x01)) - stack[-1] label_0233: // Incoming jump from 0x0232, if not (stack[-1] & ~((0x01 << 0xe0) - 0x01)) - stack[-1] // Inputs[1] { @0233 stack[-1] } 0233 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0234: // Incoming jump from 0x01B5 // Inputs[1] { @0235 msg.value } 0234 5B JUMPDEST 0235 34 CALLVALUE 0236 61 PUSH2 0x01cc 0239 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_023A: // Incoming jump from 0x0239, if not msg.value // Inputs[1] { @023C msg.data.length } 023A 60 PUSH1 0x20 023C 36 CALLDATASIZE 023D 60 PUSH1 0x03 023F 19 NOT 0240 01 ADD 0241 12 SLT 0242 61 PUSH2 0x01cc 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0246: // Incoming jump from 0x0245, if not ~0x03 + msg.data.length i< 0x20 // Inputs[1] { @024A msg.data[0x04:0x24] } 0246 60 PUSH1 0x20 0248 60 PUSH1 0x04 024A 35 CALLDATALOAD 024B 61 PUSH2 0x0253 024E 81 DUP2 024F 61 PUSH2 0x0222 0252 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0246 stack[0] = 0x20 // @024A stack[1] = msg.data[0x04:0x24] // @024B stack[2] = 0x0253 // @024E stack[3] = msg.data[0x04:0x24] // } // Block ends with call to 0x0222, returns to 0x0253 label_0253: // Incoming return from call to 0x0222 at 0x0252 // Inputs[1] { @025C stack[-1] } 0253 5B JUMPDEST 0254 63 PUSH4 0xffffffff 0259 60 PUSH1 0xe0 025B 1B SHL 025C 16 AND 025D 63 PUSH4 0x6cdb3d13 0262 60 PUSH1 0xe1 0264 1B SHL 0265 81 DUP2 0266 14 EQ 0267 90 SWAP1 0268 81 DUP2 0269 15 ISZERO 026A 61 PUSH2 0x0291 026D 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0267 stack[0] = (0xffffffff << 0xe0) & stack[-1] // @0267 stack[-1] = (0xffffffff << 0xe0) & stack[-1] == 0x6cdb3d13 << 0xe1 // } // Block ends with conditional jump to 0x0291, if !((0xffffffff << 0xe0) & stack[-1] == 0x6cdb3d13 << 0xe1) label_026E: // Incoming jump from 0x02A1 // Incoming jump from 0x026D, if not !((0xffffffff << 0xe0) & stack[-1] == 0x6cdb3d13 << 0xe1) // Inputs[1] { @026F stack[-2] } 026E 5B JUMPDEST 026F 81 DUP2 0270 15 ISZERO 0271 61 PUSH2 0x0280 0274 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0280, if !stack[-2] label_0275: // Incoming jump from 0x0274, if not !stack[-2] // Incoming jump from 0x0290 // Inputs[4] // { // @0279 memory[0x40:0x60] // @027A stack[-2] // @027F stack[-3] // @027F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3]] // } 0275 5B JUMPDEST 0276 50 POP 0277 60 PUSH1 0x40 0279 51 MLOAD 027A 90 SWAP1 027B 15 ISZERO 027C 15 ISZERO 027D 81 DUP2 027E 52 MSTORE 027F F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @027E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-2] // @027F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3]]; // } // Block terminates label_0280: // Incoming jump from 0x0274, if !stack[-2] // Inputs[3] // { // @0289 stack[-1] // @028A stack[-2] // @028C code.length // } 0280 5B JUMPDEST 0281 63 PUSH4 0x01ffc9a7 0286 60 PUSH1 0xe0 0288 1B SHL 0289 14 EQ 028A 90 SWAP1 028B 50 POP 028C 38 CODESIZE 028D 61 PUSH2 0x0275 0290 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @028A stack[-2] = 0x01ffc9a7 << 0xe0 == stack[-1] // @028C stack[-1] = code.length // } // Block ends with unconditional jump to 0x0275 label_0291: // Incoming jump from 0x026D, if !((0xffffffff << 0xe0) & stack[-1] == 0x6cdb3d13 << 0xe1) // Inputs[2] // { // @029A stack[-1] // @029C stack[-2] // } 0291 5B JUMPDEST 0292 63 PUSH4 0x03a24d07 0297 60 PUSH1 0xe2 0299 1B SHL 029A 81 DUP2 029B 14 EQ 029C 91 SWAP2 029D 50 POP 029E 61 PUSH2 0x026e 02A1 56 *JUMP // Stack delta = +0 // Outputs[1] { @029C stack[-2] = stack[-1] == 0x03a24d07 << 0xe2 } // Block ends with unconditional jump to 0x026e label_02A2: // Incoming call from 0x0CF2, returns to 0x0CF3 // Incoming call from 0x03D6, returns to 0x03D7 // Incoming call from 0x0CDF, returns to 0x0CE0 // Incoming call from 0x02DD, returns to 0x02DE // Incoming call from 0x0CCB, returns to 0x0CCC // Inputs[1] { @02A6 stack[-3] } 02A2 5B JUMPDEST 02A3 60 PUSH1 0x00 02A5 5B JUMPDEST 02A6 83 DUP4 02A7 81 DUP2 02A8 10 LT 02A9 61 PUSH2 0x02b5 02AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = 0x00 } // Block ends with conditional jump to 0x02b5, if 0x00 < stack[-3] label_02AD: // Incoming jump from 0x02AC, if not 0x00 < stack[-3] // Incoming jump from 0x02AC, if not stack[-1] < stack[-4] // Inputs[3] // { // @02B1 stack[-4] // @02B2 stack[-3] // @02B4 stack[-5] // } 02AD 50 POP 02AE 50 POP 02AF 60 PUSH1 0x00 02B1 91 SWAP2 02B2 01 ADD 02B3 52 MSTORE 02B4 56 *JUMP // Stack delta = -5 // Outputs[1] { @02B3 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_02B5: // Incoming jump from 0x02AC, if 0x00 < stack[-3] // Incoming jump from 0x02AC, if stack[-1] < stack[-4] // Inputs[4] // { // @02B6 stack[-2] // @02B7 stack[-1] // @02B9 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02BA stack[-3] // } 02B5 5B JUMPDEST 02B6 81 DUP2 02B7 81 DUP2 02B8 01 ADD 02B9 51 MLOAD 02BA 83 DUP4 02BB 82 DUP3 02BC 01 ADD 02BD 52 MSTORE 02BE 60 PUSH1 0x20 02C0 01 ADD 02C1 61 PUSH2 0x02a5 02C4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02BD memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02C0 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x02a5 label_02C5: // Incoming call from 0x17F7, returns to 0x02FB // Incoming call from 0x02FA, returns to 0x02FB // Incoming jump from 0x15CB // Inputs[3] // { // @02C6 stack[-2] // @02C6 stack[-1] // @02CE memory[stack[-1]:stack[-1] + 0x20] // } 02C5 5B JUMPDEST 02C6 90 SWAP1 02C7 60 PUSH1 0x20 02C9 91 SWAP2 02CA 61 PUSH2 0x02de 02CD 81 DUP2 02CE 51 MLOAD 02CF 80 DUP1 02D0 92 SWAP3 02D1 81 DUP2 02D2 85 DUP6 02D3 52 MSTORE 02D4 85 DUP6 02D5 80 DUP1 02D6 86 DUP7 02D7 01 ADD 02D8 91 SWAP2 02D9 01 ADD 02DA 61 PUSH2 0x02a2 02DD 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @02C6 stack[-1] = stack[-2] // @02C9 stack[-2] = 0x20 // @02CA stack[1] = 0x02de // @02CE stack[2] = memory[stack[-1]:stack[-1] + 0x20] // @02D0 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @02D3 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02D8 stack[3] = stack[-2] + 0x20 // @02D9 stack[4] = stack[-1] + 0x20 // } // Block ends with call to 0x02a2, returns to 0x02DE label_02DE: // Incoming return from call to 0x02A2 at 0x02DD // Inputs[4] // { // @02E1 stack[-1] // @02E6 stack[-2] // @02E7 stack[-3] // @02E8 stack[-4] // } 02DE 5B JUMPDEST 02DF 60 PUSH1 0x1f 02E1 01 ADD 02E2 60 PUSH1 0x1f 02E4 19 NOT 02E5 16 AND 02E6 01 ADD 02E7 01 ADD 02E8 90 SWAP1 02E9 56 *JUMP // Stack delta = -3 // Outputs[1] { @02E8 stack[-4] = (~0x1f & 0x1f + stack[-1]) + stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_02EA: // Incoming call from 0x0359, returns to 0x035A // Inputs[2] // { // @02EB stack[-1] // @02EB stack[-2] // } 02EA 5B JUMPDEST 02EB 90 SWAP1 02EC 60 PUSH1 0x20 02EE 61 PUSH2 0x02fb 02F1 92 SWAP3 02F2 81 DUP2 02F3 81 DUP2 02F4 52 MSTORE 02F5 01 ADD 02F6 90 SWAP1 02F7 61 PUSH2 0x02c5 02FA 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @02F1 stack[-2] = 0x02fb // @02F4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @02F6 stack[0] = stack[-2] // @02F6 stack[-1] = stack[-1] + 0x20 // } // Block ends with call to 0x02c5, returns to 0x02FB label_02FB: // Incoming return from call to 0x02C5 at 0x17F7 // Incoming return from call to 0x15BE at 0x15FD // Incoming return from call to 0x02C5 at 0x02FA // Incoming return from call to 0x1888 at 0x1887 // Incoming return from call to 0x07C6 at 0x080A // Inputs[2] // { // @02FC stack[-1] // @02FC stack[-2] // } 02FB 5B JUMPDEST 02FC 90 SWAP1 02FD 56 *JUMP // Stack delta = -1 // Outputs[1] { @02FC stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_02FE: // Incoming jump from 0x01B0 // Inputs[1] { @02FF msg.value } 02FE 5B JUMPDEST 02FF 34 CALLVALUE 0300 61 PUSH2 0x01cc 0303 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0304: // Incoming jump from 0x0303, if not msg.value // Inputs[1] { @0306 msg.data.length } 0304 60 PUSH1 0x20 0306 36 CALLDATASIZE 0307 60 PUSH1 0x03 0309 19 NOT 030A 01 ADD 030B 12 SLT 030C 61 PUSH2 0x01cc 030F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0310: // Incoming jump from 0x030F, if not ~0x03 + msg.data.length i< 0x20 // Inputs[6] // { // @0312 storage[0x08] // @0315 memory[0x40:0x60] // @0323 msg.data[0x04:0x24] // @033D msg.gas // @033E address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) // @033E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0310 60 PUSH1 0x08 0312 54 SLOAD 0313 60 PUSH1 0x40 0315 51 MLOAD 0316 63 PUSH4 0x03a24d07 031B 60 PUSH1 0xe2 031D 1B SHL 031E 81 DUP2 031F 52 MSTORE 0320 60 PUSH1 0x04 0322 80 DUP1 0323 35 CALLDATALOAD 0324 90 SWAP1 0325 82 DUP3 0326 01 ADD 0327 52 MSTORE 0328 60 PUSH1 0x00 032A 91 SWAP2 032B 82 DUP3 032C 90 SWAP1 032D 82 DUP3 032E 90 SWAP1 032F 60 PUSH1 0x24 0331 90 SWAP1 0332 82 DUP3 0333 90 SWAP1 0334 60 PUSH1 0x01 0336 60 PUSH1 0x01 0338 60 PUSH1 0xa0 033A 1B SHL 033B 03 SUB 033C 16 AND 033D 5A GAS 033E FA STATICCALL 033F 90 SWAP1 0340 81 DUP2 0341 15 ISZERO 0342 61 PUSH2 0x03e8 0345 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @031F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03a24d07 << 0xe2 // @0327 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.data[0x04:0x24] // @032A stack[0] = 0x00 // @033E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) // @033F stack[1] = address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) // @033F stack[2] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x03e8, if !address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) label_0346: // Incoming jump from 0x0345, if not !address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) // Inputs[2] // { // @0346 stack[-3] // @0347 stack[-2] // } 0346 82 DUP3 0347 91 SWAP2 0348 61 PUSH2 0x035e 034B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0347 stack[-2] = stack[-3] } // Block ends with conditional jump to 0x035e, if stack[-2] label_034C: // Incoming jump from 0x034B, if not stack[-2] // Incoming jump from 0x03DC // Inputs[2] // { // @034F memory[0x40:0x60] // @0354 stack[-2] // } 034C 5B JUMPDEST 034D 60 PUSH1 0x40 034F 51 MLOAD 0350 80 DUP1 0351 61 PUSH2 0x035a 0354 84 DUP5 0355 82 DUP3 0356 61 PUSH2 0x02ea 0359 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @034F stack[0] = memory[0x40:0x60] // @0350 stack[1] = memory[0x40:0x60] // @0351 stack[2] = 0x035a // @0354 stack[3] = stack[-2] // @0355 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x02ea, returns to 0x035A label_035A: // Incoming return from call to 0x0CFF at 0x0CAE // Incoming return from call to 0x02EA at 0x0359 // Inputs[4] // { // @035B stack[-2] // @035B stack[-1] // @035C stack[-3] // @035D memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]] // } 035A 5B JUMPDEST 035B 03 SUB 035C 90 SWAP1 035D F3 *RETURN // Stack delta = -3 // Outputs[1] { @035D return memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]; } // Block terminates label_035E: // Incoming jump from 0x034B, if stack[-2] // Inputs[5] // { // @035F stack[-2] // @035F stack[-1] // @0361 returndata.length // @0363 stack[-3] // @0365 returndata[stack[-3]:stack[-3] + returndata.length] // } 035E 5B JUMPDEST 035F 90 SWAP1 0360 50 POP 0361 3D RETURNDATASIZE 0362 80 DUP1 0363 83 DUP4 0364 83 DUP4 0365 3E RETURNDATACOPY 0366 61 PUSH2 0x036f 0369 81 DUP2 036A 83 DUP4 036B 61 PUSH2 0x0442 036E 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @035F stack[-2] = stack[-1] // @0361 stack[-1] = returndata.length // @0365 memory[stack[-1]:stack[-1] + returndata.length] = returndata[stack[-3]:stack[-3] + returndata.length] // @0366 stack[0] = 0x036f // @0369 stack[1] = returndata.length // @036A stack[2] = stack[-1] // } // Block ends with call to 0x0442, returns to 0x036F label_036F: // Incoming return from call to 0x0442 at 0x036E // Inputs[2] // { // @0370 stack[-2] // @0371 stack[-1] // } 036F 5B JUMPDEST 0370 81 DUP2 0371 01 ADD 0372 90 SWAP1 0373 60 PUSH1 0x20 0375 81 DUP2 0376 83 DUP4 0377 03 SUB 0378 12 SLT 0379 61 PUSH2 0x03e0 037C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0372 stack[-1] = stack[-2] // @0372 stack[-2] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x03e0, if (stack[-2] + stack[-1]) - stack[-2] i< 0x20 label_037D: // Incoming jump from 0x037C, if not (stack[-2] + stack[-1]) - stack[-2] i< 0x20 // Inputs[2] // { // @037D stack[-1] // @037E memory[stack[-1]:stack[-1] + 0x20] // } 037D 80 DUP1 037E 51 MLOAD 037F 90 SWAP1 0380 67 PUSH8 0xffffffffffffffff 0389 82 DUP3 038A 11 GT 038B 61 PUSH2 0x03e4 038E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @037F stack[0] = stack[-1] // @037F stack[-1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x03e4, if memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff label_038F: // Incoming jump from 0x038E, if not memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // Inputs[3] // { // @038F stack[-1] // @038F stack[-2] // @0390 stack[-3] // } 038F 01 ADD 0390 81 DUP2 0391 60 PUSH1 0x1f 0393 82 DUP3 0394 01 ADD 0395 12 SLT 0396 15 ISZERO 0397 61 PUSH2 0x03e0 039A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @038F stack[-2] = stack[-1] + stack[-2] } // Block ends with conditional jump to 0x03e0, if !(stack[-1] + stack[-2] + 0x1f i< stack[-3]) label_039B: // Incoming jump from 0x039A, if not !(stack[-1] + stack[-2] + 0x1f i< stack[-3]) // Inputs[3] // { // @039B stack[-1] // @039C memory[stack[-1]:stack[-1] + 0x20] // @039D stack[-3] // } 039B 80 DUP1 039C 51 MLOAD 039D 92 SWAP3 039E 61 PUSH2 0x03a6 03A1 84 DUP5 03A2 61 PUSH2 0x04dc 03A5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039D stack[0] = stack[-3] // @039D stack[-3] = memory[stack[-1]:stack[-1] + 0x20] // @039E stack[1] = 0x03a6 // @03A1 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x04dc, returns to 0x03A6 label_03A6: // Incoming return from call to 0x04DC at 0x03A5 // Inputs[3] // { // @03A7 stack[-4] // @03A7 stack[-1] // @03AD memory[0x40:0x60] // } 03A6 5B JUMPDEST 03A7 92 SWAP3 03A8 61 PUSH2 0x03b4 03AB 60 PUSH1 0x40 03AD 51 MLOAD 03AE 94 SWAP5 03AF 85 DUP6 03B0 61 PUSH2 0x0442 03B3 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @03A7 stack[-1] = stack[-4] // @03A8 stack[0] = 0x03b4 // @03AE stack[-4] = memory[0x40:0x60] // @03AE stack[1] = stack[-1] // @03AF stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x03B4 label_03B4: // Incoming return from call to 0x0442 at 0x03B3 // Inputs[4] // { // @03B5 stack[-5] // @03B6 stack[-4] // @03BB stack[-3] // @03BE stack[-1] // } 03B4 5B JUMPDEST 03B5 84 DUP5 03B6 84 DUP5 03B7 52 MSTORE 03B8 60 PUSH1 0x20 03BA 85 DUP6 03BB 84 DUP5 03BC 01 ADD 03BD 01 ADD 03BE 11 GT 03BF 61 PUSH2 0x03dd 03C2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @03B7 memory[stack[-4]:stack[-4] + 0x20] = stack[-5] } // Block ends with conditional jump to 0x03dd, if stack[-3] + stack[-5] + 0x20 > stack[-1] label_03C3: // Incoming jump from 0x03C2, if not stack[-3] + stack[-5] + 0x20 > stack[-1] // Inputs[3] // { // @03C7 stack[-4] // @03CB stack[-2] // @03CF stack[-3] // } 03C3 50 POP 03C4 61 PUSH2 0x035a 03C7 92 SWAP3 03C8 61 PUSH2 0x03d7 03CB 91 SWAP2 03CC 60 PUSH1 0x20 03CE 80 DUP1 03CF 85 DUP6 03D0 01 ADD 03D1 91 SWAP2 03D2 01 ADD 03D3 61 PUSH2 0x02a2 03D6 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @03C7 stack[-4] = 0x035a // @03C7 stack[-1] = stack[-4] // @03CB stack[-2] = 0x03d7 // @03D1 stack[0] = stack[-3] + 0x20 // @03D2 stack[1] = stack[-2] + 0x20 // } // Block ends with call to 0x02a2, returns to 0x03D7 label_03D7: // Incoming return from call to 0x02A2 at 0x03D6 // Inputs[1] { @03D8 code.length } 03D7 5B JUMPDEST 03D8 38 CODESIZE 03D9 61 PUSH2 0x034c 03DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D8 stack[0] = code.length } // Block ends with unconditional jump to 0x034c label_03DD: // Incoming jump from 0x0ABA, if msg.data.length + ~0x03 i< 0x00 // Incoming jump from 0x03C2, if stack[-3] + stack[-5] + 0x20 > stack[-1] // Inputs[2] // { // @03DE stack[-1] // @03DF memory[stack[-1]:stack[-1] + stack[-1]] // } 03DD 5B JUMPDEST 03DE 80 DUP1 03DF FD *REVERT // Stack delta = -1 // Outputs[1] { @03DF revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_03E0: // Incoming jump from 0x039A, if !(stack[-1] + stack[-2] + 0x1f i< stack[-3]) // Incoming jump from 0x037C, if (stack[-2] + stack[-1]) - stack[-2] i< 0x20 // Inputs[2] // { // @03E1 stack[-3] // @03E3 memory[stack[-3]:stack[-3] + stack[-3]] // } 03E0 5B JUMPDEST 03E1 82 DUP3 03E2 80 DUP1 03E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E3 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_03E4: // Incoming jump from 0x038E, if memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // Inputs[2] // { // @03E5 stack[-4] // @03E7 memory[stack[-4]:stack[-4] + stack[-4]] // } 03E4 5B JUMPDEST 03E5 83 DUP4 03E6 80 DUP1 03E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E7 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_03E8: // Incoming jump from 0x0345, if !address((0x01 << 0xa0) - 0x01 & storage[0x08]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]) // Incoming jump from 0x06DA, if !address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) 03E8 5B JUMPDEST 03E9 61 PUSH2 0x10b3 03EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10b3 label_03ED: // Incoming jump from 0x01AB // Inputs[1] { @03EE msg.value } 03ED 5B JUMPDEST 03EE 34 CALLVALUE 03EF 61 PUSH2 0x01cc 03F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_03F3: // Incoming jump from 0x03F2, if not msg.value // Inputs[1] { @03F5 msg.data.length } 03F3 60 PUSH1 0x00 03F5 36 CALLDATASIZE 03F6 60 PUSH1 0x03 03F8 19 NOT 03F9 01 ADD 03FA 12 SLT 03FB 61 PUSH2 0x01cc 03FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x00 label_03FF: // Incoming jump from 0x03FE, if not ~0x03 + msg.data.length i< 0x00 // Inputs[3] // { // @0403 storage[0x04] // @0406 memory[0x40:0x60] // @040A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 03FF 60 PUSH1 0x20 0401 60 PUSH1 0x04 0403 54 SLOAD 0404 60 PUSH1 0x40 0406 51 MLOAD 0407 90 SWAP1 0408 81 DUP2 0409 52 MSTORE 040A F3 *RETURN // Stack delta = +0 // Outputs[2] // { // @0409 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x04] // @040A return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_040B: // Incoming jump from 0x0441 // Inputs[1] { @0420 memory[0x00:0x24] } 040B 5B JUMPDEST 040C 63 PUSH4 0x4e487b71 0411 60 PUSH1 0xe0 0413 1B SHL 0414 60 PUSH1 0x00 0416 52 MSTORE 0417 60 PUSH1 0x41 0419 60 PUSH1 0x04 041B 52 MSTORE 041C 60 PUSH1 0x24 041E 60 PUSH1 0x00 0420 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0416 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @041B memory[0x04:0x24] = 0x41 // @0420 revert(memory[0x00:0x24]); // } // Block terminates label_0421: // Incoming call from 0x1067, returns to 0x0A3F // Incoming call from 0x0A3E, returns to 0x0A3F // Incoming call from 0x1173, returns to 0x1174 // Inputs[1] { @0424 stack[-1] } 0421 5B JUMPDEST 0422 60 PUSH1 0x20 0424 81 DUP2 0425 01 ADD 0426 90 SWAP1 0427 81 DUP2 0428 10 LT 0429 67 PUSH8 0xffffffffffffffff 0432 82 DUP3 0433 11 GT 0434 17 OR 0435 61 PUSH2 0x043d 0438 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0426 stack[-1] = stack[-1] + 0x20 } // Block ends with conditional jump to 0x043d, if (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) label_0439: // Incoming jump from 0x0438, if not (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) // Inputs[2] // { // @043B stack[-1] // @043C stack[-2] // } 0439 60 PUSH1 0x40 043B 52 MSTORE 043C 56 *JUMP // Stack delta = -2 // Outputs[1] { @043B memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_043D: // Incoming jump from 0x04EB, if stack[-1] > 0xffffffffffffffff // Incoming jump from 0x045F, if (stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1]) // Incoming jump from 0x0473, if stack[-1] > 0xffffffffffffffff // Incoming jump from 0x0438, if (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) 043D 5B JUMPDEST 043E 61 PUSH2 0x040b 0441 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x040b label_0442: // Incoming call from 0x138E, returns to 0x138F // Incoming call from 0x0855, returns to 0x0856 // Incoming call from 0x036E, returns to 0x036F // Incoming call from 0x11D0, returns to 0x11D1 // Incoming call from 0x051C, returns to 0x051D // Incoming call from 0x03B3, returns to 0x03B4 // Incoming call from 0x0707, returns to 0x0708 // Incoming jump from 0x0CFE // Incoming call from 0x04A3, returns to 0x04A4 // Inputs[2] // { // @0443 stack[-1] // @0443 stack[-2] // } 0442 5B JUMPDEST 0443 90 SWAP1 0444 60 PUSH1 0x1f 0446 80 DUP1 0447 19 NOT 0448 91 SWAP2 0449 01 ADD 044A 16 AND 044B 81 DUP2 044C 01 ADD 044D 90 SWAP1 044E 81 DUP2 044F 10 LT 0450 67 PUSH8 0xffffffffffffffff 0459 82 DUP3 045A 11 GT 045B 17 OR 045C 61 PUSH2 0x043d 045F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @044D stack[-2] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x043d, if (stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1]) label_0460: // Incoming jump from 0x045F, if not (stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1]) // Inputs[2] // { // @0462 stack[-1] // @0463 stack[-2] // } 0460 60 PUSH1 0x40 0462 52 MSTORE 0463 56 *JUMP // Stack delta = -2 // Outputs[1] { @0462 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0464: // Incoming call from 0x0495, returns to 0x0496 // Incoming call from 0x11C2, returns to 0x11C3 // Incoming jump from 0x11D8 // Incoming call from 0x0847, returns to 0x0848 // Inputs[1] { @046E stack[-1] } 0464 5B JUMPDEST 0465 67 PUSH8 0xffffffffffffffff 046E 81 DUP2 046F 11 GT 0470 61 PUSH2 0x043d 0473 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043d, if stack[-1] > 0xffffffffffffffff label_0474: // Incoming jump from 0x0473, if not stack[-1] > 0xffffffffffffffff // Inputs[2] // { // @0476 stack[-1] // @047A stack[-2] // } 0474 60 PUSH1 0x05 0476 1B SHL 0477 60 PUSH1 0x20 0479 01 ADD 047A 90 SWAP1 047B 56 *JUMP // Stack delta = -1 // Outputs[1] { @047A stack[-2] = 0x20 + (stack[-1] << 0x05) } // Block ends with unconditional jump to stack[-2] label_047C: // Incoming call from 0x089C, returns to 0x089D // Incoming call from 0x0589, returns to 0x058A // Incoming call from 0x0A0E, returns to 0x0A0F // Incoming call from 0x09F5, returns to 0x09F6 // Incoming call from 0x05A1, returns to 0x05A2 // Inputs[2] // { // @047D stack[-1] // @047D stack[-2] // } 047C 5B JUMPDEST 047D 90 SWAP1 047E 80 DUP1 047F 60 PUSH1 0x1f 0481 83 DUP4 0482 01 ADD 0483 12 SLT 0484 15 ISZERO 0485 61 PUSH2 0x01cc 0488 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @047D stack[-1] = stack[-2] // @047D stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x01cc, if !(stack[-1] + 0x1f i< stack[-2]) label_0489: // Incoming jump from 0x0488, if not !(stack[-1] + 0x1f i< stack[-2]) // Inputs[3] // { // @048B stack[-1] // @048C stack[-2] // @048D msg.data[stack[-2]:stack[-2] + 0x20] // } 0489 60 PUSH1 0x20 048B 90 SWAP1 048C 82 DUP3 048D 35 CALLDATALOAD 048E 61 PUSH2 0x0496 0491 81 DUP2 0492 61 PUSH2 0x0464 0495 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @048B stack[0] = stack[-1] // @048B stack[-1] = 0x20 // @048D stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @048E stack[2] = 0x0496 // @0491 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0464, returns to 0x0496 label_0496: // Incoming return from call to 0x0464 at 0x0495 // Inputs[3] // { // @0497 stack[-5] // @0497 stack[-1] // @049D memory[0x40:0x60] // } 0496 5B JUMPDEST 0497 93 SWAP4 0498 61 PUSH2 0x04a4 049B 60 PUSH1 0x40 049D 51 MLOAD 049E 95 SWAP6 049F 86 DUP7 04A0 61 PUSH2 0x0442 04A3 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0497 stack[-1] = stack[-5] // @0498 stack[0] = 0x04a4 // @049E stack[-5] = memory[0x40:0x60] // @049E stack[1] = stack[-1] // @049F stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x04A4 label_04A4: // Incoming return from call to 0x0442 at 0x04A3 // Inputs[4] // { // @04A5 stack[-2] // @04A6 stack[-5] // @04B1 stack[-1] // @04B4 stack[-3] // } 04A4 5B JUMPDEST 04A5 81 DUP2 04A6 85 DUP6 04A7 52 MSTORE 04A8 60 PUSH1 0x20 04AA 80 DUP1 04AB 86 DUP7 04AC 01 ADD 04AD 92 SWAP3 04AE 60 PUSH1 0x05 04B0 1B SHL 04B1 82 DUP3 04B2 01 ADD 04B3 01 ADD 04B4 92 SWAP3 04B5 83 DUP4 04B6 11 GT 04B7 61 PUSH2 0x01cc 04BA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @04A7 memory[stack[-5]:stack[-5] + 0x20] = stack[-2] // @04AD stack[-2] = stack[-5] + 0x20 // @04B4 stack[-3] = stack[-1] + (stack[-2] << 0x05) + 0x20 // } // Block ends with conditional jump to 0x01cc, if stack[-1] + (stack[-2] << 0x05) + 0x20 > stack[-3] label_04BB: // Incoming jump from 0x04BA, if not stack[-1] + (stack[-2] << 0x05) + 0x20 > stack[-3] // Inputs[3] // { // @04BD stack[-1] // @04BE stack[-2] // @04C0 stack[-3] // } 04BB 60 PUSH1 0x20 04BD 01 ADD 04BE 90 SWAP1 04BF 5B JUMPDEST 04C0 82 DUP3 04C1 82 DUP3 04C2 10 LT 04C3 61 PUSH2 0x04cd 04C6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @04BE stack[-1] = stack[-2] // @04BE stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x04cd, if 0x20 + stack[-1] < stack[-3] label_04C7: // Incoming jump from 0x04C6, if not 0x20 + stack[-1] < stack[-3] // Incoming jump from 0x04C6, if not stack[-2] < stack[-3] // Inputs[2] // { // @04CB stack[-5] // @04CB stack[-6] // } 04C7 50 POP 04C8 50 POP 04C9 50 POP 04CA 50 POP 04CB 90 SWAP1 04CC 56 *JUMP // Stack delta = -5 // Outputs[1] { @04CB stack[-6] = stack[-5] } // Block ends with unconditional jump to stack[-6] label_04CD: // Incoming jump from 0x04C6, if 0x20 + stack[-1] < stack[-3] // Incoming jump from 0x04C6, if stack[-2] < stack[-3] // Inputs[4] // { // @04CE stack[-2] // @04CF msg.data[stack[-2]:stack[-2] + 0x20] // @04D0 stack[-1] // @04D3 stack[-4] // } 04CD 5B JUMPDEST 04CE 81 DUP2 04CF 35 CALLDATALOAD 04D0 81 DUP2 04D1 52 MSTORE 04D2 90 SWAP1 04D3 83 DUP4 04D4 01 ADD 04D5 90 SWAP1 04D6 83 DUP4 04D7 01 ADD 04D8 61 PUSH2 0x04bf 04DB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04D1 memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @04D5 stack[-2] = stack[-4] + stack[-2] // @04D7 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x04bf label_04DC: // Incoming call from 0x1380, returns to 0x1381 // Incoming call from 0x03A5, returns to 0x03A6 // Incoming call from 0x050E, returns to 0x050F // Inputs[1] { @04E6 stack[-1] } 04DC 5B JUMPDEST 04DD 67 PUSH8 0xffffffffffffffff 04E6 81 DUP2 04E7 11 GT 04E8 61 PUSH2 0x043d 04EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043d, if stack[-1] > 0xffffffffffffffff label_04EC: // Incoming jump from 0x04EB, if not stack[-1] > 0xffffffffffffffff // Inputs[2] // { // @04EE stack[-1] // @04F6 stack[-2] // } 04EC 60 PUSH1 0x1f 04EE 01 ADD 04EF 60 PUSH1 0x1f 04F1 19 NOT 04F2 16 AND 04F3 60 PUSH1 0x20 04F5 01 ADD 04F6 90 SWAP1 04F7 56 *JUMP // Stack delta = -1 // Outputs[1] { @04F6 stack[-2] = 0x20 + (~0x1f & 0x1f + stack[-1]) } // Block ends with unconditional jump to stack[-2] label_04F8: // Incoming call from 0x05B9, returns to 0x05BA // Incoming call from 0x0C78, returns to 0x0C79 // Incoming call from 0x0CAE, returns to 0x0CAF // Incoming call from 0x0C90, returns to 0x0C91 // Incoming call from 0x0E95, returns to 0x0E96 // Inputs[2] // { // @04F9 stack[-2] // @04FC stack[-1] // } 04F8 5B JUMPDEST 04F9 81 DUP2 04FA 60 PUSH1 0x1f 04FC 82 DUP3 04FD 01 ADD 04FE 12 SLT 04FF 15 ISZERO 0500 61 PUSH2 0x01cc 0503 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if !(stack[-1] + 0x1f i< stack[-2]) label_0504: // Incoming jump from 0x0503, if not !(stack[-1] + 0x1f i< stack[-2]) // Inputs[2] // { // @0504 stack[-1] // @0505 msg.data[stack[-1]:stack[-1] + 0x20] // } 0504 80 DUP1 0505 35 CALLDATALOAD 0506 90 SWAP1 0507 61 PUSH2 0x050f 050A 82 DUP3 050B 61 PUSH2 0x04dc 050E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0506 stack[0] = stack[-1] // @0506 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0507 stack[1] = 0x050f // @050A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x04dc, returns to 0x050F label_050F: // Incoming return from call to 0x04DC at 0x050E // Inputs[3] // { // @0510 stack[-4] // @0510 stack[-1] // @0516 memory[0x40:0x60] // } 050F 5B JUMPDEST 0510 92 SWAP3 0511 61 PUSH2 0x051d 0514 60 PUSH1 0x40 0516 51 MLOAD 0517 94 SWAP5 0518 85 DUP6 0519 61 PUSH2 0x0442 051C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0510 stack[-1] = stack[-4] // @0511 stack[0] = 0x051d // @0517 stack[-4] = memory[0x40:0x60] // @0517 stack[1] = stack[-1] // @0518 stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x051D label_051D: // Incoming return from call to 0x0442 at 0x051C // Inputs[4] // { // @051E stack[-3] // @051F stack[-4] // @0524 stack[-2] // @0527 stack[-1] // } 051D 5B JUMPDEST 051E 82 DUP3 051F 84 DUP5 0520 52 MSTORE 0521 60 PUSH1 0x20 0523 83 DUP4 0524 83 DUP4 0525 01 ADD 0526 01 ADD 0527 11 GT 0528 61 PUSH2 0x01cc 052B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0520 memory[stack[-4]:stack[-4] + 0x20] = stack[-3] } // Block ends with conditional jump to 0x01cc, if stack[-2] + stack[-3] + 0x20 > stack[-1] label_052C: // Incoming jump from 0x052B, if not stack[-2] + stack[-3] + 0x20 > stack[-1] // Inputs[5] // { // @052C stack[-2] // @0533 stack[-1] // @0536 stack[-3] // @0538 msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] // @053D stack[-4] // } 052C 81 DUP2 052D 60 PUSH1 0x00 052F 92 SWAP3 0530 60 PUSH1 0x20 0532 80 DUP1 0533 93 SWAP4 0534 01 ADD 0535 83 DUP4 0536 86 DUP7 0537 01 ADD 0538 37 CALLDATACOPY 0539 83 DUP4 053A 01 ADD 053B 01 ADD 053C 52 MSTORE 053D 90 SWAP1 053E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0538 memory[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] = msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] // @053C memory[stack[-3] + stack[-2] + 0x20:stack[-3] + stack[-2] + 0x20 + 0x20] = 0x00 // @053D stack[-4] = stack[-3] // } // Block ends with unconditional jump to stack[-4] label_053F: // Incoming jump from 0x01A6 // Inputs[1] { @0540 msg.value } 053F 5B JUMPDEST 0540 34 CALLVALUE 0541 61 PUSH2 0x01cc 0544 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0545: // Incoming jump from 0x0544, if not msg.value // Inputs[1] { @0547 msg.data.length } 0545 60 PUSH1 0xa0 0547 36 CALLDATASIZE 0548 60 PUSH1 0x03 054A 19 NOT 054B 01 ADD 054C 12 SLT 054D 61 PUSH2 0x01cc 0550 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0xa0 label_0551: // Incoming jump from 0x0550, if not ~0x03 + msg.data.length i< 0xa0 // Inputs[1] { @0554 msg.data[0x04:0x24] } 0551 60 PUSH1 0x04 0553 80 DUP1 0554 35 CALLDATALOAD 0555 61 PUSH2 0x055d 0558 81 DUP2 0559 61 PUSH2 0x01bb 055C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0551 stack[0] = 0x04 // @0554 stack[1] = msg.data[0x04:0x24] // @0555 stack[2] = 0x055d // @0558 stack[3] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x055D label_055D: // Incoming return from call to 0x01BB at 0x055C // Inputs[1] { @0560 msg.data[0x24:0x44] } 055D 5B JUMPDEST 055E 60 PUSH1 0x24 0560 35 CALLDATALOAD 0561 61 PUSH2 0x0569 0564 81 DUP2 0565 61 PUSH2 0x01bb 0568 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0560 stack[0] = msg.data[0x24:0x44] // @0561 stack[1] = 0x0569 // @0564 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x01bb, returns to 0x0569 label_0569: // Incoming return from call to 0x01BB at 0x0568 // Inputs[2] // { // @0573 stack[-1] // @0576 msg.data[0x44:0x64] // } 0569 5B JUMPDEST 056A 67 PUSH8 0xffffffffffffffff 0573 90 SWAP1 0574 60 PUSH1 0x44 0576 35 CALLDATALOAD 0577 82 DUP3 0578 81 DUP2 0579 11 GT 057A 61 PUSH2 0x01cc 057D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0573 stack[0] = stack[-1] // @0573 stack[-1] = 0xffffffffffffffff // @0576 stack[1] = msg.data[0x44:0x64] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x44:0x64] > 0xffffffffffffffff label_057E: // Incoming jump from 0x057D, if not msg.data[0x44:0x64] > 0xffffffffffffffff // Inputs[3] // { // @0581 stack[-1] // @0582 msg.data.length // @0584 stack[-5] // } 057E 61 PUSH2 0x058a 0581 90 SWAP1 0582 36 CALLDATASIZE 0583 90 SWAP1 0584 86 DUP7 0585 01 ADD 0586 61 PUSH2 0x047c 0589 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0581 stack[-1] = 0x058a // @0583 stack[0] = msg.data.length // @0585 stack[1] = stack[-5] + stack[-1] // } // Block ends with call to 0x047c, returns to 0x058A label_058A: // Incoming return from call to 0x047C at 0x0589 // Inputs[4] // { // @058B stack[-2] // @058B stack[-1] // @058E msg.data[0x64:0x84] // @058F stack[-3] // } 058A 5B JUMPDEST 058B 90 SWAP1 058C 60 PUSH1 0x64 058E 35 CALLDATALOAD 058F 83 DUP4 0590 81 DUP2 0591 11 GT 0592 61 PUSH2 0x01cc 0595 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @058B stack[-2] = stack[-1] // @058B stack[-1] = stack[-2] // @058E stack[0] = msg.data[0x64:0x84] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x64:0x84] > stack[-3] label_0596: // Incoming jump from 0x0595, if not msg.data[0x64:0x84] > stack[-3] // Inputs[3] // { // @0599 stack[-1] // @059A msg.data.length // @059C stack[-6] // } 0596 61 PUSH2 0x05a2 0599 90 SWAP1 059A 36 CALLDATASIZE 059B 90 SWAP1 059C 87 DUP8 059D 01 ADD 059E 61 PUSH2 0x047c 05A1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0599 stack[-1] = 0x05a2 // @059B stack[0] = msg.data.length // @059D stack[1] = stack[-6] + stack[-1] // } // Block ends with call to 0x047c, returns to 0x05A2 label_05A2: // Incoming return from call to 0x047C at 0x05A1 // Inputs[3] // { // @05A3 stack[-4] // @05A3 stack[-1] // @05A6 msg.data[0x84:0xa4] // } 05A2 5B JUMPDEST 05A3 92 SWAP3 05A4 60 PUSH1 0x84 05A6 35 CALLDATALOAD 05A7 90 SWAP1 05A8 81 DUP2 05A9 11 GT 05AA 61 PUSH2 0x01cc 05AD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @05A3 stack[-4] = stack[-1] // @05A7 stack[-1] = msg.data[0x84:0xa4] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x84:0xa4] > stack[-4] label_05AE: // Incoming jump from 0x05AD, if not msg.data[0x84:0xa4] > stack[-4] // Inputs[3] // { // @05B1 stack[-1] // @05B2 msg.data.length // @05B4 stack[-6] // } 05AE 61 PUSH2 0x05ba 05B1 90 SWAP1 05B2 36 CALLDATASIZE 05B3 90 SWAP1 05B4 87 DUP8 05B5 01 ADD 05B6 61 PUSH2 0x04f8 05B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05B1 stack[-1] = 0x05ba // @05B3 stack[0] = msg.data.length // @05B5 stack[1] = stack[-6] + stack[-1] // } // Block ends with call to 0x04f8, returns to 0x05BA label_05BA: // Incoming return from call to 0x04F8 at 0x05B9 // Inputs[3] // { // @05BB stack[-5] // @05BB stack[-1] // @05C8 msg.sender // } 05BA 5B JUMPDEST 05BB 93 SWAP4 05BC 60 PUSH1 0x01 05BE 60 PUSH1 0x01 05C0 60 PUSH1 0xa0 05C2 1B SHL 05C3 03 SUB 05C4 80 DUP1 05C5 82 DUP3 05C6 16 AND 05C7 90 SWAP1 05C8 33 CALLER 05C9 82 DUP3 05CA 14 EQ 05CB 15 ISZERO 05CC 80 DUP1 05CD 61 PUSH2 0x0649 05D0 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @05BB stack[-1] = stack[-5] // @05BB stack[-5] = stack[-1] // @05C7 stack[0] = stack[-5] & (0x01 << 0xa0) - 0x01 // @05C7 stack[1] = (0x01 << 0xa0) - 0x01 // @05CB stack[2] = !(stack[-5] & (0x01 << 0xa0) - 0x01 == msg.sender) // } // Block ends with conditional jump to 0x0649, if !(stack[-5] & (0x01 << 0xa0) - 0x01 == msg.sender) label_05D1: // Incoming jump from 0x066C // Incoming jump from 0x05D0, if not !(stack[-5] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @05D5 stack[-1] } 05D1 5B JUMPDEST 05D2 61 PUSH2 0x061c 05D5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x061c, if stack[-1] label_05D6: // Incoming jump from 0x05D5, if not stack[-1] // Inputs[2] // { // @05D6 stack[-4] // @05D7 stack[-1] // } 05D6 83 DUP4 05D7 16 AND 05D8 15 ISZERO 05D9 61 PUSH2 0x0604 05DC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0604, if !(stack[-4] & stack[-1]) label_05DD: // Incoming jump from 0x05DC, if not !(stack[-4] & stack[-1]) // Inputs[1] { @05DD stack[-1] } 05DD 15 ISZERO 05DE 61 PUSH2 0x05ed 05E1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05ed, if !stack[-1] label_05E2: // Incoming jump from 0x05E1, if not !stack[-1] // Inputs[1] { @05E5 stack[-6] } 05E2 61 PUSH2 0x05eb 05E5 95 SWAP6 05E6 50 POP 05E7 61 PUSH2 0x1451 05EA 56 *JUMP // Stack delta = +0 // Outputs[1] { @05E5 stack[-6] = 0x05eb } // Block ends with call to 0x1451, returns to 0x05EB label_05EB: // Incoming return from call to 0x0EEF at 0x0EEE // Incoming return from call to 0x1451 at 0x05EA // Incoming return from call to 0x1059 at 0x1058 05EB 5B JUMPDEST 05EC 00 *STOP // Stack delta = +0 // Outputs[1] { @05EC stop(); } // Block terminates label_05ED: // Incoming jump from 0x05E1, if !stack[-1] // Inputs[3] // { // @05F0 memory[0x40:0x60] // @05FD stack[-6] // @0603 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 05ED 5B JUMPDEST 05EE 60 PUSH1 0x40 05F0 51 MLOAD 05F1 62 PUSH3 0x6a0d45 05F5 60 PUSH1 0xe2 05F7 1B SHL 05F8 81 DUP2 05F9 52 MSTORE 05FA 60 PUSH1 0x00 05FC 81 DUP2 05FD 88 DUP9 05FE 01 ADD 05FF 52 MSTORE 0600 60 PUSH1 0x24 0602 90 SWAP1 0603 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @05F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6a0d45 << 0xe2 // @05FF memory[stack[-6] + memory[0x40:0x60]:stack[-6] + memory[0x40:0x60] + 0x20] = 0x00 // @0603 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_0604: // Incoming jump from 0x05DC, if !(stack[-4] & stack[-1]) // Inputs[3] // { // @0607 memory[0x40:0x60] // @0615 stack[-7] // @061B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0604 5B JUMPDEST 0605 60 PUSH1 0x40 0607 51 MLOAD 0608 63 PUSH4 0x2bfa23e7 060D 60 PUSH1 0xe1 060F 1B SHL 0610 81 DUP2 0611 52 MSTORE 0612 60 PUSH1 0x00 0614 81 DUP2 0615 89 DUP10 0616 01 ADD 0617 52 MSTORE 0618 60 PUSH1 0x24 061A 90 SWAP1 061B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0611 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2bfa23e7 << 0xe1 // @0617 memory[stack[-7] + memory[0x40:0x60]:stack[-7] + memory[0x40:0x60] + 0x20] = 0x00 // @061B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_061C: // Incoming jump from 0x05D5, if stack[-1] // Inputs[5] // { // @0620 memory[0x40:0x60] // @062B msg.sender // @062D stack[-8] // @063A stack[-3] // @0648 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-8] + memory[0x40:0x60] + 0x40) - memory[0x40:0x60]] // } 061C 5B JUMPDEST 061D 60 PUSH1 0x40 061F 80 DUP1 0620 51 MLOAD 0621 63 PUSH4 0x711bec91 0626 60 PUSH1 0xe1 0628 1B SHL 0629 81 DUP2 062A 52 MSTORE 062B 33 CALLER 062C 81 DUP2 062D 8B DUP12 062E 01 ADD 062F 90 SWAP1 0630 81 DUP2 0631 52 MSTORE 0632 60 PUSH1 0x01 0634 60 PUSH1 0x01 0636 60 PUSH1 0xa0 0638 1B SHL 0639 03 SUB 063A 86 DUP7 063B 16 AND 063C 60 PUSH1 0x20 063E 82 DUP3 063F 01 ADD 0640 52 MSTORE 0641 90 SWAP1 0642 91 SWAP2 0643 82 DUP3 0644 91 SWAP2 0645 01 ADD 0646 03 SUB 0647 90 SWAP1 0648 FD *REVERT // Stack delta = +0 // Outputs[4] // { // @062A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x711bec91 << 0xe1 // @0631 memory[stack[-8] + memory[0x40:0x60]:stack[-8] + memory[0x40:0x60] + 0x20] = msg.sender // @0640 memory[stack[-8] + memory[0x40:0x60] + 0x20:stack[-8] + memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0648 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-8] + memory[0x40:0x60] + 0x40) - memory[0x40:0x60]]); // } // Block terminates label_0649: // Incoming jump from 0x05D0, if !(stack[-5] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[5] // { // @064D stack[-3] // @065B memory[0x00:0x40] // @065C msg.sender // @0663 memory[0x00:0x40] // @0664 storage[keccak256(memory[0x00:0x40])] // } 0649 5B JUMPDEST 064A 50 POP 064B 60 PUSH1 0x00 064D 82 DUP3 064E 81 DUP2 064F 52 MSTORE 0650 60 PUSH1 0x01 0652 60 PUSH1 0x20 0654 90 SWAP1 0655 81 DUP2 0656 52 MSTORE 0657 60 PUSH1 0x40 0659 80 DUP1 065A 83 DUP4 065B 20 SHA3 065C 33 CALLER 065D 84 DUP5 065E 52 MSTORE 065F 90 SWAP1 0660 91 SWAP2 0661 52 MSTORE 0662 90 SWAP1 0663 20 SHA3 0664 54 SLOAD 0665 60 PUSH1 0xff 0667 16 AND 0668 15 ISZERO 0669 61 PUSH2 0x05d1 066C 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @064F memory[0x00:0x20] = stack[-3] // @0656 memory[0x20:0x40] = 0x01 // @065E memory[0x00:0x20] = msg.sender // @0661 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0668 stack[-1] = !(0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to 0x05d1 label_066D: // Incoming jump from 0x01A1 // Inputs[1] { @066E msg.value } 066D 5B JUMPDEST 066E 34 CALLVALUE 066F 61 PUSH2 0x01cc 0672 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0673: // Incoming jump from 0x0672, if not msg.value // Inputs[1] { @0675 msg.data.length } 0673 60 PUSH1 0x60 0675 36 CALLDATASIZE 0676 60 PUSH1 0x03 0678 19 NOT 0679 01 ADD 067A 12 SLT 067B 61 PUSH2 0x01cc 067E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x60 label_067F: // Incoming jump from 0x067E, if not ~0x03 + msg.data.length i< 0x60 // Inputs[1] { @0683 msg.data[0x04:0x24] } 067F 60 PUSH1 0x44 0681 60 PUSH1 0x04 0683 35 CALLDATALOAD 0684 61 PUSH2 0x068c 0687 81 DUP2 0688 61 PUSH2 0x01bb 068B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @067F stack[0] = 0x44 // @0683 stack[1] = msg.data[0x04:0x24] // @0684 stack[2] = 0x068c // @0687 stack[3] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x068C label_068C: // Incoming return from call to 0x01BB at 0x068B // Inputs[1] { @0691 msg.data[0x24:0x44] } 068C 5B JUMPDEST 068D 60 PUSH1 0x20 068F 60 PUSH1 0x24 0691 35 CALLDATALOAD 0692 61 PUSH2 0x069a 0695 81 DUP2 0696 61 PUSH2 0x01bb 0699 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @068D stack[0] = 0x20 // @0691 stack[1] = msg.data[0x24:0x44] // @0692 stack[2] = 0x069a // @0695 stack[3] = msg.data[0x24:0x44] // } // Block ends with call to 0x01bb, returns to 0x069A label_069A: // Incoming return from call to 0x01BB at 0x0699 069A 5B JUMPDEST 069B 61 PUSH2 0x06a2 069E 61 PUSH2 0x1263 06A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @069B stack[0] = 0x06a2 } // Block ends with call to 0x1263, returns to 0x06A2 label_06A2: // Incoming return from call to 0x1263 at 0x06A1 // Inputs[9] // { // @06A5 memory[0x40:0x60] // @06B8 stack[-1] // @06C0 stack[-4] // @06C1 msg.data[stack[-4]:stack[-4] + 0x20] // @06CB stack[-3] // @06D3 msg.gas // @06D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]] // @06D4 stack[-2] // @06D4 address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) // } 06A2 5B JUMPDEST 06A3 60 PUSH1 0x40 06A5 51 MLOAD 06A6 63 PUSH4 0xa9059cbb 06AB 60 PUSH1 0xe0 06AD 1B SHL 06AE 81 DUP2 06AF 52 MSTORE 06B0 60 PUSH1 0x01 06B2 60 PUSH1 0x01 06B4 60 PUSH1 0xa0 06B6 1B SHL 06B7 03 SUB 06B8 91 SWAP2 06B9 82 DUP3 06BA 16 AND 06BB 60 PUSH1 0x04 06BD 82 DUP3 06BE 01 ADD 06BF 52 MSTORE 06C0 84 DUP5 06C1 35 CALLDATALOAD 06C2 60 PUSH1 0x24 06C4 82 DUP3 06C5 01 ADD 06C6 52 MSTORE 06C7 60 PUSH1 0x00 06C9 94 SWAP5 06CA 90 SWAP1 06CB 93 SWAP4 06CC 84 DUP5 06CD 92 SWAP3 06CE 83 DUP4 06CF 91 SWAP2 06D0 87 DUP8 06D1 91 SWAP2 06D2 16 AND 06D3 5A GAS 06D4 F1 CALL 06D5 80 DUP1 06D6 15 ISZERO 06D7 61 PUSH2 0x03e8 06DA 57 *JUMPI // Stack delta = -1 // Outputs[7] // { // @06AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa9059cbb << 0xe0 // @06BF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06C6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = msg.data[stack[-4]:stack[-4] + 0x20] // @06C9 stack[-4] = 0x00 // @06CB stack[-3] = memory[0x40:0x60] // @06D4 stack[-2] = address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) // @06D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2]] = address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) // } // Block ends with conditional jump to 0x03e8, if !address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) label_06DB: // Incoming jump from 0x06DA, if not !address((0x01 << 0xa0) - 0x01 & stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-4]]) // Inputs[2] // { // @06DB stack[-3] // @06DC stack[-1] // } 06DB 82 DUP3 06DC 90 SWAP1 06DD 61 PUSH2 0x06ee 06E0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06DC stack[-1] = stack[-3] } // Block ends with conditional jump to 0x06ee, if stack[-1] label_06E1: // Incoming jump from 0x0722 // Incoming jump from 0x06E0, if not stack[-1] // Inputs[1] { @06E5 stack[-2] } 06E1 5B JUMPDEST 06E2 61 PUSH2 0x06eb 06E5 91 SWAP2 06E6 50 POP 06E7 61 PUSH2 0x10bf 06EA 56 *JUMP // Stack delta = +0 // Outputs[1] { @06E5 stack[-2] = 0x06eb } // Block ends with call to 0x10bf, returns to 0x06EB label_06EB: // Incoming return from call to 0x10BF at 0x06EA // Inputs[2] // { // @06EC stack[-1] // @06ED memory[stack[-1]:stack[-1] + stack[-1]] // } 06EB 5B JUMPDEST 06EC 80 DUP1 06ED F3 *RETURN // Stack delta = -1 // Outputs[1] { @06ED return memory[stack[-1]:stack[-1] + stack[-1]]; } // Block terminates label_06EE: // Incoming jump from 0x06E0, if stack[-1] // Inputs[2] // { // @06F2 stack[-2] // @06F3 returndata.length // } 06EE 5B JUMPDEST 06EF 50 POP 06F0 60 PUSH1 0x20 06F2 81 DUP2 06F3 3D RETURNDATASIZE 06F4 60 PUSH1 0x20 06F6 11 GT 06F7 61 PUSH2 0x0727 06FA 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @06F0 stack[-1] = 0x20 // @06F2 stack[0] = stack[-2] // } // Block ends with conditional jump to 0x0727, if 0x20 > returndata.length label_06FB: // Incoming jump from 0x06FA, if not 0x20 > returndata.length // Incoming jump from 0x072E // Inputs[2] // { // @06FC stack[-2] // @0703 stack[-1] // } 06FB 5B JUMPDEST 06FC 81 DUP2 06FD 61 PUSH2 0x0708 0700 60 PUSH1 0x20 0702 93 SWAP4 0703 83 DUP4 0704 61 PUSH2 0x0442 0707 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @06FC stack[0] = stack[-2] // @06FD stack[1] = 0x0708 // @0702 stack[2] = stack[-2] // @0702 stack[-2] = 0x20 // @0703 stack[3] = stack[-1] // } // Block ends with call to 0x0442, returns to 0x0708 label_0708: // Incoming return from call to 0x0442 at 0x0707 // Inputs[3] // { // @0709 stack[-2] // @070A stack[-1] // @070C stack[-3] // } 0708 5B JUMPDEST 0709 81 DUP2 070A 01 ADD 070B 03 SUB 070C 12 SLT 070D 61 PUSH2 0x0723 0710 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0723, if (stack[-2] + stack[-1]) - stack[-2] i< stack[-3] label_0711: // Incoming jump from 0x0710, if not (stack[-2] + stack[-1]) - stack[-2] i< stack[-3] // Inputs[2] // { // @0714 stack[-1] // @0715 memory[stack[-1]:stack[-1] + 0x20] // } 0711 61 PUSH2 0x06eb 0714 90 SWAP1 0715 51 MLOAD 0716 61 PUSH2 0x071e 0719 81 DUP2 071A 61 PUSH2 0x0b89 071D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0714 stack[-1] = 0x06eb // @0715 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @0716 stack[1] = 0x071e // @0719 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0b89, returns to 0x071E label_071E: // Incoming return from call to 0x0B89 at 0x071D 071E 5B JUMPDEST 071F 61 PUSH2 0x06e1 0722 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06e1 label_0723: // Incoming jump from 0x0710, if (stack[-2] + stack[-1]) - stack[-2] i< stack[-3] // Inputs[2] // { // @0725 stack[-2] // @0726 memory[stack[-2]:stack[-2] + stack[-2]] // } 0723 5B JUMPDEST 0724 50 POP 0725 80 DUP1 0726 FD *REVERT // Stack delta = -2 // Outputs[1] { @0726 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_0727: // Incoming jump from 0x06FA, if 0x20 > returndata.length // Inputs[2] // { // @0728 returndata.length // @0729 stack[-2] // } 0727 5B JUMPDEST 0728 3D RETURNDATASIZE 0729 91 SWAP2 072A 50 POP 072B 61 PUSH2 0x06fb 072E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0729 stack[-2] = returndata.length } // Block ends with unconditional jump to 0x06fb label_072F: // Incoming jump from 0x019C // Inputs[1] { @0732 msg.data.length } 072F 5B JUMPDEST 0730 60 PUSH1 0x60 0732 36 CALLDATASIZE 0733 60 PUSH1 0x03 0735 19 NOT 0736 01 ADD 0737 12 SLT 0738 61 PUSH2 0x01cc 073B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x60 label_073C: // Incoming jump from 0x073B, if not ~0x03 + msg.data.length i< 0x60 // Inputs[4] // { // @073E msg.data[0x04:0x24] // @0741 msg.data[0x24:0x44] // @0752 memory[0x00:0x40] // @0753 storage[keccak256(memory[0x00:0x40])] // } 073C 60 PUSH1 0x04 073E 35 CALLDATALOAD 073F 60 PUSH1 0x24 0741 35 CALLDATALOAD 0742 90 SWAP1 0743 80 DUP1 0744 60 PUSH1 0x00 0746 52 MSTORE 0747 60 PUSH1 0x06 0749 60 PUSH1 0x20 074B 52 MSTORE 074C 60 PUSH1 0xff 074E 60 PUSH1 0x40 0750 60 PUSH1 0x00 0752 20 SHA3 0753 54 SLOAD 0754 16 AND 0755 15 ISZERO 0756 61 PUSH2 0x0794 0759 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0742 stack[1] = msg.data[0x04:0x24] // @0742 stack[0] = msg.data[0x24:0x44] // @0746 memory[0x00:0x20] = msg.data[0x04:0x24] // @074B memory[0x20:0x40] = 0x06 // } // Block ends with conditional jump to 0x0794, if !(storage[keccak256(memory[0x00:0x40])] & 0xff) label_075A: // Incoming jump from 0x0759, if not !(storage[keccak256(memory[0x00:0x40])] & 0xff) // Inputs[3] // { // @075A stack[-2] // @0768 stack[-1] // @0775 memory[0x00:0x40] // } 075A 81 DUP2 075B 61 PUSH2 0x0785 075E 61 PUSH2 0x077e 0761 61 PUSH2 0x05eb 0764 94 SWAP5 0765 61 PUSH2 0x0778 0768 85 DUP6 0769 60 PUSH1 0x00 076B 52 MSTORE 076C 60 PUSH1 0x07 076E 60 PUSH1 0x20 0770 52 MSTORE 0771 60 PUSH1 0x40 0773 60 PUSH1 0x00 0775 20 SHA3 0776 90 SWAP1 0777 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @075A stack[0] = stack[-2] // @075B stack[1] = 0x0785 // @075E stack[2] = 0x077e // @0764 stack[3] = stack[-2] // @0764 stack[-2] = 0x05eb // @076B memory[0x00:0x20] = stack[-1] // @0770 memory[0x20:0x40] = 0x07 // @0776 stack[4] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x0778, returns to 0x077E label_0778: // Incoming call from 0x0777, returns to 0x077E // Inputs[2] // { // @0779 stack[-1] // @0779 storage[stack[-1]] // } 0778 5B JUMPDEST 0779 54 SLOAD 077A 61 PUSH2 0x1113 077D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0779 stack[-1] = storage[stack[-1]] } // Block ends with unconditional jump to 0x1113 label_077E: // Incoming return from call to 0x0778 at 0x0777 // Inputs[2] // { // @077F msg.value // @0780 stack[-1] // } 077E 5B JUMPDEST 077F 34 CALLVALUE 0780 14 EQ 0781 61 PUSH2 0x112b 0784 56 *JUMP // Stack delta = +0 // Outputs[1] { @0780 stack[-1] = msg.value == stack[-1] } // Block ends with unconditional jump to 0x112b label_0785: // Incoming return from call to 0x077E at 0x0777 0785 5B JUMPDEST 0786 61 PUSH2 0x078d 0789 61 PUSH2 0x1167 078C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0786 stack[0] = 0x078d } // Block ends with call to 0x1167, returns to 0x078D label_078D: // Incoming return from call to 0x1167 at 0x078C // Inputs[3] // { // @078E stack[-3] // @078E stack[-1] // @078F msg.sender // } 078D 5B JUMPDEST 078E 91 SWAP2 078F 33 CALLER 0790 61 PUSH2 0x128f 0793 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @078E stack[-3] = stack[-1] // @078E stack[-1] = stack[-3] // @078F stack[0] = msg.sender // } // Block ends with unconditional jump to 0x128f label_0794: // Incoming jump from 0x0759, if !(storage[keccak256(memory[0x00:0x40])] & 0xff) // Inputs[2] // { // @0797 memory[0x40:0x60] // @07C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64] // } 0794 5B JUMPDEST 0795 60 PUSH1 0x40 0797 51 MLOAD 0798 62 PUSH3 0x461bcd 079C 60 PUSH1 0xe5 079E 1B SHL 079F 81 DUP2 07A0 52 MSTORE 07A1 60 PUSH1 0x20 07A3 60 PUSH1 0x04 07A5 82 DUP3 07A6 01 ADD 07A7 52 MSTORE 07A8 60 PUSH1 0x0a 07AA 60 PUSH1 0x24 07AC 82 DUP3 07AD 01 ADD 07AE 52 MSTORE 07AF 69 PUSH10 0x6e6f7420616374697665 07BA 60 PUSH1 0xb0 07BC 1B SHL 07BD 60 PUSH1 0x44 07BF 82 DUP3 07C0 01 ADD 07C1 52 MSTORE 07C2 60 PUSH1 0x64 07C4 90 SWAP1 07C5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07A7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07AE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @07C1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6e6f7420616374697665 << 0xb0 // @07C5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64]); // } // Block terminates label_07C6: // Incoming call from 0x15FD, returns to 0x15B0 // Incoming call from 0x1887, returns to 0x1888 // Incoming jump from 0x1895 // Incoming jump from 0x15BD // Incoming call from 0x080A, returns to 0x02FB // Inputs[3] // { // @07C7 stack[-1] // @07C7 stack[-2] // @07C9 memory[stack[-1]:stack[-1] + 0x20] // } 07C6 5B JUMPDEST 07C7 90 SWAP1 07C8 81 DUP2 07C9 51 MLOAD 07CA 80 DUP1 07CB 82 DUP3 07CC 52 MSTORE 07CD 60 PUSH1 0x20 07CF 80 DUP1 07D0 80 DUP1 07D1 93 SWAP4 07D2 01 ADD 07D3 93 SWAP4 07D4 01 ADD 07D5 91 SWAP2 07D6 60 PUSH1 0x00 07D8 5B JUMPDEST 07D9 82 DUP3 07DA 81 DUP2 07DB 10 LT 07DC 61 PUSH2 0x07e6 07DF 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @07C9 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @07CC memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @07D3 stack[-2] = stack[-2] + 0x20 // @07D5 stack[1] = 0x20 // @07D5 stack[-1] = stack[-1] + 0x20 // @07D6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x07e6, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_07E0: // Incoming jump from 0x07DF, if not stack[-1] < stack[-3] // Incoming jump from 0x07DF, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @07E4 stack[-5] // @07E4 stack[-6] // } 07E0 50 POP 07E1 50 POP 07E2 50 POP 07E3 50 POP 07E4 90 SWAP1 07E5 56 *JUMP // Stack delta = -5 // Outputs[1] { @07E4 stack[-6] = stack[-5] } // Block ends with unconditional jump to stack[-6] label_07E6: // Incoming jump from 0x07DF, if stack[-1] < stack[-3] // Incoming jump from 0x07DF, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[5] // { // @07E7 stack[-4] // @07E8 memory[stack[-4]:stack[-4] + 0x20] // @07E9 stack[-5] // @07EB stack[-1] // @07EC stack[-2] // } 07E6 5B JUMPDEST 07E7 83 DUP4 07E8 51 MLOAD 07E9 85 DUP6 07EA 52 MSTORE 07EB 93 SWAP4 07EC 81 DUP2 07ED 01 ADD 07EE 93 SWAP4 07EF 92 SWAP3 07F0 81 DUP2 07F1 01 ADD 07F2 92 SWAP3 07F3 60 PUSH1 0x01 07F5 01 ADD 07F6 61 PUSH2 0x07d8 07F9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @07EA memory[stack[-5]:stack[-5] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @07EE stack[-5] = stack[-2] + stack[-5] // @07F2 stack[-4] = stack[-2] + stack[-4] // @07F5 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x07d8 label_07FA: // Incoming jump from 0x08AE // Inputs[2] // { // @07FB stack[-1] // @07FB stack[-2] // } 07FA 5B JUMPDEST 07FB 90 SWAP1 07FC 60 PUSH1 0x20 07FE 61 PUSH2 0x02fb 0801 92 SWAP3 0802 81 DUP2 0803 81 DUP2 0804 52 MSTORE 0805 01 ADD 0806 90 SWAP1 0807 61 PUSH2 0x07c6 080A 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0801 stack[-2] = 0x02fb // @0804 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @0806 stack[0] = stack[-2] // @0806 stack[-1] = stack[-1] + 0x20 // } // Block ends with call to 0x07c6, returns to 0x02FB label_080B: // Incoming jump from 0x0197 // Inputs[1] { @080C msg.value } 080B 5B JUMPDEST 080C 34 CALLVALUE 080D 61 PUSH2 0x01cc 0810 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0811: // Incoming jump from 0x0810, if not msg.value // Inputs[1] { @0813 msg.data.length } 0811 60 PUSH1 0x40 0813 36 CALLDATASIZE 0814 60 PUSH1 0x03 0816 19 NOT 0817 01 ADD 0818 12 SLT 0819 61 PUSH2 0x01cc 081C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x40 label_081D: // Incoming jump from 0x081C, if not ~0x03 + msg.data.length i< 0x40 // Inputs[1] { @081F msg.data[0x04:0x24] } 081D 60 PUSH1 0x04 081F 35 CALLDATALOAD 0820 67 PUSH8 0xffffffffffffffff 0829 80 DUP1 082A 82 DUP3 082B 11 GT 082C 61 PUSH2 0x01cc 082F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @081F stack[0] = msg.data[0x04:0x24] // @0820 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x01cc, if msg.data[0x04:0x24] > 0xffffffffffffffff label_0830: // Incoming jump from 0x082F, if not msg.data[0x04:0x24] > 0xffffffffffffffff // Inputs[2] // { // @0830 msg.data.length // @0833 stack[-2] // } 0830 36 CALLDATASIZE 0831 60 PUSH1 0x23 0833 83 DUP4 0834 01 ADD 0835 12 SLT 0836 15 ISZERO 0837 61 PUSH2 0x01cc 083A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if !(stack[-2] + 0x23 i< msg.data.length) label_083B: // Incoming jump from 0x083A, if not !(stack[-2] + 0x23 i< msg.data.length) // Inputs[2] // { // @083B stack[-2] // @083F msg.data[0x04 + stack[-2]:0x04 + stack[-2] + 0x20] // } 083B 81 DUP2 083C 60 PUSH1 0x04 083E 01 ADD 083F 35 CALLDATALOAD 0840 61 PUSH2 0x0848 0843 81 DUP2 0844 61 PUSH2 0x0464 0847 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @083F stack[0] = msg.data[0x04 + stack[-2]:0x04 + stack[-2] + 0x20] // @0840 stack[1] = 0x0848 // @0843 stack[2] = msg.data[0x04 + stack[-2]:0x04 + stack[-2] + 0x20] // } // Block ends with call to 0x0464, returns to 0x0848 label_0848: // Incoming return from call to 0x0464 at 0x0847 // Inputs[3] // { // @0849 stack[-4] // @0849 stack[-1] // @084F memory[0x40:0x60] // } 0848 5B JUMPDEST 0849 92 SWAP3 084A 61 PUSH2 0x0856 084D 60 PUSH1 0x40 084F 51 MLOAD 0850 94 SWAP5 0851 85 DUP6 0852 61 PUSH2 0x0442 0855 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0849 stack[-1] = stack[-4] // @084A stack[0] = 0x0856 // @0850 stack[-4] = memory[0x40:0x60] // @0850 stack[1] = stack[-1] // @0851 stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x0856 label_0856: // Incoming return from call to 0x0442 at 0x0855 // Inputs[4] // { // @0857 stack[-2] // @0858 stack[-4] // @0867 stack[-1] // @086B msg.data.length // } 0856 5B JUMPDEST 0857 81 DUP2 0858 84 DUP5 0859 52 MSTORE 085A 60 PUSH1 0x20 085C 91 SWAP2 085D 60 PUSH1 0x24 085F 60 PUSH1 0x20 0861 86 DUP7 0862 01 ADD 0863 91 SWAP2 0864 60 PUSH1 0x05 0866 1B SHL 0867 83 DUP4 0868 01 ADD 0869 01 ADD 086A 91 SWAP2 086B 36 CALLDATASIZE 086C 83 DUP4 086D 11 GT 086E 61 PUSH2 0x01cc 0871 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @0859 memory[stack[-4]:stack[-4] + 0x20] = stack[-2] // @085C stack[-2] = 0x20 // @0863 stack[0] = stack[-4] + 0x20 // @086A stack[1] = stack[-1] // @086A stack[-1] = stack[-1] + (stack[-2] << 0x05) + 0x24 // } // Block ends with conditional jump to 0x01cc, if stack[-1] + (stack[-2] << 0x05) + 0x24 > msg.data.length label_0872: // Incoming jump from 0x0871, if not stack[-1] + (stack[-2] << 0x05) + 0x24 > msg.data.length // Inputs[3] // { // @0874 stack[-1] // @0875 stack[-2] // @0877 stack[-3] // } 0872 60 PUSH1 0x24 0874 01 ADD 0875 90 SWAP1 0876 5B JUMPDEST 0877 82 DUP3 0878 82 DUP3 0879 10 LT 087A 61 PUSH2 0x08af 087D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0875 stack[-1] = stack[-2] // @0875 stack[-2] = 0x24 + stack[-1] // } // Block ends with conditional jump to 0x08af, if 0x24 + stack[-1] < stack[-3] label_087E: // Incoming jump from 0x087D, if not stack[-2] < stack[-3] // Incoming jump from 0x087D, if not 0x24 + stack[-1] < stack[-3] // Inputs[3] // { // @087E stack[-6] // @0881 msg.data[0x24:0x44] // @0882 stack[-5] // } 087E 85 DUP6 087F 60 PUSH1 0x24 0881 35 CALLDATALOAD 0882 86 DUP7 0883 81 DUP2 0884 11 GT 0885 61 PUSH2 0x01cc 0888 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @087E stack[0] = stack[-6] // @0881 stack[1] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x24:0x44] > stack[-5] label_0889: // Incoming jump from 0x0888, if not msg.data[0x24:0x44] > stack[-5] // Inputs[3] // { // @088C stack[-2] // @0893 stack[-1] // @0894 msg.data.length // } 0889 61 PUSH2 0x035a 088C 91 SWAP2 088D 61 PUSH2 0x089d 0890 61 PUSH2 0x08a3 0893 92 SWAP3 0894 36 CALLDATASIZE 0895 90 SWAP1 0896 60 PUSH1 0x04 0898 01 ADD 0899 61 PUSH2 0x047c 089C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @088C stack[0] = stack[-2] // @088C stack[-2] = 0x035a // @088D stack[1] = 0x089d // @0893 stack[-1] = 0x08a3 // @0895 stack[2] = msg.data.length // @0898 stack[3] = 0x04 + stack[-1] // } // Block ends with call to 0x047c, returns to 0x089D label_089D: // Incoming return from call to 0x047C at 0x089C // Inputs[2] // { // @089E stack[-2] // @089E stack[-1] // } 089D 5B JUMPDEST 089E 90 SWAP1 089F 61 PUSH2 0x11a4 08A2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @089E stack[-1] = stack[-2] // @089E stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x11a4 label_08A3: // Incoming return from call to 0x089D at 0x089C // Inputs[3] // { // @08A6 memory[0x40:0x60] // @08A7 stack[-2] // @08A9 stack[-1] // } 08A3 5B JUMPDEST 08A4 60 PUSH1 0x40 08A6 51 MLOAD 08A7 91 SWAP2 08A8 82 DUP3 08A9 91 SWAP2 08AA 82 DUP3 08AB 61 PUSH2 0x07fa 08AE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @08A7 stack[0] = stack[-2] // @08A7 stack[-2] = memory[0x40:0x60] // @08A9 stack[-1] = memory[0x40:0x60] // @08A9 stack[1] = stack[-1] // @08AA stack[2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x07fa label_08AF: // Incoming jump from 0x087D, if stack[-2] < stack[-3] // Incoming jump from 0x087D, if 0x24 + stack[-1] < stack[-3] // Inputs[4] // { // @08B0 stack[-4] // @08B2 stack[-1] // @08B3 stack[-2] // @08B4 msg.data[stack[-2]:stack[-2] + 0x20] // } 08AF 5B JUMPDEST 08B0 83 DUP4 08B1 80 DUP1 08B2 91 SWAP2 08B3 83 DUP4 08B4 35 CALLDATALOAD 08B5 61 PUSH2 0x08bd 08B8 81 DUP2 08B9 61 PUSH2 0x01bb 08BC 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @08B0 stack[0] = stack[-4] // @08B2 stack[1] = stack[-1] // @08B2 stack[-1] = stack[-4] // @08B4 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @08B5 stack[3] = 0x08bd // @08B8 stack[4] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x01bb, returns to 0x08BD label_08BD: // Incoming return from call to 0x01BB at 0x08BC // Inputs[5] // { // @08BE stack[-2] // @08BF stack[-1] // @08C0 stack[-3] // @08C1 stack[-5] // @08C2 stack[-4] // } 08BD 5B JUMPDEST 08BE 81 DUP2 08BF 52 MSTORE 08C0 01 ADD 08C1 91 SWAP2 08C2 01 ADD 08C3 90 SWAP1 08C4 61 PUSH2 0x0876 08C7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @08BF memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @08C3 stack[-4] = stack[-2] + stack[-3] // @08C3 stack[-5] = stack[-5] + stack[-4] // } // Block ends with unconditional jump to 0x0876 label_08C8: // Incoming jump from 0x0192 // Inputs[1] { @08C9 msg.value } 08C8 5B JUMPDEST 08C9 34 CALLVALUE 08CA 61 PUSH2 0x01cc 08CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_08CE: // Incoming jump from 0x08CD, if not msg.value // Inputs[1] { @08D0 msg.data.length } 08CE 60 PUSH1 0x20 08D0 36 CALLDATASIZE 08D1 60 PUSH1 0x03 08D3 19 NOT 08D4 01 ADD 08D5 12 SLT 08D6 61 PUSH2 0x01cc 08D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_08DA: // Incoming jump from 0x08D9, if not ~0x03 + msg.data.length i< 0x20 // Inputs[5] // { // @08DC msg.data[0x04:0x24] // @08EB memory[0x00:0x40] // @08EC storage[keccak256(memory[0x00:0x40])] // @08F1 memory[0x40:0x60] // @08F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 08DA 60 PUSH1 0x04 08DC 35 CALLDATALOAD 08DD 60 PUSH1 0x00 08DF 52 MSTORE 08E0 60 PUSH1 0x03 08E2 60 PUSH1 0x20 08E4 52 MSTORE 08E5 60 PUSH1 0x20 08E7 60 PUSH1 0x40 08E9 60 PUSH1 0x00 08EB 20 SHA3 08EC 54 SLOAD 08ED 15 ISZERO 08EE 15 ISZERO 08EF 60 PUSH1 0x40 08F1 51 MLOAD 08F2 90 SWAP1 08F3 81 DUP2 08F4 52 MSTORE 08F5 F3 *RETURN // Stack delta = +0 // Outputs[4] // { // @08DF memory[0x00:0x20] = msg.data[0x04:0x24] // @08E4 memory[0x20:0x40] = 0x03 // @08F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!storage[keccak256(memory[0x00:0x40])] // @08F5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_08F6: // Incoming jump from 0x018D // Inputs[1] { @08F7 msg.value } 08F6 5B JUMPDEST 08F7 34 CALLVALUE 08F8 61 PUSH2 0x01cc 08FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_08FC: // Incoming jump from 0x08FB, if not msg.value // Inputs[1] { @08FE msg.data.length } 08FC 60 PUSH1 0x20 08FE 36 CALLDATASIZE 08FF 60 PUSH1 0x03 0901 19 NOT 0902 01 ADD 0903 12 SLT 0904 61 PUSH2 0x01cc 0907 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0908: // Incoming jump from 0x0907, if not ~0x03 + msg.data.length i< 0x20 // Inputs[1] { @090A msg.data[0x04:0x24] } 0908 60 PUSH1 0x04 090A 35 CALLDATALOAD 090B 61 PUSH2 0x0913 090E 81 DUP2 090F 61 PUSH2 0x01bb 0912 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @090A stack[0] = msg.data[0x04:0x24] // @090B stack[1] = 0x0913 // @090E stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x0913 label_0913: // Incoming return from call to 0x01BB at 0x0912 0913 5B JUMPDEST 0914 61 PUSH2 0x091b 0917 61 PUSH2 0x1263 091A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0914 stack[0] = 0x091b } // Block ends with call to 0x1263, returns to 0x091B label_091B: // Incoming return from call to 0x1263 at 0x091A // Inputs[2] // { // @091F storage[0x08] // @0932 stack[-1] // } 091B 5B JUMPDEST 091C 60 PUSH1 0x08 091E 80 DUP1 091F 54 SLOAD 0920 60 PUSH1 0x01 0922 60 PUSH1 0x01 0924 60 PUSH1 0xa0 0926 1B SHL 0927 03 SUB 0928 19 NOT 0929 16 AND 092A 60 PUSH1 0x01 092C 60 PUSH1 0x01 092E 60 PUSH1 0xa0 0930 1B SHL 0931 03 SUB 0932 92 SWAP3 0933 90 SWAP1 0934 92 SWAP3 0935 16 AND 0936 91 SWAP2 0937 90 SWAP1 0938 91 SWAP2 0939 17 OR 093A 90 SWAP1 093B 55 SSTORE 093C 00 *STOP // Stack delta = -1 // Outputs[2] // { // @093B storage[0x08] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x08]) // @093C stop(); // } // Block terminates label_093D: // Incoming jump from 0x0188 // Inputs[1] { @093E msg.value } 093D 5B JUMPDEST 093E 34 CALLVALUE 093F 61 PUSH2 0x01cc 0942 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0943: // Incoming jump from 0x0942, if not msg.value // Inputs[1] { @0945 msg.data.length } 0943 60 PUSH1 0x20 0945 36 CALLDATASIZE 0946 60 PUSH1 0x03 0948 19 NOT 0949 01 ADD 094A 12 SLT 094B 61 PUSH2 0x01cc 094E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_094F: // Incoming jump from 0x094E, if not ~0x03 + msg.data.length i< 0x20 // Inputs[1] { @0951 msg.data[0x04:0x24] } 094F 60 PUSH1 0x04 0951 35 CALLDATALOAD 0952 61 PUSH2 0x095a 0955 81 DUP2 0956 61 PUSH2 0x01bb 0959 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0951 stack[0] = msg.data[0x04:0x24] // @0952 stack[1] = 0x095a // @0955 stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x095A label_095A: // Incoming return from call to 0x01BB at 0x0959 095A 5B JUMPDEST 095B 61 PUSH2 0x0962 095E 61 PUSH2 0x1263 0961 56 *JUMP // Stack delta = +1 // Outputs[1] { @095B stack[0] = 0x0962 } // Block ends with call to 0x1263, returns to 0x0962 label_0962: // Incoming return from call to 0x1263 at 0x0961 // Inputs[5] // { // @0963 address(this) // @0963 address(this).balance // @0964 stack[-1] // @0966 address(this) // @0966 address(this).balance // } 0962 5B JUMPDEST 0963 47 SELFBALANCE 0964 90 SWAP1 0965 81 DUP2 0966 47 SELFBALANCE 0967 10 LT 0968 61 PUSH2 0x09a0 096B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0964 stack[0] = stack[-1] // @0964 stack[-1] = address(this).balance // } // Block ends with conditional jump to 0x09a0, if address(this).balance < address(this).balance label_096C: // Incoming jump from 0x096B, if not address(this).balance < address(this).balance // Inputs[5] // { // @0971 stack[-2] // @0973 stack[-1] // @097C msg.gas // @097D address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[0x00:0x00]) // @097D memory[0x00:0x00] // } 096C 60 PUSH1 0x00 096E 80 DUP1 096F 80 DUP1 0970 80 DUP1 0971 94 SWAP5 0972 81 DUP2 0973 94 SWAP5 0974 60 PUSH1 0x01 0976 80 DUP1 0977 60 PUSH1 0xa0 0979 1B SHL 097A 03 SUB 097B 16 AND 097C 5A GAS 097D F1 CALL 097E 61 PUSH2 0x0985 0981 61 PUSH2 0x1370 0984 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0971 stack[-2] = 0x00 // @097D memory[0x00:0x00] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[0x00:0x00]) // @097D stack[-1] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[0x00:0x00]) // @097E stack[0] = 0x0985 // } // Block ends with call to 0x1370, returns to 0x0985 label_0985: // Incoming return from call to 0x1370 at 0x0984 // Incoming return from call to 0x1370 at 0x0984 // Inputs[1] { @0987 stack[-2] } 0985 5B JUMPDEST 0986 50 POP 0987 15 ISZERO 0988 61 PUSH2 0x098e 098B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x098e, if !stack[-2] label_098C: // Incoming jump from 0x098B, if not !stack[-2] // Inputs[2] // { // @098C stack[-1] // @098D memory[stack[-1]:stack[-1] + stack[-1]] // } 098C 80 DUP1 098D F3 *RETURN // Stack delta = -1 // Outputs[1] { @098D return memory[stack[-1]:stack[-1] + stack[-1]]; } // Block terminates label_098E: // Incoming jump from 0x098B, if !stack[-2] // Inputs[2] // { // @0991 memory[0x40:0x60] // @099F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x04] // } 098E 5B JUMPDEST 098F 60 PUSH1 0x40 0991 51 MLOAD 0992 63 PUSH4 0x0a12f521 0997 60 PUSH1 0xe1 0999 1B SHL 099A 81 DUP2 099B 52 MSTORE 099C 60 PUSH1 0x04 099E 90 SWAP1 099F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @099B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a12f521 << 0xe1 // @099F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x04]); // } // Block terminates label_09A0: // Incoming jump from 0x096B, if address(this).balance < address(this).balance // Inputs[3] // { // @09A3 memory[0x40:0x60] // @09AE address(this) // @09B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 09A0 5B JUMPDEST 09A1 60 PUSH1 0x40 09A3 51 MLOAD 09A4 63 PUSH4 0xcd786059 09A9 60 PUSH1 0xe0 09AB 1B SHL 09AC 81 DUP2 09AD 52 MSTORE 09AE 30 ADDRESS 09AF 60 PUSH1 0x04 09B1 82 DUP3 09B2 01 ADD 09B3 52 MSTORE 09B4 60 PUSH1 0x24 09B6 90 SWAP1 09B7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @09AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcd786059 << 0xe0 // @09B3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @09B7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_09B8: // Incoming jump from 0x0183 // Inputs[1] { @09B9 msg.value } 09B8 5B JUMPDEST 09B9 34 CALLVALUE 09BA 61 PUSH2 0x01cc 09BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_09BE: // Incoming jump from 0x09BD, if not msg.value // Inputs[1] { @09C0 msg.data.length } 09BE 60 PUSH1 0x60 09C0 36 CALLDATASIZE 09C1 60 PUSH1 0x03 09C3 19 NOT 09C4 01 ADD 09C5 12 SLT 09C6 61 PUSH2 0x01cc 09C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x60 label_09CA: // Incoming jump from 0x09C9, if not ~0x03 + msg.data.length i< 0x60 // Inputs[1] { @09CC msg.data[0x04:0x24] } 09CA 60 PUSH1 0x04 09CC 35 CALLDATALOAD 09CD 61 PUSH2 0x09d5 09D0 81 DUP2 09D1 61 PUSH2 0x01bb 09D4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09CC stack[0] = msg.data[0x04:0x24] // @09CD stack[1] = 0x09d5 // @09D0 stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x09D5 label_09D5: // Incoming return from call to 0x01BB at 0x09D4 // Inputs[1] { @09E1 msg.data[0x24:0x44] } 09D5 5B JUMPDEST 09D6 67 PUSH8 0xffffffffffffffff 09DF 60 PUSH1 0x24 09E1 35 CALLDATALOAD 09E2 81 DUP2 09E3 81 DUP2 09E4 11 GT 09E5 61 PUSH2 0x01cc 09E8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @09D6 stack[0] = 0xffffffffffffffff // @09E1 stack[1] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x24:0x44] > 0xffffffffffffffff label_09E9: // Incoming jump from 0x09E8, if not msg.data[0x24:0x44] > 0xffffffffffffffff // Inputs[2] // { // @09EC stack[-1] // @09ED msg.data.length // } 09E9 61 PUSH2 0x09f6 09EC 90 SWAP1 09ED 36 CALLDATASIZE 09EE 90 SWAP1 09EF 60 PUSH1 0x04 09F1 01 ADD 09F2 61 PUSH2 0x047c 09F5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09EC stack[-1] = 0x09f6 // @09EE stack[0] = msg.data.length // @09F1 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x047c, returns to 0x09F6 label_09F6: // Incoming return from call to 0x047C at 0x09F5 // Inputs[3] // { // @09F7 stack[-2] // @09F7 stack[-1] // @09FA msg.data[0x44:0x64] // } 09F6 5B JUMPDEST 09F7 90 SWAP1 09F8 60 PUSH1 0x44 09FA 35 CALLDATALOAD 09FB 90 SWAP1 09FC 81 DUP2 09FD 11 GT 09FE 61 PUSH2 0x01cc 0A01 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @09F7 stack[-2] = stack[-1] // @09FB stack[-1] = msg.data[0x44:0x64] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x44:0x64] > stack[-2] label_0A02: // Incoming jump from 0x0A01, if not msg.data[0x44:0x64] > stack[-2] // Inputs[2] // { // @0A05 stack[-1] // @0A06 msg.data.length // } 0A02 61 PUSH2 0x0a0f 0A05 90 SWAP1 0A06 36 CALLDATASIZE 0A07 90 SWAP1 0A08 60 PUSH1 0x04 0A0A 01 ADD 0A0B 61 PUSH2 0x047c 0A0E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A05 stack[-1] = 0x0a0f // @0A07 stack[0] = msg.data.length // @0A0A stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x047c, returns to 0x0A0F label_0A0F: // Incoming return from call to 0x047C at 0x0A0E // Inputs[4] // { // @0A10 stack[-2] // @0A10 stack[-1] // @0A19 stack[-3] // @0A1B msg.sender // } 0A0F 5B JUMPDEST 0A10 90 SWAP1 0A11 60 PUSH1 0x01 0A13 60 PUSH1 0x01 0A15 60 PUSH1 0xa0 0A17 1B SHL 0A18 03 SUB 0A19 83 DUP4 0A1A 16 AND 0A1B 33 CALLER 0A1C 81 DUP2 0A1D 14 EQ 0A1E 15 ISZERO 0A1F 80 DUP1 0A20 61 PUSH2 0x0a84 0A23 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A10 stack[-1] = stack[-2] // @0A10 stack[-2] = stack[-1] // @0A1A stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0A1E stack[1] = !(stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender) // } // Block ends with conditional jump to 0x0a84, if !(stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender) label_0A24: // Incoming jump from 0x0A23, if not !(stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender) // Incoming jump from 0x0AA7 // Inputs[1] { @0A28 stack[-1] } 0A24 5B JUMPDEST 0A25 61 PUSH2 0x0a5d 0A28 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a5d, if stack[-1] label_0A29: // Incoming jump from 0x0A28, if not stack[-1] // Inputs[1] { @0A29 stack[-1] } 0A29 15 ISZERO 0A2A 61 PUSH2 0x0a45 0A2D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a45, if !stack[-1] label_0A2E: // Incoming jump from 0x0A2D, if not !stack[-1] // Inputs[2] // { // @0A31 stack[-3] // @0A36 memory[0x40:0x60] // } 0A2E 61 PUSH2 0x05eb 0A31 92 SWAP3 0A32 60 PUSH1 0x00 0A34 60 PUSH1 0x40 0A36 51 MLOAD 0A37 61 PUSH2 0x0a3f 0A3A 81 DUP2 0A3B 61 PUSH2 0x0421 0A3E 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0A31 stack[0] = stack[-3] // @0A31 stack[-3] = 0x05eb // @0A32 stack[1] = 0x00 // @0A36 stack[2] = memory[0x40:0x60] // @0A37 stack[3] = 0x0a3f // @0A3A stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x0421, returns to 0x0A3F label_0A3F: // Incoming return from call to 0x0421 at 0x1067 // Incoming return from call to 0x0421 at 0x0A3E // Inputs[2] // { // @0A40 stack[-2] // @0A40 stack[-1] // } 0A3F 5B JUMPDEST 0A40 52 MSTORE 0A41 61 PUSH2 0x13a0 0A44 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A40 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with unconditional jump to 0x13a0 label_0A45: // Incoming jump from 0x0EBD, if !stack[-1] // Incoming jump from 0x0A2D, if !stack[-1] // Incoming jump from 0x1027, if !stack[-1] // Inputs[2] // { // @0A48 memory[0x40:0x60] // @0A5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0A45 5B JUMPDEST 0A46 60 PUSH1 0x40 0A48 51 MLOAD 0A49 62 PUSH3 0x6a0d45 0A4D 60 PUSH1 0xe2 0A4F 1B SHL 0A50 81 DUP2 0A51 52 MSTORE 0A52 60 PUSH1 0x00 0A54 60 PUSH1 0x04 0A56 82 DUP3 0A57 01 ADD 0A58 52 MSTORE 0A59 60 PUSH1 0x24 0A5B 90 SWAP1 0A5C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0A51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6a0d45 << 0xe2 // @0A58 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @0A5C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_0A5D: // Incoming jump from 0x0A28, if stack[-1] // Inputs[4] // { // @0A60 memory[0x40:0x60] // @0A6B msg.sender // @0A79 stack[-4] // @0A83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44] // } 0A5D 5B JUMPDEST 0A5E 60 PUSH1 0x40 0A60 51 MLOAD 0A61 63 PUSH4 0x711bec91 0A66 60 PUSH1 0xe1 0A68 1B SHL 0A69 81 DUP2 0A6A 52 MSTORE 0A6B 33 CALLER 0A6C 60 PUSH1 0x04 0A6E 82 DUP3 0A6F 01 ADD 0A70 52 MSTORE 0A71 60 PUSH1 0x01 0A73 60 PUSH1 0x01 0A75 60 PUSH1 0xa0 0A77 1B SHL 0A78 03 SUB 0A79 85 DUP6 0A7A 16 AND 0A7B 60 PUSH1 0x24 0A7D 82 DUP3 0A7E 01 ADD 0A7F 52 MSTORE 0A80 60 PUSH1 0x44 0A82 90 SWAP1 0A83 FD *REVERT // Stack delta = +0 // Outputs[4] // { // @0A6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x711bec91 << 0xe1 // @0A70 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0A7F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0A83 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44]); // } // Block terminates label_0A84: // Incoming jump from 0x0A23, if !(stack[-3] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[5] // { // @0A88 stack[-2] // @0A96 memory[0x00:0x40] // @0A97 msg.sender // @0A9E memory[0x00:0x40] // @0A9F storage[keccak256(memory[0x00:0x40])] // } 0A84 5B JUMPDEST 0A85 50 POP 0A86 60 PUSH1 0x00 0A88 81 DUP2 0A89 81 DUP2 0A8A 52 MSTORE 0A8B 60 PUSH1 0x01 0A8D 60 PUSH1 0x20 0A8F 90 SWAP1 0A90 81 DUP2 0A91 52 MSTORE 0A92 60 PUSH1 0x40 0A94 80 DUP1 0A95 83 DUP4 0A96 20 SHA3 0A97 33 CALLER 0A98 84 DUP5 0A99 52 MSTORE 0A9A 90 SWAP1 0A9B 91 SWAP2 0A9C 52 MSTORE 0A9D 90 SWAP1 0A9E 20 SHA3 0A9F 54 SLOAD 0AA0 60 PUSH1 0xff 0AA2 16 AND 0AA3 15 ISZERO 0AA4 61 PUSH2 0x0a24 0AA7 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0A8A memory[0x00:0x20] = stack[-2] // @0A91 memory[0x20:0x40] = 0x01 // @0A99 memory[0x00:0x20] = msg.sender // @0A9C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0AA3 stack[-1] = !(0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to 0x0a24 label_0AA8: // Incoming jump from 0x017E // Inputs[1] { @0AA9 msg.value } 0AA8 5B JUMPDEST 0AA9 34 CALLVALUE 0AAA 61 PUSH2 0x01cc 0AAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0AAE: // Incoming jump from 0x0AAD, if not msg.value // Inputs[1] { @0AB4 msg.data.length } 0AAE 60 PUSH1 0x00 0AB0 80 DUP1 0AB1 60 PUSH1 0x03 0AB3 19 NOT 0AB4 36 CALLDATASIZE 0AB5 01 ADD 0AB6 12 SLT 0AB7 61 PUSH2 0x03dd 0ABA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AAE stack[0] = 0x00 } // Block ends with conditional jump to 0x03dd, if msg.data.length + ~0x03 i< 0x00 label_0ABB: // Incoming jump from 0x0ABA, if not msg.data.length + ~0x03 i< 0x00 0ABB 61 PUSH2 0x0ac2 0ABE 61 PUSH2 0x1263 0AC1 56 *JUMP // Stack delta = +1 // Outputs[1] { @0ABB stack[0] = 0x0ac2 } // Block ends with call to 0x1263, returns to 0x0AC2 label_0AC2: // Incoming return from call to 0x1263 at 0x0AC1 // Inputs[4] // { // @0AC6 storage[0x05] // @0AD5 stack[-1] // @0B03 memory[stack[-1]:stack[-1] + stack[-1]] // @0B05 memory[stack[-1]:stack[-1] + stack[-1]] // } 0AC2 5B JUMPDEST 0AC3 60 PUSH1 0x05 0AC5 80 DUP1 0AC6 54 SLOAD 0AC7 60 PUSH1 0x01 0AC9 60 PUSH1 0x01 0ACB 60 PUSH1 0xa0 0ACD 1B SHL 0ACE 03 SUB 0ACF 19 NOT 0AD0 81 DUP2 0AD1 16 AND 0AD2 90 SWAP1 0AD3 91 SWAP2 0AD4 55 SSTORE 0AD5 81 DUP2 0AD6 90 SWAP1 0AD7 60 PUSH1 0x01 0AD9 60 PUSH1 0x01 0ADB 60 PUSH1 0xa0 0ADD 1B SHL 0ADE 03 SUB 0ADF 16 AND 0AE0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0B01 82 DUP3 0B02 80 DUP1 0B03 A3 LOG3 0B04 80 DUP1 0B05 F3 *RETURN // Stack delta = -1 // Outputs[3] // { // @0AD4 storage[0x05] = storage[0x05] & ~((0x01 << 0xa0) - 0x01) // @0B03 log(memory[stack[-1]:stack[-1] + stack[-1]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x05] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @0B05 return memory[stack[-1]:stack[-1] + stack[-1]]; // } // Block terminates label_0B06: // Incoming jump from 0x0179 // Inputs[1] { @0B07 msg.value } 0B06 5B JUMPDEST 0B07 34 CALLVALUE 0B08 61 PUSH2 0x01cc 0B0B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0B0C: // Incoming jump from 0x0B0B, if not msg.value // Inputs[1] { @0B0E msg.data.length } 0B0C 60 PUSH1 0x00 0B0E 36 CALLDATASIZE 0B0F 60 PUSH1 0x03 0B11 19 NOT 0B12 01 ADD 0B13 12 SLT 0B14 61 PUSH2 0x01cc 0B17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x00 label_0B18: // Incoming jump from 0x0B17, if not ~0x03 + msg.data.length i< 0x00 // Inputs[3] // { // @0B1A storage[0x08] // @0B1D memory[0x40:0x60] // @0B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0B18 60 PUSH1 0x08 0B1A 54 SLOAD 0B1B 60 PUSH1 0x40 0B1D 51 MLOAD 0B1E 60 PUSH1 0x01 0B20 60 PUSH1 0x01 0B22 60 PUSH1 0xa0 0B24 1B SHL 0B25 03 SUB 0B26 90 SWAP1 0B27 91 SWAP2 0B28 16 AND 0B29 81 DUP2 0B2A 52 MSTORE 0B2B 60 PUSH1 0x20 0B2D 90 SWAP1 0B2E F3 *RETURN // Stack delta = +0 // Outputs[2] // { // @0B2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @0B2E return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_0B2F: // Incoming jump from 0x0174 // Inputs[1] { @0B30 msg.value } 0B2F 5B JUMPDEST 0B30 34 CALLVALUE 0B31 61 PUSH2 0x01cc 0B34 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0B35: // Incoming jump from 0x0B34, if not msg.value // Inputs[1] { @0B37 msg.data.length } 0B35 60 PUSH1 0x00 0B37 36 CALLDATASIZE 0B38 60 PUSH1 0x03 0B3A 19 NOT 0B3B 01 ADD 0B3C 12 SLT 0B3D 61 PUSH2 0x01cc 0B40 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x00 label_0B41: // Incoming jump from 0x0B40, if not ~0x03 + msg.data.length i< 0x00 // Inputs[3] // { // @0B43 storage[0x05] // @0B46 memory[0x40:0x60] // @0B57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0B41 60 PUSH1 0x05 0B43 54 SLOAD 0B44 60 PUSH1 0x40 0B46 51 MLOAD 0B47 60 PUSH1 0x01 0B49 60 PUSH1 0x01 0B4B 60 PUSH1 0xa0 0B4D 1B SHL 0B4E 03 SUB 0B4F 90 SWAP1 0B50 91 SWAP2 0B51 16 AND 0B52 81 DUP2 0B53 52 MSTORE 0B54 60 PUSH1 0x20 0B56 90 SWAP1 0B57 F3 *RETURN // Stack delta = +0 // Outputs[2] // { // @0B53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x05] & (0x01 << 0xa0) - 0x01 // @0B57 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_0B58: // Incoming jump from 0x016F // Inputs[1] { @0B59 msg.value } 0B58 5B JUMPDEST 0B59 34 CALLVALUE 0B5A 61 PUSH2 0x01cc 0B5D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0B5E: // Incoming jump from 0x0B5D, if not msg.value // Inputs[1] { @0B60 msg.data.length } 0B5E 60 PUSH1 0x20 0B60 36 CALLDATASIZE 0B61 60 PUSH1 0x03 0B63 19 NOT 0B64 01 ADD 0B65 12 SLT 0B66 61 PUSH2 0x01cc 0B69 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0B6A: // Incoming jump from 0x0B69, if not ~0x03 + msg.data.length i< 0x20 // Inputs[5] // { // @0B6C msg.data[0x04:0x24] // @0B7D memory[0x00:0x40] // @0B7E storage[keccak256(memory[0x00:0x40])] // @0B82 memory[0x40:0x60] // @0B88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0B6A 60 PUSH1 0x04 0B6C 35 CALLDATALOAD 0B6D 60 PUSH1 0x00 0B6F 52 MSTORE 0B70 60 PUSH1 0x06 0B72 60 PUSH1 0x20 0B74 52 MSTORE 0B75 60 PUSH1 0x20 0B77 60 PUSH1 0xff 0B79 60 PUSH1 0x40 0B7B 60 PUSH1 0x00 0B7D 20 SHA3 0B7E 54 SLOAD 0B7F 16 AND 0B80 60 PUSH1 0x40 0B82 51 MLOAD 0B83 90 SWAP1 0B84 15 ISZERO 0B85 15 ISZERO 0B86 81 DUP2 0B87 52 MSTORE 0B88 F3 *RETURN // Stack delta = +0 // Outputs[4] // { // @0B6F memory[0x00:0x20] = msg.data[0x04:0x24] // @0B74 memory[0x20:0x40] = 0x06 // @0B87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!(storage[keccak256(memory[0x00:0x40])] & 0xff) // @0B88 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_0B89: // Incoming call from 0x0BBB, returns to 0x0BBC // Incoming call from 0x071D, returns to 0x071E // Inputs[1] { @0B8A stack[-1] } 0B89 5B JUMPDEST 0B8A 80 DUP1 0B8B 15 ISZERO 0B8C 15 ISZERO 0B8D 03 SUB 0B8E 61 PUSH2 0x01cc 0B91 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01cc, if !!stack[-1] - stack[-1] label_0B92: // Incoming jump from 0x0B91, if not !!stack[-1] - stack[-1] // Inputs[1] { @0B92 stack[-1] } 0B92 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0B93: // Incoming jump from 0x016A // Inputs[1] { @0B94 msg.value } 0B93 5B JUMPDEST 0B94 34 CALLVALUE 0B95 61 PUSH2 0x01cc 0B98 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0B99: // Incoming jump from 0x0B98, if not msg.value // Inputs[1] { @0B9B msg.data.length } 0B99 60 PUSH1 0x40 0B9B 36 CALLDATASIZE 0B9C 60 PUSH1 0x03 0B9E 19 NOT 0B9F 01 ADD 0BA0 12 SLT 0BA1 61 PUSH2 0x01cc 0BA4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x40 label_0BA5: // Incoming jump from 0x0BA4, if not ~0x03 + msg.data.length i< 0x40 // Inputs[1] { @0BA7 msg.data[0x04:0x24] } 0BA5 60 PUSH1 0x04 0BA7 35 CALLDATALOAD 0BA8 61 PUSH2 0x0bb0 0BAB 81 DUP2 0BAC 61 PUSH2 0x01bb 0BAF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BA7 stack[0] = msg.data[0x04:0x24] // @0BA8 stack[1] = 0x0bb0 // @0BAB stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x0BB0 label_0BB0: // Incoming return from call to 0x01BB at 0x0BAF // Inputs[1] { @0BB3 msg.data[0x24:0x44] } 0BB0 5B JUMPDEST 0BB1 60 PUSH1 0x24 0BB3 35 CALLDATALOAD 0BB4 61 PUSH2 0x0bbc 0BB7 81 DUP2 0BB8 61 PUSH2 0x0b89 0BBB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BB3 stack[0] = msg.data[0x24:0x44] // @0BB4 stack[1] = 0x0bbc // @0BB7 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x0b89, returns to 0x0BBC label_0BBC: // Incoming return from call to 0x0B89 at 0x0BBB // Inputs[1] { @0BC5 stack[-2] } 0BBC 5B JUMPDEST 0BBD 60 PUSH1 0x01 0BBF 60 PUSH1 0x01 0BC1 60 PUSH1 0xa0 0BC3 1B SHL 0BC4 03 SUB 0BC5 82 DUP3 0BC6 16 AND 0BC7 91 SWAP2 0BC8 82 DUP3 0BC9 15 ISZERO 0BCA 61 PUSH2 0x0c2f 0BCD 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0BC7 stack[0] = stack[-2] // @0BC7 stack[-2] = stack[-2] & (0x01 << 0xa0) - 0x01 // } // Block ends with conditional jump to 0x0c2f, if !(stack[-2] & (0x01 << 0xa0) - 0x01) label_0BCE: // Incoming jump from 0x0BCD, if not !(stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0BCE msg.sender // @0BDF memory[0x00:0x40] // @0BE9 stack[-1] // @0BF0 memory[0x00:0x40] // @0BF1 stack[-2] // @0BF9 storage[keccak256(memory[0x00:0x40])] // @0C04 memory[0x40:0x60] // @0C2B msg.sender // @0C2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0C2D stack[-3] // } 0BCE 33 CALLER 0BCF 60 PUSH1 0x00 0BD1 90 SWAP1 0BD2 81 DUP2 0BD3 52 MSTORE 0BD4 60 PUSH1 0x01 0BD6 60 PUSH1 0x20 0BD8 90 SWAP1 0BD9 81 DUP2 0BDA 52 MSTORE 0BDB 60 PUSH1 0x40 0BDD 80 DUP1 0BDE 83 DUP4 0BDF 20 SHA3 0BE0 60 PUSH1 0x01 0BE2 60 PUSH1 0x01 0BE4 60 PUSH1 0xa0 0BE6 1B SHL 0BE7 03 SUB 0BE8 90 SWAP1 0BE9 94 SWAP5 0BEA 16 AND 0BEB 83 DUP4 0BEC 52 MSTORE 0BED 92 SWAP3 0BEE 90 SWAP1 0BEF 52 MSTORE 0BF0 20 SHA3 0BF1 90 SWAP1 0BF2 15 ISZERO 0BF3 15 ISZERO 0BF4 90 SWAP1 0BF5 60 PUSH1 0xff 0BF7 19 NOT 0BF8 81 DUP2 0BF9 54 SLOAD 0BFA 16 AND 0BFB 60 PUSH1 0xff 0BFD 83 DUP4 0BFE 16 AND 0BFF 17 OR 0C00 90 SWAP1 0C01 55 SSTORE 0C02 60 PUSH1 0x40 0C04 51 MLOAD 0C05 90 SWAP1 0C06 81 DUP2 0C07 52 MSTORE 0C08 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0C29 60 PUSH1 0x20 0C2B 33 CALLER 0C2C 92 SWAP3 0C2D A3 LOG3 0C2E 00 *STOP // Stack delta = -3 // Outputs[8] // { // @0BD3 memory[0x00:0x20] = msg.sender // @0BDA memory[0x20:0x40] = 0x01 // @0BEC memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0BEF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0C01 storage[keccak256(memory[0x00:0x40])] = (!!stack[-2] & 0xff) | (storage[keccak256(memory[0x00:0x40])] & ~0xff) // @0C07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-2] // @0C2D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-3]]); // @0C2E stop(); // } // Block terminates label_0C2F: // Incoming jump from 0x0BCD, if !(stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[2] // { // @0C32 memory[0x40:0x60] // @0C46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0C2F 5B JUMPDEST 0C30 60 PUSH1 0x40 0C32 51 MLOAD 0C33 62 PUSH3 0xced3e1 0C37 60 PUSH1 0xe8 0C39 1B SHL 0C3A 81 DUP2 0C3B 52 MSTORE 0C3C 60 PUSH1 0x00 0C3E 60 PUSH1 0x04 0C40 82 DUP3 0C41 01 ADD 0C42 52 MSTORE 0C43 60 PUSH1 0x24 0C45 90 SWAP1 0C46 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C3B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xced3e1 << 0xe8 // @0C42 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @0C46 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_0C47: // Incoming jump from 0x0165 // Inputs[1] { @0C48 msg.value } 0C47 5B JUMPDEST 0C48 34 CALLVALUE 0C49 61 PUSH2 0x01cc 0C4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0C4D: // Incoming jump from 0x0C4C, if not msg.value // Inputs[1] { @0C4F msg.data.length } 0C4D 60 PUSH1 0x60 0C4F 36 CALLDATASIZE 0C50 60 PUSH1 0x03 0C52 19 NOT 0C53 01 ADD 0C54 12 SLT 0C55 61 PUSH2 0x01cc 0C58 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x60 label_0C59: // Incoming jump from 0x0C58, if not ~0x03 + msg.data.length i< 0x60 // Inputs[1] { @0C64 msg.data[0x04:0x24] } 0C59 67 PUSH8 0xffffffffffffffff 0C62 60 PUSH1 0x04 0C64 35 CALLDATALOAD 0C65 81 DUP2 0C66 81 DUP2 0C67 11 GT 0C68 61 PUSH2 0x01cc 0C6B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C59 stack[0] = 0xffffffffffffffff // @0C64 stack[1] = msg.data[0x04:0x24] // } // Block ends with conditional jump to 0x01cc, if msg.data[0x04:0x24] > 0xffffffffffffffff label_0C6C: // Incoming jump from 0x0C6B, if not msg.data[0x04:0x24] > 0xffffffffffffffff // Inputs[2] // { // @0C6F stack[-1] // @0C70 msg.data.length // } 0C6C 61 PUSH2 0x0c79 0C6F 90 SWAP1 0C70 36 CALLDATASIZE 0C71 90 SWAP1 0C72 60 PUSH1 0x04 0C74 01 ADD 0C75 61 PUSH2 0x04f8 0C78 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C6F stack[-1] = 0x0c79 // @0C71 stack[0] = msg.data.length // @0C74 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x04f8, returns to 0x0C79 label_0C79: // Incoming return from call to 0x04F8 at 0x0C78 // Inputs[2] // { // @0C7C msg.data[0x24:0x44] // @0C7D stack[-2] // } 0C79 5B JUMPDEST 0C7A 60 PUSH1 0x24 0C7C 35 CALLDATALOAD 0C7D 82 DUP3 0C7E 81 DUP2 0C7F 11 GT 0C80 61 PUSH2 0x01cc 0C83 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C7C stack[0] = msg.data[0x24:0x44] } // Block ends with conditional jump to 0x01cc, if msg.data[0x24:0x44] > stack[-2] label_0C84: // Incoming jump from 0x0C83, if not msg.data[0x24:0x44] > stack[-2] // Inputs[2] // { // @0C87 stack[-1] // @0C88 msg.data.length // } 0C84 61 PUSH2 0x0c91 0C87 90 SWAP1 0C88 36 CALLDATASIZE 0C89 90 SWAP1 0C8A 60 PUSH1 0x04 0C8C 01 ADD 0C8D 61 PUSH2 0x04f8 0C90 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C87 stack[-1] = 0x0c91 // @0C89 stack[0] = msg.data.length // @0C8C stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x04f8, returns to 0x0C91 label_0C91: // Incoming return from call to 0x04F8 at 0x0C90 // Inputs[2] // { // @0C94 msg.data[0x44:0x64] // @0C95 stack[-3] // } 0C91 5B JUMPDEST 0C92 60 PUSH1 0x44 0C94 35 CALLDATALOAD 0C95 92 SWAP3 0C96 83 DUP4 0C97 11 GT 0C98 61 PUSH2 0x01cc 0C9B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C95 stack[-3] = msg.data[0x44:0x64] } // Block ends with conditional jump to 0x01cc, if msg.data[0x44:0x64] > stack[-3] label_0C9C: // Incoming jump from 0x0C9B, if not msg.data[0x44:0x64] > stack[-3] // Inputs[2] // { // @0CA5 stack[-3] // @0CA6 msg.data.length // } 0C9C 61 PUSH2 0x0cff 0C9F 61 PUSH2 0x0caf 0CA2 61 PUSH2 0x035a 0CA5 94 SWAP5 0CA6 36 CALLDATASIZE 0CA7 90 SWAP1 0CA8 60 PUSH1 0x04 0CAA 01 ADD 0CAB 61 PUSH2 0x04f8 0CAE 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0C9C stack[0] = 0x0cff // @0C9F stack[1] = 0x0caf // @0CA5 stack[-3] = 0x035a // @0CA7 stack[2] = msg.data.length // @0CAA stack[3] = 0x04 + stack[-3] // } // Block ends with call to 0x04f8, returns to 0x0CAF label_0CAF: // Incoming return from call to 0x04F8 at 0x0CAE // Inputs[5] // { // @0CB0 stack[-1] // @0CB0 stack[-3] // @0CB3 memory[0x40:0x60] // @0CC0 stack[-4] // @0CC3 memory[stack[-4]:stack[-4] + 0x20] // } 0CAF 5B JUMPDEST 0CB0 91 SWAP2 0CB1 60 PUSH1 0x40 0CB3 51 MLOAD 0CB4 80 DUP1 0CB5 93 SWAP4 0CB6 60 PUSH1 0x20 0CB8 92 SWAP3 0CB9 83 DUP4 0CBA 61 PUSH2 0x0ccc 0CBD 81 DUP2 0CBE 85 DUP6 0CBF 01 ADD 0CC0 98 SWAP9 0CC1 89 DUP10 0CC2 81 DUP2 0CC3 51 MLOAD 0CC4 93 SWAP4 0CC5 84 DUP5 0CC6 92 SWAP3 0CC7 01 ADD 0CC8 61 PUSH2 0x02a2 0CCB 56 *JUMP // Stack delta = +8 // Outputs[11] // { // @0CB3 stack[0] = memory[0x40:0x60] // @0CB5 stack[1] = stack[-1] // @0CB5 stack[-3] = memory[0x40:0x60] // @0CB8 stack[-1] = 0x20 // @0CB8 stack[2] = stack[-3] // @0CBA stack[4] = 0x0ccc // @0CC0 stack[-4] = memory[0x40:0x60] + 0x20 // @0CC1 stack[6] = memory[0x40:0x60] + 0x20 // @0CC4 stack[3] = memory[stack[-4]:stack[-4] + 0x20] // @0CC6 stack[5] = memory[stack[-4]:stack[-4] + 0x20] // @0CC7 stack[7] = stack[-4] + 0x20 // } // Block ends with call to 0x02a2, returns to 0x0CCC label_0CCC: // Incoming return from call to 0x02A2 at 0x0CCB // Inputs[5] // { // @0CCD stack[-4] // @0CCE stack[-1] // @0CD2 stack[-2] // @0CD3 memory[stack[-2]:stack[-2] + 0x20] // @0CD6 stack[-5] // } 0CCC 5B JUMPDEST 0CCD 83 DUP4 0CCE 01 ADD 0CCF 61 PUSH2 0x0ce0 0CD2 82 DUP3 0CD3 51 MLOAD 0CD4 80 DUP1 0CD5 93 SWAP4 0CD6 87 DUP8 0CD7 80 DUP1 0CD8 85 DUP6 0CD9 01 ADD 0CDA 91 SWAP2 0CDB 01 ADD 0CDC 61 PUSH2 0x02a2 0CDF 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0CCE stack[-1] = stack[-4] + stack[-1] // @0CCF stack[0] = 0x0ce0 // @0CD3 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0CD5 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @0CDA stack[2] = stack[-4] + stack[-1] + stack[-5] // @0CDB stack[3] = stack[-2] + stack[-5] // } // Block ends with call to 0x02a2, returns to 0x0CE0 label_0CE0: // Incoming return from call to 0x02A2 at 0x0CDF // Inputs[5] // { // @0CE1 stack[-2] // @0CE1 stack[-1] // @0CE5 stack[-3] // @0CE6 memory[stack[-3]:stack[-3] + 0x20] // @0CE9 stack[-5] // } 0CE0 5B JUMPDEST 0CE1 01 ADD 0CE2 61 PUSH2 0x0cf3 0CE5 82 DUP3 0CE6 51 MLOAD 0CE7 80 DUP1 0CE8 93 SWAP4 0CE9 86 DUP7 0CEA 80 DUP1 0CEB 85 DUP6 0CEC 01 ADD 0CED 91 SWAP2 0CEE 01 ADD 0CEF 61 PUSH2 0x02a2 0CF2 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0CE1 stack[-2] = stack[-1] + stack[-2] // @0CE2 stack[-1] = 0x0cf3 // @0CE6 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @0CE8 stack[-3] = memory[stack[-3]:stack[-3] + 0x20] // @0CED stack[1] = stack[-1] + stack[-2] + stack[-5] // @0CEE stack[2] = stack[-3] + stack[-5] // } // Block ends with call to 0x02a2, returns to 0x0CF3 label_0CF3: // Incoming return from call to 0x02A2 at 0x0CF2 // Inputs[5] // { // @0CF4 stack[-1] // @0CF4 stack[-2] // @0CF5 stack[-3] // @0CF7 stack[-6] // @0CF9 stack[-4] // } 0CF3 5B JUMPDEST 0CF4 01 ADD 0CF5 03 SUB 0CF6 80 DUP1 0CF7 84 DUP5 0CF8 52 MSTORE 0CF9 01 ADD 0CFA 82 DUP3 0CFB 61 PUSH2 0x0442 0CFE 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0CF8 memory[stack[-6]:stack[-6] + 0x20] = (stack[-1] + stack[-2]) - stack[-3] // @0CF9 stack[-4] = (stack[-1] + stack[-2]) - stack[-3] + stack[-4] // @0CFA stack[-3] = stack[-6] // } // Block ends with unconditional jump to 0x0442 label_0CFF: // Incoming return from call to 0x0CAF at 0x0CAE // Inputs[6] // { // @0D00 memory[stack[-1]:stack[-1] + 0x20] // @0D00 stack[-1] // @0D01 stack[-2] // @0D02 memory[stack[-2]:stack[-2] + memory[stack[-1]:stack[-1] + 0x20]] // @0D05 memory[0x40:0x60] // @0D09 stack[-3] // } 0CFF 5B JUMPDEST 0D00 51 MLOAD 0D01 90 SWAP1 0D02 20 SHA3 0D03 60 PUSH1 0x40 0D05 51 MLOAD 0D06 90 SWAP1 0D07 81 DUP2 0D08 52 MSTORE 0D09 90 SWAP1 0D0A 81 DUP2 0D0B 90 SWAP1 0D0C 60 PUSH1 0x20 0D0E 82 DUP3 0D0F 01 ADD 0D10 90 SWAP1 0D11 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0D08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = keccak256(memory[stack[-2]:stack[-2] + memory[stack[-1]:stack[-1] + 0x20]]) // @0D09 stack[-3] = memory[0x40:0x60] // @0D0B stack[-2] = memory[0x40:0x60] // @0D10 stack[-1] = memory[0x40:0x60] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_0D12: // Incoming jump from 0x0160 // Inputs[1] { @0D13 msg.value } 0D12 5B JUMPDEST 0D13 34 CALLVALUE 0D14 61 PUSH2 0x01cc 0D17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0D18: // Incoming jump from 0x0D17, if not msg.value // Inputs[1] { @0D1A msg.data.length } 0D18 60 PUSH1 0x20 0D1A 36 CALLDATASIZE 0D1B 60 PUSH1 0x03 0D1D 19 NOT 0D1E 01 ADD 0D1F 12 SLT 0D20 61 PUSH2 0x01cc 0D23 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0D24: // Incoming jump from 0x0D23, if not ~0x03 + msg.data.length i< 0x20 // Inputs[5] // { // @0D26 msg.data[0x04:0x24] // @0D35 memory[0x00:0x40] // @0D36 storage[keccak256(memory[0x00:0x40])] // @0D39 memory[0x40:0x60] // @0D3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0D24 60 PUSH1 0x04 0D26 35 CALLDATALOAD 0D27 60 PUSH1 0x00 0D29 52 MSTORE 0D2A 60 PUSH1 0x07 0D2C 60 PUSH1 0x20 0D2E 52 MSTORE 0D2F 60 PUSH1 0x20 0D31 60 PUSH1 0x40 0D33 60 PUSH1 0x00 0D35 20 SHA3 0D36 54 SLOAD 0D37 60 PUSH1 0x40 0D39 51 MLOAD 0D3A 90 SWAP1 0D3B 81 DUP2 0D3C 52 MSTORE 0D3D F3 *RETURN // Stack delta = +0 // Outputs[4] // { // @0D29 memory[0x00:0x20] = msg.data[0x04:0x24] // @0D2E memory[0x20:0x40] = 0x07 // @0D3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @0D3D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_0D3E: // Incoming jump from 0x015B // Inputs[1] { @0D3F msg.value } 0D3E 5B JUMPDEST 0D3F 34 CALLVALUE 0D40 61 PUSH2 0x01cc 0D43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0D44: // Incoming jump from 0x0D43, if not msg.value // Inputs[1] { @0D46 msg.data.length } 0D44 60 PUSH1 0x20 0D46 36 CALLDATASIZE 0D47 60 PUSH1 0x03 0D49 19 NOT 0D4A 01 ADD 0D4B 12 SLT 0D4C 61 PUSH2 0x01cc 0D4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0D50: // Incoming jump from 0x0D4F, if not ~0x03 + msg.data.length i< 0x20 // Inputs[5] // { // @0D52 msg.data[0x04:0x24] // @0D61 memory[0x00:0x40] // @0D62 storage[keccak256(memory[0x00:0x40])] // @0D65 memory[0x40:0x60] // @0D69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0D50 60 PUSH1 0x04 0D52 35 CALLDATALOAD 0D53 60 PUSH1 0x00 0D55 52 MSTORE 0D56 60 PUSH1 0x03 0D58 60 PUSH1 0x20 0D5A 52 MSTORE 0D5B 60 PUSH1 0x20 0D5D 60 PUSH1 0x40 0D5F 60 PUSH1 0x00 0D61 20 SHA3 0D62 54 SLOAD 0D63 60 PUSH1 0x40 0D65 51 MLOAD 0D66 90 SWAP1 0D67 81 DUP2 0D68 52 MSTORE 0D69 F3 *RETURN // Stack delta = +0 // Outputs[4] // { // @0D55 memory[0x00:0x20] = msg.data[0x04:0x24] // @0D5A memory[0x20:0x40] = 0x03 // @0D68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @0D69 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]; // } // Block terminates label_0D6A: // Incoming jump from 0x0156 // Inputs[1] { @0D6B msg.value } 0D6A 5B JUMPDEST 0D6B 34 CALLVALUE 0D6C 61 PUSH2 0x01cc 0D6F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0D70: // Incoming jump from 0x0D6F, if not msg.value // Inputs[1] { @0D72 msg.data.length } 0D70 60 PUSH1 0x40 0D72 36 CALLDATASIZE 0D73 60 PUSH1 0x03 0D75 19 NOT 0D76 01 ADD 0D77 12 SLT 0D78 61 PUSH2 0x01cc 0D7B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x40 label_0D7C: // Incoming jump from 0x0D7B, if not ~0x03 + msg.data.length i< 0x40 0D7C 61 PUSH2 0x0d83 0D7F 61 PUSH2 0x1263 0D82 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D7C stack[0] = 0x0d83 } // Block ends with call to 0x1263, returns to 0x0D83 label_0D83: // Incoming return from call to 0x1263 at 0x0D82 // Inputs[6] // { // @0D86 msg.data[0x04:0x24] // @0D93 memory[0x00:0x40] // @0D9A storage[keccak256(memory[0x00:0x40])] // @0DA6 msg.data[0x24:0x44] // @0DAB memory[0x00:0x40] // @0DB0 memory[0x00:0x00] // } 0D83 5B JUMPDEST 0D84 60 PUSH1 0x04 0D86 35 CALLDATALOAD 0D87 60 PUSH1 0x00 0D89 52 MSTORE 0D8A 60 PUSH1 0x06 0D8C 60 PUSH1 0x20 0D8E 52 MSTORE 0D8F 60 PUSH1 0x40 0D91 60 PUSH1 0x00 0D93 20 SHA3 0D94 60 PUSH1 0x01 0D96 60 PUSH1 0xff 0D98 19 NOT 0D99 82 DUP3 0D9A 54 SLOAD 0D9B 16 AND 0D9C 17 OR 0D9D 90 SWAP1 0D9E 55 SSTORE 0D9F 60 PUSH1 0x07 0DA1 60 PUSH1 0x20 0DA3 52 MSTORE 0DA4 60 PUSH1 0x24 0DA6 35 CALLDATALOAD 0DA7 60 PUSH1 0x40 0DA9 60 PUSH1 0x00 0DAB 20 SHA3 0DAC 55 SSTORE 0DAD 60 PUSH1 0x00 0DAF 80 DUP1 0DB0 F3 *RETURN // Stack delta = +0 // Outputs[6] // { // @0D89 memory[0x00:0x20] = msg.data[0x04:0x24] // @0D8E memory[0x20:0x40] = 0x06 // @0D9E storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & ~0xff) | 0x01 // @0DA3 memory[0x20:0x40] = 0x07 // @0DAC storage[keccak256(memory[0x00:0x40])] = msg.data[0x24:0x44] // @0DB0 return memory[0x00:0x00]; // } // Block terminates label_0DB1: // Incoming jump from 0x0151 // Inputs[1] { @0DB2 msg.value } 0DB1 5B JUMPDEST 0DB2 34 CALLVALUE 0DB3 61 PUSH2 0x01cc 0DB6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0DB7: // Incoming jump from 0x0DB6, if not msg.value // Inputs[1] { @0DB9 msg.data.length } 0DB7 60 PUSH1 0x40 0DB9 36 CALLDATASIZE 0DBA 60 PUSH1 0x03 0DBC 19 NOT 0DBD 01 ADD 0DBE 12 SLT 0DBF 61 PUSH2 0x01cc 0DC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x40 label_0DC3: // Incoming jump from 0x0DC2, if not ~0x03 + msg.data.length i< 0x40 // Inputs[1] { @0DCC msg.data[0x04:0x24] } 0DC3 60 PUSH1 0x20 0DC5 60 PUSH1 0xff 0DC7 61 PUSH2 0x0e0d 0DCA 60 PUSH1 0x04 0DCC 35 CALLDATALOAD 0DCD 61 PUSH2 0x0dd5 0DD0 81 DUP2 0DD1 61 PUSH2 0x01bb 0DD4 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0DC3 stack[0] = 0x20 // @0DC5 stack[1] = 0xff // @0DC7 stack[2] = 0x0e0d // @0DCC stack[3] = msg.data[0x04:0x24] // @0DCD stack[4] = 0x0dd5 // @0DD0 stack[5] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x0DD5 label_0DD5: // Incoming return from call to 0x01BB at 0x0DD4 // Inputs[2] // { // @0DD8 msg.data[0x24:0x44] // @0DD9 stack[-1] // } 0DD5 5B JUMPDEST 0DD6 60 PUSH1 0x24 0DD8 35 CALLDATALOAD 0DD9 90 SWAP1 0DDA 61 PUSH2 0x0de2 0DDD 82 DUP3 0DDE 61 PUSH2 0x01bb 0DE1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0DD9 stack[0] = stack[-1] // @0DD9 stack[-1] = msg.data[0x24:0x44] // @0DDA stack[1] = 0x0de2 // @0DDD stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x01bb, returns to 0x0DE2 label_0DE2: // Incoming return from call to 0x01BB at 0x0DE1 // Inputs[6] // { // @0DEA stack[-1] // @0DF0 stack[-5] // @0DF6 memory[0x00:0x40] // @0DF7 stack[-2] // @0E0A memory[0x00:0x40] // @0E0B stack[-3] // } 0DE2 5B JUMPDEST 0DE3 60 PUSH1 0x01 0DE5 80 DUP1 0DE6 60 PUSH1 0xa0 0DE8 1B SHL 0DE9 03 SUB 0DEA 16 AND 0DEB 60 PUSH1 0x00 0DED 52 MSTORE 0DEE 60 PUSH1 0x01 0DF0 84 DUP5 0DF1 52 MSTORE 0DF2 60 PUSH1 0x40 0DF4 60 PUSH1 0x00 0DF6 20 SHA3 0DF7 90 SWAP1 0DF8 60 PUSH1 0x01 0DFA 80 DUP1 0DFB 60 PUSH1 0xa0 0DFD 1B SHL 0DFE 03 SUB 0DFF 16 AND 0E00 60 PUSH1 0x00 0E02 52 MSTORE 0E03 60 PUSH1 0x20 0E05 52 MSTORE 0E06 60 PUSH1 0x40 0E08 60 PUSH1 0x00 0E0A 20 SHA3 0E0B 90 SWAP1 0E0C 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0DED memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0DF1 memory[stack[-5]:stack[-5] + 0x20] = 0x01 // @0E02 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0E05 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E0B stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-3] label_0E0D: // Incoming return from call to 0x0DD5 at 0x0DD4 // Inputs[6] // { // @0E0E storage[stack[-1]] // @0E0E stack[-1] // @0E0F stack[-2] // @0E12 memory[0x40:0x60] // @0E18 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3]] // @0E18 stack[-3] // } 0E0D 5B JUMPDEST 0E0E 54 SLOAD 0E0F 16 AND 0E10 60 PUSH1 0x40 0E12 51 MLOAD 0E13 90 SWAP1 0E14 15 ISZERO 0E15 15 ISZERO 0E16 81 DUP2 0E17 52 MSTORE 0E18 F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @0E17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!(storage[stack[-1]] & stack[-2]) // @0E18 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3]]; // } // Block terminates label_0E19: // Incoming jump from 0x014C // Inputs[1] { @0E1A msg.value } 0E19 5B JUMPDEST 0E1A 34 CALLVALUE 0E1B 61 PUSH2 0x01cc 0E1E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0E1F: // Incoming jump from 0x0E1E, if not msg.value // Inputs[1] { @0E21 msg.data.length } 0E1F 60 PUSH1 0x20 0E21 36 CALLDATASIZE 0E22 60 PUSH1 0x03 0E24 19 NOT 0E25 01 ADD 0E26 12 SLT 0E27 61 PUSH2 0x01cc 0E2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0E2B: // Incoming jump from 0x0E2A, if not ~0x03 + msg.data.length i< 0x20 0E2B 61 PUSH2 0x0e32 0E2E 61 PUSH2 0x1263 0E31 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E2B stack[0] = 0x0e32 } // Block ends with call to 0x1263, returns to 0x0E32 label_0E32: // Incoming return from call to 0x1263 at 0x0E31 // Inputs[3] // { // @0E35 msg.data[0x04:0x24] // @0E43 memory[0x00:0x40] // @0E45 storage[keccak256(memory[0x00:0x40])] // } 0E32 5B JUMPDEST 0E33 60 PUSH1 0x04 0E35 35 CALLDATALOAD 0E36 60 PUSH1 0x00 0E38 90 SWAP1 0E39 81 DUP2 0E3A 52 MSTORE 0E3B 60 PUSH1 0x06 0E3D 60 PUSH1 0x20 0E3F 52 MSTORE 0E40 60 PUSH1 0x40 0E42 90 SWAP1 0E43 20 SHA3 0E44 80 DUP1 0E45 54 SLOAD 0E46 60 PUSH1 0xff 0E48 19 NOT 0E49 16 AND 0E4A 90 SWAP1 0E4B 55 SSTORE 0E4C 00 *STOP // Stack delta = +0 // Outputs[4] // { // @0E3A memory[0x00:0x20] = msg.data[0x04:0x24] // @0E3F memory[0x20:0x40] = 0x06 // @0E4B storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @0E4C stop(); // } // Block terminates label_0E4D: // Incoming jump from 0x0147 // Inputs[1] { @0E4E msg.value } 0E4D 5B JUMPDEST 0E4E 34 CALLVALUE 0E4F 61 PUSH2 0x01cc 0E52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0E53: // Incoming jump from 0x0E52, if not msg.value // Inputs[1] { @0E55 msg.data.length } 0E53 60 PUSH1 0xa0 0E55 36 CALLDATASIZE 0E56 60 PUSH1 0x03 0E58 19 NOT 0E59 01 ADD 0E5A 12 SLT 0E5B 61 PUSH2 0x01cc 0E5E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0xa0 label_0E5F: // Incoming jump from 0x0E5E, if not ~0x03 + msg.data.length i< 0xa0 // Inputs[1] { @0E61 msg.data[0x04:0x24] } 0E5F 60 PUSH1 0x04 0E61 35 CALLDATALOAD 0E62 61 PUSH2 0x0e6a 0E65 81 DUP2 0E66 61 PUSH2 0x01bb 0E69 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E61 stack[0] = msg.data[0x04:0x24] // @0E62 stack[1] = 0x0e6a // @0E65 stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x0E6A label_0E6A: // Incoming return from call to 0x01BB at 0x0E69 // Inputs[1] { @0E6D msg.data[0x24:0x44] } 0E6A 5B JUMPDEST 0E6B 60 PUSH1 0x24 0E6D 35 CALLDATALOAD 0E6E 61 PUSH2 0x0e76 0E71 81 DUP2 0E72 61 PUSH2 0x01bb 0E75 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E6D stack[0] = msg.data[0x24:0x44] // @0E6E stack[1] = 0x0e76 // @0E71 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x01bb, returns to 0x0E76 label_0E76: // Incoming return from call to 0x01BB at 0x0E75 // Inputs[1] { @0E79 msg.data[0x84:0xa4] } 0E76 5B JUMPDEST 0E77 60 PUSH1 0x84 0E79 35 CALLDATALOAD 0E7A 67 PUSH8 0xffffffffffffffff 0E83 81 DUP2 0E84 11 GT 0E85 61 PUSH2 0x01cc 0E88 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E79 stack[0] = msg.data[0x84:0xa4] } // Block ends with conditional jump to 0x01cc, if msg.data[0x84:0xa4] > 0xffffffffffffffff label_0E89: // Incoming jump from 0x0E88, if not msg.data[0x84:0xa4] > 0xffffffffffffffff // Inputs[2] // { // @0E8C stack[-1] // @0E8D msg.data.length // } 0E89 61 PUSH2 0x0e96 0E8C 90 SWAP1 0E8D 36 CALLDATASIZE 0E8E 90 SWAP1 0E8F 60 PUSH1 0x04 0E91 01 ADD 0E92 61 PUSH2 0x04f8 0E95 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E8C stack[-1] = 0x0e96 // @0E8E stack[0] = msg.data.length // @0E91 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x04f8, returns to 0x0E96 label_0E96: // Incoming return from call to 0x04F8 at 0x0E95 // Inputs[4] // { // @0E97 stack[-2] // @0E97 stack[-1] // @0EA0 stack[-3] // @0EA4 msg.sender // } 0E96 5B JUMPDEST 0E97 90 SWAP1 0E98 60 PUSH1 0x01 0E9A 60 PUSH1 0x01 0E9C 60 PUSH1 0xa0 0E9E 1B SHL 0E9F 03 SUB 0EA0 83 DUP4 0EA1 81 DUP2 0EA2 16 AND 0EA3 90 SWAP1 0EA4 33 CALLER 0EA5 82 DUP3 0EA6 14 EQ 0EA7 15 ISZERO 0EA8 80 DUP1 0EA9 61 PUSH2 0x0f37 0EAC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0E97 stack[-1] = stack[-2] // @0E97 stack[-2] = stack[-1] // @0EA3 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0EA3 stack[1] = (0x01 << 0xa0) - 0x01 // @0EA7 stack[2] = !((0x01 << 0xa0) - 0x01 & stack[-3] == msg.sender) // } // Block ends with conditional jump to 0x0f37, if !((0x01 << 0xa0) - 0x01 & stack[-3] == msg.sender) label_0EAD: // Incoming jump from 0x0F5A // Incoming jump from 0x0EAC, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == msg.sender) // Inputs[1] { @0EB1 stack[-1] } 0EAD 5B JUMPDEST 0EAE 61 PUSH2 0x0f10 0EB1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f10, if stack[-1] label_0EB2: // Incoming jump from 0x0EB1, if not stack[-1] // Inputs[2] // { // @0EB2 stack[-3] // @0EB3 stack[-1] // } 0EB2 82 DUP3 0EB3 16 AND 0EB4 15 ISZERO 0EB5 61 PUSH2 0x0ef7 0EB8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ef7, if !(stack[-3] & stack[-1]) label_0EB9: // Incoming jump from 0x0EB8, if not !(stack[-3] & stack[-1]) // Inputs[1] { @0EB9 stack[-1] } 0EB9 15 ISZERO 0EBA 61 PUSH2 0x0a45 0EBD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a45, if !stack[-1] label_0EBE: // Incoming jump from 0x0EBD, if not !stack[-1] // Inputs[4] // { // @0EC1 stack[-3] // @0EC7 msg.data[0x64:0x84] // @0ECA msg.data[0x44:0x64] // @0ECE memory[0x40:0x60] // } 0EBE 61 PUSH2 0x05eb 0EC1 92 SWAP3 0EC2 61 PUSH2 0x0eef 0EC5 60 PUSH1 0x64 0EC7 35 CALLDATALOAD 0EC8 60 PUSH1 0x44 0ECA 35 CALLDATALOAD 0ECB 91 SWAP2 0ECC 60 PUSH1 0x40 0ECE 51 MLOAD 0ECF 92 SWAP3 0ED0 60 PUSH1 0x01 0ED2 84 DUP5 0ED3 52 MSTORE 0ED4 60 PUSH1 0x20 0ED6 84 DUP5 0ED7 01 ADD 0ED8 52 MSTORE 0ED9 60 PUSH1 0x40 0EDB 83 DUP4 0EDC 01 ADD 0EDD 91 SWAP2 0EDE 60 PUSH1 0x01 0EE0 83 DUP4 0EE1 52 MSTORE 0EE2 60 PUSH1 0x60 0EE4 84 DUP5 0EE5 01 ADD 0EE6 52 MSTORE 0EE7 60 PUSH1 0x80 0EE9 83 DUP4 0EEA 01 ADD 0EEB 60 PUSH1 0x40 0EED 52 MSTORE 0EEE 56 *JUMP // Stack delta = +3 // Outputs[9] // { // @0EC1 stack[-3] = 0x05eb // @0EC1 stack[0] = stack[-3] // @0ECF stack[1] = memory[0x40:0x60] // @0ED3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0ED8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[0x44:0x64] // @0EDD stack[2] = memory[0x40:0x60] + 0x40 // @0EE1 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x01 // @0EE6 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = msg.data[0x64:0x84] // @0EED memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // } // Block ends with call to 0x0eef, returns to 0x05EB label_0EEF: // Incoming call from 0x0EEE, returns to 0x05EB // Inputs[4] // { // @0EF0 stack[-4] // @0EF0 stack[-1] // @0EF1 stack[-2] // @0EF2 stack[-3] // } 0EEF 5B JUMPDEST 0EF0 92 SWAP3 0EF1 90 SWAP1 0EF2 91 SWAP2 0EF3 61 PUSH2 0x1451 0EF6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0EF0 stack[-4] = stack[-1] // @0EF1 stack[-2] = stack[-4] // @0EF2 stack[-1] = stack[-3] // @0EF2 stack[-3] = stack[-2] // } // Block ends with unconditional jump to 0x1451 label_0EF7: // Incoming jump from 0x0EB8, if !(stack[-3] & stack[-1]) // Incoming jump from 0x12A0, if !(stack[-1] & (0x01 << 0xa0) - 0x01) // Inputs[2] // { // @0EFA memory[0x40:0x60] // @0F0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0EF7 5B JUMPDEST 0EF8 60 PUSH1 0x40 0EFA 51 MLOAD 0EFB 63 PUSH4 0x2bfa23e7 0F00 60 PUSH1 0xe1 0F02 1B SHL 0F03 81 DUP2 0F04 52 MSTORE 0F05 60 PUSH1 0x00 0F07 60 PUSH1 0x04 0F09 82 DUP3 0F0A 01 ADD 0F0B 52 MSTORE 0F0C 60 PUSH1 0x24 0F0E 90 SWAP1 0F0F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0F04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2bfa23e7 << 0xe1 // @0F0B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @0F0F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_0F10: // Incoming jump from 0x0EB1, if stack[-1] // Inputs[4] // { // @0F13 memory[0x40:0x60] // @0F1E msg.sender // @0F2C stack[-5] // @0F36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44] // } 0F10 5B JUMPDEST 0F11 60 PUSH1 0x40 0F13 51 MLOAD 0F14 63 PUSH4 0x711bec91 0F19 60 PUSH1 0xe1 0F1B 1B SHL 0F1C 81 DUP2 0F1D 52 MSTORE 0F1E 33 CALLER 0F1F 60 PUSH1 0x04 0F21 82 DUP3 0F22 01 ADD 0F23 52 MSTORE 0F24 60 PUSH1 0x01 0F26 60 PUSH1 0x01 0F28 60 PUSH1 0xa0 0F2A 1B SHL 0F2B 03 SUB 0F2C 86 DUP7 0F2D 16 AND 0F2E 60 PUSH1 0x24 0F30 82 DUP3 0F31 01 ADD 0F32 52 MSTORE 0F33 60 PUSH1 0x44 0F35 90 SWAP1 0F36 FD *REVERT // Stack delta = +0 // Outputs[4] // { // @0F1D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x711bec91 << 0xe1 // @0F23 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0F32 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0F36 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44]); // } // Block terminates label_0F37: // Incoming jump from 0x0EAC, if !((0x01 << 0xa0) - 0x01 & stack[-3] == msg.sender) // Inputs[5] // { // @0F3B stack[-3] // @0F49 memory[0x00:0x40] // @0F4A msg.sender // @0F51 memory[0x00:0x40] // @0F52 storage[keccak256(memory[0x00:0x40])] // } 0F37 5B JUMPDEST 0F38 50 POP 0F39 60 PUSH1 0x00 0F3B 82 DUP3 0F3C 81 DUP2 0F3D 52 MSTORE 0F3E 60 PUSH1 0x01 0F40 60 PUSH1 0x20 0F42 90 SWAP1 0F43 81 DUP2 0F44 52 MSTORE 0F45 60 PUSH1 0x40 0F47 80 DUP1 0F48 83 DUP4 0F49 20 SHA3 0F4A 33 CALLER 0F4B 84 DUP5 0F4C 52 MSTORE 0F4D 90 SWAP1 0F4E 91 SWAP2 0F4F 52 MSTORE 0F50 90 SWAP1 0F51 20 SHA3 0F52 54 SLOAD 0F53 60 PUSH1 0xff 0F55 16 AND 0F56 15 ISZERO 0F57 61 PUSH2 0x0ead 0F5A 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0F3D memory[0x00:0x20] = stack[-3] // @0F44 memory[0x20:0x40] = 0x01 // @0F4C memory[0x00:0x20] = msg.sender // @0F4F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0F56 stack[-1] = !(0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to 0x0ead label_0F5B: // Incoming jump from 0x0142 // Inputs[1] { @0F5C msg.value } 0F5B 5B JUMPDEST 0F5C 34 CALLVALUE 0F5D 61 PUSH2 0x01cc 0F60 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0F61: // Incoming jump from 0x0F60, if not msg.value // Inputs[1] { @0F63 msg.data.length } 0F61 60 PUSH1 0x20 0F63 36 CALLDATASIZE 0F64 60 PUSH1 0x03 0F66 19 NOT 0F67 01 ADD 0F68 12 SLT 0F69 61 PUSH2 0x01cc 0F6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x20 label_0F6D: // Incoming jump from 0x0F6C, if not ~0x03 + msg.data.length i< 0x20 // Inputs[1] { @0F6F msg.data[0x04:0x24] } 0F6D 60 PUSH1 0x04 0F6F 35 CALLDATALOAD 0F70 61 PUSH2 0x0f78 0F73 81 DUP2 0F74 61 PUSH2 0x01bb 0F77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F6F stack[0] = msg.data[0x04:0x24] // @0F70 stack[1] = 0x0f78 // @0F73 stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x0F78 label_0F78: // Incoming return from call to 0x01BB at 0x0F77 0F78 5B JUMPDEST 0F79 61 PUSH2 0x0f80 0F7C 61 PUSH2 0x1263 0F7F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F79 stack[0] = 0x0f80 } // Block ends with call to 0x1263, returns to 0x0F80 label_0F80: // Incoming return from call to 0x1263 at 0x0F7F // Inputs[1] { @0F89 stack[-1] } 0F80 5B JUMPDEST 0F81 60 PUSH1 0x01 0F83 60 PUSH1 0x01 0F85 60 PUSH1 0xa0 0F87 1B SHL 0F88 03 SUB 0F89 90 SWAP1 0F8A 81 DUP2 0F8B 16 AND 0F8C 90 SWAP1 0F8D 81 DUP2 0F8E 15 ISZERO 0F8F 61 PUSH2 0x0fd4 0F92 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0F8C stack[0] = (0x01 << 0xa0) - 0x01 // @0F8C stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x0fd4, if !((0x01 << 0xa0) - 0x01 & stack[-1]) label_0F93: // Incoming jump from 0x0F92, if not !((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[4] // { // @0F95 storage[0x05] // @0F96 stack[-2] // @0FAD stack[-1] // @0FD2 memory[0x00:0x00] // } 0F93 60 PUSH1 0x05 0F95 54 SLOAD 0F96 82 DUP3 0F97 6B PUSH12 0xffffffffffffffffffffffff 0FA4 60 PUSH1 0xa0 0FA6 1B SHL 0FA7 82 DUP3 0FA8 16 AND 0FA9 17 OR 0FAA 60 PUSH1 0x05 0FAC 55 SSTORE 0FAD 16 AND 0FAE 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0FCF 60 PUSH1 0x00 0FD1 80 DUP1 0FD2 A3 LOG3 0FD3 00 *STOP // Stack delta = -2 // Outputs[3] // { // @0FAC storage[0x05] = (storage[0x05] & (0xffffffffffffffffffffffff << 0xa0)) | stack[-2] // @0FD2 log(memory[0x00:0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x05] & stack[-1], stack[-2]]); // @0FD3 stop(); // } // Block terminates label_0FD4: // Incoming jump from 0x0F92, if !((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0FD7 memory[0x40:0x60] // @0FEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 0FD4 5B JUMPDEST 0FD5 60 PUSH1 0x40 0FD7 51 MLOAD 0FD8 63 PUSH4 0x1e4fbdf7 0FDD 60 PUSH1 0xe0 0FDF 1B SHL 0FE0 81 DUP2 0FE1 52 MSTORE 0FE2 60 PUSH1 0x00 0FE4 60 PUSH1 0x04 0FE6 82 DUP3 0FE7 01 ADD 0FE8 52 MSTORE 0FE9 60 PUSH1 0x24 0FEB 90 SWAP1 0FEC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0FE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e4fbdf7 << 0xe0 // @0FE8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @0FEC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_0FED: // Incoming jump from 0x013D // Inputs[1] { @0FEE msg.value } 0FED 5B JUMPDEST 0FEE 34 CALLVALUE 0FEF 61 PUSH2 0x01cc 0FF2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if msg.value label_0FF3: // Incoming jump from 0x0FF2, if not msg.value // Inputs[1] { @0FF5 msg.data.length } 0FF3 60 PUSH1 0x60 0FF5 36 CALLDATASIZE 0FF6 60 PUSH1 0x03 0FF8 19 NOT 0FF9 01 ADD 0FFA 12 SLT 0FFB 61 PUSH2 0x01cc 0FFE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if ~0x03 + msg.data.length i< 0x60 label_0FFF: // Incoming jump from 0x0FFE, if not ~0x03 + msg.data.length i< 0x60 // Inputs[1] { @1001 msg.data[0x04:0x24] } 0FFF 60 PUSH1 0x04 1001 35 CALLDATALOAD 1002 61 PUSH2 0x100a 1005 81 DUP2 1006 61 PUSH2 0x01bb 1009 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1001 stack[0] = msg.data[0x04:0x24] // @1002 stack[1] = 0x100a // @1005 stack[2] = msg.data[0x04:0x24] // } // Block ends with call to 0x01bb, returns to 0x100A label_100A: // Incoming return from call to 0x01BB at 0x1009 // Inputs[2] // { // @1013 stack[-1] // @1015 msg.sender // } 100A 5B JUMPDEST 100B 60 PUSH1 0x01 100D 60 PUSH1 0x01 100F 60 PUSH1 0xa0 1011 1B SHL 1012 03 SUB 1013 81 DUP2 1014 16 AND 1015 33 CALLER 1016 81 DUP2 1017 14 EQ 1018 15 ISZERO 1019 80 DUP1 101A 61 PUSH2 0x108f 101D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1014 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1018 stack[1] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) // } // Block ends with conditional jump to 0x108f, if !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) label_101E: // Incoming jump from 0x101D, if not !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) // Incoming jump from 0x10B2 // Inputs[1] { @1022 stack[-1] } 101E 5B JUMPDEST 101F 61 PUSH2 0x1068 1022 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1068, if stack[-1] label_1023: // Incoming jump from 0x1022, if not stack[-1] // Inputs[1] { @1023 stack[-1] } 1023 15 ISZERO 1024 61 PUSH2 0x0a45 1027 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a45, if !stack[-1] label_1028: // Incoming jump from 0x1027, if not !stack[-1] // Inputs[4] // { // @102B stack[-1] // @1031 msg.data[0x44:0x64] // @1034 msg.data[0x24:0x44] // @1038 memory[0x40:0x60] // } 1028 61 PUSH2 0x05eb 102B 90 SWAP1 102C 61 PUSH2 0x1059 102F 60 PUSH1 0x44 1031 35 CALLDATALOAD 1032 60 PUSH1 0x24 1034 35 CALLDATALOAD 1035 91 SWAP2 1036 60 PUSH1 0x40 1038 51 MLOAD 1039 92 SWAP3 103A 60 PUSH1 0x01 103C 84 DUP5 103D 52 MSTORE 103E 60 PUSH1 0x20 1040 84 DUP5 1041 01 ADD 1042 52 MSTORE 1043 60 PUSH1 0x40 1045 83 DUP4 1046 01 ADD 1047 91 SWAP2 1048 60 PUSH1 0x01 104A 83 DUP4 104B 52 MSTORE 104C 60 PUSH1 0x60 104E 84 DUP5 104F 01 ADD 1050 52 MSTORE 1051 60 PUSH1 0x80 1053 83 DUP4 1054 01 ADD 1055 60 PUSH1 0x40 1057 52 MSTORE 1058 56 *JUMP // Stack delta = +3 // Outputs[9] // { // @102B stack[-1] = 0x05eb // @102B stack[0] = stack[-1] // @1039 stack[1] = memory[0x40:0x60] // @103D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1042 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[0x24:0x44] // @1047 stack[2] = memory[0x40:0x60] + 0x40 // @104B memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x01 // @1050 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = msg.data[0x44:0x64] // @1057 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // } // Block ends with call to 0x1059, returns to 0x05EB label_1059: // Incoming call from 0x1058, returns to 0x05EB // Inputs[3] // { // @105A stack[-3] // @105A stack[-1] // @105F memory[0x40:0x60] // } 1059 5B JUMPDEST 105A 91 SWAP2 105B 60 PUSH1 0x00 105D 60 PUSH1 0x40 105F 51 MLOAD 1060 61 PUSH2 0x0a3f 1063 81 DUP2 1064 61 PUSH2 0x0421 1067 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @105A stack[-1] = stack[-3] // @105A stack[-3] = stack[-1] // @105B stack[0] = 0x00 // @105F stack[1] = memory[0x40:0x60] // @1060 stack[2] = 0x0a3f // @1063 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x0421, returns to 0x0A3F label_1068: // Incoming jump from 0x1022, if stack[-1] // Inputs[4] // { // @106B memory[0x40:0x60] // @1076 msg.sender // @1084 stack[-2] // @108E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44] // } 1068 5B JUMPDEST 1069 60 PUSH1 0x40 106B 51 MLOAD 106C 63 PUSH4 0x711bec91 1071 60 PUSH1 0xe1 1073 1B SHL 1074 81 DUP2 1075 52 MSTORE 1076 33 CALLER 1077 60 PUSH1 0x04 1079 82 DUP3 107A 01 ADD 107B 52 MSTORE 107C 60 PUSH1 0x01 107E 60 PUSH1 0x01 1080 60 PUSH1 0xa0 1082 1B SHL 1083 03 SUB 1084 83 DUP4 1085 16 AND 1086 60 PUSH1 0x24 1088 82 DUP3 1089 01 ADD 108A 52 MSTORE 108B 60 PUSH1 0x44 108D 90 SWAP1 108E FD *REVERT // Stack delta = +0 // Outputs[4] // { // @1075 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x711bec91 << 0xe1 // @107B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @108A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @108E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44]); // } // Block terminates label_108F: // Incoming jump from 0x101D, if !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[5] // { // @1093 stack[-2] // @10A1 memory[0x00:0x40] // @10A2 msg.sender // @10A9 memory[0x00:0x40] // @10AA storage[keccak256(memory[0x00:0x40])] // } 108F 5B JUMPDEST 1090 50 POP 1091 60 PUSH1 0x00 1093 81 DUP2 1094 81 DUP2 1095 52 MSTORE 1096 60 PUSH1 0x01 1098 60 PUSH1 0x20 109A 90 SWAP1 109B 81 DUP2 109C 52 MSTORE 109D 60 PUSH1 0x40 109F 80 DUP1 10A0 83 DUP4 10A1 20 SHA3 10A2 33 CALLER 10A3 84 DUP5 10A4 52 MSTORE 10A5 90 SWAP1 10A6 91 SWAP2 10A7 52 MSTORE 10A8 90 SWAP1 10A9 20 SHA3 10AA 54 SLOAD 10AB 60 PUSH1 0xff 10AD 16 AND 10AE 15 ISZERO 10AF 61 PUSH2 0x101e 10B2 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @1095 memory[0x00:0x20] = stack[-2] // @109C memory[0x20:0x40] = 0x01 // @10A4 memory[0x00:0x20] = msg.sender // @10A7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @10AE stack[-1] = !(0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to 0x101e label_10B3: // Incoming jump from 0x03EC // Inputs[5] // { // @10B6 memory[0x40:0x60] // @10B7 returndata.length // @10BB returndata[0x00:0x00 + returndata.length] // @10BC returndata.length // @10BE memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] // } 10B3 5B JUMPDEST 10B4 60 PUSH1 0x40 10B6 51 MLOAD 10B7 3D RETURNDATASIZE 10B8 60 PUSH1 0x00 10BA 82 DUP3 10BB 3E RETURNDATACOPY 10BC 3D RETURNDATASIZE 10BD 90 SWAP1 10BE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10BB memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10BE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length]); // } // Block terminates label_10BF: // Incoming call from 0x06EA, returns to 0x06EB // Inputs[1] { @10C0 stack[-1] } 10BF 5B JUMPDEST 10C0 15 ISZERO 10C1 61 PUSH2 0x10c6 10C4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10c6, if !stack[-1] label_10C5: // Incoming jump from 0x10C4, if not !stack[-1] // Inputs[1] { @10C5 stack[-1] } 10C5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_10C6: // Incoming jump from 0x10C4, if !stack[-1] // Inputs[2] // { // @10C9 memory[0x40:0x60] // @10FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64] // } 10C6 5B JUMPDEST 10C7 60 PUSH1 0x40 10C9 51 MLOAD 10CA 62 PUSH3 0x461bcd 10CE 60 PUSH1 0xe5 10D0 1B SHL 10D1 81 DUP2 10D2 52 MSTORE 10D3 60 PUSH1 0x20 10D5 60 PUSH1 0x04 10D7 82 DUP3 10D8 01 ADD 10D9 52 MSTORE 10DA 60 PUSH1 0x0f 10DC 60 PUSH1 0x24 10DE 82 DUP3 10DF 01 ADD 10E0 52 MSTORE 10E1 6E PUSH15 0x1d1c985b9cd9995c8819985a5b1959 10F1 60 PUSH1 0x8a 10F3 1B SHL 10F4 60 PUSH1 0x44 10F6 82 DUP3 10F7 01 ADD 10F8 52 MSTORE 10F9 60 PUSH1 0x64 10FB 90 SWAP1 10FC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @10D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10D9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10E0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @10F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d1c985b9cd9995c8819985a5b1959 << 0x8a // @10FC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64]); // } // Block terminates label_10FD: // Incoming jump from 0x112A // Inputs[1] { @1112 memory[0x00:0x24] } 10FD 5B JUMPDEST 10FE 63 PUSH4 0x4e487b71 1103 60 PUSH1 0xe0 1105 1B SHL 1106 60 PUSH1 0x00 1108 52 MSTORE 1109 60 PUSH1 0x11 110B 60 PUSH1 0x04 110D 52 MSTORE 110E 60 PUSH1 0x24 1110 60 PUSH1 0x00 1112 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1108 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @110D memory[0x04:0x24] = 0x11 // @1112 revert(memory[0x00:0x24]); // } // Block terminates label_1113: // Incoming jump from 0x077D // Inputs[3] // { // @1114 stack[-2] // @1115 stack[-1] // @1117 stack[-3] // } 1113 5B JUMPDEST 1114 81 DUP2 1115 81 DUP2 1116 02 MUL 1117 92 SWAP3 1118 91 SWAP2 1119 81 DUP2 111A 15 ISZERO 111B 91 SWAP2 111C 84 DUP5 111D 04 DIV 111E 14 EQ 111F 17 OR 1120 15 ISZERO 1121 61 PUSH2 0x1126 1124 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1117 stack[-3] = stack[-1] * stack[-2] // @1118 stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x1126, if !(((stack[-1] * stack[-2]) / stack[-1] == stack[-2]) | !stack[-1]) label_1125: // Incoming jump from 0x1124, if not !(((stack[-1] * stack[-2]) / stack[-1] == stack[-2]) | !stack[-1]) // Inputs[1] { @1125 stack[-1] } 1125 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1126: // Incoming jump from 0x186F, if stack[-1] > stack[-1] + stack[-2] // Incoming jump from 0x1124, if !(((stack[-1] * stack[-2]) / stack[-1] == stack[-2]) | !stack[-1]) 1126 5B JUMPDEST 1127 61 PUSH2 0x10fd 112A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10fd label_112B: // Incoming jump from 0x0784 // Inputs[1] { @112C stack[-1] } 112B 5B JUMPDEST 112C 15 ISZERO 112D 61 PUSH2 0x1132 1130 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1132, if !stack[-1] label_1131: // Incoming jump from 0x1130, if not !stack[-1] // Inputs[1] { @1131 stack[-1] } 1131 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1132: // Incoming jump from 0x1130, if !stack[-1] // Inputs[2] // { // @1135 memory[0x40:0x60] // @1166 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64] // } 1132 5B JUMPDEST 1133 60 PUSH1 0x40 1135 51 MLOAD 1136 62 PUSH3 0x461bcd 113A 60 PUSH1 0xe5 113C 1B SHL 113D 81 DUP2 113E 52 MSTORE 113F 60 PUSH1 0x20 1141 60 PUSH1 0x04 1143 82 DUP3 1144 01 ADD 1145 52 MSTORE 1146 60 PUSH1 0x0d 1148 60 PUSH1 0x24 114A 82 DUP3 114B 01 ADD 114C 52 MSTORE 114D 6C PUSH13 0x696e76616c69642076616c7565 115B 60 PUSH1 0x98 115D 1B SHL 115E 60 PUSH1 0x44 1160 82 DUP3 1161 01 ADD 1162 52 MSTORE 1163 60 PUSH1 0x64 1165 90 SWAP1 1166 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @113E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1145 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @114C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1162 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x696e76616c69642076616c7565 << 0x98 // @1166 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64]); // } // Block terminates label_1167: // Incoming call from 0x078C, returns to 0x078D // Inputs[2] // { // @116A memory[0x40:0x60] // @116B stack[-1] // } 1167 5B JUMPDEST 1168 60 PUSH1 0x40 116A 51 MLOAD 116B 90 SWAP1 116C 61 PUSH2 0x1174 116F 82 DUP3 1170 61 PUSH2 0x0421 1173 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @116B stack[0] = stack[-1] // @116B stack[-1] = memory[0x40:0x60] // @116C stack[1] = 0x1174 // @116F stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0421, returns to 0x1174 label_1174: // Incoming return from call to 0x0421 at 0x1173 // Inputs[2] // { // @1177 stack[-2] // @1179 stack[-1] // } 1174 5B JUMPDEST 1175 60 PUSH1 0x00 1177 82 DUP3 1178 52 MSTORE 1179 56 *JUMP // Stack delta = -1 // Outputs[1] { @1178 memory[stack[-2]:stack[-2] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-1] label_117A: // Incoming call from 0x13D6, returns to 0x13D7 // Incoming call from 0x14EC, returns to 0x1301 // Incoming call from 0x1432, returns to 0x1301 // Incoming call from 0x13E5, returns to 0x1301 // Incoming call from 0x1546, returns to 0x1301 // Incoming call from 0x14DD, returns to 0x14DE // Incoming call from 0x1537, returns to 0x1538 // Incoming call from 0x1231, returns to 0x1232 // Incoming call from 0x1423, returns to 0x1424 // Inputs[3] // { // @117B stack[-1] // @117C memory[stack[-1]:stack[-1] + 0x20] // @117D stack[-2] // } 117A 5B JUMPDEST 117B 80 DUP1 117C 51 MLOAD 117D 82 DUP3 117E 10 LT 117F 15 ISZERO 1180 61 PUSH2 0x118e 1183 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x118e, if !(stack[-2] < memory[stack[-1]:stack[-1] + 0x20]) label_1184: // Incoming jump from 0x1183, if not !(stack[-2] < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1186 stack[-2] // @118A stack[-1] // @118C stack[-3] // } 1184 60 PUSH1 0x20 1186 91 SWAP2 1187 60 PUSH1 0x05 1189 1B SHL 118A 01 ADD 118B 01 ADD 118C 90 SWAP1 118D 56 *JUMP // Stack delta = -2 // Outputs[1] { @118C stack[-3] = (stack[-2] << 0x05) + stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-3] label_118E: // Incoming jump from 0x1183, if !(stack[-2] < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @11A3 memory[0x00:0x24] } 118E 5B JUMPDEST 118F 63 PUSH4 0x4e487b71 1194 60 PUSH1 0xe0 1196 1B SHL 1197 60 PUSH1 0x00 1199 52 MSTORE 119A 60 PUSH1 0x32 119C 60 PUSH1 0x04 119E 52 MSTORE 119F 60 PUSH1 0x24 11A1 60 PUSH1 0x00 11A3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1199 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @119E memory[0x04:0x24] = 0x32 // @11A3 revert(memory[0x00:0x24]); // } // Block terminates label_11A4: // Incoming jump from 0x08A2 // Inputs[5] // { // @11A5 stack[-1] // @11A5 stack[-3] // @11A6 stack[-2] // @11A9 memory[stack[-1]:stack[-1] + 0x20] // @11AB memory[stack[-2]:stack[-2] + 0x20] // } 11A4 5B JUMPDEST 11A5 91 SWAP2 11A6 90 SWAP1 11A7 91 SWAP2 11A8 80 DUP1 11A9 51 MLOAD 11AA 83 DUP4 11AB 51 MLOAD 11AC 80 DUP1 11AD 82 DUP3 11AE 03 SUB 11AF 61 PUSH2 0x1241 11B2 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @11A6 stack[-2] = stack[-3] // @11A7 stack[-3] = stack[-2] // @11A7 stack[-1] = stack[-1] // @11A9 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @11AB stack[1] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1241, if memory[stack[-1]:stack[-1] + 0x20] - memory[stack[-2]:stack[-2] + 0x20] label_11B3: // Incoming jump from 0x11B2, if not memory[stack[-1]:stack[-1] + 0x20] - memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @11B5 stack[-3] // @11B6 memory[stack[-3]:stack[-3] + 0x20] // } 11B3 50 POP 11B4 50 POP 11B5 80 DUP1 11B6 51 MLOAD 11B7 90 SWAP1 11B8 61 PUSH2 0x11d9 11BB 61 PUSH2 0x11c3 11BE 83 DUP4 11BF 61 PUSH2 0x0464 11C2 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @11B7 stack[-3] = memory[stack[-3]:stack[-3] + 0x20] // @11B7 stack[-2] = stack[-3] // @11B8 stack[-1] = 0x11d9 // @11BB stack[0] = 0x11c3 // @11BE stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x0464, returns to 0x11C3 label_11C3: // Incoming return from call to 0x0464 at 0x11C2 // Inputs[3] // { // @11C4 stack[-4] // @11C4 stack[-1] // @11CA memory[0x40:0x60] // } 11C3 5B JUMPDEST 11C4 92 SWAP3 11C5 61 PUSH2 0x11d1 11C8 60 PUSH1 0x40 11CA 51 MLOAD 11CB 94 SWAP5 11CC 85 DUP6 11CD 61 PUSH2 0x0442 11D0 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @11C4 stack[-1] = stack[-4] // @11C5 stack[0] = 0x11d1 // @11CB stack[-4] = memory[0x40:0x60] // @11CB stack[1] = stack[-1] // @11CC stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x11D1 label_11D1: // Incoming return from call to 0x0442 at 0x11D0 // Inputs[2] // { // @11D2 stack[-1] // @11D3 stack[-4] // } 11D1 5B JUMPDEST 11D2 80 DUP1 11D3 84 DUP5 11D4 52 MSTORE 11D5 61 PUSH2 0x0464 11D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @11D4 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] } // Block ends with unconditional jump to 0x0464 label_11D9: // Incoming return from call to 0x11C3 at 0x11C2 // Inputs[6] // { // @11DC stack[-2] // @11DD stack[-1] // @11E2 msg.data.length // @11E3 stack[-3] // @11E6 msg.data[msg.data.length:msg.data.length + ~0x1f + stack[-1]] // @11EB memory[stack[-2]:stack[-2] + 0x20] // } 11D9 5B JUMPDEST 11DA 60 PUSH1 0x20 11DC 91 SWAP2 11DD 90 SWAP1 11DE 60 PUSH1 0x1f 11E0 19 NOT 11E1 01 ADD 11E2 36 CALLDATASIZE 11E3 84 DUP5 11E4 84 DUP5 11E5 01 ADD 11E6 37 CALLDATACOPY 11E7 60 PUSH1 0x00 11E9 5B JUMPDEST 11EA 81 DUP2 11EB 51 MLOAD 11EC 81 DUP2 11ED 10 LT 11EE 15 ISZERO 11EF 61 PUSH2 0x1239 11F2 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @11DC stack[-2] = 0x20 // @11DD stack[-1] = stack[-2] // @11E6 memory[0x20 + stack[-3]:0x20 + stack[-3] + ~0x1f + stack[-1]] = msg.data[msg.data.length:msg.data.length + ~0x1f + stack[-1]] // @11E7 stack[0] = 0x00 // } // Block ends with conditional jump to 0x1239, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_11F3: // Incoming jump from 0x11F2, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11F2, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[10] // { // @11F5 stack[-1] // @11F8 stack[-2] // @11FB stack[-3] // @11FD memory[stack[-3] + (stack[-1] << 0x05) + stack[-2]:stack[-3] + (stack[-1] << 0x05) + stack[-2] + 0x20] // @11FF stack[-6] // @1203 memory[stack[-3] + stack[-6] + (stack[-1] << 0x05):stack[-3] + stack[-6] + (stack[-1] << 0x05) + 0x20] // @1212 memory[0x00:0x40] // @1223 memory[0x00:0x40] // @1224 storage[keccak256(memory[0x00:0x40])] // @122D stack[-4] // } 11F3 60 PUSH1 0x05 11F5 81 DUP2 11F6 90 SWAP1 11F7 1B SHL 11F8 82 DUP3 11F9 81 DUP2 11FA 01 ADD 11FB 84 DUP5 11FC 01 ADD 11FD 51 MLOAD 11FE 90 SWAP1 11FF 87 DUP8 1200 01 ADD 1201 84 DUP5 1202 01 ADD 1203 51 MLOAD 1204 60 PUSH1 0x00 1206 90 SWAP1 1207 81 DUP2 1208 52 MSTORE 1209 60 PUSH1 0x20 120B 81 DUP2 120C 81 DUP2 120D 52 MSTORE 120E 60 PUSH1 0x40 1210 80 DUP1 1211 83 DUP4 1212 20 SHA3 1213 60 PUSH1 0x01 1215 60 PUSH1 0x01 1217 60 PUSH1 0xa0 1219 1B SHL 121A 03 SUB 121B 90 SWAP1 121C 94 SWAP5 121D 16 AND 121E 83 DUP4 121F 52 MSTORE 1220 92 SWAP3 1221 90 SWAP1 1222 52 MSTORE 1223 20 SHA3 1224 54 SLOAD 1225 60 PUSH1 0x01 1227 91 SWAP2 1228 90 SWAP1 1229 61 PUSH2 0x1232 122C 82 DUP3 122D 87 DUP8 122E 61 PUSH2 0x117a 1231 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @1208 memory[0x00:0x20] = memory[stack[-3] + stack[-6] + (stack[-1] << 0x05):stack[-3] + stack[-6] + (stack[-1] << 0x05) + 0x20] // @120D memory[0x20:0x40] = 0x00 // @121F memory[0x00:0x20] = memory[stack[-3] + (stack[-1] << 0x05) + stack[-2]:stack[-3] + (stack[-1] << 0x05) + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @1222 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1227 stack[-1] = 0x01 // @1228 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1228 stack[0] = stack[-1] // @1229 stack[2] = 0x1232 // @122C stack[3] = stack[-1] // @122D stack[4] = stack[-4] // } // Block ends with call to 0x117a, returns to 0x1232 label_1232: // Incoming return from call to 0x117A at 0x1231 // Inputs[4] // { // @1233 stack[-2] // @1233 stack[-1] // @1234 stack[-4] // @1234 stack[-3] // } 1232 5B JUMPDEST 1233 52 MSTORE 1234 01 ADD 1235 61 PUSH2 0x11e9 1238 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1233 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1234 stack[-4] = stack[-3] + stack[-4] // } // Block ends with unconditional jump to 0x11e9 label_1239: // Incoming jump from 0x11F2, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11F2, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @123B stack[-4] // @123B stack[-2] // @123C stack[-6] // @1240 stack[-5] // } 1239 5B JUMPDEST 123A 50 POP 123B 91 SWAP2 123C 93 SWAP4 123D 50 POP 123E 50 POP 123F 50 POP 1240 56 *JUMP // Stack delta = -5 // Outputs[1] { @123C stack[-6] = stack[-4] } // Block ends with unconditional jump to stack[-5] label_1241: // Incoming jump from 0x11B2, if memory[stack[-1]:stack[-1] + 0x20] - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x18A5, if memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x1B3D, if memory[stack[-3]:stack[-3] + 0x20] - memory[stack[-4]:stack[-4] + 0x20] // Incoming jump from 0x19D7, if memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @1244 memory[0x40:0x60] // @1253 stack[-1] // @125B stack[-2] // @1262 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44] // } 1241 5B JUMPDEST 1242 60 PUSH1 0x40 1244 51 MLOAD 1245 63 PUSH4 0x5b059991 124A 60 PUSH1 0xe0 124C 1B SHL 124D 81 DUP2 124E 52 MSTORE 124F 60 PUSH1 0x04 1251 81 DUP2 1252 01 ADD 1253 91 SWAP2 1254 90 SWAP1 1255 91 SWAP2 1256 52 MSTORE 1257 60 PUSH1 0x24 1259 81 DUP2 125A 01 ADD 125B 91 SWAP2 125C 90 SWAP1 125D 91 SWAP2 125E 52 MSTORE 125F 60 PUSH1 0x44 1261 90 SWAP1 1262 FD *REVERT // Stack delta = -2 // Outputs[4] // { // @124E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5b059991 << 0xe0 // @1256 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] // @125E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-2] // @1262 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x44]); // } // Block terminates label_1263: // Incoming call from 0x0D82, returns to 0x0D83 // Incoming call from 0x0E31, returns to 0x0E32 // Incoming call from 0x06A1, returns to 0x06A2 // Incoming call from 0x0F7F, returns to 0x0F80 // Incoming call from 0x0961, returns to 0x0962 // Incoming call from 0x0AC1, returns to 0x0AC2 // Incoming call from 0x091A, returns to 0x091B // Inputs[2] // { // @1266 storage[0x05] // @1270 msg.sender // } 1263 5B JUMPDEST 1264 60 PUSH1 0x05 1266 54 SLOAD 1267 60 PUSH1 0x01 1269 60 PUSH1 0x01 126B 60 PUSH1 0xa0 126D 1B SHL 126E 03 SUB 126F 16 AND 1270 33 CALLER 1271 03 SUB 1272 61 PUSH2 0x1277 1275 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1277, if msg.sender - ((0x01 << 0xa0) - 0x01 & storage[0x05]) label_1276: // Incoming jump from 0x1275, if not msg.sender - ((0x01 << 0xa0) - 0x01 & storage[0x05]) // Inputs[1] { @1276 stack[-1] } 1276 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1277: // Incoming jump from 0x1275, if msg.sender - ((0x01 << 0xa0) - 0x01 & storage[0x05]) // Inputs[3] // { // @127A memory[0x40:0x60] // @1285 msg.sender // @128E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24] // } 1277 5B JUMPDEST 1278 60 PUSH1 0x40 127A 51 MLOAD 127B 63 PUSH4 0x118cdaa7 1280 60 PUSH1 0xe0 1282 1B SHL 1283 81 DUP2 1284 52 MSTORE 1285 33 CALLER 1286 60 PUSH1 0x04 1288 82 DUP3 1289 01 ADD 128A 52 MSTORE 128B 60 PUSH1 0x24 128D 90 SWAP1 128E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1284 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x118cdaa7 << 0xe0 // @128A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @128E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x24]); // } // Block terminates label_128F: // Incoming jump from 0x0793 // Inputs[3] // { // @1290 stack[-1] // @1290 stack[-5] // @1291 stack[-3] // } 128F 5B JUMPDEST 1290 93 SWAP4 1291 91 SWAP2 1292 60 PUSH1 0x01 1294 60 PUSH1 0x01 1296 60 PUSH1 0xa0 1298 1B SHL 1299 03 SUB 129A 85 DUP6 129B 16 AND 129C 15 ISZERO 129D 61 PUSH2 0x0ef7 12A0 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1290 stack[-5] = stack[-1] // @1291 stack[-1] = stack[-3] // @1291 stack[-3] = stack[-5] // } // Block ends with conditional jump to 0x0ef7, if !(stack[-1] & (0x01 << 0xa0) - 0x01) label_12A1: // Incoming jump from 0x12A0, if not !(stack[-1] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @12A6 memory[0x40:0x60] // @12A7 stack[-2] // @12B5 stack[-1] // } 12A1 61 PUSH2 0x12c7 12A4 60 PUSH1 0x40 12A6 51 MLOAD 12A7 92 SWAP3 12A8 60 PUSH1 0x01 12AA 84 DUP5 12AB 52 MSTORE 12AC 60 PUSH1 0x20 12AE 84 DUP5 12AF 01 ADD 12B0 52 MSTORE 12B1 60 PUSH1 0x40 12B3 83 DUP4 12B4 01 ADD 12B5 91 SWAP2 12B6 60 PUSH1 0x01 12B8 83 DUP4 12B9 52 MSTORE 12BA 60 PUSH1 0x60 12BC 84 DUP5 12BD 01 ADD 12BE 52 MSTORE 12BF 60 PUSH1 0x80 12C1 83 DUP4 12C2 01 ADD 12C3 60 PUSH1 0x40 12C5 52 MSTORE 12C6 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @12A7 stack[-2] = memory[0x40:0x60] // @12AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @12B0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @12B5 stack[-1] = memory[0x40:0x60] + 0x40 // @12B9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x01 // @12BE memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] // @12C5 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // } // Block ends with unconditional jump to 0x12c7 label_12C7: // Incoming jump from 0x12C6 // Inputs[4] // { // @12C8 stack[-1] // @12C8 stack[-2] // @12C9 stack[-3] // @12CF stack[-5] // } 12C7 5B JUMPDEST 12C8 90 SWAP1 12C9 91 SWAP2 12CA 61 PUSH2 0x12d4 12CD 82 DUP3 12CE 84 DUP5 12CF 87 DUP8 12D0 61 PUSH2 0x1896 12D3 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @12C8 stack[-2] = stack[-1] // @12C9 stack[-3] = stack[-2] // @12C9 stack[-1] = stack[-3] // @12CA stack[0] = 0x12d4 // @12CD stack[1] = stack[-1] // @12CE stack[2] = stack[-2] // @12CF stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1896 12D4 5B JUMPDEST 12D5 60 PUSH1 0x00 12D7 94 SWAP5 12D8 85 DUP6 12D9 5B JUMPDEST 12DA 84 DUP5 12DB 51 MLOAD 12DC 87 DUP8 12DD 10 LT 12DE 15 ISZERO 12DF 61 PUSH2 0x132c 12E2 57 *JUMPI 12E3 61 PUSH2 0x1324 12E6 60 PUSH1 0x01 12E8 91 SWAP2 12E9 61 PUSH2 0x12f2 12EC 89 DUP10 12ED 87 DUP8 12EE 61 PUSH2 0x117a 12F1 56 *JUMP 12F2 5B JUMPDEST 12F3 51 MLOAD 12F4 90 SWAP1 12F5 61 PUSH2 0x1312 12F8 61 PUSH2 0x1301 12FB 8B DUP12 12FC 8A DUP11 12FD 61 PUSH2 0x117a 1300 56 *JUMP label_1301: // Incoming return from call to 0x117A at 0x14EC // Incoming return from call to 0x117A at 0x1432 // Incoming return from call to 0x117A at 0x13E5 // Incoming return from call to 0x117A at 0x1546 // Inputs[4] // { // @1302 stack[-1] // @1302 memory[stack[-1]:stack[-1] + 0x20] // @130F memory[0x00:0x40] // @1310 stack[-2] // } 1301 5B JUMPDEST 1302 51 MLOAD 1303 60 PUSH1 0x00 1305 52 MSTORE 1306 60 PUSH1 0x03 1308 60 PUSH1 0x20 130A 52 MSTORE 130B 60 PUSH1 0x40 130D 60 PUSH1 0x00 130F 20 SHA3 1310 90 SWAP1 1311 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1305 memory[0x00:0x20] = memory[stack[-1]:stack[-1] + 0x20] // @130A memory[0x20:0x40] = 0x03 // @1310 stack[-2] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-2] label_1312: // Incoming return from call to 0x1301 at 0x1432 // Incoming return from call to 0x1301 at 0x1546 // Inputs[3] // { // @1316 stack[-3] // @1317 stack[-1] // @1318 storage[stack[-1]] // } 1312 5B JUMPDEST 1313 61 PUSH2 0x131d 1316 83 DUP4 1317 82 DUP3 1318 54 SLOAD 1319 61 PUSH2 0x1864 131C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1313 stack[0] = 0x131d // @1316 stack[1] = stack[-3] // @1318 stack[2] = storage[stack[-1]] // } // Block ends with call to 0x1864, returns to 0x131D label_131D: // Incoming return from call to 0x1864 at 0x131C // Inputs[2] // { // @131E stack[-2] // @131E stack[-1] // } 131D 5B JUMPDEST 131E 90 SWAP1 131F 55 SSTORE 1320 61 PUSH2 0x1864 1323 56 *JUMP // Stack delta = -2 // Outputs[1] { @131F storage[stack[-2]] = stack[-1] } // Block ends with unconditional jump to 0x1864 1324 5B JUMPDEST 1325 96 SWAP7 1326 01 ADD 1327 95 SWAP6 1328 61 PUSH2 0x12d9 132B 56 *JUMP 132C 5B JUMPDEST 132D 61 PUSH2 0x1346 1330 91 SWAP2 1331 95 SWAP6 1332 94 SWAP5 1333 92 SWAP3 1334 96 SWAP7 1335 50 POP 1336 61 PUSH2 0x1341 1339 90 SWAP1 133A 60 PUSH1 0x04 133C 54 SLOAD 133D 61 PUSH2 0x1864 1340 56 *JUMP label_1341: // Incoming return from call to 0x1864 at 0x144B // Incoming return from call to 0x1864 at 0x1566 // Inputs[2] // { // @1344 stack[-1] // @1345 stack[-2] // } 1341 5B JUMPDEST 1342 60 PUSH1 0x04 1344 55 SSTORE 1345 56 *JUMP // Stack delta = -2 // Outputs[1] { @1344 storage[0x04] = stack[-1] } // Block ends with unconditional jump to stack[-2] 1346 5B JUMPDEST 1347 80 DUP1 1348 51 MLOAD 1349 60 PUSH1 0x01 134B 03 SUB 134C 61 PUSH2 0x1366 134F 57 *JUMPI 1350 90 SWAP1 1351 60 PUSH1 0x20 1353 80 DUP1 1354 61 PUSH2 0x1364 1357 95 SWAP6 1358 93 SWAP4 1359 01 ADD 135A 51 MLOAD 135B 91 SWAP2 135C 01 ADD 135D 51 MLOAD 135E 91 SWAP2 135F 33 CALLER 1360 61 PUSH2 0x17f8 1363 56 *JUMP label_1364: // Incoming jump from 0x1406 // Inputs[1] { @1365 stack[-1] } 1364 5B JUMPDEST 1365 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] 1366 5B JUMPDEST 1367 61 PUSH2 0x1364 136A 93 SWAP4 136B 33 CALLER 136C 61 PUSH2 0x15fe 136F 56 *JUMP label_1370: // Incoming call from 0x0984, returns to 0x0985 // Inputs[1] { @1371 returndata.length } 1370 5B JUMPDEST 1371 3D RETURNDATASIZE 1372 15 ISZERO 1373 61 PUSH2 0x139b 1376 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x139b, if !returndata.length label_1377: // Incoming jump from 0x1376, if not !returndata.length // Inputs[2] // { // @1377 returndata.length // @1378 stack[-1] // } 1377 3D RETURNDATASIZE 1378 90 SWAP1 1379 61 PUSH2 0x1381 137C 82 DUP3 137D 61 PUSH2 0x04dc 1380 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1378 stack[0] = stack[-1] // @1378 stack[-1] = returndata.length // @1379 stack[1] = 0x1381 // @137C stack[2] = returndata.length // } // Block ends with call to 0x04dc, returns to 0x1381 label_1381: // Incoming return from call to 0x04DC at 0x1380 // Inputs[3] // { // @1382 stack[-3] // @1382 stack[-1] // @1388 memory[0x40:0x60] // } 1381 5B JUMPDEST 1382 91 SWAP2 1383 61 PUSH2 0x138f 1386 60 PUSH1 0x40 1388 51 MLOAD 1389 93 SWAP4 138A 84 DUP5 138B 61 PUSH2 0x0442 138E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1382 stack[-1] = stack[-3] // @1383 stack[0] = 0x138f // @1389 stack[-3] = memory[0x40:0x60] // @1389 stack[1] = stack[-1] // @138A stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0442, returns to 0x138F label_138F: // Incoming return from call to 0x0442 at 0x138E // Inputs[5] // { // @1390 stack[-3] // @1391 stack[-1] // @1392 returndata.length // @1399 returndata[0x00:0x00 + returndata.length] // @139A stack[-2] // } 138F 5B JUMPDEST 1390 82 DUP3 1391 52 MSTORE 1392 3D RETURNDATASIZE 1393 60 PUSH1 0x00 1395 60 PUSH1 0x20 1397 84 DUP5 1398 01 ADD 1399 3E RETURNDATACOPY 139A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1391 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1399 memory[stack[-3] + 0x20:stack[-3] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to stack[-2] label_139B: // Incoming jump from 0x1376, if !returndata.length // Inputs[1] { @139E stack[-1] } 139B 5B JUMPDEST 139C 60 PUSH1 0x60 139E 90 SWAP1 139F 56 *JUMP // Stack delta = +0 // Outputs[1] { @139E stack[-1] = 0x60 } // Block ends with unconditional jump to stack[-1] label_13A0: // Incoming jump from 0x0A44 // Inputs[4] // { // @13A1 stack[-1] // @13A1 stack[-4] // @13A2 stack[-3] // @13A8 stack[-2] // } 13A0 5B JUMPDEST 13A1 92 SWAP3 13A2 91 SWAP2 13A3 92 SWAP3 13A4 61 PUSH2 0x13ae 13A7 84 DUP5 13A8 83 DUP4 13A9 83 DUP4 13AA 61 PUSH2 0x19c8 13AD 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @13A2 stack[-3] = stack[-4] // @13A3 stack[-4] = stack[-3] // @13A3 stack[-1] = stack[-1] // @13A4 stack[0] = 0x13ae // @13A7 stack[1] = stack[-3] // @13A8 stack[2] = stack[-2] // @13A9 stack[3] = stack[-1] // } // Block ends with call to 0x19c8, returns to 0x13AE label_13AE: // Incoming return from call to 0x19C8 at 0x13AD // Inputs[1] { @13B7 stack[-1] } 13AE 5B JUMPDEST 13AF 60 PUSH1 0x01 13B1 60 PUSH1 0x01 13B3 60 PUSH1 0xa0 13B5 1B SHL 13B6 03 SUB 13B7 16 AND 13B8 15 ISZERO 13B9 61 PUSH2 0x1407 13BC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1407, if !((0x01 << 0xa0) - 0x01 & stack[-1]) label_13BD: // Incoming jump from 0x1450 // Incoming jump from 0x13BC, if not !((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @13C2 stack[-1] // @13C3 memory[stack[-1]:stack[-1] + 0x20] // } 13BD 5B JUMPDEST 13BE 60 PUSH1 0x00 13C0 80 DUP1 13C1 5B JUMPDEST 13C2 82 DUP3 13C3 51 MLOAD 13C4 82 DUP3 13C5 10 LT 13C6 15 ISZERO 13C7 61 PUSH2 0x13f5 13CA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13BE stack[0] = 0x00 // @13C0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x13f5, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_13CB: // Incoming jump from 0x13CA, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x13CA, if not !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @13CD stack[-1] // @13D1 stack[-2] // @13D2 stack[-5] // } 13CB 60 PUSH1 0x01 13CD 90 SWAP1 13CE 61 PUSH2 0x13d7 13D1 83 DUP4 13D2 87 DUP8 13D3 61 PUSH2 0x117a 13D6 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @13CD stack[0] = stack[-1] // @13CD stack[-1] = 0x01 // @13CE stack[1] = 0x13d7 // @13D1 stack[2] = stack[-2] // @13D2 stack[3] = stack[-5] // } // Block ends with call to 0x117a, returns to 0x13D7 label_13D7: // Incoming return from call to 0x117A at 0x13D6 // Inputs[5] // { // @13D8 stack[-1] // @13D8 memory[stack[-1]:stack[-1] + 0x20] // @13D9 stack[-2] // @13E0 stack[-4] // @13E1 stack[-5] // } 13D7 5B JUMPDEST 13D8 51 MLOAD 13D9 90 SWAP1 13DA 61 PUSH2 0x13e6 13DD 61 PUSH2 0x1301 13E0 85 DUP6 13E1 87 DUP8 13E2 61 PUSH2 0x117a 13E5 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @13D9 stack[-1] = stack[-2] // @13D9 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @13DA stack[0] = 0x13e6 // @13DD stack[1] = 0x1301 // @13E0 stack[2] = stack[-4] // @13E1 stack[3] = stack[-5] // } // Block ends with call to 0x117a, returns to 0x1301 label_13E6: // Incoming return from call to 0x1301 at 0x13E5 // Inputs[6] // { // @13E7 stack[-3] // @13E8 stack[-1] // @13E9 storage[stack[-1]] // @13ED stack[-2] // @13EE stack[-5] // @13EF stack[-4] // } 13E6 5B JUMPDEST 13E7 82 DUP3 13E8 81 DUP2 13E9 54 SLOAD 13EA 03 SUB 13EB 90 SWAP1 13EC 55 SSTORE 13ED 01 ADD 13EE 91 SWAP2 13EF 01 ADD 13F0 90 SWAP1 13F1 61 PUSH2 0x13c1 13F4 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @13EC storage[stack[-1]] = storage[stack[-1]] - stack[-3] // @13F0 stack[-4] = stack[-2] + stack[-3] // @13F0 stack[-5] = stack[-5] + stack[-4] // } // Block ends with unconditional jump to 0x13c1 label_13F5: // Incoming jump from 0x13CA, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x13CA, if !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[5] // { // @13F6 stack[-1] // @13F6 stack[-3] // @13FC stack[-4] // @13FD stack[-5] // @1401 storage[0x04] // } 13F5 5B JUMPDEST 13F6 91 SWAP2 13F7 50 POP 13F8 50 POP 13F9 61 PUSH2 0x1364 13FC 91 SWAP2 13FD 92 SWAP3 13FE 50 POP 13FF 60 PUSH1 0x04 1401 54 SLOAD 1402 03 SUB 1403 60 PUSH1 0x04 1405 55 SSTORE 1406 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @13FD stack[-5] = stack[-4] // @1405 storage[0x04] = storage[0x04] - stack[-1] // } // Block ends with unconditional jump to 0x1364 label_1407: // Incoming jump from 0x13BC, if !((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @140C stack[-1] // @140D memory[stack[-1]:stack[-1] + 0x20] // } 1407 5B JUMPDEST 1408 60 PUSH1 0x00 140A 80 DUP1 140B 5B JUMPDEST 140C 82 DUP3 140D 51 MLOAD 140E 82 DUP3 140F 10 LT 1410 15 ISZERO 1411 61 PUSH2 0x143b 1414 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1408 stack[0] = 0x00 // @140A stack[1] = 0x00 // } // Block ends with conditional jump to 0x143b, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1415: // Incoming jump from 0x1414, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1414, if not !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @141A stack[-1] // @141E stack[-2] // @141F stack[-5] // } 1415 61 PUSH2 0x1433 1418 60 PUSH1 0x01 141A 91 SWAP2 141B 61 PUSH2 0x1424 141E 84 DUP5 141F 88 DUP9 1420 61 PUSH2 0x117a 1423 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1415 stack[0] = 0x1433 // @141A stack[1] = stack[-1] // @141A stack[-1] = 0x01 // @141B stack[2] = 0x1424 // @141E stack[3] = stack[-2] // @141F stack[4] = stack[-5] // } // Block ends with call to 0x117a, returns to 0x1424 label_1424: // Incoming return from call to 0x117A at 0x1423 // Inputs[5] // { // @1425 memory[stack[-1]:stack[-1] + 0x20] // @1425 stack[-1] // @1426 stack[-2] // @142D stack[-5] // @142E stack[-6] // } 1424 5B JUMPDEST 1425 51 MLOAD 1426 90 SWAP1 1427 61 PUSH2 0x1312 142A 61 PUSH2 0x1301 142D 86 DUP7 142E 88 DUP9 142F 61 PUSH2 0x117a 1432 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1426 stack[-1] = stack[-2] // @1426 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @1427 stack[0] = 0x1312 // @142A stack[1] = 0x1301 // @142D stack[2] = stack[-5] // @142E stack[3] = stack[-6] // } // Block ends with call to 0x117a, returns to 0x1301 label_1433: // Incoming return from call to 0x1424 at 0x1423 // Inputs[3] // { // @1434 stack[-1] // @1434 stack[-3] // @1435 stack[-2] // } 1433 5B JUMPDEST 1434 91 SWAP2 1435 01 ADD 1436 90 SWAP1 1437 61 PUSH2 0x140b 143A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1436 stack[-2] = stack[-1] // @1436 stack[-3] = stack[-3] + stack[-2] // } // Block ends with unconditional jump to 0x140b label_143B: // Incoming jump from 0x1414, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1414, if !(stack[-2] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @143F stack[-2] // @1444 stack[-1] // @1447 storage[0x04] // } 143B 5B JUMPDEST 143C 61 PUSH2 0x144c 143F 91 SWAP2 1440 50 POP 1441 61 PUSH2 0x1341 1444 90 SWAP1 1445 60 PUSH1 0x04 1447 54 SLOAD 1448 61 PUSH2 0x1864 144B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @143F stack[-2] = 0x144c // @1444 stack[0] = stack[-1] // @1444 stack[-1] = 0x1341 // @1447 stack[1] = storage[0x04] // } // Block ends with call to 0x1864, returns to 0x1341 label_144C: // Incoming return from call to 0x1341 at 0x144B 144C 5B JUMPDEST 144D 61 PUSH2 0x13bd 1450 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13bd label_1451: // Incoming jump from 0x0EF6 // Incoming call from 0x05EA, returns to 0x05EB // Inputs[5] // { // @1452 stack[-1] // @1452 stack[-3] // @1453 stack[-5] // @1454 stack[-4] // @1455 stack[-2] // } 1451 5B JUMPDEST 1452 91 SWAP2 1453 93 SWAP4 1454 92 SWAP3 1455 90 SWAP1 1456 61 PUSH2 0x1461 1459 82 DUP3 145A 86 DUP7 145B 83 DUP4 145C 86 DUP7 145D 61 PUSH2 0x1b2e 1460 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @1452 stack[-3] = stack[-1] // @1453 stack[-5] = stack[-3] // @1454 stack[-4] = stack[-5] // @1455 stack[-2] = stack[-4] // @1455 stack[-1] = stack[-2] // @1456 stack[0] = 0x1461 // @1459 stack[1] = stack[-4] // @145A stack[2] = stack[-3] // @145B stack[3] = stack[-2] // @145C stack[4] = stack[-1] // } // Block ends with call to 0x1b2e, returns to 0x1461 label_1461: // Incoming return from call to 0x1B2E at 0x1460 // Inputs[1] { @146A stack[-3] } 1461 5B JUMPDEST 1462 60 PUSH1 0x01 1464 60 PUSH1 0x01 1466 60 PUSH1 0xa0 1468 1B SHL 1469 03 SUB 146A 83 DUP4 146B 81 DUP2 146C 16 AND 146D 15 ISZERO 146E 61 PUSH2 0x1514 1471 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1469 stack[0] = (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x1514, if !((0x01 << 0xa0) - 0x01 & stack[-3]) label_1472: // Incoming jump from 0x156B // Incoming jump from 0x1471, if not !((0x01 << 0xa0) - 0x01 & stack[-3]) // Inputs[2] // { // @1473 stack[-2] // @1474 stack[-1] // } 1472 5B JUMPDEST 1473 81 DUP2 1474 16 AND 1475 15 ISZERO 1476 80 DUP1 1477 61 PUSH2 0x14bf 147A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1475 stack[-1] = !(stack[-2] & stack[-1]) } // Block ends with conditional jump to 0x14bf, if !(stack[-2] & stack[-1]) label_147B: // Incoming jump from 0x1513 // Incoming jump from 0x147A, if not !(stack[-2] & stack[-1]) // Inputs[1] { @147C stack[-1] } 147B 5B JUMPDEST 147C 15 ISZERO 147D 61 PUSH2 0x1488 1480 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1488, if !stack[-1] label_1481: // Incoming jump from 0x14AD // Incoming jump from 0x1480, if not !stack[-1] // Inputs[1] { @1487 stack[-6] } 1481 5B JUMPDEST 1482 50 POP 1483 50 POP 1484 50 POP 1485 50 POP 1486 50 POP 1487 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1488: // Incoming jump from 0x1480, if !stack[-1] // Inputs[2] // { // @1489 stack[-5] // @148A memory[stack[-5]:stack[-5] + 0x20] // } 1488 5B JUMPDEST 1489 84 DUP5 148A 51 MLOAD 148B 60 PUSH1 0x01 148D 03 SUB 148E 61 PUSH2 0x14ae 1491 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ae, if 0x01 - memory[stack[-5]:stack[-5] + 0x20] label_1492: // Incoming jump from 0x1491, if not 0x01 - memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @1498 stack[-5] // @149A memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @149B stack[-2] // @149D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @149E stack[-3] // @149F msg.sender // } 1492 60 PUSH1 0x20 1494 80 DUP1 1495 61 PUSH2 0x14a4 1498 96 SWAP7 1499 01 ADD 149A 51 MLOAD 149B 92 SWAP3 149C 01 ADD 149D 51 MLOAD 149E 92 SWAP3 149F 33 CALLER 14A0 61 PUSH2 0x182d 14A3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1498 stack[-5] = 0x14a4 // @149B stack[-2] = memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @149E stack[0] = stack[-3] // @149E stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @149F stack[1] = msg.sender // } // Block ends with call to 0x182d, returns to 0x14A4 label_14A4: // Incoming jump from 0x14BE // Incoming return from call to 0x182D at 0x14A3 // Inputs[1] { @14A5 code.length } 14A4 5B JUMPDEST 14A5 38 CODESIZE 14A6 80 DUP1 14A7 80 DUP1 14A8 80 DUP1 14A9 80 DUP1 14AA 61 PUSH2 0x1481 14AD 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @14A5 stack[0] = code.length // @14A6 stack[1] = code.length // @14A7 stack[2] = code.length // @14A8 stack[3] = code.length // @14A9 stack[4] = code.length // } // Block ends with unconditional jump to 0x1481 label_14AE: // Incoming jump from 0x1491, if 0x01 - memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @14B2 stack[-5] // @14B3 stack[-2] // @14B4 stack[-3] // @14B5 msg.sender // } 14AE 5B JUMPDEST 14AF 61 PUSH2 0x14ba 14B2 94 SWAP5 14B3 91 SWAP2 14B4 92 SWAP3 14B5 33 CALLER 14B6 61 PUSH2 0x16f9 14B9 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @14B2 stack[-5] = 0x14ba // @14B3 stack[-2] = stack[-5] // @14B4 stack[0] = stack[-3] // @14B4 stack[-3] = stack[-2] // @14B5 stack[1] = msg.sender // } // Block ends with call to 0x16f9, returns to 0x14BA label_14BA: // Incoming return from call to 0x16F9 at 0x14B9 14BA 5B JUMPDEST 14BB 61 PUSH2 0x14a4 14BE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14a4 label_14BF: // Incoming jump from 0x147A, if !(stack[-2] & stack[-1]) // Inputs[6] // { // @14C0 stack[-1] // @14C0 stack[-6] // @14C1 stack[-5] // @14C4 stack[-4] // @14C6 stack[-2] // @14CA memory[stack[-6]:stack[-6] + 0x20] // } 14BF 5B JUMPDEST 14C0 94 SWAP5 14C1 93 SWAP4 14C2 60 PUSH1 0x00 14C4 93 SWAP4 14C5 90 SWAP1 14C6 91 SWAP2 14C7 84 DUP5 14C8 5B JUMPDEST 14C9 86 DUP7 14CA 51 MLOAD 14CB 86 DUP7 14CC 10 LT 14CD 15 ISZERO 14CE 61 PUSH2 0x14fc 14D1 57 *JUMPI // Stack delta = +2 // Outputs[7] // { // @14C0 stack[-6] = stack[-1] // @14C1 stack[-5] = stack[-6] // @14C4 stack[-4] = 0x00 // @14C5 stack[-1] = stack[-4] // @14C6 stack[-2] = stack[-5] // @14C6 stack[0] = stack[-2] // @14C7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x14fc, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_14D2: // Incoming jump from 0x14D1, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x14D1, if not !(stack[-6] < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[3] // { // @14D4 stack[-1] // @14D8 stack[-6] // @14D9 stack[-5] // } 14D2 60 PUSH1 0x01 14D4 90 SWAP1 14D5 61 PUSH2 0x14de 14D8 87 DUP8 14D9 87 DUP8 14DA 61 PUSH2 0x117a 14DD 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @14D4 stack[0] = stack[-1] // @14D4 stack[-1] = 0x01 // @14D5 stack[1] = 0x14de // @14D8 stack[2] = stack[-6] // @14D9 stack[3] = stack[-5] // } // Block ends with call to 0x117a, returns to 0x14DE label_14DE: // Incoming return from call to 0x117A at 0x14DD // Inputs[5] // { // @14DF memory[stack[-1]:stack[-1] + 0x20] // @14DF stack[-1] // @14E0 stack[-2] // @14E7 stack[-8] // @14E8 stack[-9] // } 14DE 5B JUMPDEST 14DF 51 MLOAD 14E0 90 SWAP1 14E1 61 PUSH2 0x14ed 14E4 61 PUSH2 0x1301 14E7 89 DUP10 14E8 8B DUP12 14E9 61 PUSH2 0x117a 14EC 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @14E0 stack[-1] = stack[-2] // @14E0 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @14E1 stack[0] = 0x14ed // @14E4 stack[1] = 0x1301 // @14E7 stack[2] = stack[-8] // @14E8 stack[3] = stack[-9] // } // Block ends with call to 0x117a, returns to 0x1301 label_14ED: // Incoming return from call to 0x1301 at 0x14EC // Inputs[6] // { // @14EE stack[-3] // @14EF stack[-1] // @14F0 storage[stack[-1]] // @14F4 stack[-2] // @14F5 stack[-9] // @14F6 stack[-4] // } 14ED 5B JUMPDEST 14EE 82 DUP3 14EF 81 DUP2 14F0 54 SLOAD 14F1 03 SUB 14F2 90 SWAP1 14F3 55 SSTORE 14F4 01 ADD 14F5 95 SWAP6 14F6 01 ADD 14F7 94 SWAP5 14F8 61 PUSH2 0x14c8 14FB 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @14F3 storage[stack[-1]] = storage[stack[-1]] - stack[-3] // @14F7 stack[-4] = stack[-2] + stack[-3] // @14F7 stack[-9] = stack[-9] + stack[-4] // } // Block ends with unconditional jump to 0x14c8 label_14FC: // Incoming jump from 0x14D1, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x14D1, if !(stack[-6] < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[8] // { // @1500 stack[-2] // @1501 stack[-4] // @1502 stack[-7] // @1503 stack[-8] // @1504 stack[-3] // @1505 stack[-6] // @1509 storage[0x04] // @150A stack[-1] // } 14FC 5B JUMPDEST 14FD 61 PUSH2 0x150f 1500 91 SWAP2 1501 93 SWAP4 1502 96 SWAP7 1503 97 SWAP8 1504 92 SWAP3 1505 95 SWAP6 1506 50 POP 1507 60 PUSH1 0x04 1509 54 SLOAD 150A 03 SUB 150B 60 PUSH1 0x04 150D 55 SSTORE 150E 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @1501 stack[-4] = stack[-2] // @1502 stack[-7] = stack[-4] // @1503 stack[-8] = stack[-7] // @1504 stack[-3] = stack[-8] // @1505 stack[-6] = stack[-3] // @150D storage[0x04] = storage[0x04] - stack[-1] // } // Block ends with unconditional jump to 0x150f label_150F: // Incoming jump from 0x150E 150F 5B JUMPDEST 1510 61 PUSH2 0x147b 1513 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x147b label_1514: // Incoming jump from 0x1471, if !((0x01 << 0xa0) - 0x01 & stack[-3]) // Inputs[8] // { // @1515 stack[-1] // @1515 stack[-7] // @1516 stack[-3] // @1517 stack[-4] // @151A stack[-5] // @151B stack[-2] // @1520 stack[-6] // @1521 memory[stack[-6]:stack[-6] + 0x20] // } 1514 5B JUMPDEST 1515 95 SWAP6 1516 91 SWAP2 1517 92 SWAP3 1518 60 PUSH1 0x00 151A 94 SWAP5 151B 91 SWAP2 151C 60 PUSH1 0x00 151E 95 SWAP6 151F 5B JUMPDEST 1520 87 DUP8 1521 51 MLOAD 1522 87 DUP8 1523 10 LT 1524 15 ISZERO 1525 61 PUSH2 0x154f 1528 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @1515 stack[-7] = stack[-1] // @1516 stack[-3] = stack[-7] // @1517 stack[-4] = stack[-3] // @1517 stack[-1] = stack[-4] // @151B stack[0] = stack[-2] // @151B stack[-2] = stack[-5] // @151E stack[1] = 0x00 // @151E stack[-5] = 0x00 // } // Block ends with conditional jump to 0x154f, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_1529: // Incoming jump from 0x1528, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1528, if not !(stack[-7] < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[3] // { // @152E stack[-1] // @1532 stack[-7] // @1533 stack[-6] // } 1529 61 PUSH2 0x1547 152C 60 PUSH1 0x01 152E 91 SWAP2 152F 61 PUSH2 0x1538 1532 89 DUP10 1533 89 DUP10 1534 61 PUSH2 0x117a 1537 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1529 stack[0] = 0x1547 // @152E stack[1] = stack[-1] // @152E stack[-1] = 0x01 // @152F stack[2] = 0x1538 // @1532 stack[3] = stack[-7] // @1533 stack[4] = stack[-6] // } // Block ends with call to 0x117a, returns to 0x1538 label_1538: // Incoming return from call to 0x117A at 0x1537 // Inputs[5] // { // @1539 memory[stack[-1]:stack[-1] + 0x20] // @1539 stack[-1] // @153A stack[-2] // @1541 stack[-10] // @1542 stack[-11] // } 1538 5B JUMPDEST 1539 51 MLOAD 153A 90 SWAP1 153B 61 PUSH2 0x1312 153E 61 PUSH2 0x1301 1541 8B DUP12 1542 8D DUP14 1543 61 PUSH2 0x117a 1546 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @153A stack[-1] = stack[-2] // @153A stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @153B stack[0] = 0x1312 // @153E stack[1] = 0x1301 // @1541 stack[2] = stack[-10] // @1542 stack[3] = stack[-11] // } // Block ends with call to 0x117a, returns to 0x1301 label_1547: // Incoming return from call to 0x1538 at 0x1537 // Inputs[3] // { // @1548 stack[-8] // @1548 stack[-1] // @1549 stack[-2] // } 1547 5B JUMPDEST 1548 96 SWAP7 1549 01 ADD 154A 95 SWAP6 154B 61 PUSH2 0x151f 154E 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @154A stack[-8] = stack[-8] + stack[-2] // @154A stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x151f label_154F: // Incoming jump from 0x1528, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1528, if !(stack[-7] < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[9] // { // @1553 stack[-2] // @1554 stack[-4] // @1555 stack[-7] // @155A stack[-1] // @155B stack[-9] // @155C stack[-3] // @155D stack[-6] // @155E stack[-5] // @1562 storage[0x04] // } 154F 5B JUMPDEST 1550 61 PUSH2 0x1567 1553 91 SWAP2 1554 93 SWAP4 1555 96 SWAP7 1556 50 POP 1557 61 PUSH2 0x1341 155A 90 SWAP1 155B 98 SWAP9 155C 92 SWAP3 155D 95 SWAP6 155E 94 SWAP5 155F 98 SWAP9 1560 60 PUSH1 0x04 1562 54 SLOAD 1563 61 PUSH2 0x1864 1566 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @1553 stack[-2] = 0x1567 // @1554 stack[-4] = stack[-2] // @1555 stack[-7] = stack[-4] // @155A stack[-1] = 0x1341 // @155C stack[-3] = stack[-9] // @155D stack[-6] = stack[-3] // @155E stack[-5] = stack[-6] // @155F stack[0] = stack[-1] // @155F stack[-9] = stack[-5] // @1562 stack[1] = storage[0x04] // } // Block ends with call to 0x1864, returns to 0x1341 label_1567: // Incoming return from call to 0x1341 at 0x1566 1567 5B JUMPDEST 1568 61 PUSH2 0x1472 156B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1472 156C 5B JUMPDEST 156D 90 SWAP1 156E 81 DUP2 156F 60 PUSH1 0x20 1571 91 SWAP2 1572 03 SUB 1573 12 SLT 1574 61 PUSH2 0x01cc 1577 57 *JUMPI 1578 51 MLOAD 1579 61 PUSH2 0x02fb 157C 81 DUP2 157D 61 PUSH2 0x0222 1580 56 *JUMP 1581 5B JUMPDEST 1582 92 SWAP3 1583 61 PUSH2 0x15b0 1586 61 PUSH2 0x02fb 1589 95 SWAP6 158A 93 SWAP4 158B 61 PUSH2 0x15be 158E 93 SWAP4 158F 60 PUSH1 0x01 1591 80 DUP1 1592 60 PUSH1 0xa0 1594 1B SHL 1595 03 SUB 1596 16 AND 1597 86 DUP7 1598 52 MSTORE 1599 60 PUSH1 0x00 159B 60 PUSH1 0x20 159D 87 DUP8 159E 01 ADD 159F 52 MSTORE 15A0 60 PUSH1 0xa0 15A2 60 PUSH1 0x40 15A4 87 DUP8 15A5 01 ADD 15A6 52 MSTORE 15A7 60 PUSH1 0xa0 15A9 86 DUP7 15AA 01 ADD 15AB 90 SWAP1 15AC 61 PUSH2 0x07c6 15AF 56 *JUMP label_15B0: // Incoming return from call to 0x07C6 at 0x15FD // Inputs[3] // { // @15B1 stack[-1] // @15B1 stack[-2] // @15B2 stack[-5] // } 15B0 5B JUMPDEST 15B1 90 SWAP1 15B2 84 DUP5 15B3 82 DUP3 15B4 03 SUB 15B5 60 PUSH1 0x60 15B7 86 DUP7 15B8 01 ADD 15B9 52 MSTORE 15BA 61 PUSH2 0x07c6 15BD 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @15B1 stack[-2] = stack[-1] // @15B1 stack[-1] = stack[-2] // @15B9 memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] = stack[-1] - stack[-5] // } // Block ends with unconditional jump to 0x07c6 label_15BE: // Incoming return from call to 0x15B0 at 0x15FD // Inputs[2] // { // @15BF stack[-1] // @15BF stack[-3] // } 15BE 5B JUMPDEST 15BF 91 SWAP2 15C0 60 PUSH1 0x80 15C2 81 DUP2 15C3 84 DUP5 15C4 03 SUB 15C5 91 SWAP2 15C6 01 ADD 15C7 52 MSTORE 15C8 61 PUSH2 0x02c5 15CB 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @15BF stack[-3] = stack[-1] // @15C7 memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] = stack[-1] - stack[-3] // } // Block ends with unconditional jump to 0x02c5 label_15CC: // Incoming jump from 0x1730 // Inputs[6] // { // @15CD stack[-1] // @15CD stack[-5] // @15CE stack[-2] // @15D2 stack[-6] // @15D3 stack[-4] // @15DB stack[-3] // } 15CC 5B JUMPDEST 15CD 93 SWAP4 15CE 90 SWAP1 15CF 61 PUSH2 0x02fb 15D2 95 SWAP6 15D3 93 SWAP4 15D4 61 PUSH2 0x15b0 15D7 91 SWAP2 15D8 61 PUSH2 0x15be 15DB 94 SWAP5 15DC 60 PUSH1 0x01 15DE 80 DUP1 15DF 60 PUSH1 0xa0 15E1 1B SHL 15E2 03 SUB 15E3 80 DUP1 15E4 92 SWAP3 15E5 16 AND 15E6 88 DUP9 15E7 52 MSTORE 15E8 16 AND 15E9 60 PUSH1 0x20 15EB 87 DUP8 15EC 01 ADD 15ED 52 MSTORE 15EE 60 PUSH1 0xa0 15F0 60 PUSH1 0x40 15F2 87 DUP8 15F3 01 ADD 15F4 52 MSTORE 15F5 60 PUSH1 0xa0 15F7 86 DUP7 15F8 01 ADD 15F9 90 SWAP1 15FA 61 PUSH2 0x07c6 15FD 56 *JUMP // Stack delta = +2 // Outputs[11] // { // @15CD stack[-5] = stack[-1] // @15CE stack[-2] = stack[-5] // @15D2 stack[-6] = 0x02fb // @15D3 stack[-4] = stack[-6] // @15D7 stack[-1] = 0x15b0 // @15DB stack[-3] = 0x15be // @15E7 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @15ED memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @15F4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xa0 // @15F9 stack[1] = stack[-4] // @15F9 stack[0] = stack[-1] + 0xa0 // } // Block ends with call to 0x07c6, returns to 0x15B0 15FE 5B JUMPDEST 15FF 92 SWAP3 1600 93 SWAP4 1601 91 SWAP2 1602 90 SWAP1 1603 93 SWAP4 1604 84 DUP5 1605 3B EXTCODESIZE 1606 61 PUSH2 0x1610 1609 57 *JUMPI 160A 50 POP 160B 50 POP 160C 50 POP 160D 50 POP 160E 50 POP 160F 56 *JUMP 1610 5B JUMPDEST 1611 60 PUSH1 0x20 1613 91 SWAP2 1614 61 PUSH2 0x1633 1617 60 PUSH1 0x40 1619 51 MLOAD 161A 94 SWAP5 161B 85 DUP6 161C 93 SWAP4 161D 84 DUP5 161E 93 SWAP4 161F 63 PUSH4 0xbc197c81 1624 60 PUSH1 0xe0 1626 1B SHL 1627 98 SWAP9 1628 89 DUP10 1629 86 DUP7 162A 52 MSTORE 162B 60 PUSH1 0x04 162D 86 DUP7 162E 01 ADD 162F 61 PUSH2 0x1581 1632 56 *JUMP 1633 5B JUMPDEST 1634 03 SUB 1635 81 DUP2 1636 60 PUSH1 0x00 1638 60 PUSH1 0x01 163A 60 PUSH1 0x01 163C 60 PUSH1 0xa0 163E 1B SHL 163F 03 SUB 1640 88 DUP9 1641 16 AND 1642 5A GAS 1643 F1 CALL 1644 60 PUSH1 0x00 1646 91 SWAP2 1647 81 DUP2 1648 61 PUSH2 0x16c8 164B 57 *JUMPI 164C 5B JUMPDEST 164D 50 POP 164E 61 PUSH2 0x168b 1651 57 *JUMPI 1652 82 DUP3 1653 61 PUSH2 0x165a 1656 61 PUSH2 0x1370 1659 56 *JUMP 165A 5B JUMPDEST 165B 80 DUP1 165C 51 MLOAD 165D 91 SWAP2 165E 90 SWAP1 165F 82 DUP3 1660 61 PUSH2 0x1684 1663 57 *JUMPI 1664 60 PUSH1 0x40 1666 51 MLOAD 1667 63 PUSH4 0x2bfa23e7 166C 60 PUSH1 0xe1 166E 1B SHL 166F 81 DUP2 1670 52 MSTORE 1671 60 PUSH1 0x01 1673 60 PUSH1 0x01 1675 60 PUSH1 0xa0 1677 1B SHL 1678 03 SUB 1679 83 DUP4 167A 16 AND 167B 60 PUSH1 0x04 167D 82 DUP3 167E 01 ADD 167F 52 MSTORE 1680 60 PUSH1 0x24 1682 90 SWAP1 1683 FD *REVERT 1684 5B JUMPDEST 1685 90 SWAP1 1686 50 POP 1687 60 PUSH1 0x20 1689 01 ADD 168A FD *REVERT 168B 5B JUMPDEST 168C 60 PUSH1 0x01 168E 60 PUSH1 0x01 1690 60 PUSH1 0xe0 1692 1B SHL 1693 03 SUB 1694 19 NOT 1695 16 AND 1696 03 SUB 1697 61 PUSH2 0x16a5 169A 57 *JUMPI 169B 50 POP 169C 38 CODESIZE 169D 80 DUP1 169E 80 DUP1 169F 80 DUP1 16A0 80 DUP1 16A1 61 PUSH2 0x1481 16A4 56 *JUMP 16A5 5B JUMPDEST 16A6 60 PUSH1 0x40 16A8 51 MLOAD 16A9 63 PUSH4 0x2bfa23e7 16AE 60 PUSH1 0xe1 16B0 1B SHL 16B1 81 DUP2 16B2 52 MSTORE 16B3 60 PUSH1 0x01 16B5 60 PUSH1 0x01 16B7 60 PUSH1 0xa0 16B9 1B SHL 16BA 03 SUB 16BB 91 SWAP2 16BC 90 SWAP1 16BD 91 SWAP2 16BE 16 AND 16BF 60 PUSH1 0x04 16C1 82 DUP3 16C2 01 ADD 16C3 52 MSTORE 16C4 60 PUSH1 0x24 16C6 90 SWAP1 16C7 FD *REVERT 16C8 5B JUMPDEST 16C9 61 PUSH2 0x16eb 16CC 91 SWAP2 16CD 92 SWAP3 16CE 50 POP 16CF 60 PUSH1 0x20 16D1 3D RETURNDATASIZE 16D2 60 PUSH1 0x20 16D4 11 GT 16D5 61 PUSH2 0x16f2 16D8 57 *JUMPI 16D9 5B JUMPDEST 16DA 61 PUSH2 0x16e3 16DD 81 DUP2 16DE 83 DUP4 16DF 61 PUSH2 0x0442 16E2 56 *JUMP 16E3 5B JUMPDEST 16E4 81 DUP2 16E5 01 ADD 16E6 90 SWAP1 16E7 61 PUSH2 0x156c 16EA 56 *JUMP 16EB 5B JUMPDEST 16EC 90 SWAP1 16ED 38 CODESIZE 16EE 61 PUSH2 0x164c 16F1 56 *JUMP 16F2 5B JUMPDEST 16F3 50 POP 16F4 3D RETURNDATASIZE 16F5 61 PUSH2 0x16d9 16F8 56 *JUMP label_16F9: // Incoming call from 0x14B9, returns to 0x14BA // Inputs[7] // { // @16FA stack[-1] // @16FA stack[-5] // @16FB stack[-4] // @16FC stack[-2] // @16FD stack[-6] // @16FE stack[-3] // @1701 address(stack[-3]).code.length // } 16F9 5B JUMPDEST 16FA 93 SWAP4 16FB 92 SWAP3 16FC 90 SWAP1 16FD 94 SWAP5 16FE 91 SWAP2 16FF 94 SWAP5 1700 85 DUP6 1701 3B EXTCODESIZE 1702 61 PUSH2 0x170e 1705 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @16FA stack[-5] = stack[-1] // @16FB stack[-4] = stack[-5] // @16FC stack[-2] = stack[-4] // @16FE stack[-3] = stack[-6] // @16FF stack[-1] = stack[-2] // @16FF stack[-6] = stack[-3] // } // Block ends with conditional jump to 0x170e, if address(stack[-3]).code.length label_1706: // Incoming jump from 0x1705, if not address(stack[-3]).code.length // Inputs[1] { @170D stack[-7] } 1706 5B JUMPDEST 1707 50 POP 1708 50 POP 1709 50 POP 170A 50 POP 170B 50 POP 170C 50 POP 170D 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_170E: // Incoming jump from 0x1705, if address(stack[-3]).code.length // Inputs[6] // { // @1714 stack[-3] // @1717 memory[0x40:0x60] // @1718 stack[-4] // @171A stack[-2] // @171C stack[-1] // @1725 stack[-5] // } 170E 5B JUMPDEST 170F 61 PUSH2 0x1731 1712 60 PUSH1 0x20 1714 93 SWAP4 1715 60 PUSH1 0x40 1717 51 MLOAD 1718 95 SWAP6 1719 86 DUP7 171A 94 SWAP5 171B 85 DUP6 171C 94 SWAP5 171D 63 PUSH4 0xbc197c81 1722 60 PUSH1 0xe0 1724 1B SHL 1725 99 SWAP10 1726 8A DUP11 1727 87 DUP8 1728 52 MSTORE 1729 60 PUSH1 0x04 172B 87 DUP8 172C 01 ADD 172D 61 PUSH2 0x15cc 1730 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @170F stack[0] = 0x1731 // @1714 stack[1] = stack[-3] // @1714 stack[-3] = 0x20 // @1718 stack[-4] = memory[0x40:0x60] // @1718 stack[2] = stack[-4] // @171A stack[-2] = memory[0x40:0x60] // @171A stack[3] = stack[-2] // @171C stack[-1] = memory[0x40:0x60] // @171C stack[4] = stack[-1] // @1725 stack[-5] = 0xbc197c81 << 0xe0 // @1725 stack[5] = stack[-5] // @1728 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c81 << 0xe0 // @172C stack[6] = memory[0x40:0x60] + 0x04 // } // Block ends with unconditional jump to 0x15cc 1731 5B JUMPDEST 1732 03 SUB 1733 81 DUP2 1734 60 PUSH1 0x00 1736 60 PUSH1 0x01 1738 60 PUSH1 0x01 173A 60 PUSH1 0xa0 173C 1B SHL 173D 03 SUB 173E 88 DUP9 173F 16 AND 1740 5A GAS 1741 F1 CALL 1742 60 PUSH1 0x00 1744 91 SWAP2 1745 81 DUP2 1746 61 PUSH2 0x1773 1749 57 *JUMPI 174A 5B JUMPDEST 174B 50 POP 174C 61 PUSH2 0x1758 174F 57 *JUMPI 1750 82 DUP3 1751 61 PUSH2 0x165a 1754 61 PUSH2 0x1370 1757 56 *JUMP 1758 5B JUMPDEST 1759 60 PUSH1 0x01 175B 60 PUSH1 0x01 175D 60 PUSH1 0xe0 175F 1B SHL 1760 03 SUB 1761 19 NOT 1762 16 AND 1763 03 SUB 1764 61 PUSH2 0x16a5 1767 57 *JUMPI 1768 50 POP 1769 38 CODESIZE 176A 80 DUP1 176B 80 DUP1 176C 80 DUP1 176D 80 DUP1 176E 80 DUP1 176F 61 PUSH2 0x1706 1772 56 *JUMP 1773 5B JUMPDEST 1774 61 PUSH2 0x178d 1777 91 SWAP2 1778 92 SWAP3 1779 50 POP 177A 60 PUSH1 0x20 177C 3D RETURNDATASIZE 177D 60 PUSH1 0x20 177F 11 GT 1780 61 PUSH2 0x16f2 1783 57 *JUMPI 1784 61 PUSH2 0x16e3 1787 81 DUP2 1788 83 DUP4 1789 61 PUSH2 0x0442 178C 56 *JUMP 178D 5B JUMPDEST 178E 90 SWAP1 178F 38 CODESIZE 1790 61 PUSH2 0x174a 1793 56 *JUMP 1794 5B JUMPDEST 1795 90 SWAP1 1796 92 SWAP3 1797 60 PUSH1 0xa0 1799 92 SWAP3 179A 61 PUSH2 0x02fb 179D 95 SWAP6 179E 94 SWAP5 179F 60 PUSH1 0x01 17A1 80 DUP1 17A2 86 DUP7 17A3 1B SHL 17A4 03 SUB 17A5 16 AND 17A6 83 DUP4 17A7 52 MSTORE 17A8 60 PUSH1 0x00 17AA 60 PUSH1 0x20 17AC 84 DUP5 17AD 01 ADD 17AE 52 MSTORE 17AF 60 PUSH1 0x40 17B1 83 DUP4 17B2 01 ADD 17B3 52 MSTORE 17B4 60 PUSH1 0x60 17B6 82 DUP3 17B7 01 ADD 17B8 52 MSTORE 17B9 81 DUP2 17BA 60 PUSH1 0x80 17BC 82 DUP3 17BD 01 ADD 17BE 52 MSTORE 17BF 01 ADD 17C0 90 SWAP1 17C1 61 PUSH2 0x02c5 17C4 56 *JUMP label_17C5: // Incoming jump from 0x1863 // Inputs[6] // { // @17C6 stack[-1] // @17C6 stack[-3] // @17C7 stack[-4] // @17CB stack[-6] // @17CC stack[-5] // @17CD stack[-2] // } 17C5 5B JUMPDEST 17C6 91 SWAP2 17C7 92 SWAP3 17C8 61 PUSH2 0x02fb 17CB 95 SWAP6 17CC 94 SWAP5 17CD 91 SWAP2 17CE 60 PUSH1 0xa0 17D0 94 SWAP5 17D1 60 PUSH1 0x01 17D3 80 DUP1 17D4 87 DUP8 17D5 1B SHL 17D6 03 SUB 17D7 80 DUP1 17D8 92 SWAP3 17D9 16 AND 17DA 85 DUP6 17DB 52 MSTORE 17DC 16 AND 17DD 60 PUSH1 0x20 17DF 84 DUP5 17E0 01 ADD 17E1 52 MSTORE 17E2 60 PUSH1 0x40 17E4 83 DUP4 17E5 01 ADD 17E6 52 MSTORE 17E7 60 PUSH1 0x60 17E9 82 DUP3 17EA 01 ADD 17EB 52 MSTORE 17EC 81 DUP2 17ED 60 PUSH1 0x80 17EF 82 DUP3 17F0 01 ADD 17F1 52 MSTORE 17F2 01 ADD 17F3 90 SWAP1 17F4 61 PUSH2 0x02c5 17F7 56 *JUMP // Stack delta = -3 // Outputs[8] // { // @17CB stack[-6] = 0x02fb // @17DB memory[stack[-1]:stack[-1] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @17E1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @17E6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @17EB memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-5] // @17F1 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @17F3 stack[-4] = stack[-6] // @17F3 stack[-5] = stack[-1] + 0xa0 // } // Block ends with call to 0x02c5, returns to 0x02FB 17F8 5B JUMPDEST 17F9 92 SWAP3 17FA 93 SWAP4 17FB 91 SWAP2 17FC 90 SWAP1 17FD 93 SWAP4 17FE 84 DUP5 17FF 3B EXTCODESIZE 1800 61 PUSH2 0x180a 1803 57 *JUMPI 1804 50 POP 1805 50 POP 1806 50 POP 1807 50 POP 1808 50 POP 1809 56 *JUMP 180A 5B JUMPDEST 180B 60 PUSH1 0x20 180D 91 SWAP2 180E 61 PUSH2 0x1633 1811 60 PUSH1 0x40 1813 51 MLOAD 1814 94 SWAP5 1815 85 DUP6 1816 93 SWAP4 1817 84 DUP5 1818 93 SWAP4 1819 63 PUSH4 0xf23a6e61 181E 60 PUSH1 0xe0 1820 1B SHL 1821 98 SWAP9 1822 89 DUP10 1823 86 DUP7 1824 52 MSTORE 1825 60 PUSH1 0x04 1827 86 DUP7 1828 01 ADD 1829 61 PUSH2 0x1794 182C 56 *JUMP label_182D: // Incoming call from 0x14A3, returns to 0x14A4 // Inputs[7] // { // @182E stack[-1] // @182E stack[-5] // @182F stack[-4] // @1830 stack[-2] // @1831 stack[-6] // @1832 stack[-3] // @1835 address(stack[-3]).code.length // } 182D 5B JUMPDEST 182E 93 SWAP4 182F 92 SWAP3 1830 90 SWAP1 1831 94 SWAP5 1832 91 SWAP2 1833 94 SWAP5 1834 85 DUP6 1835 3B EXTCODESIZE 1836 61 PUSH2 0x1841 1839 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @182E stack[-5] = stack[-1] // @182F stack[-4] = stack[-5] // @1830 stack[-2] = stack[-4] // @1832 stack[-3] = stack[-6] // @1833 stack[-1] = stack[-2] // @1833 stack[-6] = stack[-3] // } // Block ends with conditional jump to 0x1841, if address(stack[-3]).code.length label_183A: // Incoming jump from 0x1839, if not address(stack[-3]).code.length // Inputs[1] { @1840 stack[-7] } 183A 50 POP 183B 50 POP 183C 50 POP 183D 50 POP 183E 50 POP 183F 50 POP 1840 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1841: // Incoming jump from 0x1839, if address(stack[-3]).code.length // Inputs[6] // { // @1847 stack[-3] // @184A memory[0x40:0x60] // @184B stack[-4] // @184D stack[-2] // @184F stack[-1] // @1858 stack[-5] // } 1841 5B JUMPDEST 1842 61 PUSH2 0x1731 1845 60 PUSH1 0x20 1847 93 SWAP4 1848 60 PUSH1 0x40 184A 51 MLOAD 184B 95 SWAP6 184C 86 DUP7 184D 94 SWAP5 184E 85 DUP6 184F 94 SWAP5 1850 63 PUSH4 0xf23a6e61 1855 60 PUSH1 0xe0 1857 1B SHL 1858 99 SWAP10 1859 8A DUP11 185A 87 DUP8 185B 52 MSTORE 185C 60 PUSH1 0x04 185E 87 DUP8 185F 01 ADD 1860 61 PUSH2 0x17c5 1863 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @1842 stack[0] = 0x1731 // @1847 stack[1] = stack[-3] // @1847 stack[-3] = 0x20 // @184B stack[-4] = memory[0x40:0x60] // @184B stack[2] = stack[-4] // @184D stack[-2] = memory[0x40:0x60] // @184D stack[3] = stack[-2] // @184F stack[-1] = memory[0x40:0x60] // @184F stack[4] = stack[-1] // @1858 stack[-5] = 0xf23a6e61 << 0xe0 // @1858 stack[5] = stack[-5] // @185B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e61 << 0xe0 // @185F stack[6] = memory[0x40:0x60] + 0x04 // } // Block ends with unconditional jump to 0x17c5 label_1864: // Incoming jump from 0x191D // Incoming call from 0x131C, returns to 0x131D // Incoming call from 0x1566, returns to 0x1341 // Incoming call from 0x144B, returns to 0x1341 // Incoming jump from 0x1323 // Inputs[3] // { // @1865 stack[-3] // @1865 stack[-1] // @1866 stack[-2] // } 1864 5B JUMPDEST 1865 91 SWAP2 1866 90 SWAP1 1867 82 DUP3 1868 01 ADD 1869 80 DUP1 186A 92 SWAP3 186B 11 GT 186C 61 PUSH2 0x1126 186F 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1866 stack[-2] = stack[-3] // @186A stack[-3] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x1126, if stack[-1] > stack[-1] + stack[-2] label_1870: // Incoming jump from 0x186F, if not stack[-1] > stack[-1] + stack[-2] // Inputs[1] { @1870 stack[-1] } 1870 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1871: // Incoming jump from 0x1B2D // Incoming jump from 0x1CD4 // Incoming jump from 0x19C7 // Inputs[3] // { // @1872 stack[-1] // @1872 stack[-2] // @1873 stack[-3] // } 1871 5B JUMPDEST 1872 90 SWAP1 1873 91 SWAP2 1874 61 PUSH2 0x1888 1877 61 PUSH2 0x02fb 187A 93 SWAP4 187B 60 PUSH1 0x40 187D 84 DUP5 187E 52 MSTORE 187F 60 PUSH1 0x40 1881 84 DUP5 1882 01 ADD 1883 90 SWAP1 1884 61 PUSH2 0x07c6 1887 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1872 stack[-2] = stack[-1] // @1873 stack[-1] = stack[-3] // @1874 stack[0] = 0x1888 // @187A stack[-3] = 0x02fb // @187E memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @1883 stack[1] = stack[-1] + 0x40 // @1883 stack[2] = stack[-2] // } // Block ends with call to 0x07c6, returns to 0x1888 label_1888: // Incoming return from call to 0x07C6 at 0x1887 // Inputs[2] // { // @1889 stack[-3] // @1889 stack[-1] // } 1888 5B JUMPDEST 1889 91 SWAP2 188A 60 PUSH1 0x20 188C 81 DUP2 188D 84 DUP5 188E 03 SUB 188F 91 SWAP2 1890 01 ADD 1891 52 MSTORE 1892 61 PUSH2 0x07c6 1895 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1889 stack[-3] = stack[-1] // @1891 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // } // Block ends with unconditional jump to 0x07c6 label_1896: // Incoming jump from 0x12D3 // Inputs[5] // { // @1897 stack[-1] // @1897 stack[-3] // @1898 stack[-2] // @189B memory[stack[-2]:stack[-2] + 0x20] // @189D memory[stack[-3]:stack[-3] + 0x20] // } 1896 5B JUMPDEST 1897 91 SWAP2 1898 90 SWAP1 1899 91 SWAP2 189A 82 DUP3 189B 51 MLOAD 189C 82 DUP3 189D 51 MLOAD 189E 90 SWAP1 189F 81 DUP2 18A0 81 DUP2 18A1 03 SUB 18A2 61 PUSH2 0x1241 18A5 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @1898 stack[-2] = stack[-3] // @1899 stack[-3] = stack[-2] // @1899 stack[-1] = stack[-1] // @189E stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @189E stack[0] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x1241, if memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] label_18A6: // Incoming jump from 0x18A5, if not memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @18AB stack[-5] // @18AC memory[stack[-5]:stack[-5] + 0x20] // } 18A6 50 POP 18A7 50 POP 18A8 60 PUSH1 0x00 18AA 5B JUMPDEST 18AB 83 DUP4 18AC 51 MLOAD 18AD 81 DUP2 18AE 10 LT 18AF 15 ISZERO 18B0 61 PUSH2 0x1928 18B3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @18A8 stack[-2] = 0x00 } // Block ends with conditional jump to 0x1928, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) label_18B4: // Incoming jump from 0x18B3, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x18B3, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[6] // { // @18B6 stack[-1] // @18B9 stack[-4] // @18C1 memory[0x20 + (stack[-1] << 0x05) + stack[-4]:0x20 + (stack[-1] << 0x05) + stack[-4] + 0x20] // @18C3 stack[-3] // @18C6 memory[stack[-3] + (stack[-1] << 0x05) + 0x20:stack[-3] + (stack[-1] << 0x05) + 0x20 + 0x20] // @18CB stack[-2] // } 18B4 60 PUSH1 0x05 18B6 81 DUP2 18B7 90 SWAP1 18B8 1B SHL 18B9 84 DUP5 18BA 81 DUP2 18BB 01 ADD 18BC 60 PUSH1 0x20 18BE 90 SWAP1 18BF 81 DUP2 18C0 01 ADD 18C1 51 MLOAD 18C2 91 SWAP2 18C3 85 DUP6 18C4 01 ADD 18C5 01 ADD 18C6 51 MLOAD 18C7 60 PUSH1 0x01 18C9 92 SWAP3 18CA 91 SWAP2 18CB 84 DUP5 18CC 90 SWAP1 18CD 60 PUSH1 0x01 18CF 60 PUSH1 0x01 18D1 60 PUSH1 0xa0 18D3 1B SHL 18D4 03 SUB 18D5 82 DUP3 18D6 16 AND 18D7 61 PUSH2 0x18e4 18DA 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @18C6 stack[1] = memory[stack[-3] + (stack[-1] << 0x05) + 0x20:stack[-3] + (stack[-1] << 0x05) + 0x20 + 0x20] // @18C9 stack[-1] = 0x01 // @18CA stack[0] = stack[-1] // @18CC stack[3] = memory[0x20 + (stack[-1] << 0x05) + stack[-4]:0x20 + (stack[-1] << 0x05) + stack[-4] + 0x20] // @18CC stack[2] = stack[-2] // } // Block ends with conditional jump to 0x18e4, if stack[-2] & (0x01 << 0xa0) - 0x01 label_18DB: // Incoming jump from 0x1927 // Incoming jump from 0x18DA, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @18DF stack[-5] // @18DF stack[-4] // } 18DB 5B JUMPDEST 18DC 50 POP 18DD 50 POP 18DE 50 POP 18DF 01 ADD 18E0 61 PUSH2 0x18aa 18E3 56 *JUMP // Stack delta = -4 // Outputs[1] { @18DF stack[-5] = stack[-4] + stack[-5] } // Block ends with unconditional jump to 0x18aa label_18E4: // Incoming jump from 0x18DA, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @18E8 stack[-2] // @18EF stack[-1] // @18FC memory[0x00:0x40] // } 18E4 5B JUMPDEST 18E5 61 PUSH2 0x191e 18E8 91 SWAP2 18E9 61 PUSH2 0x18ff 18EC 61 PUSH2 0x1916 18EF 92 SWAP3 18F0 60 PUSH1 0x00 18F2 52 MSTORE 18F3 60 PUSH1 0x00 18F5 60 PUSH1 0x20 18F7 52 MSTORE 18F8 60 PUSH1 0x40 18FA 60 PUSH1 0x00 18FC 20 SHA3 18FD 90 SWAP1 18FE 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @18E8 stack[0] = stack[-2] // @18E8 stack[-2] = 0x191e // @18EF stack[-1] = 0x1916 // @18F2 memory[0x00:0x20] = stack[-1] // @18F7 memory[0x20:0x40] = 0x00 // @18FD stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1916 label_18FF: // Incoming call from 0x1BF0, returns to 0x1BF1 // Incoming call from 0x1A28, returns to 0x1A29 // Incoming call from 0x1B9F, returns to 0x1916 // Incoming call from 0x1A4F, returns to 0x1A50 // Incoming call from 0x1BC6, returns to 0x1BC7 // Incoming call from 0x18FE, returns to 0x1916 // Inputs[4] // { // @1900 stack[-2] // @1900 stack[-1] // @1913 memory[0x00:0x40] // @1914 stack[-3] // } 18FF 5B JUMPDEST 1900 90 SWAP1 1901 60 PUSH1 0x01 1903 80 DUP1 1904 60 PUSH1 0xa0 1906 1B SHL 1907 03 SUB 1908 16 AND 1909 60 PUSH1 0x00 190B 52 MSTORE 190C 60 PUSH1 0x20 190E 52 MSTORE 190F 60 PUSH1 0x40 1911 60 PUSH1 0x00 1913 20 SHA3 1914 90 SWAP1 1915 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @190B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @190E memory[0x20:0x40] = stack[-1] // @1914 stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-3] label_1916: // Incoming return from call to 0x18FF at 0x1B9F // Incoming return from call to 0x18FF at 0x18FE // Inputs[3] // { // @1917 stack[-3] // @1917 stack[-1] // @1919 storage[stack[-1]] // } 1916 5B JUMPDEST 1917 91 SWAP2 1918 82 DUP3 1919 54 SLOAD 191A 61 PUSH2 0x1864 191D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1917 stack[-3] = stack[-1] // @1917 stack[-1] = stack[-3] // @1919 stack[0] = storage[stack[-1]] // } // Block ends with unconditional jump to 0x1864 label_191E: // Incoming return from call to 0x1916 at 0x18FE // Inputs[4] // { // @191F stack[-2] // @191F stack[-1] // @1921 code.length // @1922 stack[-5] // } 191E 5B JUMPDEST 191F 90 SWAP1 1920 55 SSTORE 1921 38 CODESIZE 1922 83 DUP4 1923 81 DUP2 1924 61 PUSH2 0x18db 1927 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1920 storage[stack[-2]] = stack[-1] // @1921 stack[-2] = code.length // @1922 stack[-1] = stack[-5] // @1923 stack[0] = code.length // } // Block ends with unconditional jump to 0x18db label_1928: // Incoming jump from 0x18B3, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x18B3, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @192A stack[-4] // @192A stack[-2] // @192E memory[stack[-4]:stack[-4] + 0x20] // } 1928 5B JUMPDEST 1929 50 POP 192A 91 SWAP2 192B 60 PUSH1 0x01 192D 81 DUP2 192E 51 MLOAD 192F 14 EQ 1930 60 PUSH1 0x00 1932 14 EQ 1933 61 PUSH2 0x1989 1936 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @192A stack[-4] = stack[-2] // @192A stack[-2] = stack[-4] // } // Block ends with conditional jump to 0x1989, if 0x00 == (memory[stack[-4]:stack[-4] + 0x20] == 0x01) label_1937: // Incoming jump from 0x1936, if not 0x00 == (memory[stack[-4]:stack[-4] + 0x20] == 0x01) // Inputs[7] // { // @1939 stack[-1] // @193C memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @193D stack[-2] // @1940 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1944 memory[0x40:0x60] // @1955 stack[-3] // @195B msg.sender // } 1937 60 PUSH1 0x20 1939 90 SWAP1 193A 81 DUP2 193B 01 ADD 193C 51 MLOAD 193D 91 SWAP2 193E 81 DUP2 193F 01 ADD 1940 51 MLOAD 1941 60 PUSH1 0x40 1943 80 DUP1 1944 51 MLOAD 1945 93 SWAP4 1946 84 DUP5 1947 52 MSTORE 1948 91 SWAP2 1949 83 DUP4 194A 01 ADD 194B 52 MSTORE 194C 60 PUSH1 0x01 194E 60 PUSH1 0x01 1950 60 PUSH1 0xa0 1952 1B SHL 1953 03 SUB 1954 90 SWAP1 1955 92 SWAP3 1956 16 AND 1957 91 SWAP2 1958 60 PUSH1 0x00 195A 91 SWAP2 195B 33 CALLER 195C 91 SWAP2 195D 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 197E 91 SWAP2 197F 90 SWAP1 1980 81 DUP2 1981 90 SWAP1 1982 81 DUP2 1983 01 ADD // Stack delta = +4 // Outputs[9] // { // @1947 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @194B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1957 stack[-3] = stack[-3] & (0x01 << 0xa0) - 0x01 // @195A stack[-2] = 0x00 // @195C stack[-1] = msg.sender // @197E stack[0] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @197F stack[1] = memory[0x40:0x60] // @1981 stack[2] = memory[0x40:0x60] // @1983 stack[3] = memory[0x40:0x60] + 0x40 // } // Block continues label_1984: // Incoming jump from 0x1AEE // Incoming jump from 0x1983 // Incoming jump from 0x1C91 // Inputs[9] // { // @1985 stack[-1] // @1985 stack[-2] // @1986 stack[-3] // @1987 stack[-6] // @1987 stack[-5] // @1987 memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]] // @1987 stack[-4] // @1987 stack[-7] // @1988 stack[-8] // } 1984 5B JUMPDEST 1985 03 SUB 1986 90 SWAP1 1987 A4 LOG4 1988 56 *JUMP // Stack delta = -8 // Outputs[1] { @1987 log(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]], [stack[-4], stack[-5], stack[-6], stack[-7]]); } // Block ends with unconditional jump to stack[-8] label_1989: // Incoming jump from 0x1936, if 0x00 == (memory[stack[-4]:stack[-4] + 0x20] == 0x01) // Inputs[5] // { // @19B0 stack[-2] // @19B1 stack[-3] // @19B4 memory[0x40:0x60] // @19C1 msg.sender // @19C2 stack[-1] // } 1989 5B JUMPDEST 198A 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 19AB 61 PUSH2 0x1984 19AE 60 PUSH1 0x00 19B0 93 SWAP4 19B1 94 SWAP5 19B2 60 PUSH1 0x40 19B4 51 MLOAD 19B5 91 SWAP2 19B6 82 DUP3 19B7 91 SWAP2 19B8 60 PUSH1 0x01 19BA 80 DUP1 19BB 60 PUSH1 0xa0 19BD 1B SHL 19BE 03 SUB 19BF 16 AND 19C0 96 SWAP7 19C1 33 CALLER 19C2 95 SWAP6 19C3 83 DUP4 19C4 61 PUSH2 0x1871 19C7 56 *JUMP // Stack delta = +7 // Outputs[10] // { // @198A stack[0] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @19B0 stack[-2] = 0x00 // @19B5 stack[3] = 0x1984 // @19B5 stack[1] = memory[0x40:0x60] // @19B7 stack[2] = memory[0x40:0x60] // @19C0 stack[4] = stack[-2] // @19C0 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-3] // @19C2 stack[5] = stack[-1] // @19C2 stack[-1] = msg.sender // @19C3 stack[6] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1871 label_19C8: // Incoming call from 0x13AD, returns to 0x13AE // Inputs[6] // { // @19C9 stack[-4] // @19C9 stack[-1] // @19CA stack[-3] // @19CB stack[-2] // @19CD memory[stack[-2]:stack[-2] + 0x20] // @19CF memory[stack[-3]:stack[-3] + 0x20] // } 19C8 5B JUMPDEST 19C9 92 SWAP3 19CA 91 SWAP2 19CB 90 SWAP1 19CC 80 DUP1 19CD 51 MLOAD 19CE 82 DUP3 19CF 51 MLOAD 19D0 90 SWAP1 19D1 81 DUP2 19D2 81 DUP2 19D3 03 SUB 19D4 61 PUSH2 0x1241 19D7 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @19C9 stack[-4] = stack[-1] // @19CA stack[-3] = stack[-4] // @19CB stack[-1] = stack[-2] // @19CB stack[-2] = stack[-3] // @19D0 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @19D0 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x1241, if memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] label_19D8: // Incoming jump from 0x19D7, if not memory[stack[-2]:stack[-2] + 0x20] - memory[stack[-3]:stack[-3] + 0x20] // Inputs[2] // { // @19DD stack[-3] // @19DE memory[stack[-3]:stack[-3] + 0x20] // } 19D8 50 POP 19D9 50 POP 19DA 60 PUSH1 0x00 19DC 5B JUMPDEST 19DD 81 DUP2 19DE 51 MLOAD 19DF 81 DUP2 19E0 10 LT 19E1 15 ISZERO 19E2 61 PUSH2 0x1a8f 19E5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @19DA stack[-2] = 0x00 } // Block ends with conditional jump to 0x1a8f, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_19E6: // Incoming jump from 0x19E5, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x19E5, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[6] // { // @19E8 stack[-1] // @19EB stack[-2] // @19F3 memory[0x20 + (stack[-1] << 0x05) + stack[-2]:0x20 + (stack[-1] << 0x05) + stack[-2] + 0x20] // @19F5 stack[-3] // @19F8 memory[stack[-3] + (stack[-1] << 0x05) + 0x20:stack[-3] + (stack[-1] << 0x05) + 0x20 + 0x20] // @1A01 stack[-5] // } 19E6 60 PUSH1 0x05 19E8 81 DUP2 19E9 90 SWAP1 19EA 1B SHL 19EB 82 DUP3 19EC 81 DUP2 19ED 01 ADD 19EE 60 PUSH1 0x20 19F0 90 SWAP1 19F1 81 DUP2 19F2 01 ADD 19F3 51 MLOAD 19F4 91 SWAP2 19F5 85 DUP6 19F6 01 ADD 19F7 01 ADD 19F8 51 MLOAD 19F9 60 PUSH1 0x01 19FB 60 PUSH1 0x01 19FD 60 PUSH1 0xa0 19FF 1B SHL 1A00 03 SUB 1A01 87 DUP8 1A02 16 AND 1A03 61 PUSH2 0x1a11 1A06 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19F4 stack[0] = memory[0x20 + (stack[-1] << 0x05) + stack[-2]:0x20 + (stack[-1] << 0x05) + stack[-2] + 0x20] // @19F8 stack[1] = memory[stack[-3] + (stack[-1] << 0x05) + 0x20:stack[-3] + (stack[-1] << 0x05) + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1a11, if stack[-5] & (0x01 << 0xa0) - 0x01 label_1A07: // Incoming jump from 0x1A06, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1A57 // Inputs[1] { @1A0C stack[-3] } 1A07 5B JUMPDEST 1A08 50 POP 1A09 50 POP 1A0A 60 PUSH1 0x01 1A0C 01 ADD 1A0D 61 PUSH2 0x19dc 1A10 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A0C stack[-3] = 0x01 + stack[-3] } // Block ends with unconditional jump to 0x19dc label_1A11: // Incoming jump from 0x1A06, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A15 stack[-7] // @1A19 stack[-2] // @1A26 memory[0x00:0x40] // } 1A11 5B JUMPDEST 1A12 61 PUSH2 0x1a29 1A15 87 DUP8 1A16 61 PUSH2 0x18ff 1A19 84 DUP5 1A1A 60 PUSH1 0x00 1A1C 52 MSTORE 1A1D 60 PUSH1 0x00 1A1F 60 PUSH1 0x20 1A21 52 MSTORE 1A22 60 PUSH1 0x40 1A24 60 PUSH1 0x00 1A26 20 SHA3 1A27 90 SWAP1 1A28 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1A12 stack[0] = 0x1a29 // @1A15 stack[1] = stack[-7] // @1A1C memory[0x00:0x20] = stack[-2] // @1A21 memory[0x20:0x40] = 0x00 // @1A27 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1A29 label_1A29: // Incoming return from call to 0x18FF at 0x1A28 // Inputs[3] // { // @1A2A stack[-1] // @1A2A storage[stack[-1]] // @1A2B stack[-2] // } 1A29 5B JUMPDEST 1A2A 54 SLOAD 1A2B 81 DUP2 1A2C 81 DUP2 1A2D 10 LT 1A2E 61 PUSH2 0x1a58 1A31 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A2A stack[-1] = storage[stack[-1]] } // Block ends with conditional jump to 0x1a58, if storage[stack[-1]] < stack[-2] label_1A32: // Incoming jump from 0x1A31, if not storage[stack[-1]] < stack[-2] // Inputs[6] // { // @1A32 stack[-8] // @1A38 stack[-4] // @1A39 stack[-3] // @1A3A stack[-2] // @1A3E stack[-1] // @1A4D memory[0x00:0x40] // } 1A32 87 DUP8 1A33 61 PUSH2 0x18ff 1A36 60 PUSH1 0x01 1A38 95 SWAP6 1A39 94 SWAP5 1A3A 93 SWAP4 1A3B 61 PUSH2 0x1a50 1A3E 93 SWAP4 1A3F 03 SUB 1A40 93 SWAP4 1A41 60 PUSH1 0x00 1A43 52 MSTORE 1A44 60 PUSH1 0x00 1A46 60 PUSH1 0x20 1A48 52 MSTORE 1A49 60 PUSH1 0x40 1A4B 60 PUSH1 0x00 1A4D 20 SHA3 1A4E 90 SWAP1 1A4F 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1A32 stack[0] = stack[-8] // @1A38 stack[-4] = 0x01 // @1A39 stack[-3] = stack[-4] // @1A3E stack[-1] = 0x1a50 // @1A40 stack[-2] = stack[-1] - stack[-2] // @1A43 memory[0x00:0x20] = stack[-3] // @1A48 memory[0x20:0x40] = 0x00 // @1A4E stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1A50 label_1A50: // Incoming return from call to 0x18FF at 0x1A4F // Inputs[5] // { // @1A51 stack[-1] // @1A51 stack[-2] // @1A52 stack[-3] // @1A52 stack[-4] // @1A53 code.length // } 1A50 5B JUMPDEST 1A51 55 SSTORE 1A52 90 SWAP1 1A53 38 CODESIZE 1A54 61 PUSH2 0x1a07 1A57 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1A51 storage[stack[-1]] = stack[-2] // @1A52 stack[-4] = stack[-3] // @1A52 stack[-3] = stack[-4] // @1A53 stack[-2] = code.length // } // Block ends with unconditional jump to 0x1a07 label_1A58: // Incoming jump from 0x1A31, if storage[stack[-1]] < stack[-2] // Inputs[6] // { // @1A5B memory[0x40:0x60] // @1A6E stack[-8] // @1A79 stack[-1] // @1A81 stack[-2] // @1A88 stack[-3] // @1A8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84] // } 1A58 5B JUMPDEST 1A59 60 PUSH1 0x40 1A5B 51 MLOAD 1A5C 63 PUSH4 0x03dee4c5 1A61 60 PUSH1 0xe0 1A63 1B SHL 1A64 81 DUP2 1A65 52 MSTORE 1A66 60 PUSH1 0x01 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0xa0 1A6C 1B SHL 1A6D 03 SUB 1A6E 89 DUP10 1A6F 16 AND 1A70 60 PUSH1 0x04 1A72 82 DUP3 1A73 01 ADD 1A74 52 MSTORE 1A75 60 PUSH1 0x24 1A77 81 DUP2 1A78 01 ADD 1A79 91 SWAP2 1A7A 90 SWAP1 1A7B 91 SWAP2 1A7C 52 MSTORE 1A7D 60 PUSH1 0x44 1A7F 81 DUP2 1A80 01 ADD 1A81 82 DUP3 1A82 90 SWAP1 1A83 52 MSTORE 1A84 60 PUSH1 0x64 1A86 81 DUP2 1A87 01 ADD 1A88 83 DUP4 1A89 90 SWAP1 1A8A 52 MSTORE 1A8B 60 PUSH1 0x84 1A8D 90 SWAP1 1A8E FD *REVERT // Stack delta = -1 // Outputs[6] // { // @1A65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03dee4c5 << 0xe0 // @1A74 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1A7C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @1A83 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @1A8A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-3] // @1A8E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84]); // } // Block terminates label_1A8F: // Incoming jump from 0x19E5, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x19E5, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[5] // { // @1A91 stack[-3] // @1A91 stack[-2] // @1A94 stack[-4] // @1A95 stack[-5] // @1A9A memory[stack[-2]:stack[-2] + 0x20] // } 1A8F 5B JUMPDEST 1A90 50 POP 1A91 90 SWAP1 1A92 60 PUSH1 0x00 1A94 92 SWAP3 1A95 93 SWAP4 1A96 91 SWAP2 1A97 60 PUSH1 0x01 1A99 81 DUP2 1A9A 51 MLOAD 1A9B 14 EQ 1A9C 84 DUP5 1A9D 14 EQ 1A9E 61 PUSH2 0x1aef 1AA1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1A91 stack[-2] = stack[-3] // @1A94 stack[-4] = 0x00 // @1A95 stack[-5] = stack[-4] // @1A96 stack[-3] = stack[-5] // @1A96 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1aef, if 0x00 == (memory[stack[-2]:stack[-2] + 0x20] == 0x01) label_1AA2: // Incoming jump from 0x1AA1, if not 0x00 == (memory[stack[-2]:stack[-2] + 0x20] == 0x01) // Inputs[7] // { // @1AA4 stack[-1] // @1AA7 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1AA8 stack[-2] // @1AAB memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1AAF memory[0x40:0x60] // @1AC0 stack[-3] // @1AC3 msg.sender // } 1AA2 60 PUSH1 0x20 1AA4 90 SWAP1 1AA5 81 DUP2 1AA6 01 ADD 1AA7 51 MLOAD 1AA8 91 SWAP2 1AA9 81 DUP2 1AAA 01 ADD 1AAB 51 MLOAD 1AAC 60 PUSH1 0x40 1AAE 80 DUP1 1AAF 51 MLOAD 1AB0 93 SWAP4 1AB1 84 DUP5 1AB2 52 MSTORE 1AB3 91 SWAP2 1AB4 83 DUP4 1AB5 01 ADD 1AB6 52 MSTORE 1AB7 60 PUSH1 0x01 1AB9 60 PUSH1 0x01 1ABB 60 PUSH1 0xa0 1ABD 1B SHL 1ABE 03 SUB 1ABF 90 SWAP1 1AC0 92 SWAP3 1AC1 16 AND 1AC2 91 SWAP2 1AC3 33 CALLER 1AC4 91 SWAP2 1AC5 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1AE6 91 SWAP2 1AE7 81 DUP2 1AE8 90 SWAP1 1AE9 81 DUP2 1AEA 01 ADD 1AEB 61 PUSH2 0x1984 1AEE 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1AB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1AB6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1AC2 stack[-3] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1AC4 stack[-2] = msg.sender // @1AC4 stack[0] = memory[0x40:0x60] // @1AE6 stack[-1] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @1AE8 stack[1] = memory[0x40:0x60] // @1AEA stack[2] = memory[0x40:0x60] + 0x40 // } // Block ends with unconditional jump to 0x1984 label_1AEF: // Incoming jump from 0x1AA1, if 0x00 == (memory[stack[-2]:stack[-2] + 0x20] == 0x01) // Inputs[5] // { // @1AF2 memory[0x40:0x60] // @1AFC stack[-3] // @1AFF msg.sender // @1B00 stack[-2] // @1B22 stack[-1] // } 1AEF 5B JUMPDEST 1AF0 60 PUSH1 0x40 1AF2 51 MLOAD 1AF3 60 PUSH1 0x01 1AF5 60 PUSH1 0x01 1AF7 60 PUSH1 0xa0 1AF9 1B SHL 1AFA 03 SUB 1AFB 90 SWAP1 1AFC 93 SWAP4 1AFD 16 AND 1AFE 92 SWAP3 1AFF 33 CALLER 1B00 92 SWAP3 1B01 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1B22 92 SWAP3 1B23 82 DUP3 1B24 91 SWAP2 1B25 61 PUSH2 0x1984 1B28 91 SWAP2 1B29 83 DUP4 1B2A 61 PUSH2 0x1871 1B2D 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @1AFE stack[0] = memory[0x40:0x60] // @1AFE stack[-3] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1B00 stack[-2] = msg.sender // @1B22 stack[-1] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1B24 stack[1] = memory[0x40:0x60] // @1B24 stack[3] = stack[-2] // @1B28 stack[2] = 0x1984 // @1B28 stack[4] = stack[-1] // @1B29 stack[5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1871 label_1B2E: // Incoming call from 0x1460, returns to 0x1461 // Inputs[6] // { // @1B2F stack[-1] // @1B2F stack[-5] // @1B30 stack[-4] // @1B31 stack[-3] // @1B33 memory[stack[-3]:stack[-3] + 0x20] // @1B35 memory[stack[-4]:stack[-4] + 0x20] // } 1B2E 5B JUMPDEST 1B2F 93 SWAP4 1B30 92 SWAP3 1B31 91 SWAP2 1B32 80 DUP1 1B33 51 MLOAD 1B34 83 DUP4 1B35 51 MLOAD 1B36 90 SWAP1 1B37 81 DUP2 1B38 81 DUP2 1B39 03 SUB 1B3A 61 PUSH2 0x1241 1B3D 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1B2F stack[-5] = stack[-1] // @1B30 stack[-4] = stack[-5] // @1B31 stack[-1] = stack[-3] // @1B31 stack[-3] = stack[-4] // @1B36 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @1B36 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with conditional jump to 0x1241, if memory[stack[-3]:stack[-3] + 0x20] - memory[stack[-4]:stack[-4] + 0x20] label_1B3E: // Incoming jump from 0x1B3D, if not memory[stack[-3]:stack[-3] + 0x20] - memory[stack[-4]:stack[-4] + 0x20] // Inputs[2] // { // @1B43 stack[-3] // @1B44 memory[stack[-3]:stack[-3] + 0x20] // } 1B3E 50 POP 1B3F 50 POP 1B40 60 PUSH1 0x00 1B42 5B JUMPDEST 1B43 81 DUP2 1B44 51 MLOAD 1B45 81 DUP2 1B46 10 LT 1B47 15 ISZERO 1B48 61 PUSH2 0x1c30 1B4B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1B40 stack[-2] = 0x00 } // Block ends with conditional jump to 0x1c30, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_1B4C: // Incoming jump from 0x1B4B, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1B4B, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[7] // { // @1B4E stack[-1] // @1B51 stack[-2] // @1B59 memory[0x20 + (stack[-1] << 0x05) + stack[-2]:0x20 + (stack[-1] << 0x05) + stack[-2] + 0x20] // @1B5B stack[-4] // @1B5E memory[stack[-4] + (stack[-1] << 0x05) + 0x20:stack[-4] + (stack[-1] << 0x05) + 0x20 + 0x20] // @1B69 stack[-3] // @1B6B stack[-6] // } 1B4C 60 PUSH1 0x05 1B4E 81 DUP2 1B4F 90 SWAP1 1B50 1B SHL 1B51 82 DUP3 1B52 81 DUP2 1B53 01 ADD 1B54 60 PUSH1 0x20 1B56 90 SWAP1 1B57 81 DUP2 1B58 01 ADD 1B59 51 MLOAD 1B5A 91 SWAP2 1B5B 86 DUP7 1B5C 01 ADD 1B5D 01 ADD 1B5E 51 MLOAD 1B5F 60 PUSH1 0x01 1B61 60 PUSH1 0x01 1B63 60 PUSH1 0xa0 1B65 1B SHL 1B66 03 SUB 1B67 92 SWAP3 1B68 91 SWAP2 1B69 85 DUP6 1B6A 90 SWAP1 1B6B 89 DUP10 1B6C 85 DUP6 1B6D 16 AND 1B6E 61 PUSH2 0x1baa 1B71 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @1B5E stack[1] = memory[stack[-4] + (stack[-1] << 0x05) + 0x20:stack[-4] + (stack[-1] << 0x05) + 0x20 + 0x20] // @1B67 stack[-1] = (0x01 << 0xa0) - 0x01 // @1B68 stack[0] = stack[-1] // @1B6A stack[3] = memory[0x20 + (stack[-1] << 0x05) + stack[-2]:0x20 + (stack[-1] << 0x05) + stack[-2] + 0x20] // @1B6A stack[2] = stack[-3] // } // Block ends with conditional jump to 0x1baa, if (0x01 << 0xa0) - 0x01 & stack[-6] label_1B72: // Incoming jump from 0x1BF8 // Incoming jump from 0x1B71, if not (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[2] // { // @1B75 stack[-5] // @1B76 stack[-2] // } 1B72 5B JUMPDEST 1B73 60 PUSH1 0x01 1B75 94 SWAP5 1B76 82 DUP3 1B77 16 AND 1B78 61 PUSH2 0x1b85 1B7B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B75 stack[-5] = 0x01 } // Block ends with conditional jump to 0x1b85, if stack[-2] & stack[-5] label_1B7C: // Incoming jump from 0x1B7B, if not stack[-2] & stack[-5] // Incoming jump from 0x1BA9 // Inputs[2] // { // @1B80 stack[-4] // @1B80 stack[-5] // } 1B7C 5B JUMPDEST 1B7D 50 POP 1B7E 50 POP 1B7F 50 POP 1B80 01 ADD 1B81 61 PUSH2 0x1b42 1B84 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B80 stack[-5] = stack[-4] + stack[-5] } // Block ends with unconditional jump to 0x1b42 label_1B85: // Incoming jump from 0x1B7B, if stack[-2] & stack[-5] // Inputs[3] // { // @1B89 stack[-2] // @1B90 stack[-1] // @1B9D memory[0x00:0x40] // } 1B85 5B JUMPDEST 1B86 61 PUSH2 0x1ba0 1B89 91 SWAP2 1B8A 61 PUSH2 0x18ff 1B8D 61 PUSH2 0x1916 1B90 92 SWAP3 1B91 60 PUSH1 0x00 1B93 52 MSTORE 1B94 60 PUSH1 0x00 1B96 60 PUSH1 0x20 1B98 52 MSTORE 1B99 60 PUSH1 0x40 1B9B 60 PUSH1 0x00 1B9D 20 SHA3 1B9E 90 SWAP1 1B9F 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1B89 stack[0] = stack[-2] // @1B89 stack[-2] = 0x1ba0 // @1B90 stack[-1] = 0x1916 // @1B93 memory[0x00:0x20] = stack[-1] // @1B98 memory[0x20:0x40] = 0x00 // @1B9E stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1916 label_1BA0: // Incoming return from call to 0x1916 at 0x1B9F // Inputs[4] // { // @1BA1 stack[-2] // @1BA1 stack[-1] // @1BA3 code.length // @1BA4 stack[-6] // } 1BA0 5B JUMPDEST 1BA1 90 SWAP1 1BA2 55 SSTORE 1BA3 38 CODESIZE 1BA4 84 DUP5 1BA5 81 DUP2 1BA6 61 PUSH2 0x1b7c 1BA9 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1BA2 storage[stack[-2]] = stack[-1] // @1BA3 stack[-2] = code.length // @1BA4 stack[-1] = stack[-6] // @1BA5 stack[0] = code.length // } // Block ends with unconditional jump to 0x1b7c label_1BAA: // Incoming jump from 0x1B71, if (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[7] // { // @1BAB stack[-3] // @1BAB stack[-1] // @1BAC stack[-4] // @1BAD stack[-5] // @1BAE stack[-2] // @1BB3 stack[-10] // @1BC4 memory[0x00:0x40] // } 1BAA 5B JUMPDEST 1BAB 91 SWAP2 1BAC 92 SWAP3 1BAD 93 SWAP4 1BAE 90 SWAP1 1BAF 50 POP 1BB0 61 PUSH2 0x1bc7 1BB3 89 DUP10 1BB4 61 PUSH2 0x18ff 1BB7 84 DUP5 1BB8 60 PUSH1 0x00 1BBA 52 MSTORE 1BBB 60 PUSH1 0x00 1BBD 60 PUSH1 0x20 1BBF 52 MSTORE 1BC0 60 PUSH1 0x40 1BC2 60 PUSH1 0x00 1BC4 20 SHA3 1BC5 90 SWAP1 1BC6 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @1BAB stack[-3] = stack[-1] // @1BAC stack[-4] = stack[-3] // @1BAD stack[-5] = stack[-4] // @1BAE stack[-2] = stack[-5] // @1BB0 stack[-1] = 0x1bc7 // @1BB3 stack[0] = stack[-10] // @1BBA memory[0x00:0x20] = stack[-1] // @1BBF memory[0x20:0x40] = 0x00 // @1BC5 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1BC7 label_1BC7: // Incoming return from call to 0x18FF at 0x1BC6 // Inputs[3] // { // @1BC8 stack[-1] // @1BC8 storage[stack[-1]] // @1BC9 stack[-4] // } 1BC7 5B JUMPDEST 1BC8 54 SLOAD 1BC9 83 DUP4 1BCA 81 DUP2 1BCB 10 LT 1BCC 61 PUSH2 0x1bf9 1BCF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BC8 stack[-1] = storage[stack[-1]] } // Block ends with conditional jump to 0x1bf9, if storage[stack[-1]] < stack[-4] label_1BD0: // Incoming jump from 0x1BCF, if not storage[stack[-1]] < stack[-4] // Inputs[8] // { // @1BD0 stack[-1] // @1BD0 stack[-3] // @1BD1 stack[-7] // @1BD2 stack[-2] // @1BD3 stack[-4] // @1BD6 stack[-5] // @1BDD stack[-10] // @1BEE memory[0x00:0x40] // } 1BD0 91 SWAP2 1BD1 86 DUP7 1BD2 91 SWAP2 1BD3 84 DUP5 1BD4 60 PUSH1 0x01 1BD6 96 SWAP7 1BD7 95 SWAP6 1BD8 94 SWAP5 1BD9 03 SUB 1BDA 61 PUSH2 0x1bf1 1BDD 8C DUP13 1BDE 61 PUSH2 0x18ff 1BE1 85 DUP6 1BE2 60 PUSH1 0x00 1BE4 52 MSTORE 1BE5 60 PUSH1 0x00 1BE7 60 PUSH1 0x20 1BE9 52 MSTORE 1BEA 60 PUSH1 0x40 1BEC 60 PUSH1 0x00 1BEE 20 SHA3 1BEF 90 SWAP1 1BF0 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @1BD0 stack[-1] = stack[-3] // @1BD2 stack[0] = stack[-2] // @1BD2 stack[-2] = stack[-7] // @1BD6 stack[-5] = 0x01 // @1BD7 stack[-4] = stack[-5] // @1BD8 stack[-3] = stack[-4] // @1BD9 stack[1] = stack[-1] - stack[-4] // @1BDA stack[2] = 0x1bf1 // @1BDD stack[3] = stack[-10] // @1BE4 memory[0x00:0x20] = stack[-3] // @1BE9 memory[0x20:0x40] = 0x00 // @1BEF stack[4] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x18ff, returns to 0x1BF1 label_1BF1: // Incoming return from call to 0x18FF at 0x1BF0 // Inputs[4] // { // @1BF2 stack[-2] // @1BF2 stack[-1] // @1BF3 stack[-8] // @1BF3 stack[-3] // } 1BF1 5B JUMPDEST 1BF2 55 SSTORE 1BF3 94 SWAP5 1BF4 50 POP 1BF5 61 PUSH2 0x1b72 1BF8 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1BF2 storage[stack[-1]] = stack[-2] // @1BF3 stack[-8] = stack[-3] // } // Block ends with unconditional jump to 0x1b72 label_1BF9: // Incoming jump from 0x1BCF, if storage[stack[-1]] < stack[-4] // Inputs[6] // { // @1BFC memory[0x40:0x60] // @1C0F stack[-10] // @1C1A stack[-1] // @1C22 stack[-4] // @1C29 stack[-3] // @1C2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84] // } 1BF9 5B JUMPDEST 1BFA 60 PUSH1 0x40 1BFC 51 MLOAD 1BFD 63 PUSH4 0x03dee4c5 1C02 60 PUSH1 0xe0 1C04 1B SHL 1C05 81 DUP2 1C06 52 MSTORE 1C07 60 PUSH1 0x01 1C09 60 PUSH1 0x01 1C0B 60 PUSH1 0xa0 1C0D 1B SHL 1C0E 03 SUB 1C0F 8B DUP12 1C10 16 AND 1C11 60 PUSH1 0x04 1C13 82 DUP3 1C14 01 ADD 1C15 52 MSTORE 1C16 60 PUSH1 0x24 1C18 81 DUP2 1C19 01 ADD 1C1A 91 SWAP2 1C1B 90 SWAP1 1C1C 91 SWAP2 1C1D 52 MSTORE 1C1E 60 PUSH1 0x44 1C20 81 DUP2 1C21 01 ADD 1C22 84 DUP5 1C23 90 SWAP1 1C24 52 MSTORE 1C25 60 PUSH1 0x64 1C27 81 DUP2 1C28 01 ADD 1C29 83 DUP4 1C2A 90 SWAP1 1C2B 52 MSTORE 1C2C 60 PUSH1 0x84 1C2E 90 SWAP1 1C2F FD *REVERT // Stack delta = -1 // Outputs[6] // { // @1C06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03dee4c5 << 0xe0 // @1C15 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @1C1D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @1C24 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-4] // @1C2B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-3] // @1C2F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x84]); // } // Block terminates label_1C30: // Incoming jump from 0x1B4B, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1B4B, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[6] // { // @1C32 stack[-2] // @1C33 memory[stack[-2]:stack[-2] + 0x20] // @1C34 stack[-5] // @1C35 stack[-6] // @1C37 stack[-3] // @1C38 stack[-4] // } 1C30 5B JUMPDEST 1C31 50 POP 1C32 80 DUP1 1C33 51 MLOAD 1C34 93 SWAP4 1C35 94 SWAP5 1C36 93 SWAP4 1C37 91 SWAP2 1C38 92 SWAP3 1C39 91 SWAP2 1C3A 60 PUSH1 0x01 1C3C 03 SUB 1C3D 61 PUSH2 0x1c92 1C40 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1C35 stack[-6] = stack[-5] // @1C36 stack[-5] = stack[-6] // @1C38 stack[-4] = stack[-3] // @1C39 stack[-3] = stack[-4] // } // Block ends with conditional jump to 0x1c92, if 0x01 - memory[stack[-2]:stack[-2] + 0x20] label_1C41: // Incoming jump from 0x1C40, if not 0x01 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[8] // { // @1C43 stack[-1] // @1C46 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1C47 stack[-2] // @1C4A memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1C4E memory[0x40:0x60] // @1C5E stack[-3] // @1C61 stack[-4] // @1C66 msg.sender // } 1C41 60 PUSH1 0x20 1C43 90 SWAP1 1C44 81 DUP2 1C45 01 ADD 1C46 51 MLOAD 1C47 91 SWAP2 1C48 81 DUP2 1C49 01 ADD 1C4A 51 MLOAD 1C4B 60 PUSH1 0x40 1C4D 80 DUP1 1C4E 51 MLOAD 1C4F 93 SWAP4 1C50 84 DUP5 1C51 52 MSTORE 1C52 91 SWAP2 1C53 83 DUP4 1C54 01 ADD 1C55 52 MSTORE 1C56 60 PUSH1 0x01 1C58 60 PUSH1 0x01 1C5A 60 PUSH1 0xa0 1C5C 1B SHL 1C5D 03 SUB 1C5E 92 SWAP3 1C5F 83 DUP4 1C60 16 AND 1C61 93 SWAP4 1C62 90 SWAP1 1C63 92 SWAP3 1C64 16 AND 1C65 91 SWAP2 1C66 33 CALLER 1C67 91 SWAP2 1C68 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1C89 91 SWAP2 1C8A 81 DUP2 1C8B 90 SWAP1 1C8C 81 DUP2 1C8D 01 ADD 1C8E 61 PUSH2 0x1984 1C91 56 *JUMP // Stack delta = +3 // Outputs[9] // { // @1C51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1C55 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @1C61 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1C65 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1C67 stack[-2] = msg.sender // @1C67 stack[0] = memory[0x40:0x60] // @1C89 stack[-1] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @1C8B stack[1] = memory[0x40:0x60] // @1C8D stack[2] = memory[0x40:0x60] + 0x40 // } // Block ends with unconditional jump to 0x1984 label_1C92: // Incoming jump from 0x1C40, if 0x01 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[6] // { // @1C95 memory[0x40:0x60] // @1C9E stack[-3] // @1CA1 stack[-4] // @1CA6 msg.sender // @1CA7 stack[-2] // @1CC9 stack[-1] // } 1C92 5B JUMPDEST 1C93 60 PUSH1 0x40 1C95 51 MLOAD 1C96 60 PUSH1 0x01 1C98 60 PUSH1 0x01 1C9A 60 PUSH1 0xa0 1C9C 1B SHL 1C9D 03 SUB 1C9E 93 SWAP4 1C9F 84 DUP5 1CA0 16 AND 1CA1 94 SWAP5 1CA2 90 SWAP1 1CA3 93 SWAP4 1CA4 16 AND 1CA5 92 SWAP3 1CA6 33 CALLER 1CA7 92 SWAP3 1CA8 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1CC9 92 SWAP3 1CCA 82 DUP3 1CCB 91 SWAP2 1CCC 61 PUSH2 0x1984 1CCF 91 SWAP2 1CD0 83 DUP4 1CD1 61 PUSH2 0x1871 1CD4 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @1CA1 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1CA5 stack[0] = memory[0x40:0x60] // @1CA5 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1CA7 stack[-2] = msg.sender // @1CC9 stack[-1] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1CCB stack[1] = memory[0x40:0x60] // @1CCB stack[3] = stack[-2] // @1CCF stack[4] = stack[-1] // @1CCF stack[2] = 0x1984 // @1CD0 stack[5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1871 1CD5 FE *ASSERT 1CD6 A2 LOG2 1CD7 64 PUSH5 0x6970667358 1CDD 22 22 1CDE 12 SLT 1CDF 20 SHA3 1CE0 F0 CREATE 1CE1 3F EXTCODEHASH 1CE2 D3 D3 1CE3 B3 B3 1CE4 77 PUSH24 0xa0662655f228c102106812ce801d0e99e2e48c8455affc97 1CFD 79 PUSH26 0xd62064736f6c63430008160033