Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x02b1 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02b1, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x806ad57e 0019 11 GT 001A 61 PUSH2 0x0175 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0175, if 0x806ad57e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x806ad57e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xcebbbf0c 0024 11 GT 0025 61 PUSH2 0x00dc 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0xcebbbf0c > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xcebbbf0c > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdd73b576 002F 11 GT 0030 61 PUSH2 0x0095 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xdd73b576 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdd73b576 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe59a2ca4 003A 11 GT 003B 61 PUSH2 0x006f 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe59a2ca4 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe59a2ca4 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe59a2ca4 0045 14 EQ 0046 61 PUSH2 0x0793 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0793, if 0xe59a2ca4 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe59a2ca4 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe61c23e8 0050 14 EQ 0051 61 PUSH2 0x07b3 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b3, if 0xe61c23e8 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe61c23e8 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf21cbaf4 005B 14 EQ 005C 61 PUSH2 0x07dc 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07dc, if 0xf21cbaf4 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf21cbaf4 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x07fc 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07fc, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] 006B 61 PUSH2 0x02b8 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_006F: // Incoming jump from 0x003E, if 0xe59a2ca4 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xdd73b576 0076 14 EQ 0077 61 PUSH2 0x0740 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0740, if 0xdd73b576 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xdd73b576 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xe1f21c67 0081 14 EQ 0082 61 PUSH2 0x0753 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0753, if 0xe1f21c67 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xe1f21c67 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xe3d670d7 008C 14 EQ 008D 61 PUSH2 0x0773 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0773, if 0xe3d670d7 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xe3d670d7 == stack[-1] 0091 61 PUSH2 0x02b8 0094 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_0095: // Incoming jump from 0x0033, if 0xdd73b576 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0xcebbbf0c 009C 14 EQ 009D 61 PUSH2 0x06b2 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b2, if 0xcebbbf0c == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xcebbbf0c == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xd004f0f7 00A7 14 EQ 00A8 61 PUSH2 0x06d2 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d2, if 0xd004f0f7 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xd004f0f7 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xd0d126ca 00B2 14 EQ 00B3 61 PUSH2 0x06e5 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e5, if 0xd0d126ca == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xd0d126ca == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xd1f4ba82 00BD 14 EQ 00BE 61 PUSH2 0x0705 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0705, if 0xd1f4ba82 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xd1f4ba82 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xdbba0f01 00C8 14 EQ 00C9 61 PUSH2 0x070d 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070d, if 0xdbba0f01 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xdbba0f01 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xdbf616fa 00D3 14 EQ 00D4 61 PUSH2 0x072d 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x072d, if 0xdbf616fa == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xdbf616fa == stack[-1] 00D8 61 PUSH2 0x02b8 00DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_00DC: // Incoming jump from 0x0028, if 0xcebbbf0c > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x8ff1dcf7 00E3 11 GT 00E4 61 PUSH2 0x012e 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012e, if 0x8ff1dcf7 > stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x8ff1dcf7 > stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x8ff1dcf7 00EE 14 EQ 00EF 61 PUSH2 0x060d 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060d, if 0x8ff1dcf7 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x8ff1dcf7 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0xa1c51915 00F9 14 EQ 00FA 61 PUSH2 0x062d 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062d, if 0xa1c51915 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0xa1c51915 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0xaa156645 0104 14 EQ 0105 61 PUSH2 0x0652 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0652, if 0xaa156645 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0xaa156645 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0xbe6d055a 010F 14 EQ 0110 61 PUSH2 0x02ff 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ff, if 0xbe6d055a == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0xbe6d055a == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0xc154d48d 011A 14 EQ 011B 61 PUSH2 0x0672 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0672, if 0xc154d48d == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0xc154d48d == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0xc4f987a5 0125 14 EQ 0126 61 PUSH2 0x0692 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0692, if 0xc4f987a5 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0xc4f987a5 == stack[-1] 012A 61 PUSH2 0x02b8 012D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_012E: // Incoming jump from 0x00E7, if 0x8ff1dcf7 > stack[-1] // Inputs[1] { @012F stack[-1] } 012E 5B JUMPDEST 012F 80 DUP1 0130 63 PUSH4 0x806ad57e 0135 14 EQ 0136 61 PUSH2 0x0586 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0586, if 0x806ad57e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x806ad57e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x8071ed7f 0140 14 EQ 0141 61 PUSH2 0x05a6 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a6, if 0x8071ed7f == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x8071ed7f == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x882cf1ce 014B 14 EQ 014C 61 PUSH2 0x05bb 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bb, if 0x882cf1ce == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x882cf1ce == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x8c5fe30b 0156 14 EQ 0157 61 PUSH2 0x05db 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05db, if 0x8c5fe30b == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x8c5fe30b == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x8da5cb5b 0161 14 EQ 0162 61 PUSH2 0x05e3 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e3, if 0x8da5cb5b == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x8f32d59b 016C 14 EQ 016D 61 PUSH2 0x05f8 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f8, if 0x8f32d59b == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x8f32d59b == stack[-1] 0171 61 PUSH2 0x02b8 0174 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_0175: // Incoming jump from 0x001D, if 0x806ad57e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x4685903b 017C 11 GT 017D 61 PUSH2 0x0219 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, if 0x4685903b > stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x4685903b > stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x56c4ff14 0187 11 GT 0188 61 PUSH2 0x01d2 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d2, if 0x56c4ff14 > stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x56c4ff14 > stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x56c4ff14 0192 14 EQ 0193 61 PUSH2 0x04d1 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d1, if 0x56c4ff14 == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x56c4ff14 == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x56e6ee6f 019D 14 EQ 019E 61 PUSH2 0x04f1 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f1, if 0x56e6ee6f == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x56e6ee6f == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x652206f5 01A8 14 EQ 01A9 61 PUSH2 0x0511 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0511, if 0x652206f5 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x652206f5 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x6fcca2e1 01B3 14 EQ 01B4 61 PUSH2 0x0531 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0531, if 0x6fcca2e1 == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x6fcca2e1 == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x715018a6 01BE 14 EQ 01BF 61 PUSH2 0x0551 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0551, if 0x715018a6 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x715018a6 == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x7451ea3d 01C9 14 EQ 01CA 61 PUSH2 0x0566 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0566, if 0x7451ea3d == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x7451ea3d == stack[-1] 01CE 61 PUSH2 0x02b8 01D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_01D2: // Incoming jump from 0x018B, if 0x56c4ff14 > stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D2 5B JUMPDEST 01D3 80 DUP1 01D4 63 PUSH4 0x4685903b 01D9 14 EQ 01DA 61 PUSH2 0x0436 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0436, if 0x4685903b == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x4685903b == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x47e7ef24 01E4 14 EQ 01E5 61 PUSH2 0x0449 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0449, if 0x47e7ef24 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x47e7ef24 == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x4ebbc92a 01EF 14 EQ 01F0 61 PUSH2 0x045c 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045c, if 0x4ebbc92a == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x4ebbc92a == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x5177fb77 01FA 14 EQ 01FB 61 PUSH2 0x047c 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047c, if 0x5177fb77 == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x5177fb77 == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x53ccf3ae 0205 14 EQ 0206 61 PUSH2 0x0491 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0491, if 0x53ccf3ae == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x53ccf3ae == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x5429bd60 0210 14 EQ 0211 61 PUSH2 0x04b1 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b1, if 0x5429bd60 == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x5429bd60 == stack[-1] 0215 61 PUSH2 0x02b8 0218 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_0219: // Incoming jump from 0x0180, if 0x4685903b > stack[-1] // Inputs[1] { @021A stack[-1] } 0219 5B JUMPDEST 021A 80 DUP1 021B 63 PUSH4 0x2fc69ddf 0220 11 GT 0221 61 PUSH2 0x026b 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026b, if 0x2fc69ddf > stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x2fc69ddf > stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x2fc69ddf 022B 14 EQ 022C 61 PUSH2 0x038a 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038a, if 0x2fc69ddf == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x2fc69ddf == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x332daccf 0236 14 EQ 0237 61 PUSH2 0x03aa 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03aa, if 0x332daccf == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x332daccf == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x3fc8cef3 0241 14 EQ 0242 61 PUSH2 0x03d7 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d7, if 0x3fc8cef3 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x3fc8cef3 == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x4048a257 024C 14 EQ 024D 61 PUSH2 0x03f9 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f9, if 0x4048a257 == stack[-1] label_0251: // Incoming jump from 0x0250, if not 0x4048a257 == stack[-1] // Inputs[1] { @0251 stack[-1] } 0251 80 DUP1 0252 63 PUSH4 0x41c0e1b5 0257 14 EQ 0258 61 PUSH2 0x0419 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0419, if 0x41c0e1b5 == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x41c0e1b5 == stack[-1] // Inputs[1] { @025C stack[-1] } 025C 80 DUP1 025D 63 PUSH4 0x4641257d 0262 14 EQ 0263 61 PUSH2 0x042e 0266 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042e, if 0x4641257d == stack[-1] label_0267: // Incoming jump from 0x0266, if not 0x4641257d == stack[-1] 0267 61 PUSH2 0x02b8 026A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_026B: // Incoming jump from 0x0224, if 0x2fc69ddf > stack[-1] // Inputs[1] { @026C stack[-1] } 026B 5B JUMPDEST 026C 80 DUP1 026D 62 PUSH3 0xf714ce 0271 14 EQ 0272 61 PUSH2 0x02bd 0275 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bd, if 0xf714ce == stack[-1] label_0276: // Incoming jump from 0x0275, if not 0xf714ce == stack[-1] // Inputs[1] { @0276 stack[-1] } 0276 80 DUP1 0277 63 PUSH4 0x0111efb7 027C 14 EQ 027D 61 PUSH2 0x02df 0280 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02df, if 0x0111efb7 == stack[-1] label_0281: // Incoming jump from 0x0280, if not 0x0111efb7 == stack[-1] // Inputs[1] { @0281 stack[-1] } 0281 80 DUP1 0282 63 PUSH4 0x090125bd 0287 14 EQ 0288 61 PUSH2 0x02ff 028B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ff, if 0x090125bd == stack[-1] label_028C: // Incoming jump from 0x028B, if not 0x090125bd == stack[-1] // Inputs[1] { @028C stack[-1] } 028C 80 DUP1 028D 63 PUSH4 0x0ae75d1d 0292 14 EQ 0293 61 PUSH2 0x0312 0296 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0312, if 0x0ae75d1d == stack[-1] label_0297: // Incoming jump from 0x0296, if not 0x0ae75d1d == stack[-1] // Inputs[1] { @0297 stack[-1] } 0297 80 DUP1 0298 63 PUSH4 0x0d029be3 029D 14 EQ 029E 61 PUSH2 0x0332 02A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0332, if 0x0d029be3 == stack[-1] label_02A2: // Incoming jump from 0x02A1, if not 0x0d029be3 == stack[-1] // Inputs[1] { @02A2 stack[-1] } 02A2 80 DUP1 02A3 63 PUSH4 0x1865c57d 02A8 14 EQ 02A9 61 PUSH2 0x0368 02AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0368, if 0x1865c57d == stack[-1] label_02AD: // Incoming jump from 0x02AC, if not 0x1865c57d == stack[-1] 02AD 61 PUSH2 0x02b8 02B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b8 label_02B1: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @02B2 msg.data.length } 02B1 5B JUMPDEST 02B2 36 CALLDATASIZE 02B3 61 PUSH2 0x02b8 02B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b8, if msg.data.length label_02B7: // Incoming jump from 0x02B6, if not msg.data.length 02B7 00 *STOP // Stack delta = +0 // Outputs[1] { @02B7 stop(); } // Block terminates label_02B8: // Incoming jump from 0x0218 // Incoming jump from 0x02B0 // Incoming jump from 0x006E // Incoming jump from 0x02B6, if msg.data.length // Incoming jump from 0x026A // Incoming jump from 0x00DB // Incoming jump from 0x0094 // Incoming jump from 0x012D // Incoming jump from 0x0174 // Incoming jump from 0x01D1 // Inputs[1] { @02BC memory[0x00:0x00] } 02B8 5B JUMPDEST 02B9 60 PUSH1 0x00 02BB 80 DUP1 02BC FD *REVERT // Stack delta = +0 // Outputs[1] { @02BC revert(memory[0x00:0x00]); } // Block terminates label_02BD: // Incoming jump from 0x0275, if 0xf714ce == stack[-1] // Inputs[1] { @02BE msg.value } 02BD 5B JUMPDEST 02BE 34 CALLVALUE 02BF 80 DUP1 02C0 15 ISZERO 02C1 61 PUSH2 0x02c9 02C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BE stack[0] = msg.value } // Block ends with conditional jump to 0x02c9, if !msg.value label_02C5: // Incoming jump from 0x02C4, if not !msg.value // Inputs[1] { @02C8 memory[0x00:0x00] } 02C5 60 PUSH1 0x00 02C7 80 DUP1 02C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C8 revert(memory[0x00:0x00]); } // Block terminates label_02C9: // Incoming jump from 0x02C4, if !msg.value // Inputs[1] { @02D1 msg.data.length } 02C9 5B JUMPDEST 02CA 50 POP 02CB 61 PUSH2 0x02dd 02CE 61 PUSH2 0x02d8 02D1 36 CALLDATASIZE 02D2 60 PUSH1 0x04 02D4 61 PUSH2 0x3685 02D7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CB stack[-1] = 0x02dd // @02CE stack[0] = 0x02d8 // @02D1 stack[1] = msg.data.length // @02D2 stack[2] = 0x04 // } // Block ends with call to 0x3685, returns to 0x02D8 label_02D8: // Incoming return from call to 0x3685 at 0x02D7 02D8 5B JUMPDEST 02D9 61 PUSH2 0x081c 02DC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x081c label_02DD: // Incoming return from call to 0x0444 at 0x0443 // Incoming return from call to 0x04AC at 0x04AB // Incoming return from call to 0x04CC at 0x04CB // Incoming return from call to 0x032D at 0x032C // Incoming return from call to 0x18DB at 0x05E2 // Incoming return from call to 0x02D8 at 0x02D7 // Incoming return from call to 0x050C at 0x050B // Incoming return from call to 0x06AD at 0x06AC // Incoming return from call to 0x02FA at 0x02F9 // Incoming return from call to 0x0581 at 0x0580 // Incoming return from call to 0x07AE at 0x07AD // Incoming return from call to 0x04EC at 0x04EB // Incoming return from call to 0x0628 at 0x0627 // Incoming return from call to 0x168A at 0x0565 // Incoming return from call to 0x07F7 at 0x07F6 // Incoming return from call to 0x05A1 at 0x05A0 // Incoming return from call to 0x054C at 0x054B // Incoming return from call to 0x0728 at 0x0727 // Incoming return from call to 0x0728 at 0x0727 // Incoming return from call to 0x0DB5 at 0x0435 // Incoming return from call to 0x030D at 0x030C // Incoming return from call to 0x06E0 at 0x06DF // Incoming return from call to 0x05D6 at 0x05D5 // Incoming return from call to 0x0817 at 0x0816 // Incoming return from call to 0x052C at 0x052B // Incoming return from call to 0x074E at 0x074D // Incoming return from call to 0x1CBA at 0x070C // Incoming return from call to 0x0457 at 0x0456 // Incoming return from call to 0x068D at 0x068C 02DD 5B JUMPDEST 02DE 00 *STOP // Stack delta = +0 // Outputs[1] { @02DE stop(); } // Block terminates label_02DF: // Incoming jump from 0x0280, if 0x0111efb7 == stack[-1] // Inputs[1] { @02E0 msg.value } 02DF 5B JUMPDEST 02E0 34 CALLVALUE 02E1 80 DUP1 02E2 15 ISZERO 02E3 61 PUSH2 0x02eb 02E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E0 stack[0] = msg.value } // Block ends with conditional jump to 0x02eb, if !msg.value label_02E7: // Incoming jump from 0x02E6, if not !msg.value // Inputs[1] { @02EA memory[0x00:0x00] } 02E7 60 PUSH1 0x00 02E9 80 DUP1 02EA FD *REVERT // Stack delta = +0 // Outputs[1] { @02EA revert(memory[0x00:0x00]); } // Block terminates label_02EB: // Incoming jump from 0x02E6, if !msg.value // Inputs[1] { @02F3 msg.data.length } 02EB 5B JUMPDEST 02EC 50 POP 02ED 61 PUSH2 0x02dd 02F0 61 PUSH2 0x02fa 02F3 36 CALLDATASIZE 02F4 60 PUSH1 0x04 02F6 61 PUSH2 0x3556 02F9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02ED stack[-1] = 0x02dd // @02F0 stack[0] = 0x02fa // @02F3 stack[1] = msg.data.length // @02F4 stack[2] = 0x04 // } // Block ends with call to 0x3556, returns to 0x02FA label_02FA: // Incoming return from call to 0x3556 at 0x02F9 02FA 5B JUMPDEST 02FB 61 PUSH2 0x0a9c 02FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a9c label_02FF: // Incoming jump from 0x028B, if 0x090125bd == stack[-1] // Incoming jump from 0x0113, if 0xbe6d055a == stack[-1] // Inputs[1] { @0306 msg.data.length } 02FF 5B JUMPDEST 0300 61 PUSH2 0x02dd 0303 61 PUSH2 0x030d 0306 36 CALLDATASIZE 0307 60 PUSH1 0x04 0309 61 PUSH2 0x344c 030C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0300 stack[0] = 0x02dd // @0303 stack[1] = 0x030d // @0306 stack[2] = msg.data.length // @0307 stack[3] = 0x04 // } // Block ends with call to 0x344c, returns to 0x030D label_030D: // Incoming return from call to 0x344C at 0x030C 030D 5B JUMPDEST 030E 61 PUSH2 0x0b6a 0311 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b6a label_0312: // Incoming jump from 0x0296, if 0x0ae75d1d == stack[-1] // Inputs[1] { @0313 msg.value } 0312 5B JUMPDEST 0313 34 CALLVALUE 0314 80 DUP1 0315 15 ISZERO 0316 61 PUSH2 0x031e 0319 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0313 stack[0] = msg.value } // Block ends with conditional jump to 0x031e, if !msg.value label_031A: // Incoming jump from 0x0319, if not !msg.value // Inputs[1] { @031D memory[0x00:0x00] } 031A 60 PUSH1 0x00 031C 80 DUP1 031D FD *REVERT // Stack delta = +0 // Outputs[1] { @031D revert(memory[0x00:0x00]); } // Block terminates label_031E: // Incoming jump from 0x0319, if !msg.value // Inputs[1] { @0326 msg.data.length } 031E 5B JUMPDEST 031F 50 POP 0320 61 PUSH2 0x02dd 0323 61 PUSH2 0x032d 0326 36 CALLDATASIZE 0327 60 PUSH1 0x04 0329 61 PUSH2 0x35d4 032C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0320 stack[-1] = 0x02dd // @0323 stack[0] = 0x032d // @0326 stack[1] = msg.data.length // @0327 stack[2] = 0x04 // } // Block ends with call to 0x35d4, returns to 0x032D label_032D: // Incoming return from call to 0x35D4 at 0x032C 032D 5B JUMPDEST 032E 61 PUSH2 0x0c4f 0331 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c4f label_0332: // Incoming jump from 0x02A1, if 0x0d029be3 == stack[-1] // Inputs[1] { @0333 msg.value } 0332 5B JUMPDEST 0333 34 CALLVALUE 0334 80 DUP1 0335 15 ISZERO 0336 61 PUSH2 0x033e 0339 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0333 stack[0] = msg.value } // Block ends with conditional jump to 0x033e, if !msg.value label_033A: // Incoming jump from 0x0339, if not !msg.value // Inputs[1] { @033D memory[0x00:0x00] } 033A 60 PUSH1 0x00 033C 80 DUP1 033D FD *REVERT // Stack delta = +0 // Outputs[1] { @033D revert(memory[0x00:0x00]); } // Block terminates label_033E: // Incoming jump from 0x0339, if !msg.value // Inputs[1] { @0346 msg.data.length } 033E 5B JUMPDEST 033F 50 POP 0340 61 PUSH2 0x0352 0343 61 PUSH2 0x034d 0346 36 CALLDATASIZE 0347 60 PUSH1 0x04 0349 61 PUSH2 0x336e 034C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0340 stack[-1] = 0x0352 // @0343 stack[0] = 0x034d // @0346 stack[1] = msg.data.length // @0347 stack[2] = 0x04 // } // Block ends with call to 0x336e, returns to 0x034D label_034D: // Incoming return from call to 0x336E at 0x034C 034D 5B JUMPDEST 034E 61 PUSH2 0x0c91 0351 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c91 label_0352: // Incoming return from call to 0x034D at 0x034C // Incoming return from call to 0x10D1 at 0x0490 // Incoming return from call to 0x03A5 at 0x03A4 // Incoming return from call to 0x073B at 0x073A // Incoming return from call to 0x078E at 0x078D // Inputs[2] // { // @0355 memory[0x40:0x60] // @0359 stack[-1] // } 0352 5B JUMPDEST 0353 60 PUSH1 0x40 0355 51 MLOAD 0356 61 PUSH2 0x035f 0359 91 SWAP2 035A 90 SWAP1 035B 61 PUSH2 0x3c7d 035E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0359 stack[-1] = 0x035f // @035A stack[1] = memory[0x40:0x60] // @035A stack[0] = stack[-1] // } // Block ends with call to 0x3c7d, returns to 0x035F label_035F: // Incoming return from call to 0x3725 at 0x03F8 // Incoming return from call to 0x3C38 at 0x0389 // Incoming return from call to 0x37C9 at 0x03D6 // Incoming return from call to 0x3C7D at 0x035E // Incoming return from call to 0x3CCE at 0x07DB // Incoming return from call to 0x3CB3 at 0x0651 // Inputs[3] // { // @0362 memory[0x40:0x60] // @0364 stack[-1] // @0367 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 035F 5B JUMPDEST 0360 60 PUSH1 0x40 0362 51 MLOAD 0363 80 DUP1 0364 91 SWAP2 0365 03 SUB 0366 90 SWAP1 0367 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0367 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0368: // Incoming jump from 0x02AC, if 0x1865c57d == stack[-1] // Inputs[1] { @0369 msg.value } 0368 5B JUMPDEST 0369 34 CALLVALUE 036A 80 DUP1 036B 15 ISZERO 036C 61 PUSH2 0x0374 036F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0369 stack[0] = msg.value } // Block ends with conditional jump to 0x0374, if !msg.value label_0370: // Incoming jump from 0x036F, if not !msg.value // Inputs[1] { @0373 memory[0x00:0x00] } 0370 60 PUSH1 0x00 0372 80 DUP1 0373 FD *REVERT // Stack delta = +0 // Outputs[1] { @0373 revert(memory[0x00:0x00]); } // Block terminates label_0374: // Incoming jump from 0x036F, if !msg.value 0374 5B JUMPDEST 0375 50 POP 0376 61 PUSH2 0x037d 0379 61 PUSH2 0x0cbb 037C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0376 stack[-1] = 0x037d } // Block ends with call to 0x0cbb, returns to 0x037D label_037D: // Incoming return from call to 0x0CBB at 0x037C // Inputs[2] // { // @0380 memory[0x40:0x60] // @0384 stack[-1] // } 037D 5B JUMPDEST 037E 60 PUSH1 0x40 0380 51 MLOAD 0381 61 PUSH2 0x035f 0384 91 SWAP2 0385 90 SWAP1 0386 61 PUSH2 0x3c38 0389 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0384 stack[-1] = 0x035f // @0385 stack[1] = memory[0x40:0x60] // @0385 stack[0] = stack[-1] // } // Block ends with call to 0x3c38, returns to 0x035F label_038A: // Incoming jump from 0x022F, if 0x2fc69ddf == stack[-1] // Inputs[1] { @038B msg.value } 038A 5B JUMPDEST 038B 34 CALLVALUE 038C 80 DUP1 038D 15 ISZERO 038E 61 PUSH2 0x0396 0391 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038B stack[0] = msg.value } // Block ends with conditional jump to 0x0396, if !msg.value label_0392: // Incoming jump from 0x0391, if not !msg.value // Inputs[1] { @0395 memory[0x00:0x00] } 0392 60 PUSH1 0x00 0394 80 DUP1 0395 FD *REVERT // Stack delta = +0 // Outputs[1] { @0395 revert(memory[0x00:0x00]); } // Block terminates label_0396: // Incoming jump from 0x0391, if !msg.value // Inputs[1] { @039E msg.data.length } 0396 5B JUMPDEST 0397 50 POP 0398 61 PUSH2 0x0352 039B 61 PUSH2 0x03a5 039E 36 CALLDATASIZE 039F 60 PUSH1 0x04 03A1 61 PUSH2 0x3655 03A4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0398 stack[-1] = 0x0352 // @039B stack[0] = 0x03a5 // @039E stack[1] = msg.data.length // @039F stack[2] = 0x04 // } // Block ends with call to 0x3655, returns to 0x03A5 label_03A5: // Incoming return from call to 0x3655 at 0x03A4 03A5 5B JUMPDEST 03A6 61 PUSH2 0x0d2a 03A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d2a label_03AA: // Incoming jump from 0x023A, if 0x332daccf == stack[-1] // Inputs[1] { @03AB msg.value } 03AA 5B JUMPDEST 03AB 34 CALLVALUE 03AC 80 DUP1 03AD 15 ISZERO 03AE 61 PUSH2 0x03b6 03B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AB stack[0] = msg.value } // Block ends with conditional jump to 0x03b6, if !msg.value label_03B2: // Incoming jump from 0x03B1, if not !msg.value // Inputs[1] { @03B5 memory[0x00:0x00] } 03B2 60 PUSH1 0x00 03B4 80 DUP1 03B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B5 revert(memory[0x00:0x00]); } // Block terminates label_03B6: // Incoming jump from 0x03B1, if !msg.value // Inputs[1] { @03BE msg.data.length } 03B6 5B JUMPDEST 03B7 50 POP 03B8 61 PUSH2 0x03ca 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x3336 03C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B8 stack[-1] = 0x03ca // @03BB stack[0] = 0x03c5 // @03BE stack[1] = msg.data.length // @03BF stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x03C5 label_03C5: // Incoming return from call to 0x3336 at 0x03C4 03C5 5B JUMPDEST 03C6 61 PUSH2 0x0d48 03C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d48 label_03CA: // Incoming return from call to 0x066D at 0x066C // Incoming return from call to 0x0477 at 0x0476 // Incoming return from call to 0x0414 at 0x0413 // Incoming return from call to 0x1858 at 0x05BA // Incoming return from call to 0x1A26 at 0x060C // Incoming return from call to 0x03C5 at 0x03C4 // Inputs[2] // { // @03CD memory[0x40:0x60] // @03D1 stack[-1] // } 03CA 5B JUMPDEST 03CB 60 PUSH1 0x40 03CD 51 MLOAD 03CE 61 PUSH2 0x035f 03D1 91 SWAP2 03D2 90 SWAP1 03D3 61 PUSH2 0x37c9 03D6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03D1 stack[-1] = 0x035f // @03D2 stack[1] = memory[0x40:0x60] // @03D2 stack[0] = stack[-1] // } // Block ends with call to 0x37c9, returns to 0x035F label_03D7: // Incoming jump from 0x0245, if 0x3fc8cef3 == stack[-1] // Inputs[1] { @03D8 msg.value } 03D7 5B JUMPDEST 03D8 34 CALLVALUE 03D9 80 DUP1 03DA 15 ISZERO 03DB 61 PUSH2 0x03e3 03DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D8 stack[0] = msg.value } // Block ends with conditional jump to 0x03e3, if !msg.value label_03DF: // Incoming jump from 0x03DE, if not !msg.value // Inputs[1] { @03E2 memory[0x00:0x00] } 03DF 60 PUSH1 0x00 03E1 80 DUP1 03E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E2 revert(memory[0x00:0x00]); } // Block terminates label_03E3: // Incoming jump from 0x03DE, if !msg.value 03E3 5B JUMPDEST 03E4 50 POP 03E5 61 PUSH2 0x03ec 03E8 61 PUSH2 0x0d6a 03EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @03E5 stack[-1] = 0x03ec } // Block ends with call to 0x0d6a, returns to 0x03EC label_03EC: // Incoming return from call to 0x0700 at 0x06FF // Incoming return from call to 0x1A17 at 0x05F7 // Incoming return from call to 0x0D6A at 0x03EB // Inputs[2] // { // @03EF memory[0x40:0x60] // @03F3 stack[-1] // } 03EC 5B JUMPDEST 03ED 60 PUSH1 0x40 03EF 51 MLOAD 03F0 61 PUSH2 0x035f 03F3 91 SWAP2 03F4 90 SWAP1 03F5 61 PUSH2 0x3725 03F8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03F3 stack[-1] = 0x035f // @03F4 stack[1] = memory[0x40:0x60] // @03F4 stack[0] = stack[-1] // } // Block ends with call to 0x3725, returns to 0x035F label_03F9: // Incoming jump from 0x0250, if 0x4048a257 == stack[-1] // Inputs[1] { @03FA msg.value } 03F9 5B JUMPDEST 03FA 34 CALLVALUE 03FB 80 DUP1 03FC 15 ISZERO 03FD 61 PUSH2 0x0405 0400 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FA stack[0] = msg.value } // Block ends with conditional jump to 0x0405, if !msg.value label_0401: // Incoming jump from 0x0400, if not !msg.value // Inputs[1] { @0404 memory[0x00:0x00] } 0401 60 PUSH1 0x00 0403 80 DUP1 0404 FD *REVERT // Stack delta = +0 // Outputs[1] { @0404 revert(memory[0x00:0x00]); } // Block terminates label_0405: // Incoming jump from 0x0400, if !msg.value // Inputs[1] { @040D msg.data.length } 0405 5B JUMPDEST 0406 50 POP 0407 61 PUSH2 0x03ca 040A 61 PUSH2 0x0414 040D 36 CALLDATASIZE 040E 60 PUSH1 0x04 0410 61 PUSH2 0x3336 0413 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0407 stack[-1] = 0x03ca // @040A stack[0] = 0x0414 // @040D stack[1] = msg.data.length // @040E stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x0414 label_0414: // Incoming return from call to 0x3336 at 0x0413 0414 5B JUMPDEST 0415 61 PUSH2 0x0d79 0418 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d79 label_0419: // Incoming jump from 0x025B, if 0x41c0e1b5 == stack[-1] // Inputs[1] { @041A msg.value } 0419 5B JUMPDEST 041A 34 CALLVALUE 041B 80 DUP1 041C 15 ISZERO 041D 61 PUSH2 0x0425 0420 57 *JUMPI // Stack delta = +1 // Outputs[1] { @041A stack[0] = msg.value } // Block ends with conditional jump to 0x0425, if !msg.value label_0421: // Incoming jump from 0x0420, if not !msg.value // Inputs[1] { @0424 memory[0x00:0x00] } 0421 60 PUSH1 0x00 0423 80 DUP1 0424 FD *REVERT // Stack delta = +0 // Outputs[1] { @0424 revert(memory[0x00:0x00]); } // Block terminates label_0425: // Incoming jump from 0x0420, if !msg.value 0425 5B JUMPDEST 0426 50 POP 0427 61 PUSH2 0x02dd 042A 61 PUSH2 0x0d8e 042D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0427 stack[-1] = 0x02dd } // Block ends with unconditional jump to 0x0d8e label_042E: // Incoming jump from 0x0266, if 0x4641257d == stack[-1] 042E 5B JUMPDEST 042F 61 PUSH2 0x02dd 0432 61 PUSH2 0x0db5 0435 56 *JUMP // Stack delta = +1 // Outputs[1] { @042F stack[0] = 0x02dd } // Block ends with call to 0x0db5, returns to 0x02DD label_0436: // Incoming jump from 0x01DD, if 0x4685903b == stack[-1] // Inputs[1] { @043D msg.data.length } 0436 5B JUMPDEST 0437 61 PUSH2 0x02dd 043A 61 PUSH2 0x0444 043D 36 CALLDATASIZE 043E 60 PUSH1 0x04 0440 61 PUSH2 0x3685 0443 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0437 stack[0] = 0x02dd // @043A stack[1] = 0x0444 // @043D stack[2] = msg.data.length // @043E stack[3] = 0x04 // } // Block ends with call to 0x3685, returns to 0x0444 label_0444: // Incoming return from call to 0x3685 at 0x0443 0444 5B JUMPDEST 0445 61 PUSH2 0x0f10 0448 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f10 label_0449: // Incoming jump from 0x01E8, if 0x47e7ef24 == stack[-1] // Inputs[1] { @0450 msg.data.length } 0449 5B JUMPDEST 044A 61 PUSH2 0x02dd 044D 61 PUSH2 0x0457 0450 36 CALLDATASIZE 0451 60 PUSH1 0x04 0453 61 PUSH2 0x34ea 0456 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @044A stack[0] = 0x02dd // @044D stack[1] = 0x0457 // @0450 stack[2] = msg.data.length // @0451 stack[3] = 0x04 // } // Block ends with call to 0x34ea, returns to 0x0457 label_0457: // Incoming return from call to 0x34EA at 0x0456 0457 5B JUMPDEST 0458 61 PUSH2 0x107f 045B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x107f label_045C: // Incoming jump from 0x01F3, if 0x4ebbc92a == stack[-1] // Inputs[1] { @045D msg.value } 045C 5B JUMPDEST 045D 34 CALLVALUE 045E 80 DUP1 045F 15 ISZERO 0460 61 PUSH2 0x0468 0463 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045D stack[0] = msg.value } // Block ends with conditional jump to 0x0468, if !msg.value label_0464: // Incoming jump from 0x0463, if not !msg.value // Inputs[1] { @0467 memory[0x00:0x00] } 0464 60 PUSH1 0x00 0466 80 DUP1 0467 FD *REVERT // Stack delta = +0 // Outputs[1] { @0467 revert(memory[0x00:0x00]); } // Block terminates label_0468: // Incoming jump from 0x0463, if !msg.value // Inputs[1] { @0470 msg.data.length } 0468 5B JUMPDEST 0469 50 POP 046A 61 PUSH2 0x03ca 046D 61 PUSH2 0x0477 0470 36 CALLDATASIZE 0471 60 PUSH1 0x04 0473 61 PUSH2 0x3655 0476 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @046A stack[-1] = 0x03ca // @046D stack[0] = 0x0477 // @0470 stack[1] = msg.data.length // @0471 stack[2] = 0x04 // } // Block ends with call to 0x3655, returns to 0x0477 label_0477: // Incoming return from call to 0x3655 at 0x0476 0477 5B JUMPDEST 0478 61 PUSH2 0x1089 047B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1089 label_047C: // Incoming jump from 0x01FE, if 0x5177fb77 == stack[-1] // Inputs[1] { @047D msg.value } 047C 5B JUMPDEST 047D 34 CALLVALUE 047E 80 DUP1 047F 15 ISZERO 0480 61 PUSH2 0x0488 0483 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047D stack[0] = msg.value } // Block ends with conditional jump to 0x0488, if !msg.value label_0484: // Incoming jump from 0x0483, if not !msg.value // Inputs[1] { @0487 memory[0x00:0x00] } 0484 60 PUSH1 0x00 0486 80 DUP1 0487 FD *REVERT // Stack delta = +0 // Outputs[1] { @0487 revert(memory[0x00:0x00]); } // Block terminates label_0488: // Incoming jump from 0x0483, if !msg.value 0488 5B JUMPDEST 0489 50 POP 048A 61 PUSH2 0x0352 048D 61 PUSH2 0x10d1 0490 56 *JUMP // Stack delta = +0 // Outputs[1] { @048A stack[-1] = 0x0352 } // Block ends with call to 0x10d1, returns to 0x0352 label_0491: // Incoming jump from 0x0209, if 0x53ccf3ae == stack[-1] // Inputs[1] { @0492 msg.value } 0491 5B JUMPDEST 0492 34 CALLVALUE 0493 80 DUP1 0494 15 ISZERO 0495 61 PUSH2 0x049d 0498 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0492 stack[0] = msg.value } // Block ends with conditional jump to 0x049d, if !msg.value label_0499: // Incoming jump from 0x0498, if not !msg.value // Inputs[1] { @049C memory[0x00:0x00] } 0499 60 PUSH1 0x00 049B 80 DUP1 049C FD *REVERT // Stack delta = +0 // Outputs[1] { @049C revert(memory[0x00:0x00]); } // Block terminates label_049D: // Incoming jump from 0x0498, if !msg.value // Inputs[1] { @04A5 msg.data.length } 049D 5B JUMPDEST 049E 50 POP 049F 61 PUSH2 0x02dd 04A2 61 PUSH2 0x04ac 04A5 36 CALLDATASIZE 04A6 60 PUSH1 0x04 04A8 61 PUSH2 0x36b4 04AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @049F stack[-1] = 0x02dd // @04A2 stack[0] = 0x04ac // @04A5 stack[1] = msg.data.length // @04A6 stack[2] = 0x04 // } // Block ends with call to 0x36b4, returns to 0x04AC label_04AC: // Incoming return from call to 0x36B4 at 0x04AB 04AC 5B JUMPDEST 04AD 61 PUSH2 0x10d7 04B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10d7 label_04B1: // Incoming jump from 0x0214, if 0x5429bd60 == stack[-1] // Inputs[1] { @04B2 msg.value } 04B1 5B JUMPDEST 04B2 34 CALLVALUE 04B3 80 DUP1 04B4 15 ISZERO 04B5 61 PUSH2 0x04bd 04B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B2 stack[0] = msg.value } // Block ends with conditional jump to 0x04bd, if !msg.value label_04B9: // Incoming jump from 0x04B8, if not !msg.value // Inputs[1] { @04BC memory[0x00:0x00] } 04B9 60 PUSH1 0x00 04BB 80 DUP1 04BC FD *REVERT // Stack delta = +0 // Outputs[1] { @04BC revert(memory[0x00:0x00]); } // Block terminates label_04BD: // Incoming jump from 0x04B8, if !msg.value // Inputs[1] { @04C5 msg.data.length } 04BD 5B JUMPDEST 04BE 50 POP 04BF 61 PUSH2 0x02dd 04C2 61 PUSH2 0x04cc 04C5 36 CALLDATASIZE 04C6 60 PUSH1 0x04 04C8 61 PUSH2 0x3336 04CB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04BF stack[-1] = 0x02dd // @04C2 stack[0] = 0x04cc // @04C5 stack[1] = msg.data.length // @04C6 stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x04CC label_04CC: // Incoming return from call to 0x3336 at 0x04CB 04CC 5B JUMPDEST 04CD 61 PUSH2 0x120a 04D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x120a label_04D1: // Incoming jump from 0x0196, if 0x56c4ff14 == stack[-1] // Inputs[1] { @04D2 msg.value } 04D1 5B JUMPDEST 04D2 34 CALLVALUE 04D3 80 DUP1 04D4 15 ISZERO 04D5 61 PUSH2 0x04dd 04D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D2 stack[0] = msg.value } // Block ends with conditional jump to 0x04dd, if !msg.value label_04D9: // Incoming jump from 0x04D8, if not !msg.value // Inputs[1] { @04DC memory[0x00:0x00] } 04D9 60 PUSH1 0x00 04DB 80 DUP1 04DC FD *REVERT // Stack delta = +0 // Outputs[1] { @04DC revert(memory[0x00:0x00]); } // Block terminates label_04DD: // Incoming jump from 0x04D8, if !msg.value // Inputs[1] { @04E5 msg.data.length } 04DD 5B JUMPDEST 04DE 50 POP 04DF 61 PUSH2 0x02dd 04E2 61 PUSH2 0x04ec 04E5 36 CALLDATASIZE 04E6 60 PUSH1 0x04 04E8 61 PUSH2 0x3591 04EB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DF stack[-1] = 0x02dd // @04E2 stack[0] = 0x04ec // @04E5 stack[1] = msg.data.length // @04E6 stack[2] = 0x04 // } // Block ends with call to 0x3591, returns to 0x04EC label_04EC: // Incoming return from call to 0x3591 at 0x04EB 04EC 5B JUMPDEST 04ED 61 PUSH2 0x1250 04F0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1250 label_04F1: // Incoming jump from 0x01A1, if 0x56e6ee6f == stack[-1] // Inputs[1] { @04F2 msg.value } 04F1 5B JUMPDEST 04F2 34 CALLVALUE 04F3 80 DUP1 04F4 15 ISZERO 04F5 61 PUSH2 0x04fd 04F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F2 stack[0] = msg.value } // Block ends with conditional jump to 0x04fd, if !msg.value label_04F9: // Incoming jump from 0x04F8, if not !msg.value // Inputs[1] { @04FC memory[0x00:0x00] } 04F9 60 PUSH1 0x00 04FB 80 DUP1 04FC FD *REVERT // Stack delta = +0 // Outputs[1] { @04FC revert(memory[0x00:0x00]); } // Block terminates label_04FD: // Incoming jump from 0x04F8, if !msg.value // Inputs[1] { @0505 msg.data.length } 04FD 5B JUMPDEST 04FE 50 POP 04FF 61 PUSH2 0x02dd 0502 61 PUSH2 0x050c 0505 36 CALLDATASIZE 0506 60 PUSH1 0x04 0508 61 PUSH2 0x3556 050B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04FF stack[-1] = 0x02dd // @0502 stack[0] = 0x050c // @0505 stack[1] = msg.data.length // @0506 stack[2] = 0x04 // } // Block ends with call to 0x3556, returns to 0x050C label_050C: // Incoming return from call to 0x3556 at 0x050B 050C 5B JUMPDEST 050D 61 PUSH2 0x1383 0510 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1383 label_0511: // Incoming jump from 0x01AC, if 0x652206f5 == stack[-1] // Inputs[1] { @0512 msg.value } 0511 5B JUMPDEST 0512 34 CALLVALUE 0513 80 DUP1 0514 15 ISZERO 0515 61 PUSH2 0x051d 0518 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0512 stack[0] = msg.value } // Block ends with conditional jump to 0x051d, if !msg.value label_0519: // Incoming jump from 0x0518, if not !msg.value // Inputs[1] { @051C memory[0x00:0x00] } 0519 60 PUSH1 0x00 051B 80 DUP1 051C FD *REVERT // Stack delta = +0 // Outputs[1] { @051C revert(memory[0x00:0x00]); } // Block terminates label_051D: // Incoming jump from 0x0518, if !msg.value // Inputs[1] { @0525 msg.data.length } 051D 5B JUMPDEST 051E 50 POP 051F 61 PUSH2 0x02dd 0522 61 PUSH2 0x052c 0525 36 CALLDATASIZE 0526 60 PUSH1 0x04 0528 61 PUSH2 0x36b4 052B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @051F stack[-1] = 0x02dd // @0522 stack[0] = 0x052c // @0525 stack[1] = msg.data.length // @0526 stack[2] = 0x04 // } // Block ends with call to 0x36b4, returns to 0x052C label_052C: // Incoming return from call to 0x36B4 at 0x052B 052C 5B JUMPDEST 052D 61 PUSH2 0x1446 0530 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1446 label_0531: // Incoming jump from 0x01B7, if 0x6fcca2e1 == stack[-1] // Inputs[1] { @0532 msg.value } 0531 5B JUMPDEST 0532 34 CALLVALUE 0533 80 DUP1 0534 15 ISZERO 0535 61 PUSH2 0x053d 0538 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0532 stack[0] = msg.value } // Block ends with conditional jump to 0x053d, if !msg.value label_0539: // Incoming jump from 0x0538, if not !msg.value // Inputs[1] { @053C memory[0x00:0x00] } 0539 60 PUSH1 0x00 053B 80 DUP1 053C FD *REVERT // Stack delta = +0 // Outputs[1] { @053C revert(memory[0x00:0x00]); } // Block terminates label_053D: // Incoming jump from 0x0538, if !msg.value // Inputs[1] { @0545 msg.data.length } 053D 5B JUMPDEST 053E 50 POP 053F 61 PUSH2 0x02dd 0542 61 PUSH2 0x054c 0545 36 CALLDATASIZE 0546 60 PUSH1 0x04 0548 61 PUSH2 0x36b4 054B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @053F stack[-1] = 0x02dd // @0542 stack[0] = 0x054c // @0545 stack[1] = msg.data.length // @0546 stack[2] = 0x04 // } // Block ends with call to 0x36b4, returns to 0x054C label_054C: // Incoming return from call to 0x36B4 at 0x054B 054C 5B JUMPDEST 054D 61 PUSH2 0x1568 0550 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1568 label_0551: // Incoming jump from 0x01C2, if 0x715018a6 == stack[-1] // Inputs[1] { @0552 msg.value } 0551 5B JUMPDEST 0552 34 CALLVALUE 0553 80 DUP1 0554 15 ISZERO 0555 61 PUSH2 0x055d 0558 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0552 stack[0] = msg.value } // Block ends with conditional jump to 0x055d, if !msg.value label_0559: // Incoming jump from 0x0558, if not !msg.value // Inputs[1] { @055C memory[0x00:0x00] } 0559 60 PUSH1 0x00 055B 80 DUP1 055C FD *REVERT // Stack delta = +0 // Outputs[1] { @055C revert(memory[0x00:0x00]); } // Block terminates label_055D: // Incoming jump from 0x0558, if !msg.value 055D 5B JUMPDEST 055E 50 POP 055F 61 PUSH2 0x02dd 0562 61 PUSH2 0x168a 0565 56 *JUMP // Stack delta = +0 // Outputs[1] { @055F stack[-1] = 0x02dd } // Block ends with call to 0x168a, returns to 0x02DD label_0566: // Incoming jump from 0x01CD, if 0x7451ea3d == stack[-1] // Inputs[1] { @0567 msg.value } 0566 5B JUMPDEST 0567 34 CALLVALUE 0568 80 DUP1 0569 15 ISZERO 056A 61 PUSH2 0x0572 056D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0567 stack[0] = msg.value } // Block ends with conditional jump to 0x0572, if !msg.value label_056E: // Incoming jump from 0x056D, if not !msg.value // Inputs[1] { @0571 memory[0x00:0x00] } 056E 60 PUSH1 0x00 0570 80 DUP1 0571 FD *REVERT // Stack delta = +0 // Outputs[1] { @0571 revert(memory[0x00:0x00]); } // Block terminates label_0572: // Incoming jump from 0x056D, if !msg.value // Inputs[1] { @057A msg.data.length } 0572 5B JUMPDEST 0573 50 POP 0574 61 PUSH2 0x02dd 0577 61 PUSH2 0x0581 057A 36 CALLDATASIZE 057B 60 PUSH1 0x04 057D 61 PUSH2 0x3556 0580 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0574 stack[-1] = 0x02dd // @0577 stack[0] = 0x0581 // @057A stack[1] = msg.data.length // @057B stack[2] = 0x04 // } // Block ends with call to 0x3556, returns to 0x0581 label_0581: // Incoming return from call to 0x3556 at 0x0580 0581 5B JUMPDEST 0582 61 PUSH2 0x16f8 0585 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16f8 label_0586: // Incoming jump from 0x0139, if 0x806ad57e == stack[-1] // Inputs[1] { @0587 msg.value } 0586 5B JUMPDEST 0587 34 CALLVALUE 0588 80 DUP1 0589 15 ISZERO 058A 61 PUSH2 0x0592 058D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0587 stack[0] = msg.value } // Block ends with conditional jump to 0x0592, if !msg.value label_058E: // Incoming jump from 0x058D, if not !msg.value // Inputs[1] { @0591 memory[0x00:0x00] } 058E 60 PUSH1 0x00 0590 80 DUP1 0591 FD *REVERT // Stack delta = +0 // Outputs[1] { @0591 revert(memory[0x00:0x00]); } // Block terminates label_0592: // Incoming jump from 0x058D, if !msg.value // Inputs[1] { @059A msg.data.length } 0592 5B JUMPDEST 0593 50 POP 0594 61 PUSH2 0x02dd 0597 61 PUSH2 0x05a1 059A 36 CALLDATASIZE 059B 60 PUSH1 0x04 059D 61 PUSH2 0x3336 05A0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0594 stack[-1] = 0x02dd // @0597 stack[0] = 0x05a1 // @059A stack[1] = msg.data.length // @059B stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x05A1 label_05A1: // Incoming return from call to 0x3336 at 0x05A0 05A1 5B JUMPDEST 05A2 61 PUSH2 0x17c4 05A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x17c4 label_05A6: // Incoming jump from 0x0144, if 0x8071ed7f == stack[-1] // Inputs[1] { @05A7 msg.value } 05A6 5B JUMPDEST 05A7 34 CALLVALUE 05A8 80 DUP1 05A9 15 ISZERO 05AA 61 PUSH2 0x05b2 05AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A7 stack[0] = msg.value } // Block ends with conditional jump to 0x05b2, if !msg.value label_05AE: // Incoming jump from 0x05AD, if not !msg.value // Inputs[1] { @05B1 memory[0x00:0x00] } 05AE 60 PUSH1 0x00 05B0 80 DUP1 05B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B1 revert(memory[0x00:0x00]); } // Block terminates label_05B2: // Incoming jump from 0x05AD, if !msg.value 05B2 5B JUMPDEST 05B3 50 POP 05B4 61 PUSH2 0x03ca 05B7 61 PUSH2 0x1858 05BA 56 *JUMP // Stack delta = +0 // Outputs[1] { @05B4 stack[-1] = 0x03ca } // Block ends with call to 0x1858, returns to 0x03CA label_05BB: // Incoming jump from 0x014F, if 0x882cf1ce == stack[-1] // Inputs[1] { @05BC msg.value } 05BB 5B JUMPDEST 05BC 34 CALLVALUE 05BD 80 DUP1 05BE 15 ISZERO 05BF 61 PUSH2 0x05c7 05C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BC stack[0] = msg.value } // Block ends with conditional jump to 0x05c7, if !msg.value label_05C3: // Incoming jump from 0x05C2, if not !msg.value // Inputs[1] { @05C6 memory[0x00:0x00] } 05C3 60 PUSH1 0x00 05C5 80 DUP1 05C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C6 revert(memory[0x00:0x00]); } // Block terminates label_05C7: // Incoming jump from 0x05C2, if !msg.value // Inputs[1] { @05CF msg.data.length } 05C7 5B JUMPDEST 05C8 50 POP 05C9 61 PUSH2 0x02dd 05CC 61 PUSH2 0x05d6 05CF 36 CALLDATASIZE 05D0 60 PUSH1 0x04 05D2 61 PUSH2 0x35d4 05D5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C9 stack[-1] = 0x02dd // @05CC stack[0] = 0x05d6 // @05CF stack[1] = msg.data.length // @05D0 stack[2] = 0x04 // } // Block ends with call to 0x35d4, returns to 0x05D6 label_05D6: // Incoming return from call to 0x35D4 at 0x05D5 05D6 5B JUMPDEST 05D7 61 PUSH2 0x1861 05DA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1861 label_05DB: // Incoming jump from 0x015A, if 0x8c5fe30b == stack[-1] 05DB 5B JUMPDEST 05DC 61 PUSH2 0x02dd 05DF 61 PUSH2 0x18db 05E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @05DC stack[0] = 0x02dd } // Block ends with call to 0x18db, returns to 0x02DD label_05E3: // Incoming jump from 0x0165, if 0x8da5cb5b == stack[-1] // Inputs[1] { @05E4 msg.value } 05E3 5B JUMPDEST 05E4 34 CALLVALUE 05E5 80 DUP1 05E6 15 ISZERO 05E7 61 PUSH2 0x05ef 05EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E4 stack[0] = msg.value } // Block ends with conditional jump to 0x05ef, if !msg.value label_05EB: // Incoming jump from 0x05EA, if not !msg.value // Inputs[1] { @05EE memory[0x00:0x00] } 05EB 60 PUSH1 0x00 05ED 80 DUP1 05EE FD *REVERT // Stack delta = +0 // Outputs[1] { @05EE revert(memory[0x00:0x00]); } // Block terminates label_05EF: // Incoming jump from 0x05EA, if !msg.value 05EF 5B JUMPDEST 05F0 50 POP 05F1 61 PUSH2 0x03ec 05F4 61 PUSH2 0x1a17 05F7 56 *JUMP // Stack delta = +0 // Outputs[1] { @05F1 stack[-1] = 0x03ec } // Block ends with call to 0x1a17, returns to 0x03EC label_05F8: // Incoming jump from 0x0170, if 0x8f32d59b == stack[-1] // Inputs[1] { @05F9 msg.value } 05F8 5B JUMPDEST 05F9 34 CALLVALUE 05FA 80 DUP1 05FB 15 ISZERO 05FC 61 PUSH2 0x0604 05FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0604, if !msg.value label_0600: // Incoming jump from 0x05FF, if not !msg.value // Inputs[1] { @0603 memory[0x00:0x00] } 0600 60 PUSH1 0x00 0602 80 DUP1 0603 FD *REVERT // Stack delta = +0 // Outputs[1] { @0603 revert(memory[0x00:0x00]); } // Block terminates label_0604: // Incoming jump from 0x05FF, if !msg.value 0604 5B JUMPDEST 0605 50 POP 0606 61 PUSH2 0x03ca 0609 61 PUSH2 0x1a26 060C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0606 stack[-1] = 0x03ca } // Block ends with call to 0x1a26, returns to 0x03CA label_060D: // Incoming jump from 0x00F2, if 0x8ff1dcf7 == stack[-1] // Inputs[1] { @060E msg.value } 060D 5B JUMPDEST 060E 34 CALLVALUE 060F 80 DUP1 0610 15 ISZERO 0611 61 PUSH2 0x0619 0614 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060E stack[0] = msg.value } // Block ends with conditional jump to 0x0619, if !msg.value label_0615: // Incoming jump from 0x0614, if not !msg.value // Inputs[1] { @0618 memory[0x00:0x00] } 0615 60 PUSH1 0x00 0617 80 DUP1 0618 FD *REVERT // Stack delta = +0 // Outputs[1] { @0618 revert(memory[0x00:0x00]); } // Block terminates label_0619: // Incoming jump from 0x0614, if !msg.value // Inputs[1] { @0621 msg.data.length } 0619 5B JUMPDEST 061A 50 POP 061B 61 PUSH2 0x02dd 061E 61 PUSH2 0x0628 0621 36 CALLDATASIZE 0622 60 PUSH1 0x04 0624 61 PUSH2 0x33fe 0627 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @061B stack[-1] = 0x02dd // @061E stack[0] = 0x0628 // @0621 stack[1] = msg.data.length // @0622 stack[2] = 0x04 // } // Block ends with call to 0x33fe, returns to 0x0628 label_0628: // Incoming return from call to 0x33FE at 0x0627 0628 5B JUMPDEST 0629 61 PUSH2 0x1a4a 062C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a4a label_062D: // Incoming jump from 0x00FD, if 0xa1c51915 == stack[-1] // Inputs[1] { @062E msg.value } 062D 5B JUMPDEST 062E 34 CALLVALUE 062F 80 DUP1 0630 15 ISZERO 0631 61 PUSH2 0x0639 0634 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062E stack[0] = msg.value } // Block ends with conditional jump to 0x0639, if !msg.value label_0635: // Incoming jump from 0x0634, if not !msg.value // Inputs[1] { @0638 memory[0x00:0x00] } 0635 60 PUSH1 0x00 0637 80 DUP1 0638 FD *REVERT // Stack delta = +0 // Outputs[1] { @0638 revert(memory[0x00:0x00]); } // Block terminates label_0639: // Incoming jump from 0x0634, if !msg.value 0639 5B JUMPDEST 063A 50 POP 063B 61 PUSH2 0x0642 063E 61 PUSH2 0x1ac7 0641 56 *JUMP // Stack delta = +0 // Outputs[1] { @063B stack[-1] = 0x0642 } // Block ends with call to 0x1ac7, returns to 0x0642 label_0642: // Incoming return from call to 0x1AC7 at 0x0641 // Inputs[5] // { // @0645 memory[0x40:0x60] // @0649 stack[-4] // @064A stack[-3] // @064B stack[-2] // @064C stack[-1] // } 0642 5B JUMPDEST 0643 60 PUSH1 0x40 0645 51 MLOAD 0646 61 PUSH2 0x035f 0649 94 SWAP5 064A 93 SWAP4 064B 92 SWAP3 064C 91 SWAP2 064D 90 SWAP1 064E 61 PUSH2 0x3cb3 0651 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0649 stack[-4] = 0x035f // @064A stack[-3] = stack[-4] // @064B stack[-2] = stack[-3] // @064C stack[-1] = stack[-2] // @064D stack[1] = memory[0x40:0x60] // @064D stack[0] = stack[-1] // } // Block ends with call to 0x3cb3, returns to 0x035F label_0652: // Incoming jump from 0x0108, if 0xaa156645 == stack[-1] // Inputs[1] { @0653 msg.value } 0652 5B JUMPDEST 0653 34 CALLVALUE 0654 80 DUP1 0655 15 ISZERO 0656 61 PUSH2 0x065e 0659 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0653 stack[0] = msg.value } // Block ends with conditional jump to 0x065e, if !msg.value label_065A: // Incoming jump from 0x0659, if not !msg.value // Inputs[1] { @065D memory[0x00:0x00] } 065A 60 PUSH1 0x00 065C 80 DUP1 065D FD *REVERT // Stack delta = +0 // Outputs[1] { @065D revert(memory[0x00:0x00]); } // Block terminates label_065E: // Incoming jump from 0x0659, if !msg.value // Inputs[1] { @0666 msg.data.length } 065E 5B JUMPDEST 065F 50 POP 0660 61 PUSH2 0x03ca 0663 61 PUSH2 0x066d 0666 36 CALLDATASIZE 0667 60 PUSH1 0x04 0669 61 PUSH2 0x3336 066C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0660 stack[-1] = 0x03ca // @0663 stack[0] = 0x066d // @0666 stack[1] = msg.data.length // @0667 stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x066D label_066D: // Incoming return from call to 0x3336 at 0x066C 066D 5B JUMPDEST 066E 61 PUSH2 0x1adb 0671 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1adb label_0672: // Incoming jump from 0x011E, if 0xc154d48d == stack[-1] // Inputs[1] { @0673 msg.value } 0672 5B JUMPDEST 0673 34 CALLVALUE 0674 80 DUP1 0675 15 ISZERO 0676 61 PUSH2 0x067e 0679 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0673 stack[0] = msg.value } // Block ends with conditional jump to 0x067e, if !msg.value label_067A: // Incoming jump from 0x0679, if not !msg.value // Inputs[1] { @067D memory[0x00:0x00] } 067A 60 PUSH1 0x00 067C 80 DUP1 067D FD *REVERT // Stack delta = +0 // Outputs[1] { @067D revert(memory[0x00:0x00]); } // Block terminates label_067E: // Incoming jump from 0x0679, if !msg.value // Inputs[1] { @0686 msg.data.length } 067E 5B JUMPDEST 067F 50 POP 0680 61 PUSH2 0x02dd 0683 61 PUSH2 0x068d 0686 36 CALLDATASIZE 0687 60 PUSH1 0x04 0689 61 PUSH2 0x3655 068C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0680 stack[-1] = 0x02dd // @0683 stack[0] = 0x068d // @0686 stack[1] = msg.data.length // @0687 stack[2] = 0x04 // } // Block ends with call to 0x3655, returns to 0x068D label_068D: // Incoming return from call to 0x3655 at 0x068C 068D 5B JUMPDEST 068E 61 PUSH2 0x1af9 0691 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1af9 label_0692: // Incoming jump from 0x0129, if 0xc4f987a5 == stack[-1] // Inputs[1] { @0693 msg.value } 0692 5B JUMPDEST 0693 34 CALLVALUE 0694 80 DUP1 0695 15 ISZERO 0696 61 PUSH2 0x069e 0699 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0693 stack[0] = msg.value } // Block ends with conditional jump to 0x069e, if !msg.value label_069A: // Incoming jump from 0x0699, if not !msg.value // Inputs[1] { @069D memory[0x00:0x00] } 069A 60 PUSH1 0x00 069C 80 DUP1 069D FD *REVERT // Stack delta = +0 // Outputs[1] { @069D revert(memory[0x00:0x00]); } // Block terminates label_069E: // Incoming jump from 0x0699, if !msg.value // Inputs[1] { @06A6 msg.data.length } 069E 5B JUMPDEST 069F 50 POP 06A0 61 PUSH2 0x02dd 06A3 61 PUSH2 0x06ad 06A6 36 CALLDATASIZE 06A7 60 PUSH1 0x04 06A9 61 PUSH2 0x3336 06AC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06A0 stack[-1] = 0x02dd // @06A3 stack[0] = 0x06ad // @06A6 stack[1] = msg.data.length // @06A7 stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x06AD label_06AD: // Incoming return from call to 0x3336 at 0x06AC 06AD 5B JUMPDEST 06AE 61 PUSH2 0x1b22 06B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b22 label_06B2: // Incoming jump from 0x00A0, if 0xcebbbf0c == stack[-1] // Inputs[1] { @06B3 msg.value } 06B2 5B JUMPDEST 06B3 34 CALLVALUE 06B4 80 DUP1 06B5 15 ISZERO 06B6 61 PUSH2 0x06be 06B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B3 stack[0] = msg.value } // Block ends with conditional jump to 0x06be, if !msg.value label_06BA: // Incoming jump from 0x06B9, if not !msg.value // Inputs[1] { @06BD memory[0x00:0x00] } 06BA 60 PUSH1 0x00 06BC 80 DUP1 06BD FD *REVERT // Stack delta = +0 // Outputs[1] { @06BD revert(memory[0x00:0x00]); } // Block terminates label_06BE: // Incoming jump from 0x06B9, if !msg.value // Inputs[1] { @06C6 msg.data.length } 06BE 5B JUMPDEST 06BF 50 POP 06C0 61 PUSH2 0x0352 06C3 61 PUSH2 0x06cd 06C6 36 CALLDATASIZE 06C7 60 PUSH1 0x04 06C9 61 PUSH2 0x336e 06CC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06C0 stack[-1] = 0x0352 // @06C3 stack[0] = 0x06cd // @06C6 stack[1] = msg.data.length // @06C7 stack[2] = 0x04 // } // Block ends with call to 0x336e, returns to 0x06CD label_06CD: // Incoming return from call to 0x336E at 0x06CC 06CD 5B JUMPDEST 06CE 61 PUSH2 0x1b8d 06D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b8d label_06D2: // Incoming jump from 0x00AB, if 0xd004f0f7 == stack[-1] // Inputs[1] { @06D9 msg.data.length } 06D2 5B JUMPDEST 06D3 61 PUSH2 0x02dd 06D6 61 PUSH2 0x06e0 06D9 36 CALLDATASIZE 06DA 60 PUSH1 0x04 06DC 61 PUSH2 0x34ea 06DF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06D3 stack[0] = 0x02dd // @06D6 stack[1] = 0x06e0 // @06D9 stack[2] = msg.data.length // @06DA stack[3] = 0x04 // } // Block ends with call to 0x34ea, returns to 0x06E0 label_06E0: // Incoming return from call to 0x34EA at 0x06DF 06E0 5B JUMPDEST 06E1 61 PUSH2 0x1bac 06E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1bac label_06E5: // Incoming jump from 0x00B6, if 0xd0d126ca == stack[-1] // Inputs[1] { @06E6 msg.value } 06E5 5B JUMPDEST 06E6 34 CALLVALUE 06E7 80 DUP1 06E8 15 ISZERO 06E9 61 PUSH2 0x06f1 06EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E6 stack[0] = msg.value } // Block ends with conditional jump to 0x06f1, if !msg.value label_06ED: // Incoming jump from 0x06EC, if not !msg.value // Inputs[1] { @06F0 memory[0x00:0x00] } 06ED 60 PUSH1 0x00 06EF 80 DUP1 06F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F0 revert(memory[0x00:0x00]); } // Block terminates label_06F1: // Incoming jump from 0x06EC, if !msg.value // Inputs[1] { @06F9 msg.data.length } 06F1 5B JUMPDEST 06F2 50 POP 06F3 61 PUSH2 0x03ec 06F6 61 PUSH2 0x0700 06F9 36 CALLDATASIZE 06FA 60 PUSH1 0x04 06FC 61 PUSH2 0x34ea 06FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06F3 stack[-1] = 0x03ec // @06F6 stack[0] = 0x0700 // @06F9 stack[1] = msg.data.length // @06FA stack[2] = 0x04 // } // Block ends with call to 0x34ea, returns to 0x0700 label_0700: // Incoming return from call to 0x34EA at 0x06FF 0700 5B JUMPDEST 0701 61 PUSH2 0x1c95 0704 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1c95 label_0705: // Incoming jump from 0x00C1, if 0xd1f4ba82 == stack[-1] 0705 5B JUMPDEST 0706 61 PUSH2 0x02dd 0709 61 PUSH2 0x1cba 070C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0706 stack[0] = 0x02dd } // Block ends with call to 0x1cba, returns to 0x02DD label_070D: // Incoming jump from 0x00CC, if 0xdbba0f01 == stack[-1] // Inputs[1] { @070E msg.value } 070D 5B JUMPDEST 070E 34 CALLVALUE 070F 80 DUP1 0710 15 ISZERO 0711 61 PUSH2 0x0719 0714 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070E stack[0] = msg.value } // Block ends with conditional jump to 0x0719, if !msg.value label_0715: // Incoming jump from 0x0714, if not !msg.value // Inputs[1] { @0718 memory[0x00:0x00] } 0715 60 PUSH1 0x00 0717 80 DUP1 0718 FD *REVERT // Stack delta = +0 // Outputs[1] { @0718 revert(memory[0x00:0x00]); } // Block terminates label_0719: // Incoming jump from 0x0714, if !msg.value // Inputs[1] { @0721 msg.data.length } 0719 5B JUMPDEST 071A 50 POP 071B 61 PUSH2 0x02dd 071E 61 PUSH2 0x0728 0721 36 CALLDATASIZE 0722 60 PUSH1 0x04 0724 61 PUSH2 0x3515 0727 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @071B stack[-1] = 0x02dd // @071E stack[0] = 0x0728 // @0721 stack[1] = msg.data.length // @0722 stack[2] = 0x04 // } // Block ends with call to 0x3515, returns to 0x0728 label_0728: // Incoming return from call to 0x3515 at 0x0727 0728 5B JUMPDEST 0729 61 PUSH2 0x1d89 072C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d89 label_072D: // Incoming jump from 0x00D7, if 0xdbf616fa == stack[-1] // Inputs[1] { @0734 msg.data.length } 072D 5B JUMPDEST 072E 61 PUSH2 0x0352 0731 61 PUSH2 0x073b 0734 36 CALLDATASIZE 0735 60 PUSH1 0x04 0737 61 PUSH2 0x34ea 073A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @072E stack[0] = 0x0352 // @0731 stack[1] = 0x073b // @0734 stack[2] = msg.data.length // @0735 stack[3] = 0x04 // } // Block ends with call to 0x34ea, returns to 0x073B label_073B: // Incoming return from call to 0x34EA at 0x073A 073B 5B JUMPDEST 073C 61 PUSH2 0x1ef5 073F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1ef5 label_0740: // Incoming jump from 0x007A, if 0xdd73b576 == stack[-1] // Inputs[1] { @0747 msg.data.length } 0740 5B JUMPDEST 0741 61 PUSH2 0x02dd 0744 61 PUSH2 0x074e 0747 36 CALLDATASIZE 0748 60 PUSH1 0x04 074A 61 PUSH2 0x3655 074D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0741 stack[0] = 0x02dd // @0744 stack[1] = 0x074e // @0747 stack[2] = msg.data.length // @0748 stack[3] = 0x04 // } // Block ends with call to 0x3655, returns to 0x074E label_074E: // Incoming return from call to 0x3655 at 0x074D 074E 5B JUMPDEST 074F 61 PUSH2 0x2007 0752 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2007 label_0753: // Incoming jump from 0x0085, if 0xe1f21c67 == stack[-1] // Inputs[1] { @0754 msg.value } 0753 5B JUMPDEST 0754 34 CALLVALUE 0755 80 DUP1 0756 15 ISZERO 0757 61 PUSH2 0x075f 075A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0754 stack[0] = msg.value } // Block ends with conditional jump to 0x075f, if !msg.value label_075B: // Incoming jump from 0x075A, if not !msg.value // Inputs[1] { @075E memory[0x00:0x00] } 075B 60 PUSH1 0x00 075D 80 DUP1 075E FD *REVERT // Stack delta = +0 // Outputs[1] { @075E revert(memory[0x00:0x00]); } // Block terminates label_075F: // Incoming jump from 0x075A, if !msg.value // Inputs[1] { @0767 msg.data.length } 075F 5B JUMPDEST 0760 50 POP 0761 61 PUSH2 0x02dd 0764 61 PUSH2 0x076e 0767 36 CALLDATASIZE 0768 60 PUSH1 0x04 076A 61 PUSH2 0x33be 076D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0761 stack[-1] = 0x02dd // @0764 stack[0] = 0x076e // @0767 stack[1] = msg.data.length // @0768 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x33be 076E 5B JUMPDEST 076F 61 PUSH2 0x2151 0772 56 *JUMP label_0773: // Incoming jump from 0x0090, if 0xe3d670d7 == stack[-1] // Inputs[1] { @0774 msg.value } 0773 5B JUMPDEST 0774 34 CALLVALUE 0775 80 DUP1 0776 15 ISZERO 0777 61 PUSH2 0x077f 077A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0774 stack[0] = msg.value } // Block ends with conditional jump to 0x077f, if !msg.value label_077B: // Incoming jump from 0x077A, if not !msg.value // Inputs[1] { @077E memory[0x00:0x00] } 077B 60 PUSH1 0x00 077D 80 DUP1 077E FD *REVERT // Stack delta = +0 // Outputs[1] { @077E revert(memory[0x00:0x00]); } // Block terminates label_077F: // Incoming jump from 0x077A, if !msg.value // Inputs[1] { @0787 msg.data.length } 077F 5B JUMPDEST 0780 50 POP 0781 61 PUSH2 0x0352 0784 61 PUSH2 0x078e 0787 36 CALLDATASIZE 0788 60 PUSH1 0x04 078A 61 PUSH2 0x3336 078D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0781 stack[-1] = 0x0352 // @0784 stack[0] = 0x078e // @0787 stack[1] = msg.data.length // @0788 stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x078E label_078E: // Incoming return from call to 0x3336 at 0x078D 078E 5B JUMPDEST 078F 61 PUSH2 0x2213 0792 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2213 label_0793: // Incoming jump from 0x0049, if 0xe59a2ca4 == stack[-1] // Inputs[1] { @0794 msg.value } 0793 5B JUMPDEST 0794 34 CALLVALUE 0795 80 DUP1 0796 15 ISZERO 0797 61 PUSH2 0x079f 079A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0794 stack[0] = msg.value } // Block ends with conditional jump to 0x079f, if !msg.value label_079B: // Incoming jump from 0x079A, if not !msg.value // Inputs[1] { @079E memory[0x00:0x00] } 079B 60 PUSH1 0x00 079D 80 DUP1 079E FD *REVERT // Stack delta = +0 // Outputs[1] { @079E revert(memory[0x00:0x00]); } // Block terminates label_079F: // Incoming jump from 0x079A, if !msg.value // Inputs[1] { @07A7 msg.data.length } 079F 5B JUMPDEST 07A0 50 POP 07A1 61 PUSH2 0x02dd 07A4 61 PUSH2 0x07ae 07A7 36 CALLDATASIZE 07A8 60 PUSH1 0x04 07AA 61 PUSH2 0x3655 07AD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07A1 stack[-1] = 0x02dd // @07A4 stack[0] = 0x07ae // @07A7 stack[1] = msg.data.length // @07A8 stack[2] = 0x04 // } // Block ends with call to 0x3655, returns to 0x07AE label_07AE: // Incoming return from call to 0x3655 at 0x07AD 07AE 5B JUMPDEST 07AF 61 PUSH2 0x22ad 07B2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x22ad label_07B3: // Incoming jump from 0x0054, if 0xe61c23e8 == stack[-1] // Inputs[1] { @07B4 msg.value } 07B3 5B JUMPDEST 07B4 34 CALLVALUE 07B5 80 DUP1 07B6 15 ISZERO 07B7 61 PUSH2 0x07bf 07BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07B4 stack[0] = msg.value } // Block ends with conditional jump to 0x07bf, if !msg.value label_07BB: // Incoming jump from 0x07BA, if not !msg.value // Inputs[1] { @07BE memory[0x00:0x00] } 07BB 60 PUSH1 0x00 07BD 80 DUP1 07BE FD *REVERT // Stack delta = +0 // Outputs[1] { @07BE revert(memory[0x00:0x00]); } // Block terminates label_07BF: // Incoming jump from 0x07BA, if !msg.value 07BF 5B JUMPDEST 07C0 50 POP 07C1 61 PUSH2 0x07c8 07C4 61 PUSH2 0x22d6 07C7 56 *JUMP // Stack delta = +0 // Outputs[1] { @07C1 stack[-1] = 0x07c8 } // Block ends with call to 0x22d6, returns to 0x07C8 label_07C8: // Incoming return from call to 0x22D6 at 0x07C7 // Inputs[9] // { // @07CB memory[0x40:0x60] // @07CF stack[-8] // @07D0 stack[-7] // @07D1 stack[-6] // @07D2 stack[-5] // @07D3 stack[-4] // @07D4 stack[-3] // @07D5 stack[-2] // @07D6 stack[-1] // } 07C8 5B JUMPDEST 07C9 60 PUSH1 0x40 07CB 51 MLOAD 07CC 61 PUSH2 0x035f 07CF 98 SWAP9 07D0 97 SWAP8 07D1 96 SWAP7 07D2 95 SWAP6 07D3 94 SWAP5 07D4 93 SWAP4 07D5 92 SWAP3 07D6 91 SWAP2 07D7 90 SWAP1 07D8 61 PUSH2 0x3cce 07DB 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @07CF stack[-8] = 0x035f // @07D0 stack[-7] = stack[-8] // @07D1 stack[-6] = stack[-7] // @07D2 stack[-5] = stack[-6] // @07D3 stack[-4] = stack[-5] // @07D4 stack[-3] = stack[-4] // @07D5 stack[-2] = stack[-3] // @07D6 stack[-1] = stack[-2] // @07D7 stack[1] = memory[0x40:0x60] // @07D7 stack[0] = stack[-1] // } // Block ends with call to 0x3cce, returns to 0x035F label_07DC: // Incoming jump from 0x005F, if 0xf21cbaf4 == stack[-1] // Inputs[1] { @07DD msg.value } 07DC 5B JUMPDEST 07DD 34 CALLVALUE 07DE 80 DUP1 07DF 15 ISZERO 07E0 61 PUSH2 0x07e8 07E3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07DD stack[0] = msg.value } // Block ends with conditional jump to 0x07e8, if !msg.value label_07E4: // Incoming jump from 0x07E3, if not !msg.value // Inputs[1] { @07E7 memory[0x00:0x00] } 07E4 60 PUSH1 0x00 07E6 80 DUP1 07E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E7 revert(memory[0x00:0x00]); } // Block terminates label_07E8: // Incoming jump from 0x07E3, if !msg.value // Inputs[1] { @07F0 msg.data.length } 07E8 5B JUMPDEST 07E9 50 POP 07EA 61 PUSH2 0x02dd 07ED 61 PUSH2 0x07f7 07F0 36 CALLDATASIZE 07F1 60 PUSH1 0x04 07F3 61 PUSH2 0x35d4 07F6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07EA stack[-1] = 0x02dd // @07ED stack[0] = 0x07f7 // @07F0 stack[1] = msg.data.length // @07F1 stack[2] = 0x04 // } // Block ends with call to 0x35d4, returns to 0x07F7 label_07F7: // Incoming return from call to 0x35D4 at 0x07F6 07F7 5B JUMPDEST 07F8 61 PUSH2 0x265f 07FB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x265f label_07FC: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @07FD msg.value } 07FC 5B JUMPDEST 07FD 34 CALLVALUE 07FE 80 DUP1 07FF 15 ISZERO 0800 61 PUSH2 0x0808 0803 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07FD stack[0] = msg.value } // Block ends with conditional jump to 0x0808, if !msg.value label_0804: // Incoming jump from 0x0803, if not !msg.value // Inputs[1] { @0807 memory[0x00:0x00] } 0804 60 PUSH1 0x00 0806 80 DUP1 0807 FD *REVERT // Stack delta = +0 // Outputs[1] { @0807 revert(memory[0x00:0x00]); } // Block terminates label_0808: // Incoming jump from 0x0803, if !msg.value // Inputs[1] { @0810 msg.data.length } 0808 5B JUMPDEST 0809 50 POP 080A 61 PUSH2 0x02dd 080D 61 PUSH2 0x0817 0810 36 CALLDATASIZE 0811 60 PUSH1 0x04 0813 61 PUSH2 0x3336 0816 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @080A stack[-1] = 0x02dd // @080D stack[0] = 0x0817 // @0810 stack[1] = msg.data.length // @0811 stack[2] = 0x04 // } // Block ends with call to 0x3336, returns to 0x0817 label_0817: // Incoming return from call to 0x3336 at 0x0816 0817 5B JUMPDEST 0818 61 PUSH2 0x2696 081B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2696 label_081C: // Incoming call from 0x1003, returns to 0x1004 // Incoming jump from 0x02DC 081C 5B JUMPDEST 081D 61 PUSH2 0x0824 0820 61 PUSH2 0x1a26 0823 56 *JUMP // Stack delta = +1 // Outputs[1] { @081D stack[0] = 0x0824 } // Block ends with call to 0x1a26, returns to 0x0824 label_0824: // Incoming return from call to 0x1A26 at 0x0823 // Inputs[1] { @0828 stack[-1] } 0824 5B JUMPDEST 0825 61 PUSH2 0x0849 0828 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0849, if stack[-1] label_0829: // Incoming jump from 0x0828, if not stack[-1] // Inputs[1] { @082B memory[0x40:0x60] } 0829 60 PUSH1 0x40 082B 51 MLOAD 082C 62 PUSH3 0x461bcd 0830 60 PUSH1 0xe5 0832 1B SHL 0833 81 DUP2 0834 52 MSTORE 0835 60 PUSH1 0x04 0837 01 ADD 0838 61 PUSH2 0x0840 083B 90 SWAP1 083C 61 PUSH2 0x3a86 083F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0834 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @083B stack[0] = 0x0840 // @083B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0840: // Incoming return from call to 0x3A86 at 0x0F33 // Incoming return from call to 0x3A86 at 0x17E7 // Incoming return from call to 0x3855 at 0x2F4E // Incoming return from call to 0x3ADC at 0x1E50 // Incoming return from call to 0x3B3B at 0x1B6B // Incoming return from call to 0x3ADC at 0x0A94 // Incoming return from call to 0x3A86 at 0x1A6D // Incoming return from call to 0x399A at 0x0E1B // Incoming return from call to 0x3A86 at 0x1469 // Incoming return from call to 0x3A86 at 0x0DB1 // Incoming return from call to 0x3955 at 0x2FDE // Incoming return from call to 0x3A86 at 0x22D0 // Incoming return from call to 0x38D2 at 0x2B7E // Incoming return from call to 0x3B04 at 0x302C // Incoming return from call to 0x3A86 at 0x1273 // Incoming return from call to 0x399A at 0x175E // Incoming return from call to 0x3B3B at 0x0B16 // Incoming return from call to 0x3A86 at 0x16AD // Incoming return from call to 0x399A at 0x0BD0 // Incoming return from call to 0x3A86 at 0x0CE6 // Incoming return from call to 0x3A86 at 0x122D // Incoming return from call to 0x399A at 0x1C12 // Incoming return from call to 0x3A86 at 0x26B9 // Incoming return from call to 0x3A86 at 0x2682 // Incoming return from call to 0x399A at 0x1D20 // Incoming return from call to 0x3A86 at 0x1B1C // Incoming return from call to 0x3ABB at 0x20E5 // Incoming return from call to 0x3ABB at 0x0E96 // Incoming return from call to 0x3A45 at 0x306D // Incoming return from call to 0x381E at 0x2A3F // Incoming return from call to 0x389B at 0x3099 // Incoming return from call to 0x3A86 at 0x0ABF // Incoming return from call to 0x399A at 0x13E9 // Incoming return from call to 0x37E7 at 0x29F2 // Incoming return from call to 0x3ADC at 0x09B0 // Incoming return from call to 0x3BED at 0x27B2 // Incoming return from call to 0x399A at 0x1F5C // Incoming return from call to 0x39FD at 0x27DE // Incoming return from call to 0x399A at 0x1941 // Incoming return from call to 0x39FD at 0x2BAA // Incoming return from call to 0x3A86 at 0x158B // Incoming return from call to 0x3ADC at 0x1379 // Incoming return from call to 0x3A86 at 0x0C72 // Incoming return from call to 0x3A86 at 0x10FA // Incoming return from call to 0x399A at 0x18C7 // Incoming return from call to 0x399A at 0x206D // Incoming return from call to 0x3B3B at 0x180D // Incoming return from call to 0x3A86 at 0x1DAC // Incoming return from call to 0x3A86 at 0x1B45 // Incoming return from call to 0x39D1 at 0x0C4E // Incoming return from call to 0x3BA9 at 0x3182 // Incoming return from call to 0x3A86 at 0x083F // Inputs[3] // { // @0843 memory[0x40:0x60] // @0845 stack[-1] // @0848 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0840 5B JUMPDEST 0841 60 PUSH1 0x40 0843 51 MLOAD 0844 80 DUP1 0845 91 SWAP2 0846 03 SUB 0847 90 SWAP1 0848 FD *REVERT // Stack delta = -1 // Outputs[1] { @0848 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0849: // Incoming jump from 0x0828, if stack[-1] // Inputs[3] // { // @084C storage[0x02] // @084F memory[0x40:0x60] // @0871 address(this) // } 0849 5B JUMPDEST 084A 60 PUSH1 0x02 084C 54 SLOAD 084D 60 PUSH1 0x40 084F 51 MLOAD 0850 63 PUSH4 0x70a08231 0855 60 PUSH1 0xe0 0857 1B SHL 0858 81 DUP2 0859 52 MSTORE 085A 60 PUSH1 0x00 085C 91 SWAP2 085D 60 PUSH1 0x01 085F 60 PUSH1 0x01 0861 60 PUSH1 0xa0 0863 1B SHL 0864 03 SUB 0865 16 AND 0866 90 SWAP1 0867 63 PUSH4 0x70a08231 086C 90 SWAP1 086D 61 PUSH2 0x087a 0870 90 SWAP1 0871 30 ADDRESS 0872 90 SWAP1 0873 60 PUSH1 0x04 0875 01 ADD 0876 61 PUSH2 0x3725 0879 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @0859 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @085C stack[0] = 0x00 // @0866 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x02] // @086C stack[2] = 0x70a08231 // @0870 stack[3] = 0x087a // @0872 stack[4] = address(this) // @0875 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x087A label_087A: // Incoming return from call to 0x3725 at 0x0879 // Inputs[4] // { // @087F memory[0x40:0x60] // @0881 stack[-1] // @0884 stack[-3] // @0886 address(stack[-3]).code.length // } 087A 5B JUMPDEST 087B 60 PUSH1 0x20 087D 60 PUSH1 0x40 087F 51 MLOAD 0880 80 DUP1 0881 83 DUP4 0882 03 SUB 0883 81 DUP2 0884 86 DUP7 0885 80 DUP1 0886 3B EXTCODESIZE 0887 15 ISZERO 0888 80 DUP1 0889 15 ISZERO 088A 61 PUSH2 0x0892 088D 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @087B stack[0] = 0x20 // @087F stack[1] = memory[0x40:0x60] // @0882 stack[2] = stack[-1] - memory[0x40:0x60] // @0883 stack[3] = memory[0x40:0x60] // @0884 stack[4] = stack[-3] // @0887 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0892, if !!address(stack[-3]).code.length label_088E: // Incoming jump from 0x088D, if not !!address(stack[-3]).code.length // Inputs[1] { @0891 memory[0x00:0x00] } 088E 60 PUSH1 0x00 0890 80 DUP1 0891 FD *REVERT // Stack delta = +0 // Outputs[1] { @0891 revert(memory[0x00:0x00]); } // Block terminates label_0892: // Incoming jump from 0x088D, if !!address(stack[-3]).code.length // Inputs[8] // { // @0894 msg.gas // @0895 stack[-2] // @0895 stack[-6] // @0895 memory[stack[-3]:stack[-3] + stack[-4]] // @0895 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0895 stack[-5] // @0895 stack[-3] // @0895 stack[-4] // } 0892 5B JUMPDEST 0893 50 POP 0894 5A GAS 0895 FA STATICCALL 0896 15 ISZERO 0897 80 DUP1 0898 15 ISZERO 0899 61 PUSH2 0x08a6 089C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0895 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0896 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x08a6, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_089D: // Incoming jump from 0x089C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @089D returndata.length // @08A1 returndata[0x00:0x00 + returndata.length] // @08A2 returndata.length // @08A5 memory[0x00:0x00 + returndata.length] // } 089D 3D RETURNDATASIZE 089E 60 PUSH1 0x00 08A0 80 DUP1 08A1 3E RETURNDATACOPY 08A2 3D RETURNDATASIZE 08A3 60 PUSH1 0x00 08A5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08A1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08A5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_08A6: // Incoming jump from 0x089C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @08AD memory[0x40:0x60] // @08AE returndata.length // } 08A6 5B JUMPDEST 08A7 50 POP 08A8 50 POP 08A9 50 POP 08AA 50 POP 08AB 60 PUSH1 0x40 08AD 51 MLOAD 08AE 3D RETURNDATASIZE 08AF 60 PUSH1 0x1f 08B1 19 NOT 08B2 60 PUSH1 0x1f 08B4 82 DUP3 08B5 01 ADD 08B6 16 AND 08B7 82 DUP3 08B8 01 ADD 08B9 80 DUP1 08BA 60 PUSH1 0x40 08BC 52 MSTORE 08BD 50 POP 08BE 81 DUP2 08BF 01 ADD 08C0 90 SWAP1 08C1 61 PUSH2 0x08ca 08C4 91 SWAP2 08C5 90 SWAP1 08C6 61 PUSH2 0x366d 08C9 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @08BC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @08C4 stack[-4] = 0x08ca // @08C5 stack[-2] = memory[0x40:0x60] // @08C5 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x08CA label_08CA: // Incoming return from call to 0x366D at 0x08C9 // Inputs[3] // { // @08CB stack[-2] // @08CB stack[-1] // @08CD stack[-4] // } 08CA 5B JUMPDEST 08CB 90 SWAP1 08CC 50 POP 08CD 82 DUP3 08CE 81 DUP2 08CF 10 LT 08D0 61 PUSH2 0x09b7 08D3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @08CB stack[-2] = stack[-1] } // Block ends with conditional jump to 0x09b7, if stack[-1] < stack[-4] label_08D4: // Incoming jump from 0x08D3, if not stack[-1] < stack[-4] // Inputs[3] // { // @08D6 storage[0x02] // @08D9 memory[0x40:0x60] // @08FA stack[-3] // } 08D4 60 PUSH1 0x02 08D6 54 SLOAD 08D7 60 PUSH1 0x40 08D9 51 MLOAD 08DA 63 PUSH4 0x2e1a7d4d 08DF 60 PUSH1 0xe0 08E1 1B SHL 08E2 81 DUP2 08E3 52 MSTORE 08E4 60 PUSH1 0x01 08E6 60 PUSH1 0x01 08E8 60 PUSH1 0xa0 08EA 1B SHL 08EB 03 SUB 08EC 90 SWAP1 08ED 91 SWAP2 08EE 16 AND 08EF 90 SWAP1 08F0 63 PUSH4 0x2e1a7d4d 08F5 90 SWAP1 08F6 61 PUSH2 0x0903 08F9 90 SWAP1 08FA 86 DUP7 08FB 90 SWAP1 08FC 60 PUSH1 0x04 08FE 01 ADD 08FF 61 PUSH2 0x3c7d 0902 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @08E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e1a7d4d << 0xe0 // @08EF stack[0] = storage[0x02] & (0x01 << 0xa0) - 0x01 // @08F5 stack[1] = 0x2e1a7d4d // @08F9 stack[2] = 0x0903 // @08FB stack[3] = stack[-3] // @08FE stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3c7d, returns to 0x0903 label_0903: // Incoming return from call to 0x3C7D at 0x0902 // Inputs[4] // { // @0908 memory[0x40:0x60] // @090A stack[-1] // @090F stack[-3] // @0911 address(stack[-3]).code.length // } 0903 5B JUMPDEST 0904 60 PUSH1 0x00 0906 60 PUSH1 0x40 0908 51 MLOAD 0909 80 DUP1 090A 83 DUP4 090B 03 SUB 090C 81 DUP2 090D 60 PUSH1 0x00 090F 87 DUP8 0910 80 DUP1 0911 3B EXTCODESIZE 0912 15 ISZERO 0913 80 DUP1 0914 15 ISZERO 0915 61 PUSH2 0x091d 0918 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0904 stack[0] = 0x00 // @0908 stack[1] = memory[0x40:0x60] // @090B stack[2] = stack[-1] - memory[0x40:0x60] // @090C stack[3] = memory[0x40:0x60] // @090D stack[4] = 0x00 // @090F stack[5] = stack[-3] // @0912 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x091d, if !!address(stack[-3]).code.length label_0919: // Incoming jump from 0x0918, if not !!address(stack[-3]).code.length // Inputs[1] { @091C memory[0x00:0x00] } 0919 60 PUSH1 0x00 091B 80 DUP1 091C FD *REVERT // Stack delta = +0 // Outputs[1] { @091C revert(memory[0x00:0x00]); } // Block terminates label_091D: // Incoming jump from 0x0918, if !!address(stack[-3]).code.length // Inputs[9] // { // @091F msg.gas // @0920 stack[-4] // @0920 stack[-3] // @0920 stack[-2] // @0920 memory[stack[-4]:stack[-4] + stack[-5]] // @0920 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0920 stack[-6] // @0920 stack[-7] // @0920 stack[-5] // } 091D 5B JUMPDEST 091E 50 POP 091F 5A GAS 0920 F1 CALL 0921 15 ISZERO 0922 80 DUP1 0923 15 ISZERO 0924 61 PUSH2 0x0931 0927 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0920 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0921 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0931, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0928: // Incoming jump from 0x0927, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0928 returndata.length // @092C returndata[0x00:0x00 + returndata.length] // @092D returndata.length // @0930 memory[0x00:0x00 + returndata.length] // } 0928 3D RETURNDATASIZE 0929 60 PUSH1 0x00 092B 80 DUP1 092C 3E RETURNDATACOPY 092D 3D RETURNDATASIZE 092E 60 PUSH1 0x00 0930 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @092C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0930 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0931: // Incoming jump from 0x0927, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @0938 stack[-6] // @0942 stack[-7] // @0945 memory[0x40:0x60] // } 0931 5B JUMPDEST 0932 50 POP 0933 50 POP 0934 50 POP 0935 50 POP 0936 60 PUSH1 0x00 0938 82 DUP3 0939 60 PUSH1 0x01 093B 60 PUSH1 0x01 093D 60 PUSH1 0xa0 093F 1B SHL 0940 03 SUB 0941 16 AND 0942 84 DUP5 0943 60 PUSH1 0x40 0945 51 MLOAD 0946 61 PUSH2 0x094e 0949 90 SWAP1 094A 61 PUSH2 0x3722 094D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0936 stack[-4] = 0x00 // @0941 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0942 stack[-2] = stack[-7] // @0949 stack[-1] = 0x094e // @0949 stack[0] = memory[0x40:0x60] // } // Block ends with call to 0x3722, returns to 0x094E label_094E: // Incoming return from call to 0x3722 at 0x094D // Inputs[8] // { // @0953 memory[0x40:0x60] // @0955 stack[-1] // @0958 stack[-2] // @0959 stack[-3] // @095A msg.gas // @095B address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @095B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0960 returndata.length // } 094E 5B JUMPDEST 094F 60 PUSH1 0x00 0951 60 PUSH1 0x40 0953 51 MLOAD 0954 80 DUP1 0955 83 DUP4 0956 03 SUB 0957 81 DUP2 0958 85 DUP6 0959 87 DUP8 095A 5A GAS 095B F1 CALL 095C 92 SWAP3 095D 50 POP 095E 50 POP 095F 50 POP 0960 3D RETURNDATASIZE 0961 80 DUP1 0962 60 PUSH1 0x00 0964 81 DUP2 0965 14 EQ 0966 61 PUSH2 0x098b 0969 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @095B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @095C stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0960 stack[-2] = returndata.length // @0961 stack[-1] = returndata.length // } // Block ends with conditional jump to 0x098b, if returndata.length == 0x00 label_096A: // Incoming jump from 0x0969, if not returndata.length == 0x00 // Inputs[6] // { // @096C memory[0x40:0x60] // @096D stack[-2] // @0974 returndata.length // @097C returndata.length // @097F returndata.length // @0986 returndata[0x00:0x00 + returndata.length] // } 096A 60 PUSH1 0x40 096C 51 MLOAD 096D 91 SWAP2 096E 50 POP 096F 60 PUSH1 0x1f 0971 19 NOT 0972 60 PUSH1 0x3f 0974 3D RETURNDATASIZE 0975 01 ADD 0976 16 AND 0977 82 DUP3 0978 01 ADD 0979 60 PUSH1 0x40 097B 52 MSTORE 097C 3D RETURNDATASIZE 097D 82 DUP3 097E 52 MSTORE 097F 3D RETURNDATASIZE 0980 60 PUSH1 0x00 0982 60 PUSH1 0x20 0984 84 DUP5 0985 01 ADD 0986 3E RETURNDATACOPY 0987 61 PUSH2 0x0990 098A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @096D stack[-2] = memory[0x40:0x60] // @097B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @097E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0986 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0990 label_098B: // Incoming jump from 0x0969, if returndata.length == 0x00 // Inputs[3] // { // @098E stack[-2] // @0993 stack[-3] // @0993 stack[-4] // } 098B 5B JUMPDEST 098C 60 PUSH1 0x60 098E 91 SWAP2 098F 50 POP 0990 5B JUMPDEST 0991 50 POP 0992 50 POP 0993 90 SWAP1 0994 50 POP 0995 80 DUP1 0996 61 PUSH2 0x09b1 0999 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0993 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x09b1, if stack[-3] label_099A: // Incoming jump from 0x0999, if not stack[-3] // Incoming jump from 0x0999, if not stack[-3] // Inputs[1] { @099C memory[0x40:0x60] } 099A 60 PUSH1 0x40 099C 51 MLOAD 099D 62 PUSH3 0x461bcd 09A1 60 PUSH1 0xe5 09A3 1B SHL 09A4 81 DUP2 09A5 52 MSTORE 09A6 60 PUSH1 0x04 09A8 01 ADD 09A9 61 PUSH2 0x0840 09AC 90 SWAP1 09AD 61 PUSH2 0x3adc 09B0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09AC stack[0] = 0x0840 // @09AC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3adc, returns to 0x0840 label_09B1: // Incoming jump from 0x0999, if stack[-3] // Incoming jump from 0x0999, if stack[-3] 09B1 5B JUMPDEST 09B2 50 POP 09B3 61 PUSH2 0x0a97 09B6 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0a97 label_09B7: // Incoming jump from 0x08D3, if stack[-1] < stack[-4] // Inputs[3] // { // @09BA storage[0x02] // @09BD memory[0x40:0x60] // @09DE stack[-1] // } 09B7 5B JUMPDEST 09B8 60 PUSH1 0x02 09BA 54 SLOAD 09BB 60 PUSH1 0x40 09BD 51 MLOAD 09BE 63 PUSH4 0x2e1a7d4d 09C3 60 PUSH1 0xe0 09C5 1B SHL 09C6 81 DUP2 09C7 52 MSTORE 09C8 60 PUSH1 0x01 09CA 60 PUSH1 0x01 09CC 60 PUSH1 0xa0 09CE 1B SHL 09CF 03 SUB 09D0 90 SWAP1 09D1 91 SWAP2 09D2 16 AND 09D3 90 SWAP1 09D4 63 PUSH4 0x2e1a7d4d 09D9 90 SWAP1 09DA 61 PUSH2 0x09e7 09DD 90 SWAP1 09DE 84 DUP5 09DF 90 SWAP1 09E0 60 PUSH1 0x04 09E2 01 ADD 09E3 61 PUSH2 0x3c7d 09E6 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @09C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e1a7d4d << 0xe0 // @09D3 stack[0] = storage[0x02] & (0x01 << 0xa0) - 0x01 // @09D9 stack[1] = 0x2e1a7d4d // @09DD stack[2] = 0x09e7 // @09DF stack[3] = stack[-1] // @09E2 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3c7d, returns to 0x09E7 label_09E7: // Incoming return from call to 0x3C7D at 0x09E6 // Inputs[4] // { // @09EC memory[0x40:0x60] // @09EE stack[-1] // @09F3 stack[-3] // @09F5 address(stack[-3]).code.length // } 09E7 5B JUMPDEST 09E8 60 PUSH1 0x00 09EA 60 PUSH1 0x40 09EC 51 MLOAD 09ED 80 DUP1 09EE 83 DUP4 09EF 03 SUB 09F0 81 DUP2 09F1 60 PUSH1 0x00 09F3 87 DUP8 09F4 80 DUP1 09F5 3B EXTCODESIZE 09F6 15 ISZERO 09F7 80 DUP1 09F8 15 ISZERO 09F9 61 PUSH2 0x0a01 09FC 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @09E8 stack[0] = 0x00 // @09EC stack[1] = memory[0x40:0x60] // @09EF stack[2] = stack[-1] - memory[0x40:0x60] // @09F0 stack[3] = memory[0x40:0x60] // @09F1 stack[4] = 0x00 // @09F3 stack[5] = stack[-3] // @09F6 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0a01, if !!address(stack[-3]).code.length label_09FD: // Incoming jump from 0x09FC, if not !!address(stack[-3]).code.length // Inputs[1] { @0A00 memory[0x00:0x00] } 09FD 60 PUSH1 0x00 09FF 80 DUP1 0A00 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A00 revert(memory[0x00:0x00]); } // Block terminates label_0A01: // Incoming jump from 0x09FC, if !!address(stack[-3]).code.length // Inputs[9] // { // @0A03 msg.gas // @0A04 stack[-3] // @0A04 stack[-6] // @0A04 stack[-7] // @0A04 memory[stack[-4]:stack[-4] + stack[-5]] // @0A04 stack[-2] // @0A04 stack[-5] // @0A04 stack[-4] // @0A04 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0A01 5B JUMPDEST 0A02 50 POP 0A03 5A GAS 0A04 F1 CALL 0A05 15 ISZERO 0A06 80 DUP1 0A07 15 ISZERO 0A08 61 PUSH2 0x0a15 0A0B 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0A04 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A05 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0a15, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0A0C: // Incoming jump from 0x0A0B, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0A0C returndata.length // @0A10 returndata[0x00:0x00 + returndata.length] // @0A11 returndata.length // @0A14 memory[0x00:0x00 + returndata.length] // } 0A0C 3D RETURNDATASIZE 0A0D 60 PUSH1 0x00 0A0F 80 DUP1 0A10 3E RETURNDATACOPY 0A11 3D RETURNDATASIZE 0A12 60 PUSH1 0x00 0A14 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A10 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A14 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A15: // Incoming jump from 0x0A0B, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @0A1C stack[-6] // @0A26 stack[-5] // @0A29 memory[0x40:0x60] // } 0A15 5B JUMPDEST 0A16 50 POP 0A17 50 POP 0A18 50 POP 0A19 50 POP 0A1A 60 PUSH1 0x00 0A1C 82 DUP3 0A1D 60 PUSH1 0x01 0A1F 60 PUSH1 0x01 0A21 60 PUSH1 0xa0 0A23 1B SHL 0A24 03 SUB 0A25 16 AND 0A26 82 DUP3 0A27 60 PUSH1 0x40 0A29 51 MLOAD 0A2A 61 PUSH2 0x0a32 0A2D 90 SWAP1 0A2E 61 PUSH2 0x3722 0A31 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A1A stack[-4] = 0x00 // @0A25 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0A26 stack[-2] = stack[-5] // @0A2D stack[-1] = 0x0a32 // @0A2D stack[0] = memory[0x40:0x60] // } // Block ends with call to 0x3722, returns to 0x0A32 label_0A32: // Incoming return from call to 0x3722 at 0x0A31 // Inputs[8] // { // @0A37 memory[0x40:0x60] // @0A39 stack[-1] // @0A3C stack[-2] // @0A3D stack[-3] // @0A3E msg.gas // @0A3F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0A3F address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0A44 returndata.length // } 0A32 5B JUMPDEST 0A33 60 PUSH1 0x00 0A35 60 PUSH1 0x40 0A37 51 MLOAD 0A38 80 DUP1 0A39 83 DUP4 0A3A 03 SUB 0A3B 81 DUP2 0A3C 85 DUP6 0A3D 87 DUP8 0A3E 5A GAS 0A3F F1 CALL 0A40 92 SWAP3 0A41 50 POP 0A42 50 POP 0A43 50 POP 0A44 3D RETURNDATASIZE 0A45 80 DUP1 0A46 60 PUSH1 0x00 0A48 81 DUP2 0A49 14 EQ 0A4A 61 PUSH2 0x0a6f 0A4D 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0A3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0A40 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0A44 stack[-2] = returndata.length // @0A45 stack[-1] = returndata.length // } // Block ends with conditional jump to 0x0a6f, if returndata.length == 0x00 label_0A4E: // Incoming jump from 0x0A4D, if not returndata.length == 0x00 // Inputs[6] // { // @0A50 memory[0x40:0x60] // @0A51 stack[-2] // @0A58 returndata.length // @0A60 returndata.length // @0A63 returndata.length // @0A6A returndata[0x00:0x00 + returndata.length] // } 0A4E 60 PUSH1 0x40 0A50 51 MLOAD 0A51 91 SWAP2 0A52 50 POP 0A53 60 PUSH1 0x1f 0A55 19 NOT 0A56 60 PUSH1 0x3f 0A58 3D RETURNDATASIZE 0A59 01 ADD 0A5A 16 AND 0A5B 82 DUP3 0A5C 01 ADD 0A5D 60 PUSH1 0x40 0A5F 52 MSTORE 0A60 3D RETURNDATASIZE 0A61 82 DUP3 0A62 52 MSTORE 0A63 3D RETURNDATASIZE 0A64 60 PUSH1 0x00 0A66 60 PUSH1 0x20 0A68 84 DUP5 0A69 01 ADD 0A6A 3E RETURNDATACOPY 0A6B 61 PUSH2 0x0a74 0A6E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0A51 stack[-2] = memory[0x40:0x60] // @0A5F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0A62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0A6A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0a74 label_0A6F: // Incoming jump from 0x0A4D, if returndata.length == 0x00 // Inputs[3] // { // @0A72 stack[-2] // @0A77 stack[-4] // @0A77 stack[-3] // } 0A6F 5B JUMPDEST 0A70 60 PUSH1 0x60 0A72 91 SWAP2 0A73 50 POP 0A74 5B JUMPDEST 0A75 50 POP 0A76 50 POP 0A77 90 SWAP1 0A78 50 POP 0A79 80 DUP1 0A7A 61 PUSH2 0x0a95 0A7D 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0A77 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0a95, if stack[-3] label_0A7E: // Incoming jump from 0x0A7D, if not stack[-3] // Incoming jump from 0x0A7D, if not stack[-3] // Inputs[1] { @0A80 memory[0x40:0x60] } 0A7E 60 PUSH1 0x40 0A80 51 MLOAD 0A81 62 PUSH3 0x461bcd 0A85 60 PUSH1 0xe5 0A87 1B SHL 0A88 81 DUP2 0A89 52 MSTORE 0A8A 60 PUSH1 0x04 0A8C 01 ADD 0A8D 61 PUSH2 0x0840 0A90 90 SWAP1 0A91 61 PUSH2 0x3adc 0A94 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A90 stack[0] = 0x0840 // @0A90 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3adc, returns to 0x0840 label_0A95: // Incoming jump from 0x3D4E, if !(stack[-1] > stack[-4]) // Incoming jump from 0x0A7D, if stack[-3] // Incoming jump from 0x0A7D, if stack[-3] // Inputs[1] { @0A9B stack[-5] } 0A95 5B JUMPDEST 0A96 50 POP 0A97 5B JUMPDEST 0A98 50 POP 0A99 50 POP 0A9A 50 POP 0A9B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0A9C: // Incoming jump from 0x02FE 0A9C 5B JUMPDEST 0A9D 61 PUSH2 0x0aa4 0AA0 61 PUSH2 0x1a26 0AA3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A9D stack[0] = 0x0aa4 } // Block ends with call to 0x1a26, returns to 0x0AA4 label_0AA4: // Incoming return from call to 0x1A26 at 0x0AA3 // Inputs[1] { @0AA8 stack[-1] } 0AA4 5B JUMPDEST 0AA5 61 PUSH2 0x0ac0 0AA8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ac0, if stack[-1] label_0AA9: // Incoming jump from 0x0AA8, if not stack[-1] // Inputs[1] { @0AAB memory[0x40:0x60] } 0AA9 60 PUSH1 0x40 0AAB 51 MLOAD 0AAC 62 PUSH3 0x461bcd 0AB0 60 PUSH1 0xe5 0AB2 1B SHL 0AB3 81 DUP2 0AB4 52 MSTORE 0AB5 60 PUSH1 0x04 0AB7 01 ADD 0AB8 61 PUSH2 0x0840 0ABB 90 SWAP1 0ABC 61 PUSH2 0x3a86 0ABF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ABB stack[0] = 0x0840 // @0ABB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0AC0: // Incoming jump from 0x0AA8, if stack[-1] // Inputs[2] // { // @0AC4 stack[-1] // @0AC5 memory[stack[-1]:stack[-1] + 0x20] // } 0AC0 5B JUMPDEST 0AC1 60 PUSH1 0x00 0AC3 5B JUMPDEST 0AC4 81 DUP2 0AC5 51 MLOAD 0AC6 81 DUP2 0AC7 10 LT 0AC8 15 ISZERO 0AC9 61 PUSH2 0x0b41 0ACC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AC1 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b41, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0ACD: // Incoming jump from 0x0ACC, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0ACC, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0ACF stack[-2] // @0AD0 stack[-1] // @0AD2 memory[stack[-2]:stack[-2] + 0x20] // } 0ACD 60 PUSH1 0x00 0ACF 82 DUP3 0AD0 82 DUP3 0AD1 81 DUP2 0AD2 51 MLOAD 0AD3 81 DUP2 0AD4 10 LT 0AD5 61 PUSH2 0x0ada 0AD8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0ACD stack[0] = 0x00 // @0ACF stack[1] = stack[-2] // @0AD0 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0ada, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0AD9: // Incoming jump from 0x0AD8, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0AD9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0AD9 assert(); } // Block terminates label_0ADA: // Incoming jump from 0x0AD8, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @0ADD stack[-1] // @0AE1 stack[-2] // @0AE2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0AE3 stack[-3] // } 0ADA 5B JUMPDEST 0ADB 60 PUSH1 0x20 0ADD 02 MUL 0ADE 60 PUSH1 0x20 0AE0 01 ADD 0AE1 01 ADD 0AE2 51 MLOAD 0AE3 90 SWAP1 0AE4 50 POP 0AE5 60 PUSH1 0x00 0AE7 60 PUSH1 0x01 0AE9 60 PUSH1 0x01 0AEB 60 PUSH1 0xa0 0AED 1B SHL 0AEE 03 SUB 0AEF 16 AND 0AF0 81 DUP2 0AF1 60 PUSH1 0x01 0AF3 60 PUSH1 0x01 0AF5 60 PUSH1 0xa0 0AF7 1B SHL 0AF8 03 SUB 0AF9 16 AND 0AFA 14 EQ 0AFB 15 ISZERO 0AFC 61 PUSH2 0x0b17 0AFF 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0AE3 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x0b17, if !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & 0x00) label_0B00: // Incoming jump from 0x0AFF, if not !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & 0x00) // Inputs[1] { @0B02 memory[0x40:0x60] } 0B00 60 PUSH1 0x40 0B02 51 MLOAD 0B03 62 PUSH3 0x461bcd 0B07 60 PUSH1 0xe5 0B09 1B SHL 0B0A 81 DUP2 0B0B 52 MSTORE 0B0C 60 PUSH1 0x04 0B0E 01 ADD 0B0F 61 PUSH2 0x0840 0B12 90 SWAP1 0B13 61 PUSH2 0x3b3b 0B16 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B12 stack[0] = 0x0840 // @0B12 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3b3b, returns to 0x0840 label_0B17: // Incoming jump from 0x0AFF, if !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & 0x00) // Inputs[4] // { // @0B20 stack[-1] // @0B31 memory[0x00:0x40] // @0B33 storage[keccak256(memory[0x00:0x40])] // @0B3C stack[-2] // } 0B17 5B JUMPDEST 0B18 60 PUSH1 0x01 0B1A 60 PUSH1 0x01 0B1C 60 PUSH1 0xa0 0B1E 1B SHL 0B1F 03 SUB 0B20 16 AND 0B21 60 PUSH1 0x00 0B23 90 SWAP1 0B24 81 DUP2 0B25 52 MSTORE 0B26 60 PUSH1 0x01 0B28 60 PUSH1 0x20 0B2A 81 DUP2 0B2B 90 SWAP1 0B2C 52 MSTORE 0B2D 60 PUSH1 0x40 0B2F 90 SWAP1 0B30 91 SWAP2 0B31 20 SHA3 0B32 80 DUP1 0B33 54 SLOAD 0B34 60 PUSH1 0xff 0B36 19 NOT 0B37 16 AND 0B38 82 DUP3 0B39 17 OR 0B3A 90 SWAP1 0B3B 55 SSTORE 0B3C 01 ADD 0B3D 61 PUSH2 0x0ac3 0B40 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0B25 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0B2C memory[0x20:0x40] = 0x01 // @0B3B storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0B3C stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x0ac3 label_0B41: // Incoming jump from 0x0ACC, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0ACC, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @0B45 storage[0x00] } 0B41 5B JUMPDEST 0B42 50 POP 0B43 60 PUSH1 0x00 0B45 54 SLOAD 0B46 60 PUSH1 0x01 0B48 60 PUSH1 0xa0 0B4A 1B SHL 0B4B 90 SWAP1 0B4C 04 DIV 0B4D 60 PUSH1 0xff 0B4F 16 AND 0B50 61 PUSH2 0x0b67 0B53 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b67, if 0xff & storage[0x00] / (0x01 << 0xa0) label_0B54: // Incoming jump from 0x0B53, if not 0xff & storage[0x00] / (0x01 << 0xa0) // Inputs[1] { @0B57 storage[0x00] } 0B54 60 PUSH1 0x00 0B56 80 DUP1 0B57 54 SLOAD 0B58 60 PUSH1 0xff 0B5A 60 PUSH1 0xa0 0B5C 1B SHL 0B5D 19 NOT 0B5E 16 AND 0B5F 60 PUSH1 0x01 0B61 60 PUSH1 0xa0 0B63 1B SHL 0B64 17 OR 0B65 90 SWAP1 0B66 55 SSTORE // Stack delta = +0 // Outputs[1] { @0B66 storage[0x00] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x00]) } // Block continues label_0B67: // Incoming jump from 0x1842, if 0xff & storage[0x00] / (0x01 << 0xa0) // Incoming jump from 0x3D75, if stack[-1] == !!stack[-1] // Incoming jump from 0x0B53, if 0xff & storage[0x00] / (0x01 << 0xa0) // Incoming return from call to 0x2F29 at 0x26C2 // Incoming jump from 0x2098 // Incoming jump from 0x3D67, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x3D8A, if stack[-1] == stack[-1] & (0x01 << 0x70) - 0x01 // Incoming jump from 0x0B66 // Inputs[1] { @0B69 stack[-2] } 0B67 5B JUMPDEST 0B68 50 POP 0B69 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0B6A: // Incoming jump from 0x0311 // Inputs[1] { @0B6D storage[0x00] } 0B6A 5B JUMPDEST 0B6B 60 PUSH1 0x00 0B6D 54 SLOAD 0B6E 60 PUSH1 0x01 0B70 60 PUSH1 0xa0 0B72 1B SHL 0B73 90 SWAP1 0B74 04 DIV 0B75 60 PUSH1 0xff 0B77 16 AND 0B78 15 ISZERO 0B79 80 DUP1 0B7A 61 PUSH2 0x0b92 0B7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B78 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x0b92, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_0B7E: // Incoming jump from 0x0B7D, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @0B7F msg.sender // @0B8D memory[0x00:0x40] // @0B8E storage[keccak256(memory[0x00:0x40])] // } 0B7E 50 POP 0B7F 33 CALLER 0B80 60 PUSH1 0x00 0B82 90 SWAP1 0B83 81 DUP2 0B84 52 MSTORE 0B85 60 PUSH1 0x01 0B87 60 PUSH1 0x20 0B89 52 MSTORE 0B8A 60 PUSH1 0x40 0B8C 90 SWAP1 0B8D 20 SHA3 0B8E 54 SLOAD 0B8F 60 PUSH1 0xff 0B91 16 AND 0B92 5B JUMPDEST 0B93 80 DUP1 0B94 61 PUSH2 0x0bb5 0B97 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0B84 memory[0x00:0x20] = msg.sender // @0B89 memory[0x20:0x40] = 0x01 // @0B91 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0bb5, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0B98: // Incoming jump from 0x0B97, if not stack[-1] // Incoming jump from 0x0B97, if not 0xff & storage[keccak256(memory[0x00:0x40])] 0B98 50 POP 0B99 61 PUSH2 0x0ba0 0B9C 61 PUSH2 0x1a17 0B9F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B99 stack[-1] = 0x0ba0 } // Block ends with call to 0x1a17, returns to 0x0BA0 label_0BA0: // Incoming return from call to 0x1A17 at 0x0B9F // Inputs[2] // { // @0BA9 stack[-1] // @0BAA msg.sender // } 0BA0 5B JUMPDEST 0BA1 60 PUSH1 0x01 0BA3 60 PUSH1 0x01 0BA5 60 PUSH1 0xa0 0BA7 1B SHL 0BA8 03 SUB 0BA9 16 AND 0BAA 33 CALLER 0BAB 60 PUSH1 0x01 0BAD 60 PUSH1 0x01 0BAF 60 PUSH1 0xa0 0BB1 1B SHL 0BB2 03 SUB 0BB3 16 AND 0BB4 14 EQ // Stack delta = +0 // Outputs[1] { @0BB4 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_0BB5: // Incoming jump from 0x0BB4 // Incoming jump from 0x0B97, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0B97, if stack[-1] // Inputs[1] { @0BB9 stack[-1] } 0BB5 5B JUMPDEST 0BB6 61 PUSH2 0x0bd1 0BB9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bd1, if stack[-1] label_0BBA: // Incoming jump from 0x0BB9, if not stack[-1] // Inputs[1] { @0BBC memory[0x40:0x60] } 0BBA 60 PUSH1 0x40 0BBC 51 MLOAD 0BBD 62 PUSH3 0x461bcd 0BC1 60 PUSH1 0xe5 0BC3 1B SHL 0BC4 81 DUP2 0BC5 52 MSTORE 0BC6 60 PUSH1 0x04 0BC8 01 ADD 0BC9 61 PUSH2 0x0840 0BCC 90 SWAP1 0BCD 61 PUSH2 0x399a 0BD0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BCC stack[0] = 0x0840 // @0BCC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_0BD1: // Incoming jump from 0x0BB9, if stack[-1] // Inputs[4] // { // @0BD4 stack[-2] // @0BDE msg.value // @0BDF stack[-1] // @0BE2 memory[0x40:0x60] // } 0BD1 5B JUMPDEST 0BD2 60 PUSH1 0x00 0BD4 82 DUP3 0BD5 60 PUSH1 0x01 0BD7 60 PUSH1 0x01 0BD9 60 PUSH1 0xa0 0BDB 1B SHL 0BDC 03 SUB 0BDD 16 AND 0BDE 34 CALLVALUE 0BDF 83 DUP4 0BE0 60 PUSH1 0x40 0BE2 51 MLOAD 0BE3 61 PUSH2 0x0bec 0BE6 91 SWAP2 0BE7 90 SWAP1 0BE8 61 PUSH2 0x3706 0BEB 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0BD2 stack[0] = 0x00 // @0BDD stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0BDE stack[2] = msg.value // @0BE6 stack[3] = 0x0bec // @0BE7 stack[4] = stack[-1] // @0BE7 stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x3706, returns to 0x0BEC label_0BEC: // Incoming return from call to 0x3706 at 0x0BEB // Inputs[8] // { // @0BF1 memory[0x40:0x60] // @0BF3 stack[-1] // @0BF6 stack[-2] // @0BF7 stack[-3] // @0BF8 msg.gas // @0BF9 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0BF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0BFE returndata.length // } 0BEC 5B JUMPDEST 0BED 60 PUSH1 0x00 0BEF 60 PUSH1 0x40 0BF1 51 MLOAD 0BF2 80 DUP1 0BF3 83 DUP4 0BF4 03 SUB 0BF5 81 DUP2 0BF6 85 DUP6 0BF7 87 DUP8 0BF8 5A GAS 0BF9 F1 CALL 0BFA 92 SWAP3 0BFB 50 POP 0BFC 50 POP 0BFD 50 POP 0BFE 3D RETURNDATASIZE 0BFF 80 DUP1 0C00 60 PUSH1 0x00 0C02 81 DUP2 0C03 14 EQ 0C04 61 PUSH2 0x0c29 0C07 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0BF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0BFA stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0BFE stack[-2] = returndata.length // @0BFF stack[-1] = returndata.length // } // Block ends with conditional jump to 0x0c29, if returndata.length == 0x00 label_0C08: // Incoming jump from 0x0C07, if not returndata.length == 0x00 // Inputs[6] // { // @0C0A memory[0x40:0x60] // @0C0B stack[-2] // @0C12 returndata.length // @0C1A returndata.length // @0C1D returndata.length // @0C24 returndata[0x00:0x00 + returndata.length] // } 0C08 60 PUSH1 0x40 0C0A 51 MLOAD 0C0B 91 SWAP2 0C0C 50 POP 0C0D 60 PUSH1 0x1f 0C0F 19 NOT 0C10 60 PUSH1 0x3f 0C12 3D RETURNDATASIZE 0C13 01 ADD 0C14 16 AND 0C15 82 DUP3 0C16 01 ADD 0C17 60 PUSH1 0x40 0C19 52 MSTORE 0C1A 3D RETURNDATASIZE 0C1B 82 DUP3 0C1C 52 MSTORE 0C1D 3D RETURNDATASIZE 0C1E 60 PUSH1 0x00 0C20 60 PUSH1 0x20 0C22 84 DUP5 0C23 01 ADD 0C24 3E RETURNDATACOPY 0C25 61 PUSH2 0x0c2e 0C28 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0C0B stack[-2] = memory[0x40:0x60] // @0C19 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0C1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0C24 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0c2e label_0C29: // Incoming jump from 0x0C07, if returndata.length == 0x00 // Inputs[3] // { // @0C2C stack[-2] // @0C31 stack[-4] // @0C31 stack[-3] // } 0C29 5B JUMPDEST 0C2A 60 PUSH1 0x60 0C2C 91 SWAP2 0C2D 50 POP 0C2E 5B JUMPDEST 0C2F 50 POP 0C30 50 POP 0C31 90 SWAP1 0C32 50 POP 0C33 80 DUP1 0C34 61 PUSH2 0x0a97 0C37 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0C31 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0a97, if stack[-3] label_0C38: // Incoming jump from 0x0C37, if not stack[-3] // Incoming jump from 0x0C37, if not stack[-3] // Inputs[1] { @0C3A memory[0x40:0x60] } 0C38 60 PUSH1 0x40 0C3A 51 MLOAD 0C3B 62 PUSH3 0x461bcd 0C3F 60 PUSH1 0xe5 0C41 1B SHL 0C42 81 DUP2 0C43 52 MSTORE 0C44 60 PUSH1 0x04 0C46 01 ADD 0C47 61 PUSH2 0x0840 0C4A 90 SWAP1 0C4B 61 PUSH2 0x39d1 0C4E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C4A stack[0] = 0x0840 // @0C4A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x39d1, returns to 0x0840 label_0C4F: // Incoming jump from 0x0331 0C4F 5B JUMPDEST 0C50 61 PUSH2 0x0c57 0C53 61 PUSH2 0x1a26 0C56 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C50 stack[0] = 0x0c57 } // Block ends with call to 0x1a26, returns to 0x0C57 label_0C57: // Incoming return from call to 0x1A26 at 0x0C56 // Inputs[1] { @0C5B stack[-1] } 0C57 5B JUMPDEST 0C58 61 PUSH2 0x0c73 0C5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c73, if stack[-1] label_0C5C: // Incoming jump from 0x0C5B, if not stack[-1] // Inputs[1] { @0C5E memory[0x40:0x60] } 0C5C 60 PUSH1 0x40 0C5E 51 MLOAD 0C5F 62 PUSH3 0x461bcd 0C63 60 PUSH1 0xe5 0C65 1B SHL 0C66 81 DUP2 0C67 52 MSTORE 0C68 60 PUSH1 0x04 0C6A 01 ADD 0C6B 61 PUSH2 0x0840 0C6E 90 SWAP1 0C6F 61 PUSH2 0x3a86 0C72 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C6E stack[0] = 0x0840 // @0C6E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0C73: // Incoming jump from 0x0C5B, if stack[-1] // Inputs[3] // { // @0C77 storage[0x00] // @0C78 stack[-1] // @0C90 stack[-2] // } 0C73 5B JUMPDEST 0C74 60 PUSH1 0x00 0C76 80 DUP1 0C77 54 SLOAD 0C78 91 SWAP2 0C79 15 ISZERO 0C7A 15 ISZERO 0C7B 60 PUSH1 0x01 0C7D 60 PUSH1 0xa0 0C7F 1B SHL 0C80 02 MUL 0C81 60 PUSH1 0xff 0C83 60 PUSH1 0xa0 0C85 1B SHL 0C86 19 NOT 0C87 90 SWAP1 0C88 92 SWAP3 0C89 16 AND 0C8A 91 SWAP2 0C8B 90 SWAP1 0C8C 91 SWAP2 0C8D 17 OR 0C8E 90 SWAP1 0C8F 55 SSTORE 0C90 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C8F storage[0x00] = (storage[0x00] & ~(0xff << 0xa0)) | (0x01 << 0xa0) * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C91: // Incoming call from 0x24B6, returns to 0x24B7 // Incoming jump from 0x0351 // Incoming call from 0x259E, returns to 0x259F // Incoming call from 0x0E71, returns to 0x0E72 // Incoming call from 0x23CE, returns to 0x23CF // Incoming call from 0x20C3, returns to 0x20C4 // Inputs[3] // { // @0C9A stack[-4] // @0C9B stack[-3] // @0C9C stack[-2] // } 0C91 5B JUMPDEST 0C92 60 PUSH1 0x00 0C94 80 DUP1 0C95 60 PUSH1 0x00 0C97 61 PUSH2 0x0ca1 0C9A 87 DUP8 0C9B 87 DUP8 0C9C 87 DUP8 0C9D 61 PUSH2 0x26c3 0CA0 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0C92 stack[0] = 0x00 // @0C94 stack[1] = 0x00 // @0C95 stack[2] = 0x00 // @0C97 stack[3] = 0x0ca1 // @0C9A stack[4] = stack[-4] // @0C9B stack[5] = stack[-3] // @0C9C stack[6] = stack[-2] // } // Block ends with call to 0x26c3, returns to 0x0CA1 label_0CA1: // Incoming return from call to 0x26C3 at 0x0CA0 // Inputs[5] // { // @0CA2 stack[-1] // @0CA2 stack[-3] // @0CA4 stack[-2] // @0CA4 stack[-4] // @0CA9 stack[-6] // } 0CA1 5B JUMPDEST 0CA2 91 SWAP2 0CA3 50 POP 0CA4 91 SWAP2 0CA5 50 POP 0CA6 61 PUSH2 0x0cb0 0CA9 84 DUP5 0CAA 83 DUP4 0CAB 83 DUP4 0CAC 61 PUSH2 0x2792 0CAF 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0CA2 stack[-3] = stack[-1] // @0CA4 stack[-4] = stack[-2] // @0CA6 stack[-2] = 0x0cb0 // @0CA9 stack[-1] = stack[-6] // @0CAA stack[0] = stack[-2] // @0CAB stack[1] = stack[-1] // } // Block ends with call to 0x2792, returns to 0x0CB0 label_0CB0: // Incoming return from call to 0x2B5E at 0x1BAB // Incoming return from call to 0x2792 at 0x0CAF // Inputs[3] // { // @0CB1 stack[-1] // @0CB1 stack[-9] // @0CB2 stack[-8] // } 0CB0 5B JUMPDEST 0CB1 97 SWAP8 0CB2 96 SWAP7 0CB3 50 POP 0CB4 50 POP 0CB5 50 POP 0CB6 50 POP 0CB7 50 POP 0CB8 50 POP 0CB9 50 POP 0CBA 56 *JUMP // Stack delta = -8 // Outputs[1] { @0CB1 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_0CBB: // Incoming call from 0x037C, returns to 0x037D 0CBB 5B JUMPDEST 0CBC 61 PUSH2 0x0cc3 0CBF 61 PUSH2 0x327f 0CC2 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CBC stack[0] = 0x0cc3 } // Block ends with call to 0x327f, returns to 0x0CC3 label_0CC3: // Incoming return from call to 0x327F at 0x0CC2 0CC3 5B JUMPDEST 0CC4 61 PUSH2 0x0ccb 0CC7 61 PUSH2 0x1a26 0CCA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC4 stack[0] = 0x0ccb } // Block ends with call to 0x1a26, returns to 0x0CCB label_0CCB: // Incoming return from call to 0x1A26 at 0x0CCA // Inputs[1] { @0CCF stack[-1] } 0CCB 5B JUMPDEST 0CCC 61 PUSH2 0x0ce7 0CCF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ce7, if stack[-1] label_0CD0: // Incoming jump from 0x0CCF, if not stack[-1] // Inputs[1] { @0CD2 memory[0x40:0x60] } 0CD0 60 PUSH1 0x40 0CD2 51 MLOAD 0CD3 62 PUSH3 0x461bcd 0CD7 60 PUSH1 0xe5 0CD9 1B SHL 0CDA 81 DUP2 0CDB 52 MSTORE 0CDC 60 PUSH1 0x04 0CDE 01 ADD 0CDF 61 PUSH2 0x0840 0CE2 90 SWAP1 0CE3 61 PUSH2 0x3a86 0CE6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CDB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE2 stack[0] = 0x0840 // @0CE2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0CE7: // Incoming jump from 0x0CCF, if stack[-1] // Inputs[7] // { // @0CEC memory[0x40:0x60] // @0CF5 storage[0x0e] // @0D05 storage[0x0f] // @0D0F storage[0x10] // @0D1A storage[0x11] // @0D22 storage[0x12] // @0D28 stack[-2] // } 0CE7 5B JUMPDEST 0CE8 50 POP 0CE9 60 PUSH1 0x40 0CEB 80 DUP1 0CEC 51 MLOAD 0CED 60 PUSH1 0xa0 0CEF 81 DUP2 0CF0 01 ADD 0CF1 82 DUP3 0CF2 52 MSTORE 0CF3 60 PUSH1 0x0e 0CF5 54 SLOAD 0CF6 60 PUSH1 0x01 0CF8 60 PUSH1 0x01 0CFA 60 PUSH1 0xa0 0CFC 1B SHL 0CFD 03 SUB 0CFE 90 SWAP1 0CFF 81 DUP2 0D00 16 AND 0D01 82 DUP3 0D02 52 MSTORE 0D03 60 PUSH1 0x0f 0D05 54 SLOAD 0D06 81 DUP2 0D07 16 AND 0D08 60 PUSH1 0x20 0D0A 83 DUP4 0D0B 01 ADD 0D0C 52 MSTORE 0D0D 60 PUSH1 0x10 0D0F 54 SLOAD 0D10 16 AND 0D11 91 SWAP2 0D12 81 DUP2 0D13 01 ADD 0D14 91 SWAP2 0D15 90 SWAP1 0D16 91 SWAP2 0D17 52 MSTORE 0D18 60 PUSH1 0x11 0D1A 54 SLOAD 0D1B 60 PUSH1 0x60 0D1D 82 DUP3 0D1E 01 ADD 0D1F 52 MSTORE 0D20 60 PUSH1 0x12 0D22 54 SLOAD 0D23 60 PUSH1 0x80 0D25 82 DUP3 0D26 01 ADD 0D27 52 MSTORE 0D28 90 SWAP1 0D29 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @0CF2 memory[0x40:0x60] = memory[0x40:0x60] + 0xa0 // @0D02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @0D0C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @0D17 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[0x10] & (0x01 << 0xa0) - 0x01 // @0D1F memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = storage[0x11] // @0D27 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = storage[0x12] // @0D28 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-2] label_0D2A: // Incoming jump from 0x03A9 // Inputs[2] // { // @0D2D stack[-1] // @0D2F storage[0x06] // } 0D2A 5B JUMPDEST 0D2B 60 PUSH1 0x06 0D2D 81 DUP2 0D2E 81 DUP2 0D2F 54 SLOAD 0D30 81 DUP2 0D31 10 LT 0D32 61 PUSH2 0x0d37 0D35 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D2B stack[0] = 0x06 // @0D2D stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0d37, if stack[-1] < storage[0x06] label_0D36: // Incoming jump from 0x0D35, if not stack[-1] < storage[0x06] 0D36 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D36 assert(); } // Block terminates label_0D37: // Incoming jump from 0x0D35, if stack[-1] < storage[0x06] // Inputs[6] // { // @0D3A stack[-2] // @0D3F stack[-1] // @0D41 memory[0x00:0x20] // @0D43 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0D44 stack[-3] // @0D46 stack[-4] // } 0D37 5B JUMPDEST 0D38 60 PUSH1 0x00 0D3A 91 SWAP2 0D3B 82 DUP3 0D3C 52 MSTORE 0D3D 60 PUSH1 0x20 0D3F 90 SWAP1 0D40 91 SWAP2 0D41 20 SHA3 0D42 01 ADD 0D43 54 SLOAD 0D44 90 SWAP1 0D45 50 POP 0D46 81 DUP2 0D47 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0D3C memory[0x00:0x20] = stack[-2] // @0D44 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-4] label_0D48: // Incoming jump from 0x03C9 // Inputs[3] // { // @0D51 stack[-1] // @0D60 memory[0x00:0x40] // @0D61 storage[keccak256(memory[0x00:0x40])] // } 0D48 5B JUMPDEST 0D49 60 PUSH1 0x01 0D4B 60 PUSH1 0x01 0D4D 60 PUSH1 0xa0 0D4F 1B SHL 0D50 03 SUB 0D51 81 DUP2 0D52 16 AND 0D53 60 PUSH1 0x00 0D55 90 SWAP1 0D56 81 DUP2 0D57 52 MSTORE 0D58 60 PUSH1 0x0d 0D5A 60 PUSH1 0x20 0D5C 52 MSTORE 0D5D 60 PUSH1 0x40 0D5F 90 SWAP1 0D60 20 SHA3 0D61 54 SLOAD 0D62 60 PUSH1 0xff 0D64 16 AND // Stack delta = +1 // Outputs[3] // { // @0D57 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0D5C memory[0x20:0x40] = 0x0d // @0D64 stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_0D65: // Incoming jump from 0x22AC // Incoming jump from 0x2229 // Incoming jump from 0x10BF // Incoming jump from 0x0D64 // Inputs[3] // { // @0D66 stack[-3] // @0D66 stack[-1] // @0D67 stack[-2] // } 0D65 5B JUMPDEST 0D66 91 SWAP2 0D67 90 SWAP1 0D68 50 POP 0D69 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D66 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0D6A: // Incoming call from 0x03EB, returns to 0x03EC // Inputs[2] // { // @0D6D storage[0x02] // @0D77 stack[-1] // } 0D6A 5B JUMPDEST 0D6B 60 PUSH1 0x02 0D6D 54 SLOAD 0D6E 60 PUSH1 0x01 0D70 60 PUSH1 0x01 0D72 60 PUSH1 0xa0 0D74 1B SHL 0D75 03 SUB 0D76 16 AND 0D77 81 DUP2 0D78 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D76 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x02] } // Block ends with unconditional jump to stack[-1] label_0D79: // Incoming jump from 0x0418 // Inputs[4] // { // @0D81 stack[-1] // @0D87 memory[0x00:0x40] // @0D88 storage[keccak256(memory[0x00:0x40])] // @0D8C stack[-2] // } 0D79 5B JUMPDEST 0D7A 60 PUSH1 0x01 0D7C 60 PUSH1 0x20 0D7E 52 MSTORE 0D7F 60 PUSH1 0x00 0D81 90 SWAP1 0D82 81 DUP2 0D83 52 MSTORE 0D84 60 PUSH1 0x40 0D86 90 SWAP1 0D87 20 SHA3 0D88 54 SLOAD 0D89 60 PUSH1 0xff 0D8B 16 AND 0D8C 81 DUP2 0D8D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D7E memory[0x20:0x40] = 0x01 // @0D83 memory[0x00:0x20] = stack[-1] // @0D8B stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0D8E: // Incoming jump from 0x042D 0D8E 5B JUMPDEST 0D8F 61 PUSH2 0x0d96 0D92 61 PUSH2 0x1a26 0D95 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D8F stack[0] = 0x0d96 } // Block ends with call to 0x1a26, returns to 0x0D96 label_0D96: // Incoming return from call to 0x1A26 at 0x0D95 // Inputs[1] { @0D9A stack[-1] } 0D96 5B JUMPDEST 0D97 61 PUSH2 0x0db2 0D9A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0db2, if stack[-1] label_0D9B: // Incoming jump from 0x0D9A, if not stack[-1] // Inputs[1] { @0D9D memory[0x40:0x60] } 0D9B 60 PUSH1 0x40 0D9D 51 MLOAD 0D9E 62 PUSH3 0x461bcd 0DA2 60 PUSH1 0xe5 0DA4 1B SHL 0DA5 81 DUP2 0DA6 52 MSTORE 0DA7 60 PUSH1 0x04 0DA9 01 ADD 0DAA 61 PUSH2 0x0840 0DAD 90 SWAP1 0DAE 61 PUSH2 0x3a86 0DB1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DAD stack[0] = 0x0840 // @0DAD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0DB2: // Incoming jump from 0x0D9A, if stack[-1] // Inputs[1] { @0DB3 msg.sender } 0DB2 5B JUMPDEST 0DB3 33 CALLER 0DB4 FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @0DB4 selfdestruct(msg.sender); } // Block terminates label_0DB5: // Incoming call from 0x0435, returns to 0x02DD // Inputs[1] { @0DB8 storage[0x00] } 0DB5 5B JUMPDEST 0DB6 60 PUSH1 0x00 0DB8 54 SLOAD 0DB9 60 PUSH1 0x01 0DBB 60 PUSH1 0xa0 0DBD 1B SHL 0DBE 90 SWAP1 0DBF 04 DIV 0DC0 60 PUSH1 0xff 0DC2 16 AND 0DC3 15 ISZERO 0DC4 80 DUP1 0DC5 61 PUSH2 0x0ddd 0DC8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DC3 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x0ddd, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_0DC9: // Incoming jump from 0x0DC8, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @0DCA msg.sender // @0DD8 memory[0x00:0x40] // @0DD9 storage[keccak256(memory[0x00:0x40])] // } 0DC9 50 POP 0DCA 33 CALLER 0DCB 60 PUSH1 0x00 0DCD 90 SWAP1 0DCE 81 DUP2 0DCF 52 MSTORE 0DD0 60 PUSH1 0x01 0DD2 60 PUSH1 0x20 0DD4 52 MSTORE 0DD5 60 PUSH1 0x40 0DD7 90 SWAP1 0DD8 20 SHA3 0DD9 54 SLOAD 0DDA 60 PUSH1 0xff 0DDC 16 AND 0DDD 5B JUMPDEST 0DDE 80 DUP1 0DDF 61 PUSH2 0x0e00 0DE2 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0DCF memory[0x00:0x20] = msg.sender // @0DD4 memory[0x20:0x40] = 0x01 // @0DDC stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0e00, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0DE3: // Incoming jump from 0x0DE2, if not stack[-1] // Incoming jump from 0x0DE2, if not 0xff & storage[keccak256(memory[0x00:0x40])] 0DE3 50 POP 0DE4 61 PUSH2 0x0deb 0DE7 61 PUSH2 0x1a17 0DEA 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DE4 stack[-1] = 0x0deb } // Block ends with call to 0x1a17, returns to 0x0DEB label_0DEB: // Incoming return from call to 0x1A17 at 0x0DEA // Inputs[2] // { // @0DF4 stack[-1] // @0DF5 msg.sender // } 0DEB 5B JUMPDEST 0DEC 60 PUSH1 0x01 0DEE 60 PUSH1 0x01 0DF0 60 PUSH1 0xa0 0DF2 1B SHL 0DF3 03 SUB 0DF4 16 AND 0DF5 33 CALLER 0DF6 60 PUSH1 0x01 0DF8 60 PUSH1 0x01 0DFA 60 PUSH1 0xa0 0DFC 1B SHL 0DFD 03 SUB 0DFE 16 AND 0DFF 14 EQ // Stack delta = +0 // Outputs[1] { @0DFF stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_0E00: // Incoming jump from 0x0DE2, if stack[-1] // Incoming jump from 0x0DE2, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0DFF // Inputs[1] { @0E04 stack[-1] } 0E00 5B JUMPDEST 0E01 61 PUSH2 0x0e1c 0E04 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e1c, if stack[-1] label_0E05: // Incoming jump from 0x0E04, if not stack[-1] // Inputs[1] { @0E07 memory[0x40:0x60] } 0E05 60 PUSH1 0x40 0E07 51 MLOAD 0E08 62 PUSH3 0x461bcd 0E0C 60 PUSH1 0xe5 0E0E 1B SHL 0E0F 81 DUP2 0E10 52 MSTORE 0E11 60 PUSH1 0x04 0E13 01 ADD 0E14 61 PUSH2 0x0840 0E17 90 SWAP1 0E18 61 PUSH2 0x399a 0E1B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E17 stack[0] = 0x0840 // @0E17 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_0E1C: // Incoming jump from 0x0E04, if stack[-1] // Inputs[1] { @0E1F storage[0x0c] } 0E1C 5B JUMPDEST 0E1D 60 PUSH1 0x0c 0E1F 54 SLOAD 0E20 60 PUSH1 0xff 0E22 16 AND 0E23 80 DUP1 0E24 15 ISZERO 0E25 61 PUSH2 0x0e3d 0E28 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E22 stack[0] = 0xff & storage[0x0c] } // Block ends with conditional jump to 0x0e3d, if !(0xff & storage[0x0c]) label_0E29: // Incoming jump from 0x0E28, if not !(0xff & storage[0x0c]) // Inputs[3] // { // @0E2A block.coinbase // @0E38 memory[0x00:0x40] // @0E39 storage[keccak256(memory[0x00:0x40])] // } 0E29 50 POP 0E2A 41 COINBASE 0E2B 60 PUSH1 0x00 0E2D 90 SWAP1 0E2E 81 DUP2 0E2F 52 MSTORE 0E30 60 PUSH1 0x0d 0E32 60 PUSH1 0x20 0E34 52 MSTORE 0E35 60 PUSH1 0x40 0E37 90 SWAP1 0E38 20 SHA3 0E39 54 SLOAD 0E3A 60 PUSH1 0xff 0E3C 16 AND 0E3D 5B JUMPDEST 0E3E 15 ISZERO 0E3F 61 PUSH2 0x0e47 0E42 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0E2F memory[0x00:0x20] = block.coinbase // @0E34 memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x0e47, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0E43: // Incoming jump from 0x0E42, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x0E42, if not !stack[-1] 0E43 61 PUSH2 0x0f0e 0E46 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f0e label_0E47: // Incoming jump from 0x0E42, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x0E42, if !stack[-1] // Inputs[4] // { // @0E4A storage[0x0e] // @0E4D storage[0x10] // @0E50 storage[0x0f] // @0E53 storage[0x12] // } 0E47 5B JUMPDEST 0E48 60 PUSH1 0x0e 0E4A 54 SLOAD 0E4B 60 PUSH1 0x10 0E4D 54 SLOAD 0E4E 60 PUSH1 0x0f 0E50 54 SLOAD 0E51 60 PUSH1 0x12 0E53 54 SLOAD 0E54 60 PUSH1 0x00 0E56 93 SWAP4 0E57 61 PUSH2 0x0e72 0E5A 93 SWAP4 0E5B 60 PUSH1 0x01 0E5D 60 PUSH1 0x01 0E5F 60 PUSH1 0xa0 0E61 1B SHL 0E62 03 SUB 0E63 91 SWAP2 0E64 82 DUP3 0E65 16 AND 0E66 93 SWAP4 0E67 90 SWAP1 0E68 82 DUP3 0E69 16 AND 0E6A 92 SWAP3 0E6B 91 SWAP2 0E6C 16 AND 0E6D 90 SWAP1 0E6E 61 PUSH2 0x0c91 0E71 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0E56 stack[0] = 0x00 // @0E5A stack[1] = 0x0e72 // @0E66 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @0E6A stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x10] // @0E6D stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @0E6D stack[5] = storage[0x12] // } // Block ends with call to 0x0c91, returns to 0x0E72 label_0E72: // Incoming return from call to 0x0C91 at 0x0E71 // Inputs[3] // { // @0E75 storage[0x11] // @0E76 stack[-1] // @0E77 stack[-2] // } 0E72 5B JUMPDEST 0E73 60 PUSH1 0x11 0E75 54 SLOAD 0E76 90 SWAP1 0E77 91 SWAP2 0E78 50 POP 0E79 81 DUP2 0E7A 10 LT 0E7B 15 ISZERO 0E7C 61 PUSH2 0x0e97 0E7F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0E77 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0e97, if !(stack[-1] < storage[0x11]) label_0E80: // Incoming jump from 0x0E7F, if not !(stack[-1] < storage[0x11]) // Inputs[1] { @0E82 memory[0x40:0x60] } 0E80 60 PUSH1 0x40 0E82 51 MLOAD 0E83 62 PUSH3 0x461bcd 0E87 60 PUSH1 0xe5 0E89 1B SHL 0E8A 81 DUP2 0E8B 52 MSTORE 0E8C 60 PUSH1 0x04 0E8E 01 ADD 0E8F 61 PUSH2 0x0840 0E92 90 SWAP1 0E93 61 PUSH2 0x3abb 0E96 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E92 stack[0] = 0x0840 // @0E92 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3abb, returns to 0x0840 label_0E97: // Incoming jump from 0x0E7F, if !(stack[-1] < storage[0x11]) 0E97 5B JUMPDEST 0E98 61 PUSH2 0x0e9f 0E9B 61 PUSH2 0x2844 0E9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E98 stack[0] = 0x0e9f } // Block ends with unconditional jump to 0x2844 0E9F 5B JUMPDEST 0EA0 50 POP 0EA1 60 PUSH1 0x00 0EA3 61 PUSH2 0x0eaa 0EA6 61 PUSH2 0x2876 0EA9 56 *JUMP 0EAA 5B JUMPDEST 0EAB 90 SWAP1 0EAC 50 POP 0EAD 60 PUSH1 0x00 0EAF 41 COINBASE 0EB0 60 PUSH1 0x01 0EB2 60 PUSH1 0x01 0EB4 60 PUSH1 0xa0 0EB6 1B SHL 0EB7 03 SUB 0EB8 16 AND 0EB9 82 DUP3 0EBA 60 PUSH1 0x40 0EBC 51 MLOAD 0EBD 61 PUSH2 0x0ec5 0EC0 90 SWAP1 0EC1 61 PUSH2 0x3722 0EC4 56 *JUMP 0EC5 5B JUMPDEST 0EC6 60 PUSH1 0x00 0EC8 60 PUSH1 0x40 0ECA 51 MLOAD 0ECB 80 DUP1 0ECC 83 DUP4 0ECD 03 SUB 0ECE 81 DUP2 0ECF 85 DUP6 0ED0 87 DUP8 0ED1 5A GAS 0ED2 F1 CALL 0ED3 92 SWAP3 0ED4 50 POP 0ED5 50 POP 0ED6 50 POP 0ED7 3D RETURNDATASIZE 0ED8 80 DUP1 0ED9 60 PUSH1 0x00 0EDB 81 DUP2 0EDC 14 EQ 0EDD 61 PUSH2 0x0f02 0EE0 57 *JUMPI 0EE1 60 PUSH1 0x40 0EE3 51 MLOAD 0EE4 91 SWAP2 0EE5 50 POP 0EE6 60 PUSH1 0x1f 0EE8 19 NOT 0EE9 60 PUSH1 0x3f 0EEB 3D RETURNDATASIZE 0EEC 01 ADD 0EED 16 AND 0EEE 82 DUP3 0EEF 01 ADD 0EF0 60 PUSH1 0x40 0EF2 52 MSTORE 0EF3 3D RETURNDATASIZE 0EF4 82 DUP3 0EF5 52 MSTORE 0EF6 3D RETURNDATASIZE 0EF7 60 PUSH1 0x00 0EF9 60 PUSH1 0x20 0EFB 84 DUP5 0EFC 01 ADD 0EFD 3E RETURNDATACOPY 0EFE 61 PUSH2 0x0f07 0F01 56 *JUMP 0F02 5B JUMPDEST 0F03 60 PUSH1 0x60 0F05 91 SWAP2 0F06 50 POP label_0F07: // Incoming jump from 0x316B, if stack[-1] 0F07 5B JUMPDEST 0F08 50 POP 0F09 50 POP 0F0A 50 POP 0F0B 50 POP 0F0C 50 POP 0F0D 50 POP // Stack delta = -6 // Block continues label_0F0E: // Incoming jump from 0x196C // Incoming jump from 0x0F0D // Incoming jump from 0x0E46 // Inputs[1] { @0F0F stack[-1] } 0F0E 5B JUMPDEST 0F0F 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0F10: // Incoming jump from 0x0448 0F10 5B JUMPDEST 0F11 61 PUSH2 0x0f18 0F14 61 PUSH2 0x1a26 0F17 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F11 stack[0] = 0x0f18 } // Block ends with call to 0x1a26, returns to 0x0F18 label_0F18: // Incoming return from call to 0x1A26 at 0x0F17 // Inputs[1] { @0F1C stack[-1] } 0F18 5B JUMPDEST 0F19 61 PUSH2 0x0f34 0F1C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f34, if stack[-1] label_0F1D: // Incoming jump from 0x0F1C, if not stack[-1] // Inputs[1] { @0F1F memory[0x40:0x60] } 0F1D 60 PUSH1 0x40 0F1F 51 MLOAD 0F20 62 PUSH3 0x461bcd 0F24 60 PUSH1 0xe5 0F26 1B SHL 0F27 81 DUP2 0F28 52 MSTORE 0F29 60 PUSH1 0x04 0F2B 01 ADD 0F2C 61 PUSH2 0x0840 0F2F 90 SWAP1 0F30 61 PUSH2 0x3a86 0F33 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F28 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F2F stack[0] = 0x0840 // @0F2F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_0F34: // Incoming jump from 0x0F1C, if stack[-1] // Inputs[2] // { // @0F38 stack[-2] // @0F39 address(this) // } 0F34 5B JUMPDEST 0F35 61 PUSH2 0x0f40 0F38 82 DUP3 0F39 30 ADDRESS 0F3A 60 PUSH1 0x00 0F3C 61 PUSH2 0x1446 0F3F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F35 stack[0] = 0x0f40 // @0F38 stack[1] = stack[-2] // @0F39 stack[2] = address(this) // @0F3A stack[3] = 0x00 // } // Block ends with call to 0x1446, returns to 0x0F40 label_0F40: // Incoming return from call to 0x1446 at 0x0F3F // Inputs[2] // { // @0F44 stack[-2] // @0F45 address(this) // } 0F40 5B JUMPDEST 0F41 61 PUSH2 0x0f4c 0F44 82 DUP3 0F45 30 ADDRESS 0F46 60 PUSH1 0x00 0F48 61 PUSH2 0x1568 0F4B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F41 stack[0] = 0x0f4c // @0F44 stack[1] = stack[-2] // @0F45 stack[2] = address(this) // @0F46 stack[3] = 0x00 // } // Block ends with call to 0x1568, returns to 0x0F4C label_0F4C: // Incoming return from call to 0x1568 at 0x0F4B // Inputs[2] // { // @0F50 stack[-2] // @0F51 address(this) // } 0F4C 5B JUMPDEST 0F4D 61 PUSH2 0x0f58 0F50 82 DUP3 0F51 30 ADDRESS 0F52 60 PUSH1 0x00 0F54 61 PUSH2 0x10d7 0F57 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F4D stack[0] = 0x0f58 // @0F50 stack[1] = stack[-2] // @0F51 stack[2] = address(this) // @0F52 stack[3] = 0x00 // } // Block ends with call to 0x10d7, returns to 0x0F58 label_0F58: // Incoming return from call to 0x10D7 at 0x0F57 // Inputs[2] // { // @0F5B memory[0x40:0x60] // @0F89 address(this) // } 0F58 5B JUMPDEST 0F59 60 PUSH1 0x40 0F5B 51 MLOAD 0F5C 63 PUSH4 0x70a08231 0F61 60 PUSH1 0xe0 0F63 1B SHL 0F64 81 DUP2 0F65 52 MSTORE 0F66 60 PUSH1 0x00 0F68 90 SWAP1 0F69 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0F7E 90 SWAP1 0F7F 63 PUSH4 0x70a08231 0F84 90 SWAP1 0F85 61 PUSH2 0x0f92 0F88 90 SWAP1 0F89 30 ADDRESS 0F8A 90 SWAP1 0F8B 60 PUSH1 0x04 0F8D 01 ADD 0F8E 61 PUSH2 0x3725 0F91 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @0F65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @0F68 stack[0] = 0x00 // @0F7E stack[1] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0F84 stack[2] = 0x70a08231 // @0F88 stack[3] = 0x0f92 // @0F8A stack[4] = address(this) // @0F8D stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x0F92 label_0F92: // Incoming return from call to 0x3725 at 0x0F91 // Inputs[4] // { // @0F97 memory[0x40:0x60] // @0F99 stack[-1] // @0F9C stack[-3] // @0F9E address(stack[-3]).code.length // } 0F92 5B JUMPDEST 0F93 60 PUSH1 0x20 0F95 60 PUSH1 0x40 0F97 51 MLOAD 0F98 80 DUP1 0F99 83 DUP4 0F9A 03 SUB 0F9B 81 DUP2 0F9C 86 DUP7 0F9D 80 DUP1 0F9E 3B EXTCODESIZE 0F9F 15 ISZERO 0FA0 80 DUP1 0FA1 15 ISZERO 0FA2 61 PUSH2 0x0faa 0FA5 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0F93 stack[0] = 0x20 // @0F97 stack[1] = memory[0x40:0x60] // @0F9A stack[2] = stack[-1] - memory[0x40:0x60] // @0F9B stack[3] = memory[0x40:0x60] // @0F9C stack[4] = stack[-3] // @0F9F stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0faa, if !!address(stack[-3]).code.length label_0FA6: // Incoming jump from 0x0FA5, if not !!address(stack[-3]).code.length // Inputs[1] { @0FA9 memory[0x00:0x00] } 0FA6 60 PUSH1 0x00 0FA8 80 DUP1 0FA9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FA9 revert(memory[0x00:0x00]); } // Block terminates label_0FAA: // Incoming jump from 0x0FA5, if !!address(stack[-3]).code.length // Inputs[8] // { // @0FAC msg.gas // @0FAD stack[-6] // @0FAD address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FAD stack[-2] // @0FAD stack[-3] // @0FAD stack[-4] // @0FAD memory[stack[-3]:stack[-3] + stack[-4]] // @0FAD stack[-5] // } 0FAA 5B JUMPDEST 0FAB 50 POP 0FAC 5A GAS 0FAD FA STATICCALL 0FAE 15 ISZERO 0FAF 80 DUP1 0FB0 15 ISZERO 0FB1 61 PUSH2 0x0fbe 0FB4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0FAD memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FAE stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0fbe, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0FB5: // Incoming jump from 0x0FB4, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0FB5 returndata.length // @0FB9 returndata[0x00:0x00 + returndata.length] // @0FBA returndata.length // @0FBD memory[0x00:0x00 + returndata.length] // } 0FB5 3D RETURNDATASIZE 0FB6 60 PUSH1 0x00 0FB8 80 DUP1 0FB9 3E RETURNDATACOPY 0FBA 3D RETURNDATASIZE 0FBB 60 PUSH1 0x00 0FBD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FB9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FBD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FBE: // Incoming jump from 0x0FB4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0FC5 memory[0x40:0x60] // @0FC6 returndata.length // } 0FBE 5B JUMPDEST 0FBF 50 POP 0FC0 50 POP 0FC1 50 POP 0FC2 50 POP 0FC3 60 PUSH1 0x40 0FC5 51 MLOAD 0FC6 3D RETURNDATASIZE 0FC7 60 PUSH1 0x1f 0FC9 19 NOT 0FCA 60 PUSH1 0x1f 0FCC 82 DUP3 0FCD 01 ADD 0FCE 16 AND 0FCF 82 DUP3 0FD0 01 ADD 0FD1 80 DUP1 0FD2 60 PUSH1 0x40 0FD4 52 MSTORE 0FD5 50 POP 0FD6 81 DUP2 0FD7 01 ADD 0FD8 90 SWAP1 0FD9 61 PUSH2 0x0fe2 0FDC 91 SWAP2 0FDD 90 SWAP1 0FDE 61 PUSH2 0x366d 0FE1 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0FD4 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0FDC stack[-4] = 0x0fe2 // @0FDD stack[-2] = memory[0x40:0x60] // @0FDD stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x0FE2 label_0FE2: // Incoming return from call to 0x366D at 0x0FE1 // Inputs[5] // { // @0FE5 storage[0x08] // @0FE6 stack[-1] // @0FE7 stack[-2] // @0FE9 address(this) // @0FE9 address(this).balance // } 0FE2 5B JUMPDEST 0FE3 60 PUSH1 0x08 0FE5 54 SLOAD 0FE6 90 SWAP1 0FE7 91 SWAP2 0FE8 50 POP 0FE9 47 SELFBALANCE 0FEA 90 SWAP1 0FEB 81 DUP2 0FEC 83 DUP4 0FED 01 ADD 0FEE 11 GT 0FEF 15 ISZERO 0FF0 61 PUSH2 0x1006 0FF3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0FE7 stack[-2] = stack[-1] // @0FEA stack[-1] = address(this).balance // } // Block ends with conditional jump to 0x1006, if !(stack[-1] + address(this).balance > storage[0x08]) label_0FF4: // Incoming jump from 0x0FF3, if not !(stack[-1] + address(this).balance > storage[0x08]) // Inputs[4] // { // @0FF6 storage[0x08] // @0FF7 stack[-1] // @0FF8 stack[-2] // @0FFF stack[-3] // } 0FF4 60 PUSH1 0x08 0FF6 54 SLOAD 0FF7 81 DUP2 0FF8 83 DUP4 0FF9 01 ADD 0FFA 03 SUB 0FFB 61 PUSH2 0x1004 0FFE 81 DUP2 0FFF 85 DUP6 1000 61 PUSH2 0x081c 1003 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FFA stack[0] = (stack[-2] + stack[-1]) - storage[0x08] // @0FFB stack[1] = 0x1004 // @0FFE stack[2] = (stack[-2] + stack[-1]) - storage[0x08] // @0FFF stack[3] = stack[-3] // } // Block ends with call to 0x081c, returns to 0x1004 label_1004: // Incoming return from call to 0x081C at 0x1003 1004 5B JUMPDEST 1005 50 POP // Stack delta = -1 // Block continues label_1006: // Incoming jump from 0x1005 // Incoming jump from 0x0FF3, if !(stack[-1] + address(this).balance > storage[0x08]) 1006 5B JUMPDEST 1007 60 PUSH1 0x00 1009 61 PUSH2 0x1010 100C 61 PUSH2 0x2876 100F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1007 stack[0] = 0x00 // @1009 stack[1] = 0x1010 // } // Block ends with call to 0x2876, returns to 0x1010 label_1010: // Incoming return from call to 0x2876 at 0x100F // Inputs[2] // { // @1011 stack[-2] // @1011 stack[-1] // } 1010 5B JUMPDEST 1011 90 SWAP1 1012 50 POP 1013 80 DUP1 1014 15 ISZERO 1015 61 PUSH2 0x1078 1018 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1011 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1078, if !stack[-1] label_1019: // Incoming jump from 0x1018, if not !stack[-1] // Inputs[3] // { // @101B block.coinbase // @1025 stack[-1] // @1028 memory[0x40:0x60] // } 1019 60 PUSH1 0x00 101B 41 COINBASE 101C 60 PUSH1 0x01 101E 60 PUSH1 0x01 1020 60 PUSH1 0xa0 1022 1B SHL 1023 03 SUB 1024 16 AND 1025 82 DUP3 1026 60 PUSH1 0x40 1028 51 MLOAD 1029 61 PUSH2 0x1031 102C 90 SWAP1 102D 61 PUSH2 0x3722 1030 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1019 stack[0] = 0x00 // @1024 stack[1] = (0x01 << 0xa0) - 0x01 & block.coinbase // @1025 stack[2] = stack[-1] // @102C stack[3] = 0x1031 // @102C stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x3722, returns to 0x1031 label_1031: // Incoming return from call to 0x3722 at 0x1030 // Inputs[8] // { // @1036 memory[0x40:0x60] // @1038 stack[-1] // @103B stack[-2] // @103C stack[-3] // @103D msg.gas // @103E address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @103E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1043 returndata.length // } 1031 5B JUMPDEST 1032 60 PUSH1 0x00 1034 60 PUSH1 0x40 1036 51 MLOAD 1037 80 DUP1 1038 83 DUP4 1039 03 SUB 103A 81 DUP2 103B 85 DUP6 103C 87 DUP8 103D 5A GAS 103E F1 CALL 103F 92 SWAP3 1040 50 POP 1041 50 POP 1042 50 POP 1043 3D RETURNDATASIZE 1044 80 DUP1 1045 60 PUSH1 0x00 1047 81 DUP2 1048 14 EQ 1049 61 PUSH2 0x106e 104C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @103E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @103F stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1043 stack[-2] = returndata.length // @1044 stack[-1] = returndata.length // } // Block ends with conditional jump to 0x106e, if returndata.length == 0x00 label_104D: // Incoming jump from 0x104C, if not returndata.length == 0x00 // Inputs[6] // { // @104F memory[0x40:0x60] // @1050 stack[-2] // @1057 returndata.length // @105F returndata.length // @1062 returndata.length // @1069 returndata[0x00:0x00 + returndata.length] // } 104D 60 PUSH1 0x40 104F 51 MLOAD 1050 91 SWAP2 1051 50 POP 1052 60 PUSH1 0x1f 1054 19 NOT 1055 60 PUSH1 0x3f 1057 3D RETURNDATASIZE 1058 01 ADD 1059 16 AND 105A 82 DUP3 105B 01 ADD 105C 60 PUSH1 0x40 105E 52 MSTORE 105F 3D RETURNDATASIZE 1060 82 DUP3 1061 52 MSTORE 1062 3D RETURNDATASIZE 1063 60 PUSH1 0x00 1065 60 PUSH1 0x20 1067 84 DUP5 1068 01 ADD 1069 3E RETURNDATACOPY 106A 61 PUSH2 0x1073 106D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1050 stack[-2] = memory[0x40:0x60] // @105E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1061 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1069 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1073 label_106E: // Incoming jump from 0x104C, if returndata.length == 0x00 // Inputs[1] { @1071 stack[-2] } 106E 5B JUMPDEST 106F 60 PUSH1 0x60 1071 91 SWAP2 1072 50 POP 1073 5B JUMPDEST 1074 50 POP 1075 50 POP 1076 50 POP 1077 50 POP // Stack delta = -4 // Block continues label_1078: // Incoming jump from 0x1077 // Incoming return from call to 0x290C at 0x1EF4 // Incoming jump from 0x29DB, if stack[-1] // Incoming return from call to 0x290C at 0x1EF4 // Incoming jump from 0x1077 // Incoming jump from 0x1018, if !stack[-1] // Inputs[1] { @107E stack[-6] } 1078 5B JUMPDEST 1079 50 POP 107A 50 POP 107B 50 POP 107C 50 POP 107D 50 POP 107E 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_107F: // Incoming jump from 0x045B // Inputs[2] // { // @1083 stack[-2] // @1084 stack[-1] // } 107F 5B JUMPDEST 1080 61 PUSH2 0x0a97 1083 82 DUP3 1084 82 DUP3 1085 61 PUSH2 0x2882 1088 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1080 stack[0] = 0x0a97 // @1083 stack[1] = stack[-2] // @1084 stack[2] = stack[-1] // } // Block ends with call to 0x2882, returns to 0x0A97 label_1089: // Incoming jump from 0x047B // Inputs[1] { @1090 storage[0x06] } 1089 5B JUMPDEST 108A 60 PUSH1 0x00 108C 80 DUP1 108D 5B JUMPDEST 108E 60 PUSH1 0x06 1090 54 SLOAD 1091 81 DUP2 1092 10 LT 1093 15 ISZERO 1094 61 PUSH2 0x10c8 1097 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @108A stack[0] = 0x00 // @108C stack[1] = 0x00 // } // Block ends with conditional jump to 0x10c8, if !(0x00 < storage[0x06]) label_1098: // Incoming jump from 0x1097, if not !(stack[-1] < storage[0x06]) // Incoming jump from 0x1097, if not !(0x00 < storage[0x06]) // Inputs[3] // { // @1098 stack[-3] // @109B stack[-1] // @109D storage[0x06] // } 1098 82 DUP3 1099 60 PUSH1 0x06 109B 82 DUP3 109C 81 DUP2 109D 54 SLOAD 109E 81 DUP2 109F 10 LT 10A0 61 PUSH2 0x10a5 10A3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1098 stack[0] = stack[-3] // @1099 stack[1] = 0x06 // @109B stack[2] = stack[-1] // } // Block ends with conditional jump to 0x10a5, if stack[-1] < storage[0x06] label_10A4: // Incoming jump from 0x10A3, if not stack[-1] < storage[0x06] 10A4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @10A4 assert(); } // Block terminates label_10A5: // Incoming jump from 0x10A3, if stack[-1] < storage[0x06] // Inputs[5] // { // @10A6 stack[-1] // @10A6 stack[-2] // @10AE memory[0x00:0x20] // @10B0 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @10B1 stack[-3] // } 10A5 5B JUMPDEST 10A6 90 SWAP1 10A7 60 PUSH1 0x00 10A9 52 MSTORE 10AA 60 PUSH1 0x20 10AC 60 PUSH1 0x00 10AE 20 SHA3 10AF 01 ADD 10B0 54 SLOAD 10B1 14 EQ 10B2 15 ISZERO 10B3 61 PUSH2 0x10c0 10B6 57 *JUMPI // Stack delta = -3 // Outputs[1] { @10A9 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x10c0, if !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) label_10B7: // Incoming jump from 0x10B6, if not !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) // Inputs[1] { @10B9 stack[-2] } 10B7 60 PUSH1 0x01 10B9 91 SWAP2 10BA 50 POP 10BB 50 POP 10BC 61 PUSH2 0x0d65 10BF 56 *JUMP // Stack delta = -1 // Outputs[1] { @10B9 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x0d65 label_10C0: // Incoming jump from 0x10B6, if !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] == stack[-3]) // Inputs[1] { @10C3 stack[-1] } 10C0 5B JUMPDEST 10C1 60 PUSH1 0x01 10C3 01 ADD 10C4 61 PUSH2 0x108d 10C7 56 *JUMP // Stack delta = +0 // Outputs[1] { @10C3 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x108d label_10C8: // Incoming jump from 0x1097, if !(stack[-1] < storage[0x06]) // Incoming jump from 0x1097, if !(0x00 < storage[0x06]) // Inputs[2] // { // @10CC stack[-4] // @10CD stack[-3] // } 10C8 5B JUMPDEST 10C9 50 POP 10CA 60 PUSH1 0x00 10CC 92 SWAP3 10CD 91 SWAP2 10CE 50 POP 10CF 50 POP 10D0 56 *JUMP // Stack delta = -3 // Outputs[1] { @10CC stack[-4] = 0x00 } // Block ends with unconditional jump to stack[-4] label_10D1: // Incoming call from 0x0490, returns to 0x0352 // Inputs[2] // { // @10D4 storage[0x05] // @10D5 stack[-1] // } 10D1 5B JUMPDEST 10D2 60 PUSH1 0x05 10D4 54 SLOAD 10D5 81 DUP2 10D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @10D4 stack[0] = storage[0x05] } // Block ends with unconditional jump to stack[-1] label_10D7: // Incoming call from 0x0F57, returns to 0x0F58 // Incoming jump from 0x04B0 10D7 5B JUMPDEST 10D8 61 PUSH2 0x10df 10DB 61 PUSH2 0x1a26 10DE 56 *JUMP // Stack delta = +1 // Outputs[1] { @10D8 stack[0] = 0x10df } // Block ends with call to 0x1a26, returns to 0x10DF label_10DF: // Incoming return from call to 0x1A26 at 0x10DE // Inputs[1] { @10E3 stack[-1] } 10DF 5B JUMPDEST 10E0 61 PUSH2 0x10fb 10E3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10fb, if stack[-1] label_10E4: // Incoming jump from 0x10E3, if not stack[-1] // Inputs[1] { @10E6 memory[0x40:0x60] } 10E4 60 PUSH1 0x40 10E6 51 MLOAD 10E7 62 PUSH3 0x461bcd 10EB 60 PUSH1 0xe5 10ED 1B SHL 10EE 81 DUP2 10EF 52 MSTORE 10F0 60 PUSH1 0x04 10F2 01 ADD 10F3 61 PUSH2 0x0840 10F6 90 SWAP1 10F7 61 PUSH2 0x3a86 10FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10F6 stack[0] = 0x0840 // @10F6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_10FB: // Incoming jump from 0x10E3, if stack[-1] // Inputs[2] // { // @10FE memory[0x40:0x60] // @112E address(this) // } 10FB 5B JUMPDEST 10FC 60 PUSH1 0x40 10FE 51 MLOAD 10FF 63 PUSH4 0x70a08231 1104 60 PUSH1 0xe0 1106 1B SHL 1107 81 DUP2 1108 52 MSTORE 1109 73 PUSH20 0x6b175474e89094c44da98b954eedeac495271d0f 111E 90 SWAP1 111F 60 PUSH1 0x00 1121 90 SWAP1 1122 82 DUP3 1123 90 SWAP1 1124 63 PUSH4 0x70a08231 1129 90 SWAP1 112A 61 PUSH2 0x1137 112D 90 SWAP1 112E 30 ADDRESS 112F 90 SWAP1 1130 60 PUSH1 0x04 1132 01 ADD 1133 61 PUSH2 0x3725 1136 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1108 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @111E stack[0] = 0x6b175474e89094c44da98b954eedeac495271d0f // @1121 stack[1] = 0x00 // @1123 stack[2] = 0x6b175474e89094c44da98b954eedeac495271d0f // @1129 stack[3] = 0x70a08231 // @112D stack[4] = 0x1137 // @112F stack[5] = address(this) // @1132 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x1137 label_1137: // Incoming return from call to 0x3725 at 0x1136 // Inputs[4] // { // @113C memory[0x40:0x60] // @113E stack[-1] // @1141 stack[-3] // @1143 address(stack[-3]).code.length // } 1137 5B JUMPDEST 1138 60 PUSH1 0x20 113A 60 PUSH1 0x40 113C 51 MLOAD 113D 80 DUP1 113E 83 DUP4 113F 03 SUB 1140 81 DUP2 1141 86 DUP7 1142 80 DUP1 1143 3B EXTCODESIZE 1144 15 ISZERO 1145 80 DUP1 1146 15 ISZERO 1147 61 PUSH2 0x114f 114A 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1138 stack[0] = 0x20 // @113C stack[1] = memory[0x40:0x60] // @113F stack[2] = stack[-1] - memory[0x40:0x60] // @1140 stack[3] = memory[0x40:0x60] // @1141 stack[4] = stack[-3] // @1144 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x114f, if !!address(stack[-3]).code.length label_114B: // Incoming jump from 0x114A, if not !!address(stack[-3]).code.length // Inputs[1] { @114E memory[0x00:0x00] } 114B 60 PUSH1 0x00 114D 80 DUP1 114E FD *REVERT // Stack delta = +0 // Outputs[1] { @114E revert(memory[0x00:0x00]); } // Block terminates label_114F: // Incoming jump from 0x114A, if !!address(stack[-3]).code.length // Inputs[8] // { // @1151 msg.gas // @1152 stack[-2] // @1152 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1152 stack[-6] // @1152 stack[-5] // @1152 memory[stack[-3]:stack[-3] + stack[-4]] // @1152 stack[-3] // @1152 stack[-4] // } 114F 5B JUMPDEST 1150 50 POP 1151 5A GAS 1152 FA STATICCALL 1153 15 ISZERO 1154 80 DUP1 1155 15 ISZERO 1156 61 PUSH2 0x1163 1159 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1152 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1153 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1163, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_115A: // Incoming jump from 0x1159, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @115A returndata.length // @115E returndata[0x00:0x00 + returndata.length] // @115F returndata.length // @1162 memory[0x00:0x00 + returndata.length] // } 115A 3D RETURNDATASIZE 115B 60 PUSH1 0x00 115D 80 DUP1 115E 3E RETURNDATACOPY 115F 3D RETURNDATASIZE 1160 60 PUSH1 0x00 1162 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @115E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1162 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1163: // Incoming jump from 0x1159, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @116A memory[0x40:0x60] // @116B returndata.length // } 1163 5B JUMPDEST 1164 50 POP 1165 50 POP 1166 50 POP 1167 50 POP 1168 60 PUSH1 0x40 116A 51 MLOAD 116B 3D RETURNDATASIZE 116C 60 PUSH1 0x1f 116E 19 NOT 116F 60 PUSH1 0x1f 1171 82 DUP3 1172 01 ADD 1173 16 AND 1174 82 DUP3 1175 01 ADD 1176 80 DUP1 1177 60 PUSH1 0x40 1179 52 MSTORE 117A 50 POP 117B 81 DUP2 117C 01 ADD 117D 90 SWAP1 117E 61 PUSH2 0x1187 1181 91 SWAP2 1182 90 SWAP1 1183 61 PUSH2 0x366d 1186 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1179 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1181 stack[-4] = 0x1187 // @1182 stack[-2] = memory[0x40:0x60] // @1182 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x1187 label_1187: // Incoming return from call to 0x366D at 0x1186 // Inputs[3] // { // @1188 stack[-2] // @1188 stack[-1] // @118C storage[0x0b] // } 1187 5B JUMPDEST 1188 90 SWAP1 1189 50 POP 118A 60 PUSH1 0x0b 118C 54 SLOAD 118D 81 DUP2 118E 10 LT 118F 15 ISZERO 1190 61 PUSH2 0x119a 1193 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1188 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x119a, if !(stack[-1] < storage[0x0b]) label_1194: // Incoming jump from 0x1193, if not !(stack[-1] < storage[0x0b]) 1194 50 POP 1195 50 POP 1196 61 PUSH2 0x0a97 1199 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0a97 label_119A: // Incoming jump from 0x1193, if !(stack[-1] < storage[0x0b]) // Inputs[3] // { // @119D storage[0x0b] // @119E stack[-1] // @11A0 stack[-5] // } 119A 5B JUMPDEST 119B 60 PUSH1 0x0b 119D 54 SLOAD 119E 81 DUP2 119F 03 SUB 11A0 85 DUP6 11A1 61 PUSH2 0x11b7 11A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @119F stack[0] = stack[-1] - storage[0x0b] } // Block ends with conditional jump to 0x11b7, if stack[-5] label_11A5: // Incoming jump from 0x11A4, if not stack[-5] // Inputs[3] // { // @11A8 stack[-3] // @11A9 stack[-5] // @11AA stack[-1] // } 11A5 61 PUSH2 0x11af 11A8 83 DUP4 11A9 86 DUP7 11AA 83 DUP4 11AB 61 PUSH2 0x290c 11AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11A5 stack[0] = 0x11af // @11A8 stack[1] = stack[-3] // @11A9 stack[2] = stack[-5] // @11AA stack[3] = stack[-1] // } // Block ends with call to 0x290c, returns to 0x11AF label_11AF: // Incoming return from call to 0x290C at 0x151D // Incoming jump from 0x1E39, if stack[-3] // Incoming jump from 0x1E39, if stack[-3] // Incoming return from call to 0x290C at 0x163F // Incoming return from call to 0x290C at 0x11AE 11AF 5B JUMPDEST 11B0 50 POP 11B1 50 POP 11B2 50 POP 11B3 61 PUSH2 0x0a97 11B6 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x0a97 label_11B7: // Incoming jump from 0x11A4, if stack[-5] // Inputs[3] // { // @11FA stack[-1] // @11FB stack[-4] // @11FC stack[-5] // } 11B7 5B JUMPDEST 11B8 61 PUSH2 0x1201 11BB 73 PUSH20 0xa478c2975ab1ea89e8196811f51a7b7ade33eb11 11D0 73 PUSH20 0x6b175474e89094c44da98b954eedeac495271d0f 11E5 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 11FA 84 DUP5 11FB 88 DUP9 11FC 8A DUP11 11FD 61 PUSH2 0x29f3 1200 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @11B8 stack[0] = 0x1201 // @11BB stack[1] = 0xa478c2975ab1ea89e8196811f51a7b7ade33eb11 // @11D0 stack[2] = 0x6b175474e89094c44da98b954eedeac495271d0f // @11E5 stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @11FA stack[4] = stack[-1] // @11FB stack[5] = stack[-4] // @11FC stack[6] = stack[-5] // } // Block ends with unconditional jump to 0x29f3 1201 5B JUMPDEST 1202 50 POP 1203 50 POP 1204 50 POP 1205 50 POP 1206 50 POP 1207 50 POP 1208 50 POP 1209 56 *JUMP label_120A: // Incoming jump from 0x04D0 120A 5B JUMPDEST 120B 61 PUSH2 0x1212 120E 61 PUSH2 0x1a26 1211 56 *JUMP // Stack delta = +1 // Outputs[1] { @120B stack[0] = 0x1212 } // Block ends with call to 0x1a26, returns to 0x1212 label_1212: // Incoming return from call to 0x1A26 at 0x1211 // Inputs[1] { @1216 stack[-1] } 1212 5B JUMPDEST 1213 61 PUSH2 0x122e 1216 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x122e, if stack[-1] label_1217: // Incoming jump from 0x1216, if not stack[-1] // Inputs[1] { @1219 memory[0x40:0x60] } 1217 60 PUSH1 0x40 1219 51 MLOAD 121A 62 PUSH3 0x461bcd 121E 60 PUSH1 0xe5 1220 1B SHL 1221 81 DUP2 1222 52 MSTORE 1223 60 PUSH1 0x04 1225 01 ADD 1226 61 PUSH2 0x0840 1229 90 SWAP1 122A 61 PUSH2 0x3a86 122D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1222 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1229 stack[0] = 0x0840 // @1229 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_122E: // Incoming jump from 0x1216, if stack[-1] // Inputs[3] // { // @1232 storage[0x02] // @1245 stack[-1] // @124F stack[-2] // } 122E 5B JUMPDEST 122F 60 PUSH1 0x02 1231 80 DUP1 1232 54 SLOAD 1233 60 PUSH1 0x01 1235 60 PUSH1 0x01 1237 60 PUSH1 0xa0 1239 1B SHL 123A 03 SUB 123B 19 NOT 123C 16 AND 123D 60 PUSH1 0x01 123F 60 PUSH1 0x01 1241 60 PUSH1 0xa0 1243 1B SHL 1244 03 SUB 1245 92 SWAP3 1246 90 SWAP1 1247 92 SWAP3 1248 16 AND 1249 91 SWAP2 124A 90 SWAP1 124B 91 SWAP2 124C 17 OR 124D 90 SWAP1 124E 55 SSTORE 124F 56 *JUMP // Stack delta = -2 // Outputs[1] { @124E storage[0x02] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x02]) } // Block ends with unconditional jump to stack[-2] label_1250: // Incoming jump from 0x04F0 1250 5B JUMPDEST 1251 61 PUSH2 0x1258 1254 61 PUSH2 0x1a26 1257 56 *JUMP // Stack delta = +1 // Outputs[1] { @1251 stack[0] = 0x1258 } // Block ends with call to 0x1a26, returns to 0x1258 label_1258: // Incoming return from call to 0x1A26 at 0x1257 // Inputs[1] { @125C stack[-1] } 1258 5B JUMPDEST 1259 61 PUSH2 0x1274 125C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1274, if stack[-1] label_125D: // Incoming jump from 0x125C, if not stack[-1] // Inputs[1] { @125F memory[0x40:0x60] } 125D 60 PUSH1 0x40 125F 51 MLOAD 1260 62 PUSH3 0x461bcd 1264 60 PUSH1 0xe5 1266 1B SHL 1267 81 DUP2 1268 52 MSTORE 1269 60 PUSH1 0x04 126B 01 ADD 126C 61 PUSH2 0x0840 126F 90 SWAP1 1270 61 PUSH2 0x3a86 1273 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @126F stack[0] = 0x0840 // @126F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_1274: // Incoming jump from 0x125C, if stack[-1] // Inputs[2] // { // @1278 stack[-2] // @1279 memory[stack[-2]:stack[-2] + 0x20] // } 1274 5B JUMPDEST 1275 60 PUSH1 0x00 1277 5B JUMPDEST 1278 82 DUP3 1279 51 MLOAD 127A 81 DUP2 127B 10 LT 127C 15 ISZERO 127D 61 PUSH2 0x0a97 1280 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1275 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a97, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1281: // Incoming jump from 0x1280, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1280, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1281 stack[-2] // @1282 address(this).balance // @1282 address(this) // } 1281 81 DUP2 1282 47 SELFBALANCE 1283 10 LT 1284 15 ISZERO 1285 61 PUSH2 0x12eb 1288 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12eb, if !(address(this).balance < stack[-2]) label_1289: // Incoming jump from 0x1288, if not !(address(this).balance < stack[-2]) // Inputs[3] // { // @128B storage[0x02] // @128E memory[0x40:0x60] // @12AF stack[-2] // } 1289 60 PUSH1 0x02 128B 54 SLOAD 128C 60 PUSH1 0x40 128E 51 MLOAD 128F 63 PUSH4 0x2e1a7d4d 1294 60 PUSH1 0xe0 1296 1B SHL 1297 81 DUP2 1298 52 MSTORE 1299 60 PUSH1 0x01 129B 60 PUSH1 0x01 129D 60 PUSH1 0xa0 129F 1B SHL 12A0 03 SUB 12A1 90 SWAP1 12A2 91 SWAP2 12A3 16 AND 12A4 90 SWAP1 12A5 63 PUSH4 0x2e1a7d4d 12AA 90 SWAP1 12AB 61 PUSH2 0x12b8 12AE 90 SWAP1 12AF 85 DUP6 12B0 90 SWAP1 12B1 60 PUSH1 0x04 12B3 01 ADD 12B4 61 PUSH2 0x3c7d 12B7 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1298 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e1a7d4d << 0xe0 // @12A4 stack[0] = storage[0x02] & (0x01 << 0xa0) - 0x01 // @12AA stack[1] = 0x2e1a7d4d // @12AE stack[2] = 0x12b8 // @12B0 stack[3] = stack[-2] // @12B3 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3c7d, returns to 0x12B8 label_12B8: // Incoming return from call to 0x3C7D at 0x12B7 // Inputs[4] // { // @12BD memory[0x40:0x60] // @12BF stack[-1] // @12C4 stack[-3] // @12C6 address(stack[-3]).code.length // } 12B8 5B JUMPDEST 12B9 60 PUSH1 0x00 12BB 60 PUSH1 0x40 12BD 51 MLOAD 12BE 80 DUP1 12BF 83 DUP4 12C0 03 SUB 12C1 81 DUP2 12C2 60 PUSH1 0x00 12C4 87 DUP8 12C5 80 DUP1 12C6 3B EXTCODESIZE 12C7 15 ISZERO 12C8 80 DUP1 12C9 15 ISZERO 12CA 61 PUSH2 0x12d2 12CD 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @12B9 stack[0] = 0x00 // @12BD stack[1] = memory[0x40:0x60] // @12C0 stack[2] = stack[-1] - memory[0x40:0x60] // @12C1 stack[3] = memory[0x40:0x60] // @12C2 stack[4] = 0x00 // @12C4 stack[5] = stack[-3] // @12C7 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x12d2, if !!address(stack[-3]).code.length label_12CE: // Incoming jump from 0x12CD, if not !!address(stack[-3]).code.length // Inputs[1] { @12D1 memory[0x00:0x00] } 12CE 60 PUSH1 0x00 12D0 80 DUP1 12D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @12D1 revert(memory[0x00:0x00]); } // Block terminates label_12D2: // Incoming jump from 0x12CD, if !!address(stack[-3]).code.length // Inputs[9] // { // @12D4 msg.gas // @12D5 stack[-3] // @12D5 stack[-6] // @12D5 stack[-7] // @12D5 memory[stack[-4]:stack[-4] + stack[-5]] // @12D5 stack[-4] // @12D5 stack[-2] // @12D5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12D5 stack[-5] // } 12D2 5B JUMPDEST 12D3 50 POP 12D4 5A GAS 12D5 F1 CALL 12D6 15 ISZERO 12D7 80 DUP1 12D8 15 ISZERO 12D9 61 PUSH2 0x12e6 12DC 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @12D5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12D6 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x12e6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_12DD: // Incoming jump from 0x12DC, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @12DD returndata.length // @12E1 returndata[0x00:0x00 + returndata.length] // @12E2 returndata.length // @12E5 memory[0x00:0x00 + returndata.length] // } 12DD 3D RETURNDATASIZE 12DE 60 PUSH1 0x00 12E0 80 DUP1 12E1 3E RETURNDATACOPY 12E2 3D RETURNDATASIZE 12E3 60 PUSH1 0x00 12E5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12E1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @12E5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_12E6: // Incoming jump from 0x12DC, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 12E6 5B JUMPDEST 12E7 50 POP 12E8 50 POP 12E9 50 POP 12EA 50 POP // Stack delta = -4 // Block continues label_12EB: // Incoming jump from 0x1288, if !(address(this).balance < stack[-2]) // Incoming jump from 0x12EA // Inputs[3] // { // @12EE stack[-3] // @12EF stack[-1] // @12F1 memory[stack[-3]:stack[-3] + 0x20] // } 12EB 5B JUMPDEST 12EC 60 PUSH1 0x00 12EE 83 DUP4 12EF 82 DUP3 12F0 81 DUP2 12F1 51 MLOAD 12F2 81 DUP2 12F3 10 LT 12F4 61 PUSH2 0x12f9 12F7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @12EC stack[0] = 0x00 // @12EE stack[1] = stack[-3] // @12EF stack[2] = stack[-1] // } // Block ends with conditional jump to 0x12f9, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_12F8: // Incoming jump from 0x12F7, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 12F8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12F8 assert(); } // Block terminates label_12F9: // Incoming jump from 0x12F7, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @12FC stack[-1] // @1300 stack[-2] // @1301 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @130B stack[-5] // @130E memory[0x40:0x60] // } 12F9 5B JUMPDEST 12FA 60 PUSH1 0x20 12FC 02 MUL 12FD 60 PUSH1 0x20 12FF 01 ADD 1300 01 ADD 1301 51 MLOAD 1302 60 PUSH1 0x01 1304 60 PUSH1 0x01 1306 60 PUSH1 0xa0 1308 1B SHL 1309 03 SUB 130A 16 AND 130B 83 DUP4 130C 60 PUSH1 0x40 130E 51 MLOAD 130F 61 PUSH2 0x1317 1312 90 SWAP1 1313 61 PUSH2 0x3722 1316 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @130A stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @130B stack[-1] = stack[-5] // @1312 stack[1] = memory[0x40:0x60] // @1312 stack[0] = 0x1317 // } // Block ends with call to 0x3722, returns to 0x1317 label_1317: // Incoming return from call to 0x3722 at 0x1316 // Inputs[8] // { // @131C memory[0x40:0x60] // @131E stack[-1] // @1321 stack[-2] // @1322 stack[-3] // @1323 msg.gas // @1324 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1324 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1329 returndata.length // } 1317 5B JUMPDEST 1318 60 PUSH1 0x00 131A 60 PUSH1 0x40 131C 51 MLOAD 131D 80 DUP1 131E 83 DUP4 131F 03 SUB 1320 81 DUP2 1321 85 DUP6 1322 87 DUP8 1323 5A GAS 1324 F1 CALL 1325 92 SWAP3 1326 50 POP 1327 50 POP 1328 50 POP 1329 3D RETURNDATASIZE 132A 80 DUP1 132B 60 PUSH1 0x00 132D 81 DUP2 132E 14 EQ 132F 61 PUSH2 0x1354 1332 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1324 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1325 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1329 stack[-2] = returndata.length // @132A stack[-1] = returndata.length // } // Block ends with conditional jump to 0x1354, if returndata.length == 0x00 label_1333: // Incoming jump from 0x1332, if not returndata.length == 0x00 // Inputs[6] // { // @1335 memory[0x40:0x60] // @1336 stack[-2] // @133D returndata.length // @1345 returndata.length // @1348 returndata.length // @134F returndata[0x00:0x00 + returndata.length] // } 1333 60 PUSH1 0x40 1335 51 MLOAD 1336 91 SWAP2 1337 50 POP 1338 60 PUSH1 0x1f 133A 19 NOT 133B 60 PUSH1 0x3f 133D 3D RETURNDATASIZE 133E 01 ADD 133F 16 AND 1340 82 DUP3 1341 01 ADD 1342 60 PUSH1 0x40 1344 52 MSTORE 1345 3D RETURNDATASIZE 1346 82 DUP3 1347 52 MSTORE 1348 3D RETURNDATASIZE 1349 60 PUSH1 0x00 134B 60 PUSH1 0x20 134D 84 DUP5 134E 01 ADD 134F 3E RETURNDATACOPY 1350 61 PUSH2 0x1359 1353 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1336 stack[-2] = memory[0x40:0x60] // @1344 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1347 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @134F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1359 label_1354: // Incoming jump from 0x1332, if returndata.length == 0x00 // Inputs[3] // { // @1357 stack[-2] // @135C stack[-4] // @135C stack[-3] // } 1354 5B JUMPDEST 1355 60 PUSH1 0x60 1357 91 SWAP2 1358 50 POP 1359 5B JUMPDEST 135A 50 POP 135B 50 POP 135C 90 SWAP1 135D 50 POP 135E 80 DUP1 135F 61 PUSH2 0x137a 1362 57 *JUMPI // Stack delta = -3 // Outputs[1] { @135C stack[-4] = stack[-3] } // Block ends with conditional jump to 0x137a, if stack[-3] label_1363: // Incoming jump from 0x1362, if not stack[-3] // Incoming jump from 0x1362, if not stack[-3] // Inputs[1] { @1365 memory[0x40:0x60] } 1363 60 PUSH1 0x40 1365 51 MLOAD 1366 62 PUSH3 0x461bcd 136A 60 PUSH1 0xe5 136C 1B SHL 136D 81 DUP2 136E 52 MSTORE 136F 60 PUSH1 0x04 1371 01 ADD 1372 61 PUSH2 0x0840 1375 90 SWAP1 1376 61 PUSH2 0x3adc 1379 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @136E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1375 stack[0] = 0x0840 // @1375 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3adc, returns to 0x0840 label_137A: // Incoming jump from 0x1362, if stack[-3] // Incoming jump from 0x1362, if stack[-3] // Inputs[1] { @137E stack[-2] } 137A 5B JUMPDEST 137B 50 POP 137C 60 PUSH1 0x01 137E 01 ADD 137F 61 PUSH2 0x1277 1382 56 *JUMP // Stack delta = -1 // Outputs[1] { @137E stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x1277 label_1383: // Incoming jump from 0x0510 // Inputs[1] { @1386 storage[0x00] } 1383 5B JUMPDEST 1384 60 PUSH1 0x00 1386 54 SLOAD 1387 60 PUSH1 0x01 1389 60 PUSH1 0xa0 138B 1B SHL 138C 90 SWAP1 138D 04 DIV 138E 60 PUSH1 0xff 1390 16 AND 1391 15 ISZERO 1392 80 DUP1 1393 61 PUSH2 0x13ab 1396 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1391 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x13ab, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_1397: // Incoming jump from 0x1396, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @1398 msg.sender // @13A6 memory[0x00:0x40] // @13A7 storage[keccak256(memory[0x00:0x40])] // } 1397 50 POP 1398 33 CALLER 1399 60 PUSH1 0x00 139B 90 SWAP1 139C 81 DUP2 139D 52 MSTORE 139E 60 PUSH1 0x01 13A0 60 PUSH1 0x20 13A2 52 MSTORE 13A3 60 PUSH1 0x40 13A5 90 SWAP1 13A6 20 SHA3 13A7 54 SLOAD 13A8 60 PUSH1 0xff 13AA 16 AND 13AB 5B JUMPDEST 13AC 80 DUP1 13AD 61 PUSH2 0x13ce 13B0 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @139D memory[0x00:0x20] = msg.sender // @13A2 memory[0x20:0x40] = 0x01 // @13AA stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x13ce, if 0xff & storage[keccak256(memory[0x00:0x40])] label_13B1: // Incoming jump from 0x13B0, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x13B0, if not stack[-1] 13B1 50 POP 13B2 61 PUSH2 0x13b9 13B5 61 PUSH2 0x1a17 13B8 56 *JUMP // Stack delta = +0 // Outputs[1] { @13B2 stack[-1] = 0x13b9 } // Block ends with call to 0x1a17, returns to 0x13B9 label_13B9: // Incoming return from call to 0x1A17 at 0x13B8 // Inputs[2] // { // @13C2 stack[-1] // @13C3 msg.sender // } 13B9 5B JUMPDEST 13BA 60 PUSH1 0x01 13BC 60 PUSH1 0x01 13BE 60 PUSH1 0xa0 13C0 1B SHL 13C1 03 SUB 13C2 16 AND 13C3 33 CALLER 13C4 60 PUSH1 0x01 13C6 60 PUSH1 0x01 13C8 60 PUSH1 0xa0 13CA 1B SHL 13CB 03 SUB 13CC 16 AND 13CD 14 EQ // Stack delta = +0 // Outputs[1] { @13CD stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_13CE: // Incoming jump from 0x13B0, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x13B0, if stack[-1] // Incoming jump from 0x13CD // Inputs[1] { @13D2 stack[-1] } 13CE 5B JUMPDEST 13CF 61 PUSH2 0x13ea 13D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13ea, if stack[-1] label_13D3: // Incoming jump from 0x13D2, if not stack[-1] // Inputs[1] { @13D5 memory[0x40:0x60] } 13D3 60 PUSH1 0x40 13D5 51 MLOAD 13D6 62 PUSH3 0x461bcd 13DA 60 PUSH1 0xe5 13DC 1B SHL 13DD 81 DUP2 13DE 52 MSTORE 13DF 60 PUSH1 0x04 13E1 01 ADD 13E2 61 PUSH2 0x0840 13E5 90 SWAP1 13E6 61 PUSH2 0x399a 13E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E5 stack[0] = 0x0840 // @13E5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_13EA: // Incoming jump from 0x13D2, if stack[-1] // Inputs[2] // { // @13EE stack[-1] // @13EF memory[stack[-1]:stack[-1] + 0x20] // } 13EA 5B JUMPDEST 13EB 60 PUSH1 0x00 13ED 5B JUMPDEST 13EE 81 DUP2 13EF 51 MLOAD 13F0 81 DUP2 13F1 10 LT 13F2 15 ISZERO 13F3 61 PUSH2 0x1442 13F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13EB stack[0] = 0x00 } // Block ends with conditional jump to 0x1442, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_13F7: // Incoming jump from 0x13F6, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x13F6, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @13FD stack[-2] // @13FE stack[-1] // @1400 memory[stack[-2]:stack[-2] + 0x20] // } 13F7 60 PUSH1 0x00 13F9 60 PUSH1 0x0d 13FB 60 PUSH1 0x00 13FD 84 DUP5 13FE 84 DUP5 13FF 81 DUP2 1400 51 MLOAD 1401 81 DUP2 1402 10 LT 1403 61 PUSH2 0x1408 1406 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @13F7 stack[0] = 0x00 // @13F9 stack[1] = 0x0d // @13FB stack[2] = 0x00 // @13FD stack[3] = stack[-2] // @13FE stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1408, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_1407: // Incoming jump from 0x1406, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 1407 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1407 assert(); } // Block terminates label_1408: // Incoming jump from 0x1406, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[9] // { // @140B stack[-1] // @140E stack[-2] // @1414 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @141E stack[-3] // @1422 stack[-4] // @142B memory[0x00:0x00 + 0x40 + stack[-3]] // @142D storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // @1432 stack[-5] // @143D stack[-6] // } 1408 5B JUMPDEST 1409 60 PUSH1 0x20 140B 90 SWAP1 140C 81 DUP2 140D 02 MUL 140E 91 SWAP2 140F 90 SWAP1 1410 91 SWAP2 1411 01 ADD 1412 81 DUP2 1413 01 ADD 1414 51 MLOAD 1415 60 PUSH1 0x01 1417 60 PUSH1 0x01 1419 60 PUSH1 0xa0 141B 1B SHL 141C 03 SUB 141D 16 AND 141E 82 DUP3 141F 52 MSTORE 1420 81 DUP2 1421 01 ADD 1422 91 SWAP2 1423 90 SWAP1 1424 91 SWAP2 1425 52 MSTORE 1426 60 PUSH1 0x40 1428 01 ADD 1429 60 PUSH1 0x00 142B 20 SHA3 142C 80 DUP1 142D 54 SLOAD 142E 60 PUSH1 0xff 1430 19 NOT 1431 16 AND 1432 91 SWAP2 1433 15 ISZERO 1434 15 ISZERO 1435 91 SWAP2 1436 90 SWAP1 1437 91 SWAP2 1438 17 OR 1439 90 SWAP1 143A 55 SSTORE 143B 60 PUSH1 0x01 143D 01 ADD 143E 61 PUSH2 0x13ed 1441 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @141F memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1425 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // @143A storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] = !!stack[-5] | (~0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])]) // @143D stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x13ed label_1442: // Incoming jump from 0x1D58 // Incoming jump from 0x13F6, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x13F6, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1778, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1D41 // Incoming jump from 0x1D79, if !(0x03 == stack[-1]) // Incoming jump from 0x1C3D // Incoming jump from 0x1D6F // Incoming jump from 0x1A80 // Incoming jump from 0x1778, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @1445 stack[-3] } 1442 5B JUMPDEST 1443 50 POP 1444 50 POP 1445 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1446: // Incoming jump from 0x0530 // Incoming call from 0x0F3F, returns to 0x0F40 1446 5B JUMPDEST 1447 61 PUSH2 0x144e 144A 61 PUSH2 0x1a26 144D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1447 stack[0] = 0x144e } // Block ends with call to 0x1a26, returns to 0x144E label_144E: // Incoming return from call to 0x1A26 at 0x144D // Inputs[1] { @1452 stack[-1] } 144E 5B JUMPDEST 144F 61 PUSH2 0x146a 1452 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x146a, if stack[-1] label_1453: // Incoming jump from 0x1452, if not stack[-1] // Inputs[1] { @1455 memory[0x40:0x60] } 1453 60 PUSH1 0x40 1455 51 MLOAD 1456 62 PUSH3 0x461bcd 145A 60 PUSH1 0xe5 145C 1B SHL 145D 81 DUP2 145E 52 MSTORE 145F 60 PUSH1 0x04 1461 01 ADD 1462 61 PUSH2 0x0840 1465 90 SWAP1 1466 61 PUSH2 0x3a86 1469 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @145E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1465 stack[0] = 0x0840 // @1465 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_146A: // Incoming jump from 0x1452, if stack[-1] // Inputs[2] // { // @146D memory[0x40:0x60] // @149D address(this) // } 146A 5B JUMPDEST 146B 60 PUSH1 0x40 146D 51 MLOAD 146E 63 PUSH4 0x70a08231 1473 60 PUSH1 0xe0 1475 1B SHL 1476 81 DUP2 1477 52 MSTORE 1478 73 PUSH20 0xdac17f958d2ee523a2206206994597c13d831ec7 148D 90 SWAP1 148E 60 PUSH1 0x00 1490 90 SWAP1 1491 82 DUP3 1492 90 SWAP1 1493 63 PUSH4 0x70a08231 1498 90 SWAP1 1499 61 PUSH2 0x14a6 149C 90 SWAP1 149D 30 ADDRESS 149E 90 SWAP1 149F 60 PUSH1 0x04 14A1 01 ADD 14A2 61 PUSH2 0x3725 14A5 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1477 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @148D stack[0] = 0xdac17f958d2ee523a2206206994597c13d831ec7 // @1490 stack[1] = 0x00 // @1492 stack[2] = 0xdac17f958d2ee523a2206206994597c13d831ec7 // @1498 stack[3] = 0x70a08231 // @149C stack[4] = 0x14a6 // @149E stack[5] = address(this) // @14A1 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x14A6 label_14A6: // Incoming return from call to 0x3725 at 0x14A5 // Inputs[4] // { // @14AB memory[0x40:0x60] // @14AD stack[-1] // @14B0 stack[-3] // @14B2 address(stack[-3]).code.length // } 14A6 5B JUMPDEST 14A7 60 PUSH1 0x20 14A9 60 PUSH1 0x40 14AB 51 MLOAD 14AC 80 DUP1 14AD 83 DUP4 14AE 03 SUB 14AF 81 DUP2 14B0 86 DUP7 14B1 80 DUP1 14B2 3B EXTCODESIZE 14B3 15 ISZERO 14B4 80 DUP1 14B5 15 ISZERO 14B6 61 PUSH2 0x14be 14B9 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @14A7 stack[0] = 0x20 // @14AB stack[1] = memory[0x40:0x60] // @14AE stack[2] = stack[-1] - memory[0x40:0x60] // @14AF stack[3] = memory[0x40:0x60] // @14B0 stack[4] = stack[-3] // @14B3 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x14be, if !!address(stack[-3]).code.length label_14BA: // Incoming jump from 0x14B9, if not !!address(stack[-3]).code.length // Inputs[1] { @14BD memory[0x00:0x00] } 14BA 60 PUSH1 0x00 14BC 80 DUP1 14BD FD *REVERT // Stack delta = +0 // Outputs[1] { @14BD revert(memory[0x00:0x00]); } // Block terminates label_14BE: // Incoming jump from 0x14B9, if !!address(stack[-3]).code.length // Inputs[8] // { // @14C0 msg.gas // @14C1 stack[-5] // @14C1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14C1 memory[stack[-3]:stack[-3] + stack[-4]] // @14C1 stack[-3] // @14C1 stack[-4] // @14C1 stack[-6] // @14C1 stack[-2] // } 14BE 5B JUMPDEST 14BF 50 POP 14C0 5A GAS 14C1 FA STATICCALL 14C2 15 ISZERO 14C3 80 DUP1 14C4 15 ISZERO 14C5 61 PUSH2 0x14d2 14C8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14C1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14C2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x14d2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_14C9: // Incoming jump from 0x14C8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @14C9 returndata.length // @14CD returndata[0x00:0x00 + returndata.length] // @14CE returndata.length // @14D1 memory[0x00:0x00 + returndata.length] // } 14C9 3D RETURNDATASIZE 14CA 60 PUSH1 0x00 14CC 80 DUP1 14CD 3E RETURNDATACOPY 14CE 3D RETURNDATASIZE 14CF 60 PUSH1 0x00 14D1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14CD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @14D1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_14D2: // Incoming jump from 0x14C8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @14D9 memory[0x40:0x60] // @14DA returndata.length // } 14D2 5B JUMPDEST 14D3 50 POP 14D4 50 POP 14D5 50 POP 14D6 50 POP 14D7 60 PUSH1 0x40 14D9 51 MLOAD 14DA 3D RETURNDATASIZE 14DB 60 PUSH1 0x1f 14DD 19 NOT 14DE 60 PUSH1 0x1f 14E0 82 DUP3 14E1 01 ADD 14E2 16 AND 14E3 82 DUP3 14E4 01 ADD 14E5 80 DUP1 14E6 60 PUSH1 0x40 14E8 52 MSTORE 14E9 50 POP 14EA 81 DUP2 14EB 01 ADD 14EC 90 SWAP1 14ED 61 PUSH2 0x14f6 14F0 91 SWAP2 14F1 90 SWAP1 14F2 61 PUSH2 0x366d 14F5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @14E8 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @14F0 stack[-4] = 0x14f6 // @14F1 stack[-2] = memory[0x40:0x60] // @14F1 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x14F6 label_14F6: // Incoming return from call to 0x366D at 0x14F5 // Inputs[3] // { // @14F7 stack[-1] // @14F7 stack[-2] // @14FB storage[0x09] // } 14F6 5B JUMPDEST 14F7 90 SWAP1 14F8 50 POP 14F9 60 PUSH1 0x09 14FB 54 SLOAD 14FC 81 DUP2 14FD 10 LT 14FE 15 ISZERO 14FF 61 PUSH2 0x1509 1502 57 *JUMPI // Stack delta = -1 // Outputs[1] { @14F7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1509, if !(stack[-1] < storage[0x09]) label_1503: // Incoming jump from 0x1502, if not !(stack[-1] < storage[0x09]) 1503 50 POP 1504 50 POP 1505 61 PUSH2 0x0a97 1508 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0a97 label_1509: // Incoming jump from 0x1502, if !(stack[-1] < storage[0x09]) // Inputs[3] // { // @150C storage[0x09] // @150D stack[-1] // @150F stack[-5] // } 1509 5B JUMPDEST 150A 60 PUSH1 0x09 150C 54 SLOAD 150D 81 DUP2 150E 03 SUB 150F 85 DUP6 1510 61 PUSH2 0x151e 1513 57 *JUMPI // Stack delta = +1 // Outputs[1] { @150E stack[0] = stack[-1] - storage[0x09] } // Block ends with conditional jump to 0x151e, if stack[-5] label_1514: // Incoming jump from 0x1513, if not stack[-5] // Inputs[3] // { // @1517 stack[-3] // @1518 stack[-5] // @1519 stack[-1] // } 1514 61 PUSH2 0x11af 1517 83 DUP4 1518 86 DUP7 1519 83 DUP4 151A 61 PUSH2 0x290c 151D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1514 stack[0] = 0x11af // @1517 stack[1] = stack[-3] // @1518 stack[2] = stack[-5] // @1519 stack[3] = stack[-1] // } // Block ends with call to 0x290c, returns to 0x11AF label_151E: // Incoming jump from 0x1513, if stack[-5] // Inputs[3] // { // @1561 stack[-1] // @1562 stack[-4] // @1563 stack[-5] // } 151E 5B JUMPDEST 151F 61 PUSH2 0x1201 1522 73 PUSH20 0x0d4a11d5eeaac28ec3f61d100daf4d40471f1852 1537 73 PUSH20 0xdac17f958d2ee523a2206206994597c13d831ec7 154C 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1561 84 DUP5 1562 88 DUP9 1563 8A DUP11 1564 61 PUSH2 0x29f3 1567 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @151F stack[0] = 0x1201 // @1522 stack[1] = 0x0d4a11d5eeaac28ec3f61d100daf4d40471f1852 // @1537 stack[2] = 0xdac17f958d2ee523a2206206994597c13d831ec7 // @154C stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1561 stack[4] = stack[-1] // @1562 stack[5] = stack[-4] // @1563 stack[6] = stack[-5] // } // Block ends with unconditional jump to 0x29f3 label_1568: // Incoming call from 0x0F4B, returns to 0x0F4C // Incoming jump from 0x0550 1568 5B JUMPDEST 1569 61 PUSH2 0x1570 156C 61 PUSH2 0x1a26 156F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1569 stack[0] = 0x1570 } // Block ends with call to 0x1a26, returns to 0x1570 label_1570: // Incoming return from call to 0x1A26 at 0x156F // Inputs[1] { @1574 stack[-1] } 1570 5B JUMPDEST 1571 61 PUSH2 0x158c 1574 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x158c, if stack[-1] label_1575: // Incoming jump from 0x1574, if not stack[-1] // Inputs[1] { @1577 memory[0x40:0x60] } 1575 60 PUSH1 0x40 1577 51 MLOAD 1578 62 PUSH3 0x461bcd 157C 60 PUSH1 0xe5 157E 1B SHL 157F 81 DUP2 1580 52 MSTORE 1581 60 PUSH1 0x04 1583 01 ADD 1584 61 PUSH2 0x0840 1587 90 SWAP1 1588 61 PUSH2 0x3a86 158B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1580 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1587 stack[0] = 0x0840 // @1587 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_158C: // Incoming jump from 0x1574, if stack[-1] // Inputs[2] // { // @158F memory[0x40:0x60] // @15BF address(this) // } 158C 5B JUMPDEST 158D 60 PUSH1 0x40 158F 51 MLOAD 1590 63 PUSH4 0x70a08231 1595 60 PUSH1 0xe0 1597 1B SHL 1598 81 DUP2 1599 52 MSTORE 159A 73 PUSH20 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 15AF 90 SWAP1 15B0 60 PUSH1 0x00 15B2 90 SWAP1 15B3 82 DUP3 15B4 90 SWAP1 15B5 63 PUSH4 0x70a08231 15BA 90 SWAP1 15BB 61 PUSH2 0x15c8 15BE 90 SWAP1 15BF 30 ADDRESS 15C0 90 SWAP1 15C1 60 PUSH1 0x04 15C3 01 ADD 15C4 61 PUSH2 0x3725 15C7 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1599 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @15AF stack[0] = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 // @15B2 stack[1] = 0x00 // @15B4 stack[2] = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 // @15BA stack[3] = 0x70a08231 // @15BE stack[4] = 0x15c8 // @15C0 stack[5] = address(this) // @15C3 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x15C8 label_15C8: // Incoming return from call to 0x3725 at 0x15C7 // Inputs[4] // { // @15CD memory[0x40:0x60] // @15CF stack[-1] // @15D2 stack[-3] // @15D4 address(stack[-3]).code.length // } 15C8 5B JUMPDEST 15C9 60 PUSH1 0x20 15CB 60 PUSH1 0x40 15CD 51 MLOAD 15CE 80 DUP1 15CF 83 DUP4 15D0 03 SUB 15D1 81 DUP2 15D2 86 DUP7 15D3 80 DUP1 15D4 3B EXTCODESIZE 15D5 15 ISZERO 15D6 80 DUP1 15D7 15 ISZERO 15D8 61 PUSH2 0x15e0 15DB 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @15C9 stack[0] = 0x20 // @15CD stack[1] = memory[0x40:0x60] // @15D0 stack[2] = stack[-1] - memory[0x40:0x60] // @15D1 stack[3] = memory[0x40:0x60] // @15D2 stack[4] = stack[-3] // @15D5 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x15e0, if !!address(stack[-3]).code.length label_15DC: // Incoming jump from 0x15DB, if not !!address(stack[-3]).code.length // Inputs[1] { @15DF memory[0x00:0x00] } 15DC 60 PUSH1 0x00 15DE 80 DUP1 15DF FD *REVERT // Stack delta = +0 // Outputs[1] { @15DF revert(memory[0x00:0x00]); } // Block terminates label_15E0: // Incoming jump from 0x15DB, if !!address(stack[-3]).code.length // Inputs[8] // { // @15E2 msg.gas // @15E3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @15E3 stack[-2] // @15E3 stack[-5] // @15E3 stack[-4] // @15E3 stack[-3] // @15E3 stack[-6] // @15E3 memory[stack[-3]:stack[-3] + stack[-4]] // } 15E0 5B JUMPDEST 15E1 50 POP 15E2 5A GAS 15E3 FA STATICCALL 15E4 15 ISZERO 15E5 80 DUP1 15E6 15 ISZERO 15E7 61 PUSH2 0x15f4 15EA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @15E3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @15E4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x15f4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_15EB: // Incoming jump from 0x15EA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @15EB returndata.length // @15EF returndata[0x00:0x00 + returndata.length] // @15F0 returndata.length // @15F3 memory[0x00:0x00 + returndata.length] // } 15EB 3D RETURNDATASIZE 15EC 60 PUSH1 0x00 15EE 80 DUP1 15EF 3E RETURNDATACOPY 15F0 3D RETURNDATASIZE 15F1 60 PUSH1 0x00 15F3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15EF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @15F3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_15F4: // Incoming jump from 0x15EA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @15FB memory[0x40:0x60] // @15FC returndata.length // } 15F4 5B JUMPDEST 15F5 50 POP 15F6 50 POP 15F7 50 POP 15F8 50 POP 15F9 60 PUSH1 0x40 15FB 51 MLOAD 15FC 3D RETURNDATASIZE 15FD 60 PUSH1 0x1f 15FF 19 NOT 1600 60 PUSH1 0x1f 1602 82 DUP3 1603 01 ADD 1604 16 AND 1605 82 DUP3 1606 01 ADD 1607 80 DUP1 1608 60 PUSH1 0x40 160A 52 MSTORE 160B 50 POP 160C 81 DUP2 160D 01 ADD 160E 90 SWAP1 160F 61 PUSH2 0x1618 1612 91 SWAP2 1613 90 SWAP1 1614 61 PUSH2 0x366d 1617 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @160A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1612 stack[-4] = 0x1618 // @1613 stack[-2] = memory[0x40:0x60] // @1613 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x1618 label_1618: // Incoming return from call to 0x366D at 0x1617 // Inputs[3] // { // @1619 stack[-2] // @1619 stack[-1] // @161D storage[0x0a] // } 1618 5B JUMPDEST 1619 90 SWAP1 161A 50 POP 161B 60 PUSH1 0x0a 161D 54 SLOAD 161E 81 DUP2 161F 10 LT 1620 15 ISZERO 1621 61 PUSH2 0x162b 1624 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1619 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x162b, if !(stack[-1] < storage[0x0a]) label_1625: // Incoming jump from 0x1624, if not !(stack[-1] < storage[0x0a]) 1625 50 POP 1626 50 POP 1627 61 PUSH2 0x0a97 162A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0a97 label_162B: // Incoming jump from 0x1624, if !(stack[-1] < storage[0x0a]) // Inputs[3] // { // @162E storage[0x0a] // @162F stack[-1] // @1631 stack[-5] // } 162B 5B JUMPDEST 162C 60 PUSH1 0x0a 162E 54 SLOAD 162F 81 DUP2 1630 03 SUB 1631 85 DUP6 1632 61 PUSH2 0x1640 1635 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1630 stack[0] = stack[-1] - storage[0x0a] } // Block ends with conditional jump to 0x1640, if stack[-5] label_1636: // Incoming jump from 0x1635, if not stack[-5] // Inputs[3] // { // @1639 stack[-3] // @163A stack[-5] // @163B stack[-1] // } 1636 61 PUSH2 0x11af 1639 83 DUP4 163A 86 DUP7 163B 83 DUP4 163C 61 PUSH2 0x290c 163F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1636 stack[0] = 0x11af // @1639 stack[1] = stack[-3] // @163A stack[2] = stack[-5] // @163B stack[3] = stack[-1] // } // Block ends with call to 0x290c, returns to 0x11AF label_1640: // Incoming jump from 0x1635, if stack[-5] // Inputs[3] // { // @1683 stack[-1] // @1684 stack[-4] // @1685 stack[-5] // } 1640 5B JUMPDEST 1641 61 PUSH2 0x1201 1644 73 PUSH20 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc 1659 73 PUSH20 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 166E 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1683 84 DUP5 1684 88 DUP9 1685 8A DUP11 1686 61 PUSH2 0x29f3 1689 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1641 stack[0] = 0x1201 // @1644 stack[1] = 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc // @1659 stack[2] = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 // @166E stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1683 stack[4] = stack[-1] // @1684 stack[5] = stack[-4] // @1685 stack[6] = stack[-5] // } // Block ends with unconditional jump to 0x29f3 label_168A: // Incoming call from 0x0565, returns to 0x02DD 168A 5B JUMPDEST 168B 61 PUSH2 0x1692 168E 61 PUSH2 0x1a26 1691 56 *JUMP // Stack delta = +1 // Outputs[1] { @168B stack[0] = 0x1692 } // Block ends with call to 0x1a26, returns to 0x1692 label_1692: // Incoming return from call to 0x1A26 at 0x1691 // Inputs[1] { @1696 stack[-1] } 1692 5B JUMPDEST 1693 61 PUSH2 0x16ae 1696 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16ae, if stack[-1] label_1697: // Incoming jump from 0x1696, if not stack[-1] // Inputs[1] { @1699 memory[0x40:0x60] } 1697 60 PUSH1 0x40 1699 51 MLOAD 169A 62 PUSH3 0x461bcd 169E 60 PUSH1 0xe5 16A0 1B SHL 16A1 81 DUP2 16A2 52 MSTORE 16A3 60 PUSH1 0x04 16A5 01 ADD 16A6 61 PUSH2 0x0840 16A9 90 SWAP1 16AA 61 PUSH2 0x3a86 16AD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16A9 stack[0] = 0x0840 // @16A9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_16AE: // Incoming jump from 0x1696, if stack[-1] // Inputs[5] // { // @16B2 storage[0x00] // @16B5 memory[0x40:0x60] // @16E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16EA storage[0x00] // @16F7 stack[-1] // } 16AE 5B JUMPDEST 16AF 60 PUSH1 0x00 16B1 80 DUP1 16B2 54 SLOAD 16B3 60 PUSH1 0x40 16B5 51 MLOAD 16B6 60 PUSH1 0x01 16B8 60 PUSH1 0x01 16BA 60 PUSH1 0xa0 16BC 1B SHL 16BD 03 SUB 16BE 90 SWAP1 16BF 91 SWAP2 16C0 16 AND 16C1 90 SWAP1 16C2 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 16E3 90 SWAP1 16E4 83 DUP4 16E5 90 SWAP1 16E6 A3 LOG3 16E7 60 PUSH1 0x00 16E9 80 DUP1 16EA 54 SLOAD 16EB 60 PUSH1 0x01 16ED 60 PUSH1 0x01 16EF 60 PUSH1 0xa0 16F1 1B SHL 16F2 03 SUB 16F3 19 NOT 16F4 16 AND 16F5 90 SWAP1 16F6 55 SSTORE 16F7 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @16E6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, 0x00]); // @16F6 storage[0x00] = ~((0x01 << 0xa0) - 0x01) & storage[0x00] // } // Block ends with unconditional jump to stack[-1] label_16F8: // Incoming jump from 0x0585 // Inputs[1] { @16FB storage[0x00] } 16F8 5B JUMPDEST 16F9 60 PUSH1 0x00 16FB 54 SLOAD 16FC 60 PUSH1 0x01 16FE 60 PUSH1 0xa0 1700 1B SHL 1701 90 SWAP1 1702 04 DIV 1703 60 PUSH1 0xff 1705 16 AND 1706 15 ISZERO 1707 80 DUP1 1708 61 PUSH2 0x1720 170B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1706 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x1720, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_170C: // Incoming jump from 0x170B, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @170D msg.sender // @171B memory[0x00:0x40] // @171C storage[keccak256(memory[0x00:0x40])] // } 170C 50 POP 170D 33 CALLER 170E 60 PUSH1 0x00 1710 90 SWAP1 1711 81 DUP2 1712 52 MSTORE 1713 60 PUSH1 0x01 1715 60 PUSH1 0x20 1717 52 MSTORE 1718 60 PUSH1 0x40 171A 90 SWAP1 171B 20 SHA3 171C 54 SLOAD 171D 60 PUSH1 0xff 171F 16 AND 1720 5B JUMPDEST 1721 80 DUP1 1722 61 PUSH2 0x1743 1725 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1712 memory[0x00:0x20] = msg.sender // @1717 memory[0x20:0x40] = 0x01 // @171F stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1743, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1726: // Incoming jump from 0x1725, if not stack[-1] // Incoming jump from 0x1725, if not 0xff & storage[keccak256(memory[0x00:0x40])] 1726 50 POP 1727 61 PUSH2 0x172e 172A 61 PUSH2 0x1a17 172D 56 *JUMP // Stack delta = +0 // Outputs[1] { @1727 stack[-1] = 0x172e } // Block ends with call to 0x1a17, returns to 0x172E label_172E: // Incoming return from call to 0x1A17 at 0x172D // Inputs[2] // { // @1737 stack[-1] // @1738 msg.sender // } 172E 5B JUMPDEST 172F 60 PUSH1 0x01 1731 60 PUSH1 0x01 1733 60 PUSH1 0xa0 1735 1B SHL 1736 03 SUB 1737 16 AND 1738 33 CALLER 1739 60 PUSH1 0x01 173B 60 PUSH1 0x01 173D 60 PUSH1 0xa0 173F 1B SHL 1740 03 SUB 1741 16 AND 1742 14 EQ // Stack delta = +0 // Outputs[1] { @1742 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1743: // Incoming jump from 0x1742 // Incoming jump from 0x1725, if stack[-1] // Incoming jump from 0x1725, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1747 stack[-1] } 1743 5B JUMPDEST 1744 61 PUSH2 0x175f 1747 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x175f, if stack[-1] label_1748: // Incoming jump from 0x1747, if not stack[-1] // Inputs[1] { @174A memory[0x40:0x60] } 1748 60 PUSH1 0x40 174A 51 MLOAD 174B 62 PUSH3 0x461bcd 174F 60 PUSH1 0xe5 1751 1B SHL 1752 81 DUP2 1753 52 MSTORE 1754 60 PUSH1 0x04 1756 01 ADD 1757 61 PUSH2 0x0840 175A 90 SWAP1 175B 61 PUSH2 0x399a 175E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1753 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @175A stack[0] = 0x0840 // @175A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_175F: // Incoming jump from 0x1747, if stack[-1] // Inputs[3] // { // @1763 storage[0x0c] // @1770 stack[-1] // @1771 memory[stack[-1]:stack[-1] + 0x20] // } 175F 5B JUMPDEST 1760 60 PUSH1 0x0c 1762 80 DUP1 1763 54 SLOAD 1764 60 PUSH1 0xff 1766 19 NOT 1767 16 AND 1768 60 PUSH1 0x01 176A 17 OR 176B 90 SWAP1 176C 55 SSTORE 176D 60 PUSH1 0x00 176F 5B JUMPDEST 1770 81 DUP2 1771 51 MLOAD 1772 81 DUP2 1773 10 LT 1774 15 ISZERO 1775 61 PUSH2 0x1442 1778 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @176C storage[0x0c] = 0x01 | (~0xff & storage[0x0c]) // @176D stack[0] = 0x00 // } // Block ends with conditional jump to 0x1442, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1779: // Incoming jump from 0x1778, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1778, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @177F stack[-2] // @1780 stack[-1] // @1782 memory[stack[-2]:stack[-2] + 0x20] // } 1779 60 PUSH1 0x01 177B 60 PUSH1 0x0d 177D 60 PUSH1 0x00 177F 84 DUP5 1780 84 DUP5 1781 81 DUP2 1782 51 MLOAD 1783 81 DUP2 1784 10 LT 1785 61 PUSH2 0x178a 1788 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1779 stack[0] = 0x01 // @177B stack[1] = 0x0d // @177D stack[2] = 0x00 // @177F stack[3] = stack[-2] // @1780 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x178a, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_1789: // Incoming jump from 0x1788, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 1789 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1789 assert(); } // Block terminates label_178A: // Incoming jump from 0x1788, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[9] // { // @178D stack[-1] // @1790 stack[-2] // @1796 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17A0 stack[-3] // @17A4 stack[-4] // @17AD memory[0x00:0x00 + 0x40 + stack[-3]] // @17AF storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // @17B4 stack[-5] // @17BF stack[-6] // } 178A 5B JUMPDEST 178B 60 PUSH1 0x20 178D 90 SWAP1 178E 81 DUP2 178F 02 MUL 1790 91 SWAP2 1791 90 SWAP1 1792 91 SWAP2 1793 01 ADD 1794 81 DUP2 1795 01 ADD 1796 51 MLOAD 1797 60 PUSH1 0x01 1799 60 PUSH1 0x01 179B 60 PUSH1 0xa0 179D 1B SHL 179E 03 SUB 179F 16 AND 17A0 82 DUP3 17A1 52 MSTORE 17A2 81 DUP2 17A3 01 ADD 17A4 91 SWAP2 17A5 90 SWAP1 17A6 91 SWAP2 17A7 52 MSTORE 17A8 60 PUSH1 0x40 17AA 01 ADD 17AB 60 PUSH1 0x00 17AD 20 SHA3 17AE 80 DUP1 17AF 54 SLOAD 17B0 60 PUSH1 0xff 17B2 19 NOT 17B3 16 AND 17B4 91 SWAP2 17B5 15 ISZERO 17B6 15 ISZERO 17B7 91 SWAP2 17B8 90 SWAP1 17B9 91 SWAP2 17BA 17 OR 17BB 90 SWAP1 17BC 55 SSTORE 17BD 60 PUSH1 0x01 17BF 01 ADD 17C0 61 PUSH2 0x176f 17C3 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @17A1 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17A7 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // @17BC storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] = !!stack[-5] | (~0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])]) // @17BF stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x176f label_17C4: // Incoming jump from 0x05A5 17C4 5B JUMPDEST 17C5 61 PUSH2 0x17cc 17C8 61 PUSH2 0x1a26 17CB 56 *JUMP // Stack delta = +1 // Outputs[1] { @17C5 stack[0] = 0x17cc } // Block ends with call to 0x1a26, returns to 0x17CC label_17CC: // Incoming return from call to 0x1A26 at 0x17CB // Inputs[1] { @17D0 stack[-1] } 17CC 5B JUMPDEST 17CD 61 PUSH2 0x17e8 17D0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17e8, if stack[-1] label_17D1: // Incoming jump from 0x17D0, if not stack[-1] // Inputs[1] { @17D3 memory[0x40:0x60] } 17D1 60 PUSH1 0x40 17D3 51 MLOAD 17D4 62 PUSH3 0x461bcd 17D8 60 PUSH1 0xe5 17DA 1B SHL 17DB 81 DUP2 17DC 52 MSTORE 17DD 60 PUSH1 0x04 17DF 01 ADD 17E0 61 PUSH2 0x0840 17E3 90 SWAP1 17E4 61 PUSH2 0x3a86 17E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17E3 stack[0] = 0x0840 // @17E3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_17E8: // Incoming jump from 0x17D0, if stack[-1] // Inputs[1] { @17F1 stack[-1] } 17E8 5B JUMPDEST 17E9 60 PUSH1 0x01 17EB 60 PUSH1 0x01 17ED 60 PUSH1 0xa0 17EF 1B SHL 17F0 03 SUB 17F1 81 DUP2 17F2 16 AND 17F3 61 PUSH2 0x180e 17F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x180e, if stack[-1] & (0x01 << 0xa0) - 0x01 label_17F7: // Incoming jump from 0x17F6, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @17F9 memory[0x40:0x60] } 17F7 60 PUSH1 0x40 17F9 51 MLOAD 17FA 62 PUSH3 0x461bcd 17FE 60 PUSH1 0xe5 1800 1B SHL 1801 81 DUP2 1802 52 MSTORE 1803 60 PUSH1 0x04 1805 01 ADD 1806 61 PUSH2 0x0840 1809 90 SWAP1 180A 61 PUSH2 0x3b3b 180D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1802 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1809 stack[0] = 0x0840 // @1809 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3b3b, returns to 0x0840 label_180E: // Incoming jump from 0x17F6, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1817 stack[-1] // @1828 memory[0x00:0x40] // @182A storage[keccak256(memory[0x00:0x40])] // @1834 storage[0x00] // } 180E 5B JUMPDEST 180F 60 PUSH1 0x01 1811 60 PUSH1 0x01 1813 60 PUSH1 0xa0 1815 1B SHL 1816 03 SUB 1817 81 DUP2 1818 16 AND 1819 60 PUSH1 0x00 181B 90 SWAP1 181C 81 DUP2 181D 52 MSTORE 181E 60 PUSH1 0x01 1820 60 PUSH1 0x20 1822 81 DUP2 1823 90 SWAP1 1824 52 MSTORE 1825 60 PUSH1 0x40 1827 82 DUP3 1828 20 SHA3 1829 80 DUP1 182A 54 SLOAD 182B 60 PUSH1 0xff 182D 19 NOT 182E 16 AND 182F 90 SWAP1 1830 91 SWAP2 1831 17 OR 1832 90 SWAP1 1833 55 SSTORE 1834 54 SLOAD 1835 60 PUSH1 0x01 1837 60 PUSH1 0xa0 1839 1B SHL 183A 90 SWAP1 183B 04 DIV 183C 60 PUSH1 0xff 183E 16 AND 183F 61 PUSH2 0x0b67 1842 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @181D memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1824 memory[0x20:0x40] = 0x01 // @1833 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with conditional jump to 0x0b67, if 0xff & storage[0x00] / (0x01 << 0xa0) label_1843: // Incoming jump from 0x1842, if not 0xff & storage[0x00] / (0x01 << 0xa0) // Inputs[2] // { // @1846 storage[0x00] // @1857 stack[-2] // } 1843 60 PUSH1 0x00 1845 80 DUP1 1846 54 SLOAD 1847 60 PUSH1 0xff 1849 60 PUSH1 0xa0 184B 1B SHL 184C 19 NOT 184D 16 AND 184E 60 PUSH1 0x01 1850 60 PUSH1 0xa0 1852 1B SHL 1853 17 OR 1854 90 SWAP1 1855 55 SSTORE 1856 50 POP 1857 56 *JUMP // Stack delta = -2 // Outputs[1] { @1855 storage[0x00] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x00]) } // Block ends with unconditional jump to stack[-2] label_1858: // Incoming call from 0x05BA, returns to 0x03CA // Inputs[2] // { // @185B storage[0x04] // @185F stack[-1] // } 1858 5B JUMPDEST 1859 60 PUSH1 0x04 185B 54 SLOAD 185C 60 PUSH1 0xff 185E 16 AND 185F 81 DUP2 1860 56 *JUMP // Stack delta = +1 // Outputs[1] { @185E stack[0] = 0xff & storage[0x04] } // Block ends with unconditional jump to stack[-1] label_1861: // Incoming jump from 0x05DA // Inputs[1] { @1864 storage[0x00] } 1861 5B JUMPDEST 1862 60 PUSH1 0x00 1864 54 SLOAD 1865 60 PUSH1 0x01 1867 60 PUSH1 0xa0 1869 1B SHL 186A 90 SWAP1 186B 04 DIV 186C 60 PUSH1 0xff 186E 16 AND 186F 15 ISZERO 1870 80 DUP1 1871 61 PUSH2 0x1889 1874 57 *JUMPI // Stack delta = +1 // Outputs[1] { @186F stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x1889, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_1875: // Incoming jump from 0x1874, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @1876 msg.sender // @1884 memory[0x00:0x40] // @1885 storage[keccak256(memory[0x00:0x40])] // } 1875 50 POP 1876 33 CALLER 1877 60 PUSH1 0x00 1879 90 SWAP1 187A 81 DUP2 187B 52 MSTORE 187C 60 PUSH1 0x01 187E 60 PUSH1 0x20 1880 52 MSTORE 1881 60 PUSH1 0x40 1883 90 SWAP1 1884 20 SHA3 1885 54 SLOAD 1886 60 PUSH1 0xff 1888 16 AND 1889 5B JUMPDEST 188A 80 DUP1 188B 61 PUSH2 0x18ac 188E 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @187B memory[0x00:0x20] = msg.sender // @1880 memory[0x20:0x40] = 0x01 // @1888 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x18ac, if 0xff & storage[keccak256(memory[0x00:0x40])] label_188F: // Incoming jump from 0x188E, if not stack[-1] // Incoming jump from 0x188E, if not 0xff & storage[keccak256(memory[0x00:0x40])] 188F 50 POP 1890 61 PUSH2 0x1897 1893 61 PUSH2 0x1a17 1896 56 *JUMP // Stack delta = +0 // Outputs[1] { @1890 stack[-1] = 0x1897 } // Block ends with call to 0x1a17, returns to 0x1897 label_1897: // Incoming return from call to 0x1A17 at 0x1896 // Inputs[2] // { // @18A0 stack[-1] // @18A1 msg.sender // } 1897 5B JUMPDEST 1898 60 PUSH1 0x01 189A 60 PUSH1 0x01 189C 60 PUSH1 0xa0 189E 1B SHL 189F 03 SUB 18A0 16 AND 18A1 33 CALLER 18A2 60 PUSH1 0x01 18A4 60 PUSH1 0x01 18A6 60 PUSH1 0xa0 18A8 1B SHL 18A9 03 SUB 18AA 16 AND 18AB 14 EQ // Stack delta = +0 // Outputs[1] { @18AB stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_18AC: // Incoming jump from 0x18AB // Incoming jump from 0x188E, if stack[-1] // Incoming jump from 0x188E, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @18B0 stack[-1] } 18AC 5B JUMPDEST 18AD 61 PUSH2 0x18c8 18B0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18c8, if stack[-1] label_18B1: // Incoming jump from 0x18B0, if not stack[-1] // Inputs[1] { @18B3 memory[0x40:0x60] } 18B1 60 PUSH1 0x40 18B3 51 MLOAD 18B4 62 PUSH3 0x461bcd 18B8 60 PUSH1 0xe5 18BA 1B SHL 18BB 81 DUP2 18BC 52 MSTORE 18BD 60 PUSH1 0x04 18BF 01 ADD 18C0 61 PUSH2 0x0840 18C3 90 SWAP1 18C4 61 PUSH2 0x399a 18C7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18C3 stack[0] = 0x0840 // @18C3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_18C8: // Incoming jump from 0x18B0, if stack[-1] // Inputs[3] // { // @18CC storage[0x0c] // @18D1 stack[-1] // @18DA stack[-2] // } 18C8 5B JUMPDEST 18C9 60 PUSH1 0x0c 18CB 80 DUP1 18CC 54 SLOAD 18CD 60 PUSH1 0xff 18CF 19 NOT 18D0 16 AND 18D1 91 SWAP2 18D2 15 ISZERO 18D3 15 ISZERO 18D4 91 SWAP2 18D5 90 SWAP1 18D6 91 SWAP2 18D7 17 OR 18D8 90 SWAP1 18D9 55 SSTORE 18DA 56 *JUMP // Stack delta = -2 // Outputs[1] { @18D9 storage[0x0c] = !!stack[-1] | (~0xff & storage[0x0c]) } // Block ends with unconditional jump to stack[-2] label_18DB: // Incoming call from 0x05E2, returns to 0x02DD // Inputs[1] { @18DE storage[0x00] } 18DB 5B JUMPDEST 18DC 60 PUSH1 0x00 18DE 54 SLOAD 18DF 60 PUSH1 0x01 18E1 60 PUSH1 0xa0 18E3 1B SHL 18E4 90 SWAP1 18E5 04 DIV 18E6 60 PUSH1 0xff 18E8 16 AND 18E9 15 ISZERO 18EA 80 DUP1 18EB 61 PUSH2 0x1903 18EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18E9 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x1903, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_18EF: // Incoming jump from 0x18EE, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @18F0 msg.sender // @18FE memory[0x00:0x40] // @18FF storage[keccak256(memory[0x00:0x40])] // } 18EF 50 POP 18F0 33 CALLER 18F1 60 PUSH1 0x00 18F3 90 SWAP1 18F4 81 DUP2 18F5 52 MSTORE 18F6 60 PUSH1 0x01 18F8 60 PUSH1 0x20 18FA 52 MSTORE 18FB 60 PUSH1 0x40 18FD 90 SWAP1 18FE 20 SHA3 18FF 54 SLOAD 1900 60 PUSH1 0xff 1902 16 AND 1903 5B JUMPDEST 1904 80 DUP1 1905 61 PUSH2 0x1926 1908 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @18F5 memory[0x00:0x20] = msg.sender // @18FA memory[0x20:0x40] = 0x01 // @1902 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1926, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1909: // Incoming jump from 0x1908, if not stack[-1] // Incoming jump from 0x1908, if not 0xff & storage[keccak256(memory[0x00:0x40])] 1909 50 POP 190A 61 PUSH2 0x1911 190D 61 PUSH2 0x1a17 1910 56 *JUMP // Stack delta = +0 // Outputs[1] { @190A stack[-1] = 0x1911 } // Block ends with call to 0x1a17, returns to 0x1911 label_1911: // Incoming return from call to 0x1A17 at 0x1910 // Inputs[2] // { // @191A stack[-1] // @191B msg.sender // } 1911 5B JUMPDEST 1912 60 PUSH1 0x01 1914 60 PUSH1 0x01 1916 60 PUSH1 0xa0 1918 1B SHL 1919 03 SUB 191A 16 AND 191B 33 CALLER 191C 60 PUSH1 0x01 191E 60 PUSH1 0x01 1920 60 PUSH1 0xa0 1922 1B SHL 1923 03 SUB 1924 16 AND 1925 14 EQ // Stack delta = +0 // Outputs[1] { @1925 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1926: // Incoming jump from 0x1925 // Incoming jump from 0x1908, if stack[-1] // Incoming jump from 0x1908, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @192A stack[-1] } 1926 5B JUMPDEST 1927 61 PUSH2 0x1942 192A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1942, if stack[-1] label_192B: // Incoming jump from 0x192A, if not stack[-1] // Inputs[1] { @192D memory[0x40:0x60] } 192B 60 PUSH1 0x40 192D 51 MLOAD 192E 62 PUSH3 0x461bcd 1932 60 PUSH1 0xe5 1934 1B SHL 1935 81 DUP2 1936 52 MSTORE 1937 60 PUSH1 0x04 1939 01 ADD 193A 61 PUSH2 0x0840 193D 90 SWAP1 193E 61 PUSH2 0x399a 1941 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1936 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @193D stack[0] = 0x0840 // @193D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_1942: // Incoming jump from 0x192A, if stack[-1] // Inputs[1] { @1945 storage[0x0c] } 1942 5B JUMPDEST 1943 60 PUSH1 0x0c 1945 54 SLOAD 1946 60 PUSH1 0xff 1948 16 AND 1949 80 DUP1 194A 15 ISZERO 194B 61 PUSH2 0x1963 194E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1948 stack[0] = 0xff & storage[0x0c] } // Block ends with conditional jump to 0x1963, if !(0xff & storage[0x0c]) label_194F: // Incoming jump from 0x194E, if not !(0xff & storage[0x0c]) // Inputs[3] // { // @1950 block.coinbase // @195E memory[0x00:0x40] // @195F storage[keccak256(memory[0x00:0x40])] // } 194F 50 POP 1950 41 COINBASE 1951 60 PUSH1 0x00 1953 90 SWAP1 1954 81 DUP2 1955 52 MSTORE 1956 60 PUSH1 0x0d 1958 60 PUSH1 0x20 195A 52 MSTORE 195B 60 PUSH1 0x40 195D 90 SWAP1 195E 20 SHA3 195F 54 SLOAD 1960 60 PUSH1 0xff 1962 16 AND 1963 5B JUMPDEST 1964 15 ISZERO 1965 61 PUSH2 0x196d 1968 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1955 memory[0x00:0x20] = block.coinbase // @195A memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x196d, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1969: // Incoming jump from 0x1968, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1968, if not !stack[-1] 1969 61 PUSH2 0x0f0e 196C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f0e label_196D: // Incoming jump from 0x1968, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1968, if !stack[-1] // Inputs[4] // { // @1970 storage[0x0e] // @1973 storage[0x10] // @1976 storage[0x0f] // @1979 storage[0x11] // } 196D 5B JUMPDEST 196E 60 PUSH1 0x0e 1970 54 SLOAD 1971 60 PUSH1 0x10 1973 54 SLOAD 1974 60 PUSH1 0x0f 1976 54 SLOAD 1977 60 PUSH1 0x11 1979 54 SLOAD 197A 60 PUSH1 0x00 197C 93 SWAP4 197D 61 PUSH2 0x1998 1980 93 SWAP4 1981 60 PUSH1 0x01 1983 60 PUSH1 0x01 1985 60 PUSH1 0xa0 1987 1B SHL 1988 03 SUB 1989 91 SWAP2 198A 82 DUP3 198B 16 AND 198C 93 SWAP4 198D 90 SWAP1 198E 82 DUP3 198F 16 AND 1990 92 SWAP3 1991 91 SWAP2 1992 16 AND 1993 90 SWAP1 1994 61 PUSH2 0x1b8d 1997 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @197C stack[0] = 0x00 // @1980 stack[1] = 0x1998 // @198C stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @1990 stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x10] // @1993 stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @1993 stack[5] = storage[0x11] // } // Block ends with unconditional jump to 0x1b8d 1998 5B JUMPDEST 1999 60 PUSH1 0x12 199B 54 SLOAD 199C 90 SWAP1 199D 91 SWAP2 199E 50 POP 199F 81 DUP2 19A0 11 GT 19A1 15 ISZERO 19A2 61 PUSH2 0x19bd 19A5 57 *JUMPI 19A6 60 PUSH1 0x40 19A8 51 MLOAD 19A9 62 PUSH3 0x461bcd 19AD 60 PUSH1 0xe5 19AF 1B SHL 19B0 81 DUP2 19B1 52 MSTORE 19B2 60 PUSH1 0x04 19B4 01 ADD 19B5 61 PUSH2 0x0840 19B8 90 SWAP1 19B9 61 PUSH2 0x3abb 19BC 56 *JUMP 19BD 5B JUMPDEST 19BE 60 PUSH1 0x10 19C0 54 SLOAD 19C1 81 DUP2 19C2 90 SWAP1 19C3 61 PUSH2 0x19d4 19C6 90 SWAP1 19C7 60 PUSH1 0x01 19C9 60 PUSH1 0x01 19CB 60 PUSH1 0xa0 19CD 1B SHL 19CE 03 SUB 19CF 16 AND 19D0 61 PUSH2 0x2213 19D3 56 *JUMP 19D4 5B JUMPDEST 19D5 10 LT 19D6 61 PUSH2 0x19e7 19D9 57 *JUMPI 19DA 61 PUSH2 0x19e1 19DD 61 PUSH2 0x2b06 19E0 56 *JUMP 19E1 5B JUMPDEST 19E2 50 POP 19E3 61 PUSH2 0x1a0d 19E6 56 *JUMP 19E7 5B JUMPDEST 19E8 60 PUSH1 0x10 19EA 54 SLOAD 19EB 60 PUSH1 0x00 19ED 90 SWAP1 19EE 61 PUSH2 0x19ff 19F1 90 SWAP1 19F2 60 PUSH1 0x01 19F4 60 PUSH1 0x01 19F6 60 PUSH1 0xa0 19F8 1B SHL 19F9 03 SUB 19FA 16 AND 19FB 61 PUSH2 0x2213 19FE 56 *JUMP 19FF 5B JUMPDEST 1A00 11 GT 1A01 15 ISZERO 1A02 61 PUSH2 0x1a0d 1A05 57 *JUMPI 1A06 61 PUSH2 0x0e9f 1A09 61 PUSH2 0x2844 1A0C 56 *JUMP 1A0D 5B JUMPDEST 1A0E 60 PUSH1 0x00 1A10 61 PUSH2 0x0eaa 1A13 61 PUSH2 0x2876 1A16 56 *JUMP label_1A17: // Incoming call from 0x1F2B, returns to 0x1F2C // Incoming call from 0x0B9F, returns to 0x0BA0 // Incoming call from 0x0DEA, returns to 0x0DEB // Incoming call from 0x13B8, returns to 0x13B9 // Incoming call from 0x172D, returns to 0x172E // Incoming call from 0x1910, returns to 0x1911 // Incoming call from 0x05F7, returns to 0x03EC // Incoming call from 0x1CEF, returns to 0x1CF0 // Incoming call from 0x203C, returns to 0x203D // Incoming call from 0x1BE1, returns to 0x1BE2 // Incoming call from 0x1896, returns to 0x1897 // Inputs[2] // { // @1A1A storage[0x00] // @1A24 stack[-1] // } 1A17 5B JUMPDEST 1A18 60 PUSH1 0x00 1A1A 54 SLOAD 1A1B 60 PUSH1 0x01 1A1D 60 PUSH1 0x01 1A1F 60 PUSH1 0xa0 1A21 1B SHL 1A22 03 SUB 1A23 16 AND 1A24 90 SWAP1 1A25 56 *JUMP // Stack delta = +0 // Outputs[1] { @1A24 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_1A26: // Incoming call from 0x1B00, returns to 0x1B01 // Incoming call from 0x0D95, returns to 0x0D96 // Incoming call from 0x1691, returns to 0x1692 // Incoming call from 0x156F, returns to 0x1570 // Incoming call from 0x1211, returns to 0x1212 // Incoming call from 0x10DE, returns to 0x10DF // Incoming call from 0x144D, returns to 0x144E // Incoming call from 0x1D90, returns to 0x1D91 // Incoming call from 0x0F17, returns to 0x0F18 // Incoming call from 0x1257, returns to 0x1258 // Incoming call from 0x0C56, returns to 0x0C57 // Incoming call from 0x060C, returns to 0x03CA // Incoming call from 0x0AA3, returns to 0x0AA4 // Incoming call from 0x0CCA, returns to 0x0CCB // Incoming call from 0x17CB, returns to 0x17CC // Incoming call from 0x1A51, returns to 0x1A52 // Incoming call from 0x269D, returns to 0x269E // Incoming call from 0x0823, returns to 0x0824 // Incoming call from 0x2666, returns to 0x2667 // Incoming call from 0x22B4, returns to 0x22B5 // Incoming call from 0x1B29, returns to 0x1B2A // Inputs[1] { @1A2A storage[0x00] } 1A26 5B JUMPDEST 1A27 60 PUSH1 0x00 1A29 80 DUP1 1A2A 54 SLOAD 1A2B 60 PUSH1 0x01 1A2D 60 PUSH1 0x01 1A2F 60 PUSH1 0xa0 1A31 1B SHL 1A32 03 SUB 1A33 16 AND 1A34 61 PUSH2 0x1a3b 1A37 61 PUSH2 0x2b35 1A3A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A27 stack[0] = 0x00 // @1A33 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x00] // @1A34 stack[2] = 0x1a3b // } // Block ends with call to 0x2b35, returns to 0x1A3B label_1A3B: // Incoming return from call to 0x2B35 at 0x1A3A // Inputs[4] // { // @1A44 stack[-1] // @1A45 stack[-2] // @1A46 stack[-3] // @1A48 stack[-4] // } 1A3B 5B JUMPDEST 1A3C 60 PUSH1 0x01 1A3E 60 PUSH1 0x01 1A40 60 PUSH1 0xa0 1A42 1B SHL 1A43 03 SUB 1A44 16 AND 1A45 14 EQ 1A46 90 SWAP1 1A47 50 POP 1A48 90 SWAP1 1A49 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A48 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-4] label_1A4A: // Incoming jump from 0x062C 1A4A 5B JUMPDEST 1A4B 61 PUSH2 0x1a52 1A4E 61 PUSH2 0x1a26 1A51 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A4B stack[0] = 0x1a52 } // Block ends with call to 0x1a26, returns to 0x1A52 label_1A52: // Incoming return from call to 0x1A26 at 0x1A51 // Inputs[1] { @1A56 stack[-1] } 1A52 5B JUMPDEST 1A53 61 PUSH2 0x1a6e 1A56 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a6e, if stack[-1] label_1A57: // Incoming jump from 0x1A56, if not stack[-1] // Inputs[1] { @1A59 memory[0x40:0x60] } 1A57 60 PUSH1 0x40 1A59 51 MLOAD 1A5A 62 PUSH3 0x461bcd 1A5E 60 PUSH1 0xe5 1A60 1B SHL 1A61 81 DUP2 1A62 52 MSTORE 1A63 60 PUSH1 0x04 1A65 01 ADD 1A66 61 PUSH2 0x0840 1A69 90 SWAP1 1A6A 61 PUSH2 0x3a86 1A6D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1A62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A69 stack[0] = 0x0840 // @1A69 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_1A6E: // Incoming jump from 0x1A56, if stack[-1] // Inputs[1] { @1A72 stack[-2] } 1A6E 5B JUMPDEST 1A6F 61 PUSH2 0x1a77 1A72 82 DUP3 1A73 61 PUSH2 0x2b39 1A76 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A6F stack[0] = 0x1a77 // @1A72 stack[1] = stack[-2] // } // Block ends with call to 0x2b39, returns to 0x1A77 label_1A77: // Incoming return from call to 0x2B39 at 0x1A76 // Inputs[1] { @1A78 stack[-1] } 1A77 5B JUMPDEST 1A78 15 ISZERO 1A79 61 PUSH2 0x1a81 1A7C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a81, if !stack[-1] label_1A7D: // Incoming jump from 0x1A7C, if not !stack[-1] 1A7D 61 PUSH2 0x1442 1A80 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1442 label_1A81: // Incoming jump from 0x1A7C, if !stack[-1] // Inputs[2] // { // @1A85 stack[-1] // @1A86 memory[stack[-1]:stack[-1] + 0x20] // } 1A81 5B JUMPDEST 1A82 60 PUSH1 0x00 1A84 5B JUMPDEST 1A85 81 DUP2 1A86 51 MLOAD 1A87 81 DUP2 1A88 10 LT 1A89 15 ISZERO 1A8A 61 PUSH2 0x0a97 1A8D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A82 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a97, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1A8E: // Incoming jump from 0x1A8D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1A8D, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1A90 stack[-2] // @1A91 stack[-1] // @1A93 memory[stack[-2]:stack[-2] + 0x20] // } 1A8E 60 PUSH1 0x00 1A90 82 DUP3 1A91 82 DUP3 1A92 81 DUP2 1A93 51 MLOAD 1A94 81 DUP2 1A95 10 LT 1A96 61 PUSH2 0x1a9b 1A99 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1A8E stack[0] = 0x00 // @1A90 stack[1] = stack[-2] // @1A91 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1a9b, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_1A9A: // Incoming jump from 0x1A99, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 1A9A FE *ASSERT // Stack delta = +0 // Outputs[1] { @1A9A assert(); } // Block terminates label_1A9B: // Incoming jump from 0x1A99, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1A9E stack[-1] // @1AA2 stack[-2] // @1AA3 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1AA4 stack[-3] // } 1A9B 5B JUMPDEST 1A9C 60 PUSH1 0x20 1A9E 02 MUL 1A9F 60 PUSH1 0x20 1AA1 01 ADD 1AA2 01 ADD 1AA3 51 MLOAD 1AA4 90 SWAP1 1AA5 50 POP 1AA6 60 PUSH1 0x00 1AA8 61 PUSH2 0x1ab0 1AAB 82 DUP3 1AAC 61 PUSH2 0x2213 1AAF 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1AA4 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1AA6 stack[-2] = 0x00 // @1AA8 stack[-1] = 0x1ab0 // @1AAB stack[0] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with call to 0x2213, returns to 0x1AB0 label_1AB0: // Incoming return from call to 0x2213 at 0x1AAF // Inputs[4] // { // @1AB1 stack[-2] // @1AB1 stack[-1] // @1AB6 stack[-3] // @1AB7 stack[-6] // } 1AB0 5B JUMPDEST 1AB1 90 SWAP1 1AB2 50 POP 1AB3 61 PUSH2 0x1abd 1AB6 82 DUP3 1AB7 86 DUP7 1AB8 83 DUP4 1AB9 61 PUSH2 0x290c 1ABC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1AB1 stack[-2] = stack[-1] // @1AB3 stack[-1] = 0x1abd // @1AB6 stack[0] = stack[-3] // @1AB7 stack[1] = stack[-6] // @1AB8 stack[2] = stack[-1] // } // Block ends with call to 0x290c, returns to 0x1ABD label_1ABD: // Incoming return from call to 0x290C at 0x1ABC // Inputs[1] { @1AC2 stack[-3] } 1ABD 5B JUMPDEST 1ABE 50 POP 1ABF 50 POP 1AC0 60 PUSH1 0x01 1AC2 01 ADD 1AC3 61 PUSH2 0x1a84 1AC6 56 *JUMP // Stack delta = -2 // Outputs[1] { @1AC2 stack[-3] = 0x01 + stack[-3] } // Block ends with unconditional jump to 0x1a84 label_1AC7: // Incoming call from 0x0641, returns to 0x0642 // Inputs[5] // { // @1ACA storage[0x08] // @1ACD storage[0x09] // @1AD0 storage[0x0a] // @1AD3 storage[0x0b] // @1AD5 stack[-1] // } 1AC7 5B JUMPDEST 1AC8 60 PUSH1 0x08 1ACA 54 SLOAD 1ACB 60 PUSH1 0x09 1ACD 54 SLOAD 1ACE 60 PUSH1 0x0a 1AD0 54 SLOAD 1AD1 60 PUSH1 0x0b 1AD3 54 SLOAD 1AD4 92 SWAP3 1AD5 93 SWAP4 1AD6 91 SWAP2 1AD7 92 SWAP3 1AD8 90 SWAP1 1AD9 91 SWAP2 1ADA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1AD5 stack[-1] = storage[0x08] // @1AD7 stack[0] = storage[0x09] // @1AD8 stack[2] = storage[0x0b] // @1AD9 stack[1] = storage[0x0a] // } // Block ends with unconditional jump to stack[-1] label_1ADB: // Incoming jump from 0x0671 // Inputs[4] // { // @1AE4 stack[-1] // @1AF2 memory[0x00:0x40] // @1AF3 storage[keccak256(memory[0x00:0x40])] // @1AF7 stack[-2] // } 1ADB 5B JUMPDEST 1ADC 60 PUSH1 0x01 1ADE 60 PUSH1 0x01 1AE0 60 PUSH1 0xa0 1AE2 1B SHL 1AE3 03 SUB 1AE4 16 AND 1AE5 60 PUSH1 0x00 1AE7 90 SWAP1 1AE8 81 DUP2 1AE9 52 MSTORE 1AEA 60 PUSH1 0x01 1AEC 60 PUSH1 0x20 1AEE 52 MSTORE 1AEF 60 PUSH1 0x40 1AF1 90 SWAP1 1AF2 20 SHA3 1AF3 54 SLOAD 1AF4 60 PUSH1 0xff 1AF6 16 AND 1AF7 90 SWAP1 1AF8 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1AE9 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1AEE memory[0x20:0x40] = 0x01 // @1AF7 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1AF9: // Incoming jump from 0x0691 1AF9 5B JUMPDEST 1AFA 61 PUSH2 0x1b01 1AFD 61 PUSH2 0x1a26 1B00 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AFA stack[0] = 0x1b01 } // Block ends with call to 0x1a26, returns to 0x1B01 label_1B01: // Incoming return from call to 0x1A26 at 0x1B00 // Inputs[1] { @1B05 stack[-1] } 1B01 5B JUMPDEST 1B02 61 PUSH2 0x1b1d 1B05 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b1d, if stack[-1] label_1B06: // Incoming jump from 0x1B05, if not stack[-1] // Inputs[1] { @1B08 memory[0x40:0x60] } 1B06 60 PUSH1 0x40 1B08 51 MLOAD 1B09 62 PUSH3 0x461bcd 1B0D 60 PUSH1 0xe5 1B0F 1B SHL 1B10 81 DUP2 1B11 52 MSTORE 1B12 60 PUSH1 0x04 1B14 01 ADD 1B15 61 PUSH2 0x0840 1B18 90 SWAP1 1B19 61 PUSH2 0x3a86 1B1C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B11 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B18 stack[0] = 0x0840 // @1B18 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_1B1D: // Incoming jump from 0x1B05, if stack[-1] // Inputs[2] // { // @1B20 stack[-1] // @1B21 stack[-2] // } 1B1D 5B JUMPDEST 1B1E 60 PUSH1 0x05 1B20 55 SSTORE 1B21 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B20 storage[0x05] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1B22: // Incoming jump from 0x06B1 1B22 5B JUMPDEST 1B23 61 PUSH2 0x1b2a 1B26 61 PUSH2 0x1a26 1B29 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B23 stack[0] = 0x1b2a } // Block ends with call to 0x1a26, returns to 0x1B2A label_1B2A: // Incoming return from call to 0x1A26 at 0x1B29 // Inputs[1] { @1B2E stack[-1] } 1B2A 5B JUMPDEST 1B2B 61 PUSH2 0x1b46 1B2E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b46, if stack[-1] label_1B2F: // Incoming jump from 0x1B2E, if not stack[-1] // Inputs[1] { @1B31 memory[0x40:0x60] } 1B2F 60 PUSH1 0x40 1B31 51 MLOAD 1B32 62 PUSH3 0x461bcd 1B36 60 PUSH1 0xe5 1B38 1B SHL 1B39 81 DUP2 1B3A 52 MSTORE 1B3B 60 PUSH1 0x04 1B3D 01 ADD 1B3E 61 PUSH2 0x0840 1B41 90 SWAP1 1B42 61 PUSH2 0x3a86 1B45 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B41 stack[0] = 0x0840 // @1B41 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_1B46: // Incoming jump from 0x1B2E, if stack[-1] // Inputs[1] { @1B4F stack[-1] } 1B46 5B JUMPDEST 1B47 60 PUSH1 0x01 1B49 60 PUSH1 0x01 1B4B 60 PUSH1 0xa0 1B4D 1B SHL 1B4E 03 SUB 1B4F 81 DUP2 1B50 16 AND 1B51 61 PUSH2 0x1b6c 1B54 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b6c, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1B55: // Incoming jump from 0x1B54, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1B57 memory[0x40:0x60] } 1B55 60 PUSH1 0x40 1B57 51 MLOAD 1B58 62 PUSH3 0x461bcd 1B5C 60 PUSH1 0xe5 1B5E 1B SHL 1B5F 81 DUP2 1B60 52 MSTORE 1B61 60 PUSH1 0x04 1B63 01 ADD 1B64 61 PUSH2 0x0840 1B67 90 SWAP1 1B68 61 PUSH2 0x3b3b 1B6B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B67 stack[0] = 0x0840 // @1B67 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3b3b, returns to 0x0840 label_1B6C: // Incoming jump from 0x1B54, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1B75 stack[-1] // @1B83 memory[0x00:0x40] // @1B85 storage[keccak256(memory[0x00:0x40])] // @1B8C stack[-2] // } 1B6C 5B JUMPDEST 1B6D 60 PUSH1 0x01 1B6F 60 PUSH1 0x01 1B71 60 PUSH1 0xa0 1B73 1B SHL 1B74 03 SUB 1B75 16 AND 1B76 60 PUSH1 0x00 1B78 90 SWAP1 1B79 81 DUP2 1B7A 52 MSTORE 1B7B 60 PUSH1 0x01 1B7D 60 PUSH1 0x20 1B7F 52 MSTORE 1B80 60 PUSH1 0x40 1B82 90 SWAP1 1B83 20 SHA3 1B84 80 DUP1 1B85 54 SLOAD 1B86 60 PUSH1 0xff 1B88 19 NOT 1B89 16 AND 1B8A 90 SWAP1 1B8B 55 SSTORE 1B8C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1B7A memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1B7F memory[0x20:0x40] = 0x01 // @1B8B storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1B8D: // Incoming jump from 0x1997 // Incoming jump from 0x06D1 // Inputs[3] // { // @1B96 stack[-4] // @1B97 stack[-3] // @1B98 stack[-2] // } 1B8D 5B JUMPDEST 1B8E 60 PUSH1 0x00 1B90 80 DUP1 1B91 60 PUSH1 0x00 1B93 61 PUSH2 0x1b9d 1B96 87 DUP8 1B97 87 DUP8 1B98 87 DUP8 1B99 61 PUSH2 0x26c3 1B9C 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1B8E stack[0] = 0x00 // @1B90 stack[1] = 0x00 // @1B91 stack[2] = 0x00 // @1B93 stack[3] = 0x1b9d // @1B96 stack[4] = stack[-4] // @1B97 stack[5] = stack[-3] // @1B98 stack[6] = stack[-2] // } // Block ends with call to 0x26c3, returns to 0x1B9D label_1B9D: // Incoming return from call to 0x26C3 at 0x1B9C // Inputs[5] // { // @1B9E stack[-1] // @1B9E stack[-3] // @1BA0 stack[-4] // @1BA0 stack[-2] // @1BA5 stack[-6] // } 1B9D 5B JUMPDEST 1B9E 91 SWAP2 1B9F 50 POP 1BA0 91 SWAP2 1BA1 50 POP 1BA2 61 PUSH2 0x0cb0 1BA5 84 DUP5 1BA6 83 DUP4 1BA7 83 DUP4 1BA8 61 PUSH2 0x2b5e 1BAB 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1B9E stack[-3] = stack[-1] // @1BA0 stack[-4] = stack[-2] // @1BA2 stack[-2] = 0x0cb0 // @1BA5 stack[-1] = stack[-6] // @1BA6 stack[0] = stack[-2] // @1BA7 stack[1] = stack[-1] // } // Block ends with call to 0x2b5e, returns to 0x0CB0 label_1BAC: // Incoming jump from 0x06E4 // Inputs[1] { @1BAF storage[0x00] } 1BAC 5B JUMPDEST 1BAD 60 PUSH1 0x00 1BAF 54 SLOAD 1BB0 60 PUSH1 0x01 1BB2 60 PUSH1 0xa0 1BB4 1B SHL 1BB5 90 SWAP1 1BB6 04 DIV 1BB7 60 PUSH1 0xff 1BB9 16 AND 1BBA 15 ISZERO 1BBB 80 DUP1 1BBC 61 PUSH2 0x1bd4 1BBF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BBA stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x1bd4, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_1BC0: // Incoming jump from 0x1BBF, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @1BC1 msg.sender // @1BCF memory[0x00:0x40] // @1BD0 storage[keccak256(memory[0x00:0x40])] // } 1BC0 50 POP 1BC1 33 CALLER 1BC2 60 PUSH1 0x00 1BC4 90 SWAP1 1BC5 81 DUP2 1BC6 52 MSTORE 1BC7 60 PUSH1 0x01 1BC9 60 PUSH1 0x20 1BCB 52 MSTORE 1BCC 60 PUSH1 0x40 1BCE 90 SWAP1 1BCF 20 SHA3 1BD0 54 SLOAD 1BD1 60 PUSH1 0xff 1BD3 16 AND 1BD4 5B JUMPDEST 1BD5 80 DUP1 1BD6 61 PUSH2 0x1bf7 1BD9 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1BC6 memory[0x00:0x20] = msg.sender // @1BCB memory[0x20:0x40] = 0x01 // @1BD3 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1bf7, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1BDA: // Incoming jump from 0x1BD9, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1BD9, if not stack[-1] 1BDA 50 POP 1BDB 61 PUSH2 0x1be2 1BDE 61 PUSH2 0x1a17 1BE1 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BDB stack[-1] = 0x1be2 } // Block ends with call to 0x1a17, returns to 0x1BE2 label_1BE2: // Incoming return from call to 0x1A17 at 0x1BE1 // Inputs[2] // { // @1BEB stack[-1] // @1BEC msg.sender // } 1BE2 5B JUMPDEST 1BE3 60 PUSH1 0x01 1BE5 60 PUSH1 0x01 1BE7 60 PUSH1 0xa0 1BE9 1B SHL 1BEA 03 SUB 1BEB 16 AND 1BEC 33 CALLER 1BED 60 PUSH1 0x01 1BEF 60 PUSH1 0x01 1BF1 60 PUSH1 0xa0 1BF3 1B SHL 1BF4 03 SUB 1BF5 16 AND 1BF6 14 EQ // Stack delta = +0 // Outputs[1] { @1BF6 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1BF7: // Incoming jump from 0x1BD9, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1BD9, if stack[-1] // Incoming jump from 0x1BF6 // Inputs[1] { @1BFB stack[-1] } 1BF7 5B JUMPDEST 1BF8 61 PUSH2 0x1c13 1BFB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c13, if stack[-1] label_1BFC: // Incoming jump from 0x1BFB, if not stack[-1] // Inputs[1] { @1BFE memory[0x40:0x60] } 1BFC 60 PUSH1 0x40 1BFE 51 MLOAD 1BFF 62 PUSH3 0x461bcd 1C03 60 PUSH1 0xe5 1C05 1B SHL 1C06 81 DUP2 1C07 52 MSTORE 1C08 60 PUSH1 0x04 1C0A 01 ADD 1C0B 61 PUSH2 0x0840 1C0E 90 SWAP1 1C0F 61 PUSH2 0x399a 1C12 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C0E stack[0] = 0x0840 // @1C0E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_1C13: // Incoming jump from 0x1BFB, if stack[-1] // Inputs[1] { @1C16 storage[0x0c] } 1C13 5B JUMPDEST 1C14 60 PUSH1 0x0c 1C16 54 SLOAD 1C17 60 PUSH1 0xff 1C19 16 AND 1C1A 80 DUP1 1C1B 15 ISZERO 1C1C 61 PUSH2 0x1c34 1C1F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C19 stack[0] = 0xff & storage[0x0c] } // Block ends with conditional jump to 0x1c34, if !(0xff & storage[0x0c]) label_1C20: // Incoming jump from 0x1C1F, if not !(0xff & storage[0x0c]) // Inputs[3] // { // @1C21 block.coinbase // @1C2F memory[0x00:0x40] // @1C30 storage[keccak256(memory[0x00:0x40])] // } 1C20 50 POP 1C21 41 COINBASE 1C22 60 PUSH1 0x00 1C24 90 SWAP1 1C25 81 DUP2 1C26 52 MSTORE 1C27 60 PUSH1 0x0d 1C29 60 PUSH1 0x20 1C2B 52 MSTORE 1C2C 60 PUSH1 0x40 1C2E 90 SWAP1 1C2F 20 SHA3 1C30 54 SLOAD 1C31 60 PUSH1 0xff 1C33 16 AND 1C34 5B JUMPDEST 1C35 15 ISZERO 1C36 61 PUSH2 0x1c3e 1C39 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C26 memory[0x00:0x20] = block.coinbase // @1C2B memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x1c3e, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1C3A: // Incoming jump from 0x1C39, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1C39, if not !stack[-1] 1C3A 61 PUSH2 0x1442 1C3D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1442 label_1C3E: // Incoming jump from 0x1C39, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1C39, if !stack[-1] 1C3E 5B JUMPDEST 1C3F 60 PUSH1 0x00 1C41 80 DUP1 1C42 61 PUSH2 0x1c49 1C45 61 PUSH2 0x2c10 1C48 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C3F stack[0] = 0x00 // @1C41 stack[1] = 0x00 // @1C42 stack[2] = 0x1c49 // } // Block ends with call to 0x2c10, returns to 0x1C49 label_1C49: // Incoming return from call to 0x2C10 at 0x1C48 // Inputs[6] // { // @1C4A stack[-3] // @1C4A stack[-1] // @1C4C stack[-2] // @1C4C stack[-4] // @1C53 stack[-6] // @1C56 storage[0x07] // } 1C49 5B JUMPDEST 1C4A 91 SWAP2 1C4B 50 POP 1C4C 91 SWAP2 1C4D 50 POP 1C4E 60 PUSH1 0x00 1C50 61 PUSH2 0x1c5b 1C53 85 DUP6 1C54 60 PUSH1 0x07 1C56 54 SLOAD 1C57 61 PUSH2 0x1c95 1C5A 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1C4A stack[-3] = stack[-1] // @1C4C stack[-4] = stack[-2] // @1C4E stack[-2] = 0x00 // @1C50 stack[-1] = 0x1c5b // @1C53 stack[0] = stack[-6] // @1C56 stack[1] = storage[0x07] // } // Block ends with call to 0x1c95, returns to 0x1C5B label_1C5B: // Incoming return from call to 0x1C95 at 0x1C5A // Inputs[2] // { // @1C5C stack[-1] // @1C5C stack[-2] // } 1C5B 5B JUMPDEST 1C5C 90 SWAP1 1C5D 50 POP 1C5E 61 PUSH2 0x1c65 1C61 61 PUSH2 0x327f 1C64 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C5C stack[-2] = stack[-1] // @1C5E stack[-1] = 0x1c65 // } // Block ends with call to 0x327f, returns to 0x1C65 label_1C65: // Incoming return from call to 0x327F at 0x1C64 // Inputs[4] // { // @1C69 stack[-2] // @1C6A stack[-4] // @1C6B stack[-5] // @1C6C stack[-3] // } 1C65 5B JUMPDEST 1C66 61 PUSH2 0x1c71 1C69 82 DUP3 1C6A 85 DUP6 1C6B 87 DUP8 1C6C 86 DUP7 1C6D 61 PUSH2 0x2c2d 1C70 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C66 stack[0] = 0x1c71 // @1C69 stack[1] = stack[-2] // @1C6A stack[2] = stack[-4] // @1C6B stack[3] = stack[-5] // @1C6C stack[4] = stack[-3] // } // Block ends with call to 0x2c2d, returns to 0x1C71 label_1C71: // Incoming return from call to 0x2C2D at 0x1C70 // Inputs[8] // { // @1C72 stack[-1] // @1C72 stack[-2] // @1C7B memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // @1C80 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1C85 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1C8A memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @1C8F memory[0x80 + stack[-1]:0x80 + stack[-1] + 0x20] // @1C90 address(this) // } 1C71 5B JUMPDEST 1C72 90 SWAP1 1C73 50 POP 1C74 61 PUSH2 0x1201 1C77 81 DUP2 1C78 60 PUSH1 0x00 1C7A 01 ADD 1C7B 51 MLOAD 1C7C 82 DUP3 1C7D 60 PUSH1 0x20 1C7F 01 ADD 1C80 51 MLOAD 1C81 83 DUP4 1C82 60 PUSH1 0x40 1C84 01 ADD 1C85 51 MLOAD 1C86 84 DUP5 1C87 60 PUSH1 0x60 1C89 01 ADD 1C8A 51 MLOAD 1C8B 85 DUP6 1C8C 60 PUSH1 0x80 1C8E 01 ADD 1C8F 51 MLOAD 1C90 30 ADDRESS 1C91 61 PUSH2 0x29f3 1C94 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1C72 stack[-2] = stack[-1] // @1C74 stack[-1] = 0x1201 // @1C7B stack[0] = memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // @1C80 stack[1] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1C85 stack[2] = memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1C8A stack[3] = memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @1C8F stack[4] = memory[0x80 + stack[-1]:0x80 + stack[-1] + 0x20] // @1C90 stack[5] = address(this) // } // Block ends with unconditional jump to 0x29f3 label_1C95: // Incoming jump from 0x0704 // Incoming call from 0x1C5A, returns to 0x1C5B // Incoming call from 0x1FA7, returns to 0x1FA8 // Inputs[1] { @1C98 stack[-1] } 1C95 5B JUMPDEST 1C96 60 PUSH1 0x00 1C98 81 DUP2 1C99 61 PUSH2 0x1ca3 1C9C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C96 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ca3, if stack[-1] label_1C9D: // Incoming jump from 0x1C9C, if not stack[-1] // Inputs[1] { @1C9E stack[-3] } 1C9D 50 POP 1C9E 81 DUP2 1C9F 61 PUSH2 0x1cb4 1CA2 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C9E stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x1cb4 label_1CA3: // Incoming jump from 0x1C9C, if stack[-1] // Inputs[2] // { // @1CAE stack[-3] // @1CB2 stack[-2] // } 1CA3 5B JUMPDEST 1CA4 50 POP 1CA5 60 PUSH1 0x01 1CA7 60 PUSH1 0x01 1CA9 60 PUSH1 0xa0 1CAB 1B SHL 1CAC 03 SUB 1CAD 80 DUP1 1CAE 83 DUP4 1CAF 16 AND 1CB0 90 SWAP1 1CB1 03 SUB 1CB2 81 DUP2 1CB3 01 ADD // Stack delta = +0 // Outputs[1] { @1CB3 stack[-1] = stack[-2] + ((0x01 << 0xa0) - 0x01 - (stack[-3] & (0x01 << 0xa0) - 0x01)) } // Block continues label_1CB4: // Incoming jump from 0x1CA2 // Incoming jump from 0x1F8A // Incoming jump from 0x3042 // Incoming jump from 0x1CB3 // Incoming jump from 0x28FF // Inputs[3] // { // @1CB5 stack[-4] // @1CB5 stack[-1] // @1CB6 stack[-3] // } 1CB4 5B JUMPDEST 1CB5 92 SWAP3 1CB6 91 SWAP2 1CB7 50 POP 1CB8 50 POP 1CB9 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CB5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1CBA: // Incoming call from 0x070C, returns to 0x02DD // Inputs[1] { @1CBD storage[0x00] } 1CBA 5B JUMPDEST 1CBB 60 PUSH1 0x00 1CBD 54 SLOAD 1CBE 60 PUSH1 0x01 1CC0 60 PUSH1 0xa0 1CC2 1B SHL 1CC3 90 SWAP1 1CC4 04 DIV 1CC5 60 PUSH1 0xff 1CC7 16 AND 1CC8 15 ISZERO 1CC9 80 DUP1 1CCA 61 PUSH2 0x1ce2 1CCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CC8 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x1ce2, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_1CCE: // Incoming jump from 0x1CCD, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @1CCF msg.sender // @1CDD memory[0x00:0x40] // @1CDE storage[keccak256(memory[0x00:0x40])] // } 1CCE 50 POP 1CCF 33 CALLER 1CD0 60 PUSH1 0x00 1CD2 90 SWAP1 1CD3 81 DUP2 1CD4 52 MSTORE 1CD5 60 PUSH1 0x01 1CD7 60 PUSH1 0x20 1CD9 52 MSTORE 1CDA 60 PUSH1 0x40 1CDC 90 SWAP1 1CDD 20 SHA3 1CDE 54 SLOAD 1CDF 60 PUSH1 0xff 1CE1 16 AND 1CE2 5B JUMPDEST 1CE3 80 DUP1 1CE4 61 PUSH2 0x1d05 1CE7 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1CD4 memory[0x00:0x20] = msg.sender // @1CD9 memory[0x20:0x40] = 0x01 // @1CE1 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1d05, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1CE8: // Incoming jump from 0x1CE7, if not stack[-1] // Incoming jump from 0x1CE7, if not 0xff & storage[keccak256(memory[0x00:0x40])] 1CE8 50 POP 1CE9 61 PUSH2 0x1cf0 1CEC 61 PUSH2 0x1a17 1CEF 56 *JUMP // Stack delta = +0 // Outputs[1] { @1CE9 stack[-1] = 0x1cf0 } // Block ends with call to 0x1a17, returns to 0x1CF0 label_1CF0: // Incoming return from call to 0x1A17 at 0x1CEF // Inputs[2] // { // @1CF9 stack[-1] // @1CFA msg.sender // } 1CF0 5B JUMPDEST 1CF1 60 PUSH1 0x01 1CF3 60 PUSH1 0x01 1CF5 60 PUSH1 0xa0 1CF7 1B SHL 1CF8 03 SUB 1CF9 16 AND 1CFA 33 CALLER 1CFB 60 PUSH1 0x01 1CFD 60 PUSH1 0x01 1CFF 60 PUSH1 0xa0 1D01 1B SHL 1D02 03 SUB 1D03 16 AND 1D04 14 EQ // Stack delta = +0 // Outputs[1] { @1D04 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1D05: // Incoming jump from 0x1CE7, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1CE7, if stack[-1] // Incoming jump from 0x1D04 // Inputs[1] { @1D09 stack[-1] } 1D05 5B JUMPDEST 1D06 61 PUSH2 0x1d21 1D09 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d21, if stack[-1] label_1D0A: // Incoming jump from 0x1D09, if not stack[-1] // Inputs[1] { @1D0C memory[0x40:0x60] } 1D0A 60 PUSH1 0x40 1D0C 51 MLOAD 1D0D 62 PUSH3 0x461bcd 1D11 60 PUSH1 0xe5 1D13 1B SHL 1D14 81 DUP2 1D15 52 MSTORE 1D16 60 PUSH1 0x04 1D18 01 ADD 1D19 61 PUSH2 0x0840 1D1C 90 SWAP1 1D1D 61 PUSH2 0x399a 1D20 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D1C stack[0] = 0x0840 // @1D1C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_1D21: // Incoming jump from 0x1D09, if stack[-1] // Inputs[1] { @1D24 msg.value } 1D21 5B JUMPDEST 1D22 60 PUSH1 0x0a 1D24 34 CALLVALUE 1D25 81 DUP2 1D26 81 DUP2 1D27 04 DIV 1D28 91 SWAP2 1D29 90 SWAP1 1D2A 06 MOD 1D2B 80 DUP1 1D2C 61 PUSH2 0x1d42 1D2F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D28 stack[0] = msg.value / 0x0a // @1D2A stack[1] = msg.value % 0x0a // } // Block ends with conditional jump to 0x1d42, if msg.value % 0x0a label_1D30: // Incoming jump from 0x1D2F, if not msg.value % 0x0a // Inputs[1] { @1D39 stack[-2] } 1D30 67 PUSH8 0x0de0b6b3a7640000 1D39 82 DUP3 1D3A 02 MUL 1D3B 60 PUSH1 0x08 1D3D 55 SSTORE 1D3E 61 PUSH2 0x1442 1D41 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D3D storage[0x08] = stack[-2] * 0x0de0b6b3a7640000 } // Block ends with unconditional jump to 0x1442 label_1D42: // Incoming jump from 0x1D2F, if msg.value % 0x0a // Inputs[1] { @1D43 stack[-1] } 1D42 5B JUMPDEST 1D43 80 DUP1 1D44 60 PUSH1 0x01 1D46 14 EQ 1D47 15 ISZERO 1D48 61 PUSH2 0x1d59 1D4B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d59, if !(0x01 == stack[-1]) label_1D4C: // Incoming jump from 0x1D4B, if not !(0x01 == stack[-1]) // Inputs[1] { @1D50 stack[-2] } 1D4C 62 PUSH3 0x0f4240 1D50 82 DUP3 1D51 02 MUL 1D52 60 PUSH1 0x09 1D54 55 SSTORE 1D55 61 PUSH2 0x1442 1D58 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D54 storage[0x09] = stack[-2] * 0x0f4240 } // Block ends with unconditional jump to 0x1442 label_1D59: // Incoming jump from 0x1D4B, if !(0x01 == stack[-1]) // Inputs[1] { @1D5A stack[-1] } 1D59 5B JUMPDEST 1D5A 80 DUP1 1D5B 60 PUSH1 0x02 1D5D 14 EQ 1D5E 15 ISZERO 1D5F 61 PUSH2 0x1d70 1D62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d70, if !(0x02 == stack[-1]) label_1D63: // Incoming jump from 0x1D62, if not !(0x02 == stack[-1]) // Inputs[1] { @1D67 stack[-2] } 1D63 62 PUSH3 0x0f4240 1D67 82 DUP3 1D68 02 MUL 1D69 60 PUSH1 0x0a 1D6B 55 SSTORE 1D6C 61 PUSH2 0x1442 1D6F 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D6B storage[0x0a] = stack[-2] * 0x0f4240 } // Block ends with unconditional jump to 0x1442 label_1D70: // Incoming jump from 0x1D62, if !(0x02 == stack[-1]) // Inputs[1] { @1D71 stack[-1] } 1D70 5B JUMPDEST 1D71 80 DUP1 1D72 60 PUSH1 0x03 1D74 14 EQ 1D75 15 ISZERO 1D76 61 PUSH2 0x1442 1D79 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1442, if !(0x03 == stack[-1]) label_1D7A: // Incoming jump from 0x1D79, if not !(0x03 == stack[-1]) // Inputs[2] // { // @1D84 stack[-2] // @1D88 stack[-3] // } 1D7A 50 POP 1D7B 67 PUSH8 0x0de0b6b3a7640000 1D84 02 MUL 1D85 60 PUSH1 0x0b 1D87 55 SSTORE 1D88 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D87 storage[0x0b] = 0x0de0b6b3a7640000 * stack[-2] } // Block ends with unconditional jump to stack[-3] label_1D89: // Incoming jump from 0x072C 1D89 5B JUMPDEST 1D8A 61 PUSH2 0x1d91 1D8D 61 PUSH2 0x1a26 1D90 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D8A stack[0] = 0x1d91 } // Block ends with call to 0x1a26, returns to 0x1D91 label_1D91: // Incoming return from call to 0x1A26 at 0x1D90 // Inputs[1] { @1D95 stack[-1] } 1D91 5B JUMPDEST 1D92 61 PUSH2 0x1dad 1D95 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dad, if stack[-1] label_1D96: // Incoming jump from 0x1D95, if not stack[-1] // Inputs[1] { @1D98 memory[0x40:0x60] } 1D96 60 PUSH1 0x40 1D98 51 MLOAD 1D99 62 PUSH3 0x461bcd 1D9D 60 PUSH1 0xe5 1D9F 1B SHL 1DA0 81 DUP2 1DA1 52 MSTORE 1DA2 60 PUSH1 0x04 1DA4 01 ADD 1DA5 61 PUSH2 0x0840 1DA8 90 SWAP1 1DA9 61 PUSH2 0x3a86 1DAC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DA8 stack[0] = 0x0840 // @1DA8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_1DAD: // Incoming jump from 0x1D95, if stack[-1] // Inputs[1] { @1DB1 stack[-3] } 1DAD 5B JUMPDEST 1DAE 61 PUSH2 0x1db6 1DB1 83 DUP4 1DB2 61 PUSH2 0x2b39 1DB5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DAE stack[0] = 0x1db6 // @1DB1 stack[1] = stack[-3] // } // Block ends with call to 0x2b39, returns to 0x1DB6 label_1DB6: // Incoming return from call to 0x2B39 at 0x1DB5 // Inputs[1] { @1DB7 stack[-1] } 1DB6 5B JUMPDEST 1DB7 15 ISZERO 1DB8 61 PUSH2 0x1e56 1DBB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e56, if !stack[-1] label_1DBC: // Incoming jump from 0x1DBB, if not !stack[-1] // Inputs[2] // { // @1DBC address(this).balance // @1DBC address(this) // } 1DBC 47 SELFBALANCE 1DBD 15 ISZERO 1DBE 61 PUSH2 0x1e51 1DC1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e51, if !address(this).balance label_1DC2: // Incoming jump from 0x1DC1, if not !address(this).balance // Inputs[3] // { // @1DC2 address(this) // @1DC2 address(this).balance // @1DC6 stack[-2] // } 1DC2 47 SELFBALANCE 1DC3 60 PUSH1 0x00 1DC5 81 DUP2 1DC6 84 DUP5 1DC7 11 GT 1DC8 61 PUSH2 0x1dd1 1DCB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DC2 stack[0] = address(this).balance // @1DC3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1dd1, if stack[-2] > address(this).balance label_1DCC: // Incoming jump from 0x1DCB, if not stack[-2] > address(this).balance // Inputs[1] { @1DCC stack[-4] } 1DCC 83 DUP4 1DCD 61 PUSH2 0x1dd3 1DD0 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DCC stack[0] = stack[-4] } // Block ends with unconditional jump to 0x1dd3 label_1DD1: // Incoming jump from 0x1DCB, if stack[-2] > address(this).balance // Inputs[4] // { // @1DD2 stack[-2] // @1DD4 stack[-1] // @1DD8 stack[-3] // @1DE5 memory[0x40:0x60] // } 1DD1 5B JUMPDEST 1DD2 81 DUP2 1DD3 5B JUMPDEST 1DD4 90 SWAP1 1DD5 50 POP 1DD6 60 PUSH1 0x00 1DD8 83 DUP4 1DD9 60 PUSH1 0x01 1DDB 60 PUSH1 0x01 1DDD 60 PUSH1 0xa0 1DDF 1B SHL 1DE0 03 SUB 1DE1 16 AND 1DE2 82 DUP3 1DE3 60 PUSH1 0x40 1DE5 51 MLOAD 1DE6 61 PUSH2 0x1dee 1DE9 90 SWAP1 1DEA 61 PUSH2 0x3722 1DED 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1DD4 stack[-1] = stack[-2] // @1DD6 stack[0] = 0x00 // @1DE1 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1DE2 stack[2] = stack[-2] // @1DE9 stack[3] = 0x1dee // @1DE9 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x3722, returns to 0x1DEE label_1DEE: // Incoming return from call to 0x3722 at 0x1DED // Incoming return from call to 0x3722 at 0x1DED // Inputs[8] // { // @1DF3 memory[0x40:0x60] // @1DF5 stack[-1] // @1DF8 stack[-2] // @1DF9 stack[-3] // @1DFA msg.gas // @1DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1DFB address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1E00 returndata.length // } 1DEE 5B JUMPDEST 1DEF 60 PUSH1 0x00 1DF1 60 PUSH1 0x40 1DF3 51 MLOAD 1DF4 80 DUP1 1DF5 83 DUP4 1DF6 03 SUB 1DF7 81 DUP2 1DF8 85 DUP6 1DF9 87 DUP8 1DFA 5A GAS 1DFB F1 CALL 1DFC 92 SWAP3 1DFD 50 POP 1DFE 50 POP 1DFF 50 POP 1E00 3D RETURNDATASIZE 1E01 80 DUP1 1E02 60 PUSH1 0x00 1E04 81 DUP2 1E05 14 EQ 1E06 61 PUSH2 0x1e2b 1E09 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1DFC stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1E00 stack[-2] = returndata.length // @1E01 stack[-1] = returndata.length // } // Block ends with conditional jump to 0x1e2b, if returndata.length == 0x00 label_1E0A: // Incoming jump from 0x1E09, if not returndata.length == 0x00 // Inputs[6] // { // @1E0C memory[0x40:0x60] // @1E0D stack[-2] // @1E14 returndata.length // @1E1C returndata.length // @1E1F returndata.length // @1E26 returndata[0x00:0x00 + returndata.length] // } 1E0A 60 PUSH1 0x40 1E0C 51 MLOAD 1E0D 91 SWAP2 1E0E 50 POP 1E0F 60 PUSH1 0x1f 1E11 19 NOT 1E12 60 PUSH1 0x3f 1E14 3D RETURNDATASIZE 1E15 01 ADD 1E16 16 AND 1E17 82 DUP3 1E18 01 ADD 1E19 60 PUSH1 0x40 1E1B 52 MSTORE 1E1C 3D RETURNDATASIZE 1E1D 82 DUP3 1E1E 52 MSTORE 1E1F 3D RETURNDATASIZE 1E20 60 PUSH1 0x00 1E22 60 PUSH1 0x20 1E24 84 DUP5 1E25 01 ADD 1E26 3E RETURNDATACOPY 1E27 61 PUSH2 0x1e30 1E2A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E0D stack[-2] = memory[0x40:0x60] // @1E1B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1E1E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1E26 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1e30 label_1E2B: // Incoming jump from 0x1E09, if returndata.length == 0x00 // Inputs[3] // { // @1E2E stack[-2] // @1E33 stack[-4] // @1E33 stack[-3] // } 1E2B 5B JUMPDEST 1E2C 60 PUSH1 0x60 1E2E 91 SWAP2 1E2F 50 POP 1E30 5B JUMPDEST 1E31 50 POP 1E32 50 POP 1E33 90 SWAP1 1E34 50 POP 1E35 80 DUP1 1E36 61 PUSH2 0x11af 1E39 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1E33 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x11af, if stack[-3] label_1E3A: // Incoming jump from 0x1E39, if not stack[-3] // Incoming jump from 0x1E39, if not stack[-3] // Inputs[1] { @1E3C memory[0x40:0x60] } 1E3A 60 PUSH1 0x40 1E3C 51 MLOAD 1E3D 62 PUSH3 0x461bcd 1E41 60 PUSH1 0xe5 1E43 1B SHL 1E44 81 DUP2 1E45 52 MSTORE 1E46 60 PUSH1 0x04 1E48 01 ADD 1E49 61 PUSH2 0x0840 1E4C 90 SWAP1 1E4D 61 PUSH2 0x3adc 1E50 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E4C stack[0] = 0x0840 // @1E4C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3adc, returns to 0x0840 label_1E51: // Incoming jump from 0x1DC1, if !address(this).balance 1E51 5B JUMPDEST 1E52 61 PUSH2 0x0a97 1E55 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a97 label_1E56: // Incoming jump from 0x1DBB, if !stack[-1] // Inputs[3] // { // @1E59 memory[0x40:0x60] // @1E6F stack[-3] // @1E7C address(this) // } 1E56 5B JUMPDEST 1E57 60 PUSH1 0x40 1E59 51 MLOAD 1E5A 63 PUSH4 0x70a08231 1E5F 60 PUSH1 0xe0 1E61 1B SHL 1E62 81 DUP2 1E63 52 MSTORE 1E64 60 PUSH1 0x00 1E66 90 SWAP1 1E67 60 PUSH1 0x01 1E69 60 PUSH1 0x01 1E6B 60 PUSH1 0xa0 1E6D 1B SHL 1E6E 03 SUB 1E6F 85 DUP6 1E70 16 AND 1E71 90 SWAP1 1E72 63 PUSH4 0x70a08231 1E77 90 SWAP1 1E78 61 PUSH2 0x1e85 1E7B 90 SWAP1 1E7C 30 ADDRESS 1E7D 90 SWAP1 1E7E 60 PUSH1 0x04 1E80 01 ADD 1E81 61 PUSH2 0x3725 1E84 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1E63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @1E66 stack[0] = 0x00 // @1E71 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1E77 stack[2] = 0x70a08231 // @1E7B stack[3] = 0x1e85 // @1E7D stack[4] = address(this) // @1E80 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x1E85 label_1E85: // Incoming return from call to 0x3725 at 0x1E84 // Inputs[4] // { // @1E8A memory[0x40:0x60] // @1E8C stack[-1] // @1E8F stack[-3] // @1E91 address(stack[-3]).code.length // } 1E85 5B JUMPDEST 1E86 60 PUSH1 0x20 1E88 60 PUSH1 0x40 1E8A 51 MLOAD 1E8B 80 DUP1 1E8C 83 DUP4 1E8D 03 SUB 1E8E 81 DUP2 1E8F 86 DUP7 1E90 80 DUP1 1E91 3B EXTCODESIZE 1E92 15 ISZERO 1E93 80 DUP1 1E94 15 ISZERO 1E95 61 PUSH2 0x1e9d 1E98 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1E86 stack[0] = 0x20 // @1E8A stack[1] = memory[0x40:0x60] // @1E8D stack[2] = stack[-1] - memory[0x40:0x60] // @1E8E stack[3] = memory[0x40:0x60] // @1E8F stack[4] = stack[-3] // @1E92 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1e9d, if !!address(stack[-3]).code.length label_1E99: // Incoming jump from 0x1E98, if not !!address(stack[-3]).code.length // Inputs[1] { @1E9C memory[0x00:0x00] } 1E99 60 PUSH1 0x00 1E9B 80 DUP1 1E9C FD *REVERT // Stack delta = +0 // Outputs[1] { @1E9C revert(memory[0x00:0x00]); } // Block terminates label_1E9D: // Incoming jump from 0x1E98, if !!address(stack[-3]).code.length // Inputs[8] // { // @1E9F msg.gas // @1EA0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EA0 memory[stack[-3]:stack[-3] + stack[-4]] // @1EA0 stack[-5] // @1EA0 stack[-2] // @1EA0 stack[-4] // @1EA0 stack[-6] // @1EA0 stack[-3] // } 1E9D 5B JUMPDEST 1E9E 50 POP 1E9F 5A GAS 1EA0 FA STATICCALL 1EA1 15 ISZERO 1EA2 80 DUP1 1EA3 15 ISZERO 1EA4 61 PUSH2 0x1eb1 1EA7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1EA0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EA1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1eb1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1EA8: // Incoming jump from 0x1EA7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1EA8 returndata.length // @1EAC returndata[0x00:0x00 + returndata.length] // @1EAD returndata.length // @1EB0 memory[0x00:0x00 + returndata.length] // } 1EA8 3D RETURNDATASIZE 1EA9 60 PUSH1 0x00 1EAB 80 DUP1 1EAC 3E RETURNDATACOPY 1EAD 3D RETURNDATASIZE 1EAE 60 PUSH1 0x00 1EB0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1EAC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1EB0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1EB1: // Incoming jump from 0x1EA7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1EB8 memory[0x40:0x60] // @1EB9 returndata.length // } 1EB1 5B JUMPDEST 1EB2 50 POP 1EB3 50 POP 1EB4 50 POP 1EB5 50 POP 1EB6 60 PUSH1 0x40 1EB8 51 MLOAD 1EB9 3D RETURNDATASIZE 1EBA 60 PUSH1 0x1f 1EBC 19 NOT 1EBD 60 PUSH1 0x1f 1EBF 82 DUP3 1EC0 01 ADD 1EC1 16 AND 1EC2 82 DUP3 1EC3 01 ADD 1EC4 80 DUP1 1EC5 60 PUSH1 0x40 1EC7 52 MSTORE 1EC8 50 POP 1EC9 81 DUP2 1ECA 01 ADD 1ECB 90 SWAP1 1ECC 61 PUSH2 0x1ed5 1ECF 91 SWAP2 1ED0 90 SWAP1 1ED1 61 PUSH2 0x366d 1ED4 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1EC7 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1ECF stack[-4] = 0x1ed5 // @1ED0 stack[-2] = memory[0x40:0x60] // @1ED0 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x1ED5 label_1ED5: // Incoming return from call to 0x366D at 0x1ED4 // Inputs[3] // { // @1ED6 stack[-2] // @1ED6 stack[-1] // @1EDB stack[-4] // } 1ED5 5B JUMPDEST 1ED6 90 SWAP1 1ED7 50 POP 1ED8 60 PUSH1 0x00 1EDA 81 DUP2 1EDB 84 DUP5 1EDC 11 GT 1EDD 61 PUSH2 0x1ee6 1EE0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1ED6 stack[-2] = stack[-1] // @1ED8 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1ee6, if stack[-4] > stack[-1] label_1EE1: // Incoming jump from 0x1EE0, if not stack[-4] > stack[-1] // Inputs[1] { @1EE1 stack[-4] } 1EE1 83 DUP4 1EE2 61 PUSH2 0x1ee8 1EE5 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EE1 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x1ee8 label_1EE6: // Incoming jump from 0x1EE0, if stack[-4] > stack[-1] // Inputs[4] // { // @1EE7 stack[-2] // @1EE9 stack[-1] // @1EEE stack[-5] // @1EEF stack[-3] // } 1EE6 5B JUMPDEST 1EE7 81 DUP2 1EE8 5B JUMPDEST 1EE9 90 SWAP1 1EEA 50 POP 1EEB 61 PUSH2 0x1078 1EEE 85 DUP6 1EEF 84 DUP5 1EF0 83 DUP4 1EF1 61 PUSH2 0x290c 1EF4 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1EE9 stack[-1] = stack[-2] // @1EEB stack[0] = 0x1078 // @1EEE stack[1] = stack[-5] // @1EEF stack[2] = stack[-3] // @1EF0 stack[3] = stack[-2] // } // Block ends with call to 0x290c, returns to 0x1078 label_1EF5: // Incoming jump from 0x073F // Inputs[1] { @1EF9 storage[0x00] } 1EF5 5B JUMPDEST 1EF6 60 PUSH1 0x00 1EF8 80 DUP1 1EF9 54 SLOAD 1EFA 60 PUSH1 0x01 1EFC 60 PUSH1 0xa0 1EFE 1B SHL 1EFF 90 SWAP1 1F00 04 DIV 1F01 60 PUSH1 0xff 1F03 16 AND 1F04 15 ISZERO 1F05 80 DUP1 1F06 61 PUSH2 0x1f1e 1F09 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EF6 stack[0] = 0x00 // @1F04 stack[1] = !(0xff & storage[0x00] / (0x01 << 0xa0)) // } // Block ends with conditional jump to 0x1f1e, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_1F0A: // Incoming jump from 0x1F09, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @1F0B msg.sender // @1F19 memory[0x00:0x40] // @1F1A storage[keccak256(memory[0x00:0x40])] // } 1F0A 50 POP 1F0B 33 CALLER 1F0C 60 PUSH1 0x00 1F0E 90 SWAP1 1F0F 81 DUP2 1F10 52 MSTORE 1F11 60 PUSH1 0x01 1F13 60 PUSH1 0x20 1F15 52 MSTORE 1F16 60 PUSH1 0x40 1F18 90 SWAP1 1F19 20 SHA3 1F1A 54 SLOAD 1F1B 60 PUSH1 0xff 1F1D 16 AND 1F1E 5B JUMPDEST 1F1F 80 DUP1 1F20 61 PUSH2 0x1f41 1F23 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1F10 memory[0x00:0x20] = msg.sender // @1F15 memory[0x20:0x40] = 0x01 // @1F1D stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1f41, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1F24: // Incoming jump from 0x1F23, if not stack[-1] // Incoming jump from 0x1F23, if not 0xff & storage[keccak256(memory[0x00:0x40])] 1F24 50 POP 1F25 61 PUSH2 0x1f2c 1F28 61 PUSH2 0x1a17 1F2B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F25 stack[-1] = 0x1f2c } // Block ends with call to 0x1a17, returns to 0x1F2C label_1F2C: // Incoming return from call to 0x1A17 at 0x1F2B // Inputs[2] // { // @1F35 stack[-1] // @1F36 msg.sender // } 1F2C 5B JUMPDEST 1F2D 60 PUSH1 0x01 1F2F 60 PUSH1 0x01 1F31 60 PUSH1 0xa0 1F33 1B SHL 1F34 03 SUB 1F35 16 AND 1F36 33 CALLER 1F37 60 PUSH1 0x01 1F39 60 PUSH1 0x01 1F3B 60 PUSH1 0xa0 1F3D 1B SHL 1F3E 03 SUB 1F3F 16 AND 1F40 14 EQ // Stack delta = +0 // Outputs[1] { @1F40 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_1F41: // Incoming jump from 0x1F40 // Incoming jump from 0x1F23, if stack[-1] // Incoming jump from 0x1F23, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1F45 stack[-1] } 1F41 5B JUMPDEST 1F42 61 PUSH2 0x1f5d 1F45 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f5d, if stack[-1] label_1F46: // Incoming jump from 0x1F45, if not stack[-1] // Inputs[1] { @1F48 memory[0x40:0x60] } 1F46 60 PUSH1 0x40 1F48 51 MLOAD 1F49 62 PUSH3 0x461bcd 1F4D 60 PUSH1 0xe5 1F4F 1B SHL 1F50 81 DUP2 1F51 52 MSTORE 1F52 60 PUSH1 0x04 1F54 01 ADD 1F55 61 PUSH2 0x0840 1F58 90 SWAP1 1F59 61 PUSH2 0x399a 1F5C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F58 stack[0] = 0x0840 // @1F58 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_1F5D: // Incoming jump from 0x1F45, if stack[-1] // Inputs[1] { @1F60 storage[0x0c] } 1F5D 5B JUMPDEST 1F5E 60 PUSH1 0x0c 1F60 54 SLOAD 1F61 60 PUSH1 0xff 1F63 16 AND 1F64 80 DUP1 1F65 15 ISZERO 1F66 61 PUSH2 0x1f7e 1F69 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F63 stack[0] = 0xff & storage[0x0c] } // Block ends with conditional jump to 0x1f7e, if !(0xff & storage[0x0c]) label_1F6A: // Incoming jump from 0x1F69, if not !(0xff & storage[0x0c]) // Inputs[3] // { // @1F6B block.coinbase // @1F79 memory[0x00:0x40] // @1F7A storage[keccak256(memory[0x00:0x40])] // } 1F6A 50 POP 1F6B 41 COINBASE 1F6C 60 PUSH1 0x00 1F6E 90 SWAP1 1F6F 81 DUP2 1F70 52 MSTORE 1F71 60 PUSH1 0x0d 1F73 60 PUSH1 0x20 1F75 52 MSTORE 1F76 60 PUSH1 0x40 1F78 90 SWAP1 1F79 20 SHA3 1F7A 54 SLOAD 1F7B 60 PUSH1 0xff 1F7D 16 AND 1F7E 5B JUMPDEST 1F7F 15 ISZERO 1F80 61 PUSH2 0x1f8b 1F83 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1F70 memory[0x00:0x20] = block.coinbase // @1F75 memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x1f8b, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1F84: // Incoming jump from 0x1F83, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1F83, if not !stack[-1] 1F84 50 POP 1F85 60 PUSH1 0x00 1F87 61 PUSH2 0x1cb4 1F8A 56 *JUMP // Stack delta = +0 // Outputs[1] { @1F85 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x1cb4 label_1F8B: // Incoming jump from 0x1F83, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1F83, if !stack[-1] 1F8B 5B JUMPDEST 1F8C 60 PUSH1 0x00 1F8E 80 DUP1 1F8F 61 PUSH2 0x1f96 1F92 61 PUSH2 0x2c10 1F95 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F8C stack[0] = 0x00 // @1F8E stack[1] = 0x00 // @1F8F stack[2] = 0x1f96 // } // Block ends with call to 0x2c10, returns to 0x1F96 label_1F96: // Incoming return from call to 0x2C10 at 0x1F95 // Inputs[6] // { // @1F97 stack[-1] // @1F97 stack[-3] // @1F99 stack[-2] // @1F99 stack[-4] // @1FA0 stack[-7] // @1FA3 storage[0x07] // } 1F96 5B JUMPDEST 1F97 91 SWAP2 1F98 50 POP 1F99 91 SWAP2 1F9A 50 POP 1F9B 60 PUSH1 0x00 1F9D 61 PUSH2 0x1fa8 1FA0 86 DUP7 1FA1 60 PUSH1 0x07 1FA3 54 SLOAD 1FA4 61 PUSH2 0x1c95 1FA7 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1F97 stack[-3] = stack[-1] // @1F99 stack[-4] = stack[-2] // @1F9B stack[-2] = 0x00 // @1F9D stack[-1] = 0x1fa8 // @1FA0 stack[0] = stack[-7] // @1FA3 stack[1] = storage[0x07] // } // Block ends with call to 0x1c95, returns to 0x1FA8 label_1FA8: // Incoming return from call to 0x1C95 at 0x1FA7 // Inputs[2] // { // @1FA9 stack[-1] // @1FA9 stack[-2] // } 1FA8 5B JUMPDEST 1FA9 90 SWAP1 1FAA 50 POP 1FAB 61 PUSH2 0x1fb2 1FAE 61 PUSH2 0x327f 1FB1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1FA9 stack[-2] = stack[-1] // @1FAB stack[-1] = 0x1fb2 // } // Block ends with call to 0x327f, returns to 0x1FB2 label_1FB2: // Incoming return from call to 0x327F at 0x1FB1 // Inputs[4] // { // @1FB6 stack[-2] // @1FB7 stack[-4] // @1FB8 stack[-6] // @1FB9 stack[-3] // } 1FB2 5B JUMPDEST 1FB3 61 PUSH2 0x1fbe 1FB6 82 DUP3 1FB7 85 DUP6 1FB8 88 DUP9 1FB9 86 DUP7 1FBA 61 PUSH2 0x2c2d 1FBD 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1FB3 stack[0] = 0x1fbe // @1FB6 stack[1] = stack[-2] // @1FB7 stack[2] = stack[-4] // @1FB8 stack[3] = stack[-6] // @1FB9 stack[4] = stack[-3] // } // Block ends with call to 0x2c2d, returns to 0x1FBE label_1FBE: // Incoming return from call to 0x2C2D at 0x1FBD // Inputs[8] // { // @1FBF stack[-1] // @1FBF stack[-2] // @1FC8 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // @1FCD memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1FD2 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1FD7 memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @1FDC memory[0x80 + stack[-1]:0x80 + stack[-1] + 0x20] // @1FDD address(this) // } 1FBE 5B JUMPDEST 1FBF 90 SWAP1 1FC0 50 POP 1FC1 61 PUSH2 0x1fe2 1FC4 81 DUP2 1FC5 60 PUSH1 0x00 1FC7 01 ADD 1FC8 51 MLOAD 1FC9 82 DUP3 1FCA 60 PUSH1 0x20 1FCC 01 ADD 1FCD 51 MLOAD 1FCE 83 DUP4 1FCF 60 PUSH1 0x40 1FD1 01 ADD 1FD2 51 MLOAD 1FD3 84 DUP5 1FD4 60 PUSH1 0x60 1FD6 01 ADD 1FD7 51 MLOAD 1FD8 85 DUP6 1FD9 60 PUSH1 0x80 1FDB 01 ADD 1FDC 51 MLOAD 1FDD 30 ADDRESS 1FDE 61 PUSH2 0x29f3 1FE1 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1FBF stack[-2] = stack[-1] // @1FC1 stack[-1] = 0x1fe2 // @1FC8 stack[0] = memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // @1FCD stack[1] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1FD2 stack[2] = memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1FD7 stack[3] = memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @1FDC stack[4] = memory[0x80 + stack[-1]:0x80 + stack[-1] + 0x20] // @1FDD stack[5] = address(this) // } // Block ends with unconditional jump to 0x29f3 1FE2 5B JUMPDEST 1FE3 94 SWAP5 1FE4 50 POP 1FE5 61 PUSH2 0x1ffd 1FE8 81 DUP2 1FE9 60 PUSH1 0x00 1FEB 01 ADD 1FEC 51 MLOAD 1FED 82 DUP3 1FEE 60 PUSH1 0x20 1FF0 01 ADD 1FF1 51 MLOAD 1FF2 83 DUP4 1FF3 60 PUSH1 0x40 1FF5 01 ADD 1FF6 51 MLOAD 1FF7 87 DUP8 1FF8 89 DUP10 1FF9 61 PUSH2 0x2d89 1FFC 56 *JUMP 1FFD 5B JUMPDEST 1FFE 50 POP 1FFF 50 POP 2000 50 POP 2001 50 POP 2002 92 SWAP3 2003 91 SWAP2 2004 50 POP 2005 50 POP 2006 56 *JUMP label_2007: // Incoming jump from 0x0752 // Inputs[1] { @200A storage[0x00] } 2007 5B JUMPDEST 2008 60 PUSH1 0x00 200A 54 SLOAD 200B 60 PUSH1 0x01 200D 60 PUSH1 0xa0 200F 1B SHL 2010 90 SWAP1 2011 04 DIV 2012 60 PUSH1 0xff 2014 16 AND 2015 15 ISZERO 2016 80 DUP1 2017 61 PUSH2 0x202f 201A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2015 stack[0] = !(0xff & storage[0x00] / (0x01 << 0xa0)) } // Block ends with conditional jump to 0x202f, if !(0xff & storage[0x00] / (0x01 << 0xa0)) label_201B: // Incoming jump from 0x201A, if not !(0xff & storage[0x00] / (0x01 << 0xa0)) // Inputs[3] // { // @201C msg.sender // @202A memory[0x00:0x40] // @202B storage[keccak256(memory[0x00:0x40])] // } 201B 50 POP 201C 33 CALLER 201D 60 PUSH1 0x00 201F 90 SWAP1 2020 81 DUP2 2021 52 MSTORE 2022 60 PUSH1 0x01 2024 60 PUSH1 0x20 2026 52 MSTORE 2027 60 PUSH1 0x40 2029 90 SWAP1 202A 20 SHA3 202B 54 SLOAD 202C 60 PUSH1 0xff 202E 16 AND 202F 5B JUMPDEST 2030 80 DUP1 2031 61 PUSH2 0x2052 2034 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2021 memory[0x00:0x20] = msg.sender // @2026 memory[0x20:0x40] = 0x01 // @202E stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2052, if 0xff & storage[keccak256(memory[0x00:0x40])] label_2035: // Incoming jump from 0x2034, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x2034, if not stack[-1] 2035 50 POP 2036 61 PUSH2 0x203d 2039 61 PUSH2 0x1a17 203C 56 *JUMP // Stack delta = +0 // Outputs[1] { @2036 stack[-1] = 0x203d } // Block ends with call to 0x1a17, returns to 0x203D label_203D: // Incoming return from call to 0x1A17 at 0x203C // Inputs[2] // { // @2046 stack[-1] // @2047 msg.sender // } 203D 5B JUMPDEST 203E 60 PUSH1 0x01 2040 60 PUSH1 0x01 2042 60 PUSH1 0xa0 2044 1B SHL 2045 03 SUB 2046 16 AND 2047 33 CALLER 2048 60 PUSH1 0x01 204A 60 PUSH1 0x01 204C 60 PUSH1 0xa0 204E 1B SHL 204F 03 SUB 2050 16 AND 2051 14 EQ // Stack delta = +0 // Outputs[1] { @2051 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block continues label_2052: // Incoming jump from 0x2034, if stack[-1] // Incoming jump from 0x2034, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x2051 // Inputs[1] { @2056 stack[-1] } 2052 5B JUMPDEST 2053 61 PUSH2 0x206e 2056 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x206e, if stack[-1] label_2057: // Incoming jump from 0x2056, if not stack[-1] // Inputs[1] { @2059 memory[0x40:0x60] } 2057 60 PUSH1 0x40 2059 51 MLOAD 205A 62 PUSH3 0x461bcd 205E 60 PUSH1 0xe5 2060 1B SHL 2061 81 DUP2 2062 52 MSTORE 2063 60 PUSH1 0x04 2065 01 ADD 2066 61 PUSH2 0x0840 2069 90 SWAP1 206A 61 PUSH2 0x399a 206D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2062 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2069 stack[0] = 0x0840 // @2069 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x399a, returns to 0x0840 label_206E: // Incoming jump from 0x2056, if stack[-1] // Inputs[1] { @2071 storage[0x0c] } 206E 5B JUMPDEST 206F 60 PUSH1 0x0c 2071 54 SLOAD 2072 60 PUSH1 0xff 2074 16 AND 2075 80 DUP1 2076 15 ISZERO 2077 61 PUSH2 0x208f 207A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2074 stack[0] = 0xff & storage[0x0c] } // Block ends with conditional jump to 0x208f, if !(0xff & storage[0x0c]) label_207B: // Incoming jump from 0x207A, if not !(0xff & storage[0x0c]) // Inputs[3] // { // @207C block.coinbase // @208A memory[0x00:0x40] // @208B storage[keccak256(memory[0x00:0x40])] // } 207B 50 POP 207C 41 COINBASE 207D 60 PUSH1 0x00 207F 90 SWAP1 2080 81 DUP2 2081 52 MSTORE 2082 60 PUSH1 0x0d 2084 60 PUSH1 0x20 2086 52 MSTORE 2087 60 PUSH1 0x40 2089 90 SWAP1 208A 20 SHA3 208B 54 SLOAD 208C 60 PUSH1 0xff 208E 16 AND 208F 5B JUMPDEST 2090 15 ISZERO 2091 61 PUSH2 0x2099 2094 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2081 memory[0x00:0x20] = block.coinbase // @2086 memory[0x20:0x40] = 0x0d // } // Block ends with conditional jump to 0x2099, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_2095: // Incoming jump from 0x2094, if not !stack[-1] // Incoming jump from 0x2094, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) 2095 61 PUSH2 0x0b67 2098 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b67 label_2099: // Incoming jump from 0x2094, if !stack[-1] // Incoming jump from 0x2094, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @209C storage[0x0e] // @209F storage[0x10] // @20A2 storage[0x0f] // @20A5 storage[0x12] // } 2099 5B JUMPDEST 209A 60 PUSH1 0x0e 209C 54 SLOAD 209D 60 PUSH1 0x10 209F 54 SLOAD 20A0 60 PUSH1 0x0f 20A2 54 SLOAD 20A3 60 PUSH1 0x12 20A5 54 SLOAD 20A6 60 PUSH1 0x00 20A8 93 SWAP4 20A9 61 PUSH2 0x20c4 20AC 93 SWAP4 20AD 60 PUSH1 0x01 20AF 60 PUSH1 0x01 20B1 60 PUSH1 0xa0 20B3 1B SHL 20B4 03 SUB 20B5 91 SWAP2 20B6 82 DUP3 20B7 16 AND 20B8 93 SWAP4 20B9 90 SWAP1 20BA 82 DUP3 20BB 16 AND 20BC 92 SWAP3 20BD 91 SWAP2 20BE 16 AND 20BF 90 SWAP1 20C0 61 PUSH2 0x0c91 20C3 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @20A8 stack[0] = 0x00 // @20AC stack[1] = 0x20c4 // @20B8 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @20BC stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x10] // @20BF stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @20BF stack[5] = storage[0x12] // } // Block ends with call to 0x0c91, returns to 0x20C4 label_20C4: // Incoming return from call to 0x0C91 at 0x20C3 // Inputs[3] // { // @20C5 stack[-1] // @20C5 stack[-2] // @20C7 stack[-3] // } 20C4 5B JUMPDEST 20C5 90 SWAP1 20C6 50 POP 20C7 81 DUP2 20C8 81 DUP2 20C9 10 LT 20CA 15 ISZERO 20CB 61 PUSH2 0x20e6 20CE 57 *JUMPI // Stack delta = -1 // Outputs[1] { @20C5 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x20e6, if !(stack[-1] < stack[-3]) label_20CF: // Incoming jump from 0x20CE, if not !(stack[-1] < stack[-3]) // Inputs[1] { @20D1 memory[0x40:0x60] } 20CF 60 PUSH1 0x40 20D1 51 MLOAD 20D2 62 PUSH3 0x461bcd 20D6 60 PUSH1 0xe5 20D8 1B SHL 20D9 81 DUP2 20DA 52 MSTORE 20DB 60 PUSH1 0x04 20DD 01 ADD 20DE 61 PUSH2 0x0840 20E1 90 SWAP1 20E2 61 PUSH2 0x3abb 20E5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @20DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20E1 stack[0] = 0x0840 // @20E1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3abb, returns to 0x0840 label_20E6: // Incoming jump from 0x20CE, if !(stack[-1] < stack[-3]) 20E6 5B JUMPDEST 20E7 61 PUSH2 0x20ee 20EA 61 PUSH2 0x2844 20ED 56 *JUMP // Stack delta = +1 // Outputs[1] { @20E7 stack[0] = 0x20ee } // Block ends with unconditional jump to 0x2844 20EE 5B JUMPDEST 20EF 50 POP 20F0 60 PUSH1 0x00 20F2 61 PUSH2 0x20f9 20F5 61 PUSH2 0x2876 20F8 56 *JUMP 20F9 5B JUMPDEST 20FA 90 SWAP1 20FB 50 POP 20FC 60 PUSH1 0x00 20FE 41 COINBASE 20FF 60 PUSH1 0x01 2101 60 PUSH1 0x01 2103 60 PUSH1 0xa0 2105 1B SHL 2106 03 SUB 2107 16 AND 2108 82 DUP3 2109 60 PUSH1 0x40 210B 51 MLOAD 210C 61 PUSH2 0x2114 210F 90 SWAP1 2110 61 PUSH2 0x3722 2113 56 *JUMP 2114 5B JUMPDEST 2115 60 PUSH1 0x00 2117 60 PUSH1 0x40 2119 51 MLOAD 211A 80 DUP1 211B 83 DUP4 211C 03 SUB 211D 81 DUP2 211E 85 DUP6 211F 87 DUP8 2120 5A GAS 2121 F1 CALL 2122 92 SWAP3 2123 50 POP 2124 50 POP 2125 50 POP 2126 3D RETURNDATASIZE 2127 80 DUP1 2128 60 PUSH1 0x00 212A 81 DUP2 212B 14 EQ 212C 61 PUSH2 0x1201 212F 57 *JUMPI 2130 60 PUSH1 0x40 2132 51 MLOAD 2133 91 SWAP2 2134 50 POP 2135 60 PUSH1 0x1f 2137 19 NOT 2138 60 PUSH1 0x3f 213A 3D RETURNDATASIZE 213B 01 ADD 213C 16 AND 213D 82 DUP3 213E 01 ADD 213F 60 PUSH1 0x40 2141 52 MSTORE 2142 3D RETURNDATASIZE 2143 82 DUP3 2144 52 MSTORE 2145 3D RETURNDATASIZE 2146 60 PUSH1 0x00 2148 60 PUSH1 0x20 214A 84 DUP5 214B 01 ADD 214C 3E RETURNDATACOPY 214D 61 PUSH2 0x1201 2150 56 *JUMP 2151 5B JUMPDEST 2152 61 PUSH2 0x2159 2155 61 PUSH2 0x1a26 2158 56 *JUMP 2159 5B JUMPDEST 215A 61 PUSH2 0x2175 215D 57 *JUMPI 215E 60 PUSH1 0x40 2160 51 MLOAD 2161 62 PUSH3 0x461bcd 2165 60 PUSH1 0xe5 2167 1B SHL 2168 81 DUP2 2169 52 MSTORE 216A 60 PUSH1 0x04 216C 01 ADD 216D 61 PUSH2 0x0840 2170 90 SWAP1 2171 61 PUSH2 0x3a86 2174 56 *JUMP 2175 5B JUMPDEST 2176 60 PUSH1 0x40 2178 51 MLOAD 2179 63 PUSH4 0x6eb1769f 217E 60 PUSH1 0xe1 2180 1B SHL 2181 81 DUP2 2182 52 MSTORE 2183 60 PUSH1 0x00 2185 90 SWAP1 2186 60 PUSH1 0x01 2188 60 PUSH1 0x01 218A 60 PUSH1 0xa0 218C 1B SHL 218D 03 SUB 218E 85 DUP6 218F 16 AND 2190 90 SWAP1 2191 63 PUSH4 0xdd62ed3e 2196 90 SWAP1 2197 61 PUSH2 0x21a6 219A 90 SWAP1 219B 30 ADDRESS 219C 90 SWAP1 219D 87 DUP8 219E 90 SWAP1 219F 60 PUSH1 0x04 21A1 01 ADD 21A2 61 PUSH2 0x3739 21A5 56 *JUMP 21A6 5B JUMPDEST 21A7 60 PUSH1 0x20 21A9 60 PUSH1 0x40 21AB 51 MLOAD 21AC 80 DUP1 21AD 83 DUP4 21AE 03 SUB 21AF 81 DUP2 21B0 86 DUP7 21B1 80 DUP1 21B2 3B EXTCODESIZE 21B3 15 ISZERO 21B4 80 DUP1 21B5 15 ISZERO 21B6 61 PUSH2 0x21be 21B9 57 *JUMPI 21BA 60 PUSH1 0x00 21BC 80 DUP1 21BD FD *REVERT 21BE 5B JUMPDEST 21BF 50 POP 21C0 5A GAS 21C1 FA STATICCALL 21C2 15 ISZERO 21C3 80 DUP1 21C4 15 ISZERO 21C5 61 PUSH2 0x21d2 21C8 57 *JUMPI 21C9 3D RETURNDATASIZE 21CA 60 PUSH1 0x00 21CC 80 DUP1 21CD 3E RETURNDATACOPY 21CE 3D RETURNDATASIZE 21CF 60 PUSH1 0x00 21D1 FD *REVERT 21D2 5B JUMPDEST 21D3 50 POP 21D4 50 POP 21D5 50 POP 21D6 50 POP 21D7 60 PUSH1 0x40 21D9 51 MLOAD 21DA 3D RETURNDATASIZE 21DB 60 PUSH1 0x1f 21DD 19 NOT 21DE 60 PUSH1 0x1f 21E0 82 DUP3 21E1 01 ADD 21E2 16 AND 21E3 82 DUP3 21E4 01 ADD 21E5 80 DUP1 21E6 60 PUSH1 0x40 21E8 52 MSTORE 21E9 50 POP 21EA 81 DUP2 21EB 01 ADD 21EC 90 SWAP1 21ED 61 PUSH2 0x21f6 21F0 91 SWAP2 21F1 90 SWAP1 21F2 61 PUSH2 0x366d 21F5 56 *JUMP 21F6 5B JUMPDEST 21F7 11 GT 21F8 15 ISZERO 21F9 61 PUSH2 0x2208 21FC 57 *JUMPI 21FD 61 PUSH2 0x2208 2200 83 DUP4 2201 83 DUP4 2202 60 PUSH1 0x00 2204 61 PUSH2 0x2e42 2207 56 *JUMP 2208 5B JUMPDEST 2209 61 PUSH2 0x0a97 220C 83 DUP4 220D 83 DUP4 220E 83 DUP4 220F 61 PUSH2 0x2e42 2212 56 *JUMP label_2213: // Incoming call from 0x1AAF, returns to 0x1AB0 // Incoming jump from 0x0792 // Inputs[1] { @2219 stack[-1] } 2213 5B JUMPDEST 2214 60 PUSH1 0x00 2216 61 PUSH2 0x221e 2219 82 DUP3 221A 61 PUSH2 0x2b39 221D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2214 stack[0] = 0x00 // @2216 stack[1] = 0x221e // @2219 stack[2] = stack[-1] // } // Block ends with call to 0x2b39, returns to 0x221E label_221E: // Incoming return from call to 0x2B39 at 0x221D // Inputs[1] { @221F stack[-1] } 221E 5B JUMPDEST 221F 15 ISZERO 2220 61 PUSH2 0x222a 2223 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x222a, if !stack[-1] label_2224: // Incoming jump from 0x2223, if not !stack[-1] // Inputs[2] // { // @2225 address(this).balance // @2225 address(this) // } 2224 50 POP 2225 47 SELFBALANCE 2226 61 PUSH2 0x0d65 2229 56 *JUMP // Stack delta = +0 // Outputs[1] { @2225 stack[-1] = address(this).balance } // Block ends with unconditional jump to 0x0d65 label_222A: // Incoming jump from 0x2223, if !stack[-1] // Inputs[3] // { // @222D memory[0x40:0x60] // @2240 stack[-2] // @224D address(this) // } 222A 5B JUMPDEST 222B 60 PUSH1 0x40 222D 51 MLOAD 222E 63 PUSH4 0x70a08231 2233 60 PUSH1 0xe0 2235 1B SHL 2236 81 DUP2 2237 52 MSTORE 2238 60 PUSH1 0x01 223A 60 PUSH1 0x01 223C 60 PUSH1 0xa0 223E 1B SHL 223F 03 SUB 2240 83 DUP4 2241 16 AND 2242 90 SWAP1 2243 63 PUSH4 0x70a08231 2248 90 SWAP1 2249 61 PUSH2 0x2256 224C 90 SWAP1 224D 30 ADDRESS 224E 90 SWAP1 224F 60 PUSH1 0x04 2251 01 ADD 2252 61 PUSH2 0x3725 2255 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2237 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @2242 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2248 stack[1] = 0x70a08231 // @224C stack[2] = 0x2256 // @224E stack[3] = address(this) // @2251 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x2256 label_2256: // Incoming return from call to 0x3725 at 0x2255 // Inputs[4] // { // @225B memory[0x40:0x60] // @225D stack[-1] // @2260 stack[-3] // @2262 address(stack[-3]).code.length // } 2256 5B JUMPDEST 2257 60 PUSH1 0x20 2259 60 PUSH1 0x40 225B 51 MLOAD 225C 80 DUP1 225D 83 DUP4 225E 03 SUB 225F 81 DUP2 2260 86 DUP7 2261 80 DUP1 2262 3B EXTCODESIZE 2263 15 ISZERO 2264 80 DUP1 2265 15 ISZERO 2266 61 PUSH2 0x226e 2269 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2257 stack[0] = 0x20 // @225B stack[1] = memory[0x40:0x60] // @225E stack[2] = stack[-1] - memory[0x40:0x60] // @225F stack[3] = memory[0x40:0x60] // @2260 stack[4] = stack[-3] // @2263 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x226e, if !!address(stack[-3]).code.length label_226A: // Incoming jump from 0x2269, if not !!address(stack[-3]).code.length // Inputs[1] { @226D memory[0x00:0x00] } 226A 60 PUSH1 0x00 226C 80 DUP1 226D FD *REVERT // Stack delta = +0 // Outputs[1] { @226D revert(memory[0x00:0x00]); } // Block terminates label_226E: // Incoming jump from 0x2269, if !!address(stack[-3]).code.length // Inputs[8] // { // @2270 msg.gas // @2271 stack[-6] // @2271 memory[stack[-3]:stack[-3] + stack[-4]] // @2271 stack[-5] // @2271 stack[-4] // @2271 stack[-2] // @2271 stack[-3] // @2271 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 226E 5B JUMPDEST 226F 50 POP 2270 5A GAS 2271 FA STATICCALL 2272 15 ISZERO 2273 80 DUP1 2274 15 ISZERO 2275 61 PUSH2 0x2282 2278 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2271 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2272 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2282, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2279: // Incoming jump from 0x2278, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2279 returndata.length // @227D returndata[0x00:0x00 + returndata.length] // @227E returndata.length // @2281 memory[0x00:0x00 + returndata.length] // } 2279 3D RETURNDATASIZE 227A 60 PUSH1 0x00 227C 80 DUP1 227D 3E RETURNDATACOPY 227E 3D RETURNDATASIZE 227F 60 PUSH1 0x00 2281 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @227D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2281 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2282: // Incoming jump from 0x2278, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2289 memory[0x40:0x60] // @228A returndata.length // } 2282 5B JUMPDEST 2283 50 POP 2284 50 POP 2285 50 POP 2286 50 POP 2287 60 PUSH1 0x40 2289 51 MLOAD 228A 3D RETURNDATASIZE 228B 60 PUSH1 0x1f 228D 19 NOT 228E 60 PUSH1 0x1f 2290 82 DUP3 2291 01 ADD 2292 16 AND 2293 82 DUP3 2294 01 ADD 2295 80 DUP1 2296 60 PUSH1 0x40 2298 52 MSTORE 2299 50 POP 229A 81 DUP2 229B 01 ADD 229C 90 SWAP1 229D 61 PUSH2 0x22a6 22A0 91 SWAP2 22A1 90 SWAP1 22A2 61 PUSH2 0x366d 22A5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2298 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @22A0 stack[-4] = 0x22a6 // @22A1 stack[-2] = memory[0x40:0x60] // @22A1 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x22A6 label_22A6: // Incoming return from call to 0x366D at 0x22A5 // Inputs[2] // { // @22A7 stack[-1] // @22A7 stack[-2] // } 22A6 5B JUMPDEST 22A7 90 SWAP1 22A8 50 POP 22A9 61 PUSH2 0x0d65 22AC 56 *JUMP // Stack delta = -1 // Outputs[1] { @22A7 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0d65 label_22AD: // Incoming jump from 0x07B2 22AD 5B JUMPDEST 22AE 61 PUSH2 0x22b5 22B1 61 PUSH2 0x1a26 22B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @22AE stack[0] = 0x22b5 } // Block ends with call to 0x1a26, returns to 0x22B5 label_22B5: // Incoming return from call to 0x1A26 at 0x22B4 // Inputs[1] { @22B9 stack[-1] } 22B5 5B JUMPDEST 22B6 61 PUSH2 0x22d1 22B9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x22d1, if stack[-1] label_22BA: // Incoming jump from 0x22B9, if not stack[-1] // Inputs[1] { @22BC memory[0x40:0x60] } 22BA 60 PUSH1 0x40 22BC 51 MLOAD 22BD 62 PUSH3 0x461bcd 22C1 60 PUSH1 0xe5 22C3 1B SHL 22C4 81 DUP2 22C5 52 MSTORE 22C6 60 PUSH1 0x04 22C8 01 ADD 22C9 61 PUSH2 0x0840 22CC 90 SWAP1 22CD 61 PUSH2 0x3a86 22D0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @22C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @22CC stack[0] = 0x0840 // @22CC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_22D1: // Incoming jump from 0x22B9, if stack[-1] // Inputs[2] // { // @22D4 stack[-1] // @22D5 stack[-2] // } 22D1 5B JUMPDEST 22D2 60 PUSH1 0x07 22D4 55 SSTORE 22D5 56 *JUMP // Stack delta = -2 // Outputs[1] { @22D4 storage[0x07] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_22D6: // Incoming call from 0x07C7, returns to 0x07C8 // Inputs[2] // { // @2308 address(this) // @230B memory[0x40:0x60] // } 22D6 5B JUMPDEST 22D7 60 PUSH1 0x00 22D9 80 DUP1 22DA 60 PUSH1 0x00 22DC 80 DUP1 22DD 60 PUSH1 0x00 22DF 80 DUP1 22E0 60 PUSH1 0x00 22E2 80 DUP1 22E3 60 PUSH1 0x00 22E5 73 PUSH20 0xdac17f958d2ee523a2206206994597c13d831ec7 22FA 60 PUSH1 0x01 22FC 60 PUSH1 0x01 22FE 60 PUSH1 0xa0 2300 1B SHL 2301 03 SUB 2302 16 AND 2303 63 PUSH4 0x70a08231 2308 30 ADDRESS 2309 60 PUSH1 0x40 230B 51 MLOAD 230C 82 DUP3 230D 63 PUSH4 0xffffffff 2312 16 AND 2313 60 PUSH1 0xe0 2315 1B SHL 2316 81 DUP2 2317 52 MSTORE 2318 60 PUSH1 0x04 231A 01 ADD 231B 61 PUSH2 0x2324 231E 91 SWAP2 231F 90 SWAP1 2320 61 PUSH2 0x3725 2323 56 *JUMP // Stack delta = +14 // Outputs[15] // { // @22D7 stack[0] = 0x00 // @22D9 stack[1] = 0x00 // @22DA stack[2] = 0x00 // @22DC stack[3] = 0x00 // @22DD stack[4] = 0x00 // @22DF stack[5] = 0x00 // @22E0 stack[6] = 0x00 // @22E2 stack[7] = 0x00 // @22E3 stack[8] = 0x00 // @2302 stack[9] = (0x01 << 0xa0) - 0x01 & 0xdac17f958d2ee523a2206206994597c13d831ec7 // @2303 stack[10] = 0x70a08231 // @2317 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @231E stack[11] = 0x2324 // @231F stack[12] = address(this) // @231F stack[13] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x2324 label_2324: // Incoming return from call to 0x3725 at 0x2323 // Inputs[4] // { // @2329 memory[0x40:0x60] // @232B stack[-1] // @232E stack[-3] // @2330 address(stack[-3]).code.length // } 2324 5B JUMPDEST 2325 60 PUSH1 0x20 2327 60 PUSH1 0x40 2329 51 MLOAD 232A 80 DUP1 232B 83 DUP4 232C 03 SUB 232D 81 DUP2 232E 86 DUP7 232F 80 DUP1 2330 3B EXTCODESIZE 2331 15 ISZERO 2332 80 DUP1 2333 15 ISZERO 2334 61 PUSH2 0x233c 2337 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2325 stack[0] = 0x20 // @2329 stack[1] = memory[0x40:0x60] // @232C stack[2] = stack[-1] - memory[0x40:0x60] // @232D stack[3] = memory[0x40:0x60] // @232E stack[4] = stack[-3] // @2331 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x233c, if !!address(stack[-3]).code.length label_2338: // Incoming jump from 0x2337, if not !!address(stack[-3]).code.length // Inputs[1] { @233B memory[0x00:0x00] } 2338 60 PUSH1 0x00 233A 80 DUP1 233B FD *REVERT // Stack delta = +0 // Outputs[1] { @233B revert(memory[0x00:0x00]); } // Block terminates label_233C: // Incoming jump from 0x2337, if !!address(stack[-3]).code.length // Inputs[8] // { // @233E msg.gas // @233F stack[-6] // @233F stack[-2] // @233F stack[-5] // @233F stack[-4] // @233F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @233F stack[-3] // @233F memory[stack[-3]:stack[-3] + stack[-4]] // } 233C 5B JUMPDEST 233D 50 POP 233E 5A GAS 233F FA STATICCALL 2340 15 ISZERO 2341 80 DUP1 2342 15 ISZERO 2343 61 PUSH2 0x2350 2346 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @233F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2340 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2350, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2347: // Incoming jump from 0x2346, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2347 returndata.length // @234B returndata[0x00:0x00 + returndata.length] // @234C returndata.length // @234F memory[0x00:0x00 + returndata.length] // } 2347 3D RETURNDATASIZE 2348 60 PUSH1 0x00 234A 80 DUP1 234B 3E RETURNDATACOPY 234C 3D RETURNDATASIZE 234D 60 PUSH1 0x00 234F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @234B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @234F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2350: // Incoming jump from 0x2346, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2357 memory[0x40:0x60] // @2358 returndata.length // } 2350 5B JUMPDEST 2351 50 POP 2352 50 POP 2353 50 POP 2354 50 POP 2355 60 PUSH1 0x40 2357 51 MLOAD 2358 3D RETURNDATASIZE 2359 60 PUSH1 0x1f 235B 19 NOT 235C 60 PUSH1 0x1f 235E 82 DUP3 235F 01 ADD 2360 16 AND 2361 82 DUP3 2362 01 ADD 2363 80 DUP1 2364 60 PUSH1 0x40 2366 52 MSTORE 2367 50 POP 2368 81 DUP2 2369 01 ADD 236A 90 SWAP1 236B 61 PUSH2 0x2374 236E 91 SWAP2 236F 90 SWAP1 2370 61 PUSH2 0x366d 2373 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2366 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @236E stack[-4] = 0x2374 // @236F stack[-2] = memory[0x40:0x60] // @236F stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x2374 label_2374: // Incoming return from call to 0x366D at 0x2373 // Inputs[3] // { // @2375 stack[-2] // @2375 stack[-1] // @2379 storage[0x09] // } 2374 5B JUMPDEST 2375 90 SWAP1 2376 50 POP 2377 60 PUSH1 0x09 2379 54 SLOAD 237A 81 DUP2 237B 11 GT 237C 15 ISZERO 237D 61 PUSH2 0x23d2 2380 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2375 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23d2, if !(stack[-1] > storage[0x09]) label_2381: // Incoming jump from 0x2380, if not !(stack[-1] > storage[0x09]) // Inputs[3] // { // @2383 storage[0x09] // @2384 stack[-1] // @2386 stack[-9] // } 2381 60 PUSH1 0x09 2383 54 SLOAD 2384 81 DUP2 2385 03 SUB 2386 98 SWAP9 2387 50 POP 2388 61 PUSH2 0x23cf 238B 73 PUSH20 0x0d4a11d5eeaac28ec3f61d100daf4d40471f1852 23A0 73 PUSH20 0xdac17f958d2ee523a2206206994597c13d831ec7 23B5 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 23CA 8C DUP13 23CB 61 PUSH2 0x0c91 23CE 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2386 stack[-9] = stack[-1] - storage[0x09] // @2388 stack[0] = 0x23cf // @238B stack[1] = 0x0d4a11d5eeaac28ec3f61d100daf4d40471f1852 // @23A0 stack[2] = 0xdac17f958d2ee523a2206206994597c13d831ec7 // @23B5 stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @23CA stack[4] = stack[-1] - storage[0x09] // } // Block ends with call to 0x0c91, returns to 0x23CF label_23CF: // Incoming return from call to 0x0C91 at 0x23CE // Inputs[2] // { // @23D0 stack[-1] // @23D0 stack[-9] // } 23CF 5B JUMPDEST 23D0 97 SWAP8 23D1 50 POP // Stack delta = -1 // Outputs[1] { @23D0 stack[-9] = stack[-1] } // Block continues label_23D2: // Incoming jump from 0x23D1 // Incoming jump from 0x2380, if !(stack[-1] > storage[0x09]) // Inputs[2] // { // @23D5 memory[0x40:0x60] // @2403 address(this) // } 23D2 5B JUMPDEST 23D3 60 PUSH1 0x40 23D5 51 MLOAD 23D6 63 PUSH4 0x70a08231 23DB 60 PUSH1 0xe0 23DD 1B SHL 23DE 81 DUP2 23DF 52 MSTORE 23E0 60 PUSH1 0x00 23E2 90 SWAP1 23E3 73 PUSH20 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 23F8 90 SWAP1 23F9 63 PUSH4 0x70a08231 23FE 90 SWAP1 23FF 61 PUSH2 0x240c 2402 90 SWAP1 2403 30 ADDRESS 2404 90 SWAP1 2405 60 PUSH1 0x04 2407 01 ADD 2408 61 PUSH2 0x3725 240B 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @23DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @23E2 stack[0] = 0x00 // @23F8 stack[1] = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 // @23FE stack[2] = 0x70a08231 // @2402 stack[3] = 0x240c // @2404 stack[4] = address(this) // @2407 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x240C label_240C: // Incoming return from call to 0x3725 at 0x240B // Inputs[4] // { // @2411 memory[0x40:0x60] // @2413 stack[-1] // @2416 stack[-3] // @2418 address(stack[-3]).code.length // } 240C 5B JUMPDEST 240D 60 PUSH1 0x20 240F 60 PUSH1 0x40 2411 51 MLOAD 2412 80 DUP1 2413 83 DUP4 2414 03 SUB 2415 81 DUP2 2416 86 DUP7 2417 80 DUP1 2418 3B EXTCODESIZE 2419 15 ISZERO 241A 80 DUP1 241B 15 ISZERO 241C 61 PUSH2 0x2424 241F 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @240D stack[0] = 0x20 // @2411 stack[1] = memory[0x40:0x60] // @2414 stack[2] = stack[-1] - memory[0x40:0x60] // @2415 stack[3] = memory[0x40:0x60] // @2416 stack[4] = stack[-3] // @2419 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x2424, if !!address(stack[-3]).code.length label_2420: // Incoming jump from 0x241F, if not !!address(stack[-3]).code.length // Inputs[1] { @2423 memory[0x00:0x00] } 2420 60 PUSH1 0x00 2422 80 DUP1 2423 FD *REVERT // Stack delta = +0 // Outputs[1] { @2423 revert(memory[0x00:0x00]); } // Block terminates label_2424: // Incoming jump from 0x241F, if !!address(stack[-3]).code.length // Inputs[8] // { // @2426 msg.gas // @2427 memory[stack[-3]:stack[-3] + stack[-4]] // @2427 stack[-5] // @2427 stack[-3] // @2427 stack[-4] // @2427 stack[-2] // @2427 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2427 stack[-6] // } 2424 5B JUMPDEST 2425 50 POP 2426 5A GAS 2427 FA STATICCALL 2428 15 ISZERO 2429 80 DUP1 242A 15 ISZERO 242B 61 PUSH2 0x2438 242E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2427 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2428 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2438, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_242F: // Incoming jump from 0x242E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @242F returndata.length // @2433 returndata[0x00:0x00 + returndata.length] // @2434 returndata.length // @2437 memory[0x00:0x00 + returndata.length] // } 242F 3D RETURNDATASIZE 2430 60 PUSH1 0x00 2432 80 DUP1 2433 3E RETURNDATACOPY 2434 3D RETURNDATASIZE 2435 60 PUSH1 0x00 2437 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2433 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2437 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2438: // Incoming jump from 0x242E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @243F memory[0x40:0x60] // @2440 returndata.length // } 2438 5B JUMPDEST 2439 50 POP 243A 50 POP 243B 50 POP 243C 50 POP 243D 60 PUSH1 0x40 243F 51 MLOAD 2440 3D RETURNDATASIZE 2441 60 PUSH1 0x1f 2443 19 NOT 2444 60 PUSH1 0x1f 2446 82 DUP3 2447 01 ADD 2448 16 AND 2449 82 DUP3 244A 01 ADD 244B 80 DUP1 244C 60 PUSH1 0x40 244E 52 MSTORE 244F 50 POP 2450 81 DUP2 2451 01 ADD 2452 90 SWAP1 2453 61 PUSH2 0x245c 2456 91 SWAP2 2457 90 SWAP1 2458 61 PUSH2 0x366d 245B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @244E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2456 stack[-4] = 0x245c // @2457 stack[-2] = memory[0x40:0x60] // @2457 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x245C label_245C: // Incoming return from call to 0x366D at 0x245B // Inputs[3] // { // @245D stack[-2] // @245D stack[-1] // @2461 storage[0x0a] // } 245C 5B JUMPDEST 245D 90 SWAP1 245E 50 POP 245F 60 PUSH1 0x0a 2461 54 SLOAD 2462 81 DUP2 2463 11 GT 2464 15 ISZERO 2465 61 PUSH2 0x24ba 2468 57 *JUMPI // Stack delta = -1 // Outputs[1] { @245D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x24ba, if !(stack[-1] > storage[0x0a]) label_2469: // Incoming jump from 0x2468, if not !(stack[-1] > storage[0x0a]) // Inputs[3] // { // @246B storage[0x0a] // @246C stack[-1] // @246E stack[-8] // } 2469 60 PUSH1 0x0a 246B 54 SLOAD 246C 81 DUP2 246D 03 SUB 246E 97 SWAP8 246F 50 POP 2470 61 PUSH2 0x24b7 2473 73 PUSH20 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc 2488 73 PUSH20 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 249D 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 24B2 8B DUP12 24B3 61 PUSH2 0x0c91 24B6 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @246E stack[-8] = stack[-1] - storage[0x0a] // @2470 stack[0] = 0x24b7 // @2473 stack[1] = 0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc // @2488 stack[2] = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 // @249D stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @24B2 stack[4] = stack[-1] - storage[0x0a] // } // Block ends with call to 0x0c91, returns to 0x24B7 label_24B7: // Incoming return from call to 0x0C91 at 0x24B6 // Inputs[2] // { // @24B8 stack[-8] // @24B8 stack[-1] // } 24B7 5B JUMPDEST 24B8 96 SWAP7 24B9 50 POP // Stack delta = -1 // Outputs[1] { @24B8 stack[-8] = stack[-1] } // Block continues label_24BA: // Incoming jump from 0x24B9 // Incoming jump from 0x2468, if !(stack[-1] > storage[0x0a]) // Inputs[2] // { // @24BD memory[0x40:0x60] // @24EB address(this) // } 24BA 5B JUMPDEST 24BB 60 PUSH1 0x40 24BD 51 MLOAD 24BE 63 PUSH4 0x70a08231 24C3 60 PUSH1 0xe0 24C5 1B SHL 24C6 81 DUP2 24C7 52 MSTORE 24C8 60 PUSH1 0x00 24CA 90 SWAP1 24CB 73 PUSH20 0x6b175474e89094c44da98b954eedeac495271d0f 24E0 90 SWAP1 24E1 63 PUSH4 0x70a08231 24E6 90 SWAP1 24E7 61 PUSH2 0x24f4 24EA 90 SWAP1 24EB 30 ADDRESS 24EC 90 SWAP1 24ED 60 PUSH1 0x04 24EF 01 ADD 24F0 61 PUSH2 0x3725 24F3 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @24C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @24CA stack[0] = 0x00 // @24E0 stack[1] = 0x6b175474e89094c44da98b954eedeac495271d0f // @24E6 stack[2] = 0x70a08231 // @24EA stack[3] = 0x24f4 // @24EC stack[4] = address(this) // @24EF stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x24F4 label_24F4: // Incoming return from call to 0x3725 at 0x24F3 // Inputs[4] // { // @24F9 memory[0x40:0x60] // @24FB stack[-1] // @24FE stack[-3] // @2500 address(stack[-3]).code.length // } 24F4 5B JUMPDEST 24F5 60 PUSH1 0x20 24F7 60 PUSH1 0x40 24F9 51 MLOAD 24FA 80 DUP1 24FB 83 DUP4 24FC 03 SUB 24FD 81 DUP2 24FE 86 DUP7 24FF 80 DUP1 2500 3B EXTCODESIZE 2501 15 ISZERO 2502 80 DUP1 2503 15 ISZERO 2504 61 PUSH2 0x250c 2507 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @24F5 stack[0] = 0x20 // @24F9 stack[1] = memory[0x40:0x60] // @24FC stack[2] = stack[-1] - memory[0x40:0x60] // @24FD stack[3] = memory[0x40:0x60] // @24FE stack[4] = stack[-3] // @2501 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x250c, if !!address(stack[-3]).code.length label_2508: // Incoming jump from 0x2507, if not !!address(stack[-3]).code.length // Inputs[1] { @250B memory[0x00:0x00] } 2508 60 PUSH1 0x00 250A 80 DUP1 250B FD *REVERT // Stack delta = +0 // Outputs[1] { @250B revert(memory[0x00:0x00]); } // Block terminates label_250C: // Incoming jump from 0x2507, if !!address(stack[-3]).code.length // Inputs[8] // { // @250E msg.gas // @250F stack[-6] // @250F stack[-5] // @250F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @250F stack[-2] // @250F stack[-3] // @250F stack[-4] // @250F memory[stack[-3]:stack[-3] + stack[-4]] // } 250C 5B JUMPDEST 250D 50 POP 250E 5A GAS 250F FA STATICCALL 2510 15 ISZERO 2511 80 DUP1 2512 15 ISZERO 2513 61 PUSH2 0x2520 2516 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @250F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2510 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2520, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2517: // Incoming jump from 0x2516, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2517 returndata.length // @251B returndata[0x00:0x00 + returndata.length] // @251C returndata.length // @251F memory[0x00:0x00 + returndata.length] // } 2517 3D RETURNDATASIZE 2518 60 PUSH1 0x00 251A 80 DUP1 251B 3E RETURNDATACOPY 251C 3D RETURNDATASIZE 251D 60 PUSH1 0x00 251F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @251B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @251F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2520: // Incoming jump from 0x2516, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2527 memory[0x40:0x60] // @2528 returndata.length // } 2520 5B JUMPDEST 2521 50 POP 2522 50 POP 2523 50 POP 2524 50 POP 2525 60 PUSH1 0x40 2527 51 MLOAD 2528 3D RETURNDATASIZE 2529 60 PUSH1 0x1f 252B 19 NOT 252C 60 PUSH1 0x1f 252E 82 DUP3 252F 01 ADD 2530 16 AND 2531 82 DUP3 2532 01 ADD 2533 80 DUP1 2534 60 PUSH1 0x40 2536 52 MSTORE 2537 50 POP 2538 81 DUP2 2539 01 ADD 253A 90 SWAP1 253B 61 PUSH2 0x2544 253E 91 SWAP2 253F 90 SWAP1 2540 61 PUSH2 0x366d 2543 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2536 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @253E stack[-4] = 0x2544 // @253F stack[-2] = memory[0x40:0x60] // @253F stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x2544 label_2544: // Incoming return from call to 0x366D at 0x2543 // Inputs[3] // { // @2545 stack[-2] // @2545 stack[-1] // @2549 storage[0x0b] // } 2544 5B JUMPDEST 2545 90 SWAP1 2546 50 POP 2547 60 PUSH1 0x0b 2549 54 SLOAD 254A 81 DUP2 254B 11 GT 254C 15 ISZERO 254D 61 PUSH2 0x25a2 2550 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2545 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x25a2, if !(stack[-1] > storage[0x0b]) label_2551: // Incoming jump from 0x2550, if not !(stack[-1] > storage[0x0b]) // Inputs[3] // { // @2553 storage[0x0b] // @2554 stack[-1] // @2556 stack[-7] // } 2551 60 PUSH1 0x0b 2553 54 SLOAD 2554 81 DUP2 2555 03 SUB 2556 96 SWAP7 2557 50 POP 2558 61 PUSH2 0x259f 255B 73 PUSH20 0xa478c2975ab1ea89e8196811f51a7b7ade33eb11 2570 73 PUSH20 0x6b175474e89094c44da98b954eedeac495271d0f 2585 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 259A 8A DUP11 259B 61 PUSH2 0x0c91 259E 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2556 stack[-7] = stack[-1] - storage[0x0b] // @2558 stack[0] = 0x259f // @255B stack[1] = 0xa478c2975ab1ea89e8196811f51a7b7ade33eb11 // @2570 stack[2] = 0x6b175474e89094c44da98b954eedeac495271d0f // @2585 stack[3] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @259A stack[4] = stack[-1] - storage[0x0b] // } // Block ends with call to 0x0c91, returns to 0x259F label_259F: // Incoming return from call to 0x0C91 at 0x259E // Inputs[2] // { // @25A0 stack[-1] // @25A0 stack[-7] // } 259F 5B JUMPDEST 25A0 95 SWAP6 25A1 50 POP // Stack delta = -1 // Outputs[1] { @25A0 stack[-7] = stack[-1] } // Block continues label_25A2: // Incoming jump from 0x2550, if !(stack[-1] > storage[0x0b]) // Incoming jump from 0x25A1 // Inputs[2] // { // @25A5 memory[0x40:0x60] // @25D3 address(this) // } 25A2 5B JUMPDEST 25A3 60 PUSH1 0x40 25A5 51 MLOAD 25A6 63 PUSH4 0x70a08231 25AB 60 PUSH1 0xe0 25AD 1B SHL 25AE 81 DUP2 25AF 52 MSTORE 25B0 60 PUSH1 0x00 25B2 90 SWAP1 25B3 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 25C8 90 SWAP1 25C9 63 PUSH4 0x70a08231 25CE 90 SWAP1 25CF 61 PUSH2 0x25dc 25D2 90 SWAP1 25D3 30 ADDRESS 25D4 90 SWAP1 25D5 60 PUSH1 0x04 25D7 01 ADD 25D8 61 PUSH2 0x3725 25DB 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @25AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @25B2 stack[0] = 0x00 // @25C8 stack[1] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @25CE stack[2] = 0x70a08231 // @25D2 stack[3] = 0x25dc // @25D4 stack[4] = address(this) // @25D7 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3725, returns to 0x25DC label_25DC: // Incoming return from call to 0x3725 at 0x25DB // Inputs[4] // { // @25E1 memory[0x40:0x60] // @25E3 stack[-1] // @25E6 stack[-3] // @25E8 address(stack[-3]).code.length // } 25DC 5B JUMPDEST 25DD 60 PUSH1 0x20 25DF 60 PUSH1 0x40 25E1 51 MLOAD 25E2 80 DUP1 25E3 83 DUP4 25E4 03 SUB 25E5 81 DUP2 25E6 86 DUP7 25E7 80 DUP1 25E8 3B EXTCODESIZE 25E9 15 ISZERO 25EA 80 DUP1 25EB 15 ISZERO 25EC 61 PUSH2 0x25f4 25EF 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @25DD stack[0] = 0x20 // @25E1 stack[1] = memory[0x40:0x60] // @25E4 stack[2] = stack[-1] - memory[0x40:0x60] // @25E5 stack[3] = memory[0x40:0x60] // @25E6 stack[4] = stack[-3] // @25E9 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x25f4, if !!address(stack[-3]).code.length label_25F0: // Incoming jump from 0x25EF, if not !!address(stack[-3]).code.length // Inputs[1] { @25F3 memory[0x00:0x00] } 25F0 60 PUSH1 0x00 25F2 80 DUP1 25F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F3 revert(memory[0x00:0x00]); } // Block terminates label_25F4: // Incoming jump from 0x25EF, if !!address(stack[-3]).code.length // Inputs[8] // { // @25F6 msg.gas // @25F7 stack[-3] // @25F7 stack[-4] // @25F7 stack[-2] // @25F7 stack[-6] // @25F7 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25F7 memory[stack[-3]:stack[-3] + stack[-4]] // @25F7 stack[-5] // } 25F4 5B JUMPDEST 25F5 50 POP 25F6 5A GAS 25F7 FA STATICCALL 25F8 15 ISZERO 25F9 80 DUP1 25FA 15 ISZERO 25FB 61 PUSH2 0x2608 25FE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @25F7 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25F8 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2608, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_25FF: // Incoming jump from 0x25FE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @25FF returndata.length // @2603 returndata[0x00:0x00 + returndata.length] // @2604 returndata.length // @2607 memory[0x00:0x00 + returndata.length] // } 25FF 3D RETURNDATASIZE 2600 60 PUSH1 0x00 2602 80 DUP1 2603 3E RETURNDATACOPY 2604 3D RETURNDATASIZE 2605 60 PUSH1 0x00 2607 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2603 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2607 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2608: // Incoming jump from 0x25FE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @260F memory[0x40:0x60] // @2610 returndata.length // } 2608 5B JUMPDEST 2609 50 POP 260A 50 POP 260B 50 POP 260C 50 POP 260D 60 PUSH1 0x40 260F 51 MLOAD 2610 3D RETURNDATASIZE 2611 60 PUSH1 0x1f 2613 19 NOT 2614 60 PUSH1 0x1f 2616 82 DUP3 2617 01 ADD 2618 16 AND 2619 82 DUP3 261A 01 ADD 261B 80 DUP1 261C 60 PUSH1 0x40 261E 52 MSTORE 261F 50 POP 2620 81 DUP2 2621 01 ADD 2622 90 SWAP1 2623 61 PUSH2 0x262c 2626 91 SWAP2 2627 90 SWAP1 2628 61 PUSH2 0x366d 262B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @261E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2626 stack[-4] = 0x262c // @2627 stack[-2] = memory[0x40:0x60] // @2627 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x366d, returns to 0x262C label_262C: // Incoming return from call to 0x366D at 0x262B // Inputs[5] // { // @262F storage[0x08] // @2630 stack[-1] // @2631 stack[-2] // @2633 address(this).balance // @2633 address(this) // } 262C 5B JUMPDEST 262D 60 PUSH1 0x08 262F 54 SLOAD 2630 90 SWAP1 2631 91 SWAP2 2632 50 POP 2633 47 SELFBALANCE 2634 90 SWAP1 2635 81 DUP2 2636 83 DUP4 2637 01 ADD 2638 11 GT 2639 15 ISZERO 263A 61 PUSH2 0x2647 263D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2631 stack[-2] = stack[-1] // @2634 stack[-1] = address(this).balance // } // Block ends with conditional jump to 0x2647, if !(stack[-1] + address(this).balance > storage[0x08]) label_263E: // Incoming jump from 0x263D, if not !(stack[-1] + address(this).balance > storage[0x08]) // Inputs[12] // { // @2640 storage[0x08] // @2641 stack[-2] // @2642 stack[-1] // @2645 stack[-7] // @2649 stack[-8] // @264A stack[-10] // @264B stack[-12] // @264F stack[-6] // @2658 stack[-9] // @265A stack[-11] // @265C stack[-13] // @265D stack[-14] // } 263E 60 PUSH1 0x08 2640 54 SLOAD 2641 82 DUP3 2642 82 DUP3 2643 01 ADD 2644 03 SUB 2645 96 SWAP7 2646 50 POP 2647 5B JUMPDEST 2648 86 DUP7 2649 88 DUP9 264A 8B DUP12 264B 8E DUP15 264C 01 ADD 264D 01 ADD 264E 01 ADD 264F 95 SWAP6 2650 50 POP 2651 50 POP 2652 50 POP 2653 50 POP 2654 50 POP 2655 50 POP 2656 90 SWAP1 2657 91 SWAP2 2658 92 SWAP3 2659 93 SWAP4 265A 94 SWAP5 265B 95 SWAP6 265C 96 SWAP7 265D 97 SWAP8 265E 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @2656 stack[-7] = stack[-12] + stack[-10] + stack[-8] + ((stack[-1] + stack[-2]) - storage[0x08]) // @2657 stack[-8] = (stack[-1] + stack[-2]) - storage[0x08] // @2658 stack[-9] = stack[-8] // @2659 stack[-10] = stack[-9] // @265A stack[-11] = stack[-10] // @265B stack[-12] = stack[-11] // @265C stack[-13] = stack[-12] // @265D stack[-14] = stack[-13] // } // Block ends with unconditional jump to stack[-14] label_265F: // Incoming jump from 0x07FB 265F 5B JUMPDEST 2660 61 PUSH2 0x2667 2663 61 PUSH2 0x1a26 2666 56 *JUMP // Stack delta = +1 // Outputs[1] { @2660 stack[0] = 0x2667 } // Block ends with call to 0x1a26, returns to 0x2667 label_2667: // Incoming return from call to 0x1A26 at 0x2666 // Inputs[1] { @266B stack[-1] } 2667 5B JUMPDEST 2668 61 PUSH2 0x2683 266B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2683, if stack[-1] label_266C: // Incoming jump from 0x266B, if not stack[-1] // Inputs[1] { @266E memory[0x40:0x60] } 266C 60 PUSH1 0x40 266E 51 MLOAD 266F 62 PUSH3 0x461bcd 2673 60 PUSH1 0xe5 2675 1B SHL 2676 81 DUP2 2677 52 MSTORE 2678 60 PUSH1 0x04 267A 01 ADD 267B 61 PUSH2 0x0840 267E 90 SWAP1 267F 61 PUSH2 0x3a86 2682 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2677 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @267E stack[0] = 0x0840 // @267E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_2683: // Incoming jump from 0x266B, if stack[-1] // Inputs[3] // { // @2687 storage[0x04] // @268C stack[-1] // @2695 stack[-2] // } 2683 5B JUMPDEST 2684 60 PUSH1 0x04 2686 80 DUP1 2687 54 SLOAD 2688 60 PUSH1 0xff 268A 19 NOT 268B 16 AND 268C 91 SWAP2 268D 15 ISZERO 268E 15 ISZERO 268F 91 SWAP2 2690 90 SWAP1 2691 91 SWAP2 2692 17 OR 2693 90 SWAP1 2694 55 SSTORE 2695 56 *JUMP // Stack delta = -2 // Outputs[1] { @2694 storage[0x04] = !!stack[-1] | (~0xff & storage[0x04]) } // Block ends with unconditional jump to stack[-2] label_2696: // Incoming jump from 0x081B 2696 5B JUMPDEST 2697 61 PUSH2 0x269e 269A 61 PUSH2 0x1a26 269D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2697 stack[0] = 0x269e } // Block ends with call to 0x1a26, returns to 0x269E label_269E: // Incoming return from call to 0x1A26 at 0x269D // Inputs[1] { @26A2 stack[-1] } 269E 5B JUMPDEST 269F 61 PUSH2 0x26ba 26A2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x26ba, if stack[-1] label_26A3: // Incoming jump from 0x26A2, if not stack[-1] // Inputs[1] { @26A5 memory[0x40:0x60] } 26A3 60 PUSH1 0x40 26A5 51 MLOAD 26A6 62 PUSH3 0x461bcd 26AA 60 PUSH1 0xe5 26AC 1B SHL 26AD 81 DUP2 26AE 52 MSTORE 26AF 60 PUSH1 0x04 26B1 01 ADD 26B2 61 PUSH2 0x0840 26B5 90 SWAP1 26B6 61 PUSH2 0x3a86 26B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @26B5 stack[0] = 0x0840 // @26B5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a86, returns to 0x0840 label_26BA: // Incoming jump from 0x26A2, if stack[-1] // Inputs[1] { @26BE stack[-1] } 26BA 5B JUMPDEST 26BB 61 PUSH2 0x0b67 26BE 81 DUP2 26BF 61 PUSH2 0x2f29 26C2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @26BB stack[0] = 0x0b67 // @26BE stack[1] = stack[-1] // } // Block ends with call to 0x2f29, returns to 0x0B67 label_26C3: // Incoming call from 0x2A02, returns to 0x2A03 // Incoming call from 0x0CA0, returns to 0x0CA1 // Incoming call from 0x1B9C, returns to 0x1B9D // Inputs[2] // { // @26CC stack[-2] // @26CD stack[-1] // } 26C3 5B JUMPDEST 26C4 60 PUSH1 0x00 26C6 80 DUP1 26C7 60 PUSH1 0x00 26C9 61 PUSH2 0x26d2 26CC 85 DUP6 26CD 85 DUP6 26CE 61 PUSH2 0x2faa 26D1 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @26C4 stack[0] = 0x00 // @26C6 stack[1] = 0x00 // @26C7 stack[2] = 0x00 // @26C9 stack[3] = 0x26d2 // @26CC stack[4] = stack[-2] // @26CD stack[5] = stack[-1] // } // Block ends with call to 0x2faa, returns to 0x26D2 label_26D2: // Incoming return from call to 0x2FAA at 0x26D1 // Inputs[6] // { // @26D4 stack[-3] // @26D4 stack[-2] // @26D9 stack[-8] // @26EA memory[0x40:0x60] // @26FE memory[0x40:0x60] // @2705 address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } 26D2 5B JUMPDEST 26D3 50 POP 26D4 90 SWAP1 26D5 50 POP 26D6 60 PUSH1 0x00 26D8 80 DUP1 26D9 87 DUP8 26DA 60 PUSH1 0x01 26DC 60 PUSH1 0x01 26DE 60 PUSH1 0xa0 26E0 1B SHL 26E1 03 SUB 26E2 16 AND 26E3 63 PUSH4 0x0902f1ac 26E8 60 PUSH1 0x40 26EA 51 MLOAD 26EB 81 DUP2 26EC 63 PUSH4 0xffffffff 26F1 16 AND 26F2 60 PUSH1 0xe0 26F4 1B SHL 26F5 81 DUP2 26F6 52 MSTORE 26F7 60 PUSH1 0x04 26F9 01 ADD 26FA 60 PUSH1 0x60 26FC 60 PUSH1 0x40 26FE 51 MLOAD 26FF 80 DUP1 2700 83 DUP4 2701 03 SUB 2702 81 DUP2 2703 86 DUP7 2704 80 DUP1 2705 3B EXTCODESIZE 2706 15 ISZERO 2707 80 DUP1 2708 15 ISZERO 2709 61 PUSH2 0x2711 270C 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @26D4 stack[-3] = stack[-2] // @26D6 stack[-2] = 0x00 // @26D8 stack[-1] = 0x00 // @26E2 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-8] // @26E3 stack[1] = 0x0902f1ac // @26F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @26F9 stack[2] = 0x04 + memory[0x40:0x60] // @26FA stack[3] = 0x60 // @26FE stack[4] = memory[0x40:0x60] // @2701 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2702 stack[6] = memory[0x40:0x60] // @2703 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-8] // @2706 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } // Block ends with conditional jump to 0x2711, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length label_270D: // Incoming jump from 0x270C, if not !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[1] { @2710 memory[0x00:0x00] } 270D 60 PUSH1 0x00 270F 80 DUP1 2710 FD *REVERT // Stack delta = +0 // Outputs[1] { @2710 revert(memory[0x00:0x00]); } // Block terminates label_2711: // Incoming jump from 0x270C, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[8] // { // @2713 msg.gas // @2714 stack[-2] // @2714 stack[-6] // @2714 memory[stack[-3]:stack[-3] + stack[-4]] // @2714 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2714 stack[-5] // @2714 stack[-3] // @2714 stack[-4] // } 2711 5B JUMPDEST 2712 50 POP 2713 5A GAS 2714 FA STATICCALL 2715 15 ISZERO 2716 80 DUP1 2717 15 ISZERO 2718 61 PUSH2 0x2725 271B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2714 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2715 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2725, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_271C: // Incoming jump from 0x271B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @271C returndata.length // @2720 returndata[0x00:0x00 + returndata.length] // @2721 returndata.length // @2724 memory[0x00:0x00 + returndata.length] // } 271C 3D RETURNDATASIZE 271D 60 PUSH1 0x00 271F 80 DUP1 2720 3E RETURNDATACOPY 2721 3D RETURNDATASIZE 2722 60 PUSH1 0x00 2724 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2720 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2724 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2725: // Incoming jump from 0x271B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @272C memory[0x40:0x60] // @272D returndata.length // } 2725 5B JUMPDEST 2726 50 POP 2727 50 POP 2728 50 POP 2729 50 POP 272A 60 PUSH1 0x40 272C 51 MLOAD 272D 3D RETURNDATASIZE 272E 60 PUSH1 0x1f 2730 19 NOT 2731 60 PUSH1 0x1f 2733 82 DUP3 2734 01 ADD 2735 16 AND 2736 82 DUP3 2737 01 ADD 2738 80 DUP1 2739 60 PUSH1 0x40 273B 52 MSTORE 273C 50 POP 273D 81 DUP2 273E 01 ADD 273F 90 SWAP1 2740 61 PUSH2 0x2749 2743 91 SWAP2 2744 90 SWAP1 2745 61 PUSH2 0x360c 2748 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @273B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2743 stack[-4] = 0x2749 // @2744 stack[-2] = memory[0x40:0x60] // @2744 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x360c, returns to 0x2749 label_2749: // Incoming return from call to 0x360C at 0x2748 // Inputs[6] // { // @2753 stack[-2] // @2754 stack[-4] // @275E stack[-3] // @275F stack[-5] // @2761 stack[-6] // @276B stack[-10] // } 2749 5B JUMPDEST 274A 50 POP 274B 60 PUSH1 0x01 274D 60 PUSH1 0x01 274F 60 PUSH1 0x70 2751 1B SHL 2752 03 SUB 2753 16 AND 2754 91 SWAP2 2755 50 POP 2756 60 PUSH1 0x01 2758 60 PUSH1 0x01 275A 60 PUSH1 0x70 275C 1B SHL 275D 03 SUB 275E 16 AND 275F 91 SWAP2 2760 50 POP 2761 82 DUP3 2762 60 PUSH1 0x01 2764 60 PUSH1 0x01 2766 60 PUSH1 0xa0 2768 1B SHL 2769 03 SUB 276A 16 AND 276B 87 DUP8 276C 60 PUSH1 0x01 276E 60 PUSH1 0x01 2770 60 PUSH1 0xa0 2772 1B SHL 2773 03 SUB 2774 16 AND 2775 14 EQ 2776 61 PUSH2 0x2780 2779 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @2754 stack[-4] = (0x01 << 0x70) - 0x01 & stack[-2] // @275F stack[-5] = (0x01 << 0x70) - 0x01 & stack[-3] // } // Block ends with conditional jump to 0x2780, if (0x01 << 0xa0) - 0x01 & stack[-10] == (0x01 << 0xa0) - 0x01 & stack[-6] label_277A: // Incoming jump from 0x2779, if not (0x01 << 0xa0) - 0x01 & stack[-10] == (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[2] // { // @277A stack[-1] // @277B stack[-2] // } 277A 80 DUP1 277B 82 DUP3 277C 61 PUSH2 0x2783 277F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @277A stack[0] = stack[-1] // @277B stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x2783 label_2780: // Incoming jump from 0x2779, if (0x01 << 0xa0) - 0x01 & stack[-10] == (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[5] // { // @2781 stack[-2] // @2782 stack[-1] // @2785 stack[-9] // @2787 stack[-8] // @2789 stack[-7] // } 2780 5B JUMPDEST 2781 81 DUP2 2782 81 DUP2 2783 5B JUMPDEST 2784 90 SWAP1 2785 99 SWAP10 2786 90 SWAP1 2787 98 SWAP9 2788 50 POP 2789 96 SWAP7 278A 50 POP 278B 50 POP 278C 50 POP 278D 50 POP 278E 50 POP 278F 50 POP 2790 50 POP 2791 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @2785 stack[-9] = stack[-2] // @2787 stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_2792: // Incoming call from 0x2A11, returns to 0x2A12 // Incoming call from 0x0CAF, returns to 0x0CB0 // Inputs[1] { @2796 stack[-3] } 2792 5B JUMPDEST 2793 60 PUSH1 0x00 2795 80 DUP1 2796 84 DUP5 2797 11 GT 2798 61 PUSH2 0x27b3 279B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2793 stack[0] = 0x00 } // Block ends with conditional jump to 0x27b3, if stack[-3] > 0x00 label_279C: // Incoming jump from 0x279B, if not stack[-3] > 0x00 // Inputs[1] { @279E memory[0x40:0x60] } 279C 60 PUSH1 0x40 279E 51 MLOAD 279F 62 PUSH3 0x461bcd 27A3 60 PUSH1 0xe5 27A5 1B SHL 27A6 81 DUP2 27A7 52 MSTORE 27A8 60 PUSH1 0x04 27AA 01 ADD 27AB 61 PUSH2 0x0840 27AE 90 SWAP1 27AF 61 PUSH2 0x3bed 27B2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @27A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @27AE stack[0] = 0x0840 // @27AE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3bed, returns to 0x0840 label_27B3: // Incoming jump from 0x279B, if stack[-3] > 0x00 // Inputs[1] { @27B6 stack[-3] } 27B3 5B JUMPDEST 27B4 60 PUSH1 0x00 27B6 83 DUP4 27B7 11 GT 27B8 80 DUP1 27B9 15 ISZERO 27BA 61 PUSH2 0x27c3 27BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27B7 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x27c3, if !(stack[-3] > 0x00) label_27BE: // Incoming jump from 0x27BD, if not !(stack[-3] > 0x00) // Inputs[1] { @27C1 stack[-3] } 27BE 50 POP 27BF 60 PUSH1 0x00 27C1 82 DUP3 27C2 11 GT 27C3 5B JUMPDEST 27C4 61 PUSH2 0x27df 27C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x27df, if stack[-3] > 0x00 label_27C8: // Incoming jump from 0x27C7, if not stack[-1] // Incoming jump from 0x27C7, if not stack[-3] > 0x00 // Inputs[1] { @27CA memory[0x40:0x60] } 27C8 60 PUSH1 0x40 27CA 51 MLOAD 27CB 62 PUSH3 0x461bcd 27CF 60 PUSH1 0xe5 27D1 1B SHL 27D2 81 DUP2 27D3 52 MSTORE 27D4 60 PUSH1 0x04 27D6 01 ADD 27D7 61 PUSH2 0x0840 27DA 90 SWAP1 27DB 61 PUSH2 0x39fd 27DE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @27D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @27DA stack[0] = 0x0840 // @27DA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x39fd, returns to 0x0840 label_27DF: // Incoming jump from 0x27C7, if stack[-1] // Incoming jump from 0x27C7, if stack[-3] > 0x00 // Inputs[1] { @27E5 stack[-4] } 27DF 5B JUMPDEST 27E0 60 PUSH1 0x00 27E2 61 PUSH2 0x27f3 27E5 85 DUP6 27E6 61 PUSH2 0x03e5 27E9 63 PUSH4 0xffffffff 27EE 61 PUSH2 0x3034 27F1 16 AND 27F2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @27E0 stack[0] = 0x00 // @27E2 stack[1] = 0x27f3 // @27E5 stack[2] = stack[-4] // @27E6 stack[3] = 0x03e5 // } // Block ends with call to 0x3034 & 0xffffffff, returns to 0x27F3 label_27F3: // Incoming return from call to 0x3034 at 0x27F2 // Inputs[3] // { // @27F4 stack[-2] // @27F4 stack[-1] // @27FC stack[-4] // } 27F3 5B JUMPDEST 27F4 90 SWAP1 27F5 50 POP 27F6 60 PUSH1 0x00 27F8 61 PUSH2 0x2807 27FB 82 DUP3 27FC 85 DUP6 27FD 63 PUSH4 0xffffffff 2802 61 PUSH2 0x3034 2805 16 AND 2806 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @27F4 stack[-2] = stack[-1] // @27F6 stack[-1] = 0x00 // @27F8 stack[0] = 0x2807 // @27FB stack[1] = stack[-1] // @27FC stack[2] = stack[-4] // } // Block ends with call to 0x3034 & 0xffffffff, returns to 0x2807 label_2807: // Incoming return from call to 0x3034 at 0x2806 // Inputs[4] // { // @2808 stack[-2] // @2808 stack[-1] // @280F stack[-3] // @2813 stack[-6] // } 2807 5B JUMPDEST 2808 90 SWAP1 2809 50 POP 280A 60 PUSH1 0x00 280C 61 PUSH2 0x282d 280F 83 DUP4 2810 61 PUSH2 0x2821 2813 88 DUP9 2814 61 PUSH2 0x03e8 2817 63 PUSH4 0xffffffff 281C 61 PUSH2 0x3034 281F 16 AND 2820 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2808 stack[-2] = stack[-1] // @280A stack[-1] = 0x00 // @280C stack[0] = 0x282d // @280F stack[1] = stack[-3] // @2810 stack[2] = 0x2821 // @2813 stack[3] = stack[-6] // @2814 stack[4] = 0x03e8 // } // Block ends with call to 0x3034 & 0xffffffff, returns to 0x2821 label_2821: // Incoming return from call to 0x3034 at 0x2820 // Inputs[2] // { // @2822 stack[-2] // @2822 stack[-1] // } 2821 5B JUMPDEST 2822 90 SWAP1 2823 63 PUSH4 0xffffffff 2828 61 PUSH2 0x3075 282B 16 AND 282C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2822 stack[-1] = stack[-2] // @2822 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x3075 & 0xffffffff label_282D: // Incoming return from call to 0x2821 at 0x2820 // Inputs[3] // { // @282E stack[-1] // @282E stack[-2] // @2831 stack[-3] // } 282D 5B JUMPDEST 282E 90 SWAP1 282F 50 POP 2830 80 DUP1 2831 82 DUP3 2832 81 DUP2 2833 61 PUSH2 0x2838 2836 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @282E stack[-2] = stack[-1] // @2830 stack[-1] = stack[-1] // @2831 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x2838, if stack[-1] label_2837: // Incoming jump from 0x2836, if not stack[-1] 2837 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2837 assert(); } // Block terminates label_2838: // Incoming jump from 0x2836, if stack[-1] // Inputs[4] // { // @2839 stack[-2] // @2839 stack[-1] // @283A stack[-10] // @283B stack[-9] // } 2838 5B JUMPDEST 2839 04 DIV 283A 97 SWAP8 283B 96 SWAP7 283C 50 POP 283D 50 POP 283E 50 POP 283F 50 POP 2840 50 POP 2841 50 POP 2842 50 POP 2843 56 *JUMP // Stack delta = -9 // Outputs[1] { @283A stack[-10] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-10] label_2844: // Incoming jump from 0x20ED // Incoming jump from 0x0E9E // Inputs[5] // { // @2847 storage[0x0e] // @284A storage[0x10] // @284D storage[0x0f] // @2850 storage[0x12] // @286C address(this) // } 2844 5B JUMPDEST 2845 60 PUSH1 0x0e 2847 54 SLOAD 2848 60 PUSH1 0x10 284A 54 SLOAD 284B 60 PUSH1 0x0f 284D 54 SLOAD 284E 60 PUSH1 0x12 2850 54 SLOAD 2851 60 PUSH1 0x00 2853 93 SWAP4 2854 61 PUSH2 0x2871 2857 93 SWAP4 2858 60 PUSH1 0x01 285A 60 PUSH1 0x01 285C 60 PUSH1 0xa0 285E 1B SHL 285F 03 SUB 2860 91 SWAP2 2861 82 DUP3 2862 16 AND 2863 93 SWAP4 2864 90 SWAP1 2865 82 DUP3 2866 16 AND 2867 92 SWAP3 2868 91 SWAP2 2869 16 AND 286A 90 SWAP1 286B 85 DUP6 286C 30 ADDRESS 286D 61 PUSH2 0x29f3 2870 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @2853 stack[0] = 0x00 // @2857 stack[1] = 0x2871 // @2863 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x0e] // @2867 stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x10] // @286A stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @286A stack[5] = storage[0x12] // @286B stack[6] = 0x00 // @286C stack[7] = address(this) // } // Block ends with unconditional jump to 0x29f3 2871 5B JUMPDEST 2872 90 SWAP1 2873 50 POP 2874 90 SWAP1 2875 56 *JUMP label_2876: // Incoming call from 0x100F, returns to 0x1010 // Inputs[2] // { // @287E msg.value // @2880 stack[-1] // } 2876 5B JUMPDEST 2877 65 PUSH6 0x5af3107a4000 287E 34 CALLVALUE 287F 02 MUL 2880 90 SWAP1 2881 56 *JUMP // Stack delta = +0 // Outputs[1] { @2880 stack[-1] = msg.value * 0x5af3107a4000 } // Block ends with unconditional jump to stack[-1] label_2882: // Incoming call from 0x1088, returns to 0x0A97 // Inputs[1] { @2888 stack[-2] } 2882 5B JUMPDEST 2883 60 PUSH1 0x00 2885 61 PUSH2 0x288d 2888 83 DUP4 2889 61 PUSH2 0x2b39 288C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2883 stack[0] = 0x00 // @2885 stack[1] = 0x288d // @2888 stack[2] = stack[-2] // } // Block ends with call to 0x2b39, returns to 0x288D label_288D: // Incoming return from call to 0x2B39 at 0x288C // Inputs[1] { @288E stack[-1] } 288D 5B JUMPDEST 288E 15 ISZERO 288F 61 PUSH2 0x2900 2892 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2900, if !stack[-1] label_2893: // Incoming jump from 0x2892, if not !stack[-1] // Inputs[5] // { // @2898 storage[0x02] // @28B7 stack[-2] // @28BA memory[0x40:0x60] // @28CE memory[0x40:0x60] // @28D6 address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00).code.length // } 2893 60 PUSH1 0x02 2895 60 PUSH1 0x00 2897 90 SWAP1 2898 54 SLOAD 2899 90 SWAP1 289A 61 PUSH2 0x0100 289D 0A EXP 289E 90 SWAP1 289F 04 DIV 28A0 60 PUSH1 0x01 28A2 60 PUSH1 0x01 28A4 60 PUSH1 0xa0 28A6 1B SHL 28A7 03 SUB 28A8 16 AND 28A9 60 PUSH1 0x01 28AB 60 PUSH1 0x01 28AD 60 PUSH1 0xa0 28AF 1B SHL 28B0 03 SUB 28B1 16 AND 28B2 63 PUSH4 0xd0e30db0 28B7 83 DUP4 28B8 60 PUSH1 0x40 28BA 51 MLOAD 28BB 82 DUP3 28BC 63 PUSH4 0xffffffff 28C1 16 AND 28C2 60 PUSH1 0xe0 28C4 1B SHL 28C5 81 DUP2 28C6 52 MSTORE 28C7 60 PUSH1 0x04 28C9 01 ADD 28CA 60 PUSH1 0x00 28CC 60 PUSH1 0x40 28CE 51 MLOAD 28CF 80 DUP1 28D0 83 DUP4 28D1 03 SUB 28D2 81 DUP2 28D3 85 DUP6 28D4 88 DUP9 28D5 80 DUP1 28D6 3B EXTCODESIZE 28D7 15 ISZERO 28D8 80 DUP1 28D9 15 ISZERO 28DA 61 PUSH2 0x28e2 28DD 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @28B1 stack[0] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00 // @28B2 stack[1] = 0xd0e30db0 // @28B7 stack[2] = stack[-2] // @28C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @28C9 stack[3] = 0x04 + memory[0x40:0x60] // @28CA stack[4] = 0x00 // @28CE stack[5] = memory[0x40:0x60] // @28D1 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @28D2 stack[7] = memory[0x40:0x60] // @28D3 stack[8] = stack[-2] // @28D4 stack[9] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00 // @28D7 stack[10] = !address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x28e2, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00).code.length label_28DE: // Incoming jump from 0x28DD, if not !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @28E1 memory[0x00:0x00] } 28DE 60 PUSH1 0x00 28E0 80 DUP1 28E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @28E1 revert(memory[0x00:0x00]); } // Block terminates label_28E2: // Incoming jump from 0x28DD, if !!address((0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @28E4 msg.gas // @28E5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @28E5 stack[-7] // @28E5 stack[-2] // @28E5 stack[-5] // @28E5 stack[-6] // @28E5 stack[-3] // @28E5 stack[-4] // @28E5 memory[stack[-4]:stack[-4] + stack[-5]] // } 28E2 5B JUMPDEST 28E3 50 POP 28E4 5A GAS 28E5 F1 CALL 28E6 15 ISZERO 28E7 80 DUP1 28E8 15 ISZERO 28E9 61 PUSH2 0x28f6 28EC 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @28E5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @28E6 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x28f6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_28ED: // Incoming jump from 0x28EC, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @28ED returndata.length // @28F1 returndata[0x00:0x00 + returndata.length] // @28F2 returndata.length // @28F5 memory[0x00:0x00 + returndata.length] // } 28ED 3D RETURNDATASIZE 28EE 60 PUSH1 0x00 28F0 80 DUP1 28F1 3E RETURNDATACOPY 28F2 3D RETURNDATASIZE 28F3 60 PUSH1 0x00 28F5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @28F1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @28F5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_28F6: // Incoming jump from 0x28EC, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 28F6 5B JUMPDEST 28F7 50 POP 28F8 50 POP 28F9 50 POP 28FA 50 POP 28FB 50 POP 28FC 61 PUSH2 0x1cb4 28FF 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x1cb4 label_2900: // Incoming jump from 0x2892, if !stack[-1] // Inputs[4] // { // @2904 stack[-3] // @2905 msg.sender // @2906 address(this) // @2907 stack[-2] // } 2900 5B JUMPDEST 2901 61 PUSH2 0x1cb4 2904 83 DUP4 2905 33 CALLER 2906 30 ADDRESS 2907 85 DUP6 2908 61 PUSH2 0x309a 290B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2901 stack[0] = 0x1cb4 // @2904 stack[1] = stack[-3] // @2905 stack[2] = msg.sender // @2906 stack[3] = address(this) // @2907 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x309a label_290C: // Incoming call from 0x151D, returns to 0x11AF // Incoming call from 0x163F, returns to 0x11AF // Incoming call from 0x2A85, returns to 0x2A86 // Incoming call from 0x1ABC, returns to 0x1ABD // Incoming call from 0x1EF4, returns to 0x1078 // Incoming call from 0x11AE, returns to 0x11AF // Incoming call from 0x1EF4, returns to 0x1078 // Incoming call from 0x2A85, returns to 0x2A86 // Inputs[4] // { // @2911 stack[-3] // @2920 stack[-2] // @2921 stack[-1] // @2924 memory[0x40:0x60] // } 290C 5B JUMPDEST 290D 60 PUSH1 0x00 290F 60 PUSH1 0x60 2911 84 DUP5 2912 60 PUSH1 0x01 2914 60 PUSH1 0x01 2916 60 PUSH1 0xa0 2918 1B SHL 2919 03 SUB 291A 16 AND 291B 63 PUSH4 0xa9059cbb 2920 85 DUP6 2921 85 DUP6 2922 60 PUSH1 0x40 2924 51 MLOAD 2925 60 PUSH1 0x24 2927 01 ADD 2928 61 PUSH2 0x2932 292B 92 SWAP3 292C 91 SWAP2 292D 90 SWAP1 292E 61 PUSH2 0x37b0 2931 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @290D stack[0] = 0x00 // @290F stack[1] = 0x60 // @291A stack[2] = (0x01 << 0xa0) - 0x01 & stack[-3] // @291B stack[3] = 0xa9059cbb // @292B stack[4] = 0x2932 // @292C stack[5] = stack[-2] // @292D stack[6] = stack[-1] // @292D stack[7] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x37b0, returns to 0x2932 label_2932: // Incoming return from call to 0x37B0 at 0x2931 // Inputs[5] // { // @2935 memory[0x40:0x60] // @2939 stack[-1] // @2942 stack[-2] // @294B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2961 memory[0x40:0x60] // } 2932 5B JUMPDEST 2933 60 PUSH1 0x40 2935 51 MLOAD 2936 60 PUSH1 0x20 2938 81 DUP2 2939 83 DUP4 293A 03 SUB 293B 03 SUB 293C 81 DUP2 293D 52 MSTORE 293E 90 SWAP1 293F 60 PUSH1 0x40 2941 52 MSTORE 2942 90 SWAP1 2943 60 PUSH1 0xe0 2945 1B SHL 2946 60 PUSH1 0x20 2948 82 DUP3 2949 01 ADD 294A 80 DUP1 294B 51 MLOAD 294C 60 PUSH1 0x01 294E 60 PUSH1 0x01 2950 60 PUSH1 0xe0 2952 1B SHL 2953 03 SUB 2954 83 DUP4 2955 81 DUP2 2956 83 DUP4 2957 16 AND 2958 17 OR 2959 83 DUP4 295A 52 MSTORE 295B 50 POP 295C 50 POP 295D 50 POP 295E 50 POP 295F 60 PUSH1 0x40 2961 51 MLOAD 2962 61 PUSH2 0x296b 2965 91 SWAP2 2966 90 SWAP1 2967 61 PUSH2 0x3706 296A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @293D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @2941 memory[0x40:0x60] = stack[-1] // @295A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & (0x01 << 0xe0) - 0x01) | (stack[-2] << 0xe0) // @2965 stack[-2] = 0x296b // @2966 stack[0] = memory[0x40:0x60] // @2966 stack[-1] = memory[0x40:0x60] // } // Block ends with call to 0x3706, returns to 0x296B label_296B: // Incoming return from call to 0x3706 at 0x296A // Inputs[7] // { // @2970 memory[0x40:0x60] // @2972 stack[-1] // @2977 stack[-2] // @2978 msg.gas // @2979 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @2979 address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @297D returndata.length // } 296B 5B JUMPDEST 296C 60 PUSH1 0x00 296E 60 PUSH1 0x40 2970 51 MLOAD 2971 80 DUP1 2972 83 DUP4 2973 03 SUB 2974 81 DUP2 2975 60 PUSH1 0x00 2977 86 DUP7 2978 5A GAS 2979 F1 CALL 297A 91 SWAP2 297B 50 POP 297C 50 POP 297D 3D RETURNDATASIZE 297E 80 DUP1 297F 60 PUSH1 0x00 2981 81 DUP2 2982 14 EQ 2983 61 PUSH2 0x29a8 2986 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2979 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @297A stack[-2] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @297D stack[-1] = returndata.length // @297E stack[0] = returndata.length // } // Block ends with conditional jump to 0x29a8, if returndata.length == 0x00 label_2987: // Incoming jump from 0x2986, if not returndata.length == 0x00 // Inputs[6] // { // @2989 memory[0x40:0x60] // @298A stack[-2] // @2991 returndata.length // @2999 returndata.length // @299C returndata.length // @29A3 returndata[0x00:0x00 + returndata.length] // } 2987 60 PUSH1 0x40 2989 51 MLOAD 298A 91 SWAP2 298B 50 POP 298C 60 PUSH1 0x1f 298E 19 NOT 298F 60 PUSH1 0x3f 2991 3D RETURNDATASIZE 2992 01 ADD 2993 16 AND 2994 82 DUP3 2995 01 ADD 2996 60 PUSH1 0x40 2998 52 MSTORE 2999 3D RETURNDATASIZE 299A 82 DUP3 299B 52 MSTORE 299C 3D RETURNDATASIZE 299D 60 PUSH1 0x00 299F 60 PUSH1 0x20 29A1 84 DUP5 29A2 01 ADD 29A3 3E RETURNDATACOPY 29A4 61 PUSH2 0x29ad 29A7 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @298A stack[-2] = memory[0x40:0x60] // @2998 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @299B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @29A3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x29ad label_29A8: // Incoming jump from 0x2986, if returndata.length == 0x00 // Inputs[4] // { // @29AB stack[-2] // @29AF stack[-4] // @29B1 stack[-3] // @29B1 stack[-5] // } 29A8 5B JUMPDEST 29A9 60 PUSH1 0x60 29AB 91 SWAP2 29AC 50 POP 29AD 5B JUMPDEST 29AE 50 POP 29AF 91 SWAP2 29B0 50 POP 29B1 91 SWAP2 29B2 50 POP 29B3 81 DUP2 29B4 80 DUP1 29B5 15 ISZERO 29B6 61 PUSH2 0x29d7 29B9 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @29AF stack[-4] = 0x60 // @29B1 stack[-5] = stack[-3] // @29B3 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x29d7, if !stack[-3] label_29BA: // Incoming jump from 0x29B9, if not !stack[-3] // Incoming jump from 0x29B9, if not !stack[-3] // Inputs[2] // { // @29BB stack[-2] // @29BC memory[stack[-2]:stack[-2] + 0x20] // } 29BA 50 POP 29BB 80 DUP1 29BC 51 MLOAD 29BD 15 ISZERO 29BE 80 DUP1 29BF 61 PUSH2 0x29d7 29C2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @29BD stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x29d7, if !memory[stack[-2]:stack[-2] + 0x20] label_29C3: // Incoming jump from 0x29C2, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @29C4 stack[-2] // @29CA memory[stack[-2]:stack[-2] + 0x20] // } 29C3 50 POP 29C4 80 DUP1 29C5 80 DUP1 29C6 60 PUSH1 0x20 29C8 01 ADD 29C9 90 SWAP1 29CA 51 MLOAD 29CB 81 DUP2 29CC 01 ADD 29CD 90 SWAP1 29CE 61 PUSH2 0x29d7 29D1 91 SWAP2 29D2 90 SWAP1 29D3 61 PUSH2 0x35f0 29D6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @29D1 stack[-1] = 0x29d7 // @29D2 stack[1] = 0x20 + stack[-2] // @29D2 stack[0] = 0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x35f0, returns to 0x29D7 label_29D7: // Incoming jump from 0x29B9, if !stack[-3] // Incoming jump from 0x29C2, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming return from call to 0x35F0 at 0x29D6 // Incoming jump from 0x29B9, if !stack[-3] // Inputs[1] { @29DB stack[-1] } 29D7 5B JUMPDEST 29D8 61 PUSH2 0x1078 29DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1078, if stack[-1] label_29DC: // Incoming jump from 0x29DB, if not stack[-1] // Inputs[1] { @29DE memory[0x40:0x60] } 29DC 60 PUSH1 0x40 29DE 51 MLOAD 29DF 62 PUSH3 0x461bcd 29E3 60 PUSH1 0xe5 29E5 1B SHL 29E6 81 DUP2 29E7 52 MSTORE 29E8 60 PUSH1 0x04 29EA 01 ADD 29EB 61 PUSH2 0x0840 29EE 90 SWAP1 29EF 61 PUSH2 0x37e7 29F2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @29E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @29EE stack[0] = 0x0840 // @29EE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x37e7, returns to 0x0840 label_29F3: // Incoming jump from 0x1C94 // Incoming jump from 0x1FE1 // Incoming jump from 0x2870 // Incoming jump from 0x1200 // Incoming jump from 0x1689 // Incoming jump from 0x1567 // Inputs[3] // { // @29FC stack[-6] // @29FD stack[-5] // @29FE stack[-4] // } 29F3 5B JUMPDEST 29F4 60 PUSH1 0x00 29F6 80 DUP1 29F7 60 PUSH1 0x00 29F9 61 PUSH2 0x2a03 29FC 89 DUP10 29FD 89 DUP10 29FE 89 DUP10 29FF 61 PUSH2 0x26c3 2A02 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @29F4 stack[0] = 0x00 // @29F6 stack[1] = 0x00 // @29F7 stack[2] = 0x00 // @29F9 stack[3] = 0x2a03 // @29FC stack[4] = stack[-6] // @29FD stack[5] = stack[-5] // @29FE stack[6] = stack[-4] // } // Block ends with call to 0x26c3, returns to 0x2A03 label_2A03: // Incoming return from call to 0x26C3 at 0x2A02 // Inputs[5] // { // @2A04 stack[-1] // @2A04 stack[-3] // @2A06 stack[-2] // @2A06 stack[-4] // @2A0B stack[-8] // } 2A03 5B JUMPDEST 2A04 91 SWAP2 2A05 50 POP 2A06 91 SWAP2 2A07 50 POP 2A08 61 PUSH2 0x2a12 2A0B 86 DUP7 2A0C 83 DUP4 2A0D 83 DUP4 2A0E 61 PUSH2 0x2792 2A11 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @2A04 stack[-3] = stack[-1] // @2A06 stack[-4] = stack[-2] // @2A08 stack[-2] = 0x2a12 // @2A0B stack[-1] = stack[-8] // @2A0C stack[0] = stack[-2] // @2A0D stack[1] = stack[-1] // } // Block ends with call to 0x2792, returns to 0x2A12 label_2A12: // Incoming return from call to 0x2792 at 0x2A11 // Inputs[2] // { // @2A13 stack[-4] // @2A13 stack[-1] // } 2A12 5B JUMPDEST 2A13 92 SWAP3 2A14 50 POP 2A15 60 PUSH1 0x00 2A17 83 DUP4 2A18 11 GT 2A19 80 DUP1 2A1A 15 ISZERO 2A1B 61 PUSH2 0x2a24 2A1E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2A13 stack[-4] = stack[-1] // @2A18 stack[-1] = stack[-1] > 0x00 // } // Block ends with conditional jump to 0x2a24, if !(stack[-1] > 0x00) label_2A1F: // Incoming jump from 0x2A1E, if not !(stack[-1] > 0x00) // Inputs[2] // { // @2A20 stack[-6] // @2A21 stack[-4] // } 2A1F 50 POP 2A20 84 DUP5 2A21 83 DUP4 2A22 10 LT 2A23 15 ISZERO 2A24 5B JUMPDEST 2A25 61 PUSH2 0x2a40 2A28 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a40, if !(stack[-4] < stack[-6]) label_2A29: // Incoming jump from 0x2A28, if not !(stack[-4] < stack[-6]) // Incoming jump from 0x2A28, if not stack[-1] // Inputs[1] { @2A2B memory[0x40:0x60] } 2A29 60 PUSH1 0x40 2A2B 51 MLOAD 2A2C 62 PUSH3 0x461bcd 2A30 60 PUSH1 0xe5 2A32 1B SHL 2A33 81 DUP2 2A34 52 MSTORE 2A35 60 PUSH1 0x04 2A37 01 ADD 2A38 61 PUSH2 0x0840 2A3B 90 SWAP1 2A3C 61 PUSH2 0x381e 2A3F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2A3B stack[0] = 0x0840 // @2A3B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x381e, returns to 0x0840 label_2A40: // Incoming jump from 0x2A28, if !(stack[-4] < stack[-6]) // Incoming jump from 0x2A28, if stack[-1] // Inputs[2] // { // @2A46 stack[-8] // @2A47 stack[-7] // } 2A40 5B JUMPDEST 2A41 60 PUSH1 0x00 2A43 61 PUSH2 0x2a4c 2A46 89 DUP10 2A47 89 DUP10 2A48 61 PUSH2 0x2faa 2A4B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A41 stack[0] = 0x00 // @2A43 stack[1] = 0x2a4c // @2A46 stack[2] = stack[-8] // @2A47 stack[3] = stack[-7] // } // Block ends with call to 0x2faa, returns to 0x2A4C label_2A4C: // Incoming return from call to 0x2FAA at 0x2A4B // Inputs[3] // { // @2A4E stack[-2] // @2A4E stack[-3] // @2A5D stack[-11] // } 2A4C 5B JUMPDEST 2A4D 50 POP 2A4E 90 SWAP1 2A4F 50 POP 2A50 60 PUSH1 0x00 2A52 80 DUP1 2A53 82 DUP3 2A54 60 PUSH1 0x01 2A56 60 PUSH1 0x01 2A58 60 PUSH1 0xa0 2A5A 1B SHL 2A5B 03 SUB 2A5C 16 AND 2A5D 8B DUP12 2A5E 60 PUSH1 0x01 2A60 60 PUSH1 0x01 2A62 60 PUSH1 0xa0 2A64 1B SHL 2A65 03 SUB 2A66 16 AND 2A67 14 EQ 2A68 61 PUSH2 0x2a73 2A6B 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2A4E stack[-3] = stack[-2] // @2A50 stack[-2] = 0x00 // @2A52 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2a73, if (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-2] label_2A6C: // Incoming jump from 0x2A6B, if not (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[1] { @2A6C stack[-6] } 2A6C 85 DUP6 2A6D 60 PUSH1 0x00 2A6F 61 PUSH2 0x2a77 2A72 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A6C stack[0] = stack[-6] // @2A6D stack[1] = 0x00 // } // Block ends with unconditional jump to 0x2a77 label_2A73: // Incoming jump from 0x2A6B, if (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[6] // { // @2A76 stack[-6] // @2A78 stack[-1] // @2A7A stack[-2] // @2A7F stack[-11] // @2A80 stack[-12] // @2A81 stack[-9] // } 2A73 5B JUMPDEST 2A74 60 PUSH1 0x00 2A76 86 DUP7 2A77 5B JUMPDEST 2A78 91 SWAP2 2A79 50 POP 2A7A 91 SWAP2 2A7B 50 POP 2A7C 61 PUSH2 0x2a86 2A7F 8B DUP12 2A80 8D DUP14 2A81 8B DUP12 2A82 61 PUSH2 0x290c 2A85 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2A78 stack[-1] = stack[-6] // @2A7A stack[-2] = 0x00 // @2A7C stack[0] = 0x2a86 // @2A7F stack[1] = stack[-11] // @2A80 stack[2] = stack[-12] // @2A81 stack[3] = stack[-9] // } // Block ends with call to 0x290c, returns to 0x2A86 label_2A86: // Incoming return from call to 0x290C at 0x2A85 // Incoming return from call to 0x290C at 0x2A85 // Inputs[5] // { // @2A8A memory[0x40:0x60] // @2AAA stack[-12] // @2AB7 stack[-2] // @2AB9 stack[-1] // @2ABB stack[-7] // } 2A86 5B JUMPDEST 2A87 60 PUSH1 0x40 2A89 80 DUP1 2A8A 51 MLOAD 2A8B 60 PUSH1 0x00 2A8D 81 DUP2 2A8E 52 MSTORE 2A8F 60 PUSH1 0x20 2A91 81 DUP2 2A92 01 ADD 2A93 91 SWAP2 2A94 82 DUP3 2A95 90 SWAP1 2A96 52 MSTORE 2A97 63 PUSH4 0x022c0d9f 2A9C 60 PUSH1 0xe0 2A9E 1B SHL 2A9F 90 SWAP1 2AA0 91 SWAP2 2AA1 52 MSTORE 2AA2 60 PUSH1 0x01 2AA4 60 PUSH1 0x01 2AA6 60 PUSH1 0xa0 2AA8 1B SHL 2AA9 03 SUB 2AAA 8D DUP14 2AAB 16 AND 2AAC 90 SWAP1 2AAD 63 PUSH4 0x022c0d9f 2AB2 90 SWAP1 2AB3 61 PUSH2 0x2ac5 2AB6 90 SWAP1 2AB7 85 DUP6 2AB8 90 SWAP1 2AB9 85 DUP6 2ABA 90 SWAP1 2ABB 8C DUP13 2ABC 90 SWAP1 2ABD 60 PUSH1 0x24 2ABF 81 DUP2 2AC0 01 ADD 2AC1 61 PUSH2 0x3c86 2AC4 56 *JUMP // Stack delta = +8 // Outputs[11] // { // @2A8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2A96 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @2AA1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x022c0d9f << 0xe0 // @2AAC stack[0] = stack[-12] & (0x01 << 0xa0) - 0x01 // @2AB2 stack[1] = 0x022c0d9f // @2AB6 stack[2] = 0x2ac5 // @2AB8 stack[3] = stack[-2] // @2ABA stack[4] = stack[-1] // @2ABC stack[5] = stack[-7] // @2ABC stack[6] = memory[0x40:0x60] // @2AC0 stack[7] = memory[0x40:0x60] + 0x24 // } // Block ends with unconditional jump to 0x3c86 2AC5 5B JUMPDEST 2AC6 60 PUSH1 0x00 2AC8 60 PUSH1 0x40 2ACA 51 MLOAD 2ACB 80 DUP1 2ACC 83 DUP4 2ACD 03 SUB 2ACE 81 DUP2 2ACF 60 PUSH1 0x00 2AD1 87 DUP8 2AD2 80 DUP1 2AD3 3B EXTCODESIZE 2AD4 15 ISZERO 2AD5 80 DUP1 2AD6 15 ISZERO 2AD7 61 PUSH2 0x2adf 2ADA 57 *JUMPI 2ADB 60 PUSH1 0x00 2ADD 80 DUP1 2ADE FD *REVERT 2ADF 5B JUMPDEST 2AE0 50 POP 2AE1 5A GAS 2AE2 F1 CALL 2AE3 15 ISZERO 2AE4 80 DUP1 2AE5 15 ISZERO 2AE6 61 PUSH2 0x2af3 2AE9 57 *JUMPI 2AEA 3D RETURNDATASIZE 2AEB 60 PUSH1 0x00 2AED 80 DUP1 2AEE 3E RETURNDATACOPY 2AEF 3D RETURNDATASIZE 2AF0 60 PUSH1 0x00 2AF2 FD *REVERT 2AF3 5B JUMPDEST 2AF4 50 POP 2AF5 50 POP 2AF6 50 POP 2AF7 50 POP 2AF8 50 POP 2AF9 50 POP 2AFA 50 POP 2AFB 50 POP 2AFC 50 POP 2AFD 96 SWAP7 2AFE 95 SWAP6 2AFF 50 POP 2B00 50 POP 2B01 50 POP 2B02 50 POP 2B03 50 POP 2B04 50 POP 2B05 56 *JUMP 2B06 5B JUMPDEST 2B07 60 PUSH1 0x0e 2B09 54 SLOAD 2B0A 60 PUSH1 0x10 2B0C 54 SLOAD 2B0D 60 PUSH1 0x0f 2B0F 54 SLOAD 2B10 60 PUSH1 0x11 2B12 54 SLOAD 2B13 60 PUSH1 0x12 2B15 54 SLOAD 2B16 60 PUSH1 0x00 2B18 94 SWAP5 2B19 61 PUSH2 0x2871 2B1C 94 SWAP5 2B1D 60 PUSH1 0x01 2B1F 60 PUSH1 0x01 2B21 60 PUSH1 0xa0 2B23 1B SHL 2B24 03 SUB 2B25 91 SWAP2 2B26 82 DUP3 2B27 16 AND 2B28 94 SWAP5 2B29 90 SWAP1 2B2A 82 DUP3 2B2B 16 AND 2B2C 93 SWAP4 2B2D 91 SWAP2 2B2E 16 AND 2B2F 91 SWAP2 2B30 30 ADDRESS 2B31 61 PUSH2 0x3183 2B34 56 *JUMP label_2B35: // Incoming call from 0x1A3A, returns to 0x1A3B // Inputs[2] // { // @2B36 msg.sender // @2B37 stack[-1] // } 2B35 5B JUMPDEST 2B36 33 CALLER 2B37 90 SWAP1 2B38 56 *JUMP // Stack delta = +0 // Outputs[1] { @2B37 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_2B39: // Incoming call from 0x288C, returns to 0x288D // Incoming call from 0x1DB5, returns to 0x1DB6 // Incoming call from 0x221D, returns to 0x221E // Incoming call from 0x1A76, returns to 0x1A77 // Inputs[2] // { // @2B42 stack[-1] // @2B5A stack[-2] // } 2B39 5B JUMPDEST 2B3A 60 PUSH1 0x01 2B3C 60 PUSH1 0x01 2B3E 60 PUSH1 0xa0 2B40 1B SHL 2B41 03 SUB 2B42 81 DUP2 2B43 16 AND 2B44 73 PUSH20 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee 2B59 14 EQ 2B5A 91 SWAP2 2B5B 90 SWAP1 2B5C 50 POP 2B5D 56 *JUMP // Stack delta = -1 // Outputs[1] { @2B5A stack[-2] = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee == stack[-1] & (0x01 << 0xa0) - 0x01 } // Block ends with unconditional jump to stack[-2] label_2B5E: // Incoming call from 0x1BAB, returns to 0x0CB0 // Inputs[1] { @2B62 stack[-3] } 2B5E 5B JUMPDEST 2B5F 60 PUSH1 0x00 2B61 80 DUP1 2B62 84 DUP5 2B63 11 GT 2B64 61 PUSH2 0x2b7f 2B67 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B5F stack[0] = 0x00 } // Block ends with conditional jump to 0x2b7f, if stack[-3] > 0x00 label_2B68: // Incoming jump from 0x2B67, if not stack[-3] > 0x00 // Inputs[1] { @2B6A memory[0x40:0x60] } 2B68 60 PUSH1 0x40 2B6A 51 MLOAD 2B6B 62 PUSH3 0x461bcd 2B6F 60 PUSH1 0xe5 2B71 1B SHL 2B72 81 DUP2 2B73 52 MSTORE 2B74 60 PUSH1 0x04 2B76 01 ADD 2B77 61 PUSH2 0x0840 2B7A 90 SWAP1 2B7B 61 PUSH2 0x38d2 2B7E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2B73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2B7A stack[0] = 0x0840 // @2B7A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x38d2, returns to 0x0840 label_2B7F: // Incoming jump from 0x2B67, if stack[-3] > 0x00 // Inputs[1] { @2B82 stack[-3] } 2B7F 5B JUMPDEST 2B80 60 PUSH1 0x00 2B82 83 DUP4 2B83 11 GT 2B84 80 DUP1 2B85 15 ISZERO 2B86 61 PUSH2 0x2b8f 2B89 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B83 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x2b8f, if !(stack[-3] > 0x00) label_2B8A: // Incoming jump from 0x2B89, if not !(stack[-3] > 0x00) // Inputs[1] { @2B8D stack[-3] } 2B8A 50 POP 2B8B 60 PUSH1 0x00 2B8D 82 DUP3 2B8E 11 GT 2B8F 5B JUMPDEST 2B90 61 PUSH2 0x2bab 2B93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2bab, if stack[-3] > 0x00 label_2B94: // Incoming jump from 0x2B93, if not stack[-3] > 0x00 // Incoming jump from 0x2B93, if not stack[-1] // Inputs[1] { @2B96 memory[0x40:0x60] } 2B94 60 PUSH1 0x40 2B96 51 MLOAD 2B97 62 PUSH3 0x461bcd 2B9B 60 PUSH1 0xe5 2B9D 1B SHL 2B9E 81 DUP2 2B9F 52 MSTORE 2BA0 60 PUSH1 0x04 2BA2 01 ADD 2BA3 61 PUSH2 0x0840 2BA6 90 SWAP1 2BA7 61 PUSH2 0x39fd 2BAA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2B9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2BA6 stack[0] = 0x0840 // @2BA6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x39fd, returns to 0x0840 label_2BAB: // Incoming jump from 0x2B93, if stack[-3] > 0x00 // Incoming jump from 0x2B93, if stack[-1] // Inputs[2] // { // @2BB7 stack[-3] // @2BB8 stack[-4] // } 2BAB 5B JUMPDEST 2BAC 60 PUSH1 0x00 2BAE 61 PUSH2 0x2bcf 2BB1 61 PUSH2 0x03e8 2BB4 61 PUSH2 0x2bc3 2BB7 86 DUP7 2BB8 88 DUP9 2BB9 63 PUSH4 0xffffffff 2BBE 61 PUSH2 0x3034 2BC1 16 AND 2BC2 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2BAC stack[0] = 0x00 // @2BAE stack[1] = 0x2bcf // @2BB1 stack[2] = 0x03e8 // @2BB4 stack[3] = 0x2bc3 // @2BB7 stack[4] = stack[-3] // @2BB8 stack[5] = stack[-4] // } // Block ends with call to 0x3034 & 0xffffffff, returns to 0x2BC3 label_2BC3: // Incoming return from call to 0x3034 at 0x2BC2 // Incoming return from call to 0x3216 at 0x2BE8 // Inputs[2] // { // @2BC4 stack[-1] // @2BC4 stack[-2] // } 2BC3 5B JUMPDEST 2BC4 90 SWAP1 2BC5 63 PUSH4 0xffffffff 2BCA 61 PUSH2 0x3034 2BCD 16 AND 2BCE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2BC4 stack[-1] = stack[-2] // @2BC4 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x3034 & 0xffffffff label_2BCF: // Incoming return from call to 0x2BC3 at 0x2BC2 // Inputs[4] // { // @2BD0 stack[-2] // @2BD0 stack[-1] // @2BDD stack[-4] // @2BDE stack[-6] // } 2BCF 5B JUMPDEST 2BD0 90 SWAP1 2BD1 50 POP 2BD2 60 PUSH1 0x00 2BD4 61 PUSH2 0x2be9 2BD7 61 PUSH2 0x03e5 2BDA 61 PUSH2 0x2bc3 2BDD 86 DUP7 2BDE 89 DUP10 2BDF 63 PUSH4 0xffffffff 2BE4 61 PUSH2 0x3216 2BE7 16 AND 2BE8 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2BD0 stack[-2] = stack[-1] // @2BD2 stack[-1] = 0x00 // @2BD4 stack[0] = 0x2be9 // @2BD7 stack[1] = 0x03e5 // @2BDA stack[2] = 0x2bc3 // @2BDD stack[3] = stack[-4] // @2BDE stack[4] = stack[-6] // } // Block ends with call to 0x3216 & 0xffffffff, returns to 0x2BC3 label_2BE9: // Incoming return from call to 0x2BC3 at 0x2BE8 // Inputs[3] // { // @2BEA stack[-1] // @2BEA stack[-2] // @2BF2 stack[-3] // } 2BE9 5B JUMPDEST 2BEA 90 SWAP1 2BEB 50 POP 2BEC 61 PUSH2 0x2c06 2BEF 60 PUSH1 0x01 2BF1 82 DUP3 2BF2 84 DUP5 2BF3 81 DUP2 2BF4 61 PUSH2 0x2bf9 2BF7 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2BEA stack[-2] = stack[-1] // @2BEC stack[-1] = 0x2c06 // @2BEF stack[0] = 0x01 // @2BF1 stack[1] = stack[-1] // @2BF2 stack[2] = stack[-3] // } // Block ends with conditional call to 0x2bf9, returns to 0x2C06, if stack[-1] label_2BF8: // Incoming jump from 0x2BF7, if not stack[-1] 2BF8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BF8 assert(); } // Block terminates label_2BF9: // Incoming call from 0x2BF7, returns to 0x2C06, if stack[-1] // Inputs[3] // { // @2BFA stack[-2] // @2BFA stack[-1] // @2BFB stack[-3] // } 2BF9 5B JUMPDEST 2BFA 04 DIV 2BFB 90 SWAP1 2BFC 63 PUSH4 0xffffffff 2C01 61 PUSH2 0x3075 2C04 16 AND 2C05 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2BFB stack[-2] = stack[-3] // @2BFB stack[-3] = stack[-1] / stack[-2] // } // Block ends with unconditional jump to 0x3075 & 0xffffffff label_2C06: // Incoming return from call to 0x2BF9 at 0x2BF7 // Incoming return from call to 0x36DA at 0x3CB2 // Inputs[3] // { // @2C07 stack[-1] // @2C07 stack[-8] // @2C08 stack[-7] // } 2C06 5B JUMPDEST 2C07 96 SWAP7 2C08 95 SWAP6 2C09 50 POP 2C0A 50 POP 2C0B 50 POP 2C0C 50 POP 2C0D 50 POP 2C0E 50 POP 2C0F 56 *JUMP // Stack delta = -7 // Outputs[1] { @2C07 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2C10: // Incoming call from 0x1C48, returns to 0x1C49 // Incoming call from 0x1F95, returns to 0x1F96 // Inputs[2] // { // @2C16 msg.value // @2C27 stack[-1] // } 2C10 5B JUMPDEST 2C11 60 PUSH1 0x0a 2C13 61 PUSH2 0x03e8 2C16 34 CALLVALUE 2C17 81 DUP2 2C18 81 DUP2 2C19 06 MOD 2C1A 83 DUP4 2C1B 81 DUP2 2C1C 04 DIV 2C1D 84 DUP5 2C1E 0A EXP 2C1F 92 SWAP3 2C20 90 SWAP1 2C21 91 SWAP2 2C22 04 DIV 2C23 91 SWAP2 2C24 90 SWAP1 2C25 91 SWAP2 2C26 02 MUL 2C27 92 SWAP3 2C28 91 SWAP2 2C29 90 SWAP1 2C2A 06 MOD 2C2B 90 SWAP1 2C2C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2C27 stack[-1] = msg.value / 0x03e8 * 0x0a ** (msg.value % 0x03e8 / 0x0a) // @2C2B stack[0] = msg.value % 0x03e8 % 0x0a // } // Block ends with unconditional jump to stack[-1] label_2C2D: // Incoming call from 0x1C70, returns to 0x1C71 // Incoming call from 0x1FBD, returns to 0x1FBE 2C2D 5B JUMPDEST 2C2E 61 PUSH2 0x2c35 2C31 61 PUSH2 0x327f 2C34 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C2E stack[0] = 0x2c35 } // Block ends with call to 0x327f, returns to 0x2C35 label_2C35: // Incoming return from call to 0x327F at 0x2C34 // Inputs[4] // { // @2C38 stack[-5] // @2C49 memory[0x40:0x60] // @2C5D memory[0x40:0x60] // @2C64 address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 2C35 5B JUMPDEST 2C36 60 PUSH1 0x00 2C38 85 DUP6 2C39 60 PUSH1 0x01 2C3B 60 PUSH1 0x01 2C3D 60 PUSH1 0xa0 2C3F 1B SHL 2C40 03 SUB 2C41 16 AND 2C42 63 PUSH4 0x0dfe1681 2C47 60 PUSH1 0x40 2C49 51 MLOAD 2C4A 81 DUP2 2C4B 63 PUSH4 0xffffffff 2C50 16 AND 2C51 60 PUSH1 0xe0 2C53 1B SHL 2C54 81 DUP2 2C55 52 MSTORE 2C56 60 PUSH1 0x04 2C58 01 ADD 2C59 60 PUSH1 0x20 2C5B 60 PUSH1 0x40 2C5D 51 MLOAD 2C5E 80 DUP1 2C5F 83 DUP4 2C60 03 SUB 2C61 81 DUP2 2C62 86 DUP7 2C63 80 DUP1 2C64 3B EXTCODESIZE 2C65 15 ISZERO 2C66 80 DUP1 2C67 15 ISZERO 2C68 61 PUSH2 0x2c70 2C6B 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @2C36 stack[0] = 0x00 // @2C41 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2C42 stack[2] = 0x0dfe1681 // @2C55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0 // @2C58 stack[3] = 0x04 + memory[0x40:0x60] // @2C59 stack[4] = 0x20 // @2C5D stack[5] = memory[0x40:0x60] // @2C60 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2C61 stack[7] = memory[0x40:0x60] // @2C62 stack[8] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2C65 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional jump to 0x2c70, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_2C6C: // Incoming jump from 0x2C6B, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @2C6F memory[0x00:0x00] } 2C6C 60 PUSH1 0x00 2C6E 80 DUP1 2C6F FD *REVERT // Stack delta = +0 // Outputs[1] { @2C6F revert(memory[0x00:0x00]); } // Block terminates label_2C70: // Incoming jump from 0x2C6B, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[8] // { // @2C72 msg.gas // @2C73 stack[-5] // @2C73 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2C73 stack[-2] // @2C73 stack[-3] // @2C73 memory[stack[-3]:stack[-3] + stack[-4]] // @2C73 stack[-6] // @2C73 stack[-4] // } 2C70 5B JUMPDEST 2C71 50 POP 2C72 5A GAS 2C73 FA STATICCALL 2C74 15 ISZERO 2C75 80 DUP1 2C76 15 ISZERO 2C77 61 PUSH2 0x2c84 2C7A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2C73 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2C74 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2c84, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2C7B: // Incoming jump from 0x2C7A, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2C7B returndata.length // @2C7F returndata[0x00:0x00 + returndata.length] // @2C80 returndata.length // @2C83 memory[0x00:0x00 + returndata.length] // } 2C7B 3D RETURNDATASIZE 2C7C 60 PUSH1 0x00 2C7E 80 DUP1 2C7F 3E RETURNDATACOPY 2C80 3D RETURNDATASIZE 2C81 60 PUSH1 0x00 2C83 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2C7F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2C83 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2C84: // Incoming jump from 0x2C7A, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2C8B memory[0x40:0x60] // @2C8C returndata.length // } 2C84 5B JUMPDEST 2C85 50 POP 2C86 50 POP 2C87 50 POP 2C88 50 POP 2C89 60 PUSH1 0x40 2C8B 51 MLOAD 2C8C 3D RETURNDATASIZE 2C8D 60 PUSH1 0x1f 2C8F 19 NOT 2C90 60 PUSH1 0x1f 2C92 82 DUP3 2C93 01 ADD 2C94 16 AND 2C95 82 DUP3 2C96 01 ADD 2C97 80 DUP1 2C98 60 PUSH1 0x40 2C9A 52 MSTORE 2C9B 50 POP 2C9C 81 DUP2 2C9D 01 ADD 2C9E 90 SWAP1 2C9F 61 PUSH2 0x2ca8 2CA2 91 SWAP2 2CA3 90 SWAP1 2CA4 61 PUSH2 0x3352 2CA7 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2C9A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2CA2 stack[-4] = 0x2ca8 // @2CA3 stack[-2] = memory[0x40:0x60] // @2CA3 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x3352, returns to 0x2CA8 label_2CA8: // Incoming return from call to 0x3352 at 0x2CA7 // Inputs[6] // { // @2CA9 stack[-2] // @2CA9 stack[-1] // @2CAD stack[-7] // @2CBE memory[0x40:0x60] // @2CD2 memory[0x40:0x60] // @2CD9 address((0x01 << 0xa0) - 0x01 & stack[-7]).code.length // } 2CA8 5B JUMPDEST 2CA9 90 SWAP1 2CAA 50 POP 2CAB 60 PUSH1 0x00 2CAD 86 DUP7 2CAE 60 PUSH1 0x01 2CB0 60 PUSH1 0x01 2CB2 60 PUSH1 0xa0 2CB4 1B SHL 2CB5 03 SUB 2CB6 16 AND 2CB7 63 PUSH4 0xd21220a7 2CBC 60 PUSH1 0x40 2CBE 51 MLOAD 2CBF 81 DUP2 2CC0 63 PUSH4 0xffffffff 2CC5 16 AND 2CC6 60 PUSH1 0xe0 2CC8 1B SHL 2CC9 81 DUP2 2CCA 52 MSTORE 2CCB 60 PUSH1 0x04 2CCD 01 ADD 2CCE 60 PUSH1 0x20 2CD0 60 PUSH1 0x40 2CD2 51 MLOAD 2CD3 80 DUP1 2CD4 83 DUP4 2CD5 03 SUB 2CD6 81 DUP2 2CD7 86 DUP7 2CD8 80 DUP1 2CD9 3B EXTCODESIZE 2CDA 15 ISZERO 2CDB 80 DUP1 2CDC 15 ISZERO 2CDD 61 PUSH2 0x2ce5 2CE0 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @2CA9 stack[-2] = stack[-1] // @2CAB stack[-1] = 0x00 // @2CB6 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-7] // @2CB7 stack[1] = 0xd21220a7 // @2CCA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd21220a7) << 0xe0 // @2CCD stack[2] = 0x04 + memory[0x40:0x60] // @2CCE stack[3] = 0x20 // @2CD2 stack[4] = memory[0x40:0x60] // @2CD5 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2CD6 stack[6] = memory[0x40:0x60] // @2CD7 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-7] // @2CDA stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-7]).code.length // } // Block ends with conditional jump to 0x2ce5, if !!address((0x01 << 0xa0) - 0x01 & stack[-7]).code.length label_2CE1: // Incoming jump from 0x2CE0, if not !!address((0x01 << 0xa0) - 0x01 & stack[-7]).code.length // Inputs[1] { @2CE4 memory[0x00:0x00] } 2CE1 60 PUSH1 0x00 2CE3 80 DUP1 2CE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @2CE4 revert(memory[0x00:0x00]); } // Block terminates label_2CE5: // Incoming jump from 0x2CE0, if !!address((0x01 << 0xa0) - 0x01 & stack[-7]).code.length // Inputs[8] // { // @2CE7 msg.gas // @2CE8 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2CE8 stack[-4] // @2CE8 memory[stack[-3]:stack[-3] + stack[-4]] // @2CE8 stack[-5] // @2CE8 stack[-2] // @2CE8 stack[-3] // @2CE8 stack[-6] // } 2CE5 5B JUMPDEST 2CE6 50 POP 2CE7 5A GAS 2CE8 FA STATICCALL 2CE9 15 ISZERO 2CEA 80 DUP1 2CEB 15 ISZERO 2CEC 61 PUSH2 0x2cf9 2CEF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2CE8 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @2CE9 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x2cf9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2CF0: // Incoming jump from 0x2CEF, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2CF0 returndata.length // @2CF4 returndata[0x00:0x00 + returndata.length] // @2CF5 returndata.length // @2CF8 memory[0x00:0x00 + returndata.length] // } 2CF0 3D RETURNDATASIZE 2CF1 60 PUSH1 0x00 2CF3 80 DUP1 2CF4 3E RETURNDATACOPY 2CF5 3D RETURNDATASIZE 2CF6 60 PUSH1 0x00 2CF8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2CF4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2CF8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2CF9: // Incoming jump from 0x2CEF, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2D00 memory[0x40:0x60] // @2D01 returndata.length // } 2CF9 5B JUMPDEST 2CFA 50 POP 2CFB 50 POP 2CFC 50 POP 2CFD 50 POP 2CFE 60 PUSH1 0x40 2D00 51 MLOAD 2D01 3D RETURNDATASIZE 2D02 60 PUSH1 0x1f 2D04 19 NOT 2D05 60 PUSH1 0x1f 2D07 82 DUP3 2D08 01 ADD 2D09 16 AND 2D0A 82 DUP3 2D0B 01 ADD 2D0C 80 DUP1 2D0D 60 PUSH1 0x40 2D0F 52 MSTORE 2D10 50 POP 2D11 81 DUP2 2D12 01 ADD 2D13 90 SWAP1 2D14 61 PUSH2 0x2d1d 2D17 91 SWAP2 2D18 90 SWAP1 2D19 61 PUSH2 0x3352 2D1C 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2D0F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2D17 stack[-4] = 0x2d1d // @2D18 stack[-2] = memory[0x40:0x60] // @2D18 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x3352, returns to 0x2D1D label_2D1D: // Incoming return from call to 0x3352 at 0x2D1C // Inputs[5] // { // @2D1E stack[-2] // @2D1E stack[-1] // @2D22 memory[0x40:0x60] // @2D2B stack[-8] // @2D3A stack[-5] // } 2D1D 5B JUMPDEST 2D1E 90 SWAP1 2D1F 50 POP 2D20 60 PUSH1 0x40 2D22 51 MLOAD 2D23 80 DUP1 2D24 60 PUSH1 0xa0 2D26 01 ADD 2D27 60 PUSH1 0x40 2D29 52 MSTORE 2D2A 80 DUP1 2D2B 88 DUP9 2D2C 60 PUSH1 0x01 2D2E 60 PUSH1 0x01 2D30 60 PUSH1 0xa0 2D32 1B SHL 2D33 03 SUB 2D34 16 AND 2D35 81 DUP2 2D36 52 MSTORE 2D37 60 PUSH1 0x20 2D39 01 ADD 2D3A 85 DUP6 2D3B 60 PUSH1 0x00 2D3D 14 EQ 2D3E 61 PUSH2 0x2d47 2D41 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2D1E stack[-2] = stack[-1] // @2D22 stack[-1] = memory[0x40:0x60] // @2D29 memory[0x40:0x60] = 0xa0 + memory[0x40:0x60] // @2D36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-8] // @2D39 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x2d47, if 0x00 == stack[-5] label_2D42: // Incoming jump from 0x2D41, if not 0x00 == stack[-5] // Inputs[1] { @2D42 stack[-3] } 2D42 82 DUP3 2D43 61 PUSH2 0x2d49 2D46 56 *JUMP // Stack delta = +1 // Outputs[1] { @2D42 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x2d49 label_2D47: // Incoming jump from 0x2D41, if 0x00 == stack[-5] // Inputs[3] // { // @2D48 stack[-4] // @2D53 stack[-1] // @2D58 stack[-6] // } 2D47 5B JUMPDEST 2D48 83 DUP4 2D49 5B JUMPDEST 2D4A 60 PUSH1 0x01 2D4C 60 PUSH1 0x01 2D4E 60 PUSH1 0xa0 2D50 1B SHL 2D51 03 SUB 2D52 16 AND 2D53 81 DUP2 2D54 52 MSTORE 2D55 60 PUSH1 0x20 2D57 01 ADD 2D58 85 DUP6 2D59 15 ISZERO 2D5A 61 PUSH2 0x2d63 2D5D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2D54 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @2D57 stack[-1] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x2d63, if !stack[-6] label_2D5E: // Incoming jump from 0x2D5D, if not !stack[-7] // Incoming jump from 0x2D5D, if not !stack[-6] // Inputs[1] { @2D5E stack[-4] } 2D5E 83 DUP4 2D5F 61 PUSH2 0x2d65 2D62 56 *JUMP // Stack delta = +1 // Outputs[1] { @2D5E stack[0] = stack[-4] } // Block ends with unconditional jump to 0x2d65 label_2D63: // Incoming jump from 0x2D5D, if !stack[-7] // Incoming jump from 0x2D5D, if !stack[-6] // Inputs[8] // { // @2D64 stack[-3] // @2D6F stack[-1] // @2D74 stack[-8] // @2D7A stack[-7] // @2D7E stack[-5] // @2D7E stack[-2] // @2D82 stack[-10] // @2D83 stack[-9] // } 2D63 5B JUMPDEST 2D64 82 DUP3 2D65 5B JUMPDEST 2D66 60 PUSH1 0x01 2D68 60 PUSH1 0x01 2D6A 60 PUSH1 0xa0 2D6C 1B SHL 2D6D 03 SUB 2D6E 16 AND 2D6F 81 DUP2 2D70 52 MSTORE 2D71 60 PUSH1 0x20 2D73 01 ADD 2D74 87 DUP8 2D75 81 DUP2 2D76 52 MSTORE 2D77 60 PUSH1 0x20 2D79 01 ADD 2D7A 86 DUP7 2D7B 81 DUP2 2D7C 52 MSTORE 2D7D 50 POP 2D7E 92 SWAP3 2D7F 50 POP 2D80 50 POP 2D81 50 POP 2D82 94 SWAP5 2D83 93 SWAP4 2D84 50 POP 2D85 50 POP 2D86 50 POP 2D87 50 POP 2D88 56 *JUMP // Stack delta = -9 // Outputs[4] // { // @2D70 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @2D76 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = stack[-8] // @2D7C memory[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] = stack[-7] // @2D82 stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] 2D89 5B JUMPDEST 2D8A 60 PUSH1 0x40 2D8C 80 DUP1 2D8D 51 MLOAD 2D8E 60 PUSH1 0xa0 2D90 81 DUP2 2D91 01 ADD 2D92 82 DUP3 2D93 52 MSTORE 2D94 60 PUSH1 0x01 2D96 60 PUSH1 0x01 2D98 60 PUSH1 0xa0 2D9A 1B SHL 2D9B 03 SUB 2D9C 80 DUP1 2D9D 88 DUP9 2D9E 16 AND 2D9F 80 DUP1 2DA0 83 DUP4 2DA1 52 MSTORE 2DA2 87 DUP8 2DA3 82 DUP3 2DA4 16 AND 2DA5 60 PUSH1 0x20 2DA7 84 DUP5 2DA8 01 ADD 2DA9 81 DUP2 2DAA 90 SWAP1 2DAB 52 MSTORE 2DAC 91 SWAP2 2DAD 87 DUP8 2DAE 16 AND 2DAF 83 DUP4 2DB0 85 DUP6 2DB1 01 ADD 2DB2 81 DUP2 2DB3 90 SWAP1 2DB4 52 MSTORE 2DB5 60 PUSH1 0x60 2DB7 84 DUP5 2DB8 01 ADD 2DB9 87 DUP8 2DBA 90 SWAP1 2DBB 52 MSTORE 2DBC 60 PUSH1 0x80 2DBE 90 SWAP1 2DBF 93 SWAP4 2DC0 01 ADD 2DC1 85 DUP6 2DC2 90 SWAP1 2DC3 52 MSTORE 2DC4 60 PUSH1 0x0e 2DC6 80 DUP1 2DC7 54 SLOAD 2DC8 60 PUSH1 0x01 2DCA 60 PUSH1 0x01 2DCC 60 PUSH1 0xa0 2DCE 1B SHL 2DCF 03 SUB 2DD0 19 NOT 2DD1 90 SWAP1 2DD2 81 DUP2 2DD3 16 AND 2DD4 90 SWAP1 2DD5 92 SWAP3 2DD6 17 OR 2DD7 90 SWAP1 2DD8 55 SSTORE 2DD9 60 PUSH1 0x0f 2DDB 80 DUP1 2DDC 54 SLOAD 2DDD 82 DUP3 2DDE 16 AND 2DDF 90 SWAP1 2DE0 92 SWAP3 2DE1 17 OR 2DE2 90 SWAP1 2DE3 91 SWAP2 2DE4 55 SSTORE 2DE5 60 PUSH1 0x10 2DE7 80 DUP1 2DE8 54 SLOAD 2DE9 90 SWAP1 2DEA 91 SWAP2 2DEB 16 AND 2DEC 90 SWAP1 2DED 91 SWAP2 2DEE 17 OR 2DEF 90 SWAP1 2DF0 55 SSTORE 2DF1 60 PUSH1 0x11 2DF3 83 DUP4 2DF4 90 SWAP1 2DF5 55 SSTORE 2DF6 60 PUSH1 0x12 2DF8 82 DUP3 2DF9 90 SWAP1 2DFA 55 SSTORE 2DFB 51 MLOAD 2DFC 7F PUSH32 0x0c5698cf4fb028bda2b09a6e97f92fcb388a04d24d162e24523496d1e59e2a70 2E1D 90 SWAP1 2E1E 61 PUSH2 0x2e33 2E21 90 SWAP1 2E22 87 DUP8 2E23 90 SWAP1 2E24 87 DUP8 2E25 90 SWAP1 2E26 87 DUP8 2E27 90 SWAP1 2E28 87 DUP8 2E29 90 SWAP1 2E2A 87 DUP8 2E2B 90 SWAP1 2E2C 60 PUSH1 0x00 2E2E 90 SWAP1 2E2F 61 PUSH2 0x3753 2E32 56 *JUMP 2E33 5B JUMPDEST 2E34 60 PUSH1 0x40 2E36 51 MLOAD 2E37 80 DUP1 2E38 91 SWAP2 2E39 03 SUB 2E3A 90 SWAP1 2E3B A1 LOG1 2E3C 50 POP 2E3D 50 POP 2E3E 50 POP 2E3F 50 POP 2E40 50 POP 2E41 56 *JUMP 2E42 5B JUMPDEST 2E43 60 PUSH1 0x00 2E45 60 PUSH1 0x60 2E47 84 DUP5 2E48 60 PUSH1 0x01 2E4A 60 PUSH1 0x01 2E4C 60 PUSH1 0xa0 2E4E 1B SHL 2E4F 03 SUB 2E50 16 AND 2E51 63 PUSH4 0x095ea7b3 2E56 85 DUP6 2E57 85 DUP6 2E58 60 PUSH1 0x40 2E5A 51 MLOAD 2E5B 60 PUSH1 0x24 2E5D 01 ADD 2E5E 61 PUSH2 0x2e68 2E61 92 SWAP3 2E62 91 SWAP2 2E63 90 SWAP1 2E64 61 PUSH2 0x37b0 2E67 56 *JUMP 2E68 5B JUMPDEST 2E69 60 PUSH1 0x40 2E6B 51 MLOAD 2E6C 60 PUSH1 0x20 2E6E 81 DUP2 2E6F 83 DUP4 2E70 03 SUB 2E71 03 SUB 2E72 81 DUP2 2E73 52 MSTORE 2E74 90 SWAP1 2E75 60 PUSH1 0x40 2E77 52 MSTORE 2E78 90 SWAP1 2E79 60 PUSH1 0xe0 2E7B 1B SHL 2E7C 60 PUSH1 0x20 2E7E 82 DUP3 2E7F 01 ADD 2E80 80 DUP1 2E81 51 MLOAD 2E82 60 PUSH1 0x01 2E84 60 PUSH1 0x01 2E86 60 PUSH1 0xe0 2E88 1B SHL 2E89 03 SUB 2E8A 83 DUP4 2E8B 81 DUP2 2E8C 83 DUP4 2E8D 16 AND 2E8E 17 OR 2E8F 83 DUP4 2E90 52 MSTORE 2E91 50 POP 2E92 50 POP 2E93 50 POP 2E94 50 POP 2E95 60 PUSH1 0x40 2E97 51 MLOAD 2E98 61 PUSH2 0x2ea1 2E9B 91 SWAP2 2E9C 90 SWAP1 2E9D 61 PUSH2 0x3706 2EA0 56 *JUMP 2EA1 5B JUMPDEST 2EA2 60 PUSH1 0x00 2EA4 60 PUSH1 0x40 2EA6 51 MLOAD 2EA7 80 DUP1 2EA8 83 DUP4 2EA9 03 SUB 2EAA 81 DUP2 2EAB 60 PUSH1 0x00 2EAD 86 DUP7 2EAE 5A GAS 2EAF F1 CALL 2EB0 91 SWAP2 2EB1 50 POP 2EB2 50 POP 2EB3 3D RETURNDATASIZE 2EB4 80 DUP1 2EB5 60 PUSH1 0x00 2EB7 81 DUP2 2EB8 14 EQ 2EB9 61 PUSH2 0x2ede 2EBC 57 *JUMPI 2EBD 60 PUSH1 0x40 2EBF 51 MLOAD 2EC0 91 SWAP2 2EC1 50 POP 2EC2 60 PUSH1 0x1f 2EC4 19 NOT 2EC5 60 PUSH1 0x3f 2EC7 3D RETURNDATASIZE 2EC8 01 ADD 2EC9 16 AND 2ECA 82 DUP3 2ECB 01 ADD 2ECC 60 PUSH1 0x40 2ECE 52 MSTORE 2ECF 3D RETURNDATASIZE 2ED0 82 DUP3 2ED1 52 MSTORE 2ED2 3D RETURNDATASIZE 2ED3 60 PUSH1 0x00 2ED5 60 PUSH1 0x20 2ED7 84 DUP5 2ED8 01 ADD 2ED9 3E RETURNDATACOPY 2EDA 61 PUSH2 0x2ee3 2EDD 56 *JUMP 2EDE 5B JUMPDEST 2EDF 60 PUSH1 0x60 2EE1 91 SWAP2 2EE2 50 POP 2EE3 5B JUMPDEST 2EE4 50 POP 2EE5 91 SWAP2 2EE6 50 POP 2EE7 91 SWAP2 2EE8 50 POP 2EE9 81 DUP2 2EEA 80 DUP1 2EEB 15 ISZERO 2EEC 61 PUSH2 0x2f0d 2EEF 57 *JUMPI 2EF0 50 POP 2EF1 80 DUP1 2EF2 51 MLOAD 2EF3 15 ISZERO 2EF4 80 DUP1 2EF5 61 PUSH2 0x2f0d 2EF8 57 *JUMPI 2EF9 50 POP 2EFA 80 DUP1 2EFB 80 DUP1 2EFC 60 PUSH1 0x20 2EFE 01 ADD 2EFF 90 SWAP1 2F00 51 MLOAD 2F01 81 DUP2 2F02 01 ADD 2F03 90 SWAP1 2F04 61 PUSH2 0x2f0d 2F07 91 SWAP2 2F08 90 SWAP1 2F09 61 PUSH2 0x35f0 2F0C 56 *JUMP 2F0D 5B JUMPDEST 2F0E 61 PUSH2 0x1078 2F11 57 *JUMPI 2F12 60 PUSH1 0x40 2F14 51 MLOAD 2F15 62 PUSH3 0x461bcd 2F19 60 PUSH1 0xe5 2F1B 1B SHL 2F1C 81 DUP2 2F1D 52 MSTORE 2F1E 60 PUSH1 0x04 2F20 01 ADD 2F21 61 PUSH2 0x0840 2F24 90 SWAP1 2F25 61 PUSH2 0x391e 2F28 56 *JUMP label_2F29: // Incoming call from 0x26C2, returns to 0x0B67 // Inputs[1] { @2F32 stack[-1] } 2F29 5B JUMPDEST 2F2A 60 PUSH1 0x01 2F2C 60 PUSH1 0x01 2F2E 60 PUSH1 0xa0 2F30 1B SHL 2F31 03 SUB 2F32 81 DUP2 2F33 16 AND 2F34 61 PUSH2 0x2f4f 2F37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2f4f, if stack[-1] & (0x01 << 0xa0) - 0x01 label_2F38: // Incoming jump from 0x2F37, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2F3A memory[0x40:0x60] } 2F38 60 PUSH1 0x40 2F3A 51 MLOAD 2F3B 62 PUSH3 0x461bcd 2F3F 60 PUSH1 0xe5 2F41 1B SHL 2F42 81 DUP2 2F43 52 MSTORE 2F44 60 PUSH1 0x04 2F46 01 ADD 2F47 61 PUSH2 0x0840 2F4A 90 SWAP1 2F4B 61 PUSH2 0x3855 2F4E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2F43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2F4A stack[0] = 0x0840 // @2F4A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3855, returns to 0x0840 label_2F4F: // Incoming jump from 0x2F37, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @2F53 storage[0x00] // @2F56 memory[0x40:0x60] // @2F60 stack[-1] // @2F88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2F8C storage[0x00] // @2FA9 stack[-2] // } 2F4F 5B JUMPDEST 2F50 60 PUSH1 0x00 2F52 80 DUP1 2F53 54 SLOAD 2F54 60 PUSH1 0x40 2F56 51 MLOAD 2F57 60 PUSH1 0x01 2F59 60 PUSH1 0x01 2F5B 60 PUSH1 0xa0 2F5D 1B SHL 2F5E 03 SUB 2F5F 80 DUP1 2F60 85 DUP6 2F61 16 AND 2F62 93 SWAP4 2F63 92 SWAP3 2F64 16 AND 2F65 91 SWAP2 2F66 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 2F87 91 SWAP2 2F88 A3 LOG3 2F89 60 PUSH1 0x00 2F8B 80 DUP1 2F8C 54 SLOAD 2F8D 60 PUSH1 0x01 2F8F 60 PUSH1 0x01 2F91 60 PUSH1 0xa0 2F93 1B SHL 2F94 03 SUB 2F95 19 NOT 2F96 16 AND 2F97 60 PUSH1 0x01 2F99 60 PUSH1 0x01 2F9B 60 PUSH1 0xa0 2F9D 1B SHL 2F9E 03 SUB 2F9F 92 SWAP3 2FA0 90 SWAP1 2FA1 92 SWAP3 2FA2 16 AND 2FA3 91 SWAP2 2FA4 90 SWAP1 2FA5 91 SWAP2 2FA6 17 OR 2FA7 90 SWAP1 2FA8 55 SSTORE 2FA9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2F88 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // @2FA8 storage[0x00] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] label_2FAA: // Incoming call from 0x2A4B, returns to 0x2A4C // Incoming call from 0x26D1, returns to 0x26D2 // Inputs[2] // { // @2FAE stack[-1] // @2FB8 stack[-2] // } 2FAA 5B JUMPDEST 2FAB 60 PUSH1 0x00 2FAD 80 DUP1 2FAE 82 DUP3 2FAF 60 PUSH1 0x01 2FB1 60 PUSH1 0x01 2FB3 60 PUSH1 0xa0 2FB5 1B SHL 2FB6 03 SUB 2FB7 16 AND 2FB8 84 DUP5 2FB9 60 PUSH1 0x01 2FBB 60 PUSH1 0x01 2FBD 60 PUSH1 0xa0 2FBF 1B SHL 2FC0 03 SUB 2FC1 16 AND 2FC2 14 EQ 2FC3 15 ISZERO 2FC4 61 PUSH2 0x2fdf 2FC7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2FAB stack[0] = 0x00 // @2FAD stack[1] = 0x00 // } // Block ends with conditional jump to 0x2fdf, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_2FC8: // Incoming jump from 0x2FC7, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @2FCA memory[0x40:0x60] } 2FC8 60 PUSH1 0x40 2FCA 51 MLOAD 2FCB 62 PUSH3 0x461bcd 2FCF 60 PUSH1 0xe5 2FD1 1B SHL 2FD2 81 DUP2 2FD3 52 MSTORE 2FD4 60 PUSH1 0x04 2FD6 01 ADD 2FD7 61 PUSH2 0x0840 2FDA 90 SWAP1 2FDB 61 PUSH2 0x3955 2FDE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2FD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2FDA stack[0] = 0x0840 // @2FDA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3955, returns to 0x0840 label_2FDF: // Incoming jump from 0x2FC7, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @2FE0 stack[-3] // @2FEA stack[-4] // } 2FDF 5B JUMPDEST 2FE0 82 DUP3 2FE1 60 PUSH1 0x01 2FE3 60 PUSH1 0x01 2FE5 60 PUSH1 0xa0 2FE7 1B SHL 2FE8 03 SUB 2FE9 16 AND 2FEA 84 DUP5 2FEB 60 PUSH1 0x01 2FED 60 PUSH1 0x01 2FEF 60 PUSH1 0xa0 2FF1 1B SHL 2FF2 03 SUB 2FF3 16 AND 2FF4 10 LT 2FF5 61 PUSH2 0x2fff 2FF8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2fff, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] label_2FF9: // Incoming jump from 0x2FF8, if not (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @2FF9 stack[-3] // @2FFA stack[-4] // } 2FF9 82 DUP3 2FFA 84 DUP5 2FFB 61 PUSH2 0x3002 2FFE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2FF9 stack[0] = stack[-3] // @2FFA stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x3002 label_2FFF: // Incoming jump from 0x2FF8, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[4] // { // @3000 stack[-4] // @3001 stack[-3] // @3004 stack[-2] // @3006 stack[-1] // } 2FFF 5B JUMPDEST 3000 83 DUP4 3001 83 DUP4 3002 5B JUMPDEST 3003 90 SWAP1 3004 92 SWAP3 3005 50 POP 3006 90 SWAP1 3007 50 POP 3008 60 PUSH1 0x01 300A 60 PUSH1 0x01 300C 60 PUSH1 0xa0 300E 1B SHL 300F 03 SUB 3010 82 DUP3 3011 16 AND 3012 61 PUSH2 0x302d 3015 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3004 stack[-2] = stack[-4] // @3006 stack[-1] = stack[-3] // } // Block ends with conditional jump to 0x302d, if stack[-4] & (0x01 << 0xa0) - 0x01 label_3016: // Incoming jump from 0x3015, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x3015, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3018 memory[0x40:0x60] } 3016 60 PUSH1 0x40 3018 51 MLOAD 3019 62 PUSH3 0x461bcd 301D 60 PUSH1 0xe5 301F 1B SHL 3020 81 DUP2 3021 52 MSTORE 3022 60 PUSH1 0x04 3024 01 ADD 3025 61 PUSH2 0x0840 3028 90 SWAP1 3029 61 PUSH2 0x3b04 302C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3021 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3028 stack[0] = 0x0840 // @3028 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3b04, returns to 0x0840 label_302D: // Incoming jump from 0x3015, if stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x3015, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @302E stack[-4] // @302E stack[-1] // @3030 stack[-5] // @3030 stack[-2] // @3031 stack[-3] // } 302D 5B JUMPDEST 302E 92 SWAP3 302F 50 POP 3030 92 SWAP3 3031 90 SWAP1 3032 50 POP 3033 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @302E stack[-4] = stack[-1] // @3030 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_3034: // Incoming call from 0x2806, returns to 0x2807 // Incoming call from 0x2BC2, returns to 0x2BC3 // Incoming jump from 0x2BCE // Incoming call from 0x2820, returns to 0x2821 // Incoming call from 0x27F2, returns to 0x27F3 // Inputs[1] { @3037 stack[-2] } 3034 5B JUMPDEST 3035 60 PUSH1 0x00 3037 82 DUP3 3038 61 PUSH2 0x3043 303B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3035 stack[0] = 0x00 } // Block ends with conditional jump to 0x3043, if stack[-2] label_303C: // Incoming jump from 0x303B, if not stack[-2] 303C 50 POP 303D 60 PUSH1 0x00 303F 61 PUSH2 0x1cb4 3042 56 *JUMP // Stack delta = +0 // Outputs[1] { @303D stack[-1] = 0x00 } // Block ends with unconditional jump to 0x1cb4 label_3043: // Incoming jump from 0x303B, if stack[-2] // Inputs[2] // { // @3044 stack[-3] // @3045 stack[-2] // } 3043 5B JUMPDEST 3044 82 DUP3 3045 82 DUP3 3046 02 MUL 3047 82 DUP3 3048 84 DUP5 3049 82 DUP3 304A 81 DUP2 304B 61 PUSH2 0x3050 304E 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3046 stack[0] = stack[-2] * stack[-3] // @3047 stack[1] = stack[-2] // @3048 stack[2] = stack[-3] // @3049 stack[3] = stack[-2] * stack[-3] // } // Block ends with conditional jump to 0x3050, if stack[-3] label_304F: // Incoming jump from 0x304E, if not stack[-3] 304F FE *ASSERT // Stack delta = +0 // Outputs[1] { @304F assert(); } // Block terminates label_3050: // Incoming jump from 0x304E, if stack[-3] // Inputs[3] // { // @3051 stack[-1] // @3051 stack[-2] // @3052 stack[-3] // } 3050 5B JUMPDEST 3051 04 DIV 3052 14 EQ 3053 61 PUSH2 0x306e 3056 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x306e, if stack[-1] / stack[-2] == stack[-3] label_3057: // Incoming jump from 0x3056, if not stack[-1] / stack[-2] == stack[-3] // Inputs[1] { @3059 memory[0x40:0x60] } 3057 60 PUSH1 0x40 3059 51 MLOAD 305A 62 PUSH3 0x461bcd 305E 60 PUSH1 0xe5 3060 1B SHL 3061 81 DUP2 3062 52 MSTORE 3063 60 PUSH1 0x04 3065 01 ADD 3066 61 PUSH2 0x0840 3069 90 SWAP1 306A 61 PUSH2 0x3a45 306D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3062 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3069 stack[0] = 0x0840 // @3069 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3a45, returns to 0x0840 label_306E: // Incoming return from call to 0x36DA at 0x37E6 // Incoming jump from 0x3056, if stack[-1] / stack[-2] == stack[-3] // Incoming return from call to 0x3D6C at 0x35EF // Incoming return from call to 0x3277 at 0x325E // Incoming return from call to 0x3D57 at 0x336D // Incoming return from call to 0x3D57 at 0x3351 // Incoming jump from 0x3082, if !(stack[-1] + stack[-2] < stack[-2]) // Incoming return from call to 0x3D6C at 0x360B // Inputs[3] // { // @306F stack[-5] // @306F stack[-1] // @3070 stack[-4] // } 306E 5B JUMPDEST 306F 93 SWAP4 3070 92 SWAP3 3071 50 POP 3072 50 POP 3073 50 POP 3074 56 *JUMP // Stack delta = -4 // Outputs[1] { @306F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_3075: // Incoming jump from 0x282C // Incoming jump from 0x2C05 // Inputs[2] // { // @3078 stack[-2] // @3079 stack[-1] // } 3075 5B JUMPDEST 3076 60 PUSH1 0x00 3078 82 DUP3 3079 82 DUP3 307A 01 ADD 307B 83 DUP4 307C 81 DUP2 307D 10 LT 307E 15 ISZERO 307F 61 PUSH2 0x306e 3082 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3076 stack[0] = 0x00 // @307A stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x306e, if !(stack[-1] + stack[-2] < stack[-2]) label_3083: // Incoming jump from 0x3082, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[1] { @3085 memory[0x40:0x60] } 3083 60 PUSH1 0x40 3085 51 MLOAD 3086 62 PUSH3 0x461bcd 308A 60 PUSH1 0xe5 308C 1B SHL 308D 81 DUP2 308E 52 MSTORE 308F 60 PUSH1 0x04 3091 01 ADD 3092 61 PUSH2 0x0840 3095 90 SWAP1 3096 61 PUSH2 0x389b 3099 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @308E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3095 stack[0] = 0x0840 // @3095 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x389b, returns to 0x0840 label_309A: // Incoming jump from 0x290B // Inputs[5] // { // @309F stack[-4] // @30AE stack[-3] // @30AF stack[-2] // @30B0 stack[-1] // @30B3 memory[0x40:0x60] // } 309A 5B JUMPDEST 309B 60 PUSH1 0x00 309D 60 PUSH1 0x60 309F 85 DUP6 30A0 60 PUSH1 0x01 30A2 60 PUSH1 0x01 30A4 60 PUSH1 0xa0 30A6 1B SHL 30A7 03 SUB 30A8 16 AND 30A9 63 PUSH4 0x23b872dd 30AE 86 DUP7 30AF 86 DUP7 30B0 86 DUP7 30B1 60 PUSH1 0x40 30B3 51 MLOAD 30B4 60 PUSH1 0x24 30B6 01 ADD 30B7 61 PUSH2 0x30c2 30BA 93 SWAP4 30BB 92 SWAP3 30BC 91 SWAP2 30BD 90 SWAP1 30BE 61 PUSH2 0x378c 30C1 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @309B stack[0] = 0x00 // @309D stack[1] = 0x60 // @30A8 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-4] // @30A9 stack[3] = 0x23b872dd // @30BA stack[4] = 0x30c2 // @30BB stack[5] = stack[-3] // @30BC stack[6] = stack[-2] // @30BD stack[7] = stack[-1] // @30BD stack[8] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x378c, returns to 0x30C2 label_30C2: // Incoming return from call to 0x378C at 0x30C1 // Inputs[5] // { // @30C5 memory[0x40:0x60] // @30C9 stack[-1] // @30D2 stack[-2] // @30DB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @30F1 memory[0x40:0x60] // } 30C2 5B JUMPDEST 30C3 60 PUSH1 0x40 30C5 51 MLOAD 30C6 60 PUSH1 0x20 30C8 81 DUP2 30C9 83 DUP4 30CA 03 SUB 30CB 03 SUB 30CC 81 DUP2 30CD 52 MSTORE 30CE 90 SWAP1 30CF 60 PUSH1 0x40 30D1 52 MSTORE 30D2 90 SWAP1 30D3 60 PUSH1 0xe0 30D5 1B SHL 30D6 60 PUSH1 0x20 30D8 82 DUP3 30D9 01 ADD 30DA 80 DUP1 30DB 51 MLOAD 30DC 60 PUSH1 0x01 30DE 60 PUSH1 0x01 30E0 60 PUSH1 0xe0 30E2 1B SHL 30E3 03 SUB 30E4 83 DUP4 30E5 81 DUP2 30E6 83 DUP4 30E7 16 AND 30E8 17 OR 30E9 83 DUP4 30EA 52 MSTORE 30EB 50 POP 30EC 50 POP 30ED 50 POP 30EE 50 POP 30EF 60 PUSH1 0x40 30F1 51 MLOAD 30F2 61 PUSH2 0x30fb 30F5 91 SWAP2 30F6 90 SWAP1 30F7 61 PUSH2 0x3706 30FA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @30CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @30D1 memory[0x40:0x60] = stack[-1] // @30EA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & (0x01 << 0xe0) - 0x01) | (stack[-2] << 0xe0) // @30F5 stack[-2] = 0x30fb // @30F6 stack[0] = memory[0x40:0x60] // @30F6 stack[-1] = memory[0x40:0x60] // } // Block ends with call to 0x3706, returns to 0x30FB label_30FB: // Incoming return from call to 0x3706 at 0x30FA // Inputs[7] // { // @3100 memory[0x40:0x60] // @3102 stack[-1] // @3107 stack[-2] // @3108 msg.gas // @3109 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @3109 address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @310D returndata.length // } 30FB 5B JUMPDEST 30FC 60 PUSH1 0x00 30FE 60 PUSH1 0x40 3100 51 MLOAD 3101 80 DUP1 3102 83 DUP4 3103 03 SUB 3104 81 DUP2 3105 60 PUSH1 0x00 3107 86 DUP7 3108 5A GAS 3109 F1 CALL 310A 91 SWAP2 310B 50 POP 310C 50 POP 310D 3D RETURNDATASIZE 310E 80 DUP1 310F 60 PUSH1 0x00 3111 81 DUP2 3112 14 EQ 3113 61 PUSH2 0x3138 3116 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @3109 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @310A stack[-2] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @310D stack[-1] = returndata.length // @310E stack[0] = returndata.length // } // Block ends with conditional jump to 0x3138, if returndata.length == 0x00 label_3117: // Incoming jump from 0x3116, if not returndata.length == 0x00 // Inputs[6] // { // @3119 memory[0x40:0x60] // @311A stack[-2] // @3121 returndata.length // @3129 returndata.length // @312C returndata.length // @3133 returndata[0x00:0x00 + returndata.length] // } 3117 60 PUSH1 0x40 3119 51 MLOAD 311A 91 SWAP2 311B 50 POP 311C 60 PUSH1 0x1f 311E 19 NOT 311F 60 PUSH1 0x3f 3121 3D RETURNDATASIZE 3122 01 ADD 3123 16 AND 3124 82 DUP3 3125 01 ADD 3126 60 PUSH1 0x40 3128 52 MSTORE 3129 3D RETURNDATASIZE 312A 82 DUP3 312B 52 MSTORE 312C 3D RETURNDATASIZE 312D 60 PUSH1 0x00 312F 60 PUSH1 0x20 3131 84 DUP5 3132 01 ADD 3133 3E RETURNDATACOPY 3134 61 PUSH2 0x313d 3137 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @311A stack[-2] = memory[0x40:0x60] // @3128 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @312B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @3133 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x313d label_3138: // Incoming jump from 0x3116, if returndata.length == 0x00 // Inputs[4] // { // @313B stack[-2] // @313F stack[-4] // @3141 stack[-3] // @3141 stack[-5] // } 3138 5B JUMPDEST 3139 60 PUSH1 0x60 313B 91 SWAP2 313C 50 POP 313D 5B JUMPDEST 313E 50 POP 313F 91 SWAP2 3140 50 POP 3141 91 SWAP2 3142 50 POP 3143 81 DUP2 3144 80 DUP1 3145 15 ISZERO 3146 61 PUSH2 0x3167 3149 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @313F stack[-4] = 0x60 // @3141 stack[-5] = stack[-3] // @3143 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x3167, if !stack[-3] label_314A: // Incoming jump from 0x3149, if not !stack[-3] // Incoming jump from 0x3149, if not !stack[-3] // Inputs[2] // { // @314B stack[-2] // @314C memory[stack[-2]:stack[-2] + 0x20] // } 314A 50 POP 314B 80 DUP1 314C 51 MLOAD 314D 15 ISZERO 314E 80 DUP1 314F 61 PUSH2 0x3167 3152 57 *JUMPI // Stack delta = +0 // Outputs[1] { @314D stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3167, if !memory[stack[-2]:stack[-2] + 0x20] label_3153: // Incoming jump from 0x3152, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @3154 stack[-2] // @315A memory[stack[-2]:stack[-2] + 0x20] // } 3153 50 POP 3154 80 DUP1 3155 80 DUP1 3156 60 PUSH1 0x20 3158 01 ADD 3159 90 SWAP1 315A 51 MLOAD 315B 81 DUP2 315C 01 ADD 315D 90 SWAP1 315E 61 PUSH2 0x3167 3161 91 SWAP2 3162 90 SWAP1 3163 61 PUSH2 0x35f0 3166 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3161 stack[-1] = 0x3167 // @3162 stack[1] = 0x20 + stack[-2] // @3162 stack[0] = 0x20 + stack[-2] + memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x35f0, returns to 0x3167 label_3167: // Incoming jump from 0x3149, if !stack[-3] // Incoming return from call to 0x35F0 at 0x3166 // Incoming jump from 0x3152, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x3149, if !stack[-3] // Inputs[1] { @316B stack[-1] } 3167 5B JUMPDEST 3168 61 PUSH2 0x0f07 316B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f07, if stack[-1] label_316C: // Incoming jump from 0x316B, if not stack[-1] // Inputs[1] { @316E memory[0x40:0x60] } 316C 60 PUSH1 0x40 316E 51 MLOAD 316F 62 PUSH3 0x461bcd 3173 60 PUSH1 0xe5 3175 1B SHL 3176 81 DUP2 3177 52 MSTORE 3178 60 PUSH1 0x04 317A 01 ADD 317B 61 PUSH2 0x0840 317E 90 SWAP1 317F 61 PUSH2 0x3ba9 3182 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3177 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @317E stack[0] = 0x0840 // @317E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3ba9, returns to 0x0840 3183 5B JUMPDEST 3184 60 PUSH1 0x00 3186 80 DUP1 3187 60 PUSH1 0x00 3189 61 PUSH2 0x3193 318C 89 DUP10 318D 89 DUP10 318E 89 DUP10 318F 61 PUSH2 0x26c3 3192 56 *JUMP 3193 5B JUMPDEST 3194 91 SWAP2 3195 50 POP 3196 91 SWAP2 3197 50 POP 3198 61 PUSH2 0x31a2 319B 86 DUP7 319C 83 DUP4 319D 83 DUP4 319E 61 PUSH2 0x2b5e 31A1 56 *JUMP 31A2 5B JUMPDEST 31A3 92 SWAP3 31A4 50 POP 31A5 60 PUSH1 0x00 31A7 83 DUP4 31A8 11 GT 31A9 80 DUP1 31AA 15 ISZERO 31AB 61 PUSH2 0x31b4 31AE 57 *JUMPI 31AF 50 POP 31B0 84 DUP5 31B1 83 DUP4 31B2 11 GT 31B3 15 ISZERO 31B4 5B JUMPDEST 31B5 61 PUSH2 0x31d0 31B8 57 *JUMPI 31B9 60 PUSH1 0x40 31BB 51 MLOAD 31BC 62 PUSH3 0x461bcd 31C0 60 PUSH1 0xe5 31C2 1B SHL 31C3 81 DUP2 31C4 52 MSTORE 31C5 60 PUSH1 0x04 31C7 01 ADD 31C8 61 PUSH2 0x0840 31CB 90 SWAP1 31CC 61 PUSH2 0x3b72 31CF 56 *JUMP 31D0 5B JUMPDEST 31D1 60 PUSH1 0x00 31D3 61 PUSH2 0x31dc 31D6 89 DUP10 31D7 89 DUP10 31D8 61 PUSH2 0x2faa 31DB 56 *JUMP 31DC 5B JUMPDEST 31DD 50 POP 31DE 90 SWAP1 31DF 50 POP 31E0 60 PUSH1 0x00 31E2 80 DUP1 31E3 82 DUP3 31E4 60 PUSH1 0x01 31E6 60 PUSH1 0x01 31E8 60 PUSH1 0xa0 31EA 1B SHL 31EB 03 SUB 31EC 16 AND 31ED 8B DUP12 31EE 60 PUSH1 0x01 31F0 60 PUSH1 0x01 31F2 60 PUSH1 0xa0 31F4 1B SHL 31F5 03 SUB 31F6 16 AND 31F7 14 EQ 31F8 61 PUSH2 0x3203 31FB 57 *JUMPI 31FC 88 DUP9 31FD 60 PUSH1 0x00 31FF 61 PUSH2 0x3207 3202 56 *JUMP 3203 5B JUMPDEST 3204 60 PUSH1 0x00 3206 89 DUP10 3207 5B JUMPDEST 3208 91 SWAP2 3209 50 POP 320A 91 SWAP2 320B 50 POP 320C 61 PUSH2 0x2a86 320F 8B DUP12 3210 8D DUP14 3211 88 DUP9 3212 61 PUSH2 0x290c 3215 56 *JUMP label_3216: // Incoming call from 0x2BE8, returns to 0x2BC3 // Inputs[3] // { // @321C stack[-2] // @321D stack[-1] // @3220 memory[0x40:0x60] // } 3216 5B JUMPDEST 3217 60 PUSH1 0x00 3219 61 PUSH2 0x306e 321C 83 DUP4 321D 83 DUP4 321E 60 PUSH1 0x40 3220 51 MLOAD 3221 80 DUP1 3222 60 PUSH1 0x40 3224 01 ADD 3225 60 PUSH1 0x40 3227 52 MSTORE 3228 80 DUP1 3229 60 PUSH1 0x1e 322B 81 DUP2 322C 52 MSTORE 322D 60 PUSH1 0x20 322F 01 ADD 3230 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 3251 81 DUP2 3252 52 MSTORE 3253 50 POP 3254 60 PUSH1 0x00 3256 81 DUP2 3257 84 DUP5 3258 84 DUP5 3259 11 GT 325A 15 ISZERO 325B 61 PUSH2 0x3277 325E 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @3217 stack[0] = 0x00 // @3219 stack[1] = 0x306e // @321C stack[2] = stack[-2] // @321D stack[3] = stack[-1] // @3220 stack[4] = memory[0x40:0x60] // @3227 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @322C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @3252 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // @3254 stack[5] = 0x00 // @3256 stack[6] = memory[0x40:0x60] // } // Block ends with conditional call to 0x3277, returns to 0x306E, if !(stack[-1] > stack[-2]) label_325F: // Incoming jump from 0x325E, if not !(stack[-1] > stack[-2]) // Inputs[2] // { // @3261 memory[0x40:0x60] // @3271 stack[-1] // } 325F 60 PUSH1 0x40 3261 51 MLOAD 3262 62 PUSH3 0x461bcd 3266 60 PUSH1 0xe5 3268 1B SHL 3269 81 DUP2 326A 52 MSTORE 326B 60 PUSH1 0x04 326D 01 ADD 326E 61 PUSH2 0x0840 3271 91 SWAP2 3272 90 SWAP1 3273 61 PUSH2 0x37d4 3276 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @326A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3271 stack[-1] = 0x0840 // @3272 stack[1] = 0x04 + memory[0x40:0x60] // @3272 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x37d4 label_3277: // Incoming call from 0x325E, returns to 0x306E, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @327B stack[-5] // @327B stack[-4] // @327D stack[-6] // } 3277 5B JUMPDEST 3278 50 POP 3279 50 POP 327A 50 POP 327B 90 SWAP1 327C 03 SUB 327D 90 SWAP1 327E 56 *JUMP // Stack delta = -5 // Outputs[1] { @327D stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_327F: // Incoming call from 0x2C34, returns to 0x2C35 // Incoming call from 0x1C64, returns to 0x1C65 // Incoming call from 0x0CC2, returns to 0x0CC3 // Incoming call from 0x1FB1, returns to 0x1FB2 // Inputs[2] // { // @3283 memory[0x40:0x60] // @32AB stack[-1] // } 327F 5B JUMPDEST 3280 60 PUSH1 0x40 3282 80 DUP1 3283 51 MLOAD 3284 60 PUSH1 0xa0 3286 81 DUP2 3287 01 ADD 3288 82 DUP3 3289 52 MSTORE 328A 60 PUSH1 0x00 328C 80 DUP1 328D 82 DUP3 328E 52 MSTORE 328F 60 PUSH1 0x20 3291 82 DUP3 3292 01 ADD 3293 81 DUP2 3294 90 SWAP1 3295 52 MSTORE 3296 91 SWAP2 3297 81 DUP2 3298 01 ADD 3299 82 DUP3 329A 90 SWAP1 329B 52 MSTORE 329C 60 PUSH1 0x60 329E 81 DUP2 329F 01 ADD 32A0 82 DUP3 32A1 90 SWAP1 32A2 52 MSTORE 32A3 60 PUSH1 0x80 32A5 81 DUP2 32A6 01 ADD 32A7 91 SWAP2 32A8 90 SWAP1 32A9 91 SWAP2 32AA 52 MSTORE 32AB 90 SWAP1 32AC 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @3289 memory[0x40:0x60] = memory[0x40:0x60] + 0xa0 // @328E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @3295 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @329B memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @32A2 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @32AA memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = 0x00 // @32AB stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_32AD: // Incoming call from 0x35C4, returns to 0x35C5 // Incoming call from 0x3441, returns to 0x3442 // Incoming call from 0x3588, returns to 0x3589 // Inputs[2] // { // @32B0 stack[-2] // @32B3 stack[-1] // } 32AD 5B JUMPDEST 32AE 60 PUSH1 0x00 32B0 82 DUP3 32B1 60 PUSH1 0x1f 32B3 83 DUP4 32B4 01 ADD 32B5 12 SLT 32B6 61 PUSH2 0x32bd 32B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @32AE stack[0] = 0x00 } // Block ends with conditional jump to 0x32bd, if stack[-1] + 0x1f i< stack[-2] label_32BA: // Incoming jump from 0x32B9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @32BA stack[-1] // @32BC memory[stack[-1]:stack[-1] + stack[-1]] // } 32BA 80 DUP1 32BB 81 DUP2 32BC FD *REVERT // Stack delta = +0 // Outputs[1] { @32BC revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_32BD: // Incoming jump from 0x32B9, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @32BE stack[-2] // @32BF msg.data[stack[-2]:stack[-2] + 0x20] // } 32BD 5B JUMPDEST 32BE 81 DUP2 32BF 35 CALLDATALOAD 32C0 67 PUSH8 0xffffffffffffffff 32C9 81 DUP2 32CA 11 GT 32CB 15 ISZERO 32CC 61 PUSH2 0x32d3 32CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @32BF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x32d3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_32D0: // Incoming jump from 0x32CF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @32D0 stack[-2] // @32D2 memory[stack[-2]:stack[-2] + stack[-2]] // } 32D0 81 DUP2 32D1 82 DUP3 32D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @32D2 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_32D3: // Incoming jump from 0x32CF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @32D7 stack[-1] } 32D3 5B JUMPDEST 32D4 60 PUSH1 0x20 32D6 80 DUP1 32D7 82 DUP3 32D8 02 MUL 32D9 61 PUSH2 0x32e3 32DC 82 DUP3 32DD 82 DUP3 32DE 01 ADD 32DF 61 PUSH2 0x3d04 32E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @32D4 stack[0] = 0x20 // @32D8 stack[1] = stack[-1] * 0x20 // @32D9 stack[2] = 0x32e3 // @32DE stack[3] = stack[-1] * 0x20 + 0x20 // } // Block ends with call to 0x3d04, returns to 0x32E3 label_32E3: // Incoming return from call to 0x3D04 at 0x32E2 // Inputs[7] // { // @32E4 stack[-4] // @32E5 stack[-1] // @32E7 stack[-5] // @32E9 stack[-3] // @32EC stack[-6] // @32EF stack[-2] // @32F4 stack[-7] // } 32E3 5B JUMPDEST 32E4 83 DUP4 32E5 81 DUP2 32E6 52 MSTORE 32E7 93 SWAP4 32E8 50 POP 32E9 81 DUP2 32EA 84 DUP5 32EB 01 ADD 32EC 85 DUP6 32ED 83 DUP4 32EE 01 ADD 32EF 82 DUP3 32F0 87 DUP8 32F1 01 ADD 32F2 84 DUP5 32F3 01 ADD 32F4 88 DUP9 32F5 10 LT 32F6 15 ISZERO 32F7 61 PUSH2 0x32ff 32FA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @32E6 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @32E7 stack[-5] = stack[-1] // @32EB stack[-1] = stack[-1] + stack[-3] // @32EE stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x32ff, if !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) label_32FB: // Incoming jump from 0x32FA, if not !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) // Inputs[1] { @32FE memory[0x00:0x00] } 32FB 60 PUSH1 0x00 32FD 80 DUP1 32FE FD *REVERT // Stack delta = +0 // Outputs[1] { @32FE revert(memory[0x00:0x00]); } // Block terminates label_32FF: // Incoming jump from 0x32FA, if !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) // Inputs[2] // { // @3302 stack[-3] // @3305 stack[-5] // } 32FF 5B JUMPDEST 3300 60 PUSH1 0x00 3302 92 SWAP3 3303 50 POP 3304 5B JUMPDEST 3305 84 DUP5 3306 83 DUP4 3307 10 LT 3308 15 ISZERO 3309 61 PUSH2 0x332b 330C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3302 stack[-3] = 0x00 } // Block ends with conditional jump to 0x332b, if !(0x00 < stack[-5]) label_330D: // Incoming jump from 0x330C, if not !(0x00 < stack[-5]) // Incoming jump from 0x330C, if not !(stack[-3] < stack[-5]) // Inputs[2] // { // @330D stack[-1] // @330E msg.data[stack[-1]:stack[-1] + 0x20] // } 330D 80 DUP1 330E 35 CALLDATALOAD 330F 61 PUSH2 0x3317 3312 81 DUP2 3313 61 PUSH2 0x3d57 3316 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @330E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @330F stack[1] = 0x3317 // @3312 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x3317 label_3317: // Incoming return from call to 0x3D57 at 0x3316 // Inputs[5] // { // @3318 stack[-3] // @3319 stack[-1] // @331C stack[-4] // @331D stack[-2] // @3322 stack[-5] // } 3317 5B JUMPDEST 3318 82 DUP3 3319 52 MSTORE 331A 60 PUSH1 0x01 331C 92 SWAP3 331D 90 SWAP1 331E 92 SWAP3 331F 01 ADD 3320 91 SWAP2 3321 90 SWAP1 3322 83 DUP4 3323 01 ADD 3324 90 SWAP1 3325 83 DUP4 3326 01 ADD 3327 61 PUSH2 0x3304 332A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3319 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @3320 stack[-4] = 0x01 + stack[-4] // @3324 stack[-3] = stack[-5] + stack[-3] // @3326 stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x3304 label_332B: // Incoming jump from 0x330C, if !(0x00 < stack[-5]) // Incoming jump from 0x330C, if !(stack[-3] < stack[-5]) // Inputs[3] // { // @3331 stack[-6] // @3331 stack[-9] // @3332 stack[-8] // } 332B 5B JUMPDEST 332C 50 POP 332D 50 POP 332E 50 POP 332F 50 POP 3330 50 POP 3331 92 SWAP3 3332 91 SWAP2 3333 50 POP 3334 50 POP 3335 56 *JUMP // Stack delta = -8 // Outputs[1] { @3331 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_3336: // Incoming call from 0x066C, returns to 0x066D // Incoming call from 0x03C4, returns to 0x03C5 // Incoming call from 0x0413, returns to 0x0414 // Incoming call from 0x05A0, returns to 0x05A1 // Incoming call from 0x078D, returns to 0x078E // Incoming call from 0x06AC, returns to 0x06AD // Incoming call from 0x0816, returns to 0x0817 // Incoming call from 0x04CB, returns to 0x04CC // Inputs[2] // { // @333B stack[-1] // @333C stack[-2] // } 3336 5B JUMPDEST 3337 60 PUSH1 0x00 3339 60 PUSH1 0x20 333B 82 DUP3 333C 84 DUP5 333D 03 SUB 333E 12 SLT 333F 15 ISZERO 3340 61 PUSH2 0x3347 3343 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3337 stack[0] = 0x00 } // Block ends with conditional jump to 0x3347, if !(stack[-2] - stack[-1] i< 0x20) label_3344: // Incoming jump from 0x3343, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3344 stack[-1] // @3346 memory[stack[-1]:stack[-1] + stack[-1]] // } 3344 80 DUP1 3345 81 DUP2 3346 FD *REVERT // Stack delta = +0 // Outputs[1] { @3346 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3347: // Incoming jump from 0x3343, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3348 stack[-2] // @3349 msg.data[stack[-2]:stack[-2] + 0x20] // } 3347 5B JUMPDEST 3348 81 DUP2 3349 35 CALLDATALOAD 334A 61 PUSH2 0x306e 334D 81 DUP2 334E 61 PUSH2 0x3d57 3351 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3349 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @334A stack[1] = 0x306e // @334D stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x306E label_3352: // Incoming call from 0x2D1C, returns to 0x2D1D // Incoming call from 0x2CA7, returns to 0x2CA8 // Inputs[2] // { // @3357 stack[-1] // @3358 stack[-2] // } 3352 5B JUMPDEST 3353 60 PUSH1 0x00 3355 60 PUSH1 0x20 3357 82 DUP3 3358 84 DUP5 3359 03 SUB 335A 12 SLT 335B 15 ISZERO 335C 61 PUSH2 0x3363 335F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3353 stack[0] = 0x00 } // Block ends with conditional jump to 0x3363, if !(stack[-2] - stack[-1] i< 0x20) label_3360: // Incoming jump from 0x335F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3360 stack[-1] // @3362 memory[stack[-1]:stack[-1] + stack[-1]] // } 3360 80 DUP1 3361 81 DUP2 3362 FD *REVERT // Stack delta = +0 // Outputs[1] { @3362 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3363: // Incoming jump from 0x335F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3364 stack[-2] // @3365 memory[stack[-2]:stack[-2] + 0x20] // } 3363 5B JUMPDEST 3364 81 DUP2 3365 51 MLOAD 3366 61 PUSH2 0x306e 3369 81 DUP2 336A 61 PUSH2 0x3d57 336D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3365 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @3366 stack[1] = 0x306e // @3369 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x306E label_336E: // Incoming call from 0x034C, returns to 0x034D // Incoming call from 0x06CC, returns to 0x06CD // Inputs[2] // { // @3377 stack[-1] // @3378 stack[-2] // } 336E 5B JUMPDEST 336F 60 PUSH1 0x00 3371 80 DUP1 3372 60 PUSH1 0x00 3374 80 DUP1 3375 60 PUSH1 0x80 3377 85 DUP6 3378 87 DUP8 3379 03 SUB 337A 12 SLT 337B 15 ISZERO 337C 61 PUSH2 0x3383 337F 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @336F stack[0] = 0x00 // @3371 stack[1] = 0x00 // @3372 stack[2] = 0x00 // @3374 stack[3] = 0x00 // } // Block ends with conditional jump to 0x3383, if !(stack[-2] - stack[-1] i< 0x80) label_3380: // Incoming jump from 0x337F, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3380 stack[-3] // @3382 memory[stack[-3]:stack[-3] + stack[-3]] // } 3380 82 DUP3 3381 83 DUP4 3382 FD *REVERT // Stack delta = +0 // Outputs[1] { @3382 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3383: // Incoming jump from 0x337F, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3384 stack[-5] // @3385 msg.data[stack[-5]:stack[-5] + 0x20] // } 3383 5B JUMPDEST 3384 84 DUP5 3385 35 CALLDATALOAD 3386 61 PUSH2 0x338e 3389 81 DUP2 338A 61 PUSH2 0x3d57 338D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3385 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @3386 stack[1] = 0x338e // @3389 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x338E label_338E: // Incoming return from call to 0x3D57 at 0x338D // Inputs[4] // { // @338F stack[-1] // @338F stack[-5] // @3393 stack[-6] // @3395 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 338E 5B JUMPDEST 338F 93 SWAP4 3390 50 POP 3391 60 PUSH1 0x20 3393 85 DUP6 3394 01 ADD 3395 35 CALLDATALOAD 3396 61 PUSH2 0x339e 3399 81 DUP2 339A 61 PUSH2 0x3d57 339D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @338F stack[-5] = stack[-1] // @3395 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @3396 stack[0] = 0x339e // @3399 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x339E label_339E: // Incoming return from call to 0x3D57 at 0x339D // Inputs[4] // { // @339F stack[-4] // @339F stack[-1] // @33A3 stack[-6] // @33A5 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // } 339E 5B JUMPDEST 339F 92 SWAP3 33A0 50 POP 33A1 60 PUSH1 0x40 33A3 85 DUP6 33A4 01 ADD 33A5 35 CALLDATALOAD 33A6 61 PUSH2 0x33ae 33A9 81 DUP2 33AA 61 PUSH2 0x3d57 33AD 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @339F stack[-4] = stack[-1] // @33A5 stack[-1] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @33A6 stack[0] = 0x33ae // @33A9 stack[1] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x33AE label_33AE: // Incoming return from call to 0x3D57 at 0x33AD // Inputs[8] // { // @33AF stack[-5] // @33AF stack[-1] // @33B0 stack[-8] // @33B1 stack[-4] // @33B2 stack[-7] // @33B4 stack[-2] // @33B5 stack[-6] // @33B9 msg.data[0x60 + stack[-6]:0x60 + stack[-6] + 0x20] // } 33AE 5B JUMPDEST 33AF 93 SWAP4 33B0 96 SWAP7 33B1 92 SWAP3 33B2 95 SWAP6 33B3 50 POP 33B4 92 SWAP3 33B5 93 SWAP4 33B6 60 PUSH1 0x60 33B8 01 ADD 33B9 35 CALLDATALOAD 33BA 92 SWAP3 33BB 50 POP 33BC 50 POP 33BD 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @33B0 stack[-8] = stack[-5] // @33B2 stack[-7] = stack[-4] // @33B5 stack[-6] = stack[-1] // @33BA stack[-5] = msg.data[0x60 + stack[-6]:0x60 + stack[-6] + 0x20] // } // Block ends with unconditional jump to stack[-8] label_33BE: // Incoming jump from 0x076D // Inputs[2] // { // @33C6 stack[-1] // @33C7 stack[-2] // } 33BE 5B JUMPDEST 33BF 60 PUSH1 0x00 33C1 80 DUP1 33C2 60 PUSH1 0x00 33C4 60 PUSH1 0x60 33C6 84 DUP5 33C7 86 DUP7 33C8 03 SUB 33C9 12 SLT 33CA 15 ISZERO 33CB 61 PUSH2 0x33d2 33CE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @33BF stack[0] = 0x00 // @33C1 stack[1] = 0x00 // @33C2 stack[2] = 0x00 // } // Block ends with conditional jump to 0x33d2, if !(stack[-2] - stack[-1] i< 0x60) label_33CF: // Incoming jump from 0x33CE, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @33CF stack[-3] // @33D1 memory[stack[-3]:stack[-3] + stack[-3]] // } 33CF 82 DUP3 33D0 83 DUP4 33D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @33D1 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_33D2: // Incoming jump from 0x33CE, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @33D3 stack[-4] // @33D4 msg.data[stack[-4]:stack[-4] + 0x20] // } 33D2 5B JUMPDEST 33D3 83 DUP4 33D4 35 CALLDATALOAD 33D5 61 PUSH2 0x33dd 33D8 81 DUP2 33D9 61 PUSH2 0x3d57 33DC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @33D4 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @33D5 stack[1] = 0x33dd // @33D8 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x33DD label_33DD: // Incoming return from call to 0x3D57 at 0x33DC // Inputs[4] // { // @33DE stack[-4] // @33DE stack[-1] // @33E2 stack[-5] // @33E4 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 33DD 5B JUMPDEST 33DE 92 SWAP3 33DF 50 POP 33E0 60 PUSH1 0x20 33E2 84 DUP5 33E3 01 ADD 33E4 35 CALLDATALOAD 33E5 61 PUSH2 0x33ed 33E8 81 DUP2 33E9 61 PUSH2 0x3d57 33EC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @33DE stack[-4] = stack[-1] // @33E4 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @33E5 stack[0] = 0x33ed // @33E8 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x33ED label_33ED: // Incoming return from call to 0x3D57 at 0x33EC // Incoming return from call to 0x3D57 at 0x36D9 // Inputs[6] // { // @33EE stack[-1] // @33EE stack[-4] // @33EF stack[-7] // @33F1 stack[-6] // @33F7 stack[-5] // @33FB msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 33ED 5B JUMPDEST 33EE 92 SWAP3 33EF 95 SWAP6 33F0 92 SWAP3 33F1 94 SWAP5 33F2 50 POP 33F3 50 POP 33F4 50 POP 33F5 60 PUSH1 0x40 33F7 91 SWAP2 33F8 90 SWAP1 33F9 91 SWAP2 33FA 01 ADD 33FB 35 CALLDATALOAD 33FC 90 SWAP1 33FD 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @33EF stack[-7] = stack[-4] // @33F1 stack[-6] = stack[-1] // @33FC stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_33FE: // Incoming call from 0x0627, returns to 0x0628 // Inputs[2] // { // @3404 stack[-1] // @3405 stack[-2] // } 33FE 5B JUMPDEST 33FF 60 PUSH1 0x00 3401 80 DUP1 3402 60 PUSH1 0x40 3404 83 DUP4 3405 85 DUP6 3406 03 SUB 3407 12 SLT 3408 15 ISZERO 3409 61 PUSH2 0x3410 340C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33FF stack[0] = 0x00 // @3401 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3410, if !(stack[-2] - stack[-1] i< 0x40) label_340D: // Incoming jump from 0x340C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @340D stack[-2] // @340F memory[stack[-2]:stack[-2] + stack[-2]] // } 340D 81 DUP2 340E 82 DUP3 340F FD *REVERT // Stack delta = +0 // Outputs[1] { @340F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3410: // Incoming jump from 0x340C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3411 stack[-3] // @3412 msg.data[stack[-3]:stack[-3] + 0x20] // } 3410 5B JUMPDEST 3411 82 DUP3 3412 35 CALLDATALOAD 3413 61 PUSH2 0x341b 3416 81 DUP2 3417 61 PUSH2 0x3d57 341A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3412 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3413 stack[1] = 0x341b // @3416 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x341B label_341B: // Incoming return from call to 0x3D57 at 0x341A // Inputs[4] // { // @341C stack[-3] // @341C stack[-1] // @3420 stack[-4] // @3422 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 341B 5B JUMPDEST 341C 91 SWAP2 341D 50 POP 341E 60 PUSH1 0x20 3420 83 DUP4 3421 01 ADD 3422 35 CALLDATALOAD 3423 67 PUSH8 0xffffffffffffffff 342C 81 DUP2 342D 11 GT 342E 15 ISZERO 342F 61 PUSH2 0x3436 3432 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @341C stack[-3] = stack[-1] // @3422 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x3436, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_3433: // Incoming jump from 0x3432, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3433 stack[-2] // @3435 memory[stack[-2]:stack[-2] + stack[-2]] // } 3433 81 DUP2 3434 82 DUP3 3435 FD *REVERT // Stack delta = +0 // Outputs[1] { @3435 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3436: // Incoming jump from 0x3432, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @343A stack[-5] // @343B stack[-1] // @343C stack[-4] // } 3436 5B JUMPDEST 3437 61 PUSH2 0x3442 343A 85 DUP6 343B 82 DUP3 343C 86 DUP7 343D 01 ADD 343E 61 PUSH2 0x32ad 3441 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3437 stack[0] = 0x3442 // @343A stack[1] = stack[-5] // @343D stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x32ad, returns to 0x3442 label_3442: // Incoming return from call to 0x32AD at 0x3441 // Inputs[6] // { // @3443 stack[-3] // @3443 stack[-1] // @3446 stack[-6] // @3448 stack[-7] // @3448 stack[-4] // @3449 stack[-5] // } 3442 5B JUMPDEST 3443 91 SWAP2 3444 50 POP 3445 50 POP 3446 92 SWAP3 3447 50 POP 3448 92 SWAP3 3449 90 SWAP1 344A 50 POP 344B 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @3446 stack[-6] = stack[-1] // @3448 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_344C: // Incoming call from 0x030C, returns to 0x030D // Inputs[2] // { // @3452 stack[-1] // @3453 stack[-2] // } 344C 5B JUMPDEST 344D 60 PUSH1 0x00 344F 80 DUP1 3450 60 PUSH1 0x40 3452 83 DUP4 3453 85 DUP6 3454 03 SUB 3455 12 SLT 3456 15 ISZERO 3457 61 PUSH2 0x345e 345A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @344D stack[0] = 0x00 // @344F stack[1] = 0x00 // } // Block ends with conditional jump to 0x345e, if !(stack[-2] - stack[-1] i< 0x40) label_345B: // Incoming jump from 0x345A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @345B stack[-2] // @345D memory[stack[-2]:stack[-2] + stack[-2]] // } 345B 81 DUP2 345C 82 DUP3 345D FD *REVERT // Stack delta = +0 // Outputs[1] { @345D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_345E: // Incoming jump from 0x345A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @345F stack[-3] // @3460 msg.data[stack[-3]:stack[-3] + 0x20] // } 345E 5B JUMPDEST 345F 82 DUP3 3460 35 CALLDATALOAD 3461 61 PUSH2 0x3469 3464 81 DUP2 3465 61 PUSH2 0x3d57 3468 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3460 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3461 stack[1] = 0x3469 // @3464 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x3469 label_3469: // Incoming return from call to 0x3D57 at 0x3468 // Inputs[4] // { // @346A stack[-1] // @346A stack[-3] // @346E stack[-4] // @3471 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } 3469 5B JUMPDEST 346A 91 SWAP2 346B 50 POP 346C 60 PUSH1 0x20 346E 83 DUP4 346F 81 DUP2 3470 01 ADD 3471 35 CALLDATALOAD 3472 67 PUSH8 0xffffffffffffffff 347B 80 DUP1 347C 82 DUP3 347D 11 GT 347E 15 ISZERO 347F 61 PUSH2 0x3486 3482 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @346A stack[-3] = stack[-1] // @346C stack[-1] = 0x20 // @3471 stack[0] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3472 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x3486, if !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) label_3483: // Incoming jump from 0x3482, if not !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3483 stack[-4] // @3485 memory[stack[-4]:stack[-4] + stack[-4]] // } 3483 83 DUP4 3484 84 DUP5 3485 FD *REVERT // Stack delta = +0 // Outputs[1] { @3485 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_3486: // Incoming jump from 0x3482, if !(msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3487 stack[-2] // @3488 stack[-6] // @348A stack[-7] // } 3486 5B JUMPDEST 3487 81 DUP2 3488 86 DUP7 3489 01 ADD 348A 87 DUP8 348B 60 PUSH1 0x1f 348D 82 DUP3 348E 01 ADD 348F 12 SLT 3490 61 PUSH2 0x3497 3493 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3489 stack[0] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x3497, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_3494: // Incoming jump from 0x3493, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @3494 stack[-5] // @3496 memory[stack[-5]:stack[-5] + stack[-5]] // } 3494 84 DUP5 3495 85 DUP6 3496 FD *REVERT // Stack delta = +0 // Outputs[1] { @3496 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_3497: // Incoming jump from 0x3493, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[4] // { // @3498 stack[-1] // @3499 msg.data[stack[-1]:stack[-1] + 0x20] // @349A stack[-3] // @349C stack[-2] // } 3497 5B JUMPDEST 3498 80 DUP1 3499 35 CALLDATALOAD 349A 92 SWAP3 349B 50 POP 349C 81 DUP2 349D 83 DUP4 349E 11 GT 349F 15 ISZERO 34A0 61 PUSH2 0x34a7 34A3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @349A stack[-3] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x34a7, if !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) label_34A4: // Incoming jump from 0x34A3, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) // Inputs[2] // { // @34A4 stack[-5] // @34A6 memory[stack[-5]:stack[-5] + stack[-5]] // } 34A4 84 DUP5 34A5 85 DUP6 34A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @34A6 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_34A7: // Incoming jump from 0x34A3, if !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) // Inputs[2] // { // @34AD stack[-3] // @34B3 stack[-4] // } 34A7 5B JUMPDEST 34A8 61 PUSH2 0x34b9 34AB 60 PUSH1 0x1f 34AD 84 DUP5 34AE 01 ADD 34AF 60 PUSH1 0x1f 34B1 19 NOT 34B2 16 AND 34B3 85 DUP6 34B4 01 ADD 34B5 61 PUSH2 0x3d04 34B8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @34A8 stack[0] = 0x34b9 // @34B4 stack[1] = stack[-4] + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x3d04, returns to 0x34B9 label_34B9: // Incoming return from call to 0x3D04 at 0x34B8 // Inputs[6] // { // @34BA stack[-1] // @34BA stack[-3] // @34BC stack[-4] // @34BF stack[-9] // @34C0 stack[-5] // @34C2 stack[-2] // } 34B9 5B JUMPDEST 34BA 91 SWAP2 34BB 50 POP 34BC 82 DUP3 34BD 82 DUP3 34BE 52 MSTORE 34BF 87 DUP8 34C0 84 DUP5 34C1 84 DUP5 34C2 83 DUP4 34C3 01 ADD 34C4 01 ADD 34C5 11 GT 34C6 15 ISZERO 34C7 61 PUSH2 0x34ce 34CA 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @34BA stack[-3] = stack[-1] // @34BE memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x34ce, if !(stack[-2] + stack[-4] + stack[-5] > stack[-9]) label_34CB: // Incoming jump from 0x34CA, if not !(stack[-2] + stack[-4] + stack[-5] > stack[-9]) // Inputs[2] // { // @34CB stack[-5] // @34CD memory[stack[-5]:stack[-5] + stack[-5]] // } 34CB 84 DUP5 34CC 85 DUP6 34CD FD *REVERT // Stack delta = +0 // Outputs[1] { @34CD revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_34CE: // Incoming jump from 0x34CA, if !(stack[-2] + stack[-4] + stack[-5] > stack[-9]) // Inputs[10] // { // @34CF stack[-3] // @34D0 stack[-4] // @34D1 stack[-1] // @34D4 stack[-2] // @34D6 msg.data[stack[-1] + stack[-4]:stack[-1] + stack[-4] + stack[-3]] // @34DE stack[-5] // @34E2 stack[-6] // @34E3 stack[-9] // @34E5 stack[-8] // @34E7 stack[-7] // } 34CE 5B JUMPDEST 34CF 82 DUP3 34D0 84 DUP5 34D1 82 DUP3 34D2 01 ADD 34D3 85 DUP6 34D4 84 DUP5 34D5 01 ADD 34D6 37 CALLDATACOPY 34D7 50 POP 34D8 90 SWAP1 34D9 81 DUP2 34DA 01 ADD 34DB 90 SWAP1 34DC 91 SWAP2 34DD 01 ADD 34DE 91 SWAP2 34DF 90 SWAP1 34E0 91 SWAP2 34E1 52 MSTORE 34E2 90 SWAP1 34E3 93 SWAP4 34E4 90 SWAP1 34E5 92 SWAP3 34E6 50 POP 34E7 90 SWAP1 34E8 50 POP 34E9 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @34D6 memory[stack[-2] + stack[-4]:stack[-2] + stack[-4] + stack[-3]] = msg.data[stack[-1] + stack[-4]:stack[-1] + stack[-4] + stack[-3]] // @34E1 memory[stack[-4] + stack[-2] + stack[-3]:stack[-4] + stack[-2] + stack[-3] + 0x20] = stack[-5] // @34E3 stack[-9] = stack[-6] // @34E5 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-9] label_34EA: // Incoming call from 0x06DF, returns to 0x06E0 // Incoming call from 0x073A, returns to 0x073B // Incoming call from 0x0456, returns to 0x0457 // Incoming call from 0x06FF, returns to 0x0700 // Inputs[2] // { // @34F0 stack[-1] // @34F1 stack[-2] // } 34EA 5B JUMPDEST 34EB 60 PUSH1 0x00 34ED 80 DUP1 34EE 60 PUSH1 0x40 34F0 83 DUP4 34F1 85 DUP6 34F2 03 SUB 34F3 12 SLT 34F4 15 ISZERO 34F5 61 PUSH2 0x34fc 34F8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34EB stack[0] = 0x00 // @34ED stack[1] = 0x00 // } // Block ends with conditional jump to 0x34fc, if !(stack[-2] - stack[-1] i< 0x40) label_34F9: // Incoming jump from 0x34F8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @34F9 stack[-2] // @34FB memory[stack[-2]:stack[-2] + stack[-2]] // } 34F9 81 DUP2 34FA 82 DUP3 34FB FD *REVERT // Stack delta = +0 // Outputs[1] { @34FB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_34FC: // Incoming jump from 0x34F8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @34FD stack[-3] // @34FE msg.data[stack[-3]:stack[-3] + 0x20] // } 34FC 5B JUMPDEST 34FD 82 DUP3 34FE 35 CALLDATALOAD 34FF 61 PUSH2 0x3507 3502 81 DUP2 3503 61 PUSH2 0x3d57 3506 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34FE stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @34FF stack[1] = 0x3507 // @3502 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x3507 label_3507: // Incoming return from call to 0x3D57 at 0x3506 // Inputs[5] // { // @3508 stack[-1] // @3508 stack[-6] // @350B stack[-4] // @350F msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3510 stack[-5] // } 3507 5B JUMPDEST 3508 94 SWAP5 3509 60 PUSH1 0x20 350B 93 SWAP4 350C 90 SWAP1 350D 93 SWAP4 350E 01 ADD 350F 35 CALLDATALOAD 3510 93 SWAP4 3511 50 POP 3512 50 POP 3513 50 POP 3514 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3508 stack[-6] = stack[-1] // @3510 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_3515: // Incoming call from 0x0727, returns to 0x0728 // Inputs[2] // { // @351D stack[-1] // @351E stack[-2] // } 3515 5B JUMPDEST 3516 60 PUSH1 0x00 3518 80 DUP1 3519 60 PUSH1 0x00 351B 60 PUSH1 0x60 351D 84 DUP5 351E 86 DUP7 351F 03 SUB 3520 12 SLT 3521 15 ISZERO 3522 61 PUSH2 0x3529 3525 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3516 stack[0] = 0x00 // @3518 stack[1] = 0x00 // @3519 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3529, if !(stack[-2] - stack[-1] i< 0x60) label_3526: // Incoming jump from 0x3525, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3526 stack[-3] // @3528 memory[stack[-3]:stack[-3] + stack[-3]] // } 3526 82 DUP3 3527 83 DUP4 3528 FD *REVERT // Stack delta = +0 // Outputs[1] { @3528 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3529: // Incoming jump from 0x3525, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @352A stack[-4] // @352B msg.data[stack[-4]:stack[-4] + 0x20] // } 3529 5B JUMPDEST 352A 83 DUP4 352B 35 CALLDATALOAD 352C 61 PUSH2 0x3534 352F 81 DUP2 3530 61 PUSH2 0x3d57 3533 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @352B stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @352C stack[1] = 0x3534 // @352F stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3d57, returns to 0x3534 label_3534: // Incoming return from call to 0x3D57 at 0x3533 // Inputs[6] // { // @3535 stack[-1] // @3535 stack[-4] // @3539 stack[-5] // @353B msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @353C stack[-3] // @3542 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 3534 5B JUMPDEST 3535 92 SWAP3 3536 50 POP 3537 60 PUSH1 0x20 3539 84 DUP5 353A 01 ADD 353B 35 CALLDATALOAD 353C 91 SWAP2 353D 50 POP 353E 60 PUSH1 0x40 3540 84 DUP5 3541 01 ADD 3542 35 CALLDATALOAD 3543 61 PUSH2 0x354b 3546 81 DUP2 3547 61 PUSH2 0x3d57 354A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3535 stack[-4] = stack[-1] // @353C stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3542 stack[-1] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3543 stack[0] = 0x354b // @3546 stack[1] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x354B label_354B: // Incoming jump from 0x3651, if memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff // Incoming return from call to 0x3D57 at 0x354A // Inputs[7] // { // @354C stack[-1] // @354D stack[-2] // @3550 stack[-5] // @3552 stack[-6] // @3552 stack[-3] // @3554 stack[-4] // @3554 stack[-7] // } 354B 5B JUMPDEST 354C 80 DUP1 354D 91 SWAP2 354E 50 POP 354F 50 POP 3550 92 SWAP3 3551 50 POP 3552 92 SWAP3 3553 50 POP 3554 92 SWAP3 3555 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3550 stack[-5] = stack[-1] // @3552 stack[-6] = stack[-3] // @3554 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3556: // Incoming call from 0x02F9, returns to 0x02FA // Incoming call from 0x0580, returns to 0x0581 // Incoming call from 0x050B, returns to 0x050C // Inputs[2] // { // @355B stack[-1] // @355C stack[-2] // } 3556 5B JUMPDEST 3557 60 PUSH1 0x00 3559 60 PUSH1 0x20 355B 82 DUP3 355C 84 DUP5 355D 03 SUB 355E 12 SLT 355F 15 ISZERO 3560 61 PUSH2 0x3567 3563 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3557 stack[0] = 0x00 } // Block ends with conditional jump to 0x3567, if !(stack[-2] - stack[-1] i< 0x20) label_3564: // Incoming jump from 0x3563, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3564 stack[-1] // @3566 memory[stack[-1]:stack[-1] + stack[-1]] // } 3564 80 DUP1 3565 81 DUP2 3566 FD *REVERT // Stack delta = +0 // Outputs[1] { @3566 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3567: // Incoming jump from 0x3563, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3568 stack[-2] // @3569 msg.data[stack[-2]:stack[-2] + 0x20] // } 3567 5B JUMPDEST 3568 81 DUP2 3569 35 CALLDATALOAD 356A 67 PUSH8 0xffffffffffffffff 3573 81 DUP2 3574 11 GT 3575 15 ISZERO 3576 61 PUSH2 0x357d 3579 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3569 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x357d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_357A: // Incoming jump from 0x3579, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @357A stack[-2] // @357C memory[stack[-2]:stack[-2] + stack[-2]] // } 357A 81 DUP2 357B 82 DUP3 357C FD *REVERT // Stack delta = +0 // Outputs[1] { @357C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_357D: // Incoming jump from 0x3579, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3581 stack[-4] // @3582 stack[-1] // @3583 stack[-3] // } 357D 5B JUMPDEST 357E 61 PUSH2 0x3589 3581 84 DUP5 3582 82 DUP3 3583 85 DUP6 3584 01 ADD 3585 61 PUSH2 0x32ad 3588 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @357E stack[0] = 0x3589 // @3581 stack[1] = stack[-4] // @3584 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x32ad, returns to 0x3589 label_3589: // Incoming return from call to 0x32AD at 0x3588 // Inputs[3] // { // @358A stack[-1] // @358A stack[-6] // @358B stack[-5] // } 3589 5B JUMPDEST 358A 94 SWAP5 358B 93 SWAP4 358C 50 POP 358D 50 POP 358E 50 POP 358F 50 POP 3590 56 *JUMP // Stack delta = -5 // Outputs[1] { @358A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3591: // Incoming call from 0x04EB, returns to 0x04EC // Inputs[2] // { // @3597 stack[-1] // @3598 stack[-2] // } 3591 5B JUMPDEST 3592 60 PUSH1 0x00 3594 80 DUP1 3595 60 PUSH1 0x40 3597 83 DUP4 3598 85 DUP6 3599 03 SUB 359A 12 SLT 359B 15 ISZERO 359C 61 PUSH2 0x35a3 359F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3592 stack[0] = 0x00 // @3594 stack[1] = 0x00 // } // Block ends with conditional jump to 0x35a3, if !(stack[-2] - stack[-1] i< 0x40) label_35A0: // Incoming jump from 0x359F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @35A0 stack[-2] // @35A2 memory[stack[-2]:stack[-2] + stack[-2]] // } 35A0 81 DUP2 35A1 82 DUP3 35A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @35A2 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_35A3: // Incoming jump from 0x359F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @35A4 stack[-3] // @35A5 msg.data[stack[-3]:stack[-3] + 0x20] // } 35A3 5B JUMPDEST 35A4 82 DUP3 35A5 35 CALLDATALOAD 35A6 67 PUSH8 0xffffffffffffffff 35AF 81 DUP2 35B0 11 GT 35B1 15 ISZERO 35B2 61 PUSH2 0x35b9 35B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35A5 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x35b9, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_35B6: // Incoming jump from 0x35B5, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @35B6 stack[-3] // @35B8 memory[stack[-3]:stack[-3] + stack[-3]] // } 35B6 82 DUP3 35B7 83 DUP4 35B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @35B8 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_35B9: // Incoming jump from 0x35B5, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @35BD stack[-5] // @35BE stack[-1] // @35BF stack[-4] // } 35B9 5B JUMPDEST 35BA 61 PUSH2 0x35c5 35BD 85 DUP6 35BE 82 DUP3 35BF 86 DUP7 35C0 01 ADD 35C1 61 PUSH2 0x32ad 35C4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @35BA stack[0] = 0x35c5 // @35BD stack[1] = stack[-5] // @35C0 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x32ad, returns to 0x35C5 label_35C5: // Incoming return from call to 0x32AD at 0x35C4 // Inputs[5] // { // @35C6 stack[-1] // @35C6 stack[-7] // @35C9 stack[-5] // @35CD msg.data[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // @35CE stack[-6] // } 35C5 5B JUMPDEST 35C6 95 SWAP6 35C7 60 PUSH1 0x20 35C9 94 SWAP5 35CA 90 SWAP1 35CB 94 SWAP5 35CC 01 ADD 35CD 35 CALLDATALOAD 35CE 94 SWAP5 35CF 50 POP 35D0 50 POP 35D1 50 POP 35D2 50 POP 35D3 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @35C6 stack[-7] = stack[-1] // @35CE stack[-6] = msg.data[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_35D4: // Incoming call from 0x05D5, returns to 0x05D6 // Incoming call from 0x07F6, returns to 0x07F7 // Incoming call from 0x032C, returns to 0x032D // Inputs[2] // { // @35D9 stack[-1] // @35DA stack[-2] // } 35D4 5B JUMPDEST 35D5 60 PUSH1 0x00 35D7 60 PUSH1 0x20 35D9 82 DUP3 35DA 84 DUP5 35DB 03 SUB 35DC 12 SLT 35DD 15 ISZERO 35DE 61 PUSH2 0x35e5 35E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35D5 stack[0] = 0x00 } // Block ends with conditional jump to 0x35e5, if !(stack[-2] - stack[-1] i< 0x20) label_35E2: // Incoming jump from 0x35E1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @35E2 stack[-1] // @35E4 memory[stack[-1]:stack[-1] + stack[-1]] // } 35E2 80 DUP1 35E3 81 DUP2 35E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @35E4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_35E5: // Incoming jump from 0x35E1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @35E6 stack[-2] // @35E7 msg.data[stack[-2]:stack[-2] + 0x20] // } 35E5 5B JUMPDEST 35E6 81 DUP2 35E7 35 CALLDATALOAD 35E8 61 PUSH2 0x306e 35EB 81 DUP2 35EC 61 PUSH2 0x3d6c 35EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @35E7 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @35E8 stack[1] = 0x306e // @35EB stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d6c, returns to 0x306E label_35F0: // Incoming call from 0x29D6, returns to 0x29D7 // Incoming call from 0x3166, returns to 0x3167 // Inputs[2] // { // @35F5 stack[-1] // @35F6 stack[-2] // } 35F0 5B JUMPDEST 35F1 60 PUSH1 0x00 35F3 60 PUSH1 0x20 35F5 82 DUP3 35F6 84 DUP5 35F7 03 SUB 35F8 12 SLT 35F9 15 ISZERO 35FA 61 PUSH2 0x3601 35FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35F1 stack[0] = 0x00 } // Block ends with conditional jump to 0x3601, if !(stack[-2] - stack[-1] i< 0x20) label_35FE: // Incoming jump from 0x35FD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @35FE stack[-1] // @3600 memory[stack[-1]:stack[-1] + stack[-1]] // } 35FE 80 DUP1 35FF 81 DUP2 3600 FD *REVERT // Stack delta = +0 // Outputs[1] { @3600 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3601: // Incoming jump from 0x35FD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3602 stack[-2] // @3603 memory[stack[-2]:stack[-2] + 0x20] // } 3601 5B JUMPDEST 3602 81 DUP2 3603 51 MLOAD 3604 61 PUSH2 0x306e 3607 81 DUP2 3608 61 PUSH2 0x3d6c 360B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3603 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @3604 stack[1] = 0x306e // @3607 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3d6c, returns to 0x306E label_360C: // Incoming call from 0x2748, returns to 0x2749 // Inputs[2] // { // @3614 stack[-1] // @3615 stack[-2] // } 360C 5B JUMPDEST 360D 60 PUSH1 0x00 360F 80 DUP1 3610 60 PUSH1 0x00 3612 60 PUSH1 0x60 3614 84 DUP5 3615 86 DUP7 3616 03 SUB 3617 12 SLT 3618 15 ISZERO 3619 61 PUSH2 0x3620 361C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @360D stack[0] = 0x00 // @360F stack[1] = 0x00 // @3610 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3620, if !(stack[-2] - stack[-1] i< 0x60) label_361D: // Incoming jump from 0x361C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @361D stack[-3] // @361F memory[stack[-3]:stack[-3] + stack[-3]] // } 361D 82 DUP3 361E 83 DUP4 361F FD *REVERT // Stack delta = +0 // Outputs[1] { @361F revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3620: // Incoming jump from 0x361C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3621 stack[-4] // @3622 memory[stack[-4]:stack[-4] + 0x20] // } 3620 5B JUMPDEST 3621 83 DUP4 3622 51 MLOAD 3623 61 PUSH2 0x362b 3626 81 DUP2 3627 61 PUSH2 0x3d7a 362A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3622 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3623 stack[1] = 0x362b // @3626 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3d7a, returns to 0x362B label_362B: // Incoming return from call to 0x3D7A at 0x362A // Inputs[4] // { // @362E stack[-5] // @3630 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3631 stack[-1] // @3632 stack[-4] // } 362B 5B JUMPDEST 362C 60 PUSH1 0x20 362E 85 DUP6 362F 01 ADD 3630 51 MLOAD 3631 90 SWAP1 3632 93 SWAP4 3633 50 POP 3634 61 PUSH2 0x363c 3637 81 DUP2 3638 61 PUSH2 0x3d7a 363B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3631 stack[-1] = memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3632 stack[-4] = stack[-1] // @3634 stack[0] = 0x363c // @3637 stack[1] = memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3d7a, returns to 0x363C label_363C: // Incoming return from call to 0x3D7A at 0x363B // Inputs[4] // { // @363F stack[-5] // @3641 memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3642 stack[-1] // @3643 stack[-3] // } 363C 5B JUMPDEST 363D 60 PUSH1 0x40 363F 85 DUP6 3640 01 ADD 3641 51 MLOAD 3642 90 SWAP1 3643 92 SWAP3 3644 50 POP 3645 63 PUSH4 0xffffffff 364A 81 DUP2 364B 16 AND 364C 81 DUP2 364D 14 EQ 364E 61 PUSH2 0x354b 3651 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3642 stack[-1] = memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3643 stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x354b, if memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff label_3652: // Incoming jump from 0x3651, if not memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff // Inputs[2] // { // @3652 stack[-2] // @3654 memory[stack[-2]:stack[-2] + stack[-2]] // } 3652 81 DUP2 3653 82 DUP3 3654 FD *REVERT // Stack delta = +0 // Outputs[1] { @3654 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3655: // Incoming call from 0x0476, returns to 0x0477 // Incoming call from 0x03A4, returns to 0x03A5 // Incoming call from 0x074D, returns to 0x074E // Incoming call from 0x07AD, returns to 0x07AE // Incoming call from 0x068C, returns to 0x068D // Inputs[2] // { // @365A stack[-1] // @365B stack[-2] // } 3655 5B JUMPDEST 3656 60 PUSH1 0x00 3658 60 PUSH1 0x20 365A 82 DUP3 365B 84 DUP5 365C 03 SUB 365D 12 SLT 365E 15 ISZERO 365F 61 PUSH2 0x3666 3662 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3656 stack[0] = 0x00 } // Block ends with conditional jump to 0x3666, if !(stack[-2] - stack[-1] i< 0x20) label_3663: // Incoming jump from 0x3662, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3663 stack[-1] // @3665 memory[stack[-1]:stack[-1] + stack[-1]] // } 3663 80 DUP1 3664 81 DUP2 3665 FD *REVERT // Stack delta = +0 // Outputs[1] { @3665 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3666: // Incoming jump from 0x3662, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3668 stack[-2] // @3668 msg.data[stack[-2]:stack[-2] + 0x20] // @3669 stack[-4] // @366A stack[-3] // } 3666 5B JUMPDEST 3667 50 POP 3668 35 CALLDATALOAD 3669 91 SWAP2 366A 90 SWAP1 366B 50 POP 366C 56 *JUMP // Stack delta = -3 // Outputs[1] { @3669 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_366D: // Incoming call from 0x262B, returns to 0x262C // Incoming call from 0x2543, returns to 0x2544 // Incoming call from 0x1ED4, returns to 0x1ED5 // Incoming call from 0x14F5, returns to 0x14F6 // Incoming call from 0x1186, returns to 0x1187 // Incoming call from 0x08C9, returns to 0x08CA // Incoming call from 0x22A5, returns to 0x22A6 // Incoming call from 0x0FE1, returns to 0x0FE2 // Incoming call from 0x245B, returns to 0x245C // Incoming call from 0x2373, returns to 0x2374 // Incoming call from 0x1617, returns to 0x1618 // Inputs[2] // { // @3672 stack[-1] // @3673 stack[-2] // } 366D 5B JUMPDEST 366E 60 PUSH1 0x00 3670 60 PUSH1 0x20 3672 82 DUP3 3673 84 DUP5 3674 03 SUB 3675 12 SLT 3676 15 ISZERO 3677 61 PUSH2 0x367e 367A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @366E stack[0] = 0x00 } // Block ends with conditional jump to 0x367e, if !(stack[-2] - stack[-1] i< 0x20) label_367B: // Incoming jump from 0x367A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @367B stack[-1] // @367D memory[stack[-1]:stack[-1] + stack[-1]] // } 367B 80 DUP1 367C 81 DUP2 367D FD *REVERT // Stack delta = +0 // Outputs[1] { @367D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_367E: // Incoming jump from 0x367A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3680 memory[stack[-2]:stack[-2] + 0x20] // @3680 stack[-2] // @3681 stack[-4] // @3682 stack[-3] // } 367E 5B JUMPDEST 367F 50 POP 3680 51 MLOAD 3681 91 SWAP2 3682 90 SWAP1 3683 50 POP 3684 56 *JUMP // Stack delta = -3 // Outputs[1] { @3681 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_3685: // Incoming call from 0x0443, returns to 0x0444 // Incoming call from 0x02D7, returns to 0x02D8 // Inputs[2] // { // @368B stack[-1] // @368C stack[-2] // } 3685 5B JUMPDEST 3686 60 PUSH1 0x00 3688 80 DUP1 3689 60 PUSH1 0x40 368B 83 DUP4 368C 85 DUP6 368D 03 SUB 368E 12 SLT 368F 15 ISZERO 3690 61 PUSH2 0x3697 3693 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3686 stack[0] = 0x00 // @3688 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3697, if !(stack[-2] - stack[-1] i< 0x40) label_3694: // Incoming jump from 0x3693, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3694 stack[-2] // @3696 memory[stack[-2]:stack[-2] + stack[-2]] // } 3694 81 DUP2 3695 82 DUP3 3696 FD *REVERT // Stack delta = +0 // Outputs[1] { @3696 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3697: // Incoming jump from 0x3693, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @3698 stack[-3] // @3699 msg.data[stack[-3]:stack[-3] + 0x20] // @369A stack[-2] // @36A0 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 3697 5B JUMPDEST 3698 82 DUP3 3699 35 CALLDATALOAD 369A 91 SWAP2 369B 50 POP 369C 60 PUSH1 0x20 369E 83 DUP4 369F 01 ADD 36A0 35 CALLDATALOAD 36A1 61 PUSH2 0x36a9 36A4 81 DUP2 36A5 61 PUSH2 0x3d57 36A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @369A stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @36A0 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @36A1 stack[1] = 0x36a9 // @36A4 stack[2] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x36A9 label_36A9: // Incoming return from call to 0x3D57 at 0x36A8 // Inputs[6] // { // @36AA stack[-1] // @36AB stack[-2] // @36AE stack[-5] // @36B0 stack[-3] // @36B0 stack[-6] // @36B1 stack[-4] // } 36A9 5B JUMPDEST 36AA 80 DUP1 36AB 91 SWAP2 36AC 50 POP 36AD 50 POP 36AE 92 SWAP3 36AF 50 POP 36B0 92 SWAP3 36B1 90 SWAP1 36B2 50 POP 36B3 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @36AE stack[-5] = stack[-1] // @36B0 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_36B4: // Incoming call from 0x04AB, returns to 0x04AC // Incoming call from 0x052B, returns to 0x052C // Incoming call from 0x054B, returns to 0x054C // Inputs[2] // { // @36BC stack[-1] // @36BD stack[-2] // } 36B4 5B JUMPDEST 36B5 60 PUSH1 0x00 36B7 80 DUP1 36B8 60 PUSH1 0x00 36BA 60 PUSH1 0x60 36BC 84 DUP5 36BD 86 DUP7 36BE 03 SUB 36BF 12 SLT 36C0 15 ISZERO 36C1 61 PUSH2 0x36c8 36C4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @36B5 stack[0] = 0x00 // @36B7 stack[1] = 0x00 // @36B8 stack[2] = 0x00 // } // Block ends with conditional jump to 0x36c8, if !(stack[-2] - stack[-1] i< 0x60) label_36C5: // Incoming jump from 0x36C4, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @36C5 stack[-1] // @36C7 memory[stack[-1]:stack[-1] + stack[-1]] // } 36C5 80 DUP1 36C6 81 DUP2 36C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @36C7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_36C8: // Incoming jump from 0x36C4, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[4] // { // @36C9 stack[-4] // @36CA msg.data[stack[-4]:stack[-4] + 0x20] // @36CB stack[-3] // @36D1 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 36C8 5B JUMPDEST 36C9 83 DUP4 36CA 35 CALLDATALOAD 36CB 92 SWAP3 36CC 50 POP 36CD 60 PUSH1 0x20 36CF 84 DUP5 36D0 01 ADD 36D1 35 CALLDATALOAD 36D2 61 PUSH2 0x33ed 36D5 81 DUP2 36D6 61 PUSH2 0x3d57 36D9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @36CB stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @36D1 stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @36D2 stack[1] = 0x33ed // @36D5 stack[2] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x3d57, returns to 0x33ED label_36DA: // Incoming call from 0x37E6, returns to 0x306E // Incoming call from 0x3CB2, returns to 0x2C06 // Inputs[3] // { // @36DD stack[-1] // @36DE memory[stack[-1]:stack[-1] + 0x20] // @36E0 stack[-2] // } 36DA 5B JUMPDEST 36DB 60 PUSH1 0x00 36DD 81 DUP2 36DE 51 MLOAD 36DF 80 DUP1 36E0 84 DUP5 36E1 52 MSTORE 36E2 61 PUSH2 0x36f2 36E5 81 DUP2 36E6 60 PUSH1 0x20 36E8 86 DUP7 36E9 01 ADD 36EA 60 PUSH1 0x20 36EC 86 DUP7 36ED 01 ADD 36EE 61 PUSH2 0x3d2b 36F1 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @36DB stack[0] = 0x00 // @36DE stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @36E1 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @36E2 stack[2] = 0x36f2 // @36E5 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @36E9 stack[4] = stack[-2] + 0x20 // @36ED stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x3d2b, returns to 0x36F2 label_36F2: // Incoming return from call to 0x3D2B at 0x36F1 // Inputs[4] // { // @36F5 stack[-1] // @36FA stack[-4] // @36FB stack[-2] // @3701 stack[-5] // } 36F2 5B JUMPDEST 36F3 60 PUSH1 0x1f 36F5 01 ADD 36F6 60 PUSH1 0x1f 36F8 19 NOT 36F9 16 AND 36FA 92 SWAP3 36FB 90 SWAP1 36FC 92 SWAP3 36FD 01 ADD 36FE 60 PUSH1 0x20 3700 01 ADD 3701 92 SWAP3 3702 91 SWAP2 3703 50 POP 3704 50 POP 3705 56 *JUMP // Stack delta = -4 // Outputs[1] { @3701 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_3706: // Incoming call from 0x0BEB, returns to 0x0BEC // Incoming call from 0x296A, returns to 0x296B // Incoming call from 0x30FA, returns to 0x30FB // Inputs[3] // { // @3709 stack[-2] // @370A memory[stack[-2]:stack[-2] + 0x20] // @370F stack[-1] // } 3706 5B JUMPDEST 3707 60 PUSH1 0x00 3709 82 DUP3 370A 51 MLOAD 370B 61 PUSH2 0x3718 370E 81 DUP2 370F 84 DUP5 3710 60 PUSH1 0x20 3712 87 DUP8 3713 01 ADD 3714 61 PUSH2 0x3d2b 3717 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3707 stack[0] = 0x00 // @370A stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @370B stack[2] = 0x3718 // @370E stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @370F stack[4] = stack[-1] // @3713 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x3d2b, returns to 0x3718 label_3718: // Incoming return from call to 0x3D2B at 0x3717 // Inputs[5] // { // @3719 stack[-1] // @3719 stack[-3] // @371A stack[-2] // @371D stack[-5] // @371E stack[-4] // } 3718 5B JUMPDEST 3719 91 SWAP2 371A 90 SWAP1 371B 91 SWAP2 371C 01 ADD 371D 92 SWAP3 371E 91 SWAP2 371F 50 POP 3720 50 POP 3721 56 *JUMP // Stack delta = -4 // Outputs[1] { @371D stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_3722: // Incoming call from 0x1030, returns to 0x1031 // Incoming call from 0x0A31, returns to 0x0A32 // Incoming call from 0x1DED, returns to 0x1DEE // Incoming call from 0x094D, returns to 0x094E // Incoming call from 0x1316, returns to 0x1317 // Incoming call from 0x1DED, returns to 0x1DEE // Inputs[2] // { // @3723 stack[-1] // @3723 stack[-2] // } 3722 5B JUMPDEST 3723 90 SWAP1 3724 56 *JUMP // Stack delta = -1 // Outputs[1] { @3723 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_3725: // Incoming call from 0x2323, returns to 0x2324 // Incoming call from 0x2255, returns to 0x2256 // Incoming call from 0x240B, returns to 0x240C // Incoming call from 0x25DB, returns to 0x25DC // Incoming call from 0x03F8, returns to 0x035F // Incoming call from 0x24F3, returns to 0x24F4 // Incoming call from 0x0F91, returns to 0x0F92 // Incoming call from 0x1E84, returns to 0x1E85 // Incoming call from 0x0879, returns to 0x087A // Incoming call from 0x15C7, returns to 0x15C8 // Incoming call from 0x14A5, returns to 0x14A6 // Incoming call from 0x1136, returns to 0x1137 // Inputs[3] // { // @372E stack[-2] // @372F stack[-1] // @3737 stack[-3] // } 3725 5B JUMPDEST 3726 60 PUSH1 0x01 3728 60 PUSH1 0x01 372A 60 PUSH1 0xa0 372C 1B SHL 372D 03 SUB 372E 91 SWAP2 372F 90 SWAP1 3730 91 SWAP2 3731 16 AND 3732 81 DUP2 3733 52 MSTORE 3734 60 PUSH1 0x20 3736 01 ADD 3737 90 SWAP1 3738 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3733 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @3737 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 3739 5B JUMPDEST 373A 60 PUSH1 0x01 373C 60 PUSH1 0x01 373E 60 PUSH1 0xa0 3740 1B SHL 3741 03 SUB 3742 92 SWAP3 3743 83 DUP4 3744 16 AND 3745 81 DUP2 3746 52 MSTORE 3747 91 SWAP2 3748 16 AND 3749 60 PUSH1 0x20 374B 82 DUP3 374C 01 ADD 374D 52 MSTORE 374E 60 PUSH1 0x40 3750 01 ADD 3751 90 SWAP1 3752 56 *JUMP 3753 5B JUMPDEST 3754 60 PUSH1 0x01 3756 60 PUSH1 0x01 3758 60 PUSH1 0xa0 375A 1B SHL 375B 03 SUB 375C 96 SWAP7 375D 87 DUP8 375E 16 AND 375F 81 DUP2 3760 52 MSTORE 3761 94 SWAP5 3762 86 DUP7 3763 16 AND 3764 60 PUSH1 0x20 3766 86 DUP7 3767 01 ADD 3768 52 MSTORE 3769 92 SWAP3 376A 90 SWAP1 376B 94 SWAP5 376C 16 AND 376D 60 PUSH1 0x40 376F 84 DUP5 3770 01 ADD 3771 52 MSTORE 3772 60 PUSH1 0x60 3774 83 DUP4 3775 01 ADD 3776 52 MSTORE 3777 60 PUSH1 0x80 3779 82 DUP3 377A 01 ADD 377B 92 SWAP3 377C 90 SWAP1 377D 92 SWAP3 377E 52 MSTORE 377F 90 SWAP1 3780 15 ISZERO 3781 15 ISZERO 3782 60 PUSH1 0xa0 3784 82 DUP3 3785 01 ADD 3786 52 MSTORE 3787 60 PUSH1 0xc0 3789 01 ADD 378A 90 SWAP1 378B 56 *JUMP label_378C: // Incoming call from 0x30C1, returns to 0x30C2 // Inputs[5] // { // @3795 stack[-4] // @3798 stack[-1] // @379A stack[-3] // @379B stack[-2] // @37AE stack[-5] // } 378C 5B JUMPDEST 378D 60 PUSH1 0x01 378F 60 PUSH1 0x01 3791 60 PUSH1 0xa0 3793 1B SHL 3794 03 SUB 3795 93 SWAP4 3796 84 DUP5 3797 16 AND 3798 81 DUP2 3799 52 MSTORE 379A 91 SWAP2 379B 90 SWAP1 379C 92 SWAP3 379D 16 AND 379E 60 PUSH1 0x20 37A0 82 DUP3 37A1 01 ADD 37A2 52 MSTORE 37A3 60 PUSH1 0x40 37A5 81 DUP2 37A6 01 ADD 37A7 91 SWAP2 37A8 90 SWAP1 37A9 91 SWAP2 37AA 52 MSTORE 37AB 60 PUSH1 0x60 37AD 01 ADD 37AE 90 SWAP1 37AF 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @3799 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @37A2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @37AA memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-2] // @37AE stack[-5] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-5] label_37B0: // Incoming call from 0x2931, returns to 0x2932 // Inputs[4] // { // @37B9 stack[-3] // @37BA stack[-1] // @37C3 stack[-2] // @37C7 stack[-4] // } 37B0 5B JUMPDEST 37B1 60 PUSH1 0x01 37B3 60 PUSH1 0x01 37B5 60 PUSH1 0xa0 37B7 1B SHL 37B8 03 SUB 37B9 92 SWAP3 37BA 90 SWAP1 37BB 92 SWAP3 37BC 16 AND 37BD 82 DUP3 37BE 52 MSTORE 37BF 60 PUSH1 0x20 37C1 82 DUP3 37C2 01 ADD 37C3 52 MSTORE 37C4 60 PUSH1 0x40 37C6 01 ADD 37C7 90 SWAP1 37C8 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @37BE memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @37C3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-2] // @37C7 stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_37C9: // Incoming call from 0x03D6, returns to 0x035F // Inputs[3] // { // @37CA stack[-2] // @37CA stack[-1] // @37D2 stack[-3] // } 37C9 5B JUMPDEST 37CA 90 SWAP1 37CB 15 ISZERO 37CC 15 ISZERO 37CD 81 DUP2 37CE 52 MSTORE 37CF 60 PUSH1 0x20 37D1 01 ADD 37D2 90 SWAP1 37D3 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @37CE memory[stack[-1]:stack[-1] + 0x20] = !!stack[-2] // @37D2 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_37D4: // Incoming jump from 0x3276 // Inputs[2] // { // @37D9 stack[-1] // @37E2 stack[-2] // } 37D4 5B JUMPDEST 37D5 60 PUSH1 0x00 37D7 60 PUSH1 0x20 37D9 82 DUP3 37DA 52 MSTORE 37DB 61 PUSH2 0x306e 37DE 60 PUSH1 0x20 37E0 83 DUP4 37E1 01 ADD 37E2 84 DUP5 37E3 61 PUSH2 0x36da 37E6 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @37D5 stack[0] = 0x00 // @37DA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @37DB stack[1] = 0x306e // @37E1 stack[2] = stack[-1] + 0x20 // @37E2 stack[3] = stack[-2] // } // Block ends with call to 0x36da, returns to 0x306E label_37E7: // Incoming call from 0x29F2, returns to 0x0840 // Inputs[2] // { // @37EB stack[-1] // @381C stack[-2] // } 37E7 5B JUMPDEST 37E8 60 PUSH1 0x20 37EA 80 DUP1 37EB 82 DUP3 37EC 52 MSTORE 37ED 60 PUSH1 0x1f 37EF 90 SWAP1 37F0 82 DUP3 37F1 01 ADD 37F2 52 MSTORE 37F3 7F PUSH32 0x5472616e7366657248656c7065723a205452414e534645525f4641494c454400 3814 60 PUSH1 0x40 3816 82 DUP3 3817 01 ADD 3818 52 MSTORE 3819 60 PUSH1 0x60 381B 01 ADD 381C 90 SWAP1 381D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @37EC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @37F2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1f // @3818 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x5472616e7366657248656c7065723a205452414e534645525f4641494c454400 // @381C stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_381E: // Incoming call from 0x2A3F, returns to 0x0840 // Inputs[2] // { // @3822 stack[-1] // @3853 stack[-2] // } 381E 5B JUMPDEST 381F 60 PUSH1 0x20 3821 80 DUP1 3822 82 DUP3 3823 52 MSTORE 3824 60 PUSH1 0x1c 3826 90 SWAP1 3827 82 DUP3 3828 01 ADD 3829 52 MSTORE 382A 7F PUSH32 0x556e69537761704578616374496e20616d6f756e744f7574206c6f7700000000 384B 60 PUSH1 0x40 384D 82 DUP3 384E 01 ADD 384F 52 MSTORE 3850 60 PUSH1 0x60 3852 01 ADD 3853 90 SWAP1 3854 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3823 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3829 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1c // @384F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e69537761704578616374496e20616d6f756e744f7574206c6f7700000000 // @3853 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3855: // Incoming call from 0x2F4E, returns to 0x0840 // Inputs[2] // { // @3859 stack[-1] // @3899 stack[-2] // } 3855 5B JUMPDEST 3856 60 PUSH1 0x20 3858 80 DUP1 3859 82 DUP3 385A 52 MSTORE 385B 60 PUSH1 0x26 385D 90 SWAP1 385E 82 DUP3 385F 01 ADD 3860 52 MSTORE 3861 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 3882 60 PUSH1 0x40 3884 82 DUP3 3885 01 ADD 3886 52 MSTORE 3887 65 PUSH6 0x646472657373 388E 60 PUSH1 0xd0 3890 1B SHL 3891 60 PUSH1 0x60 3893 82 DUP3 3894 01 ADD 3895 52 MSTORE 3896 60 PUSH1 0x80 3898 01 ADD 3899 90 SWAP1 389A 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @385A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3860 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x26 // @3886 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @3895 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x646472657373 << 0xd0 // @3899 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_389B: // Incoming call from 0x3099, returns to 0x0840 // Inputs[2] // { // @389F stack[-1] // @38D0 stack[-2] // } 389B 5B JUMPDEST 389C 60 PUSH1 0x20 389E 80 DUP1 389F 82 DUP3 38A0 52 MSTORE 38A1 60 PUSH1 0x1b 38A3 90 SWAP1 38A4 82 DUP3 38A5 01 ADD 38A6 52 MSTORE 38A7 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 38C8 60 PUSH1 0x40 38CA 82 DUP3 38CB 01 ADD 38CC 52 MSTORE 38CD 60 PUSH1 0x60 38CF 01 ADD 38D0 90 SWAP1 38D1 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @38A0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @38A6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1b // @38CC memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @38D0 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_38D2: // Incoming call from 0x2B7E, returns to 0x0840 // Inputs[2] // { // @38D6 stack[-1] // @391C stack[-2] // } 38D2 5B JUMPDEST 38D3 60 PUSH1 0x20 38D5 80 DUP1 38D6 82 DUP3 38D7 52 MSTORE 38D8 60 PUSH1 0x2c 38DA 90 SWAP1 38DB 82 DUP3 38DC 01 ADD 38DD 52 MSTORE 38DE 7F PUSH32 0x556e697377617056324c6962726172793a20494e53554646494349454e545f4f 38FF 60 PUSH1 0x40 3901 82 DUP3 3902 01 ADD 3903 52 MSTORE 3904 6B PUSH12 0x155514155517d05353d55395 3911 60 PUSH1 0xa2 3913 1B SHL 3914 60 PUSH1 0x60 3916 82 DUP3 3917 01 ADD 3918 52 MSTORE 3919 60 PUSH1 0x80 391B 01 ADD 391C 90 SWAP1 391D 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @38D7 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @38DD memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @3903 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e697377617056324c6962726172793a20494e53554646494349454e545f4f // @3918 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x155514155517d05353d55395 << 0xa2 // @391C stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 391E 5B JUMPDEST 391F 60 PUSH1 0x20 3921 80 DUP1 3922 82 DUP3 3923 52 MSTORE 3924 60 PUSH1 0x1e 3926 90 SWAP1 3927 82 DUP3 3928 01 ADD 3929 52 MSTORE 392A 7F PUSH32 0x5472616e7366657248656c7065723a20415050524f56455f4641494c45440000 394B 60 PUSH1 0x40 394D 82 DUP3 394E 01 ADD 394F 52 MSTORE 3950 60 PUSH1 0x60 3952 01 ADD 3953 90 SWAP1 3954 56 *JUMP label_3955: // Incoming call from 0x2FDE, returns to 0x0840 // Inputs[2] // { // @3959 stack[-1] // @3998 stack[-2] // } 3955 5B JUMPDEST 3956 60 PUSH1 0x20 3958 80 DUP1 3959 82 DUP3 395A 52 MSTORE 395B 60 PUSH1 0x25 395D 90 SWAP1 395E 82 DUP3 395F 01 ADD 3960 52 MSTORE 3961 7F PUSH32 0x556e697377617056324c6962726172793a204944454e544943414c5f41444452 3982 60 PUSH1 0x40 3984 82 DUP3 3985 01 ADD 3986 52 MSTORE 3987 64 PUSH5 0x4553534553 398D 60 PUSH1 0xd8 398F 1B SHL 3990 60 PUSH1 0x60 3992 82 DUP3 3993 01 ADD 3994 52 MSTORE 3995 60 PUSH1 0x80 3997 01 ADD 3998 90 SWAP1 3999 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @395A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3960 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @3986 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e697377617056324c6962726172793a204944454e544943414c5f41444452 // @3994 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x4553534553 << 0xd8 // @3998 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_399A: // Incoming call from 0x1F5C, returns to 0x0840 // Incoming call from 0x1D20, returns to 0x0840 // Incoming call from 0x206D, returns to 0x0840 // Incoming call from 0x175E, returns to 0x0840 // Incoming call from 0x18C7, returns to 0x0840 // Incoming call from 0x0E1B, returns to 0x0840 // Incoming call from 0x0BD0, returns to 0x0840 // Incoming call from 0x13E9, returns to 0x0840 // Incoming call from 0x1C12, returns to 0x0840 // Incoming call from 0x1941, returns to 0x0840 // Inputs[2] // { // @399E stack[-1] // @39CF stack[-2] // } 399A 5B JUMPDEST 399B 60 PUSH1 0x20 399D 80 DUP1 399E 82 DUP3 399F 52 MSTORE 39A0 60 PUSH1 0x19 39A2 90 SWAP1 39A3 82 DUP3 39A4 01 ADD 39A5 52 MSTORE 39A6 7F PUSH32 0x6f6e6c7920776f726b65722063616e2063616c6c207468697300000000000000 39C7 60 PUSH1 0x40 39C9 82 DUP3 39CA 01 ADD 39CB 52 MSTORE 39CC 60 PUSH1 0x60 39CE 01 ADD 39CF 90 SWAP1 39D0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @399F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @39A5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @39CB memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x6f6e6c7920776f726b65722063616e2063616c6c207468697300000000000000 // @39CF stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_39D1: // Incoming call from 0x0C4E, returns to 0x0840 // Inputs[2] // { // @39D5 stack[-1] // @39FB stack[-2] // } 39D1 5B JUMPDEST 39D2 60 PUSH1 0x20 39D4 80 DUP1 39D5 82 DUP3 39D6 52 MSTORE 39D7 60 PUSH1 0x12 39D9 90 SWAP1 39DA 82 DUP3 39DB 01 ADD 39DC 52 MSTORE 39DD 71 PUSH18 0x10d85b1b081d185c99d95d08119052531151 39F0 60 PUSH1 0x72 39F2 1B SHL 39F3 60 PUSH1 0x40 39F5 82 DUP3 39F6 01 ADD 39F7 52 MSTORE 39F8 60 PUSH1 0x60 39FA 01 ADD 39FB 90 SWAP1 39FC 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @39D6 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @39DC memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x12 // @39F7 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x10d85b1b081d185c99d95d08119052531151 << 0x72 // @39FB stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_39FD: // Incoming call from 0x27DE, returns to 0x0840 // Incoming call from 0x2BAA, returns to 0x0840 // Inputs[2] // { // @3A01 stack[-1] // @3A43 stack[-2] // } 39FD 5B JUMPDEST 39FE 60 PUSH1 0x20 3A00 80 DUP1 3A01 82 DUP3 3A02 52 MSTORE 3A03 60 PUSH1 0x28 3A05 90 SWAP1 3A06 82 DUP3 3A07 01 ADD 3A08 52 MSTORE 3A09 7F PUSH32 0x556e697377617056324c6962726172793a20494e53554646494349454e545f4c 3A2A 60 PUSH1 0x40 3A2C 82 DUP3 3A2D 01 ADD 3A2E 52 MSTORE 3A2F 67 PUSH8 0x4951554944495459 3A38 60 PUSH1 0xc0 3A3A 1B SHL 3A3B 60 PUSH1 0x60 3A3D 82 DUP3 3A3E 01 ADD 3A3F 52 MSTORE 3A40 60 PUSH1 0x80 3A42 01 ADD 3A43 90 SWAP1 3A44 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3A02 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3A08 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @3A2E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e697377617056324c6962726172793a20494e53554646494349454e545f4c // @3A3F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x4951554944495459 << 0xc0 // @3A43 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3A45: // Incoming call from 0x306D, returns to 0x0840 // Inputs[2] // { // @3A49 stack[-1] // @3A84 stack[-2] // } 3A45 5B JUMPDEST 3A46 60 PUSH1 0x20 3A48 80 DUP1 3A49 82 DUP3 3A4A 52 MSTORE 3A4B 60 PUSH1 0x21 3A4D 90 SWAP1 3A4E 82 DUP3 3A4F 01 ADD 3A50 52 MSTORE 3A51 7F PUSH32 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f 3A72 60 PUSH1 0x40 3A74 82 DUP3 3A75 01 ADD 3A76 52 MSTORE 3A77 60 PUSH1 0x77 3A79 60 PUSH1 0xf8 3A7B 1B SHL 3A7C 60 PUSH1 0x60 3A7E 82 DUP3 3A7F 01 ADD 3A80 52 MSTORE 3A81 60 PUSH1 0x80 3A83 01 ADD 3A84 90 SWAP1 3A85 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3A4A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3A50 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x21 // @3A76 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f // @3A80 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x77 << 0xf8 // @3A84 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3A86: // Incoming call from 0x0F33, returns to 0x0840 // Incoming call from 0x17E7, returns to 0x0840 // Incoming call from 0x0C72, returns to 0x0840 // Incoming call from 0x1B1C, returns to 0x0840 // Incoming call from 0x1A6D, returns to 0x0840 // Incoming call from 0x0ABF, returns to 0x0840 // Incoming call from 0x0DB1, returns to 0x0840 // Incoming call from 0x1B45, returns to 0x0840 // Incoming call from 0x22D0, returns to 0x0840 // Incoming call from 0x1273, returns to 0x0840 // Incoming call from 0x1DAC, returns to 0x0840 // Incoming call from 0x26B9, returns to 0x0840 // Incoming call from 0x158B, returns to 0x0840 // Incoming call from 0x16AD, returns to 0x0840 // Incoming call from 0x083F, returns to 0x0840 // Incoming call from 0x1469, returns to 0x0840 // Incoming call from 0x0CE6, returns to 0x0840 // Incoming call from 0x122D, returns to 0x0840 // Incoming call from 0x2682, returns to 0x0840 // Incoming call from 0x10FA, returns to 0x0840 // Inputs[2] // { // @3A8A stack[-1] // @3AB9 stack[-2] // } 3A86 5B JUMPDEST 3A87 60 PUSH1 0x20 3A89 80 DUP1 3A8A 82 DUP3 3A8B 52 MSTORE 3A8C 81 DUP2 3A8D 81 DUP2 3A8E 01 ADD 3A8F 52 MSTORE 3A90 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 3AB1 60 PUSH1 0x40 3AB3 82 DUP3 3AB4 01 ADD 3AB5 52 MSTORE 3AB6 60 PUSH1 0x60 3AB8 01 ADD 3AB9 90 SWAP1 3ABA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3A8B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3A8F memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @3AB5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @3AB9 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3ABB: // Incoming call from 0x0E96, returns to 0x0840 // Incoming call from 0x20E5, returns to 0x0840 // Inputs[2] // { // @3ABF stack[-1] // @3ADA stack[-2] // } 3ABB 5B JUMPDEST 3ABC 60 PUSH1 0x20 3ABE 80 DUP1 3ABF 82 DUP3 3AC0 52 MSTORE 3AC1 60 PUSH1 0x07 3AC3 90 SWAP1 3AC4 82 DUP3 3AC5 01 ADD 3AC6 52 MSTORE 3AC7 66 PUSH7 0x3a393c9022a929 3ACF 60 PUSH1 0xc9 3AD1 1B SHL 3AD2 60 PUSH1 0x40 3AD4 82 DUP3 3AD5 01 ADD 3AD6 52 MSTORE 3AD7 60 PUSH1 0x60 3AD9 01 ADD 3ADA 90 SWAP1 3ADB 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3AC0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3AC6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x07 // @3AD6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x3a393c9022a929 << 0xc9 // @3ADA stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3ADC: // Incoming call from 0x1E50, returns to 0x0840 // Incoming call from 0x09B0, returns to 0x0840 // Incoming call from 0x1379, returns to 0x0840 // Incoming call from 0x0A94, returns to 0x0840 // Inputs[2] // { // @3AE0 stack[-1] // @3B02 stack[-2] // } 3ADC 5B JUMPDEST 3ADD 60 PUSH1 0x20 3ADF 80 DUP1 3AE0 82 DUP3 3AE1 52 MSTORE 3AE2 60 PUSH1 0x0e 3AE4 90 SWAP1 3AE5 82 DUP3 3AE6 01 ADD 3AE7 52 MSTORE 3AE8 6D PUSH14 0x11549497d1551217d19052531151 3AF7 60 PUSH1 0x92 3AF9 1B SHL 3AFA 60 PUSH1 0x40 3AFC 82 DUP3 3AFD 01 ADD 3AFE 52 MSTORE 3AFF 60 PUSH1 0x60 3B01 01 ADD 3B02 90 SWAP1 3B03 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3AE1 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3AE7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0e // @3AFE memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x11549497d1551217d19052531151 << 0x92 // @3B02 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3B04: // Incoming call from 0x302C, returns to 0x0840 // Inputs[2] // { // @3B08 stack[-1] // @3B39 stack[-2] // } 3B04 5B JUMPDEST 3B05 60 PUSH1 0x20 3B07 80 DUP1 3B08 82 DUP3 3B09 52 MSTORE 3B0A 60 PUSH1 0x1e 3B0C 90 SWAP1 3B0D 82 DUP3 3B0E 01 ADD 3B0F 52 MSTORE 3B10 7F PUSH32 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 3B31 60 PUSH1 0x40 3B33 82 DUP3 3B34 01 ADD 3B35 52 MSTORE 3B36 60 PUSH1 0x60 3B38 01 ADD 3B39 90 SWAP1 3B3A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3B09 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3B0F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1e // @3B35 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 // @3B39 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3B3B: // Incoming call from 0x1B6B, returns to 0x0840 // Incoming call from 0x180D, returns to 0x0840 // Incoming call from 0x0B16, returns to 0x0840 // Inputs[2] // { // @3B3F stack[-1] // @3B70 stack[-2] // } 3B3B 5B JUMPDEST 3B3C 60 PUSH1 0x20 3B3E 80 DUP1 3B3F 82 DUP3 3B40 52 MSTORE 3B41 60 PUSH1 0x17 3B43 90 SWAP1 3B44 82 DUP3 3B45 01 ADD 3B46 52 MSTORE 3B47 7F PUSH32 0x5f776f726b6572206d75737420626520646566696e6564000000000000000000 3B68 60 PUSH1 0x40 3B6A 82 DUP3 3B6B 01 ADD 3B6C 52 MSTORE 3B6D 60 PUSH1 0x60 3B6F 01 ADD 3B70 90 SWAP1 3B71 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3B40 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3B46 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x17 // @3B6C memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x5f776f726b6572206d75737420626520646566696e6564000000000000000000 // @3B70 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3B72 5B JUMPDEST 3B73 60 PUSH1 0x20 3B75 80 DUP1 3B76 82 DUP3 3B77 52 MSTORE 3B78 60 PUSH1 0x1d 3B7A 90 SWAP1 3B7B 82 DUP3 3B7C 01 ADD 3B7D 52 MSTORE 3B7E 7F PUSH32 0x556e695377617045786163744f757420616d6f756e744f7574206c6f77000000 3B9F 60 PUSH1 0x40 3BA1 82 DUP3 3BA2 01 ADD 3BA3 52 MSTORE 3BA4 60 PUSH1 0x60 3BA6 01 ADD 3BA7 90 SWAP1 3BA8 56 *JUMP label_3BA9: // Incoming call from 0x3182, returns to 0x0840 // Inputs[2] // { // @3BAD stack[-1] // @3BEB stack[-2] // } 3BA9 5B JUMPDEST 3BAA 60 PUSH1 0x20 3BAC 80 DUP1 3BAD 82 DUP3 3BAE 52 MSTORE 3BAF 60 PUSH1 0x24 3BB1 90 SWAP1 3BB2 82 DUP3 3BB3 01 ADD 3BB4 52 MSTORE 3BB5 7F PUSH32 0x5472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641 3BD6 60 PUSH1 0x40 3BD8 82 DUP3 3BD9 01 ADD 3BDA 52 MSTORE 3BDB 63 PUSH4 0x12531151 3BE0 60 PUSH1 0xe2 3BE2 1B SHL 3BE3 60 PUSH1 0x60 3BE5 82 DUP3 3BE6 01 ADD 3BE7 52 MSTORE 3BE8 60 PUSH1 0x80 3BEA 01 ADD 3BEB 90 SWAP1 3BEC 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3BAE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3BB4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x24 // @3BDA memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x5472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641 // @3BE7 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x12531151 << 0xe2 // @3BEB stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3BED: // Incoming call from 0x27B2, returns to 0x0840 // Inputs[2] // { // @3BF1 stack[-1] // @3C36 stack[-2] // } 3BED 5B JUMPDEST 3BEE 60 PUSH1 0x20 3BF0 80 DUP1 3BF1 82 DUP3 3BF2 52 MSTORE 3BF3 60 PUSH1 0x2b 3BF5 90 SWAP1 3BF6 82 DUP3 3BF7 01 ADD 3BF8 52 MSTORE 3BF9 7F PUSH32 0x556e697377617056324c6962726172793a20494e53554646494349454e545f49 3C1A 60 PUSH1 0x40 3C1C 82 DUP3 3C1D 01 ADD 3C1E 52 MSTORE 3C1F 6A PUSH11 0x1394155517d05353d55395 3C2B 60 PUSH1 0xaa 3C2D 1B SHL 3C2E 60 PUSH1 0x60 3C30 82 DUP3 3C31 01 ADD 3C32 52 MSTORE 3C33 60 PUSH1 0x80 3C35 01 ADD 3C36 90 SWAP1 3C37 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3BF2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3BF8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @3C1E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e697377617056324c6962726172793a20494e53554646494349454e545f49 // @3C32 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1394155517d05353d55395 << 0xaa // @3C36 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3C38: // Incoming call from 0x0389, returns to 0x035F // Inputs[8] // { // @3C39 stack[-2] // @3C3A memory[stack[-2]:stack[-2] + 0x20] // @3C46 stack[-1] // @3C4D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @3C59 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @3C66 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @3C70 memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // @3C7B stack[-3] // } 3C38 5B JUMPDEST 3C39 81 DUP2 3C3A 51 MLOAD 3C3B 60 PUSH1 0x01 3C3D 60 PUSH1 0x01 3C3F 60 PUSH1 0xa0 3C41 1B SHL 3C42 03 SUB 3C43 90 SWAP1 3C44 81 DUP2 3C45 16 AND 3C46 82 DUP3 3C47 52 MSTORE 3C48 60 PUSH1 0x20 3C4A 80 DUP1 3C4B 84 DUP5 3C4C 01 ADD 3C4D 51 MLOAD 3C4E 82 DUP3 3C4F 16 AND 3C50 90 SWAP1 3C51 83 DUP4 3C52 01 ADD 3C53 52 MSTORE 3C54 60 PUSH1 0x40 3C56 80 DUP1 3C57 84 DUP5 3C58 01 ADD 3C59 51 MLOAD 3C5A 90 SWAP1 3C5B 91 SWAP2 3C5C 16 AND 3C5D 90 SWAP1 3C5E 82 DUP3 3C5F 01 ADD 3C60 52 MSTORE 3C61 60 PUSH1 0x60 3C63 80 DUP1 3C64 83 DUP4 3C65 01 ADD 3C66 51 MLOAD 3C67 90 SWAP1 3C68 82 DUP3 3C69 01 ADD 3C6A 52 MSTORE 3C6B 60 PUSH1 0x80 3C6D 91 SWAP2 3C6E 82 DUP3 3C6F 01 ADD 3C70 51 MLOAD 3C71 91 SWAP2 3C72 81 DUP2 3C73 01 ADD 3C74 91 SWAP2 3C75 90 SWAP1 3C76 91 SWAP2 3C77 52 MSTORE 3C78 60 PUSH1 0xa0 3C7A 01 ADD 3C7B 90 SWAP1 3C7C 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @3C47 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @3C53 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @3C60 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @3C6A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @3C77 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // @3C7B stack[-3] = 0xa0 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3C7D: // Incoming call from 0x0902, returns to 0x0903 // Incoming call from 0x035E, returns to 0x035F // Incoming call from 0x12B7, returns to 0x12B8 // Incoming call from 0x09E6, returns to 0x09E7 // Inputs[3] // { // @3C7E stack[-2] // @3C7E stack[-1] // @3C84 stack[-3] // } 3C7D 5B JUMPDEST 3C7E 90 SWAP1 3C7F 81 DUP2 3C80 52 MSTORE 3C81 60 PUSH1 0x20 3C83 01 ADD 3C84 90 SWAP1 3C85 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3C80 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @3C84 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3C86: // Incoming jump from 0x2AC4 // Inputs[5] // { // @3C89 stack[-5] // @3C8A stack[-1] // @3C8C stack[-4] // @3C99 stack[-3] // @3CAE stack[-2] // } 3C86 5B JUMPDEST 3C87 60 PUSH1 0x00 3C89 85 DUP6 3C8A 82 DUP3 3C8B 52 MSTORE 3C8C 84 DUP5 3C8D 60 PUSH1 0x20 3C8F 83 DUP4 3C90 01 ADD 3C91 52 MSTORE 3C92 60 PUSH1 0x01 3C94 80 DUP1 3C95 60 PUSH1 0xa0 3C97 1B SHL 3C98 03 SUB 3C99 84 DUP5 3C9A 16 AND 3C9B 60 PUSH1 0x40 3C9D 83 DUP4 3C9E 01 ADD 3C9F 52 MSTORE 3CA0 60 PUSH1 0x80 3CA2 60 PUSH1 0x60 3CA4 83 DUP4 3CA5 01 ADD 3CA6 52 MSTORE 3CA7 61 PUSH2 0x2c06 3CAA 60 PUSH1 0x80 3CAC 83 DUP4 3CAD 01 ADD 3CAE 84 DUP5 3CAF 61 PUSH2 0x36da 3CB2 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @3C87 stack[0] = 0x00 // @3C8B memory[stack[-1]:stack[-1] + 0x20] = stack[-5] // @3C91 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] // @3C9F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @3CA6 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @3CA7 stack[1] = 0x2c06 // @3CAD stack[2] = stack[-1] + 0x80 // @3CAE stack[3] = stack[-2] // } // Block ends with call to 0x36da, returns to 0x2C06 label_3CB3: // Incoming call from 0x0651, returns to 0x035F // Inputs[6] // { // @3CB4 stack[-1] // @3CB4 stack[-5] // @3CBB stack[-4] // @3CBC stack[-2] // @3CC3 stack[-3] // @3CCC stack[-6] // } 3CB3 5B JUMPDEST 3CB4 93 SWAP4 3CB5 84 DUP5 3CB6 52 MSTORE 3CB7 60 PUSH1 0x20 3CB9 84 DUP5 3CBA 01 ADD 3CBB 92 SWAP3 3CBC 90 SWAP1 3CBD 92 SWAP3 3CBE 52 MSTORE 3CBF 60 PUSH1 0x40 3CC1 83 DUP4 3CC2 01 ADD 3CC3 52 MSTORE 3CC4 60 PUSH1 0x60 3CC6 82 DUP3 3CC7 01 ADD 3CC8 52 MSTORE 3CC9 60 PUSH1 0x80 3CCB 01 ADD 3CCC 90 SWAP1 3CCD 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @3CB6 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] // @3CBE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] // @3CC3 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @3CC8 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-2] // @3CCC stack[-6] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-6] label_3CCE: // Incoming call from 0x07DB, returns to 0x035F // Inputs[10] // { // @3CCF stack[-9] // @3CCF stack[-1] // @3CD6 stack[-8] // @3CD7 stack[-2] // @3CDE stack[-7] // @3CDF stack[-3] // @3CE6 stack[-6] // @3CE7 stack[-4] // @3CEE stack[-5] // @3D02 stack[-10] // } 3CCE 5B JUMPDEST 3CCF 97 SWAP8 3CD0 88 DUP9 3CD1 52 MSTORE 3CD2 60 PUSH1 0x20 3CD4 88 DUP9 3CD5 01 ADD 3CD6 96 SWAP7 3CD7 90 SWAP1 3CD8 96 SWAP7 3CD9 52 MSTORE 3CDA 60 PUSH1 0x40 3CDC 87 DUP8 3CDD 01 ADD 3CDE 94 SWAP5 3CDF 90 SWAP1 3CE0 94 SWAP5 3CE1 52 MSTORE 3CE2 60 PUSH1 0x60 3CE4 86 DUP7 3CE5 01 ADD 3CE6 92 SWAP3 3CE7 90 SWAP1 3CE8 92 SWAP3 3CE9 52 MSTORE 3CEA 60 PUSH1 0x80 3CEC 85 DUP6 3CED 01 ADD 3CEE 52 MSTORE 3CEF 60 PUSH1 0xa0 3CF1 84 DUP5 3CF2 01 ADD 3CF3 52 MSTORE 3CF4 60 PUSH1 0xc0 3CF6 83 DUP4 3CF7 01 ADD 3CF8 52 MSTORE 3CF9 60 PUSH1 0xe0 3CFB 82 DUP3 3CFC 01 ADD 3CFD 52 MSTORE 3CFE 61 PUSH2 0x0100 3D01 01 ADD 3D02 90 SWAP1 3D03 56 *JUMP // Stack delta = -9 // Outputs[9] // { // @3CD1 memory[stack[-1]:stack[-1] + 0x20] = stack[-9] // @3CD9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-8] // @3CE1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-7] // @3CE9 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-6] // @3CEE memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = stack[-5] // @3CF3 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] = stack[-4] // @3CF8 memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] = stack[-3] // @3CFD memory[stack[-1] + 0xe0:stack[-1] + 0xe0 + 0x20] = stack[-2] // @3D02 stack[-10] = 0x0100 + stack[-1] // } // Block ends with unconditional jump to stack[-10] label_3D04: // Incoming call from 0x34B8, returns to 0x34B9 // Incoming call from 0x32E2, returns to 0x32E3 // Inputs[2] // { // @3D07 memory[0x40:0x60] // @3D08 stack[-1] // } 3D04 5B JUMPDEST 3D05 60 PUSH1 0x40 3D07 51 MLOAD 3D08 81 DUP2 3D09 81 DUP2 3D0A 01 ADD 3D0B 67 PUSH8 0xffffffffffffffff 3D14 81 DUP2 3D15 11 GT 3D16 82 DUP3 3D17 82 DUP3 3D18 10 LT 3D19 17 OR 3D1A 15 ISZERO 3D1B 61 PUSH2 0x3d23 3D1E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3D07 stack[0] = memory[0x40:0x60] // @3D0A stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x3d23, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_3D1F: // Incoming jump from 0x3D1E, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[1] { @3D22 memory[0x00:0x00] } 3D1F 60 PUSH1 0x00 3D21 80 DUP1 3D22 FD *REVERT // Stack delta = +0 // Outputs[1] { @3D22 revert(memory[0x00:0x00]); } // Block terminates label_3D23: // Incoming jump from 0x3D1E, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @3D26 stack[-1] // @3D27 stack[-4] // @3D27 stack[-2] // @3D28 stack[-3] // } 3D23 5B JUMPDEST 3D24 60 PUSH1 0x40 3D26 52 MSTORE 3D27 91 SWAP2 3D28 90 SWAP1 3D29 50 POP 3D2A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3D26 memory[0x40:0x60] = stack[-1] // @3D27 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_3D2B: // Incoming call from 0x36F1, returns to 0x36F2 // Incoming call from 0x3717, returns to 0x3718 // Inputs[1] { @3D2F stack[-3] } 3D2B 5B JUMPDEST 3D2C 60 PUSH1 0x00 3D2E 5B JUMPDEST 3D2F 83 DUP4 3D30 81 DUP2 3D31 10 LT 3D32 15 ISZERO 3D33 61 PUSH2 0x3d46 3D36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3D2C stack[0] = 0x00 } // Block ends with conditional jump to 0x3d46, if !(0x00 < stack[-3]) label_3D37: // Incoming jump from 0x3D36, if not !(0x00 < stack[-3]) // Incoming jump from 0x3D36, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3D37 stack[-2] // @3D38 stack[-1] // @3D3A memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3D3B stack[-3] // } 3D37 81 DUP2 3D38 81 DUP2 3D39 01 ADD 3D3A 51 MLOAD 3D3B 83 DUP4 3D3C 82 DUP3 3D3D 01 ADD 3D3E 52 MSTORE 3D3F 60 PUSH1 0x20 3D41 01 ADD 3D42 61 PUSH2 0x3d2e 3D45 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3D3E memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3D41 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x3d2e label_3D46: // Incoming jump from 0x3D36, if !(0x00 < stack[-3]) // Incoming jump from 0x3D36, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @3D47 stack[-4] // @3D48 stack[-1] // } 3D46 5B JUMPDEST 3D47 83 DUP4 3D48 81 DUP2 3D49 11 GT 3D4A 15 ISZERO 3D4B 61 PUSH2 0x0a95 3D4E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a95, if !(stack[-1] > stack[-4]) label_3D4F: // Incoming jump from 0x3D4E, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @3D53 stack[-4] // @3D54 stack[-3] // @3D56 stack[-5] // } 3D4F 50 POP 3D50 50 POP 3D51 60 PUSH1 0x00 3D53 91 SWAP2 3D54 01 ADD 3D55 52 MSTORE 3D56 56 *JUMP // Stack delta = -5 // Outputs[1] { @3D55 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_3D57: // Incoming call from 0x3533, returns to 0x3534 // Incoming call from 0x354A, returns to 0x354B // Incoming call from 0x339D, returns to 0x339E // Incoming call from 0x33EC, returns to 0x33ED // Incoming call from 0x3506, returns to 0x3507 // Incoming call from 0x3351, returns to 0x306E // Incoming call from 0x336D, returns to 0x306E // Incoming call from 0x341A, returns to 0x341B // Incoming call from 0x3316, returns to 0x3317 // Incoming call from 0x33DC, returns to 0x33DD // Incoming call from 0x338D, returns to 0x338E // Incoming call from 0x3468, returns to 0x3469 // Incoming call from 0x36A8, returns to 0x36A9 // Incoming call from 0x33AD, returns to 0x33AE // Incoming call from 0x36D9, returns to 0x33ED // Inputs[1] { @3D60 stack[-1] } 3D57 5B JUMPDEST 3D58 60 PUSH1 0x01 3D5A 60 PUSH1 0x01 3D5C 60 PUSH1 0xa0 3D5E 1B SHL 3D5F 03 SUB 3D60 81 DUP2 3D61 16 AND 3D62 81 DUP2 3D63 14 EQ 3D64 61 PUSH2 0x0b67 3D67 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b67, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_3D68: // Incoming jump from 0x3D67, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3D6B memory[0x00:0x00] } 3D68 60 PUSH1 0x00 3D6A 80 DUP1 3D6B FD *REVERT // Stack delta = +0 // Outputs[1] { @3D6B revert(memory[0x00:0x00]); } // Block terminates label_3D6C: // Incoming call from 0x35EF, returns to 0x306E // Incoming call from 0x360B, returns to 0x306E // Inputs[1] { @3D6D stack[-1] } 3D6C 5B JUMPDEST 3D6D 80 DUP1 3D6E 15 ISZERO 3D6F 15 ISZERO 3D70 81 DUP2 3D71 14 EQ 3D72 61 PUSH2 0x0b67 3D75 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b67, if stack[-1] == !!stack[-1] label_3D76: // Incoming jump from 0x3D75, if not stack[-1] == !!stack[-1] // Inputs[1] { @3D79 memory[0x00:0x00] } 3D76 60 PUSH1 0x00 3D78 80 DUP1 3D79 FD *REVERT // Stack delta = +0 // Outputs[1] { @3D79 revert(memory[0x00:0x00]); } // Block terminates label_3D7A: // Incoming call from 0x363B, returns to 0x363C // Incoming call from 0x362A, returns to 0x362B // Inputs[1] { @3D83 stack[-1] } 3D7A 5B JUMPDEST 3D7B 60 PUSH1 0x01 3D7D 60 PUSH1 0x01 3D7F 60 PUSH1 0x70 3D81 1B SHL 3D82 03 SUB 3D83 81 DUP2 3D84 16 AND 3D85 81 DUP2 3D86 14 EQ 3D87 61 PUSH2 0x0b67 3D8A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b67, if stack[-1] == stack[-1] & (0x01 << 0x70) - 0x01 label_3D8B: // Incoming jump from 0x3D8A, if not stack[-1] == stack[-1] & (0x01 << 0x70) - 0x01 // Inputs[1] { @3D8E memory[0x00:0x00] } 3D8B 60 PUSH1 0x00 3D8D 80 DUP1 3D8E FD *REVERT // Stack delta = +0 // Outputs[1] { @3D8E revert(memory[0x00:0x00]); } // Block terminates 3D8F FE *ASSERT 3D90 A2 LOG2 3D91 64 PUSH5 0x6970667358 3D97 22 22 3D98 12 SLT 3D99 20 SHA3 3D9A 4E 4E 3D9B 50 POP 3D9C FB FB 3D9D 8A DUP11 3D9E A4 LOG4 3D9F 59 MSIZE 3DA0 94 SWAP5 3DA1 F1 CALL 3DA2 FC FC 3DA3 9B SWAP12 3DA4 63 PUSH4 0xa9f4037f 3DA9 C1 C1 3DAA 46 CHAINID 3DAB 5E 5E 3DAC F6 F6 3DAD D2 D2 3DAE F1 CALL 3DAF EF EF 3DB0 21 21 3DB1 68 PUSH9 0xbe1d38982018b6f264 3DBB 73 PUSH20 0x6f6c63430006060033