Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0235 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0235, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x74bbcb6a 0026 11 GT 0027 61 PUSH2 0x0137 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0137, if 0x74bbcb6a > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x74bbcb6a > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x74bbcb6a 0031 14 EQ 0032 61 PUSH2 0x047c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047c, if 0x74bbcb6a == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x74bbcb6a == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x7ecebe00 003C 14 EQ 003D 61 PUSH2 0x04aa 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04aa, if 0x7ecebe00 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x7ecebe00 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x82730ad4 0047 14 EQ 0048 61 PUSH2 0x04bd 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bd, if 0x82730ad4 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x82730ad4 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x840fe8ab 0052 14 EQ 0053 61 PUSH2 0x04d0 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d0, if 0x840fe8ab == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x840fe8ab == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x857ac5c1 005D 14 EQ 005E 61 PUSH2 0x0510 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0510, if 0x857ac5c1 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x857ac5c1 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x8aec8542 0068 14 EQ 0069 61 PUSH2 0x0538 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0538, if 0x8aec8542 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x8aec8542 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x8f52439a 0073 14 EQ 0074 61 PUSH2 0x0540 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0540, if 0x8f52439a == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x8f52439a == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x91d14854 007E 14 EQ 007F 61 PUSH2 0x0553 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0553, if 0x91d14854 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x91d14854 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x91fcd9a9 0089 14 EQ 008A 61 PUSH2 0x0566 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0566, if 0x91fcd9a9 == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x91fcd9a9 == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0x95d89b41 0094 14 EQ 0095 61 PUSH2 0x0579 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0579, if 0x95d89b41 == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0x9a8a0592 009F 14 EQ 00A0 61 PUSH2 0x0581 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0581, if 0x9a8a0592 == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0x9a8a0592 == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0xa217fddf 00AA 14 EQ 00AB 61 PUSH2 0x0587 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0587, if 0xa217fddf == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0xa217fddf == stack[-1] // Inputs[1] { @00AF stack[-1] } 00AF 80 DUP1 00B0 63 PUSH4 0xa457c2d7 00B5 14 EQ 00B6 61 PUSH2 0x058f 00B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058f, if 0xa457c2d7 == stack[-1] label_00BA: // Incoming jump from 0x00B9, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @00BA stack[-1] } 00BA 80 DUP1 00BB 63 PUSH4 0xa9059cbb 00C0 14 EQ 00C1 61 PUSH2 0x05a2 00C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a2, if 0xa9059cbb == stack[-1] label_00C5: // Incoming jump from 0x00C4, if not 0xa9059cbb == stack[-1] // Inputs[1] { @00C5 stack[-1] } 00C5 80 DUP1 00C6 63 PUSH4 0xb54d321d 00CB 14 EQ 00CC 61 PUSH2 0x05b5 00CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b5, if 0xb54d321d == stack[-1] label_00D0: // Incoming jump from 0x00CF, if not 0xb54d321d == stack[-1] // Inputs[1] { @00D0 stack[-1] } 00D0 80 DUP1 00D1 63 PUSH4 0xd505accf 00D6 14 EQ 00D7 61 PUSH2 0x05be 00DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05be, if 0xd505accf == stack[-1] label_00DB: // Incoming jump from 0x00DA, if not 0xd505accf == stack[-1] // Inputs[1] { @00DB stack[-1] } 00DB 80 DUP1 00DC 63 PUSH4 0xd547741f 00E1 14 EQ 00E2 61 PUSH2 0x05d1 00E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d1, if 0xd547741f == stack[-1] label_00E6: // Incoming jump from 0x00E5, if not 0xd547741f == stack[-1] // Inputs[1] { @00E6 stack[-1] } 00E6 80 DUP1 00E7 63 PUSH4 0xdd62ed3e 00EC 14 EQ 00ED 61 PUSH2 0x05e4 00F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e4, if 0xdd62ed3e == stack[-1] label_00F1: // Incoming jump from 0x00F0, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @00F1 stack[-1] } 00F1 80 DUP1 00F2 63 PUSH4 0xe044c1ce 00F7 14 EQ 00F8 61 PUSH2 0x05f7 00FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f7, if 0xe044c1ce == stack[-1] label_00FC: // Incoming jump from 0x00FB, if not 0xe044c1ce == stack[-1] // Inputs[1] { @00FC stack[-1] } 00FC 80 DUP1 00FD 63 PUSH4 0xe06174e4 0102 14 EQ 0103 61 PUSH2 0x060a 0106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060a, if 0xe06174e4 == stack[-1] label_0107: // Incoming jump from 0x0106, if not 0xe06174e4 == stack[-1] // Inputs[1] { @0107 stack[-1] } 0107 80 DUP1 0108 63 PUSH4 0xe06fbe47 010D 14 EQ 010E 61 PUSH2 0x063a 0111 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063a, if 0xe06fbe47 == stack[-1] label_0112: // Incoming jump from 0x0111, if not 0xe06fbe47 == stack[-1] // Inputs[1] { @0112 stack[-1] } 0112 80 DUP1 0113 63 PUSH4 0xe35fba6c 0118 14 EQ 0119 61 PUSH2 0x0642 011C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0642, if 0xe35fba6c == stack[-1] label_011D: // Incoming jump from 0x011C, if not 0xe35fba6c == stack[-1] // Inputs[1] { @011D stack[-1] } 011D 80 DUP1 011E 63 PUSH4 0xee964f36 0123 14 EQ 0124 61 PUSH2 0x0655 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0655, if 0xee964f36 == stack[-1] label_0128: // Incoming jump from 0x0127, if not 0xee964f36 == stack[-1] // Inputs[1] { @0128 stack[-1] } 0128 80 DUP1 0129 63 PUSH4 0xf9fec849 012E 14 EQ 012F 61 PUSH2 0x065d 0132 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065d, if 0xf9fec849 == stack[-1] label_0133: // Incoming jump from 0x0132, if not 0xf9fec849 == stack[-1] // Inputs[1] { @0136 memory[0x00:0x00] } 0133 60 PUSH1 0x00 0135 80 DUP1 0136 FD *REVERT // Stack delta = +0 // Outputs[1] { @0136 revert(memory[0x00:0x00]); } // Block terminates label_0137: // Incoming jump from 0x002A, if 0x74bbcb6a > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0138 stack[-1] } 0137 5B JUMPDEST 0138 80 DUP1 0139 63 PUSH4 0x01ffc9a7 013E 14 EQ 013F 61 PUSH2 0x023a 0142 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023a, if 0x01ffc9a7 == stack[-1] label_0143: // Incoming jump from 0x0142, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0143 stack[-1] } 0143 80 DUP1 0144 63 PUSH4 0x06fdde03 0149 14 EQ 014A 61 PUSH2 0x0262 014D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0262, if 0x06fdde03 == stack[-1] label_014E: // Incoming jump from 0x014D, if not 0x06fdde03 == stack[-1] // Inputs[1] { @014E stack[-1] } 014E 80 DUP1 014F 63 PUSH4 0x095ea7b3 0154 14 EQ 0155 61 PUSH2 0x0277 0158 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x095ea7b3 == stack[-1] label_0159: // Incoming jump from 0x0158, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0159 stack[-1] } 0159 80 DUP1 015A 63 PUSH4 0x0982d5b0 015F 14 EQ 0160 61 PUSH2 0x028a 0163 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028a, if 0x0982d5b0 == stack[-1] label_0164: // Incoming jump from 0x0163, if not 0x0982d5b0 == stack[-1] // Inputs[1] { @0164 stack[-1] } 0164 80 DUP1 0165 63 PUSH4 0x0c008f7b 016A 14 EQ 016B 61 PUSH2 0x029d 016E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029d, if 0x0c008f7b == stack[-1] label_016F: // Incoming jump from 0x016E, if not 0x0c008f7b == stack[-1] // Inputs[1] { @016F stack[-1] } 016F 80 DUP1 0170 63 PUSH4 0x16d8806e 0175 14 EQ 0176 61 PUSH2 0x02be 0179 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0x16d8806e == stack[-1] label_017A: // Incoming jump from 0x0179, if not 0x16d8806e == stack[-1] // Inputs[1] { @017A stack[-1] } 017A 80 DUP1 017B 63 PUSH4 0x18160ddd 0180 14 EQ 0181 61 PUSH2 0x02d1 0184 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d1, if 0x18160ddd == stack[-1] label_0185: // Incoming jump from 0x0184, if not 0x18160ddd == stack[-1] // Inputs[1] { @0185 stack[-1] } 0185 80 DUP1 0186 63 PUSH4 0x23b872dd 018B 14 EQ 018C 61 PUSH2 0x02d9 018F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0x23b872dd == stack[-1] label_0190: // Incoming jump from 0x018F, if not 0x23b872dd == stack[-1] // Inputs[1] { @0190 stack[-1] } 0190 80 DUP1 0191 63 PUSH4 0x248a9ca3 0196 14 EQ 0197 61 PUSH2 0x02ec 019A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ec, if 0x248a9ca3 == stack[-1] label_019B: // Incoming jump from 0x019A, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @019B stack[-1] } 019B 80 DUP1 019C 63 PUSH4 0x2f2ff15d 01A1 14 EQ 01A2 61 PUSH2 0x02ff 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ff, if 0x2f2ff15d == stack[-1] label_01A6: // Incoming jump from 0x01A5, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @01A6 stack[-1] } 01A6 80 DUP1 01A7 63 PUSH4 0x313ce567 01AC 14 EQ 01AD 61 PUSH2 0x0314 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0314, if 0x313ce567 == stack[-1] label_01B1: // Incoming jump from 0x01B0, if not 0x313ce567 == stack[-1] // Inputs[1] { @01B1 stack[-1] } 01B1 80 DUP1 01B2 63 PUSH4 0x3644e515 01B7 14 EQ 01B8 61 PUSH2 0x032a 01BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032a, if 0x3644e515 == stack[-1] label_01BC: // Incoming jump from 0x01BB, if not 0x3644e515 == stack[-1] // Inputs[1] { @01BC stack[-1] } 01BC 80 DUP1 01BD 63 PUSH4 0x36568abe 01C2 14 EQ 01C3 61 PUSH2 0x0332 01C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0332, if 0x36568abe == stack[-1] label_01C7: // Incoming jump from 0x01C6, if not 0x36568abe == stack[-1] // Inputs[1] { @01C7 stack[-1] } 01C7 80 DUP1 01C8 63 PUSH4 0x38427779 01CD 14 EQ 01CE 61 PUSH2 0x0345 01D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0345, if 0x38427779 == stack[-1] label_01D2: // Incoming jump from 0x01D1, if not 0x38427779 == stack[-1] // Inputs[1] { @01D2 stack[-1] } 01D2 80 DUP1 01D3 63 PUSH4 0x39509351 01D8 14 EQ 01D9 61 PUSH2 0x0358 01DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0358, if 0x39509351 == stack[-1] label_01DD: // Incoming jump from 0x01DC, if not 0x39509351 == stack[-1] // Inputs[1] { @01DD stack[-1] } 01DD 80 DUP1 01DE 63 PUSH4 0x412ef5a3 01E3 14 EQ 01E4 61 PUSH2 0x036b 01E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036b, if 0x412ef5a3 == stack[-1] label_01E8: // Incoming jump from 0x01E7, if not 0x412ef5a3 == stack[-1] // Inputs[1] { @01E8 stack[-1] } 01E8 80 DUP1 01E9 63 PUSH4 0x421bedb3 01EE 14 EQ 01EF 61 PUSH2 0x037e 01F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037e, if 0x421bedb3 == stack[-1] label_01F3: // Incoming jump from 0x01F2, if not 0x421bedb3 == stack[-1] // Inputs[1] { @01F3 stack[-1] } 01F3 80 DUP1 01F4 63 PUSH4 0x5382fe98 01F9 14 EQ 01FA 61 PUSH2 0x0386 01FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if 0x5382fe98 == stack[-1] label_01FE: // Incoming jump from 0x01FD, if not 0x5382fe98 == stack[-1] // Inputs[1] { @01FE stack[-1] } 01FE 80 DUP1 01FF 63 PUSH4 0x54fd4d50 0204 14 EQ 0205 61 PUSH2 0x0399 0208 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0399, if 0x54fd4d50 == stack[-1] label_0209: // Incoming jump from 0x0208, if not 0x54fd4d50 == stack[-1] // Inputs[1] { @0209 stack[-1] } 0209 80 DUP1 020A 63 PUSH4 0x60246c88 020F 14 EQ 0210 61 PUSH2 0x03a1 0213 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0x60246c88 == stack[-1] label_0214: // Incoming jump from 0x0213, if not 0x60246c88 == stack[-1] // Inputs[1] { @0214 stack[-1] } 0214 80 DUP1 0215 63 PUSH4 0x6386c1c7 021A 14 EQ 021B 61 PUSH2 0x03fc 021E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fc, if 0x6386c1c7 == stack[-1] label_021F: // Incoming jump from 0x021E, if not 0x6386c1c7 == stack[-1] // Inputs[1] { @021F stack[-1] } 021F 80 DUP1 0220 63 PUSH4 0x671bb4f1 0225 14 EQ 0226 61 PUSH2 0x0440 0229 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0440, if 0x671bb4f1 == stack[-1] label_022A: // Incoming jump from 0x0229, if not 0x671bb4f1 == stack[-1] // Inputs[1] { @022A stack[-1] } 022A 80 DUP1 022B 63 PUSH4 0x70a08231 0230 14 EQ 0231 61 PUSH2 0x0453 0234 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0453, if 0x70a08231 == stack[-1] label_0235: // Incoming jump from 0x0234, if not 0x70a08231 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @0239 memory[0x00:0x00] } 0235 5B JUMPDEST 0236 60 PUSH1 0x00 0238 80 DUP1 0239 FD *REVERT // Stack delta = +0 // Outputs[1] { @0239 revert(memory[0x00:0x00]); } // Block terminates label_023A: // Incoming jump from 0x0142, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0241 msg.data.length } 023A 5B JUMPDEST 023B 61 PUSH2 0x024d 023E 61 PUSH2 0x0248 0241 36 CALLDATASIZE 0242 60 PUSH1 0x04 0244 61 PUSH2 0x3975 0247 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023B stack[0] = 0x024d // @023E stack[1] = 0x0248 // @0241 stack[2] = msg.data.length // @0242 stack[3] = 0x04 // } // Block ends with call to 0x3975, returns to 0x0248 label_0248: // Incoming return from call to 0x3975 at 0x0247 0248 5B JUMPDEST 0249 61 PUSH2 0x0670 024C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0670 label_024D: // Incoming return from call to 0x02CC at 0x02CB // Incoming return from call to 0x0285 at 0x0284 // Incoming return from call to 0x0650 at 0x064F // Incoming return from call to 0x0248 at 0x0247 // Incoming return from call to 0x0561 at 0x0560 // Incoming return from call to 0x0298 at 0x0297 // Incoming return from call to 0x059D at 0x059C // Inputs[2] // { // @0250 memory[0x40:0x60] // @0251 stack[-1] // } 024D 5B JUMPDEST 024E 60 PUSH1 0x40 0250 51 MLOAD 0251 90 SWAP1 0252 15 ISZERO 0253 15 ISZERO 0254 81 DUP2 0255 52 MSTORE 0256 60 PUSH1 0x20 0258 01 ADD // Stack delta = +0 // Outputs[2] // { // @0255 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0258 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0259: // Incoming jump from 0x02BD // Incoming return from call to 0x39CB at 0x0276 // Incoming jump from 0x043F // Incoming jump from 0x0329 // Incoming jump from 0x0639 // Incoming jump from 0x0258 // Incoming jump from 0x04A9 // Incoming jump from 0x0537 // Incoming jump from 0x03FB // Incoming jump from 0x050F // Inputs[3] // { // @025C memory[0x40:0x60] // @025E stack[-1] // @0261 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0259 5B JUMPDEST 025A 60 PUSH1 0x40 025C 51 MLOAD 025D 80 DUP1 025E 91 SWAP2 025F 03 SUB 0260 90 SWAP1 0261 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0261 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0262: // Incoming jump from 0x014D, if 0x06fdde03 == stack[-1] 0262 5B JUMPDEST 0263 61 PUSH2 0x026a 0266 61 PUSH2 0x06a7 0269 56 *JUMP // Stack delta = +1 // Outputs[1] { @0263 stack[0] = 0x026a } // Block ends with call to 0x06a7, returns to 0x026A label_026A: // Incoming return from call to 0x13F8 at 0x0580 // Incoming return from call to 0x0F9C at 0x03A0 // Incoming return from call to 0x06A7 at 0x0269 // Inputs[2] // { // @026D memory[0x40:0x60] // @0271 stack[-1] // } 026A 5B JUMPDEST 026B 60 PUSH1 0x40 026D 51 MLOAD 026E 61 PUSH2 0x0259 0271 91 SWAP2 0272 90 SWAP1 0273 61 PUSH2 0x39cb 0276 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0271 stack[-1] = 0x0259 // @0272 stack[1] = memory[0x40:0x60] // @0272 stack[0] = stack[-1] // } // Block ends with call to 0x39cb, returns to 0x0259 label_0277: // Incoming jump from 0x0158, if 0x095ea7b3 == stack[-1] // Inputs[1] { @027E msg.data.length } 0277 5B JUMPDEST 0278 61 PUSH2 0x024d 027B 61 PUSH2 0x0285 027E 36 CALLDATASIZE 027F 60 PUSH1 0x04 0281 61 PUSH2 0x3a1a 0284 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0278 stack[0] = 0x024d // @027B stack[1] = 0x0285 // @027E stack[2] = msg.data.length // @027F stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x0285 label_0285: // Incoming return from call to 0x3A1A at 0x0284 0285 5B JUMPDEST 0286 61 PUSH2 0x0739 0289 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0739 label_028A: // Incoming jump from 0x0163, if 0x0982d5b0 == stack[-1] // Inputs[1] { @0291 msg.data.length } 028A 5B JUMPDEST 028B 61 PUSH2 0x024d 028E 61 PUSH2 0x0298 0291 36 CALLDATASIZE 0292 60 PUSH1 0x04 0294 61 PUSH2 0x3acf 0297 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @028B stack[0] = 0x024d // @028E stack[1] = 0x0298 // @0291 stack[2] = msg.data.length // @0292 stack[3] = 0x04 // } // Block ends with call to 0x3acf, returns to 0x0298 label_0298: // Incoming return from call to 0x3ACF at 0x0297 0298 5B JUMPDEST 0299 61 PUSH2 0x0751 029C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0751 label_029D: // Incoming jump from 0x016E, if 0x0c008f7b == stack[-1] // Inputs[1] { @02A4 msg.data.length } 029D 5B JUMPDEST 029E 61 PUSH2 0x02b0 02A1 61 PUSH2 0x02ab 02A4 36 CALLDATASIZE 02A5 60 PUSH1 0x04 02A7 61 PUSH2 0x3b5c 02AA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029E stack[0] = 0x02b0 // @02A1 stack[1] = 0x02ab // @02A4 stack[2] = msg.data.length // @02A5 stack[3] = 0x04 // } // Block ends with call to 0x3b5c, returns to 0x02AB label_02AB: // Incoming return from call to 0x3B5C at 0x02AA 02AB 5B JUMPDEST 02AC 61 PUSH2 0x07cd 02AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07cd label_02B0: // Incoming jump from 0x02D8 // Incoming return from call to 0x054E at 0x054D // Incoming return from call to 0x04B8 at 0x04B7 // Incoming jump from 0x058E // Incoming return from call to 0x16D1 at 0x0641 // Incoming return from call to 0x0574 at 0x0573 // Incoming jump from 0x0586 // Incoming return from call to 0x066B at 0x066A // Incoming jump from 0x05BD // Incoming return from call to 0x0461 at 0x0460 // Incoming return from call to 0x02FA at 0x02F9 // Inputs[2] // { // @02B3 memory[0x40:0x60] // @02B4 stack[-1] // } 02B0 5B JUMPDEST 02B1 60 PUSH1 0x40 02B3 51 MLOAD 02B4 90 SWAP1 02B5 81 DUP2 02B6 52 MSTORE 02B7 60 PUSH1 0x20 02B9 01 ADD 02BA 61 PUSH2 0x0259 02BD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02B9 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_02BE: // Incoming jump from 0x0179, if 0x16d8806e == stack[-1] // Inputs[1] { @02C5 msg.data.length } 02BE 5B JUMPDEST 02BF 61 PUSH2 0x024d 02C2 61 PUSH2 0x02cc 02C5 36 CALLDATASIZE 02C6 60 PUSH1 0x04 02C8 61 PUSH2 0x3a1a 02CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BF stack[0] = 0x024d // @02C2 stack[1] = 0x02cc // @02C5 stack[2] = msg.data.length // @02C6 stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x02CC label_02CC: // Incoming return from call to 0x3A1A at 0x02CB 02CC 5B JUMPDEST 02CD 61 PUSH2 0x07e0 02D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07e0 label_02D1: // Incoming jump from 0x0184, if 0x18160ddd == stack[-1] // Inputs[1] { @02D4 storage[0x99] } 02D1 5B JUMPDEST 02D2 60 PUSH1 0x99 02D4 54 SLOAD 02D5 61 PUSH2 0x02b0 02D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D4 stack[0] = storage[0x99] } // Block ends with unconditional jump to 0x02b0 label_02D9: // Incoming jump from 0x018F, if 0x23b872dd == stack[-1] // Inputs[1] { @02E0 msg.data.length } 02D9 5B JUMPDEST 02DA 61 PUSH2 0x024d 02DD 61 PUSH2 0x02e7 02E0 36 CALLDATASIZE 02E1 60 PUSH1 0x04 02E3 61 PUSH2 0x3b7e 02E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DA stack[0] = 0x024d // @02DD stack[1] = 0x02e7 // @02E0 stack[2] = msg.data.length // @02E1 stack[3] = 0x04 // } // Block ends with call to 0x3b7e, returns to 0x02E7 label_02E7: // Incoming return from call to 0x3B7E at 0x02E6 02E7 5B JUMPDEST 02E8 61 PUSH2 0x0bbb 02EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bbb label_02EC: // Incoming jump from 0x019A, if 0x248a9ca3 == stack[-1] // Inputs[1] { @02F3 msg.data.length } 02EC 5B JUMPDEST 02ED 61 PUSH2 0x02b0 02F0 61 PUSH2 0x02fa 02F3 36 CALLDATASIZE 02F4 60 PUSH1 0x04 02F6 61 PUSH2 0x3bba 02F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02ED stack[0] = 0x02b0 // @02F0 stack[1] = 0x02fa // @02F3 stack[2] = msg.data.length // @02F4 stack[3] = 0x04 // } // Block ends with call to 0x3bba, returns to 0x02FA label_02FA: // Incoming return from call to 0x3BBA at 0x02F9 02FA 5B JUMPDEST 02FB 61 PUSH2 0x0bdf 02FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bdf label_02FF: // Incoming jump from 0x01A5, if 0x2f2ff15d == stack[-1] // Inputs[1] { @0306 msg.data.length } 02FF 5B JUMPDEST 0300 61 PUSH2 0x0312 0303 61 PUSH2 0x030d 0306 36 CALLDATASIZE 0307 60 PUSH1 0x04 0309 61 PUSH2 0x3bd3 030C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0300 stack[0] = 0x0312 // @0303 stack[1] = 0x030d // @0306 stack[2] = msg.data.length // @0307 stack[3] = 0x04 // } // Block ends with call to 0x3bd3, returns to 0x030D label_030D: // Incoming return from call to 0x3BD3 at 0x030C 030D 5B JUMPDEST 030E 61 PUSH2 0x0bf4 0311 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf4 label_0312: // Incoming return from call to 0x1BDC at 0x065C // Incoming return from call to 0x030D at 0x030C // Incoming return from call to 0x044E at 0x044D // Incoming return from call to 0x05DF at 0x05DE // Incoming return from call to 0x0353 at 0x0352 // Incoming return from call to 0x04CB at 0x04CA // Incoming return from call to 0x0340 at 0x033F 0312 5B JUMPDEST 0313 00 *STOP // Stack delta = +0 // Outputs[1] { @0313 stop(); } // Block terminates label_0314: // Incoming jump from 0x01B0, if 0x313ce567 == stack[-1] // Inputs[2] // { // @0318 storage[0x0130] // @031B memory[0x40:0x60] // } 0314 5B JUMPDEST 0315 61 PUSH2 0x0130 0318 54 SLOAD 0319 60 PUSH1 0x40 031B 51 MLOAD 031C 60 PUSH1 0xff 031E 90 SWAP1 031F 91 SWAP2 0320 16 AND 0321 81 DUP2 0322 52 MSTORE 0323 60 PUSH1 0x20 0325 01 ADD 0326 61 PUSH2 0x0259 0329 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0322 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0130] & 0xff // @0325 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_032A: // Incoming jump from 0x01BB, if 0x3644e515 == stack[-1] 032A 5B JUMPDEST 032B 61 PUSH2 0x02b0 032E 61 PUSH2 0x0c15 0331 56 *JUMP // Stack delta = +1 // Outputs[1] { @032B stack[0] = 0x02b0 } // Block ends with unconditional jump to 0x0c15 label_0332: // Incoming jump from 0x01C6, if 0x36568abe == stack[-1] // Inputs[1] { @0339 msg.data.length } 0332 5B JUMPDEST 0333 61 PUSH2 0x0312 0336 61 PUSH2 0x0340 0339 36 CALLDATASIZE 033A 60 PUSH1 0x04 033C 61 PUSH2 0x3bd3 033F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0333 stack[0] = 0x0312 // @0336 stack[1] = 0x0340 // @0339 stack[2] = msg.data.length // @033A stack[3] = 0x04 // } // Block ends with call to 0x3bd3, returns to 0x0340 label_0340: // Incoming return from call to 0x3BD3 at 0x033F 0340 5B JUMPDEST 0341 61 PUSH2 0x0c24 0344 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c24 label_0345: // Incoming jump from 0x01D1, if 0x38427779 == stack[-1] // Inputs[1] { @034C msg.data.length } 0345 5B JUMPDEST 0346 61 PUSH2 0x0312 0349 61 PUSH2 0x0353 034C 36 CALLDATASIZE 034D 60 PUSH1 0x04 034F 61 PUSH2 0x3bba 0352 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0346 stack[0] = 0x0312 // @0349 stack[1] = 0x0353 // @034C stack[2] = msg.data.length // @034D stack[3] = 0x04 // } // Block ends with call to 0x3bba, returns to 0x0353 label_0353: // Incoming return from call to 0x3BBA at 0x0352 0353 5B JUMPDEST 0354 61 PUSH2 0x0ca2 0357 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ca2 label_0358: // Incoming jump from 0x01DC, if 0x39509351 == stack[-1] // Inputs[1] { @035F msg.data.length } 0358 5B JUMPDEST 0359 61 PUSH2 0x024d 035C 61 PUSH2 0x0366 035F 36 CALLDATASIZE 0360 60 PUSH1 0x04 0362 61 PUSH2 0x3a1a 0365 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0359 stack[0] = 0x024d // @035C stack[1] = 0x0366 // @035F stack[2] = msg.data.length // @0360 stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x0366 label_0366: // Incoming return from call to 0x3A1A at 0x0365 0366 5B JUMPDEST 0367 61 PUSH2 0x0cd6 036A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cd6 label_036B: // Incoming jump from 0x01E7, if 0x412ef5a3 == stack[-1] // Inputs[1] { @0372 msg.data.length } 036B 5B JUMPDEST 036C 61 PUSH2 0x0312 036F 61 PUSH2 0x0379 0372 36 CALLDATASIZE 0373 60 PUSH1 0x04 0375 61 PUSH2 0x3c30 0378 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036C stack[0] = 0x0312 // @036F stack[1] = 0x0379 // @0372 stack[2] = msg.data.length // @0373 stack[3] = 0x04 // } // Block ends with call to 0x3c30, returns to 0x0379 label_0379: // Incoming return from call to 0x3C30 at 0x0378 0379 5B JUMPDEST 037A 61 PUSH2 0x0cf8 037D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cf8 label_037E: // Incoming jump from 0x01F2, if 0x421bedb3 == stack[-1] 037E 5B JUMPDEST 037F 61 PUSH2 0x0312 0382 61 PUSH2 0x0e44 0385 56 *JUMP // Stack delta = +1 // Outputs[1] { @037F stack[0] = 0x0312 } // Block ends with unconditional jump to 0x0e44 label_0386: // Incoming jump from 0x01FD, if 0x5382fe98 == stack[-1] // Inputs[1] { @038D msg.data.length } 0386 5B JUMPDEST 0387 61 PUSH2 0x0312 038A 61 PUSH2 0x0394 038D 36 CALLDATASIZE 038E 60 PUSH1 0x04 0390 61 PUSH2 0x3cd8 0393 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0387 stack[0] = 0x0312 // @038A stack[1] = 0x0394 // @038D stack[2] = msg.data.length // @038E stack[3] = 0x04 // } // Block ends with call to 0x3cd8, returns to 0x0394 label_0394: // Incoming return from call to 0x3CD8 at 0x0393 0394 5B JUMPDEST 0395 61 PUSH2 0x0e83 0398 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e83 label_0399: // Incoming jump from 0x0208, if 0x54fd4d50 == stack[-1] 0399 5B JUMPDEST 039A 61 PUSH2 0x026a 039D 61 PUSH2 0x0f9c 03A0 56 *JUMP // Stack delta = +1 // Outputs[1] { @039A stack[0] = 0x026a } // Block ends with call to 0x0f9c, returns to 0x026A label_03A1: // Incoming jump from 0x0213, if 0x60246c88 == stack[-1] 03A1 5B JUMPDEST 03A2 61 PUSH2 0x03a9 03A5 61 PUSH2 0x0fb9 03A8 56 *JUMP // Stack delta = +1 // Outputs[1] { @03A2 stack[0] = 0x03a9 } // Block ends with call to 0x0fb9, returns to 0x03A9 label_03A9: // Incoming return from call to 0x0FB9 at 0x03A8 // Inputs[11] // { // @03AD memory[0x40:0x60] // @03AE stack[-10] // @03B5 stack[-9] // @03B9 stack[-1] // @03BC stack[-8] // @03BD stack[-2] // @03C4 stack[-7] // @03C5 stack[-3] // @03CC stack[-6] // @03CD stack[-4] // @03D4 stack[-5] // } 03A9 5B JUMPDEST 03AA 60 PUSH1 0x40 03AC 80 DUP1 03AD 51 MLOAD 03AE 9A SWAP11 03AF 8B DUP12 03B0 52 MSTORE 03B1 60 PUSH1 0x20 03B3 8B DUP12 03B4 01 ADD 03B5 99 SWAP10 03B6 90 SWAP1 03B7 99 SWAP10 03B8 52 MSTORE 03B9 97 SWAP8 03BA 89 DUP10 03BB 01 ADD 03BC 96 SWAP7 03BD 90 SWAP1 03BE 96 SWAP7 03BF 52 MSTORE 03C0 60 PUSH1 0x60 03C2 88 DUP9 03C3 01 ADD 03C4 94 SWAP5 03C5 90 SWAP1 03C6 94 SWAP5 03C7 52 MSTORE 03C8 60 PUSH1 0x80 03CA 87 DUP8 03CB 01 ADD 03CC 92 SWAP3 03CD 90 SWAP1 03CE 92 SWAP3 03CF 52 MSTORE 03D0 60 PUSH1 0xa0 03D2 86 DUP7 03D3 01 ADD 03D4 52 MSTORE 03D5 60 PUSH1 0xc0 03D7 85 DUP6 03D8 01 ADD 03D9 52 MSTORE 03DA 60 PUSH1 0xe0 03DC 84 DUP5 03DD 01 ADD 03DE 52 MSTORE 03DF 63 PUSH4 0xffffffff 03E4 90 SWAP1 03E5 81 DUP2 03E6 16 AND 03E7 61 PUSH2 0x0100 03EA 84 DUP5 03EB 01 ADD 03EC 52 MSTORE 03ED 16 AND 03EE 61 PUSH2 0x0120 03F1 82 DUP3 03F2 01 ADD 03F3 52 MSTORE 03F4 61 PUSH2 0x0140 03F7 01 ADD 03F8 61 PUSH2 0x0259 03FB 56 *JUMP // Stack delta = -9 // Outputs[11] // { // @03B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-10] // @03B8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-9] // @03BF memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-8] // @03C7 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-7] // @03CF memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-6] // @03D4 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-5] // @03D9 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-4] // @03DE memory[memory[0x40:0x60] + 0xe0:memory[0x40:0x60] + 0xe0 + 0x20] = stack[-3] // @03EC memory[memory[0x40:0x60] + 0x0100:memory[0x40:0x60] + 0x0100 + 0x20] = 0xffffffff & stack[-2] // @03F3 memory[memory[0x40:0x60] + 0x0120:memory[0x40:0x60] + 0x0120 + 0x20] = 0xffffffff & stack[-1] // @03F7 stack[-10] = 0x0140 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_03FC: // Incoming jump from 0x021E, if 0x6386c1c7 == stack[-1] // Inputs[1] { @0403 msg.data.length } 03FC 5B JUMPDEST 03FD 61 PUSH2 0x040f 0400 61 PUSH2 0x040a 0403 36 CALLDATASIZE 0404 60 PUSH1 0x04 0406 61 PUSH2 0x3d29 0409 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03FD stack[0] = 0x040f // @0400 stack[1] = 0x040a // @0403 stack[2] = msg.data.length // @0404 stack[3] = 0x04 // } // Block ends with call to 0x3d29, returns to 0x040A label_040A: // Incoming return from call to 0x3D29 at 0x0409 040A 5B JUMPDEST 040B 61 PUSH2 0x1060 040E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1060 label_040F: // Incoming return from call to 0x040A at 0x0409 // Inputs[6] // { // @0413 memory[0x40:0x60] // @0414 stack[-5] // @041B stack[-4] // @041F stack[-1] // @0422 stack[-3] // @0423 stack[-2] // } 040F 5B JUMPDEST 0410 60 PUSH1 0x40 0412 80 DUP1 0413 51 MLOAD 0414 95 SWAP6 0415 86 DUP7 0416 52 MSTORE 0417 60 PUSH1 0x20 0419 86 DUP7 041A 01 ADD 041B 94 SWAP5 041C 90 SWAP1 041D 94 SWAP5 041E 52 MSTORE 041F 92 SWAP3 0420 84 DUP5 0421 01 ADD 0422 91 SWAP2 0423 90 SWAP1 0424 91 SWAP2 0425 52 MSTORE 0426 63 PUSH4 0xffffffff 042B 90 SWAP1 042C 81 DUP2 042D 16 AND 042E 60 PUSH1 0x60 0430 84 DUP5 0431 01 ADD 0432 52 MSTORE 0433 16 AND 0434 60 PUSH1 0x80 0436 82 DUP3 0437 01 ADD 0438 52 MSTORE 0439 60 PUSH1 0xa0 043B 01 ADD 043C 61 PUSH2 0x0259 043F 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @0416 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @041E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-4] // @0425 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-3] // @0432 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0xffffffff & stack[-2] // @0438 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = 0xffffffff & stack[-1] // @043B stack[-5] = 0xa0 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_0440: // Incoming jump from 0x0229, if 0x671bb4f1 == stack[-1] // Inputs[1] { @0447 msg.data.length } 0440 5B JUMPDEST 0441 61 PUSH2 0x0312 0444 61 PUSH2 0x044e 0447 36 CALLDATASIZE 0448 60 PUSH1 0x04 044A 61 PUSH2 0x3d44 044D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0441 stack[0] = 0x0312 // @0444 stack[1] = 0x044e // @0447 stack[2] = msg.data.length // @0448 stack[3] = 0x04 // } // Block ends with call to 0x3d44, returns to 0x044E label_044E: // Incoming return from call to 0x3D44 at 0x044D 044E 5B JUMPDEST 044F 61 PUSH2 0x10d5 0452 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10d5 label_0453: // Incoming jump from 0x0234, if 0x70a08231 == stack[-1] // Inputs[1] { @045A msg.data.length } 0453 5B JUMPDEST 0454 61 PUSH2 0x02b0 0457 61 PUSH2 0x0461 045A 36 CALLDATASIZE 045B 60 PUSH1 0x04 045D 61 PUSH2 0x3d29 0460 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0454 stack[0] = 0x02b0 // @0457 stack[1] = 0x0461 // @045A stack[2] = msg.data.length // @045B stack[3] = 0x04 // } // Block ends with call to 0x3d29, returns to 0x0461 label_0461: // Incoming return from call to 0x3D29 at 0x0460 // Inputs[4] // { // @046A stack[-1] // @0478 memory[0x00:0x40] // @0479 storage[keccak256(memory[0x00:0x40])] // @047A stack[-2] // } 0461 5B JUMPDEST 0462 60 PUSH1 0x01 0464 60 PUSH1 0x01 0466 60 PUSH1 0xa0 0468 1B SHL 0469 03 SUB 046A 16 AND 046B 60 PUSH1 0x00 046D 90 SWAP1 046E 81 DUP2 046F 52 MSTORE 0470 60 PUSH1 0x97 0472 60 PUSH1 0x20 0474 52 MSTORE 0475 60 PUSH1 0x40 0477 90 SWAP1 0478 20 SHA3 0479 54 SLOAD 047A 90 SWAP1 047B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @046F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0474 memory[0x20:0x40] = 0x97 // @047A stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_047C: // Incoming jump from 0x0035, if 0x74bbcb6a == stack[-1] // Inputs[1] { @0483 msg.data.length } 047C 5B JUMPDEST 047D 61 PUSH2 0x048f 0480 61 PUSH2 0x048a 0483 36 CALLDATASIZE 0484 60 PUSH1 0x04 0486 61 PUSH2 0x3a1a 0489 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @047D stack[0] = 0x048f // @0480 stack[1] = 0x048a // @0483 stack[2] = msg.data.length // @0484 stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x048A label_048A: // Incoming return from call to 0x3A1A at 0x0489 048A 5B JUMPDEST 048B 61 PUSH2 0x1128 048E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1128 label_048F: // Incoming return from call to 0x048A at 0x0489 // Inputs[4] // { // @0493 memory[0x40:0x60] // @0494 stack[-3] // @049B stack[-2] // @049F stack[-1] // } 048F 5B JUMPDEST 0490 60 PUSH1 0x40 0492 80 DUP1 0493 51 MLOAD 0494 93 SWAP4 0495 84 DUP5 0496 52 MSTORE 0497 60 PUSH1 0x20 0499 84 DUP5 049A 01 ADD 049B 92 SWAP3 049C 90 SWAP1 049D 92 SWAP3 049E 52 MSTORE 049F 90 SWAP1 04A0 82 DUP3 04A1 01 ADD 04A2 52 MSTORE 04A3 60 PUSH1 0x60 04A5 01 ADD 04A6 61 PUSH2 0x0259 04A9 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0496 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @049E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @04A2 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-1] // @04A5 stack[-3] = 0x60 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_04AA: // Incoming jump from 0x0040, if 0x7ecebe00 == stack[-1] // Inputs[1] { @04B1 msg.data.length } 04AA 5B JUMPDEST 04AB 61 PUSH2 0x02b0 04AE 61 PUSH2 0x04b8 04B1 36 CALLDATASIZE 04B2 60 PUSH1 0x04 04B4 61 PUSH2 0x3d29 04B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04AB stack[0] = 0x02b0 // @04AE stack[1] = 0x04b8 // @04B1 stack[2] = msg.data.length // @04B2 stack[3] = 0x04 // } // Block ends with call to 0x3d29, returns to 0x04B8 label_04B8: // Incoming return from call to 0x3D29 at 0x04B7 04B8 5B JUMPDEST 04B9 61 PUSH2 0x11d4 04BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11d4 label_04BD: // Incoming jump from 0x004B, if 0x82730ad4 == stack[-1] // Inputs[1] { @04C4 msg.data.length } 04BD 5B JUMPDEST 04BE 61 PUSH2 0x0312 04C1 61 PUSH2 0x04cb 04C4 36 CALLDATASIZE 04C5 60 PUSH1 0x04 04C7 61 PUSH2 0x3b5c 04CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04BE stack[0] = 0x0312 // @04C1 stack[1] = 0x04cb // @04C4 stack[2] = msg.data.length // @04C5 stack[3] = 0x04 // } // Block ends with call to 0x3b5c, returns to 0x04CB label_04CB: // Incoming return from call to 0x3B5C at 0x04CA 04CB 5B JUMPDEST 04CC 61 PUSH2 0x11f2 04CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11f2 label_04D0: // Incoming jump from 0x0056, if 0x840fe8ab == stack[-1] // Inputs[1] { @04D7 msg.data.length } 04D0 5B JUMPDEST 04D1 61 PUSH2 0x04e3 04D4 61 PUSH2 0x04de 04D7 36 CALLDATASIZE 04D8 60 PUSH1 0x04 04DA 61 PUSH2 0x3a1a 04DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04D1 stack[0] = 0x04e3 // @04D4 stack[1] = 0x04de // @04D7 stack[2] = msg.data.length // @04D8 stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x04DE label_04DE: // Incoming return from call to 0x3A1A at 0x04DD 04DE 5B JUMPDEST 04DF 61 PUSH2 0x1226 04E2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1226 label_04E3: // Incoming return from call to 0x04DE at 0x04DD // Inputs[7] // { // @04E7 memory[0x40:0x60] // @04E8 stack[-6] // @04EF stack[-5] // @04F3 stack[-1] // @04F6 stack[-4] // @04F7 stack[-2] // @04FE stack[-3] // } 04E3 5B JUMPDEST 04E4 60 PUSH1 0x40 04E6 80 DUP1 04E7 51 MLOAD 04E8 96 SWAP7 04E9 87 DUP8 04EA 52 MSTORE 04EB 60 PUSH1 0x20 04ED 87 DUP8 04EE 01 ADD 04EF 95 SWAP6 04F0 90 SWAP1 04F1 95 SWAP6 04F2 52 MSTORE 04F3 93 SWAP4 04F4 85 DUP6 04F5 01 ADD 04F6 92 SWAP3 04F7 90 SWAP1 04F8 92 SWAP3 04F9 52 MSTORE 04FA 60 PUSH1 0x60 04FC 84 DUP5 04FD 01 ADD 04FE 52 MSTORE 04FF 60 PUSH1 0x80 0501 83 DUP4 0502 01 ADD 0503 52 MSTORE 0504 60 PUSH1 0xa0 0506 82 DUP3 0507 01 ADD 0508 52 MSTORE 0509 60 PUSH1 0xc0 050B 01 ADD 050C 61 PUSH2 0x0259 050F 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @04EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6] // @04F2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-5] // @04F9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-4] // @04FE memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-3] // @0503 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-2] // @0508 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-1] // @050B stack[-6] = 0xc0 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_0510: // Incoming jump from 0x0061, if 0x857ac5c1 == stack[-1] // Inputs[1] { @0517 msg.data.length } 0510 5B JUMPDEST 0511 61 PUSH2 0x0523 0514 61 PUSH2 0x051e 0517 36 CALLDATASIZE 0518 60 PUSH1 0x04 051A 61 PUSH2 0x3bba 051D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0511 stack[0] = 0x0523 // @0514 stack[1] = 0x051e // @0517 stack[2] = msg.data.length // @0518 stack[3] = 0x04 // } // Block ends with call to 0x3bba, returns to 0x051E label_051E: // Incoming return from call to 0x3BBA at 0x051D 051E 5B JUMPDEST 051F 61 PUSH2 0x12b6 0522 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12b6 label_0523: // Incoming return from call to 0x0605 at 0x0604 // Incoming return from call to 0x051E at 0x051D // Inputs[3] // { // @0527 memory[0x40:0x60] // @0528 stack[-2] // @052F stack[-1] // } 0523 5B JUMPDEST 0524 60 PUSH1 0x40 0526 80 DUP1 0527 51 MLOAD 0528 92 SWAP3 0529 83 DUP4 052A 52 MSTORE 052B 60 PUSH1 0x20 052D 83 DUP4 052E 01 ADD 052F 91 SWAP2 0530 90 SWAP1 0531 91 SWAP2 0532 52 MSTORE 0533 01 ADD 0534 61 PUSH2 0x0259 0537 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @052A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0532 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0533 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_0538: // Incoming jump from 0x006C, if 0x8aec8542 == stack[-1] 0538 5B JUMPDEST 0539 61 PUSH2 0x02b0 053C 61 PUSH2 0x1318 053F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0539 stack[0] = 0x02b0 } // Block ends with unconditional jump to 0x1318 label_0540: // Incoming jump from 0x0077, if 0x8f52439a == stack[-1] // Inputs[1] { @0547 msg.data.length } 0540 5B JUMPDEST 0541 61 PUSH2 0x02b0 0544 61 PUSH2 0x054e 0547 36 CALLDATASIZE 0548 60 PUSH1 0x04 054A 61 PUSH2 0x3bba 054D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0541 stack[0] = 0x02b0 // @0544 stack[1] = 0x054e // @0547 stack[2] = msg.data.length // @0548 stack[3] = 0x04 // } // Block ends with call to 0x3bba, returns to 0x054E label_054E: // Incoming return from call to 0x3BBA at 0x054D 054E 5B JUMPDEST 054F 61 PUSH2 0x1371 0552 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1371 label_0553: // Incoming jump from 0x0082, if 0x91d14854 == stack[-1] // Inputs[1] { @055A msg.data.length } 0553 5B JUMPDEST 0554 61 PUSH2 0x024d 0557 61 PUSH2 0x0561 055A 36 CALLDATASIZE 055B 60 PUSH1 0x04 055D 61 PUSH2 0x3bd3 0560 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0554 stack[0] = 0x024d // @0557 stack[1] = 0x0561 // @055A stack[2] = msg.data.length // @055B stack[3] = 0x04 // } // Block ends with call to 0x3bd3, returns to 0x0561 label_0561: // Incoming return from call to 0x3BD3 at 0x0560 0561 5B JUMPDEST 0562 61 PUSH2 0x13b7 0565 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13b7 label_0566: // Incoming jump from 0x008D, if 0x91fcd9a9 == stack[-1] // Inputs[1] { @056D msg.data.length } 0566 5B JUMPDEST 0567 61 PUSH2 0x02b0 056A 61 PUSH2 0x0574 056D 36 CALLDATASIZE 056E 60 PUSH1 0x04 0570 61 PUSH2 0x3d29 0573 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0567 stack[0] = 0x02b0 // @056A stack[1] = 0x0574 // @056D stack[2] = msg.data.length // @056E stack[3] = 0x04 // } // Block ends with call to 0x3d29, returns to 0x0574 label_0574: // Incoming return from call to 0x3D29 at 0x0573 0574 5B JUMPDEST 0575 61 PUSH2 0x13e2 0578 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13e2 label_0579: // Incoming jump from 0x0098, if 0x95d89b41 == stack[-1] 0579 5B JUMPDEST 057A 61 PUSH2 0x026a 057D 61 PUSH2 0x13f8 0580 56 *JUMP // Stack delta = +1 // Outputs[1] { @057A stack[0] = 0x026a } // Block ends with call to 0x13f8, returns to 0x026A label_0581: // Incoming jump from 0x00A3, if 0x9a8a0592 == stack[-1] // Inputs[1] { @0582 CHAINID() } 0581 5B JUMPDEST 0582 46 CHAINID 0583 61 PUSH2 0x02b0 0586 56 *JUMP // Stack delta = +1 // Outputs[1] { @0582 stack[0] = CHAINID() } // Block ends with unconditional jump to 0x02b0 label_0587: // Incoming jump from 0x00AE, if 0xa217fddf == stack[-1] 0587 5B JUMPDEST 0588 61 PUSH2 0x02b0 058B 60 PUSH1 0x00 058D 81 DUP2 058E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0588 stack[0] = 0x02b0 // @058B stack[1] = 0x00 // } // Block ends with unconditional jump to 0x02b0 label_058F: // Incoming jump from 0x00B9, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0596 msg.data.length } 058F 5B JUMPDEST 0590 61 PUSH2 0x024d 0593 61 PUSH2 0x059d 0596 36 CALLDATASIZE 0597 60 PUSH1 0x04 0599 61 PUSH2 0x3a1a 059C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0590 stack[0] = 0x024d // @0593 stack[1] = 0x059d // @0596 stack[2] = msg.data.length // @0597 stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x059D label_059D: // Incoming return from call to 0x3A1A at 0x059C 059D 5B JUMPDEST 059E 61 PUSH2 0x1407 05A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1407 label_05A2: // Incoming jump from 0x00C4, if 0xa9059cbb == stack[-1] // Inputs[1] { @05A9 msg.data.length } 05A2 5B JUMPDEST 05A3 61 PUSH2 0x024d 05A6 61 PUSH2 0x05b0 05A9 36 CALLDATASIZE 05AA 60 PUSH1 0x04 05AC 61 PUSH2 0x3a1a 05AF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05A3 stack[0] = 0x024d // @05A6 stack[1] = 0x05b0 // @05A9 stack[2] = msg.data.length // @05AA stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x05B0 label_05B0: // Incoming return from call to 0x3A1A at 0x05AF 05B0 5B JUMPDEST 05B1 61 PUSH2 0x1482 05B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1482 label_05B5: // Incoming jump from 0x00CF, if 0xb54d321d == stack[-1] // Inputs[1] { @05B9 storage[0x0173] } 05B5 5B JUMPDEST 05B6 61 PUSH2 0x0173 05B9 54 SLOAD 05BA 61 PUSH2 0x02b0 05BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @05B9 stack[0] = storage[0x0173] } // Block ends with unconditional jump to 0x02b0 label_05BE: // Incoming jump from 0x00DA, if 0xd505accf == stack[-1] // Inputs[1] { @05C5 msg.data.length } 05BE 5B JUMPDEST 05BF 61 PUSH2 0x0312 05C2 61 PUSH2 0x05cc 05C5 36 CALLDATASIZE 05C6 60 PUSH1 0x04 05C8 61 PUSH2 0x3d77 05CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05BF stack[0] = 0x0312 // @05C2 stack[1] = 0x05cc // @05C5 stack[2] = msg.data.length // @05C6 stack[3] = 0x04 // } // Block ends with call to 0x3d77, returns to 0x05CC label_05CC: // Incoming return from call to 0x3D77 at 0x05CB 05CC 5B JUMPDEST 05CD 61 PUSH2 0x1490 05D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1490 label_05D1: // Incoming jump from 0x00E5, if 0xd547741f == stack[-1] // Inputs[1] { @05D8 msg.data.length } 05D1 5B JUMPDEST 05D2 61 PUSH2 0x0312 05D5 61 PUSH2 0x05df 05D8 36 CALLDATASIZE 05D9 60 PUSH1 0x04 05DB 61 PUSH2 0x3bd3 05DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05D2 stack[0] = 0x0312 // @05D5 stack[1] = 0x05df // @05D8 stack[2] = msg.data.length // @05D9 stack[3] = 0x04 // } // Block ends with call to 0x3bd3, returns to 0x05DF label_05DF: // Incoming return from call to 0x3BD3 at 0x05DE 05DF 5B JUMPDEST 05E0 61 PUSH2 0x15f4 05E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15f4 label_05E4: // Incoming jump from 0x00F0, if 0xdd62ed3e == stack[-1] // Inputs[1] { @05EB msg.data.length } 05E4 5B JUMPDEST 05E5 61 PUSH2 0x02b0 05E8 61 PUSH2 0x05f2 05EB 36 CALLDATASIZE 05EC 60 PUSH1 0x04 05EE 61 PUSH2 0x3de1 05F1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05E5 stack[0] = 0x02b0 // @05E8 stack[1] = 0x05f2 // @05EB stack[2] = msg.data.length // @05EC stack[3] = 0x04 // } // Block ends with unconditional jump to 0x3de1 05F2 5B JUMPDEST 05F3 61 PUSH2 0x1610 05F6 56 *JUMP label_05F7: // Incoming jump from 0x00FB, if 0xe044c1ce == stack[-1] // Inputs[1] { @05FE msg.data.length } 05F7 5B JUMPDEST 05F8 61 PUSH2 0x0523 05FB 61 PUSH2 0x0605 05FE 36 CALLDATASIZE 05FF 60 PUSH1 0x04 0601 61 PUSH2 0x3a1a 0604 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05F8 stack[0] = 0x0523 // @05FB stack[1] = 0x0605 // @05FE stack[2] = msg.data.length // @05FF stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x0605 label_0605: // Incoming return from call to 0x3A1A at 0x0604 0605 5B JUMPDEST 0606 61 PUSH2 0x163b 0609 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x163b label_060A: // Incoming jump from 0x0106, if 0xe06174e4 == stack[-1] // Inputs[4] // { // @060E storage[0x0171] // @0612 storage[0x0172] // @0616 storage[0x0174] // @061A memory[0x40:0x60] // } 060A 5B JUMPDEST 060B 61 PUSH2 0x0171 060E 54 SLOAD 060F 61 PUSH2 0x0172 0612 54 SLOAD 0613 61 PUSH2 0x0174 0616 54 SLOAD 0617 60 PUSH1 0x40 0619 80 DUP1 061A 51 MLOAD 061B 93 SWAP4 061C 84 DUP5 061D 52 MSTORE 061E 60 PUSH1 0x20 0620 84 DUP5 0621 01 ADD 0622 92 SWAP3 0623 90 SWAP1 0624 92 SWAP3 0625 52 MSTORE 0626 60 PUSH1 0x01 0628 60 PUSH1 0x01 062A 60 PUSH1 0xa0 062C 1B SHL 062D 03 SUB 062E 16 AND 062F 90 SWAP1 0630 82 DUP3 0631 01 ADD 0632 52 MSTORE 0633 60 PUSH1 0x60 0635 01 ADD 0636 61 PUSH2 0x0259 0639 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @061D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0171] // @0625 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[0x0172] // @0632 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x0174] // @0635 stack[0] = 0x60 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0259 label_063A: // Incoming jump from 0x0111, if 0xe06fbe47 == stack[-1] 063A 5B JUMPDEST 063B 61 PUSH2 0x02b0 063E 61 PUSH2 0x16d1 0641 56 *JUMP // Stack delta = +1 // Outputs[1] { @063B stack[0] = 0x02b0 } // Block ends with call to 0x16d1, returns to 0x02B0 label_0642: // Incoming jump from 0x011C, if 0xe35fba6c == stack[-1] // Inputs[1] { @0649 msg.data.length } 0642 5B JUMPDEST 0643 61 PUSH2 0x024d 0646 61 PUSH2 0x0650 0649 36 CALLDATASIZE 064A 60 PUSH1 0x04 064C 61 PUSH2 0x3a1a 064F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0643 stack[0] = 0x024d // @0646 stack[1] = 0x0650 // @0649 stack[2] = msg.data.length // @064A stack[3] = 0x04 // } // Block ends with call to 0x3a1a, returns to 0x0650 label_0650: // Incoming return from call to 0x3A1A at 0x064F 0650 5B JUMPDEST 0651 61 PUSH2 0x1717 0654 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1717 label_0655: // Incoming jump from 0x0127, if 0xee964f36 == stack[-1] 0655 5B JUMPDEST 0656 61 PUSH2 0x0312 0659 61 PUSH2 0x1bdc 065C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0656 stack[0] = 0x0312 } // Block ends with call to 0x1bdc, returns to 0x0312 label_065D: // Incoming jump from 0x0132, if 0xf9fec849 == stack[-1] // Inputs[1] { @0664 msg.data.length } 065D 5B JUMPDEST 065E 61 PUSH2 0x02b0 0661 61 PUSH2 0x066b 0664 36 CALLDATASIZE 0665 60 PUSH1 0x04 0667 61 PUSH2 0x3bba 066A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @065E stack[0] = 0x02b0 // @0661 stack[1] = 0x066b // @0664 stack[2] = msg.data.length // @0665 stack[3] = 0x04 // } // Block ends with call to 0x3bba, returns to 0x066B label_066B: // Incoming return from call to 0x3BBA at 0x066A 066B 5B JUMPDEST 066C 61 PUSH2 0x1d67 066F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d67 label_0670: // Incoming jump from 0x024C // Inputs[1] { @067C stack[-1] } 0670 5B JUMPDEST 0671 60 PUSH1 0x00 0673 60 PUSH1 0x01 0675 60 PUSH1 0x01 0677 60 PUSH1 0xe0 0679 1B SHL 067A 03 SUB 067B 19 NOT 067C 82 DUP3 067D 16 AND 067E 63 PUSH4 0x7965db0b 0683 60 PUSH1 0xe0 0685 1B SHL 0686 14 EQ 0687 80 DUP1 0688 61 PUSH2 0x06a1 068B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0671 stack[0] = 0x00 // @0686 stack[1] = 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x06a1, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_068C: // Incoming jump from 0x068B, if not 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[2] // { // @069E stack[-3] // @06A2 stack[-4] // } 068C 50 POP 068D 63 PUSH4 0x01ffc9a7 0692 60 PUSH1 0xe0 0694 1B SHL 0695 60 PUSH1 0x01 0697 60 PUSH1 0x01 0699 60 PUSH1 0xe0 069B 1B SHL 069C 03 SUB 069D 19 NOT 069E 83 DUP4 069F 16 AND 06A0 14 EQ 06A1 5B JUMPDEST 06A2 92 SWAP3 06A3 91 SWAP2 06A4 50 POP 06A5 50 POP 06A6 56 *JUMP // Stack delta = -3 // Outputs[1] { @06A2 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_06A7: // Incoming call from 0x3060, returns to 0x3061 // Incoming call from 0x0269, returns to 0x026A // Inputs[1] { @06AD storage[0x9a] } 06A7 5B JUMPDEST 06A8 60 PUSH1 0x60 06AA 60 PUSH1 0x9a 06AC 80 DUP1 06AD 54 SLOAD 06AE 61 PUSH2 0x06b6 06B1 90 SWAP1 06B2 61 PUSH2 0x3e0b 06B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06A8 stack[0] = 0x60 // @06AA stack[1] = 0x9a // @06B1 stack[2] = 0x06b6 // @06B1 stack[3] = storage[0x9a] // } // Block ends with call to 0x3e0b, returns to 0x06B6 label_06B6: // Incoming return from call to 0x3E0B at 0x1406 // Incoming return from call to 0x3E0B at 0x06B5 // Inputs[4] // { // @06B7 stack[-1] // @06C6 memory[0x40:0x60] // @06CE stack[-2] // @06D9 storage[stack[-2]] // } 06B6 5B JUMPDEST 06B7 80 DUP1 06B8 60 PUSH1 0x1f 06BA 01 ADD 06BB 60 PUSH1 0x20 06BD 80 DUP1 06BE 91 SWAP2 06BF 04 DIV 06C0 02 MUL 06C1 60 PUSH1 0x20 06C3 01 ADD 06C4 60 PUSH1 0x40 06C6 51 MLOAD 06C7 90 SWAP1 06C8 81 DUP2 06C9 01 ADD 06CA 60 PUSH1 0x40 06CC 52 MSTORE 06CD 80 DUP1 06CE 92 SWAP3 06CF 91 SWAP2 06D0 90 SWAP1 06D1 81 DUP2 06D2 81 DUP2 06D3 52 MSTORE 06D4 60 PUSH1 0x20 06D6 01 ADD 06D7 82 DUP3 06D8 80 DUP1 06D9 54 SLOAD 06DA 61 PUSH2 0x06e2 06DD 90 SWAP1 06DE 61 PUSH2 0x3e0b 06E1 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06CC memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06CE stack[-2] = memory[0x40:0x60] // @06CF stack[-1] = stack[-2] // @06D0 stack[0] = stack[-1] // @06D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06D6 stack[1] = 0x20 + memory[0x40:0x60] // @06D7 stack[2] = stack[-2] // @06DD stack[4] = storage[stack[-2]] // @06DD stack[3] = 0x06e2 // } // Block ends with call to 0x3e0b, returns to 0x06E2 label_06E2: // Incoming return from call to 0x3E0B at 0x06E1 // Inputs[1] { @06E3 stack[-1] } 06E2 5B JUMPDEST 06E3 80 DUP1 06E4 15 ISZERO 06E5 61 PUSH2 0x072f 06E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x072f, if !stack[-1] label_06E9: // Incoming jump from 0x06E8, if not !stack[-1] // Inputs[1] { @06E9 stack[-1] } 06E9 80 DUP1 06EA 60 PUSH1 0x1f 06EC 10 LT 06ED 61 PUSH2 0x0704 06F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0704, if 0x1f < stack[-1] label_06F1: // Incoming jump from 0x06F0, if not 0x1f < stack[-1] // Inputs[4] // { // @06F5 stack[-2] // @06F6 storage[stack[-2]] // @06F9 stack[-3] // @06FB stack[-1] // } 06F1 61 PUSH2 0x0100 06F4 80 DUP1 06F5 83 DUP4 06F6 54 SLOAD 06F7 04 DIV 06F8 02 MUL 06F9 83 DUP4 06FA 52 MSTORE 06FB 91 SWAP2 06FC 60 PUSH1 0x20 06FE 01 ADD 06FF 91 SWAP2 0700 61 PUSH2 0x072f 0703 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06FA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06FF stack[-1] = stack[-1] // @06FF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x072f label_0704: // Incoming jump from 0x06F0, if 0x1f < stack[-1] // Inputs[5] // { // @0705 stack[-3] // @0706 stack[-1] // @0708 stack[-2] // @0710 memory[0x00:0x20] // @0714 storage[keccak256(memory[0x00:0x20])] // } 0704 5B JUMPDEST 0705 82 DUP3 0706 01 ADD 0707 91 SWAP2 0708 90 SWAP1 0709 60 PUSH1 0x00 070B 52 MSTORE 070C 60 PUSH1 0x20 070E 60 PUSH1 0x00 0710 20 SHA3 0711 90 SWAP1 0712 5B JUMPDEST 0713 81 DUP2 0714 54 SLOAD 0715 81 DUP2 0716 52 MSTORE 0717 90 SWAP1 0718 60 PUSH1 0x01 071A 01 ADD 071B 90 SWAP1 071C 60 PUSH1 0x20 071E 01 ADD 071F 80 DUP1 0720 83 DUP4 0721 11 GT 0722 61 PUSH2 0x0712 0725 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0707 stack[-3] = stack[-3] + stack[-1] // @070B memory[0x00:0x20] = stack[-2] // @0716 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @071B stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @071E stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0712, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0726: // Incoming jump from 0x0725, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0725, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0726 stack[-3] // @0727 stack[-1] // } 0726 82 DUP3 0727 90 SWAP1 0728 03 SUB 0729 60 PUSH1 0x1f 072B 16 AND 072C 82 DUP3 072D 01 ADD 072E 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @072E stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @072E stack[-1] = stack[-3] // } // Block continues label_072F: // Incoming jump from 0x0703 // Incoming jump from 0x06E8, if !stack[-1] // Incoming jump from 0x072E // Inputs[3] // { // @0735 stack[-6] // @0735 stack[-7] // @0737 stack[-8] // } 072F 5B JUMPDEST 0730 50 POP 0731 50 POP 0732 50 POP 0733 50 POP 0734 50 POP 0735 90 SWAP1 0736 50 POP 0737 90 SWAP1 0738 56 *JUMP // Stack delta = -7 // Outputs[1] { @0737 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0739: // Incoming jump from 0x0289 // Inputs[3] // { // @073C msg.sender // @0741 stack[-2] // @0742 stack[-1] // } 0739 5B JUMPDEST 073A 60 PUSH1 0x00 073C 33 CALLER 073D 61 PUSH2 0x0747 0740 81 DUP2 0741 85 DUP6 0742 85 DUP6 0743 61 PUSH2 0x1dc0 0746 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @073A stack[0] = 0x00 // @073C stack[1] = msg.sender // @073D stack[2] = 0x0747 // @0740 stack[3] = msg.sender // @0741 stack[4] = stack[-2] // @0742 stack[5] = stack[-1] // } // Block ends with call to 0x1dc0, returns to 0x0747 label_0747: // Incoming return from call to 0x0CE9 at 0x0CE8 // Incoming return from call to 0x2107 at 0x148F // Incoming return from call to 0x1DC0 at 0x0746 // Inputs[2] // { // @074B stack[-5] // @074C stack[-4] // } 0747 5B JUMPDEST 0748 50 POP 0749 60 PUSH1 0x01 074B 93 SWAP4 074C 92 SWAP3 074D 50 POP 074E 50 POP 074F 50 POP 0750 56 *JUMP // Stack delta = -4 // Outputs[1] { @074B stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0751: // Incoming jump from 0x029C // Inputs[2] // { // @0757 stack[-6] // @075A stack[-2] // } 0751 5B JUMPDEST 0752 60 PUSH1 0x00 0754 61 PUSH2 0x075f 0757 87 DUP8 0758 60 PUSH1 0x03 075A 85 DUP6 075B 61 PUSH2 0x1ee4 075E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0752 stack[0] = 0x00 // @0754 stack[1] = 0x075f // @0757 stack[2] = stack[-6] // @0758 stack[3] = 0x03 // @075A stack[4] = stack[-2] // } // Block ends with call to 0x1ee4, returns to 0x075F label_075F: // Incoming return from call to 0x1EE4 at 0x075E // Inputs[8] // { // @0760 stack[-5] // @0761 stack[-4] // @0767 CHAINID() // @0768 address(this) // @0769 stack[-7] // @076A stack[-6] // @076D stack[-3] // @0770 memory[0x40:0x60] // } 075F 5B JUMPDEST 0760 84 DUP5 0761 84 DUP5 0762 01 ADD 0763 60 PUSH1 0x00 0765 60 PUSH1 0x03 0767 46 CHAINID 0768 30 ADDRESS 0769 8B DUP12 076A 8B DUP12 076B 8B DUP12 076C 8B DUP12 076D 8B DUP12 076E 60 PUSH1 0x40 0770 51 MLOAD 0771 60 PUSH1 0x20 0773 01 ADD 0774 61 PUSH2 0x0784 0777 98 SWAP9 0778 97 SWAP8 0779 96 SWAP7 077A 95 SWAP6 077B 94 SWAP5 077C 93 SWAP4 077D 92 SWAP3 077E 91 SWAP2 077F 90 SWAP1 0780 61 PUSH2 0x3e56 0783 56 *JUMP // Stack delta = +12 // Outputs[12] // { // @0762 stack[0] = stack[-4] + stack[-5] // @0763 stack[1] = 0x00 // @0777 stack[2] = 0x0784 // @0778 stack[3] = 0x03 // @0779 stack[4] = CHAINID() // @077A stack[5] = address(this) // @077B stack[6] = stack[-7] // @077C stack[7] = stack[-6] // @077D stack[8] = stack[-5] // @077E stack[9] = stack[-4] // @077F stack[10] = stack[-3] // @077F stack[11] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3e56, returns to 0x0784 label_0784: // Incoming return from call to 0x3E56 at 0x0783 // Inputs[7] // { // @0787 memory[0x40:0x60] // @078B stack[-1] // @0795 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @079A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @079B stack[-2] // @07A1 stack[-10] // @07A2 stack[-5] // } 0784 5B JUMPDEST 0785 60 PUSH1 0x40 0787 51 MLOAD 0788 60 PUSH1 0x20 078A 81 DUP2 078B 83 DUP4 078C 03 SUB 078D 03 SUB 078E 81 DUP2 078F 52 MSTORE 0790 90 SWAP1 0791 60 PUSH1 0x40 0793 52 MSTORE 0794 80 DUP1 0795 51 MLOAD 0796 90 SWAP1 0797 60 PUSH1 0x20 0799 01 ADD 079A 20 SHA3 079B 90 SWAP1 079C 50 POP 079D 61 PUSH2 0x07a7 07A0 81 DUP2 07A1 8A DUP11 07A2 86 DUP7 07A3 61 PUSH2 0x2026 07A6 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @078F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0793 memory[0x40:0x60] = stack[-1] // @079B stack[-2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @079D stack[-1] = 0x07a7 // @07A0 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @07A1 stack[1] = stack[-10] // @07A2 stack[2] = stack[-5] // } // Block ends with call to 0x2026, returns to 0x07A7 label_07A7: // Incoming return from call to 0x2026 at 0x07A6 // Inputs[3] // { // @07AC stack[-10] // @07AD stack[-7] // @07AE msg.sender // } 07A7 5B JUMPDEST 07A8 50 POP 07A9 61 PUSH2 0x07b3 07AC 89 DUP10 07AD 87 DUP8 07AE 33 CALLER 07AF 61 PUSH2 0x20fa 07B2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07A9 stack[-1] = 0x07b3 // @07AC stack[0] = stack[-10] // @07AD stack[1] = stack[-7] // @07AE stack[2] = msg.sender // } // Block ends with call to 0x20fa, returns to 0x07B3 label_07B3: // Incoming return from call to 0x20FA at 0x07B2 // Inputs[3] // { // @07B7 stack[-9] // @07B8 stack[-8] // @07B9 stack[-7] // } 07B3 5B JUMPDEST 07B4 61 PUSH2 0x07be 07B7 89 DUP10 07B8 89 DUP10 07B9 89 DUP10 07BA 61 PUSH2 0x2107 07BD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07B4 stack[0] = 0x07be // @07B7 stack[1] = stack[-9] // @07B8 stack[2] = stack[-8] // @07B9 stack[3] = stack[-7] // } // Block ends with call to 0x2107, returns to 0x07BE label_07BE: // Incoming return from call to 0x2107 at 0x07BD // Inputs[2] // { // @07C2 stack[-10] // @07C3 stack[-9] // } 07BE 5B JUMPDEST 07BF 50 POP 07C0 60 PUSH1 0x01 07C2 98 SWAP9 07C3 97 SWAP8 07C4 50 POP 07C5 50 POP 07C6 50 POP 07C7 50 POP 07C8 50 POP 07C9 50 POP 07CA 50 POP 07CB 50 POP 07CC 56 *JUMP // Stack delta = -9 // Outputs[1] { @07C2 stack[-10] = 0x01 } // Block ends with unconditional jump to stack[-10] label_07CD: // Incoming jump from 0x02AF // Inputs[2] // { // @07D3 stack[-2] // @07D4 stack[-1] // } 07CD 5B JUMPDEST 07CE 60 PUSH1 0x00 07D0 61 PUSH2 0x07d9 07D3 83 DUP4 07D4 83 DUP4 07D5 61 PUSH2 0x22d7 07D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07CE stack[0] = 0x00 // @07D0 stack[1] = 0x07d9 // @07D3 stack[2] = stack[-2] // @07D4 stack[3] = stack[-1] // } // Block ends with call to 0x22d7, returns to 0x07D9 label_07D9: // Incoming return from call to 0x41A1 at 0x424D // Incoming return from call to 0x41A1 at 0x424D // Incoming jump from 0x367B, if !stack[-5] // Incoming jump from 0x399A, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x3A5A at 0x3C1E // Incoming return from call to 0x22D7 at 0x07D8 // Incoming return from call to 0x22D7 at 0x07D8 // Incoming return from call to 0x39FE at 0x3D43 // Inputs[3] // { // @07DA stack[-5] // @07DA stack[-1] // @07DB stack[-4] // } 07D9 5B JUMPDEST 07DA 93 SWAP4 07DB 92 SWAP3 07DC 50 POP 07DD 50 POP 07DE 50 POP 07DF 56 *JUMP // Stack delta = -4 // Outputs[1] { @07DA stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_07E0: // Incoming jump from 0x02D0 // Inputs[2] // { // @07E4 storage[0x0174] // @07F1 msg.sender // } 07E0 5B JUMPDEST 07E1 61 PUSH2 0x0174 07E4 54 SLOAD 07E5 60 PUSH1 0x00 07E7 90 SWAP1 07E8 60 PUSH1 0x01 07EA 60 PUSH1 0x01 07EC 60 PUSH1 0xa0 07EE 1B SHL 07EF 03 SUB 07F0 16 AND 07F1 33 CALLER 07F2 60 PUSH1 0x01 07F4 60 PUSH1 0x01 07F6 60 PUSH1 0xa0 07F8 1B SHL 07F9 03 SUB 07FA 16 AND 07FB 14 EQ 07FC 61 PUSH2 0x0820 07FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E7 stack[0] = 0x00 } // Block ends with conditional jump to 0x0820, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] label_0800: // Incoming jump from 0x07FF, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] // Inputs[1] { @0802 memory[0x40:0x60] } 0800 60 PUSH1 0x40 0802 51 MLOAD 0803 62 PUSH3 0x461bcd 0807 60 PUSH1 0xe5 0809 1B SHL 080A 81 DUP2 080B 52 MSTORE 080C 60 PUSH1 0x04 080E 01 ADD 080F 61 PUSH2 0x0817 0812 90 SWAP1 0813 61 PUSH2 0x3eca 0816 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @080B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0812 stack[0] = 0x0817 // @0812 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3eca, returns to 0x0817 label_0817: // Incoming return from call to 0x42B1 at 0x309D // Incoming return from call to 0x3FE8 at 0x1218 // Incoming jump from 0x216A // Incoming jump from 0x2596 // Incoming return from call to 0x3ECA at 0x0816 // Incoming jump from 0x118B // Incoming jump from 0x34BA // Incoming jump from 0x1E21 // Incoming jump from 0x2F28 // Incoming return from call to 0x3ECA at 0x174D // Incoming jump from 0x14DF // Incoming jump from 0x36C2 // Incoming return from call to 0x42B1 at 0x387C // Incoming return from call to 0x3EFF at 0x176D // Incoming return from call to 0x40E7 at 0x1686 // Incoming return from call to 0x3FE8 at 0x10FB // Incoming jump from 0x2244 // Incoming jump from 0x252A // Incoming jump from 0x1474 // Incoming jump from 0x3793 // Incoming jump from 0x0D94 // Incoming jump from 0x20ED // Incoming return from call to 0x4113 at 0x133B // Incoming jump from 0x0ED2 // Incoming return from call to 0x42B1 at 0x2A5E // Incoming return from call to 0x42B1 at 0x2A35 // Incoming return from call to 0x40E7 at 0x12E9 // Incoming return from call to 0x39CB at 0x3056 // Incoming return from call to 0x42B1 at 0x36E9 // Incoming jump from 0x09AB // Incoming jump from 0x0C93 // Incoming return from call to 0x3EFF at 0x083F // Incoming jump from 0x344D // Incoming return from call to 0x4113 at 0x1D8A // Incoming jump from 0x1FB4 // Incoming return from call to 0x4037 at 0x0E78 // Incoming return from call to 0x3FE8 at 0x0CC8 // Incoming jump from 0x21CC // Incoming jump from 0x1E82 // Incoming jump from 0x288B // Incoming jump from 0x337E // Incoming jump from 0x33E0 // Inputs[3] // { // @081A memory[0x40:0x60] // @081C stack[-1] // @081F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0817 5B JUMPDEST 0818 60 PUSH1 0x40 081A 51 MLOAD 081B 80 DUP1 081C 91 SWAP2 081D 03 SUB 081E 90 SWAP1 081F FD *REVERT // Stack delta = -1 // Outputs[1] { @081F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0820: // Incoming jump from 0x07FF, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] // Inputs[1] { @0823 stack[-2] } 0820 5B JUMPDEST 0821 60 PUSH1 0x00 0823 82 DUP3 0824 11 GT 0825 61 PUSH2 0x0840 0828 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0840, if stack[-2] > 0x00 label_0829: // Incoming jump from 0x0828, if not stack[-2] > 0x00 // 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 0x0817 083B 90 SWAP1 083C 61 PUSH2 0x3eff 083F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0834 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @083B stack[0] = 0x0817 // @083B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3eff, returns to 0x0817 label_0840: // Incoming jump from 0x0828, if stack[-2] > 0x00 // Inputs[3] // { // @0849 stack[-3] // @0859 memory[0x00:0x40] // @085D storage[0x02 + keccak256(memory[0x00:0x40])] // } 0840 5B JUMPDEST 0841 60 PUSH1 0x01 0843 60 PUSH1 0x01 0845 60 PUSH1 0xa0 0847 1B SHL 0848 03 SUB 0849 83 DUP4 084A 16 AND 084B 60 PUSH1 0x00 084D 90 SWAP1 084E 81 DUP2 084F 52 MSTORE 0850 61 PUSH2 0x0166 0853 60 PUSH1 0x20 0855 52 MSTORE 0856 60 PUSH1 0x40 0858 90 SWAP1 0859 20 SHA3 085A 60 PUSH1 0x02 085C 01 ADD 085D 54 SLOAD 085E 63 PUSH4 0xffffffff 0863 16 AND 0864 61 PUSH2 0x088c 0867 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @084F memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0855 memory[0x20:0x40] = 0x0166 // } // Block ends with conditional jump to 0x088c, if 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] label_0868: // Incoming jump from 0x0867, if not 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0870 stack[-3] // @0880 memory[0x00:0x40] // } 0868 60 PUSH1 0x01 086A 60 PUSH1 0x01 086C 60 PUSH1 0xa0 086E 1B SHL 086F 03 SUB 0870 83 DUP4 0871 16 AND 0872 60 PUSH1 0x00 0874 90 SWAP1 0875 81 DUP2 0876 52 MSTORE 0877 61 PUSH2 0x0166 087A 60 PUSH1 0x20 087C 52 MSTORE 087D 60 PUSH1 0x40 087F 90 SWAP1 0880 20 SHA3 0881 61 PUSH2 0x088c 0884 90 SWAP1 0885 60 PUSH1 0x01 0887 01 ADD 0888 61 PUSH2 0x23e0 088B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0876 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @087C memory[0x20:0x40] = 0x0166 // @0884 stack[0] = 0x088c // @0887 stack[1] = 0x01 + keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x23e0, returns to 0x088C label_088C: // Incoming jump from 0x0867, if 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] // Incoming return from call to 0x23E0 at 0x088B // Inputs[2] // { // @0890 stack[-3] // @0891 block.number // } 088C 5B JUMPDEST 088D 61 PUSH2 0x0896 0890 83 DUP4 0891 43 NUMBER 0892 61 PUSH2 0x23f9 0895 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @088D stack[0] = 0x0896 // @0890 stack[1] = stack[-3] // @0891 stack[2] = block.number // } // Block ends with call to 0x23f9, returns to 0x0896 label_0896: // Incoming return from call to 0x23F9 at 0x0895 // Inputs[4] // { // @089F stack[-4] // @08AF memory[0x00:0x40] // @08B1 storage[keccak256(memory[0x00:0x40])] // @08B9 stack[-1] // } 0896 5B JUMPDEST 0897 60 PUSH1 0x01 0899 60 PUSH1 0x01 089B 60 PUSH1 0xa0 089D 1B SHL 089E 03 SUB 089F 84 DUP5 08A0 16 AND 08A1 60 PUSH1 0x00 08A3 90 SWAP1 08A4 81 DUP2 08A5 52 MSTORE 08A6 61 PUSH2 0x0166 08A9 60 PUSH1 0x20 08AB 52 MSTORE 08AC 60 PUSH1 0x40 08AE 81 DUP2 08AF 20 SHA3 08B0 80 DUP1 08B1 54 SLOAD 08B2 90 SWAP1 08B3 91 SWAP2 08B4 90 SWAP1 08B5 61 PUSH2 0x08bf 08B8 90 SWAP1 08B9 84 DUP5 08BA 90 SWAP1 08BB 61 PUSH2 0x3f5f 08BE 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @08A5 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @08AB memory[0x20:0x40] = 0x0166 // @08B3 stack[0] = keccak256(memory[0x00:0x40]) // @08B4 stack[1] = 0x00 // @08B8 stack[2] = 0x08bf // @08BA stack[3] = stack[-1] // @08BA stack[4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3f5f, returns to 0x08BF label_08BF: // Incoming return from call to 0x3F5F at 0x08BE // Inputs[5] // { // @08C0 stack[-2] // @08C0 stack[-1] // @08C1 stack[-3] // @08C8 storage[0x0173] // @08D4 block.number // } 08BF 5B JUMPDEST 08C0 90 SWAP1 08C1 91 SWAP2 08C2 55 SSTORE 08C3 50 POP 08C4 50 POP 08C5 61 PUSH2 0x0173 08C8 54 SLOAD 08C9 60 PUSH1 0x00 08CB 90 SWAP1 08CC 61 PUSH2 0x08de 08CF 90 SWAP1 08D0 61 PUSH2 0x08d9 08D3 90 SWAP1 08D4 43 NUMBER 08D5 61 PUSH2 0x3f5f 08D8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08C2 storage[stack[-3]] = stack[-1] // @08CB stack[-4] = 0x00 // @08CF stack[-3] = 0x08de // @08D3 stack[-2] = 0x08d9 // @08D3 stack[-1] = storage[0x0173] // @08D4 stack[0] = block.number // } // Block ends with call to 0x3f5f, returns to 0x08D9 label_08D9: // Incoming return from call to 0x3F5F at 0x08D8 08D9 5B JUMPDEST 08DA 61 PUSH2 0x24c6 08DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x24c6 label_08DE: // Incoming return from call to 0x08D9 at 0x08D8 // Inputs[5] // { // @08E7 stack[-5] // @08F7 memory[0x00:0x40] // @08FB storage[0x06 + keccak256(memory[0x00:0x40])] // @08FC stack[-1] // @08FD stack[-2] // } 08DE 5B JUMPDEST 08DF 60 PUSH1 0x01 08E1 60 PUSH1 0x01 08E3 60 PUSH1 0xa0 08E5 1B SHL 08E6 03 SUB 08E7 85 DUP6 08E8 16 AND 08E9 60 PUSH1 0x00 08EB 90 SWAP1 08EC 81 DUP2 08ED 52 MSTORE 08EE 61 PUSH2 0x0166 08F1 60 PUSH1 0x20 08F3 52 MSTORE 08F4 60 PUSH1 0x40 08F6 90 SWAP1 08F7 20 SHA3 08F8 60 PUSH1 0x06 08FA 01 ADD 08FB 54 SLOAD 08FC 90 SWAP1 08FD 91 SWAP2 08FE 50 POP 08FF 15 ISZERO 0900 61 PUSH2 0x09ac 0903 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @08ED memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @08F3 memory[0x20:0x40] = 0x0166 // @08FD stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x09ac, if !storage[0x06 + keccak256(memory[0x00:0x40])] label_0904: // Incoming jump from 0x0903, if not !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[3] // { // @090C stack[-4] // @091C memory[0x00:0x40] // @0921 storage[keccak256(memory[0x00:0x40]) + 0x06] // } 0904 60 PUSH1 0x01 0906 60 PUSH1 0x01 0908 60 PUSH1 0xa0 090A 1B SHL 090B 03 SUB 090C 84 DUP5 090D 16 AND 090E 60 PUSH1 0x00 0910 90 SWAP1 0911 81 DUP2 0912 52 MSTORE 0913 61 PUSH2 0x0166 0916 60 PUSH1 0x20 0918 52 MSTORE 0919 60 PUSH1 0x40 091B 81 DUP2 091C 20 SHA3 091D 60 PUSH1 0x06 091F 81 DUP2 0920 01 ADD 0921 54 SLOAD 0922 60 PUSH1 0x05 0924 90 SWAP1 0925 91 SWAP2 0926 01 ADD 0927 91 SWAP2 0928 90 SWAP1 0929 61 PUSH2 0x0934 092C 90 SWAP1 092D 60 PUSH1 0x01 092F 90 SWAP1 0930 61 PUSH2 0x3f77 0933 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0912 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0918 memory[0x20:0x40] = 0x0166 // @0927 stack[0] = keccak256(memory[0x00:0x40]) + 0x05 // @0928 stack[1] = 0x00 // @092C stack[2] = 0x0934 // @092F stack[3] = 0x01 // @092F stack[4] = storage[keccak256(memory[0x00:0x40]) + 0x06] // } // Block ends with call to 0x3f77, returns to 0x0934 label_0934: // Incoming return from call to 0x3F77 at 0x0933 // Inputs[6] // { // @0935 stack[-2] // @0936 stack[-1] // @093A stack[-3] // @0942 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0943 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @0944 stack[-4] // } 0934 5B JUMPDEST 0935 81 DUP2 0936 52 MSTORE 0937 60 PUSH1 0x20 0939 01 ADD 093A 90 SWAP1 093B 81 DUP2 093C 52 MSTORE 093D 60 PUSH1 0x20 093F 01 ADD 0940 60 PUSH1 0x00 0942 20 SHA3 0943 54 SLOAD 0944 81 DUP2 0945 63 PUSH4 0xffffffff 094A 16 AND 094B 11 GT 094C 61 PUSH2 0x09ac 094F 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0936 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @093C memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x09ac, if 0xffffffff & stack[-4] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] label_0950: // Incoming jump from 0x094F, if not 0xffffffff & stack[-4] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // Inputs[1] { @0952 memory[0x40:0x60] } 0950 60 PUSH1 0x40 0952 51 MLOAD 0953 62 PUSH3 0x461bcd 0957 60 PUSH1 0xe5 0959 1B SHL 095A 81 DUP2 095B 52 MSTORE 095C 60 PUSH1 0x20 095E 60 PUSH1 0x04 0960 82 DUP3 0961 01 ADD 0962 52 MSTORE 0963 60 PUSH1 0x2c 0965 60 PUSH1 0x24 0967 82 DUP3 0968 01 ADD 0969 52 MSTORE 096A 7F PUSH32 0x45524332305265776172643a20616c7265616479207374616b6520696e207468 098B 60 PUSH1 0x44 098D 82 DUP3 098E 01 ADD 098F 52 MSTORE 0990 6B PUSH12 0x652073616d6520626c6f636b 099D 60 PUSH1 0xa0 099F 1B SHL 09A0 60 PUSH1 0x64 09A2 82 DUP3 09A3 01 ADD 09A4 52 MSTORE 09A5 60 PUSH1 0x84 09A7 01 ADD 09A8 61 PUSH2 0x0817 09AB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @095B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0962 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0969 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @098F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332305265776172643a20616c7265616479207374616b6520696e207468 // @09A4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x652073616d6520626c6f636b << 0xa0 // @09A7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_09AC: // Incoming jump from 0x094F, if 0xffffffff & stack[-4] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // Incoming jump from 0x0903, if !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[1] { @09B2 stack[-3] } 09AC 5B JUMPDEST 09AD 60 PUSH1 0x00 09AF 61 PUSH2 0x09b7 09B2 84 DUP5 09B3 61 PUSH2 0x252f 09B6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09AD stack[0] = 0x00 // @09AF stack[1] = 0x09b7 // @09B2 stack[2] = stack[-3] // } // Block ends with call to 0x252f, returns to 0x09B7 label_09B7: // Incoming return from call to 0x252F at 0x09B6 // Inputs[4] // { // @09BB storage[0x0165] // @09BC stack[-1] // @09BD stack[-2] // @09C7 stack[-3] // } 09B7 5B JUMPDEST 09B8 61 PUSH2 0x0165 09BB 54 SLOAD 09BC 90 SWAP1 09BD 91 SWAP2 09BE 50 POP 09BF 61 PUSH2 0x09d5 09C2 90 SWAP1 09C3 61 PUSH2 0x016e 09C6 90 SWAP1 09C7 84 DUP5 09C8 90 SWAP1 09C9 84 DUP5 09CA 90 SWAP1 09CB 63 PUSH4 0xffffffff 09D0 16 AND 09D1 61 PUSH2 0x2597 09D4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @09BD stack[-2] = stack[-1] // @09C2 stack[-1] = 0x09d5 // @09C6 stack[0] = 0x016e // @09C8 stack[1] = stack[-3] // @09CA stack[2] = stack[-1] // @09D0 stack[3] = 0xffffffff & storage[0x0165] // } // Block ends with call to 0x2597, returns to 0x09D5 label_09D5: // Incoming return from call to 0x2597 at 0x09D4 // Inputs[5] // { // @09DE stack[-5] // @09EE memory[0x00:0x40] // @09F2 storage[0x0165] // @09FB stack[-2] // @09FD stack[-1] // } 09D5 5B JUMPDEST 09D6 60 PUSH1 0x01 09D8 60 PUSH1 0x01 09DA 60 PUSH1 0xa0 09DC 1B SHL 09DD 03 SUB 09DE 85 DUP6 09DF 16 AND 09E0 60 PUSH1 0x00 09E2 90 SWAP1 09E3 81 DUP2 09E4 52 MSTORE 09E5 61 PUSH2 0x0166 09E8 60 PUSH1 0x20 09EA 52 MSTORE 09EB 60 PUSH1 0x40 09ED 90 SWAP1 09EE 20 SHA3 09EF 61 PUSH2 0x0165 09F2 54 SLOAD 09F3 61 PUSH2 0x0a09 09F6 91 SWAP2 09F7 60 PUSH1 0x01 09F9 01 ADD 09FA 90 SWAP1 09FB 84 DUP5 09FC 90 SWAP1 09FD 84 DUP5 09FE 90 SWAP1 09FF 63 PUSH4 0xffffffff 0A04 16 AND 0A05 61 PUSH2 0x2597 0A08 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @09E4 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @09EA memory[0x20:0x40] = 0x0166 // @09F6 stack[0] = 0x0a09 // @09FA stack[1] = 0x01 + keccak256(memory[0x00:0x40]) // @09FC stack[2] = stack[-2] // @09FE stack[3] = stack[-1] // @0A04 stack[4] = 0xffffffff & storage[0x0165] // } // Block ends with call to 0x2597, returns to 0x0A09 label_0A09: // Incoming return from call to 0x2597 at 0x0A08 // Inputs[4] // { // @0A0D storage[0x016f] // @0A12 storage[0x0165] // @0A3D memory[0x00:0x40] // @0A3F storage[keccak256(memory[0x00:0x40])] // } 0A09 5B JUMPDEST 0A0A 61 PUSH2 0x016f 0A0D 54 SLOAD 0A0E 61 PUSH2 0x0165 0A11 80 DUP1 0A12 54 SLOAD 0A13 63 PUSH4 0xffffffff 0A18 81 DUP2 0A19 81 DUP2 0A1A 16 AND 0A1B 60 PUSH1 0x01 0A1D 81 DUP2 0A1E 01 ADD 0A1F 82 DUP3 0A20 16 AND 0A21 63 PUSH4 0xffffffff 0A26 19 NOT 0A27 93 SWAP4 0A28 84 DUP5 0A29 16 AND 0A2A 17 OR 0A2B 90 SWAP1 0A2C 93 SWAP4 0A2D 55 SSTORE 0A2E 60 PUSH1 0x00 0A30 92 SWAP3 0A31 83 DUP4 0A32 52 MSTORE 0A33 61 PUSH2 0x0164 0A36 60 PUSH1 0x20 0A38 52 MSTORE 0A39 60 PUSH1 0x40 0A3B 90 SWAP1 0A3C 92 SWAP3 0A3D 20 SHA3 0A3E 80 DUP1 0A3F 54 SLOAD 0A40 90 SWAP1 0A41 91 SWAP2 0A42 16 AND 0A43 60 PUSH1 0x01 0A45 60 PUSH1 0x20 0A47 1B SHL 0A48 90 SWAP1 0A49 93 SWAP4 0A4A 04 DIV 0A4B 91 SWAP2 0A4C 90 SWAP1 0A4D 91 SWAP2 0A4E 16 AND 0A4F 91 SWAP2 0A50 90 SWAP1 0A51 91 SWAP2 0A52 17 OR 0A53 90 SWAP1 0A54 55 SSTORE 0A55 61 PUSH2 0x0a5f 0A58 61 PUSH2 0x016e 0A5B 61 PUSH2 0x2673 0A5E 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0A2D storage[0x0165] = (~0xffffffff & storage[0x0165]) | (0xffffffff & (0xffffffff & storage[0x0165]) + 0x01) // @0A32 memory[0x00:0x20] = 0xffffffff & storage[0x0165] // @0A38 memory[0x20:0x40] = 0x0164 // @0A54 storage[keccak256(memory[0x00:0x40])] = (storage[0x016f] / (0x01 << 0x20) & 0xffffffff) | (~0xffffffff & storage[keccak256(memory[0x00:0x40])]) // @0A55 stack[0] = 0x0a5f // @0A58 stack[1] = 0x016e // } // Block ends with call to 0x2673, returns to 0x0A5F label_0A5F: // Incoming return from call to 0x2673 at 0x0A5E // Inputs[1] { @0A60 stack[-1] } 0A5F 5B JUMPDEST 0A60 80 DUP1 0A61 15 ISZERO 0A62 61 PUSH2 0x0a6c 0A65 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a6c, if !stack[-1] label_0A66: // Incoming jump from 0x0A65, if not !stack[-1] // Inputs[1] { @0A6A storage[0x016b] } 0A66 50 POP 0A67 61 PUSH2 0x016b 0A6A 54 SLOAD 0A6B 15 ISZERO 0A6C 5B JUMPDEST 0A6D 15 ISZERO 0A6E 61 PUSH2 0x0a7d 0A71 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a7d, if !!storage[0x016b] label_0A72: // Incoming jump from 0x0A71, if not !stack[-1] // Incoming jump from 0x0A71, if not !!storage[0x016b] // Inputs[1] { @0A72 block.number } 0A72 43 NUMBER 0A73 61 PUSH2 0x016d 0A76 55 SSTORE 0A77 60 PUSH1 0x00 0A79 61 PUSH2 0x0167 0A7C 55 SSTORE 0A7D 5B JUMPDEST 0A7E 61 PUSH2 0x0a85 0A81 61 PUSH2 0x1bdc 0A84 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0A76 storage[0x016d] = block.number // @0A7C storage[0x0167] = 0x00 // @0A7E stack[0] = 0x0a85 // } // Block ends with call to 0x1bdc, returns to 0x0A85 label_0A85: // Incoming return from call to 0x1BDC at 0x0A84 // Incoming return from call to 0x1BDC at 0x0A84 // Inputs[4] // { // @0A8A storage[0x016c] // @0A8B stack[-4] // @0A92 stack[-5] // @0A98 stack[-2] // } 0A85 5B JUMPDEST 0A86 61 PUSH2 0x016c 0A89 80 DUP1 0A8A 54 SLOAD 0A8B 85 DUP6 0A8C 01 ADD 0A8D 90 SWAP1 0A8E 55 SSTORE 0A8F 61 PUSH2 0x0a9e 0A92 85 DUP6 0A93 63 PUSH4 0xffffffff 0A98 84 DUP5 0A99 16 AND 0A9A 61 PUSH2 0x2685 0A9D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0A8E storage[0x016c] = stack[-4] + storage[0x016c] // @0A8F stack[0] = 0x0a9e // @0A92 stack[1] = stack[-5] // @0A99 stack[2] = stack[-2] & 0xffffffff // } // Block ends with call to 0x2685, returns to 0x0A9E label_0A9E: // Incoming return from call to 0x2685 at 0x0A9D // Inputs[12] // { // @0AA7 stack[-6] // @0ABB memory[0x00:0x40] // @0AC0 storage[keccak256(memory[0x00:0x40]) + 0x06] // @0ACC memory[0x00:0x40] // @0ACD stack[-1] // @0AD4 storage[0x0168] // @0AD8 storage[0x0174] // @0ADA memory[0x40:0x60] // @0B0B memory[0x40:0x60] // @0B11 msg.gas // @0B12 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B12 address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 0A9E 5B JUMPDEST 0A9F 60 PUSH1 0x01 0AA1 60 PUSH1 0x01 0AA3 60 PUSH1 0xa0 0AA5 1B SHL 0AA6 03 SUB 0AA7 86 DUP7 0AA8 81 DUP2 0AA9 16 AND 0AAA 60 PUSH1 0x00 0AAC 81 DUP2 0AAD 81 DUP2 0AAE 52 MSTORE 0AAF 61 PUSH2 0x0166 0AB2 60 PUSH1 0x20 0AB4 90 SWAP1 0AB5 81 DUP2 0AB6 52 MSTORE 0AB7 60 PUSH1 0x40 0AB9 80 DUP1 0ABA 83 DUP4 0ABB 20 SHA3 0ABC 60 PUSH1 0x06 0ABE 81 DUP2 0ABF 01 ADD 0AC0 54 SLOAD 0AC1 84 DUP5 0AC2 52 MSTORE 0AC3 60 PUSH1 0x03 0AC5 01 ADD 0AC6 90 SWAP1 0AC7 91 SWAP2 0AC8 52 MSTORE 0AC9 90 SWAP1 0ACA 81 DUP2 0ACB 90 SWAP1 0ACC 20 SHA3 0ACD 93 SWAP4 0ACE 90 SWAP1 0ACF 93 SWAP4 0AD0 55 SSTORE 0AD1 61 PUSH2 0x0168 0AD4 54 SLOAD 0AD5 61 PUSH2 0x0174 0AD8 54 SLOAD 0AD9 93 SWAP4 0ADA 51 MLOAD 0ADB 63 PUSH4 0x0213119b 0AE0 60 PUSH1 0xe5 0AE2 1B SHL 0AE3 81 DUP2 0AE4 52 MSTORE 0AE5 60 PUSH1 0x04 0AE7 81 DUP2 0AE8 01 ADD 0AE9 92 SWAP3 0AEA 90 SWAP1 0AEB 92 SWAP3 0AEC 52 MSTORE 0AED 6A PUSH11 0x084595161401484a000000 0AF9 93 SWAP4 0AFA 90 SWAP1 0AFB 92 SWAP3 0AFC 16 AND 0AFD 90 SWAP1 0AFE 63 PUSH4 0x42623360 0B03 90 SWAP1 0B04 60 PUSH1 0x24 0B06 01 ADD 0B07 60 PUSH1 0x20 0B09 60 PUSH1 0x40 0B0B 51 MLOAD 0B0C 80 DUP1 0B0D 83 DUP4 0B0E 03 SUB 0B0F 81 DUP2 0B10 86 DUP7 0B11 5A GAS 0B12 FA STATICCALL 0B13 15 ISZERO 0B14 80 DUP1 0B15 15 ISZERO 0B16 61 PUSH2 0x0b23 0B19 57 *JUMPI // Stack delta = +5 // Outputs[14] // { // @0AAE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0AB6 memory[0x20:0x40] = 0x0166 // @0AC2 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @0AC8 memory[0x20:0x40] = 0x03 + keccak256(memory[0x00:0x40]) // @0AD0 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0AE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0213119b << 0xe5 // @0AEC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0AF9 stack[-1] = 0x084595161401484a000000 // @0AFB stack[0] = storage[0x0168] // @0AFD stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0174] // @0B03 stack[2] = 0x42623360 // @0B06 stack[3] = 0x24 + memory[0x40:0x60] // @0B12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0B13 stack[4] = !address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0b23, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0B1A: // Incoming jump from 0x0B19, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0B1A returndata.length // @0B1E returndata[0x00:0x00 + returndata.length] // @0B1F returndata.length // @0B22 memory[0x00:0x00 + returndata.length] // } 0B1A 3D RETURNDATASIZE 0B1B 60 PUSH1 0x00 0B1D 80 DUP1 0B1E 3E RETURNDATACOPY 0B1F 3D RETURNDATASIZE 0B20 60 PUSH1 0x00 0B22 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B1E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0B22 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0B23: // Incoming jump from 0x0B19, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0174]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @0B2A memory[0x40:0x60] // @0B2B returndata.length // } 0B23 5B JUMPDEST 0B24 50 POP 0B25 50 POP 0B26 50 POP 0B27 50 POP 0B28 60 PUSH1 0x40 0B2A 51 MLOAD 0B2B 3D RETURNDATASIZE 0B2C 60 PUSH1 0x1f 0B2E 19 NOT 0B2F 60 PUSH1 0x1f 0B31 82 DUP3 0B32 01 ADD 0B33 16 AND 0B34 82 DUP3 0B35 01 ADD 0B36 80 DUP1 0B37 60 PUSH1 0x40 0B39 52 MSTORE 0B3A 50 POP 0B3B 81 DUP2 0B3C 01 ADD 0B3D 90 SWAP1 0B3E 61 PUSH2 0x0b47 0B41 91 SWAP2 0B42 90 SWAP1 0B43 61 PUSH2 0x3f8e 0B46 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0B39 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0B41 stack[-4] = 0x0b47 // @0B42 stack[-2] = memory[0x40:0x60] // @0B42 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x3f8e, returns to 0x0B47 label_0B47: // Incoming return from call to 0x3F8E at 0x0B46 // Inputs[2] // { // @0B4B stack[-2] // @0B4C stack[-1] // } 0B47 5B JUMPDEST 0B48 61 PUSH2 0x0b51 0B4B 91 SWAP2 0B4C 90 SWAP1 0B4D 61 PUSH2 0x3fa7 0B50 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B4B stack[-2] = 0x0b51 // @0B4C stack[-1] = stack[-2] // @0B4C stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x0B51 label_0B51: // Incoming return from call to 0x3FA7 at 0x0B50 // Inputs[2] // { // @0B55 stack[-2] // @0B56 stack[-1] // } 0B51 5B JUMPDEST 0B52 61 PUSH2 0x0b5b 0B55 91 SWAP2 0B56 90 SWAP1 0B57 61 PUSH2 0x3fc6 0B5A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B55 stack[-2] = 0x0b5b // @0B56 stack[-1] = stack[-2] // @0B56 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x0B5B label_0B5B: // Incoming return from call to 0x3FC6 at 0x0B5A // Inputs[11] // { // @0B64 stack[-6] // @0B77 memory[0x00:0x40] // @0B7D storage[keccak256(memory[0x00:0x40]) + 0x06] // @0B88 memory[0x00:0x40] // @0B89 stack[-1] // @0B8E storage[keccak256(memory[0x00:0x40]) + 0x06] // @0B97 memory[0x00:0x40] // @0B9E stack[-3] // @0BAB storage[keccak256(memory[0x00:0x40]) + 0x06] // @0BB4 stack[-4] // @0BB6 stack[-7] // } 0B5B 5B JUMPDEST 0B5C 60 PUSH1 0x01 0B5E 60 PUSH1 0x01 0B60 60 PUSH1 0xa0 0B62 1B SHL 0B63 03 SUB 0B64 86 DUP7 0B65 16 AND 0B66 60 PUSH1 0x00 0B68 81 DUP2 0B69 81 DUP2 0B6A 52 MSTORE 0B6B 61 PUSH2 0x0166 0B6E 60 PUSH1 0x20 0B70 81 DUP2 0B71 81 DUP2 0B72 52 MSTORE 0B73 60 PUSH1 0x40 0B75 80 DUP1 0B76 84 DUP5 0B77 20 SHA3 0B78 60 PUSH1 0x06 0B7A 81 DUP2 0B7B 01 ADD 0B7C 80 DUP1 0B7D 54 SLOAD 0B7E 86 DUP7 0B7F 52 MSTORE 0B80 60 PUSH1 0x04 0B82 82 DUP3 0B83 01 ADD 0B84 84 DUP5 0B85 52 MSTORE 0B86 82 DUP3 0B87 86 DUP7 0B88 20 SHA3 0B89 97 SWAP8 0B8A 90 SWAP1 0B8B 97 SWAP8 0B8C 55 SSTORE 0B8D 86 DUP7 0B8E 54 SLOAD 0B8F 85 DUP6 0B90 52 MSTORE 0B91 60 PUSH1 0x05 0B93 01 ADD 0B94 82 DUP3 0B95 52 MSTORE 0B96 83 DUP4 0B97 20 SHA3 0B98 63 PUSH4 0xffffffff 0B9D 90 SWAP1 0B9E 97 SWAP8 0B9F 16 AND 0BA0 90 SWAP1 0BA1 96 SWAP7 0BA2 55 SSTORE 0BA3 91 SWAP2 0BA4 90 SWAP1 0BA5 52 MSTORE 0BA6 90 SWAP1 0BA7 92 SWAP3 0BA8 52 MSTORE 0BA9 50 POP 0BAA 80 DUP1 0BAB 54 SLOAD 0BAC 60 PUSH1 0x01 0BAE 90 SWAP1 0BAF 81 DUP2 0BB0 01 ADD 0BB1 90 SWAP1 0BB2 91 SWAP2 0BB3 55 SSTORE 0BB4 90 SWAP1 0BB5 50 POP 0BB6 92 SWAP3 0BB7 91 SWAP2 0BB8 50 POP 0BB9 50 POP 0BBA 56 *JUMP // Stack delta = -6 // Outputs[12] // { // @0B6A memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0B72 memory[0x20:0x40] = 0x0166 // @0B7F memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @0B85 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x04 // @0B8C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0B90 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @0B95 memory[0x20:0x40] = 0x05 + keccak256(memory[0x00:0x40]) // @0BA2 storage[keccak256(memory[0x00:0x40])] = stack[-3] & 0xffffffff // @0BA5 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0BA8 memory[0x20:0x40] = 0x0166 // @0BB3 storage[keccak256(memory[0x00:0x40]) + 0x06] = 0x01 + storage[keccak256(memory[0x00:0x40]) + 0x06] // @0BB6 stack[-7] = 0x01 // } // Block ends with unconditional jump to stack[-7] label_0BBB: // Incoming jump from 0x02EB // Inputs[3] // { // @0BBE msg.sender // @0BC2 stack[-3] // @0BC4 stack[-1] // } 0BBB 5B JUMPDEST 0BBC 60 PUSH1 0x00 0BBE 33 CALLER 0BBF 61 PUSH2 0x0bc9 0BC2 85 DUP6 0BC3 82 DUP3 0BC4 85 DUP6 0BC5 61 PUSH2 0x2825 0BC8 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0BBC stack[0] = 0x00 // @0BBE stack[1] = msg.sender // @0BBF stack[2] = 0x0bc9 // @0BC2 stack[3] = stack[-3] // @0BC3 stack[4] = msg.sender // @0BC4 stack[5] = stack[-1] // } // Block ends with call to 0x2825, returns to 0x0BC9 label_0BC9: // Incoming return from call to 0x2825 at 0x0BC8 // Inputs[3] // { // @0BCD stack[-5] // @0BCE stack[-4] // @0BCF stack[-3] // } 0BC9 5B JUMPDEST 0BCA 61 PUSH2 0x0bd4 0BCD 85 DUP6 0BCE 85 DUP6 0BCF 85 DUP6 0BD0 61 PUSH2 0x2107 0BD3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BCA stack[0] = 0x0bd4 // @0BCD stack[1] = stack[-5] // @0BCE stack[2] = stack[-4] // @0BCF stack[3] = stack[-3] // } // Block ends with call to 0x2107, returns to 0x0BD4 label_0BD4: // Incoming return from call to 0x1DC0 at 0x1481 // Incoming return from call to 0x2107 at 0x0BD3 // Inputs[2] // { // @0BD8 stack[-6] // @0BD9 stack[-5] // } 0BD4 5B JUMPDEST 0BD5 50 POP 0BD6 60 PUSH1 0x01 0BD8 94 SWAP5 0BD9 93 SWAP4 0BDA 50 POP 0BDB 50 POP 0BDC 50 POP 0BDD 50 POP 0BDE 56 *JUMP // Stack delta = -5 // Outputs[1] { @0BD8 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0BDF: // Incoming call from 0x0BFC, returns to 0x0BFD // Incoming jump from 0x02FE // Incoming call from 0x15FC, returns to 0x15FD // Inputs[4] // { // @0BE2 stack[-1] // @0BED memory[0x00:0x40] // @0BF1 storage[0x01 + keccak256(memory[0x00:0x40])] // @0BF2 stack[-2] // } 0BDF 5B JUMPDEST 0BE0 60 PUSH1 0x00 0BE2 90 SWAP1 0BE3 81 DUP2 0BE4 52 MSTORE 0BE5 60 PUSH1 0x65 0BE7 60 PUSH1 0x20 0BE9 52 MSTORE 0BEA 60 PUSH1 0x40 0BEC 90 SWAP1 0BED 20 SHA3 0BEE 60 PUSH1 0x01 0BF0 01 ADD 0BF1 54 SLOAD 0BF2 90 SWAP1 0BF3 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0BE4 memory[0x00:0x20] = stack[-1] // @0BE9 memory[0x20:0x40] = 0x65 // @0BF2 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0BF4: // Incoming jump from 0x0311 // Inputs[1] { @0BF8 stack[-2] } 0BF4 5B JUMPDEST 0BF5 61 PUSH2 0x0bfd 0BF8 82 DUP3 0BF9 61 PUSH2 0x0bdf 0BFC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BF5 stack[0] = 0x0bfd // @0BF8 stack[1] = stack[-2] // } // Block ends with call to 0x0bdf, returns to 0x0BFD label_0BFD: // Incoming return from call to 0x0BDF at 0x0BFC // Inputs[1] { @0C01 stack[-1] } 0BFD 5B JUMPDEST 0BFE 61 PUSH2 0x0c06 0C01 81 DUP2 0C02 61 PUSH2 0x2899 0C05 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BFE stack[0] = 0x0c06 // @0C01 stack[1] = stack[-1] // } // Block ends with call to 0x2899, returns to 0x0C06 label_0C06: // Incoming return from call to 0x2899 at 0x0C05 // Inputs[2] // { // @0C0A stack[-3] // @0C0B stack[-2] // } 0C06 5B JUMPDEST 0C07 61 PUSH2 0x0c10 0C0A 83 DUP4 0C0B 83 DUP4 0C0C 61 PUSH2 0x28a3 0C0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C07 stack[0] = 0x0c10 // @0C0A stack[1] = stack[-3] // @0C0B stack[2] = stack[-2] // } // Block ends with call to 0x28a3, returns to 0x0C10 label_0C10: // Incoming return from call to 0x29A8 at 0x160F // Incoming jump from 0x2100, if !stack[-2] // Incoming return from call to 0x28A3 at 0x0C0F // Inputs[1] { @0C14 stack[-4] } 0C10 5B JUMPDEST 0C11 50 POP 0C12 50 POP 0C13 50 POP 0C14 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0C15: // Incoming jump from 0x0331 0C15 5B JUMPDEST 0C16 60 PUSH1 0x00 0C18 61 PUSH2 0x0c1f 0C1B 61 PUSH2 0x2929 0C1E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C16 stack[0] = 0x00 // @0C18 stack[1] = 0x0c1f // } // Block ends with unconditional jump to 0x2929 label_0C1F: // Incoming return from call to 0x3F5F at 0x1716 // Incoming return from call to 0x3FC6 at 0x1370 // Inputs[3] // { // @0C20 stack[-1] // @0C20 stack[-2] // @0C22 stack[-3] // } 0C1F 5B JUMPDEST 0C20 90 SWAP1 0C21 50 POP 0C22 90 SWAP1 0C23 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C22 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0C24: // Incoming jump from 0x0344 // Inputs[2] // { // @0C2D stack[-1] // @0C2F msg.sender // } 0C24 5B JUMPDEST 0C25 60 PUSH1 0x01 0C27 60 PUSH1 0x01 0C29 60 PUSH1 0xa0 0C2B 1B SHL 0C2C 03 SUB 0C2D 81 DUP2 0C2E 16 AND 0C2F 33 CALLER 0C30 14 EQ 0C31 61 PUSH2 0x0c94 0C34 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c94, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_0C35: // Incoming jump from 0x0C34, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C37 memory[0x40:0x60] } 0C35 60 PUSH1 0x40 0C37 51 MLOAD 0C38 62 PUSH3 0x461bcd 0C3C 60 PUSH1 0xe5 0C3E 1B SHL 0C3F 81 DUP2 0C40 52 MSTORE 0C41 60 PUSH1 0x20 0C43 60 PUSH1 0x04 0C45 82 DUP3 0C46 01 ADD 0C47 52 MSTORE 0C48 60 PUSH1 0x2f 0C4A 60 PUSH1 0x24 0C4C 82 DUP3 0C4D 01 ADD 0C4E 52 MSTORE 0C4F 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 0C70 60 PUSH1 0x44 0C72 82 DUP3 0C73 01 ADD 0C74 52 MSTORE 0C75 6E PUSH15 0x103937b632b9903337b91039b2b633 0C85 60 PUSH1 0x89 0C87 1B SHL 0C88 60 PUSH1 0x64 0C8A 82 DUP3 0C8B 01 ADD 0C8C 52 MSTORE 0C8D 60 PUSH1 0x84 0C8F 01 ADD 0C90 61 PUSH2 0x0817 0C93 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C4E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0C74 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @0C8C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103937b632b9903337b91039b2b633 << 0x89 // @0C8F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_0C94: // Incoming jump from 0x0C34, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0C98 stack[-2] // @0C99 stack[-1] // } 0C94 5B JUMPDEST 0C95 61 PUSH2 0x0c9e 0C98 82 DUP3 0C99 82 DUP3 0C9A 61 PUSH2 0x29a8 0C9D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C95 stack[0] = 0x0c9e // @0C98 stack[1] = stack[-2] // @0C99 stack[2] = stack[-1] // } // Block ends with call to 0x29a8, returns to 0x0C9E label_0C9E: // Incoming return from call to 0x373E at 0x3221 // Incoming return from call to 0x29A8 at 0x0C9D // Incoming jump from 0x3001, if stack[-1] // Incoming return from call to 0x3118 at 0x2C15 // Incoming jump from 0x29B7, if !stack[-1] // Incoming jump from 0x28B1, if stack[-1] // Inputs[1] { @0CA1 stack[-3] } 0C9E 5B JUMPDEST 0C9F 50 POP 0CA0 50 POP 0CA1 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0CA2: // Incoming jump from 0x0357 // Inputs[1] { @0CA8 msg.sender } 0CA2 5B JUMPDEST 0CA3 61 PUSH2 0x0cad 0CA6 60 PUSH1 0x00 0CA8 33 CALLER 0CA9 61 PUSH2 0x13b7 0CAC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA3 stack[0] = 0x0cad // @0CA6 stack[1] = 0x00 // @0CA8 stack[2] = msg.sender // } // Block ends with call to 0x13b7, returns to 0x0CAD label_0CAD: // Incoming return from call to 0x13B7 at 0x0CAC // Inputs[1] { @0CB1 stack[-1] } 0CAD 5B JUMPDEST 0CAE 61 PUSH2 0x0cc9 0CB1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cc9, if stack[-1] label_0CB2: // Incoming jump from 0x0CB1, if not stack[-1] // Inputs[1] { @0CB4 memory[0x40:0x60] } 0CB2 60 PUSH1 0x40 0CB4 51 MLOAD 0CB5 62 PUSH3 0x461bcd 0CB9 60 PUSH1 0xe5 0CBB 1B SHL 0CBC 81 DUP2 0CBD 52 MSTORE 0CBE 60 PUSH1 0x04 0CC0 01 ADD 0CC1 61 PUSH2 0x0817 0CC4 90 SWAP1 0CC5 61 PUSH2 0x3fe8 0CC8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CC4 stack[0] = 0x0817 // @0CC4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3fe8, returns to 0x0817 label_0CC9: // Incoming jump from 0x0CB1, if stack[-1] // Inputs[1] { @0CCD stack[-1] } 0CC9 5B JUMPDEST 0CCA 61 PUSH2 0x0cd3 0CCD 81 DUP2 0CCE 61 PUSH2 0x016d 0CD1 55 SSTORE 0CD2 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CD1 storage[0x016d] = stack[-1] } // Block ends with unconditional jump to 0x0cd3 label_0CD3: // Incoming jump from 0x0CD2 // Incoming return from call to 0x2FF3 at 0x28A2 // Incoming jump from 0x3468, if !(stack[-1] == stack[-2]) // Inputs[1] { @0CD5 stack[-2] } 0CD3 5B JUMPDEST 0CD4 50 POP 0CD5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0CD6: // Incoming jump from 0x036A // Inputs[3] // { // @0CD9 msg.sender // @0CDE stack[-2] // @0CDF stack[-1] // } 0CD6 5B JUMPDEST 0CD7 60 PUSH1 0x00 0CD9 33 CALLER 0CDA 61 PUSH2 0x0747 0CDD 81 DUP2 0CDE 85 DUP6 0CDF 85 DUP6 0CE0 61 PUSH2 0x0ce9 0CE3 83 DUP4 0CE4 83 DUP4 0CE5 61 PUSH2 0x1610 0CE8 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @0CD7 stack[0] = 0x00 // @0CD9 stack[1] = msg.sender // @0CDA stack[2] = 0x0747 // @0CDD stack[3] = msg.sender // @0CDE stack[4] = stack[-2] // @0CDF stack[5] = stack[-1] // @0CE0 stack[6] = 0x0ce9 // @0CE3 stack[7] = msg.sender // @0CE4 stack[8] = stack[-2] // } // Block ends with call to 0x1610, returns to 0x0CE9 label_0CE9: // Incoming return from call to 0x1610 at 0x0CE8 // Inputs[2] // { // @0CED stack[-2] // @0CEE stack[-1] // } 0CE9 5B JUMPDEST 0CEA 61 PUSH2 0x0cf3 0CED 91 SWAP2 0CEE 90 SWAP1 0CEF 61 PUSH2 0x3f5f 0CF2 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0CED stack[-2] = 0x0cf3 // @0CEE stack[-1] = stack[-2] // @0CEE stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x0CF3 label_0CF3: // Incoming return from call to 0x3F5F at 0x0CF2 0CF3 5B JUMPDEST 0CF4 61 PUSH2 0x1dc0 0CF7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1dc0 label_0CF8: // Incoming jump from 0x037D // Inputs[1] { @0CFB storage[0x00] } 0CF8 5B JUMPDEST 0CF9 60 PUSH1 0x00 0CFB 54 SLOAD 0CFC 61 PUSH2 0x0100 0CFF 90 SWAP1 0D00 04 DIV 0D01 60 PUSH1 0xff 0D03 16 AND 0D04 15 ISZERO 0D05 80 DUP1 0D06 80 DUP1 0D07 15 ISZERO 0D08 61 PUSH2 0x0d18 0D0B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D04 stack[0] = !(0xff & storage[0x00] / 0x0100) // @0D05 stack[1] = !(0xff & storage[0x00] / 0x0100) // } // Block ends with conditional jump to 0x0d18, if !!(0xff & storage[0x00] / 0x0100) label_0D0C: // Incoming jump from 0x0D0B, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @0D0F storage[0x00] } 0D0C 50 POP 0D0D 60 PUSH1 0x00 0D0F 54 SLOAD 0D10 60 PUSH1 0x01 0D12 60 PUSH1 0xff 0D14 90 SWAP1 0D15 91 SWAP2 0D16 16 AND 0D17 10 LT 0D18 5B JUMPDEST 0D19 80 DUP1 0D1A 61 PUSH2 0x0d32 0D1D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D17 stack[-1] = storage[0x00] & 0xff < 0x01 } // Block ends with conditional jump to 0x0d32, if storage[0x00] & 0xff < 0x01 label_0D1E: // Incoming jump from 0x0D1D, if not stack[-1] // Incoming jump from 0x0D1D, if not storage[0x00] & 0xff < 0x01 // Inputs[2] // { // @0D1F address(this) // @0D20 address(address(this)).code.length // } 0D1E 50 POP 0D1F 30 ADDRESS 0D20 3B EXTCODESIZE 0D21 15 ISZERO 0D22 80 DUP1 0D23 15 ISZERO 0D24 61 PUSH2 0x0d32 0D27 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D21 stack[-1] = !address(address(this)).code.length } // Block ends with conditional jump to 0x0d32, if !!address(address(this)).code.length label_0D28: // Incoming jump from 0x0D27, if not !!address(address(this)).code.length // Inputs[1] { @0D2B storage[0x00] } 0D28 50 POP 0D29 60 PUSH1 0x00 0D2B 54 SLOAD 0D2C 60 PUSH1 0xff 0D2E 16 AND 0D2F 60 PUSH1 0x01 0D31 14 EQ // Stack delta = +0 // Outputs[1] { @0D31 stack[-1] = 0x01 == 0xff & storage[0x00] } // Block continues label_0D32: // Incoming jump from 0x0D31 // Incoming jump from 0x0D27, if !!address(address(this)).code.length // Incoming jump from 0x0D1D, if stack[-1] // Incoming jump from 0x0D1D, if storage[0x00] & 0xff < 0x01 // Inputs[1] { @0D36 stack[-1] } 0D32 5B JUMPDEST 0D33 61 PUSH2 0x0d95 0D36 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d95, if stack[-1] label_0D37: // Incoming jump from 0x0D36, if not stack[-1] // Inputs[1] { @0D39 memory[0x40:0x60] } 0D37 60 PUSH1 0x40 0D39 51 MLOAD 0D3A 62 PUSH3 0x461bcd 0D3E 60 PUSH1 0xe5 0D40 1B SHL 0D41 81 DUP2 0D42 52 MSTORE 0D43 60 PUSH1 0x20 0D45 60 PUSH1 0x04 0D47 82 DUP3 0D48 01 ADD 0D49 52 MSTORE 0D4A 60 PUSH1 0x2e 0D4C 60 PUSH1 0x24 0D4E 82 DUP3 0D4F 01 ADD 0D50 52 MSTORE 0D51 7F PUSH32 0x496e697469616c697a61626c653a20636f6e747261637420697320616c726561 0D72 60 PUSH1 0x44 0D74 82 DUP3 0D75 01 ADD 0D76 52 MSTORE 0D77 6D PUSH14 0x191e481a5b9a5d1a585b1a5e9959 0D86 60 PUSH1 0x92 0D88 1B SHL 0D89 60 PUSH1 0x64 0D8B 82 DUP3 0D8C 01 ADD 0D8D 52 MSTORE 0D8E 60 PUSH1 0x84 0D90 01 ADD 0D91 61 PUSH2 0x0817 0D94 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D42 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D49 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D50 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2e // @0D76 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e697469616c697a61626c653a20636f6e747261637420697320616c726561 // @0D8D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x191e481a5b9a5d1a585b1a5e9959 << 0x92 // @0D90 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_0D95: // Incoming jump from 0x0D36, if stack[-1] // Inputs[2] // { // @0D99 storage[0x00] // @0DA3 stack[-1] // } 0D95 5B JUMPDEST 0D96 60 PUSH1 0x00 0D98 80 DUP1 0D99 54 SLOAD 0D9A 60 PUSH1 0xff 0D9C 19 NOT 0D9D 16 AND 0D9E 60 PUSH1 0x01 0DA0 17 OR 0DA1 90 SWAP1 0DA2 55 SSTORE 0DA3 80 DUP1 0DA4 15 ISZERO 0DA5 61 PUSH2 0x0db8 0DA8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DA2 storage[0x00] = 0x01 | (~0xff & storage[0x00]) } // Block ends with conditional jump to 0x0db8, if !stack[-1] label_0DA9: // Incoming jump from 0x0DA8, if not !stack[-1] // Inputs[1] { @0DAC storage[0x00] } 0DA9 60 PUSH1 0x00 0DAB 80 DUP1 0DAC 54 SLOAD 0DAD 61 PUSH2 0xff00 0DB0 19 NOT 0DB1 16 AND 0DB2 61 PUSH2 0x0100 0DB5 17 OR 0DB6 90 SWAP1 0DB7 55 SSTORE 0DB8 5B JUMPDEST 0DB9 61 PUSH2 0x0dc0 0DBC 61 PUSH2 0x2a0f 0DBF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0DB7 storage[0x00] = 0x0100 | (~0xff00 & storage[0x00]) // @0DB9 stack[0] = 0x0dc0 // } // Block ends with call to 0x2a0f, returns to 0x0DC0 label_0DC0: // Incoming return from call to 0x2A0F at 0x0DBF // Incoming return from call to 0x2A0F at 0x0DBF 0DC0 5B JUMPDEST 0DC1 61 PUSH2 0x0dc8 0DC4 61 PUSH2 0x2a0f 0DC7 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DC1 stack[0] = 0x0dc8 } // Block ends with call to 0x2a0f, returns to 0x0DC8 label_0DC8: // Incoming return from call to 0x2A0F at 0x0DC7 // Inputs[1] { @0DCE msg.sender } 0DC8 5B JUMPDEST 0DC9 61 PUSH2 0x0dd3 0DCC 60 PUSH1 0x00 0DCE 33 CALLER 0DCF 61 PUSH2 0x28a3 0DD2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DC9 stack[0] = 0x0dd3 // @0DCC stack[1] = 0x00 // @0DCE stack[2] = msg.sender // } // Block ends with call to 0x28a3, returns to 0x0DD3 label_0DD3: // Incoming return from call to 0x28A3 at 0x0DD2 // Inputs[8] // { // @0DD7 stack[-9] // @0DD8 stack[-8] // @0DD9 stack[-7] // @0DDA stack[-6] // @0DDB stack[-5] // @0DDC stack[-4] // @0DDD stack[-3] // @0DDE stack[-2] // } 0DD3 5B JUMPDEST 0DD4 61 PUSH2 0x0de3 0DD7 89 DUP10 0DD8 89 DUP10 0DD9 89 DUP10 0DDA 89 DUP10 0DDB 89 DUP10 0DDC 89 DUP10 0DDD 89 DUP10 0DDE 89 DUP10 0DDF 61 PUSH2 0x2a38 0DE2 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @0DD4 stack[0] = 0x0de3 // @0DD7 stack[1] = stack[-9] // @0DD8 stack[2] = stack[-8] // @0DD9 stack[3] = stack[-7] // @0DDA stack[4] = stack[-6] // @0DDB stack[5] = stack[-5] // @0DDC stack[6] = stack[-4] // @0DDD stack[7] = stack[-3] // @0DDE stack[8] = stack[-2] // } // Block ends with unconditional jump to 0x2a38 0DE3 5B JUMPDEST 0DE4 61 PUSH2 0x0deb 0DE7 61 PUSH2 0x2a8f 0DEA 56 *JUMP 0DEB 5B JUMPDEST 0DEC 61 PUSH2 0x0df3 0DEF 61 PUSH2 0x2a8f 0DF2 56 *JUMP 0DF3 5B JUMPDEST 0DF4 80 DUP1 0DF5 15 ISZERO 0DF6 61 PUSH2 0x0e39 0DF9 57 *JUMPI 0DFA 60 PUSH1 0x00 0DFC 80 DUP1 0DFD 54 SLOAD 0DFE 61 PUSH2 0xff00 0E01 19 NOT 0E02 16 AND 0E03 90 SWAP1 0E04 55 SSTORE 0E05 60 PUSH1 0x40 0E07 51 MLOAD 0E08 60 PUSH1 0x01 0E0A 81 DUP2 0E0B 52 MSTORE 0E0C 7F PUSH32 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498 0E2D 90 SWAP1 0E2E 60 PUSH1 0x20 0E30 01 ADD 0E31 60 PUSH1 0x40 0E33 51 MLOAD 0E34 80 DUP1 0E35 91 SWAP2 0E36 03 SUB 0E37 90 SWAP1 0E38 A1 LOG1 0E39 5B JUMPDEST 0E3A 50 POP 0E3B 50 POP 0E3C 50 POP 0E3D 50 POP 0E3E 50 POP 0E3F 50 POP 0E40 50 POP 0E41 50 POP 0E42 50 POP 0E43 56 *JUMP label_0E44: // Incoming jump from 0x0385 0E44 5B JUMPDEST 0E45 61 PUSH2 0x0e4c 0E48 61 PUSH2 0x1bdc 0E4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E45 stack[0] = 0x0e4c } // Block ends with call to 0x1bdc, returns to 0x0E4C label_0E4C: // Incoming return from call to 0x1BDC at 0x0E4B // Inputs[1] { @0E52 msg.sender } 0E4C 5B JUMPDEST 0E4D 60 PUSH1 0x00 0E4F 61 PUSH2 0x0e57 0E52 33 CALLER 0E53 61 PUSH2 0x2abe 0E56 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E4D stack[0] = 0x00 // @0E4F stack[1] = 0x0e57 // @0E52 stack[2] = msg.sender // } // Block ends with call to 0x2abe, returns to 0x0E57 label_0E57: // Incoming return from call to 0x2ABE at 0x0E56 // Inputs[2] // { // @0E58 stack[-2] // @0E58 stack[-1] // } 0E57 5B JUMPDEST 0E58 90 SWAP1 0E59 50 POP 0E5A 60 PUSH1 0x00 0E5C 81 DUP2 0E5D 11 GT 0E5E 61 PUSH2 0x0e79 0E61 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0E58 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0e79, if stack[-1] > 0x00 label_0E62: // Incoming jump from 0x0E61, if not stack[-1] > 0x00 // Inputs[1] { @0E64 memory[0x40:0x60] } 0E62 60 PUSH1 0x40 0E64 51 MLOAD 0E65 62 PUSH3 0x461bcd 0E69 60 PUSH1 0xe5 0E6B 1B SHL 0E6C 81 DUP2 0E6D 52 MSTORE 0E6E 60 PUSH1 0x04 0E70 01 ADD 0E71 61 PUSH2 0x0817 0E74 90 SWAP1 0E75 61 PUSH2 0x4037 0E78 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E6D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E74 stack[0] = 0x0817 // @0E74 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4037, returns to 0x0817 label_0E79: // Incoming jump from 0x0E61, if stack[-1] > 0x00 // Inputs[2] // { // @0E7D msg.sender // @0E7E stack[-1] // } 0E79 5B JUMPDEST 0E7A 61 PUSH2 0x0cd3 0E7D 33 CALLER 0E7E 82 DUP3 0E7F 61 PUSH2 0x2c0c 0E82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E7A stack[0] = 0x0cd3 // @0E7D stack[1] = msg.sender // @0E7E stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x2c0c label_0E83: // Incoming jump from 0x0398 // Inputs[2] // { // @0E84 block.timestamp // @0E85 stack[-4] // } 0E83 5B JUMPDEST 0E84 42 TIMESTAMP 0E85 84 DUP5 0E86 10 LT 0E87 15 ISZERO 0E88 61 PUSH2 0x0ed3 0E8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ed3, if !(stack[-4] < block.timestamp) label_0E8C: // Incoming jump from 0x0E8B, if not !(stack[-4] < block.timestamp) // Inputs[1] { @0E8E memory[0x40:0x60] } 0E8C 60 PUSH1 0x40 0E8E 51 MLOAD 0E8F 62 PUSH3 0x461bcd 0E93 60 PUSH1 0xe5 0E95 1B SHL 0E96 81 DUP2 0E97 52 MSTORE 0E98 60 PUSH1 0x20 0E9A 60 PUSH1 0x04 0E9C 82 DUP3 0E9D 01 ADD 0E9E 81 DUP2 0E9F 90 SWAP1 0EA0 52 MSTORE 0EA1 60 PUSH1 0x24 0EA3 82 DUP3 0EA4 01 ADD 0EA5 52 MSTORE 0EA6 7F PUSH32 0x45524332304d696e7461626c653a205369676e61747572652065787069726564 0EC7 60 PUSH1 0x44 0EC9 82 DUP3 0ECA 01 ADD 0ECB 52 MSTORE 0ECC 60 PUSH1 0x64 0ECE 01 ADD 0ECF 61 PUSH2 0x0817 0ED2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EA0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EA5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0ECB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332304d696e7461626c653a205369676e61747572652065787069726564 // @0ECE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_0ED3: // Incoming jump from 0x0E8B, if !(stack[-4] < block.timestamp) // Inputs[5] // { // @0EFF CHAINID() // @0F00 address(this) // @0F01 stack[-6] // @0F02 stack[-5] // @0F05 memory[0x40:0x60] // } 0ED3 5B JUMPDEST 0ED4 60 PUSH1 0x00 0ED6 61 PUSH2 0x0f3a 0ED9 61 PUSH2 0x0f32 0EDC 7F PUSH32 0xbde9ded4b0f17394af57db78b30f32f7ecfcc04693dd0e113fd2181ebbdd1142 0EFD 60 PUSH1 0x02 0EFF 46 CHAINID 0F00 30 ADDRESS 0F01 8C DUP13 0F02 8C DUP13 0F03 60 PUSH1 0x40 0F05 51 MLOAD 0F06 60 PUSH1 0x20 0F08 01 ADD 0F09 61 PUSH2 0x0f17 0F0C 96 SWAP7 0F0D 95 SWAP6 0F0E 94 SWAP5 0F0F 93 SWAP4 0F10 92 SWAP3 0F11 91 SWAP2 0F12 90 SWAP1 0F13 61 PUSH2 0x4091 0F16 56 *JUMP // Stack delta = +11 // Outputs[11] // { // @0ED4 stack[0] = 0x00 // @0ED6 stack[1] = 0x0f3a // @0ED9 stack[2] = 0x0f32 // @0F0C stack[3] = 0x0f17 // @0F0D stack[4] = 0xbde9ded4b0f17394af57db78b30f32f7ecfcc04693dd0e113fd2181ebbdd1142 // @0F0E stack[5] = 0x02 // @0F0F stack[6] = CHAINID() // @0F10 stack[7] = address(this) // @0F11 stack[8] = stack[-6] // @0F12 stack[9] = stack[-5] // @0F12 stack[10] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x4091, returns to 0x0F17 label_0F17: // Incoming return from call to 0x4091 at 0x0F16 // Inputs[4] // { // @0F1A memory[0x40:0x60] // @0F1E stack[-1] // @0F28 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0F2D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 0F17 5B JUMPDEST 0F18 60 PUSH1 0x40 0F1A 51 MLOAD 0F1B 60 PUSH1 0x20 0F1D 81 DUP2 0F1E 83 DUP4 0F1F 03 SUB 0F20 03 SUB 0F21 81 DUP2 0F22 52 MSTORE 0F23 90 SWAP1 0F24 60 PUSH1 0x40 0F26 52 MSTORE 0F27 80 DUP1 0F28 51 MLOAD 0F29 90 SWAP1 0F2A 60 PUSH1 0x20 0F2C 01 ADD 0F2D 20 SHA3 0F2E 61 PUSH2 0x2c16 0F31 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0F26 memory[0x40:0x60] = stack[-1] // @0F2D stack[-1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x2c16 0F32 5B JUMPDEST 0F33 85 DUP6 0F34 85 DUP6 0F35 85 DUP6 0F36 61 PUSH2 0x2c64 0F39 56 *JUMP 0F3A 5B JUMPDEST 0F3B 90 SWAP1 0F3C 50 POP 0F3D 61 PUSH2 0x0f48 0F40 81 DUP2 0F41 60 PUSH1 0x02 0F43 88 DUP9 0F44 61 PUSH2 0x1ee4 0F47 56 *JUMP 0F48 5B JUMPDEST 0F49 61 PUSH2 0x0f50 0F4C 61 PUSH2 0x1bdc 0F4F 56 *JUMP 0F50 5B JUMPDEST 0F51 60 PUSH1 0x00 0F53 61 PUSH2 0x0f5b 0F56 82 DUP3 0F57 61 PUSH2 0x2abe 0F5A 56 *JUMP 0F5B 5B JUMPDEST 0F5C 90 SWAP1 0F5D 50 POP 0F5E 60 PUSH1 0x00 0F60 81 DUP2 0F61 11 GT 0F62 61 PUSH2 0x0f7d 0F65 57 *JUMPI 0F66 60 PUSH1 0x40 0F68 51 MLOAD 0F69 62 PUSH3 0x461bcd 0F6D 60 PUSH1 0xe5 0F6F 1B SHL 0F70 81 DUP2 0F71 52 MSTORE 0F72 60 PUSH1 0x04 0F74 01 ADD 0F75 61 PUSH2 0x0817 0F78 90 SWAP1 0F79 61 PUSH2 0x4037 0F7C 56 *JUMP 0F7D 5B JUMPDEST 0F7E 61 PUSH2 0x0f87 0F81 82 DUP3 0F82 82 DUP3 0F83 61 PUSH2 0x2c0c 0F86 56 *JUMP 0F87 5B JUMPDEST 0F88 61 PUSH2 0x0f92 0F8B 82 DUP3 0F8C 89 DUP10 0F8D 33 CALLER 0F8E 61 PUSH2 0x20fa 0F91 56 *JUMP 0F92 5B JUMPDEST 0F93 50 POP 0F94 50 POP 0F95 50 POP 0F96 50 POP 0F97 50 POP 0F98 50 POP 0F99 50 POP 0F9A 50 POP 0F9B 56 *JUMP label_0F9C: // Incoming call from 0x03A0, returns to 0x026A // Incoming call from 0x3076, returns to 0x3061 // Inputs[2] // { // @0FA0 memory[0x40:0x60] // @0FB7 stack[-1] // } 0F9C 5B JUMPDEST 0F9D 60 PUSH1 0x40 0F9F 80 DUP1 0FA0 51 MLOAD 0FA1 80 DUP1 0FA2 82 DUP3 0FA3 01 ADD 0FA4 90 SWAP1 0FA5 91 SWAP2 0FA6 52 MSTORE 0FA7 60 PUSH1 0x03 0FA9 81 DUP2 0FAA 52 MSTORE 0FAB 62 PUSH3 0x312e31 0FAF 60 PUSH1 0xe8 0FB1 1B SHL 0FB2 60 PUSH1 0x20 0FB4 82 DUP3 0FB5 01 ADD 0FB6 52 MSTORE 0FB7 90 SWAP1 0FB8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0FA6 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0FAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 // @0FB6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x312e31 << 0xe8 // @0FB7 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_0FB9: // Incoming call from 0x03A8, returns to 0x03A9 // Inputs[6] // { // @0FCF storage[0x0167] // @0FD6 storage[0x0168] // @0FDD storage[0x0169] // @0FF0 storage[0x016b] // @0FF7 storage[0x016c] // @0FFE storage[0x016d] // } 0FB9 5B JUMPDEST 0FBA 60 PUSH1 0x00 0FBC 80 DUP1 0FBD 60 PUSH1 0x00 0FBF 80 DUP1 0FC0 60 PUSH1 0x00 0FC2 80 DUP1 0FC3 60 PUSH1 0x00 0FC5 80 DUP1 0FC6 60 PUSH1 0x00 0FC8 80 DUP1 0FC9 61 PUSH2 0x0167 0FCC 60 PUSH1 0x00 0FCE 01 ADD 0FCF 54 SLOAD 0FD0 61 PUSH2 0x0167 0FD3 60 PUSH1 0x01 0FD5 01 ADD 0FD6 54 SLOAD 0FD7 61 PUSH2 0x0167 0FDA 60 PUSH1 0x02 0FDC 01 ADD 0FDD 54 SLOAD 0FDE 6A PUSH11 0x084595161401484a000000 0FEA 61 PUSH2 0x0167 0FED 60 PUSH1 0x04 0FEF 01 ADD 0FF0 54 SLOAD 0FF1 61 PUSH2 0x0167 0FF4 60 PUSH1 0x05 0FF6 01 ADD 0FF7 54 SLOAD 0FF8 61 PUSH2 0x0167 0FFB 60 PUSH1 0x06 0FFD 01 ADD 0FFE 54 SLOAD 0FFF 61 PUSH2 0x100c 1002 61 PUSH2 0x0167 1005 60 PUSH1 0x07 1007 01 ADD 1008 61 PUSH2 0x2c8c 100B 56 *JUMP // Stack delta = +19 // Outputs[19] // { // @0FBA stack[0] = 0x00 // @0FBC stack[1] = 0x00 // @0FBD stack[2] = 0x00 // @0FBF stack[3] = 0x00 // @0FC0 stack[4] = 0x00 // @0FC2 stack[5] = 0x00 // @0FC3 stack[6] = 0x00 // @0FC5 stack[7] = 0x00 // @0FC6 stack[8] = 0x00 // @0FC8 stack[9] = 0x00 // @0FCF stack[10] = storage[0x0167] // @0FD6 stack[11] = storage[0x0168] // @0FDD stack[12] = storage[0x0169] // @0FDE stack[13] = 0x084595161401484a000000 // @0FF0 stack[14] = storage[0x016b] // @0FF7 stack[15] = storage[0x016c] // @0FFE stack[16] = storage[0x016d] // @0FFF stack[17] = 0x100c // @1007 stack[18] = 0x07 + 0x0167 // } // Block ends with call to 0x2c8c, returns to 0x100C label_100C: // Incoming return from call to 0x2C8C at 0x100B // Incoming return from call to 0x2C8C at 0x100B // Inputs[21] // { // @1019 storage[0x016f] // @1033 storage[0x016f] // @1041 stack[-9] // @1043 stack[-10] // @1045 stack[-1] // @1045 stack[-11] // @1047 stack[-12] // @1047 stack[-2] // @1049 stack[-13] // @1049 stack[-3] // @104B stack[-14] // @104B stack[-4] // @104D stack[-15] // @104D stack[-5] // @104F stack[-6] // @104F stack[-16] // @1051 stack[-7] // @1051 stack[-17] // @1053 stack[-8] // @1053 stack[-18] // @105E stack[-19] // } 100C 5B JUMPDEST 100D 61 PUSH2 0x0167 1010 60 PUSH1 0x07 1012 01 ADD 1013 60 PUSH1 0x01 1015 01 ADD 1016 60 PUSH1 0x00 1018 90 SWAP1 1019 54 SLOAD 101A 90 SWAP1 101B 61 PUSH2 0x0100 101E 0A EXP 101F 90 SWAP1 1020 04 DIV 1021 63 PUSH4 0xffffffff 1026 16 AND 1027 61 PUSH2 0x0167 102A 60 PUSH1 0x07 102C 01 ADD 102D 60 PUSH1 0x01 102F 01 ADD 1030 60 PUSH1 0x04 1032 90 SWAP1 1033 54 SLOAD 1034 90 SWAP1 1035 61 PUSH2 0x0100 1038 0A EXP 1039 90 SWAP1 103A 04 DIV 103B 63 PUSH4 0xffffffff 1040 16 AND 1041 99 SWAP10 1042 50 POP 1043 99 SWAP10 1044 50 POP 1045 99 SWAP10 1046 50 POP 1047 99 SWAP10 1048 50 POP 1049 99 SWAP10 104A 50 POP 104B 99 SWAP10 104C 50 POP 104D 99 SWAP10 104E 50 POP 104F 99 SWAP10 1050 50 POP 1051 99 SWAP10 1052 50 POP 1053 99 SWAP10 1054 50 POP 1055 90 SWAP1 1056 91 SWAP2 1057 92 SWAP3 1058 93 SWAP4 1059 94 SWAP5 105A 95 SWAP6 105B 96 SWAP7 105C 97 SWAP8 105D 98 SWAP9 105E 99 SWAP10 105F 56 *JUMP // Stack delta = -9 // Outputs[10] // { // @1055 stack[-10] = 0xffffffff & storage[0x016f] / 0x0100 ** 0x04 // @1056 stack[-11] = 0xffffffff & storage[0x016f] / 0x0100 ** 0x00 // @1057 stack[-12] = stack[-1] // @1058 stack[-13] = stack[-2] // @1059 stack[-14] = stack[-3] // @105A stack[-15] = stack[-4] // @105B stack[-16] = stack[-5] // @105C stack[-17] = stack[-6] // @105D stack[-18] = stack[-7] // @105E stack[-19] = stack[-8] // } // Block ends with unconditional jump to stack[-19] label_1060: // Incoming jump from 0x040E // Inputs[4] // { // @1069 stack[-1] // @1079 memory[0x00:0x40] // @107B storage[keccak256(memory[0x00:0x40])] // @1080 storage[keccak256(memory[0x00:0x40]) + 0x06] // } 1060 5B JUMPDEST 1061 60 PUSH1 0x01 1063 60 PUSH1 0x01 1065 60 PUSH1 0xa0 1067 1B SHL 1068 03 SUB 1069 81 DUP2 106A 16 AND 106B 60 PUSH1 0x00 106D 90 SWAP1 106E 81 DUP2 106F 52 MSTORE 1070 61 PUSH2 0x0166 1073 60 PUSH1 0x20 1075 52 MSTORE 1076 60 PUSH1 0x40 1078 81 DUP2 1079 20 SHA3 107A 80 DUP1 107B 54 SLOAD 107C 60 PUSH1 0x06 107E 82 DUP3 107F 01 ADD 1080 54 SLOAD 1081 83 DUP4 1082 92 SWAP3 1083 83 DUP4 1084 92 SWAP3 1085 83 DUP4 1086 92 SWAP3 1087 83 DUP4 1088 92 SWAP3 1089 61 PUSH2 0x1094 108C 90 SWAP1 108D 60 PUSH1 0x01 108F 01 ADD 1090 61 PUSH2 0x2c8c 1093 56 *JUMP // Stack delta = +9 // Outputs[11] // { // @106D stack[0] = 0x00 // @106F memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1075 memory[0x20:0x40] = 0x0166 // @1082 stack[1] = 0x00 // @1084 stack[2] = 0x00 // @1084 stack[5] = storage[keccak256(memory[0x00:0x40])] // @1086 stack[6] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @1086 stack[3] = 0x00 // @1088 stack[4] = 0x00 // @108C stack[7] = 0x1094 // @108F stack[8] = 0x01 + keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2c8c, returns to 0x1094 label_1094: // Incoming return from call to 0x2C8C at 0x1093 // Inputs[11] // { // @109D stack[-9] // @109E stack[-1] // @10AF memory[0x00:0x40] // @10B3 storage[0x02 + keccak256(memory[0x00:0x40])] // @10B4 stack[-3] // @10B5 stack[-10] // @10B6 stack[-2] // @10B8 stack[-8] // @10C2 stack[-7] // @10CF stack[-6] // @10D1 stack[-5] // } 1094 5B JUMPDEST 1095 60 PUSH1 0x01 1097 60 PUSH1 0x01 1099 60 PUSH1 0xa0 109B 1B SHL 109C 03 SUB 109D 98 SWAP9 109E 90 SWAP1 109F 98 SWAP9 10A0 16 AND 10A1 60 PUSH1 0x00 10A3 90 SWAP1 10A4 81 DUP2 10A5 52 MSTORE 10A6 61 PUSH2 0x0166 10A9 60 PUSH1 0x20 10AB 52 MSTORE 10AC 60 PUSH1 0x40 10AE 90 SWAP1 10AF 20 SHA3 10B0 60 PUSH1 0x02 10B2 01 ADD 10B3 54 SLOAD 10B4 91 SWAP2 10B5 98 SWAP9 10B6 90 SWAP1 10B7 97 SWAP8 10B8 96 SWAP7 10B9 50 POP 10BA 63 PUSH4 0xffffffff 10BF 80 DUP1 10C0 83 DUP4 10C1 16 AND 10C2 96 SWAP7 10C3 50 POP 10C4 60 PUSH1 0x01 10C6 60 PUSH1 0x20 10C8 1B SHL 10C9 90 SWAP1 10CA 92 SWAP3 10CB 04 DIV 10CC 90 SWAP1 10CD 91 SWAP2 10CE 16 AND 10CF 93 SWAP4 10D0 50 POP 10D1 91 SWAP2 10D2 50 POP 10D3 50 POP 10D4 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @10A5 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-9] // @10AB memory[0x20:0x40] = 0x0166 // @10B5 stack[-10] = stack[-3] // @10B7 stack[-9] = stack[-2] // @10B8 stack[-8] = stack[-1] // @10C2 stack[-7] = storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // @10CF stack[-6] = 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // } // Block ends with unconditional jump to stack[-10] label_10D5: // Incoming jump from 0x0452 // Inputs[1] { @10DB msg.sender } 10D5 5B JUMPDEST 10D6 61 PUSH2 0x10e0 10D9 60 PUSH1 0x00 10DB 33 CALLER 10DC 61 PUSH2 0x13b7 10DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10D6 stack[0] = 0x10e0 // @10D9 stack[1] = 0x00 // @10DB stack[2] = msg.sender // } // Block ends with call to 0x13b7, returns to 0x10E0 label_10E0: // Incoming return from call to 0x13B7 at 0x10DF // Inputs[1] { @10E4 stack[-1] } 10E0 5B JUMPDEST 10E1 61 PUSH2 0x10fc 10E4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10fc, if stack[-1] label_10E5: // Incoming jump from 0x10E4, if not stack[-1] // Inputs[1] { @10E7 memory[0x40:0x60] } 10E5 60 PUSH1 0x40 10E7 51 MLOAD 10E8 62 PUSH3 0x461bcd 10EC 60 PUSH1 0xe5 10EE 1B SHL 10EF 81 DUP2 10F0 52 MSTORE 10F1 60 PUSH1 0x04 10F3 01 ADD 10F4 61 PUSH2 0x0817 10F7 90 SWAP1 10F8 61 PUSH2 0x3fe8 10FB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10F7 stack[0] = 0x0817 // @10F7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3fe8, returns to 0x0817 label_10FC: // Incoming jump from 0x10E4, if stack[-1] // Inputs[6] // { // @1105 stack[-3] // @1106 stack[-1] // @111A memory[0x00:0x40] // @111B stack[-2] // @1125 memory[0x00:0x40] // @1127 stack[-4] // } 10FC 5B JUMPDEST 10FD 60 PUSH1 0x01 10FF 60 PUSH1 0x01 1101 60 PUSH1 0xa0 1103 1B SHL 1104 03 SUB 1105 92 SWAP3 1106 90 SWAP1 1107 92 SWAP3 1108 16 AND 1109 60 PUSH1 0x00 110B 90 SWAP1 110C 81 DUP2 110D 52 MSTORE 110E 61 PUSH2 0x0166 1111 60 PUSH1 0x20 1113 90 SWAP1 1114 81 DUP2 1115 52 MSTORE 1116 60 PUSH1 0x40 1118 80 DUP1 1119 83 DUP4 111A 20 SHA3 111B 93 SWAP4 111C 83 DUP4 111D 52 MSTORE 111E 60 PUSH1 0x04 1120 90 SWAP1 1121 93 SWAP4 1122 01 ADD 1123 90 SWAP1 1124 52 MSTORE 1125 20 SHA3 1126 55 SSTORE 1127 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @110D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1115 memory[0x20:0x40] = 0x0166 // @111D memory[0x00:0x20] = stack[-2] // @1124 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x04 // @1126 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_1128: // Incoming jump from 0x048E // Inputs[4] // { // @1131 stack[-2] // @1141 memory[0x00:0x40] // @1145 storage[0x06 + keccak256(memory[0x00:0x40])] // @114A stack[-1] // } 1128 5B JUMPDEST 1129 60 PUSH1 0x01 112B 60 PUSH1 0x01 112D 60 PUSH1 0xa0 112F 1B SHL 1130 03 SUB 1131 82 DUP3 1132 16 AND 1133 60 PUSH1 0x00 1135 90 SWAP1 1136 81 DUP2 1137 52 MSTORE 1138 61 PUSH2 0x0166 113B 60 PUSH1 0x20 113D 52 MSTORE 113E 60 PUSH1 0x40 1140 81 DUP2 1141 20 SHA3 1142 60 PUSH1 0x06 1144 01 ADD 1145 54 SLOAD 1146 81 DUP2 1147 90 SWAP1 1148 81 DUP2 1149 90 SWAP1 114A 84 DUP5 114B 10 LT 114C 61 PUSH2 0x118c 114F 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1135 stack[0] = 0x00 // @1137 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @113D memory[0x20:0x40] = 0x0166 // @1147 stack[1] = 0x00 // @1149 stack[2] = 0x00 // } // Block ends with conditional jump to 0x118c, if stack[-1] < storage[0x06 + keccak256(memory[0x00:0x40])] label_1150: // Incoming jump from 0x114F, if not stack[-1] < storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[1] { @1152 memory[0x40:0x60] } 1150 60 PUSH1 0x40 1152 51 MLOAD 1153 62 PUSH3 0x461bcd 1157 60 PUSH1 0xe5 1159 1B SHL 115A 81 DUP2 115B 52 MSTORE 115C 60 PUSH1 0x20 115E 60 PUSH1 0x04 1160 82 DUP3 1161 01 ADD 1162 52 MSTORE 1163 60 PUSH1 0x12 1165 60 PUSH1 0x24 1167 82 DUP3 1168 01 ADD 1169 52 MSTORE 116A 71 PUSH18 0x125b99195e081bdd5d081bd988189bdd5b99 117D 60 PUSH1 0x72 117F 1B SHL 1180 60 PUSH1 0x44 1182 82 DUP3 1183 01 ADD 1184 52 MSTORE 1185 60 PUSH1 0x64 1187 01 ADD 1188 61 PUSH2 0x0817 118B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @115B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1162 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1169 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @1184 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x125b99195e081bdd5d081bd988189bdd5b99 << 0x72 // @1187 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_118C: // Incoming jump from 0x114F, if stack[-1] < storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[10] // { // @1198 stack[-5] // @1199 stack[-4] // @11AD memory[0x00:0x40] // @11B9 memory[0x00:0x40] // @11BA storage[keccak256(memory[0x00:0x40])] // @11C3 memory[0x00:0x40] // @11C4 storage[keccak256(memory[0x00:0x40])] // @11CF memory[0x00:0x40] // @11D0 storage[keccak256(memory[0x00:0x40])] // @11D2 stack[-6] // } 118C 5B JUMPDEST 118D 50 POP 118E 50 POP 118F 50 POP 1190 60 PUSH1 0x01 1192 60 PUSH1 0x01 1194 60 PUSH1 0xa0 1196 1B SHL 1197 03 SUB 1198 91 SWAP2 1199 90 SWAP1 119A 91 SWAP2 119B 16 AND 119C 60 PUSH1 0x00 119E 90 SWAP1 119F 81 DUP2 11A0 52 MSTORE 11A1 61 PUSH2 0x0166 11A4 60 PUSH1 0x20 11A6 90 SWAP1 11A7 81 DUP2 11A8 52 MSTORE 11A9 60 PUSH1 0x40 11AB 80 DUP1 11AC 83 DUP4 11AD 20 SHA3 11AE 93 SWAP4 11AF 83 DUP4 11B0 52 MSTORE 11B1 60 PUSH1 0x04 11B3 84 DUP5 11B4 01 ADD 11B5 82 DUP3 11B6 52 MSTORE 11B7 80 DUP1 11B8 83 DUP4 11B9 20 SHA3 11BA 54 SLOAD 11BB 60 PUSH1 0x05 11BD 85 DUP6 11BE 01 ADD 11BF 83 DUP4 11C0 52 MSTORE 11C1 81 DUP2 11C2 84 DUP5 11C3 20 SHA3 11C4 54 SLOAD 11C5 60 PUSH1 0x03 11C7 90 SWAP1 11C8 95 SWAP6 11C9 01 ADD 11CA 90 SWAP1 11CB 92 SWAP3 11CC 52 MSTORE 11CD 90 SWAP1 11CE 91 SWAP2 11CF 20 SHA3 11D0 54 SLOAD 11D1 90 SWAP1 11D2 92 SWAP3 11D3 56 *JUMP // Stack delta = -3 // Outputs[9] // { // @11A0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @11A8 memory[0x20:0x40] = 0x0166 // @11B0 memory[0x00:0x20] = stack[-4] // @11B6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x04 // @11C0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x05 // @11C8 stack[-5] = storage[keccak256(memory[0x00:0x40])] // @11CC memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x03 // @11D1 stack[-4] = storage[keccak256(memory[0x00:0x40])] // @11D2 stack[-6] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-6] label_11D4: // Incoming jump from 0x04BC // Inputs[3] // { // @11DD stack[-1] // @11EC memory[0x00:0x40] // @11ED storage[keccak256(memory[0x00:0x40])] // } 11D4 5B JUMPDEST 11D5 60 PUSH1 0x01 11D7 60 PUSH1 0x01 11D9 60 PUSH1 0xa0 11DB 1B SHL 11DC 03 SUB 11DD 81 DUP2 11DE 16 AND 11DF 60 PUSH1 0x00 11E1 90 SWAP1 11E2 81 DUP2 11E3 52 MSTORE 11E4 60 PUSH1 0xfd 11E6 60 PUSH1 0x20 11E8 52 MSTORE 11E9 60 PUSH1 0x40 11EB 81 DUP2 11EC 20 SHA3 11ED 54 SLOAD 11EE 61 PUSH2 0x06a1 11F1 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @11E1 stack[0] = 0x00 // @11E3 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @11E8 memory[0x20:0x40] = 0xfd // @11ED stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x06a1 label_11F2: // Incoming jump from 0x04CF // Inputs[1] { @11F8 msg.sender } 11F2 5B JUMPDEST 11F3 61 PUSH2 0x11fd 11F6 60 PUSH1 0x00 11F8 33 CALLER 11F9 61 PUSH2 0x13b7 11FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11F3 stack[0] = 0x11fd // @11F6 stack[1] = 0x00 // @11F8 stack[2] = msg.sender // } // Block ends with call to 0x13b7, returns to 0x11FD label_11FD: // Incoming return from call to 0x13B7 at 0x11FC // Inputs[1] { @1201 stack[-1] } 11FD 5B JUMPDEST 11FE 61 PUSH2 0x1219 1201 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1219, if stack[-1] label_1202: // Incoming jump from 0x1201, if not stack[-1] // Inputs[1] { @1204 memory[0x40:0x60] } 1202 60 PUSH1 0x40 1204 51 MLOAD 1205 62 PUSH3 0x461bcd 1209 60 PUSH1 0xe5 120B 1B SHL 120C 81 DUP2 120D 52 MSTORE 120E 60 PUSH1 0x04 1210 01 ADD 1211 61 PUSH2 0x0817 1214 90 SWAP1 1215 61 PUSH2 0x3fe8 1218 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @120D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1214 stack[0] = 0x0817 // @1214 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3fe8, returns to 0x0817 label_1219: // Incoming jump from 0x1201, if stack[-1] // Inputs[3] // { // @121D stack[-2] // @121E stack[-1] // @1225 stack[-3] // } 1219 5B JUMPDEST 121A 61 PUSH2 0x0173 121D 91 SWAP2 121E 90 SWAP1 121F 91 SWAP2 1220 55 SSTORE 1221 61 PUSH2 0x0171 1224 55 SSTORE 1225 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1220 storage[0x0173] = stack[-2] // @1224 storage[0x0171] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1226: // Incoming jump from 0x04E2 // Inputs[1] { @1233 stack[-1] } 1226 5B JUMPDEST 1227 60 PUSH1 0x00 1229 80 DUP1 122A 60 PUSH1 0x00 122C 80 DUP1 122D 60 PUSH1 0x00 122F 80 DUP1 1230 61 PUSH2 0x1238 1233 87 DUP8 1234 61 PUSH2 0x2ce9 1237 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @1227 stack[0] = 0x00 // @1229 stack[1] = 0x00 // @122A stack[2] = 0x00 // @122C stack[3] = 0x00 // @122D stack[4] = 0x00 // @122F stack[5] = 0x00 // @1230 stack[6] = 0x1238 // @1233 stack[7] = stack[-1] // } // Block ends with call to 0x2ce9, returns to 0x1238 label_1238: // Incoming return from call to 0x2CE9 at 0x1237 // Inputs[7] // { // @1239 stack[-3] // @1239 stack[-1] // @123A stack[-9] // @123C stack[-8] // @123C stack[-2] // @123E stack[-7] // @1244 stack[-10] // } 1238 5B JUMPDEST 1239 91 SWAP2 123A 97 SWAP8 123B 50 POP 123C 95 SWAP6 123D 50 POP 123E 93 SWAP4 123F 50 POP 1240 61 PUSH2 0x1249 1243 84 DUP5 1244 88 DUP9 1245 61 PUSH2 0x22d7 1248 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @123A stack[-9] = stack[-3] // @123C stack[-8] = stack[-2] // @123E stack[-7] = stack[-1] // @1240 stack[-3] = 0x1249 // @1243 stack[-2] = stack[-1] // @1244 stack[-1] = stack[-10] // } // Block ends with call to 0x22d7, returns to 0x1249 label_1249: // Incoming return from call to 0x22D7 at 0x1248 // Incoming return from call to 0x22D7 at 0x1248 // Inputs[3] // { // @124A stack[-3] // @124A stack[-1] // @124C stack[-6] // } 1249 5B JUMPDEST 124A 91 SWAP2 124B 50 POP 124C 84 DUP5 124D 15 ISZERO 124E 61 PUSH2 0x127e 1251 57 *JUMPI // Stack delta = -1 // Outputs[1] { @124A stack[-3] = stack[-1] } // Block ends with conditional jump to 0x127e, if !stack[-6] label_1252: // Incoming jump from 0x1251, if not !stack[-6] // Inputs[2] // { // @1252 stack[-5] // @1262 stack[-2] // } 1252 84 DUP5 1253 61 PUSH2 0x1267 1256 6A PUSH11 0x084595161401484a000000 1262 84 DUP5 1263 61 PUSH2 0x3fa7 1266 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1252 stack[0] = stack[-5] // @1253 stack[1] = 0x1267 // @1256 stack[2] = 0x084595161401484a000000 // @1262 stack[3] = stack[-2] // } // Block ends with call to 0x3fa7, returns to 0x1267 label_1267: // Incoming return from call to 0x3FA7 at 0x1266 // Inputs[2] // { // @126B stack[-2] // @126C stack[-1] // } 1267 5B JUMPDEST 1268 61 PUSH2 0x1271 126B 91 SWAP2 126C 90 SWAP1 126D 61 PUSH2 0x3fc6 1270 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @126B stack[-2] = 0x1271 // @126C stack[-1] = stack[-2] // @126C stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1271 label_1271: // Incoming return from call to 0x3FC6 at 0x1270 // Inputs[2] // { // @1275 stack[-1] // @1276 stack[-7] // } 1271 5B JUMPDEST 1272 61 PUSH2 0x127b 1275 90 SWAP1 1276 87 DUP8 1277 61 PUSH2 0x3f5f 127A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1275 stack[0] = stack[-1] // @1275 stack[-1] = 0x127b // @1276 stack[1] = stack[-7] // } // Block ends with call to 0x3f5f, returns to 0x127B label_127B: // Incoming return from call to 0x3F5F at 0x127A // Inputs[2] // { // @127C stack[-7] // @127C stack[-1] // } 127B 5B JUMPDEST 127C 95 SWAP6 127D 50 POP // Stack delta = -1 // Outputs[1] { @127C stack[-7] = stack[-1] } // Block continues label_127E: // Incoming jump from 0x127D // Incoming jump from 0x1251, if !stack[-6] // Inputs[2] // { // @1282 stack[-8] // @1283 stack[-7] // } 127E 5B JUMPDEST 127F 61 PUSH2 0x1288 1282 88 DUP9 1283 88 DUP9 1284 61 PUSH2 0x2ddf 1287 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @127F stack[0] = 0x1288 // @1282 stack[1] = stack[-8] // @1283 stack[2] = stack[-7] // } // Block ends with call to 0x2ddf, returns to 0x1288 label_1288: // Incoming return from call to 0x2DDF at 0x1287 // Inputs[3] // { // @1289 stack[-4] // @1289 stack[-1] // @129A stack[-7] // } 1288 5B JUMPDEST 1289 92 SWAP3 128A 50 POP 128B 6A PUSH11 0x084595161401484a000000 1297 61 PUSH2 0x12a0 129A 87 DUP8 129B 85 DUP6 129C 61 PUSH2 0x3fa7 129F 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1289 stack[-4] = stack[-1] // @128B stack[-1] = 0x084595161401484a000000 // @1297 stack[0] = 0x12a0 // @129A stack[1] = stack[-7] // @129B stack[2] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x12A0 label_12A0: // Incoming return from call to 0x3FA7 at 0x129F // Inputs[2] // { // @12A4 stack[-2] // @12A5 stack[-1] // } 12A0 5B JUMPDEST 12A1 61 PUSH2 0x12aa 12A4 91 SWAP2 12A5 90 SWAP1 12A6 61 PUSH2 0x3fc6 12A9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @12A4 stack[-2] = 0x12aa // @12A5 stack[-1] = stack[-2] // @12A5 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x12AA label_12AA: // Incoming return from call to 0x3FC6 at 0x12A9 // Inputs[10] // { // @12AB stack[-2] // @12AB stack[-1] // @12AD stack[-5] // @12AE stack[-8] // @12B0 stack[-3] // @12B0 stack[-6] // @12B1 stack[-9] // @12B3 stack[-7] // @12B3 stack[-4] // @12B4 stack[-10] // } 12AA 5B JUMPDEST 12AB 90 SWAP1 12AC 50 POP 12AD 92 SWAP3 12AE 95 SWAP6 12AF 50 POP 12B0 92 SWAP3 12B1 95 SWAP6 12B2 50 POP 12B3 92 SWAP3 12B4 95 SWAP6 12B5 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @12AD stack[-5] = stack[-1] // @12AE stack[-8] = stack[-5] // @12B0 stack[-6] = stack[-3] // @12B1 stack[-9] = stack[-6] // @12B3 stack[-7] = stack[-4] // @12B4 stack[-10] = stack[-7] // } // Block ends with unconditional jump to stack[-10] label_12B6: // Incoming jump from 0x0522 // Inputs[3] // { // @12B9 stack[-1] // @12C5 memory[0x00:0x40] // @12C6 storage[keccak256(memory[0x00:0x40])] // } 12B6 5B JUMPDEST 12B7 60 PUSH1 0x00 12B9 81 DUP2 12BA 81 DUP2 12BB 52 MSTORE 12BC 61 PUSH2 0x016e 12BF 60 PUSH1 0x20 12C1 52 MSTORE 12C2 60 PUSH1 0x40 12C4 81 DUP2 12C5 20 SHA3 12C6 54 SLOAD 12C7 81 DUP2 12C8 90 SWAP1 12C9 63 PUSH4 0xffffffff 12CE 16 AND 12CF 61 PUSH2 0x12ea 12D2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @12B7 stack[0] = 0x00 // @12BB memory[0x00:0x20] = stack[-1] // @12C1 memory[0x20:0x40] = 0x016e // @12C8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x12ea, if 0xffffffff & storage[keccak256(memory[0x00:0x40])] label_12D3: // Incoming jump from 0x12D2, if not 0xffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @12D5 memory[0x40:0x60] } 12D3 60 PUSH1 0x40 12D5 51 MLOAD 12D6 62 PUSH3 0x461bcd 12DA 60 PUSH1 0xe5 12DC 1B SHL 12DD 81 DUP2 12DE 52 MSTORE 12DF 60 PUSH1 0x04 12E1 01 ADD 12E2 61 PUSH2 0x0817 12E5 90 SWAP1 12E6 61 PUSH2 0x40e7 12E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12E5 stack[0] = 0x0817 // @12E5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x40e7, returns to 0x0817 label_12EA: // Incoming jump from 0x12D2, if 0xffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @12EF stack[-3] // @12FB memory[0x00:0x40] // @12FC storage[keccak256(memory[0x00:0x40])] // @1304 stack[-4] // } 12EA 5B JUMPDEST 12EB 50 POP 12EC 50 POP 12ED 60 PUSH1 0x00 12EF 90 SWAP1 12F0 81 DUP2 12F1 52 MSTORE 12F2 61 PUSH2 0x016e 12F5 60 PUSH1 0x20 12F7 52 MSTORE 12F8 60 PUSH1 0x40 12FA 90 SWAP1 12FB 20 SHA3 12FC 54 SLOAD 12FD 63 PUSH4 0xffffffff 1302 81 DUP2 1303 16 AND 1304 91 SWAP2 1305 60 PUSH1 0x01 1307 60 PUSH1 0x20 1309 1B SHL 130A 90 SWAP1 130B 91 SWAP2 130C 04 DIV 130D 60 PUSH1 0x01 130F 60 PUSH1 0x01 1311 60 PUSH1 0x60 1313 1B SHL 1314 03 SUB 1315 16 AND 1316 90 SWAP1 1317 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @12F1 memory[0x00:0x20] = stack[-3] // @12F7 memory[0x20:0x40] = 0x016e // @1304 stack[-4] = storage[keccak256(memory[0x00:0x40])] & 0xffffffff // @1316 stack[-3] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // } // Block ends with unconditional jump to stack[-4] label_1318: // Incoming jump from 0x053F // Inputs[2] // { // @131E storage[0x0172] // @131F block.number // } 1318 5B JUMPDEST 1319 60 PUSH1 0x00 131B 61 PUSH2 0x0172 131E 54 SLOAD 131F 43 NUMBER 1320 11 GT 1321 61 PUSH2 0x133c 1324 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1319 stack[0] = 0x00 } // Block ends with conditional jump to 0x133c, if block.number > storage[0x0172] label_1325: // Incoming jump from 0x1324, if not block.number > storage[0x0172] // Inputs[1] { @1327 memory[0x40:0x60] } 1325 60 PUSH1 0x40 1327 51 MLOAD 1328 62 PUSH3 0x461bcd 132C 60 PUSH1 0xe5 132E 1B SHL 132F 81 DUP2 1330 52 MSTORE 1331 60 PUSH1 0x04 1333 01 ADD 1334 61 PUSH2 0x0817 1337 90 SWAP1 1338 61 PUSH2 0x4113 133B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1330 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1337 stack[0] = 0x0817 // @1337 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4113, returns to 0x0817 label_133C: // Incoming jump from 0x1324, if block.number > storage[0x0172] // Inputs[3] // { // @1340 storage[0x0171] // @1344 storage[0x0172] // @1349 block.number // } 133C 5B JUMPDEST 133D 61 PUSH2 0x0171 1340 54 SLOAD 1341 61 PUSH2 0x0172 1344 54 SLOAD 1345 61 PUSH2 0x134e 1348 90 SWAP1 1349 43 NUMBER 134A 61 PUSH2 0x3f77 134D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1340 stack[0] = storage[0x0171] // @1348 stack[1] = 0x134e // @1348 stack[2] = storage[0x0172] // @1349 stack[3] = block.number // } // Block ends with call to 0x3f77, returns to 0x134E label_134E: // Incoming return from call to 0x3F77 at 0x134D // Inputs[2] // { // @1352 stack[-2] // @1353 stack[-1] // } 134E 5B JUMPDEST 134F 61 PUSH2 0x1358 1352 91 SWAP2 1353 90 SWAP1 1354 61 PUSH2 0x3fc6 1357 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1352 stack[-2] = 0x1358 // @1353 stack[-1] = stack[-2] // @1353 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1358 label_1358: // Incoming return from call to 0x3FC6 at 0x1357 // Inputs[1] { @135C stack[-1] } 1358 5B JUMPDEST 1359 61 PUSH2 0x1363 135C 90 SWAP1 135D 60 PUSH1 0x02 135F 61 PUSH2 0x4242 1362 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @135C stack[0] = stack[-1] // @135C stack[-1] = 0x1363 // @135D stack[1] = 0x02 // } // Block ends with call to 0x4242, returns to 0x1363 label_1363: // Incoming return from call to 0x4242 at 0x1362 // Inputs[2] // { // @1367 storage[0x0170] // @136B stack[-1] // } 1363 5B JUMPDEST 1364 61 PUSH2 0x0170 1367 54 SLOAD 1368 61 PUSH2 0x0c1f 136B 91 SWAP2 136C 90 SWAP1 136D 61 PUSH2 0x3fc6 1370 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @136B stack[-1] = 0x0c1f // @136C stack[1] = storage[0x0170] // @136C stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x0C1F label_1371: // Incoming call from 0x22E2, returns to 0x22E3 // Incoming call from 0x23A7, returns to 0x23A8 // Incoming jump from 0x0552 // Inputs[3] // { // @1375 storage[0x0171] // @1379 storage[0x0172] // @1382 stack[-1] // } 1371 5B JUMPDEST 1372 61 PUSH2 0x0171 1375 54 SLOAD 1376 61 PUSH2 0x0172 1379 54 SLOAD 137A 60 PUSH1 0x00 137C 91 SWAP2 137D 90 SWAP1 137E 61 PUSH2 0x1387 1381 82 DUP3 1382 85 DUP6 1383 61 PUSH2 0x3f5f 1386 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @137C stack[0] = 0x00 // @137D stack[1] = storage[0x0171] // @137D stack[2] = storage[0x0172] // @137E stack[3] = 0x1387 // @1381 stack[4] = storage[0x0171] // @1382 stack[5] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x1387 label_1387: // Incoming return from call to 0x3F5F at 0x1386 // Inputs[2] // { // @138B stack[-2] // @138C stack[-1] // } 1387 5B JUMPDEST 1388 61 PUSH2 0x1391 138B 91 SWAP2 138C 90 SWAP1 138D 61 PUSH2 0x3f77 1390 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @138B stack[-2] = 0x1391 // @138C stack[-1] = stack[-2] // @138C stack[0] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x1391 label_1391: // Incoming return from call to 0x3F77 at 0x1390 // Inputs[2] // { // @1395 stack[-2] // @1396 stack[-1] // } 1391 5B JUMPDEST 1392 61 PUSH2 0x139b 1395 91 SWAP2 1396 90 SWAP1 1397 61 PUSH2 0x3fc6 139A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1395 stack[-2] = 0x139b // @1396 stack[-1] = stack[-2] // @1396 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x139B label_139B: // Incoming return from call to 0x3FC6 at 0x139A // Inputs[2] // { // @139F storage[0x0171] // @13A3 stack[-1] // } 139B 5B JUMPDEST 139C 61 PUSH2 0x0171 139F 54 SLOAD 13A0 61 PUSH2 0x13a9 13A3 91 SWAP2 13A4 90 SWAP1 13A5 61 PUSH2 0x3fa7 13A8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13A3 stack[-1] = 0x13a9 // @13A4 stack[1] = storage[0x0171] // @13A4 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x13A9 label_13A9: // Incoming return from call to 0x3FA7 at 0x13A8 // Inputs[2] // { // @13AD storage[0x0172] // @13B1 stack[-1] // } 13A9 5B JUMPDEST 13AA 61 PUSH2 0x0172 13AD 54 SLOAD 13AE 61 PUSH2 0x06a1 13B1 91 SWAP2 13B2 90 SWAP1 13B3 61 PUSH2 0x3f5f 13B6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13B1 stack[-1] = 0x06a1 // @13B2 stack[1] = storage[0x0172] // @13B2 stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x06A1 label_13B7: // Incoming call from 0x2FFC, returns to 0x2FFD // Incoming call from 0x29B1, returns to 0x29B2 // Incoming call from 0x10DF, returns to 0x10E0 // Incoming call from 0x28AC, returns to 0x28AD // Incoming jump from 0x0565 // Incoming call from 0x11FC, returns to 0x11FD // Incoming call from 0x0CAC, returns to 0x0CAD // Inputs[6] // { // @13BA stack[-2] // @13C8 memory[0x00:0x40] // @13D1 stack[-1] // @13DB memory[0x00:0x40] // @13DC storage[keccak256(memory[0x00:0x40])] // @13E0 stack[-3] // } 13B7 5B JUMPDEST 13B8 60 PUSH1 0x00 13BA 91 SWAP2 13BB 82 DUP3 13BC 52 MSTORE 13BD 60 PUSH1 0x65 13BF 60 PUSH1 0x20 13C1 90 SWAP1 13C2 81 DUP2 13C3 52 MSTORE 13C4 60 PUSH1 0x40 13C6 80 DUP1 13C7 84 DUP5 13C8 20 SHA3 13C9 60 PUSH1 0x01 13CB 60 PUSH1 0x01 13CD 60 PUSH1 0xa0 13CF 1B SHL 13D0 03 SUB 13D1 93 SWAP4 13D2 90 SWAP1 13D3 93 SWAP4 13D4 16 AND 13D5 84 DUP5 13D6 52 MSTORE 13D7 91 SWAP2 13D8 90 SWAP1 13D9 52 MSTORE 13DA 90 SWAP1 13DB 20 SHA3 13DC 54 SLOAD 13DD 60 PUSH1 0xff 13DF 16 AND 13E0 90 SWAP1 13E1 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @13BC memory[0x00:0x20] = stack[-2] // @13C3 memory[0x20:0x40] = 0x65 // @13D6 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @13D9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13E0 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_13E2: // Incoming jump from 0x0578 // Inputs[2] // { // @13E8 stack[-1] // @13EC block.number // } 13E2 5B JUMPDEST 13E3 60 PUSH1 0x00 13E5 61 PUSH2 0x06a1 13E8 82 DUP3 13E9 61 PUSH2 0x13f3 13EC 43 NUMBER 13ED 60 PUSH1 0x01 13EF 61 PUSH2 0x3f5f 13F2 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @13E3 stack[0] = 0x00 // @13E5 stack[1] = 0x06a1 // @13E8 stack[2] = stack[-1] // @13E9 stack[3] = 0x13f3 // @13EC stack[4] = block.number // @13ED stack[5] = 0x01 // } // Block ends with call to 0x3f5f, returns to 0x13F3 label_13F3: // Incoming return from call to 0x3F5F at 0x13F2 13F3 5B JUMPDEST 13F4 61 PUSH2 0x2685 13F7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2685 label_13F8: // Incoming call from 0x0580, returns to 0x026A // Inputs[1] { @13FE storage[0x9b] } 13F8 5B JUMPDEST 13F9 60 PUSH1 0x60 13FB 60 PUSH1 0x9b 13FD 80 DUP1 13FE 54 SLOAD 13FF 61 PUSH2 0x06b6 1402 90 SWAP1 1403 61 PUSH2 0x3e0b 1406 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13F9 stack[0] = 0x60 // @13FB stack[1] = 0x9b // @1402 stack[2] = 0x06b6 // @1402 stack[3] = storage[0x9b] // } // Block ends with call to 0x3e0b, returns to 0x06B6 label_1407: // Incoming jump from 0x05A1 // Inputs[2] // { // @140A msg.sender // @1410 stack[-2] // } 1407 5B JUMPDEST 1408 60 PUSH1 0x00 140A 33 CALLER 140B 81 DUP2 140C 61 PUSH2 0x1415 140F 82 DUP3 1410 86 DUP7 1411 61 PUSH2 0x1610 1414 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1408 stack[0] = 0x00 // @140A stack[1] = msg.sender // @140B stack[2] = 0x00 // @140C stack[3] = 0x1415 // @140F stack[4] = msg.sender // @1410 stack[5] = stack[-2] // } // Block ends with call to 0x1610, returns to 0x1415 label_1415: // Incoming return from call to 0x1610 at 0x1414 // Inputs[3] // { // @1416 stack[-1] // @1416 stack[-2] // @1418 stack[-5] // } 1415 5B JUMPDEST 1416 90 SWAP1 1417 50 POP 1418 83 DUP4 1419 81 DUP2 141A 10 LT 141B 15 ISZERO 141C 61 PUSH2 0x1475 141F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1416 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1475, if !(stack[-1] < stack[-5]) label_1420: // Incoming jump from 0x141F, if not !(stack[-1] < stack[-5]) // Inputs[1] { @1422 memory[0x40:0x60] } 1420 60 PUSH1 0x40 1422 51 MLOAD 1423 62 PUSH3 0x461bcd 1427 60 PUSH1 0xe5 1429 1B SHL 142A 81 DUP2 142B 52 MSTORE 142C 60 PUSH1 0x20 142E 60 PUSH1 0x04 1430 82 DUP3 1431 01 ADD 1432 52 MSTORE 1433 60 PUSH1 0x25 1435 60 PUSH1 0x24 1437 82 DUP3 1438 01 ADD 1439 52 MSTORE 143A 7F PUSH32 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 145B 60 PUSH1 0x44 145D 82 DUP3 145E 01 ADD 145F 52 MSTORE 1460 64 PUSH5 0x207a65726f 1466 60 PUSH1 0xd8 1468 1B SHL 1469 60 PUSH1 0x64 146B 82 DUP3 146C 01 ADD 146D 52 MSTORE 146E 60 PUSH1 0x84 1470 01 ADD 1471 61 PUSH2 0x0817 1474 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @142B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1432 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1439 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @145F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 // @146D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x207a65726f << 0xd8 // @1470 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_1475: // Incoming jump from 0x141F, if !(stack[-1] < stack[-5]) // Inputs[4] // { // @1479 stack[-2] // @147A stack[-5] // @147B stack[-4] // @147C stack[-1] // } 1475 5B JUMPDEST 1476 61 PUSH2 0x0bd4 1479 82 DUP3 147A 86 DUP7 147B 86 DUP7 147C 84 DUP5 147D 03 SUB 147E 61 PUSH2 0x1dc0 1481 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1476 stack[0] = 0x0bd4 // @1479 stack[1] = stack[-2] // @147A stack[2] = stack[-5] // @147D stack[3] = stack[-1] - stack[-4] // } // Block ends with call to 0x1dc0, returns to 0x0BD4 label_1482: // Incoming jump from 0x05B4 // Inputs[3] // { // @1485 msg.sender // @148A stack[-2] // @148B stack[-1] // } 1482 5B JUMPDEST 1483 60 PUSH1 0x00 1485 33 CALLER 1486 61 PUSH2 0x0747 1489 81 DUP2 148A 85 DUP6 148B 85 DUP6 148C 61 PUSH2 0x2107 148F 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1483 stack[0] = 0x00 // @1485 stack[1] = msg.sender // @1486 stack[2] = 0x0747 // @1489 stack[3] = msg.sender // @148A stack[4] = stack[-2] // @148B stack[5] = stack[-1] // } // Block ends with call to 0x2107, returns to 0x0747 label_1490: // Incoming jump from 0x05D0 // Inputs[2] // { // @1491 stack[-4] // @1492 block.timestamp // } 1490 5B JUMPDEST 1491 83 DUP4 1492 42 TIMESTAMP 1493 11 GT 1494 15 ISZERO 1495 61 PUSH2 0x14e0 1498 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14e0, if !(block.timestamp > stack[-4]) label_1499: // Incoming jump from 0x1498, if not !(block.timestamp > stack[-4]) // Inputs[1] { @149B memory[0x40:0x60] } 1499 60 PUSH1 0x40 149B 51 MLOAD 149C 62 PUSH3 0x461bcd 14A0 60 PUSH1 0xe5 14A2 1B SHL 14A3 81 DUP2 14A4 52 MSTORE 14A5 60 PUSH1 0x20 14A7 60 PUSH1 0x04 14A9 82 DUP3 14AA 01 ADD 14AB 52 MSTORE 14AC 60 PUSH1 0x1d 14AE 60 PUSH1 0x24 14B0 82 DUP3 14B1 01 ADD 14B2 52 MSTORE 14B3 7F PUSH32 0x45524332305065726d69743a206578706972656420646561646c696e65000000 14D4 60 PUSH1 0x44 14D6 82 DUP3 14D7 01 ADD 14D8 52 MSTORE 14D9 60 PUSH1 0x64 14DB 01 ADD 14DC 61 PUSH2 0x0817 14DF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @14A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14AB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14B2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @14D8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332305065726d69743a206578706972656420646561646c696e65000000 // @14DB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_14E0: // Incoming jump from 0x1498, if !(block.timestamp > stack[-4]) // Inputs[3] // { // @1504 stack[-7] // @1505 stack[-6] // @1506 stack[-5] // } 14E0 5B JUMPDEST 14E1 60 PUSH1 0x00 14E3 7F PUSH32 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 1504 88 DUP9 1505 88 DUP9 1506 88 DUP9 1507 61 PUSH2 0x150f 150A 8C DUP13 150B 61 PUSH2 0x2e9b 150E 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @14E1 stack[0] = 0x00 // @14E3 stack[1] = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 // @1504 stack[2] = stack[-7] // @1505 stack[3] = stack[-6] // @1506 stack[4] = stack[-5] // @1507 stack[5] = 0x150f // @150A stack[6] = stack[-7] // } // Block ends with unconditional jump to 0x2e9b 150F 5B JUMPDEST 1510 60 PUSH1 0x40 1512 80 DUP1 1513 51 MLOAD 1514 60 PUSH1 0x20 1516 81 DUP2 1517 01 ADD 1518 96 SWAP7 1519 90 SWAP1 151A 96 SWAP7 151B 52 MSTORE 151C 60 PUSH1 0x01 151E 60 PUSH1 0x01 1520 60 PUSH1 0xa0 1522 1B SHL 1523 03 SUB 1524 94 SWAP5 1525 85 DUP6 1526 16 AND 1527 90 SWAP1 1528 86 DUP7 1529 01 ADD 152A 52 MSTORE 152B 92 SWAP3 152C 90 SWAP1 152D 91 SWAP2 152E 16 AND 152F 60 PUSH1 0x60 1531 84 DUP5 1532 01 ADD 1533 52 MSTORE 1534 60 PUSH1 0x80 1536 83 DUP4 1537 01 ADD 1538 52 MSTORE 1539 60 PUSH1 0xa0 153B 82 DUP3 153C 01 ADD 153D 52 MSTORE 153E 60 PUSH1 0xc0 1540 81 DUP2 1541 01 ADD 1542 86 DUP7 1543 90 SWAP1 1544 52 MSTORE 1545 60 PUSH1 0xe0 1547 01 ADD 1548 60 PUSH1 0x40 154A 51 MLOAD 154B 60 PUSH1 0x20 154D 81 DUP2 154E 83 DUP4 154F 03 SUB 1550 03 SUB 1551 81 DUP2 1552 52 MSTORE 1553 90 SWAP1 1554 60 PUSH1 0x40 1556 52 MSTORE 1557 80 DUP1 1558 51 MLOAD 1559 90 SWAP1 155A 60 PUSH1 0x20 155C 01 ADD 155D 20 SHA3 155E 90 SWAP1 155F 50 POP 1560 60 PUSH1 0x00 1562 61 PUSH2 0x156a 1565 82 DUP3 1566 61 PUSH2 0x2c16 1569 56 *JUMP 156A 5B JUMPDEST 156B 90 SWAP1 156C 50 POP 156D 60 PUSH1 0x00 156F 61 PUSH2 0x157a 1572 82 DUP3 1573 87 DUP8 1574 87 DUP8 1575 87 DUP8 1576 61 PUSH2 0x2c64 1579 56 *JUMP 157A 5B JUMPDEST 157B 90 SWAP1 157C 50 POP 157D 89 DUP10 157E 60 PUSH1 0x01 1580 60 PUSH1 0x01 1582 60 PUSH1 0xa0 1584 1B SHL 1585 03 SUB 1586 16 AND 1587 81 DUP2 1588 60 PUSH1 0x01 158A 60 PUSH1 0x01 158C 60 PUSH1 0xa0 158E 1B SHL 158F 03 SUB 1590 16 AND 1591 14 EQ 1592 61 PUSH2 0x15dd 1595 57 *JUMPI 1596 60 PUSH1 0x40 1598 51 MLOAD 1599 62 PUSH3 0x461bcd 159D 60 PUSH1 0xe5 159F 1B SHL 15A0 81 DUP2 15A1 52 MSTORE 15A2 60 PUSH1 0x20 15A4 60 PUSH1 0x04 15A6 82 DUP3 15A7 01 ADD 15A8 52 MSTORE 15A9 60 PUSH1 0x1e 15AB 60 PUSH1 0x24 15AD 82 DUP3 15AE 01 ADD 15AF 52 MSTORE 15B0 7F PUSH32 0x45524332305065726d69743a20696e76616c6964207369676e61747572650000 15D1 60 PUSH1 0x44 15D3 82 DUP3 15D4 01 ADD 15D5 52 MSTORE 15D6 60 PUSH1 0x64 15D8 01 ADD 15D9 61 PUSH2 0x0817 15DC 56 *JUMP 15DD 5B JUMPDEST 15DE 61 PUSH2 0x15e8 15E1 8A DUP11 15E2 8A DUP11 15E3 8A DUP11 15E4 61 PUSH2 0x1dc0 15E7 56 *JUMP 15E8 5B JUMPDEST 15E9 50 POP 15EA 50 POP 15EB 50 POP 15EC 50 POP 15ED 50 POP 15EE 50 POP 15EF 50 POP 15F0 50 POP 15F1 50 POP 15F2 50 POP 15F3 56 *JUMP label_15F4: // Incoming jump from 0x05E3 // Inputs[1] { @15F8 stack[-2] } 15F4 5B JUMPDEST 15F5 61 PUSH2 0x15fd 15F8 82 DUP3 15F9 61 PUSH2 0x0bdf 15FC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15F5 stack[0] = 0x15fd // @15F8 stack[1] = stack[-2] // } // Block ends with call to 0x0bdf, returns to 0x15FD label_15FD: // Incoming return from call to 0x0BDF at 0x15FC // Inputs[1] { @1601 stack[-1] } 15FD 5B JUMPDEST 15FE 61 PUSH2 0x1606 1601 81 DUP2 1602 61 PUSH2 0x2899 1605 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15FE stack[0] = 0x1606 // @1601 stack[1] = stack[-1] // } // Block ends with call to 0x2899, returns to 0x1606 label_1606: // Incoming return from call to 0x2899 at 0x1605 // Inputs[2] // { // @160A stack[-3] // @160B stack[-2] // } 1606 5B JUMPDEST 1607 61 PUSH2 0x0c10 160A 83 DUP4 160B 83 DUP4 160C 61 PUSH2 0x29a8 160F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1607 stack[0] = 0x0c10 // @160A stack[1] = stack[-3] // @160B stack[2] = stack[-2] // } // Block ends with call to 0x29a8, returns to 0x0C10 label_1610: // Incoming call from 0x0CE8, returns to 0x0CE9 // Incoming call from 0x2830, returns to 0x2831 // Incoming call from 0x1414, returns to 0x1415 // Inputs[6] // { // @1619 stack[-2] // @162C memory[0x00:0x40] // @162D stack[-1] // @1637 memory[0x00:0x40] // @1638 storage[keccak256(memory[0x00:0x40])] // @1639 stack[-3] // } 1610 5B JUMPDEST 1611 60 PUSH1 0x01 1613 60 PUSH1 0x01 1615 60 PUSH1 0xa0 1617 1B SHL 1618 03 SUB 1619 91 SWAP2 161A 82 DUP3 161B 16 AND 161C 60 PUSH1 0x00 161E 90 SWAP1 161F 81 DUP2 1620 52 MSTORE 1621 60 PUSH1 0x98 1623 60 PUSH1 0x20 1625 90 SWAP1 1626 81 DUP2 1627 52 MSTORE 1628 60 PUSH1 0x40 162A 80 DUP1 162B 83 DUP4 162C 20 SHA3 162D 93 SWAP4 162E 90 SWAP1 162F 94 SWAP5 1630 16 AND 1631 82 DUP3 1632 52 MSTORE 1633 91 SWAP2 1634 90 SWAP1 1635 91 SWAP2 1636 52 MSTORE 1637 20 SHA3 1638 54 SLOAD 1639 90 SWAP1 163A 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1620 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1627 memory[0x20:0x40] = 0x98 // @1632 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1636 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1639 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_163B: // Incoming jump from 0x0609 // Inputs[5] // { // @1644 stack[-2] // @1657 memory[0x00:0x40] // @1658 stack[-1] // @1662 memory[0x00:0x40] // @1663 storage[keccak256(memory[0x00:0x40])] // } 163B 5B JUMPDEST 163C 60 PUSH1 0x01 163E 60 PUSH1 0x01 1640 60 PUSH1 0xa0 1642 1B SHL 1643 03 SUB 1644 82 DUP3 1645 16 AND 1646 60 PUSH1 0x00 1648 90 SWAP1 1649 81 DUP2 164A 52 MSTORE 164B 61 PUSH2 0x0166 164E 60 PUSH1 0x20 1650 90 SWAP1 1651 81 DUP2 1652 52 MSTORE 1653 60 PUSH1 0x40 1655 80 DUP1 1656 83 DUP4 1657 20 SHA3 1658 84 DUP5 1659 84 DUP5 165A 52 MSTORE 165B 60 PUSH1 0x01 165D 01 ADD 165E 90 SWAP1 165F 91 SWAP2 1660 52 MSTORE 1661 81 DUP2 1662 20 SHA3 1663 54 SLOAD 1664 81 DUP2 1665 90 SWAP1 1666 63 PUSH4 0xffffffff 166B 16 AND 166C 61 PUSH2 0x1687 166F 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1648 stack[0] = 0x00 // @164A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1652 memory[0x20:0x40] = 0x0166 // @165A memory[0x00:0x20] = stack[-1] // @1660 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1665 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1687, if 0xffffffff & storage[keccak256(memory[0x00:0x40])] label_1670: // Incoming jump from 0x166F, if not 0xffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1672 memory[0x40:0x60] } 1670 60 PUSH1 0x40 1672 51 MLOAD 1673 62 PUSH3 0x461bcd 1677 60 PUSH1 0xe5 1679 1B SHL 167A 81 DUP2 167B 52 MSTORE 167C 60 PUSH1 0x04 167E 01 ADD 167F 61 PUSH2 0x0817 1682 90 SWAP1 1683 61 PUSH2 0x40e7 1686 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @167B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1682 stack[0] = 0x0817 // @1682 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x40e7, returns to 0x0817 label_1687: // Incoming jump from 0x166F, if 0xffffffff & storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @1692 stack[-4] // @16A5 memory[0x00:0x40] // @16A6 stack[-3] // @16B0 memory[0x00:0x40] // @16B1 storage[keccak256(memory[0x00:0x40])] // @16CD stack[-5] // } 1687 5B JUMPDEST 1688 50 POP 1689 50 POP 168A 60 PUSH1 0x01 168C 60 PUSH1 0x01 168E 60 PUSH1 0xa0 1690 1B SHL 1691 03 SUB 1692 82 DUP3 1693 16 AND 1694 60 PUSH1 0x00 1696 90 SWAP1 1697 81 DUP2 1698 52 MSTORE 1699 61 PUSH2 0x0166 169C 60 PUSH1 0x20 169E 90 SWAP1 169F 81 DUP2 16A0 52 MSTORE 16A1 60 PUSH1 0x40 16A3 80 DUP1 16A4 83 DUP4 16A5 20 SHA3 16A6 84 DUP5 16A7 84 DUP5 16A8 52 MSTORE 16A9 60 PUSH1 0x01 16AB 01 ADD 16AC 90 SWAP1 16AD 91 SWAP2 16AE 52 MSTORE 16AF 90 SWAP1 16B0 20 SHA3 16B1 54 SLOAD 16B2 63 PUSH4 0xffffffff 16B7 81 DUP2 16B8 16 AND 16B9 90 SWAP1 16BA 60 PUSH1 0x01 16BC 60 PUSH1 0x20 16BE 1B SHL 16BF 90 SWAP1 16C0 04 DIV 16C1 60 PUSH1 0x01 16C3 60 PUSH1 0x01 16C5 60 PUSH1 0x60 16C7 1B SHL 16C8 03 SUB 16C9 16 AND 16CA 5B JUMPDEST 16CB 92 SWAP3 16CC 50 POP 16CD 92 SWAP3 16CE 90 SWAP1 16CF 50 POP 16D0 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1698 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @16A0 memory[0x20:0x40] = 0x0166 // @16A8 memory[0x00:0x20] = stack[-3] // @16AE memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @16CB stack[-4] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // @16CD stack[-5] = storage[keccak256(memory[0x00:0x40])] & 0xffffffff // } // Block ends with unconditional jump to stack[-5] label_16D1: // Incoming call from 0x0641, returns to 0x02B0 // Inputs[3] // { // @16D5 storage[0x0171] // @16D9 storage[0x0172] // @16E2 block.number // } 16D1 5B JUMPDEST 16D2 61 PUSH2 0x0171 16D5 54 SLOAD 16D6 61 PUSH2 0x0172 16D9 54 SLOAD 16DA 60 PUSH1 0x00 16DC 91 SWAP2 16DD 90 SWAP1 16DE 61 PUSH2 0x16e7 16E1 82 DUP3 16E2 43 NUMBER 16E3 61 PUSH2 0x3f5f 16E6 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @16DC stack[0] = 0x00 // @16DD stack[1] = storage[0x0171] // @16DD stack[2] = storage[0x0172] // @16DE stack[3] = 0x16e7 // @16E1 stack[4] = storage[0x0171] // @16E2 stack[5] = block.number // } // Block ends with call to 0x3f5f, returns to 0x16E7 label_16E7: // Incoming return from call to 0x3F5F at 0x16E6 // Inputs[2] // { // @16EB stack[-2] // @16EC stack[-1] // } 16E7 5B JUMPDEST 16E8 61 PUSH2 0x16f1 16EB 91 SWAP2 16EC 90 SWAP1 16ED 61 PUSH2 0x3f77 16F0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16EB stack[-2] = 0x16f1 // @16EC stack[-1] = stack[-2] // @16EC stack[0] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x16F1 label_16F1: // Incoming return from call to 0x3F77 at 0x16F0 // Inputs[2] // { // @16F5 stack[-2] // @16F6 stack[-1] // } 16F1 5B JUMPDEST 16F2 61 PUSH2 0x16fb 16F5 91 SWAP2 16F6 90 SWAP1 16F7 61 PUSH2 0x3fc6 16FA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16F5 stack[-2] = 0x16fb // @16F6 stack[-1] = stack[-2] // @16F6 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x16FB label_16FB: // Incoming return from call to 0x3FC6 at 0x16FA // Inputs[2] // { // @16FF storage[0x0171] // @1703 stack[-1] // } 16FB 5B JUMPDEST 16FC 61 PUSH2 0x0171 16FF 54 SLOAD 1700 61 PUSH2 0x1709 1703 91 SWAP2 1704 90 SWAP1 1705 61 PUSH2 0x3fa7 1708 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1703 stack[-1] = 0x1709 // @1704 stack[1] = storage[0x0171] // @1704 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x1709 label_1709: // Incoming return from call to 0x3FA7 at 0x1708 // Inputs[2] // { // @170D storage[0x0172] // @1711 stack[-1] // } 1709 5B JUMPDEST 170A 61 PUSH2 0x0172 170D 54 SLOAD 170E 61 PUSH2 0x0c1f 1711 91 SWAP2 1712 90 SWAP1 1713 61 PUSH2 0x3f5f 1716 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1711 stack[-1] = 0x0c1f // @1712 stack[1] = storage[0x0172] // @1712 stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x0C1F label_1717: // Incoming jump from 0x0654 // Inputs[2] // { // @171B storage[0x0174] // @1728 msg.sender // } 1717 5B JUMPDEST 1718 61 PUSH2 0x0174 171B 54 SLOAD 171C 60 PUSH1 0x00 171E 90 SWAP1 171F 60 PUSH1 0x01 1721 60 PUSH1 0x01 1723 60 PUSH1 0xa0 1725 1B SHL 1726 03 SUB 1727 16 AND 1728 33 CALLER 1729 60 PUSH1 0x01 172B 60 PUSH1 0x01 172D 60 PUSH1 0xa0 172F 1B SHL 1730 03 SUB 1731 16 AND 1732 14 EQ 1733 61 PUSH2 0x174e 1736 57 *JUMPI // Stack delta = +1 // Outputs[1] { @171E stack[0] = 0x00 } // Block ends with conditional jump to 0x174e, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] label_1737: // Incoming jump from 0x1736, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] // Inputs[1] { @1739 memory[0x40:0x60] } 1737 60 PUSH1 0x40 1739 51 MLOAD 173A 62 PUSH3 0x461bcd 173E 60 PUSH1 0xe5 1740 1B SHL 1741 81 DUP2 1742 52 MSTORE 1743 60 PUSH1 0x04 1745 01 ADD 1746 61 PUSH2 0x0817 1749 90 SWAP1 174A 61 PUSH2 0x3eca 174D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1742 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1749 stack[0] = 0x0817 // @1749 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3eca, returns to 0x0817 label_174E: // Incoming jump from 0x1736, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0174] // Inputs[1] { @1751 stack[-2] } 174E 5B JUMPDEST 174F 60 PUSH1 0x00 1751 82 DUP3 1752 11 GT 1753 61 PUSH2 0x176e 1756 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x176e, if stack[-2] > 0x00 label_1757: // Incoming jump from 0x1756, if not stack[-2] > 0x00 // Inputs[1] { @1759 memory[0x40:0x60] } 1757 60 PUSH1 0x40 1759 51 MLOAD 175A 62 PUSH3 0x461bcd 175E 60 PUSH1 0xe5 1760 1B SHL 1761 81 DUP2 1762 52 MSTORE 1763 60 PUSH1 0x04 1765 01 ADD 1766 61 PUSH2 0x0817 1769 90 SWAP1 176A 61 PUSH2 0x3eff 176D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1762 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1769 stack[0] = 0x0817 // @1769 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3eff, returns to 0x0817 label_176E: // Incoming jump from 0x1756, if stack[-2] > 0x00 // Inputs[2] // { // @1772 stack[-3] // @1773 block.number // } 176E 5B JUMPDEST 176F 61 PUSH2 0x1778 1772 83 DUP4 1773 43 NUMBER 1774 61 PUSH2 0x23f9 1777 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @176F stack[0] = 0x1778 // @1772 stack[1] = stack[-3] // @1773 stack[2] = block.number // } // Block ends with call to 0x23f9, returns to 0x1778 label_1778: // Incoming return from call to 0x23F9 at 0x1777 // Inputs[4] // { // @1781 stack[-4] // @1791 memory[0x00:0x40] // @1793 storage[keccak256(memory[0x00:0x40])] // @179B stack[-1] // } 1778 5B JUMPDEST 1779 60 PUSH1 0x01 177B 60 PUSH1 0x01 177D 60 PUSH1 0xa0 177F 1B SHL 1780 03 SUB 1781 84 DUP5 1782 16 AND 1783 60 PUSH1 0x00 1785 90 SWAP1 1786 81 DUP2 1787 52 MSTORE 1788 61 PUSH2 0x0166 178B 60 PUSH1 0x20 178D 52 MSTORE 178E 60 PUSH1 0x40 1790 81 DUP2 1791 20 SHA3 1792 80 DUP1 1793 54 SLOAD 1794 90 SWAP1 1795 91 SWAP2 1796 90 SWAP1 1797 61 PUSH2 0x17a1 179A 90 SWAP1 179B 84 DUP5 179C 90 SWAP1 179D 61 PUSH2 0x3f5f 17A0 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1787 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @178D memory[0x20:0x40] = 0x0166 // @1795 stack[0] = keccak256(memory[0x00:0x40]) // @1796 stack[1] = 0x00 // @179A stack[2] = 0x17a1 // @179C stack[3] = stack[-1] // @179C stack[4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3f5f, returns to 0x17A1 label_17A1: // Incoming return from call to 0x3F5F at 0x17A0 // Inputs[4] // { // @17A2 stack[-2] // @17A2 stack[-1] // @17A3 stack[-3] // @17A9 stack[-4] // } 17A1 5B JUMPDEST 17A2 90 SWAP1 17A3 91 SWAP2 17A4 55 SSTORE 17A5 50 POP 17A6 61 PUSH2 0x17af 17A9 90 SWAP1 17AA 50 POP 17AB 61 PUSH2 0x1bdc 17AE 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @17A4 storage[stack[-3]] = stack[-1] // @17A9 stack[-4] = 0x17af // } // Block ends with call to 0x1bdc, returns to 0x17AF label_17AF: // Incoming return from call to 0x1BDC at 0x17AE // Inputs[3] // { // @17B4 storage[0x016c] // @17B5 stack[-2] // @17BD stack[-3] // } 17AF 5B JUMPDEST 17B0 61 PUSH2 0x016c 17B3 80 DUP1 17B4 54 SLOAD 17B5 83 DUP4 17B6 90 SWAP1 17B7 03 SUB 17B8 90 SWAP1 17B9 55 SSTORE 17BA 61 PUSH2 0x17c2 17BD 83 DUP4 17BE 61 PUSH2 0x2abe 17C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17B9 storage[0x016c] = storage[0x016c] - stack[-2] // @17BA stack[0] = 0x17c2 // @17BD stack[1] = stack[-3] // } // Block ends with call to 0x2abe, returns to 0x17C2 label_17C2: // Incoming return from call to 0x2ABE at 0x17C1 // Inputs[6] // { // @17CB stack[-4] // @17DE memory[0x00:0x40] // @17E3 storage[keccak256(memory[0x00:0x40]) + 0x06] // @17ED memory[0x00:0x40] // @17EE stack[-1] // @17F5 stack[-3] // } 17C2 5B JUMPDEST 17C3 60 PUSH1 0x01 17C5 60 PUSH1 0x01 17C7 60 PUSH1 0xa0 17C9 1B SHL 17CA 03 SUB 17CB 84 DUP5 17CC 16 AND 17CD 60 PUSH1 0x00 17CF 90 SWAP1 17D0 81 DUP2 17D1 52 MSTORE 17D2 61 PUSH2 0x0166 17D5 60 PUSH1 0x20 17D7 90 SWAP1 17D8 81 DUP2 17D9 52 MSTORE 17DA 60 PUSH1 0x40 17DC 80 DUP1 17DD 83 DUP4 17DE 20 SHA3 17DF 60 PUSH1 0x06 17E1 81 DUP2 17E2 01 ADD 17E3 54 SLOAD 17E4 84 DUP5 17E5 52 MSTORE 17E6 60 PUSH1 0x03 17E8 01 ADD 17E9 90 SWAP1 17EA 91 SWAP2 17EB 52 MSTORE 17EC 81 DUP2 17ED 20 SHA3 17EE 91 SWAP2 17EF 90 SWAP1 17F0 91 SWAP2 17F1 55 SSTORE 17F2 61 PUSH2 0x17fa 17F5 83 DUP4 17F6 61 PUSH2 0x252f 17F9 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @17D1 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @17D9 memory[0x20:0x40] = 0x0166 // @17E5 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @17EB memory[0x20:0x40] = 0x03 + keccak256(memory[0x00:0x40]) // @17F0 stack[-1] = 0x00 // @17F1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @17F2 stack[0] = 0x17fa // @17F5 stack[1] = stack[-3] // } // Block ends with call to 0x252f, returns to 0x17FA label_17FA: // Incoming return from call to 0x252F at 0x17F9 // Inputs[5] // { // @1803 stack[-5] // @1813 memory[0x00:0x40] // @1817 storage[0x02 + keccak256(memory[0x00:0x40])] // @1818 stack[-1] // @1819 stack[-2] // } 17FA 5B JUMPDEST 17FB 60 PUSH1 0x01 17FD 60 PUSH1 0x01 17FF 60 PUSH1 0xa0 1801 1B SHL 1802 03 SUB 1803 85 DUP6 1804 16 AND 1805 60 PUSH1 0x00 1807 90 SWAP1 1808 81 DUP2 1809 52 MSTORE 180A 61 PUSH2 0x0166 180D 60 PUSH1 0x20 180F 52 MSTORE 1810 60 PUSH1 0x40 1812 81 DUP2 1813 20 SHA3 1814 60 PUSH1 0x02 1816 01 ADD 1817 54 SLOAD 1818 91 SWAP2 1819 92 SWAP3 181A 50 POP 181B 90 SWAP1 181C 63 PUSH4 0xffffffff 1821 80 DUP1 1822 82 DUP3 1823 16 AND 1824 91 SWAP2 1825 60 PUSH1 0x01 1827 60 PUSH1 0x20 1829 1B SHL 182A 90 SWAP1 182B 04 DIV 182C 16 AND 182D 5B JUMPDEST 182E 81 DUP2 182F 63 PUSH4 0xffffffff 1834 16 AND 1835 81 DUP2 1836 10 LT 1837 61 PUSH2 0x1aba 183A 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1809 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @180F memory[0x20:0x40] = 0x0166 // @1819 stack[-2] = stack[-1] // @181B stack[-1] = 0x00 // @1824 stack[0] = storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // @182C stack[1] = storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & 0xffffffff // } // Block ends with conditional jump to 0x1aba, if storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & 0xffffffff < 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff label_183B: // Incoming jump from 0x183A, if not storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & 0xffffffff < 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // Incoming jump from 0x183A, if not stack[-1] < 0xffffffff & stack[-2] // Inputs[10] // { // @1843 stack[-7] // @1856 memory[0x00:0x40] // @1857 stack[-1] // @1864 memory[0x00:0x40] // @1866 storage[keccak256(memory[0x00:0x40])] // @186A stack[-3] // @1875 memory[0x00:0x40] // @1877 storage[keccak256(memory[0x00:0x40])] // @1896 storage[keccak256(memory[0x00:0x40])] // @18A3 stack[-4] // } 183B 60 PUSH1 0x01 183D 60 PUSH1 0x01 183F 60 PUSH1 0xa0 1841 1B SHL 1842 03 SUB 1843 87 DUP8 1844 16 AND 1845 60 PUSH1 0x00 1847 90 SWAP1 1848 81 DUP2 1849 52 MSTORE 184A 61 PUSH2 0x0166 184D 60 PUSH1 0x20 184F 90 SWAP1 1850 81 DUP2 1851 52 MSTORE 1852 60 PUSH1 0x40 1854 80 DUP1 1855 83 DUP4 1856 20 SHA3 1857 84 DUP5 1858 84 DUP5 1859 52 MSTORE 185A 60 PUSH1 0x01 185C 90 SWAP1 185D 81 DUP2 185E 01 ADD 185F 80 DUP1 1860 84 DUP5 1861 52 MSTORE 1862 82 DUP3 1863 85 DUP6 1864 20 SHA3 1865 80 DUP1 1866 54 SLOAD 1867 61 PUSH2 0xffff 186A 8A DUP11 186B 16 AND 186C 87 DUP8 186D 52 MSTORE 186E 61 PUSH2 0x0175 1871 86 DUP7 1872 52 MSTORE 1873 93 SWAP4 1874 86 DUP7 1875 20 SHA3 1876 80 DUP1 1877 54 SLOAD 1878 63 PUSH4 0xffffffff 187D 19 NOT 187E 16 AND 187F 63 PUSH4 0xffffffff 1884 90 SWAP1 1885 95 SWAP6 1886 16 AND 1887 94 SWAP5 1888 90 SWAP1 1889 94 SWAP5 188A 17 OR 188B 90 SWAP1 188C 93 SWAP4 188D 55 SSTORE 188E 93 SWAP4 188F 85 DUP6 1890 90 SWAP1 1891 52 MSTORE 1892 92 SWAP3 1893 90 SWAP1 1894 91 SWAP2 1895 52 MSTORE 1896 54 SLOAD 1897 93 SWAP4 1898 01 ADD 1899 92 SWAP3 189A 60 PUSH1 0x01 189C 60 PUSH1 0x01 189E 60 PUSH1 0x60 18A0 1B SHL 18A1 03 SUB 18A2 80 DUP1 18A3 86 DUP7 18A4 16 AND 18A5 60 PUSH1 0x01 18A7 60 PUSH1 0x20 18A9 1B SHL 18AA 90 SWAP1 18AB 92 SWAP3 18AC 04 DIV 18AD 16 AND 18AE 10 LT 18AF 61 PUSH2 0x19fc 18B2 57 *JUMPI // Stack delta = +0 // Outputs[10] // { // @1849 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @1851 memory[0x20:0x40] = 0x0166 // @1859 memory[0x00:0x20] = stack[-1] // @1861 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @186D memory[0x00:0x20] = stack[-3] & 0xffff // @1872 memory[0x20:0x40] = 0x0175 // @188D storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & 0xffffffff) | (~0xffffffff & storage[keccak256(memory[0x00:0x40])]) // @1891 memory[0x00:0x20] = stack[-1] // @1895 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1899 stack[-3] = stack[-3] + 0x01 // } // Block ends with conditional jump to 0x19fc, if storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & (0x01 << 0x60) - 0x01 < stack[-4] & (0x01 << 0x60) - 0x01 label_18B3: // Incoming jump from 0x18B2, if not storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & (0x01 << 0x60) - 0x01 < stack[-4] & (0x01 << 0x60) - 0x01 // Inputs[6] // { // @18BB stack[-7] // @18CE memory[0x00:0x40] // @18CF stack[-1] // @18D9 memory[0x00:0x40] // @18DB storage[keccak256(memory[0x00:0x40])] // @18DC stack[-4] // } 18B3 60 PUSH1 0x01 18B5 60 PUSH1 0x01 18B7 60 PUSH1 0xa0 18B9 1B SHL 18BA 03 SUB 18BB 87 DUP8 18BC 16 AND 18BD 60 PUSH1 0x00 18BF 90 SWAP1 18C0 81 DUP2 18C1 52 MSTORE 18C2 61 PUSH2 0x0166 18C5 60 PUSH1 0x20 18C7 90 SWAP1 18C8 81 DUP2 18C9 52 MSTORE 18CA 60 PUSH1 0x40 18CC 80 DUP1 18CD 83 DUP4 18CE 20 SHA3 18CF 84 DUP5 18D0 84 DUP5 18D1 52 MSTORE 18D2 60 PUSH1 0x01 18D4 01 ADD 18D5 90 SWAP1 18D6 91 SWAP2 18D7 52 MSTORE 18D8 90 SWAP1 18D9 20 SHA3 18DA 80 DUP1 18DB 54 SLOAD 18DC 85 DUP6 18DD 91 SWAP2 18DE 90 SWAP1 18DF 60 PUSH1 0x04 18E1 90 SWAP1 18E2 61 PUSH2 0x18fc 18E5 90 SWAP1 18E6 84 DUP5 18E7 90 SWAP1 18E8 60 PUSH1 0x01 18EA 60 PUSH1 0x20 18EC 1B SHL 18ED 90 SWAP1 18EE 04 DIV 18EF 60 PUSH1 0x01 18F1 60 PUSH1 0x01 18F3 60 PUSH1 0x60 18F5 1B SHL 18F6 03 SUB 18F7 16 AND 18F8 61 PUSH2 0x424e 18FB 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @18C1 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @18C9 memory[0x20:0x40] = 0x0166 // @18D1 memory[0x00:0x20] = stack[-1] // @18D7 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @18DD stack[0] = stack[-4] // @18DE stack[1] = keccak256(memory[0x00:0x40]) // @18E1 stack[2] = 0x04 // @18E5 stack[3] = 0x18fc // @18E7 stack[4] = stack[-4] // @18F7 stack[5] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // } // Block ends with call to 0x424e, returns to 0x18FC label_18FC: // Incoming return from call to 0x424E at 0x18FB // Inputs[5] // { // @18FD stack[-3] // @18FE storage[stack[-3]] // @1907 stack[-1] // @190D stack[-2] // @1924 storage[0x0165] // } 18FC 5B JUMPDEST 18FD 82 DUP3 18FE 54 SLOAD 18FF 60 PUSH1 0x01 1901 60 PUSH1 0x01 1903 60 PUSH1 0x60 1905 1B SHL 1906 03 SUB 1907 91 SWAP2 1908 82 DUP3 1909 16 AND 190A 61 PUSH2 0x0100 190D 93 SWAP4 190E 90 SWAP1 190F 93 SWAP4 1910 0A EXP 1911 92 SWAP3 1912 83 DUP4 1913 02 MUL 1914 91 SWAP2 1915 90 SWAP1 1916 92 SWAP3 1917 02 MUL 1918 19 NOT 1919 90 SWAP1 191A 91 SWAP2 191B 16 AND 191C 17 OR 191D 90 SWAP1 191E 55 SSTORE 191F 50 POP 1920 61 PUSH2 0x0165 1923 80 DUP1 1924 54 SLOAD 1925 61 PUSH2 0x0164 1928 91 SWAP2 1929 60 PUSH1 0x00 192B 91 SWAP2 192C 63 PUSH4 0xffffffff 1931 16 AND 1932 90 SWAP1 1933 82 DUP3 1934 61 PUSH2 0x193c 1937 83 DUP4 1938 61 PUSH2 0x4276 193B 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @191E storage[stack[-3]] = (storage[stack[-3]] & ~(0x0100 ** stack[-2] * ((0x01 << 0x60) - 0x01))) | 0x0100 ** stack[-2] * ((0x01 << 0x60) - 0x01 & stack[-1]) // @1928 stack[-4] = 0x0164 // @192B stack[-3] = 0x00 // @1932 stack[-2] = 0xffffffff & storage[0x0165] // @1932 stack[-1] = 0x0165 // @1933 stack[0] = 0x00 // @1934 stack[1] = 0x193c // @1937 stack[2] = 0xffffffff & storage[0x0165] // } // Block ends with call to 0x4276, returns to 0x193C label_193C: // Incoming return from call to 0x4276 at 0x193B // Inputs[17] // { // @193D stack[-3] // @193E storage[stack[-3]] // @1942 stack[-2] // @1952 stack[-1] // @195A stack[-4] // @195D stack[-5] // @1964 stack[-6] // @1970 stack[-13] // @1980 memory[0x00:0x40] // @1981 stack[-7] // @198B memory[0x00:0x40] // @198C storage[keccak256(memory[0x00:0x40])] // @199F memory[0x00:0x40] // @19A0 storage[keccak256(memory[0x00:0x40])] // @19AC memory[0x00:0x40] // @19AE storage[keccak256(memory[0x00:0x40])] // @19AF stack[-10] // } 193C 5B JUMPDEST 193D 82 DUP3 193E 54 SLOAD 193F 61 PUSH2 0x0100 1942 92 SWAP3 1943 90 SWAP1 1944 92 SWAP3 1945 0A EXP 1946 63 PUSH4 0xffffffff 194B 81 DUP2 194C 81 DUP2 194D 02 MUL 194E 19 NOT 194F 90 SWAP1 1950 93 SWAP4 1951 16 AND 1952 91 SWAP2 1953 83 DUP4 1954 16 AND 1955 02 MUL 1956 17 OR 1957 90 SWAP1 1958 91 SWAP2 1959 55 SSTORE 195A 90 SWAP1 195B 81 DUP2 195C 16 AND 195D 82 DUP3 195E 52 MSTORE 195F 60 PUSH1 0x20 1961 91 SWAP2 1962 82 DUP3 1963 01 ADD 1964 92 SWAP3 1965 90 SWAP1 1966 92 SWAP3 1967 52 MSTORE 1968 60 PUSH1 0x01 196A 60 PUSH1 0x01 196C 60 PUSH1 0xa0 196E 1B SHL 196F 03 SUB 1970 89 DUP10 1971 16 AND 1972 60 PUSH1 0x00 1974 90 SWAP1 1975 81 DUP2 1976 52 MSTORE 1977 61 PUSH2 0x0166 197A 82 DUP3 197B 52 MSTORE 197C 60 PUSH1 0x40 197E 80 DUP1 197F 82 DUP3 1980 20 SHA3 1981 85 DUP6 1982 83 DUP4 1983 52 MSTORE 1984 60 PUSH1 0x01 1986 01 ADD 1987 83 DUP4 1988 52 MSTORE 1989 80 DUP1 198A 82 DUP3 198B 20 SHA3 198C 54 SLOAD 198D 60 PUSH1 0x01 198F 60 PUSH1 0x80 1991 1B SHL 1992 90 SWAP1 1993 04 DIV 1994 84 DUP5 1995 16 AND 1996 82 DUP3 1997 52 MSTORE 1998 61 PUSH2 0x0164 199B 83 DUP4 199C 52 MSTORE 199D 80 DUP1 199E 82 DUP3 199F 20 SHA3 19A0 54 SLOAD 19A1 90 SWAP1 19A2 93 SWAP4 19A3 16 AND 19A4 81 DUP2 19A5 52 MSTORE 19A6 61 PUSH2 0x016e 19A9 90 SWAP1 19AA 91 SWAP2 19AB 52 MSTORE 19AC 20 SHA3 19AD 80 DUP1 19AE 54 SLOAD 19AF 85 DUP6 19B0 91 SWAP2 19B1 90 SWAP1 19B2 60 PUSH1 0x04 19B4 90 SWAP1 19B5 61 PUSH2 0x19cf 19B8 90 SWAP1 19B9 84 DUP5 19BA 90 SWAP1 19BB 60 PUSH1 0x01 19BD 60 PUSH1 0x20 19BF 1B SHL 19C0 90 SWAP1 19C1 04 DIV 19C2 60 PUSH1 0x01 19C4 60 PUSH1 0x01 19C6 60 PUSH1 0x60 19C8 1B SHL 19C9 03 SUB 19CA 16 AND 19CB 61 PUSH2 0x424e 19CE 56 *JUMP // Stack delta = +0 // Outputs[17] // { // @1959 storage[stack[-3]] = (0xffffffff & stack[-1]) * 0x0100 ** stack[-2] | (storage[stack[-3]] & ~(0xffffffff * 0x0100 ** stack[-2])) // @195E memory[stack[-5]:stack[-5] + 0x20] = 0xffffffff & stack[-4] // @1967 memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] = stack[-6] // @1976 memory[0x00:0x20] = stack[-13] & (0x01 << 0xa0) - 0x01 // @197B memory[0x20:0x40] = 0x0166 // @1983 memory[0x00:0x20] = stack[-7] // @1988 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1997 memory[0x00:0x20] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x80) // @199C memory[0x20:0x40] = 0x0164 // @19A5 memory[0x00:0x20] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] // @19AB memory[0x20:0x40] = 0x016e // @19B0 stack[-6] = stack[-10] // @19B1 stack[-5] = keccak256(memory[0x00:0x40]) // @19B4 stack[-4] = 0x04 // @19B8 stack[-3] = 0x19cf // @19BA stack[-2] = stack[-10] // @19CA stack[-1] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // } // Block ends with call to 0x424e, returns to 0x19CF label_19CF: // Incoming return from call to 0x424E at 0x19CE // Inputs[6] // { // @19D0 stack[-4] // @19D0 stack[-1] // @19D5 stack[-2] // @19D6 stack[-3] // @19D7 storage[stack[-3]] // @19F6 stack[-8] // } 19CF 5B JUMPDEST 19D0 92 SWAP3 19D1 50 POP 19D2 61 PUSH2 0x0100 19D5 0A EXP 19D6 81 DUP2 19D7 54 SLOAD 19D8 81 DUP2 19D9 60 PUSH1 0x01 19DB 60 PUSH1 0x01 19DD 60 PUSH1 0x60 19DF 1B SHL 19E0 03 SUB 19E1 02 MUL 19E2 19 NOT 19E3 16 AND 19E4 90 SWAP1 19E5 83 DUP4 19E6 60 PUSH1 0x01 19E8 60 PUSH1 0x01 19EA 60 PUSH1 0x60 19EC 1B SHL 19ED 03 SUB 19EE 16 AND 19EF 02 MUL 19F0 17 OR 19F1 90 SWAP1 19F2 55 SSTORE 19F3 50 POP 19F4 60 PUSH1 0x00 19F6 93 SWAP4 19F7 50 POP 19F8 61 PUSH2 0x1aba 19FB 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @19F2 storage[stack[-3]] = ((0x01 << 0x60) - 0x01 & stack[-1]) * 0x0100 ** stack[-2] | (~((0x01 << 0x60) - 0x01 * 0x0100 ** stack[-2]) & storage[stack[-3]]) // @19F6 stack[-8] = 0x00 // } // Block ends with unconditional jump to 0x1aba label_19FC: // Incoming jump from 0x18B2, if storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & (0x01 << 0x60) - 0x01 < stack[-4] & (0x01 << 0x60) - 0x01 // Inputs[6] // { // @1A05 stack[-7] // @1A18 memory[0x00:0x40] // @1A19 stack[-1] // @1A23 memory[0x00:0x40] // @1A24 storage[keccak256(memory[0x00:0x40])] // @1A39 stack[-4] // } 19FC 5B JUMPDEST 19FD 60 PUSH1 0x01 19FF 60 PUSH1 0x01 1A01 60 PUSH1 0xa0 1A03 1B SHL 1A04 03 SUB 1A05 87 DUP8 1A06 16 AND 1A07 60 PUSH1 0x00 1A09 90 SWAP1 1A0A 81 DUP2 1A0B 52 MSTORE 1A0C 61 PUSH2 0x0166 1A0F 60 PUSH1 0x20 1A11 90 SWAP1 1A12 81 DUP2 1A13 52 MSTORE 1A14 60 PUSH1 0x40 1A16 80 DUP1 1A17 83 DUP4 1A18 20 SHA3 1A19 84 DUP5 1A1A 84 DUP5 1A1B 52 MSTORE 1A1C 60 PUSH1 0x01 1A1E 01 ADD 1A1F 90 SWAP1 1A20 91 SWAP2 1A21 52 MSTORE 1A22 90 SWAP1 1A23 20 SHA3 1A24 54 SLOAD 1A25 61 PUSH2 0x1a3e 1A28 90 SWAP1 1A29 60 PUSH1 0x01 1A2B 60 PUSH1 0x20 1A2D 1B SHL 1A2E 90 SWAP1 1A2F 04 DIV 1A30 60 PUSH1 0x01 1A32 60 PUSH1 0x01 1A34 60 PUSH1 0x60 1A36 1B SHL 1A37 03 SUB 1A38 16 AND 1A39 85 DUP6 1A3A 61 PUSH2 0x424e 1A3D 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1A0B memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @1A13 memory[0x20:0x40] = 0x0166 // @1A1B memory[0x00:0x20] = stack[-1] // @1A21 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1A28 stack[0] = 0x1a3e // @1A38 stack[1] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // @1A39 stack[2] = stack[-4] // } // Block ends with call to 0x424e, returns to 0x1A3E label_1A3E: // Incoming return from call to 0x424E at 0x1A3D // Inputs[11] // { // @1A47 stack[-8] // @1A5A memory[0x00:0x40] // @1A5B stack[-2] // @1A65 memory[0x00:0x40] // @1A67 storage[keccak256(memory[0x00:0x40])] // @1A94 memory[0x00:0x40] // @1A95 storage[keccak256(memory[0x00:0x40])] // @1AA1 memory[0x00:0x40] // @1AA3 storage[keccak256(memory[0x00:0x40])] // @1AA9 stack[-1] // @1AA9 stack[-5] // } 1A3E 5B JUMPDEST 1A3F 60 PUSH1 0x01 1A41 60 PUSH1 0x01 1A43 60 PUSH1 0xa0 1A45 1B SHL 1A46 03 SUB 1A47 88 DUP9 1A48 16 AND 1A49 60 PUSH1 0x00 1A4B 90 SWAP1 1A4C 81 DUP2 1A4D 52 MSTORE 1A4E 61 PUSH2 0x0166 1A51 60 PUSH1 0x20 1A53 90 SWAP1 1A54 81 DUP2 1A55 52 MSTORE 1A56 60 PUSH1 0x40 1A58 80 DUP1 1A59 83 DUP4 1A5A 20 SHA3 1A5B 85 DUP6 1A5C 84 DUP5 1A5D 52 MSTORE 1A5E 60 PUSH1 0x01 1A60 01 ADD 1A61 82 DUP3 1A62 52 MSTORE 1A63 80 DUP1 1A64 83 DUP4 1A65 20 SHA3 1A66 80 DUP1 1A67 54 SLOAD 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0x20 1A6C 1B SHL 1A6D 60 PUSH1 0x01 1A6F 60 PUSH1 0x80 1A71 1B SHL 1A72 03 SUB 1A73 19 NOT 1A74 90 SWAP1 1A75 81 DUP2 1A76 16 AND 1A77 91 SWAP2 1A78 82 DUP3 1A79 90 SWAP1 1A7A 55 SSTORE 1A7B 60 PUSH1 0x01 1A7D 60 PUSH1 0x80 1A7F 1B SHL 1A80 90 SWAP1 1A81 91 SWAP2 1A82 04 DIV 1A83 63 PUSH4 0xffffffff 1A88 90 SWAP1 1A89 81 DUP2 1A8A 16 AND 1A8B 85 DUP6 1A8C 52 MSTORE 1A8D 61 PUSH2 0x0164 1A90 84 DUP5 1A91 52 MSTORE 1A92 82 DUP3 1A93 85 DUP6 1A94 20 SHA3 1A95 54 SLOAD 1A96 16 AND 1A97 84 DUP5 1A98 52 MSTORE 1A99 61 PUSH2 0x016e 1A9C 90 SWAP1 1A9D 92 SWAP3 1A9E 52 MSTORE 1A9F 90 SWAP1 1AA0 91 SWAP2 1AA1 20 SHA3 1AA2 80 DUP1 1AA3 54 SLOAD 1AA4 90 SWAP1 1AA5 91 SWAP2 1AA6 16 AND 1AA7 90 SWAP1 1AA8 55 SSTORE 1AA9 93 SWAP4 1AAA 50 POP 1AAB 61 PUSH2 0x1ab3 1AAE 81 DUP2 1AAF 61 PUSH2 0x429a 1AB2 56 *JUMP // Stack delta = +1 // Outputs[13] // { // @1A4D memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1A55 memory[0x20:0x40] = 0x0166 // @1A5D memory[0x00:0x20] = stack[-2] // @1A62 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1A7A storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0x80) - (0x01 << 0x20)) & storage[keccak256(memory[0x00:0x40])] // @1A8C memory[0x00:0x20] = 0xffffffff & (~((0x01 << 0x80) - (0x01 << 0x20)) & storage[keccak256(memory[0x00:0x40])]) / (0x01 << 0x80) // @1A91 memory[0x20:0x40] = 0x0164 // @1A98 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] & 0xffffffff // @1A9E memory[0x20:0x40] = 0x016e // @1AA8 storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0x80) - (0x01 << 0x20)) & storage[keccak256(memory[0x00:0x40])] // @1AA9 stack[-5] = stack[-1] // @1AAB stack[-1] = 0x1ab3 // @1AAE stack[0] = stack[-2] // } // Block ends with call to 0x429a, returns to 0x1AB3 label_1AB3: // Incoming return from call to 0x429A at 0x1AB2 // Inputs[2] // { // @1AB4 stack[-1] // @1AB4 stack[-2] // } 1AB3 5B JUMPDEST 1AB4 90 SWAP1 1AB5 50 POP 1AB6 61 PUSH2 0x182d 1AB9 56 *JUMP // Stack delta = -1 // Outputs[1] { @1AB4 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x182d label_1ABA: // Incoming jump from 0x183A, if storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & 0xffffffff < 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // Incoming jump from 0x183A, if stack[-1] < 0xffffffff & stack[-2] // Incoming jump from 0x19FB // Inputs[1] { @1AC4 stack[-4] } 1ABA 5B JUMPDEST 1ABB 50 POP 1ABC 60 PUSH1 0x01 1ABE 60 PUSH1 0x01 1AC0 60 PUSH1 0x60 1AC2 1B SHL 1AC3 03 SUB 1AC4 83 DUP4 1AC5 16 AND 1AC6 15 ISZERO 1AC7 61 PUSH2 0x1b26 1ACA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b26, if !(stack[-4] & (0x01 << 0x60) - 0x01) label_1ACB: // Incoming jump from 0x1ACA, if not !(stack[-4] & (0x01 << 0x60) - 0x01) // Inputs[4] // { // @1AD3 stack[-6] // @1AE3 memory[0x00:0x40] // @1AE5 storage[keccak256(memory[0x00:0x40])] // @1AEE stack[-3] // } 1ACB 60 PUSH1 0x01 1ACD 60 PUSH1 0x01 1ACF 60 PUSH1 0xa0 1AD1 1B SHL 1AD2 03 SUB 1AD3 86 DUP7 1AD4 16 AND 1AD5 60 PUSH1 0x00 1AD7 90 SWAP1 1AD8 81 DUP2 1AD9 52 MSTORE 1ADA 61 PUSH2 0x0166 1ADD 60 PUSH1 0x20 1ADF 52 MSTORE 1AE0 60 PUSH1 0x40 1AE2 81 DUP2 1AE3 20 SHA3 1AE4 80 DUP1 1AE5 54 SLOAD 1AE6 60 PUSH1 0x01 1AE8 60 PUSH1 0x01 1AEA 60 PUSH1 0x60 1AEC 1B SHL 1AED 03 SUB 1AEE 86 DUP7 1AEF 16 AND 1AF0 92 SWAP3 1AF1 90 SWAP1 1AF2 61 PUSH2 0x1afc 1AF5 90 SWAP1 1AF6 84 DUP5 1AF7 90 SWAP1 1AF8 61 PUSH2 0x3f77 1AFB 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1AD9 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1ADF memory[0x20:0x40] = 0x0166 // @1AE3 stack[1] = keccak256(memory[0x00:0x40]) // @1AF0 stack[0] = stack[-3] & (0x01 << 0x60) - 0x01 // @1AF1 stack[2] = 0x00 // @1AF5 stack[3] = 0x1afc // @1AF7 stack[4] = stack[-3] & (0x01 << 0x60) - 0x01 // @1AF7 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3f77, returns to 0x1AFC label_1AFC: // Incoming return from call to 0x3F77 at 0x1AFB // Inputs[5] // { // @1AFD stack[-2] // @1AFD stack[-1] // @1AFE stack[-3] // @1B06 storage[0x016b] // @1B0F stack[-7] // } 1AFC 5B JUMPDEST 1AFD 90 SWAP1 1AFE 91 SWAP2 1AFF 55 SSTORE 1B00 50 POP 1B01 50 POP 1B02 61 PUSH2 0x016b 1B05 80 DUP1 1B06 54 SLOAD 1B07 60 PUSH1 0x01 1B09 60 PUSH1 0x01 1B0B 60 PUSH1 0x60 1B0D 1B SHL 1B0E 03 SUB 1B0F 85 DUP6 1B10 16 AND 1B11 91 SWAP2 1B12 90 SWAP1 1B13 60 PUSH1 0x00 1B15 90 SWAP1 1B16 61 PUSH2 0x1b20 1B19 90 SWAP1 1B1A 84 DUP5 1B1B 90 SWAP1 1B1C 61 PUSH2 0x3f77 1B1F 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @1AFF storage[stack[-3]] = stack[-1] // @1B11 stack[-4] = stack[-7] & (0x01 << 0x60) - 0x01 // @1B12 stack[-3] = 0x016b // @1B15 stack[-2] = 0x00 // @1B19 stack[-1] = 0x1b20 // @1B1B stack[0] = stack[-7] & (0x01 << 0x60) - 0x01 // @1B1B stack[1] = storage[0x016b] // } // Block ends with call to 0x3f77, returns to 0x1B20 label_1B20: // Incoming return from call to 0x3F77 at 0x1B1F // Inputs[3] // { // @1B21 stack[-2] // @1B21 stack[-1] // @1B22 stack[-3] // } 1B20 5B JUMPDEST 1B21 90 SWAP1 1B22 91 SWAP2 1B23 55 SSTORE 1B24 50 POP 1B25 50 POP // Stack delta = -4 // Outputs[1] { @1B23 storage[stack[-3]] = stack[-1] } // Block continues label_1B26: // Incoming jump from 0x1B25 // Incoming jump from 0x1ACA, if !(stack[-4] & (0x01 << 0x60) - 0x01) // Inputs[1] { @1B2A storage[0x016c] } 1B26 5B JUMPDEST 1B27 61 PUSH2 0x016c 1B2A 54 SLOAD 1B2B 61 PUSH2 0x1b40 1B2E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b40, if storage[0x016c] label_1B2F: // Incoming jump from 0x1B2E, if not storage[0x016c] // Inputs[5] // { // @1B3B block.number // @1B44 storage[0x0167] // @1B4D stack[-6] // @1B5D memory[0x00:0x40] // @1B5E storage[keccak256(memory[0x00:0x40])] // } 1B2F 60 PUSH1 0x00 1B31 61 PUSH2 0x0167 1B34 81 DUP2 1B35 90 SWAP1 1B36 55 SSTORE 1B37 61 PUSH2 0x0168 1B3A 55 SSTORE 1B3B 43 NUMBER 1B3C 61 PUSH2 0x016d 1B3F 55 SSTORE 1B40 5B JUMPDEST 1B41 61 PUSH2 0x0167 1B44 54 SLOAD 1B45 60 PUSH1 0x01 1B47 60 PUSH1 0x01 1B49 60 PUSH1 0xa0 1B4B 1B SHL 1B4C 03 SUB 1B4D 87 DUP8 1B4E 16 AND 1B4F 60 PUSH1 0x00 1B51 90 SWAP1 1B52 81 DUP2 1B53 52 MSTORE 1B54 61 PUSH2 0x0166 1B57 60 PUSH1 0x20 1B59 52 MSTORE 1B5A 60 PUSH1 0x40 1B5C 90 SWAP1 1B5D 20 SHA3 1B5E 54 SLOAD 1B5F 6A PUSH11 0x084595161401484a000000 1B6B 91 SWAP2 1B6C 61 PUSH2 0x1b74 1B6F 91 SWAP2 1B70 61 PUSH2 0x3fa7 1B73 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1B36 storage[0x0167] = 0x00 // @1B3A storage[0x0168] = 0x00 // @1B3F storage[0x016d] = block.number // @1B53 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1B59 memory[0x20:0x40] = 0x0166 // @1B6B stack[0] = 0x084595161401484a000000 // @1B6B stack[2] = storage[0x0167] // @1B6F stack[1] = 0x1b74 // @1B6F stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3fa7, returns to 0x1B74 label_1B74: // Incoming return from call to 0x3FA7 at 0x1B73 // Incoming return from call to 0x3FA7 at 0x1B73 // Inputs[2] // { // @1B78 stack[-2] // @1B79 stack[-1] // } 1B74 5B JUMPDEST 1B75 61 PUSH2 0x1b7e 1B78 91 SWAP2 1B79 90 SWAP1 1B7A 61 PUSH2 0x3fc6 1B7D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B78 stack[-2] = 0x1b7e // @1B79 stack[-1] = stack[-2] // @1B79 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1B7E label_1B7E: // Incoming return from call to 0x3FC6 at 0x1B7D // Inputs[11] // { // @1B87 stack[-7] // @1B9A memory[0x00:0x40] // @1BA0 storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BAB memory[0x00:0x40] // @1BAC stack[-1] // @1BB1 storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BBA memory[0x00:0x40] // @1BBE block.number // @1BC9 storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BD2 stack[-5] // @1BD7 stack[-8] // } 1B7E 5B JUMPDEST 1B7F 60 PUSH1 0x01 1B81 60 PUSH1 0x01 1B83 60 PUSH1 0xa0 1B85 1B SHL 1B86 03 SUB 1B87 87 DUP8 1B88 16 AND 1B89 60 PUSH1 0x00 1B8B 81 DUP2 1B8C 81 DUP2 1B8D 52 MSTORE 1B8E 61 PUSH2 0x0166 1B91 60 PUSH1 0x20 1B93 81 DUP2 1B94 81 DUP2 1B95 52 MSTORE 1B96 60 PUSH1 0x40 1B98 80 DUP1 1B99 84 DUP5 1B9A 20 SHA3 1B9B 60 PUSH1 0x06 1B9D 81 DUP2 1B9E 01 ADD 1B9F 80 DUP1 1BA0 54 SLOAD 1BA1 86 DUP7 1BA2 52 MSTORE 1BA3 60 PUSH1 0x04 1BA5 82 DUP3 1BA6 01 ADD 1BA7 84 DUP5 1BA8 52 MSTORE 1BA9 82 DUP3 1BAA 86 DUP7 1BAB 20 SHA3 1BAC 97 SWAP8 1BAD 90 SWAP1 1BAE 97 SWAP8 1BAF 55 SSTORE 1BB0 86 DUP7 1BB1 54 SLOAD 1BB2 85 DUP6 1BB3 52 MSTORE 1BB4 60 PUSH1 0x05 1BB6 01 ADD 1BB7 82 DUP3 1BB8 52 MSTORE 1BB9 83 DUP4 1BBA 20 SHA3 1BBB 60 PUSH1 0x00 1BBD 19 NOT 1BBE 43 NUMBER 1BBF 01 ADD 1BC0 90 SWAP1 1BC1 55 SSTORE 1BC2 92 SWAP3 1BC3 90 SWAP1 1BC4 91 SWAP2 1BC5 52 MSTORE 1BC6 90 SWAP1 1BC7 52 MSTORE 1BC8 80 DUP1 1BC9 54 SLOAD 1BCA 60 PUSH1 0x01 1BCC 90 SWAP1 1BCD 81 DUP2 1BCE 01 ADD 1BCF 90 SWAP1 1BD0 91 SWAP2 1BD1 55 SSTORE 1BD2 93 SWAP4 1BD3 50 POP 1BD4 50 POP 1BD5 50 POP 1BD6 50 POP 1BD7 92 SWAP3 1BD8 91 SWAP2 1BD9 50 POP 1BDA 50 POP 1BDB 56 *JUMP // Stack delta = -7 // Outputs[12] // { // @1B8D memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @1B95 memory[0x20:0x40] = 0x0166 // @1BA2 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BA8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x04 // @1BAF storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1BB3 memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BB8 memory[0x20:0x40] = 0x05 + keccak256(memory[0x00:0x40]) // @1BC1 storage[keccak256(memory[0x00:0x40])] = block.number + ~0x00 // @1BC5 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @1BC7 memory[0x20:0x40] = 0x0166 // @1BD1 storage[keccak256(memory[0x00:0x40]) + 0x06] = 0x01 + storage[keccak256(memory[0x00:0x40]) + 0x06] // @1BD7 stack[-8] = 0x01 // } // Block ends with unconditional jump to stack[-8] label_1BDC: // Incoming call from 0x065C, returns to 0x0312 // Incoming call from 0x17AE, returns to 0x17AF // Incoming call from 0x0A84, returns to 0x0A85 // Incoming call from 0x0A84, returns to 0x0A85 // Incoming call from 0x0E4B, returns to 0x0E4C // Inputs[1] { @1BE0 storage[0x0169] } 1BDC 5B JUMPDEST 1BDD 61 PUSH2 0x0169 1BE0 54 SLOAD 1BE1 15 ISZERO 1BE2 80 DUP1 1BE3 15 ISZERO 1BE4 90 SWAP1 1BE5 61 PUSH2 0x1bf0 1BE8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BE4 stack[0] = !!storage[0x0169] } // Block ends with conditional jump to 0x1bf0, if !storage[0x0169] label_1BE9: // Incoming jump from 0x1BE8, if not !storage[0x0169] // Inputs[2] // { // @1BED storage[0x0169] // @1BEE block.number // } 1BE9 50 POP 1BEA 61 PUSH2 0x0169 1BED 54 SLOAD 1BEE 43 NUMBER 1BEF 11 GT 1BF0 5B JUMPDEST 1BF1 15 ISZERO 1BF2 61 PUSH2 0x1d60 1BF5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d60, if !(block.number > storage[0x0169]) label_1BF6: // Incoming jump from 0x1BF5, if not !stack[-1] // Incoming jump from 0x1BF5, if not !(block.number > storage[0x0169]) // Inputs[2] // { // @1BFC storage[0x0173] // @1BFD block.number // } 1BF6 61 PUSH2 0x1c0c 1BF9 61 PUSH2 0x0173 1BFC 54 SLOAD 1BFD 43 NUMBER 1BFE 61 PUSH2 0x1c07 1C01 91 SWAP2 1C02 90 SWAP1 1C03 61 PUSH2 0x3f5f 1C06 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BF6 stack[0] = 0x1c0c // @1C01 stack[1] = 0x1c07 // @1C02 stack[2] = storage[0x0173] // @1C02 stack[3] = block.number // } // Block ends with call to 0x3f5f, returns to 0x1C07 label_1C07: // Incoming return from call to 0x3F5F at 0x1C06 1C07 5B JUMPDEST 1C08 61 PUSH2 0x2ce9 1C0B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2ce9 label_1C0C: // Incoming return from call to 0x1C07 at 0x1C06 // Inputs[1] { @1C12 stack[-3] } 1C0C 5B JUMPDEST 1C0D 50 POP 1C0E 50 POP 1C0F 61 PUSH2 0x0168 1C12 55 SSTORE 1C13 5B JUMPDEST 1C14 61 PUSH2 0x1c1e 1C17 61 PUSH2 0x016e 1C1A 61 PUSH2 0x2673 1C1D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1C12 storage[0x0168] = stack[-3] // @1C14 stack[-3] = 0x1c1e // @1C17 stack[-2] = 0x016e // } // Block ends with call to 0x2673, returns to 0x1C1E label_1C1E: // Incoming return from call to 0x2673 at 0x1C1D // Incoming return from call to 0x2673 at 0x1C1D // Inputs[1] { @1C1F stack[-1] } 1C1E 5B JUMPDEST 1C1F 15 ISZERO 1C20 80 DUP1 1C21 15 ISZERO 1C22 61 PUSH2 0x1c46 1C25 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C1F stack[-1] = !stack[-1] } // Block ends with conditional jump to 0x1c46, if !!stack[-1] label_1C26: // Incoming jump from 0x1C25, if not !!stack[-1] // Inputs[4] // { // @1C2A storage[0x016f] // @1C41 memory[0x00:0x40] // @1C42 storage[keccak256(memory[0x00:0x40])] // @1C44 block.number // } 1C26 50 POP 1C27 61 PUSH2 0x016f 1C2A 54 SLOAD 1C2B 63 PUSH4 0xffffffff 1C30 90 SWAP1 1C31 81 DUP2 1C32 16 AND 1C33 60 PUSH1 0x00 1C35 90 SWAP1 1C36 81 DUP2 1C37 52 MSTORE 1C38 61 PUSH2 0x016e 1C3B 60 PUSH1 0x20 1C3D 52 MSTORE 1C3E 60 PUSH1 0x40 1C40 90 SWAP1 1C41 20 SHA3 1C42 54 SLOAD 1C43 16 AND 1C44 43 NUMBER 1C45 11 GT 1C46 5B JUMPDEST 1C47 15 ISZERO 1C48 61 PUSH2 0x1d0b 1C4B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C37 memory[0x00:0x20] = 0xffffffff & storage[0x016f] // @1C3D memory[0x20:0x40] = 0x016e // } // Block ends with conditional jump to 0x1d0b, if !(block.number > storage[keccak256(memory[0x00:0x40])] & 0xffffffff) label_1C4C: // Incoming jump from 0x1C4B, if not !stack[-1] // Incoming jump from 0x1C4B, if not !(block.number > storage[keccak256(memory[0x00:0x40])] & 0xffffffff) // Inputs[1] { @1C4F storage[0x016b] } 1C4C 61 PUSH2 0x016b 1C4F 54 SLOAD 1C50 15 ISZERO 1C51 61 PUSH2 0x1cb8 1C54 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1cb8, if !storage[0x016b] label_1C55: // Incoming jump from 0x1C54, if not !storage[0x016b] // Inputs[5] // { // @1C58 storage[0x016b] // @1C5C storage[0x0169] // @1C60 storage[0x016f] // @1C77 memory[0x00:0x40] // @1C78 storage[keccak256(memory[0x00:0x40])] // } 1C55 61 PUSH2 0x016b 1C58 54 SLOAD 1C59 61 PUSH2 0x0169 1C5C 54 SLOAD 1C5D 61 PUSH2 0x016f 1C60 54 SLOAD 1C61 63 PUSH4 0xffffffff 1C66 90 SWAP1 1C67 81 DUP2 1C68 16 AND 1C69 60 PUSH1 0x00 1C6B 90 SWAP1 1C6C 81 DUP2 1C6D 52 MSTORE 1C6E 61 PUSH2 0x016e 1C71 60 PUSH1 0x20 1C73 52 MSTORE 1C74 60 PUSH1 0x40 1C76 90 SWAP1 1C77 20 SHA3 1C78 54 SLOAD 1C79 6A PUSH11 0x084595161401484a000000 1C85 92 SWAP3 1C86 61 PUSH2 0x1c91 1C89 92 SWAP3 1C8A 90 SWAP1 1C8B 91 SWAP2 1C8C 16 AND 1C8D 61 PUSH2 0x22d7 1C90 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1C58 stack[0] = storage[0x016b] // @1C6D memory[0x00:0x20] = 0xffffffff & storage[0x016f] // @1C73 memory[0x20:0x40] = 0x016e // @1C85 stack[1] = 0x084595161401484a000000 // @1C89 stack[2] = 0x1c91 // @1C8B stack[3] = storage[0x0169] // @1C8C stack[4] = storage[keccak256(memory[0x00:0x40])] & 0xffffffff // } // Block ends with call to 0x22d7, returns to 0x1C91 label_1C91: // Incoming return from call to 0x22D7 at 0x1C90 // Incoming return from call to 0x22D7 at 0x1C90 // Inputs[2] // { // @1C95 stack[-2] // @1C96 stack[-1] // } 1C91 5B JUMPDEST 1C92 61 PUSH2 0x1c9b 1C95 91 SWAP2 1C96 90 SWAP1 1C97 61 PUSH2 0x3fa7 1C9A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C95 stack[-2] = 0x1c9b // @1C96 stack[-1] = stack[-2] // @1C96 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x1C9B label_1C9B: // Incoming return from call to 0x3FA7 at 0x1C9A // Inputs[2] // { // @1C9F stack[-2] // @1CA0 stack[-1] // } 1C9B 5B JUMPDEST 1C9C 61 PUSH2 0x1ca5 1C9F 91 SWAP2 1CA0 90 SWAP1 1CA1 61 PUSH2 0x3fc6 1CA4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C9F stack[-2] = 0x1ca5 // @1CA0 stack[-1] = stack[-2] // @1CA0 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1CA5 label_1CA5: // Incoming return from call to 0x3FC6 at 0x1CA4 // Inputs[2] // { // @1CA9 storage[0x0167] // @1CAD stack[-1] // } 1CA5 5B JUMPDEST 1CA6 61 PUSH2 0x0167 1CA9 54 SLOAD 1CAA 61 PUSH2 0x1cb3 1CAD 91 SWAP2 1CAE 90 SWAP1 1CAF 61 PUSH2 0x3f5f 1CB2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1CAD stack[-1] = 0x1cb3 // @1CAE stack[1] = storage[0x0167] // @1CAE stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x1CB3 label_1CB3: // Incoming return from call to 0x3F5F at 0x1CB2 // Inputs[1] { @1CB7 stack[-1] } 1CB3 5B JUMPDEST 1CB4 61 PUSH2 0x0167 1CB7 55 SSTORE // Stack delta = -1 // Outputs[1] { @1CB7 storage[0x0167] = stack[-1] } // Block continues label_1CB8: // Incoming jump from 0x1CB7 // Incoming jump from 0x1C54, if !storage[0x016b] // Inputs[5] // { // @1CBC storage[0x016f] // @1CD6 memory[0x00:0x40] // @1CD8 storage[keccak256(memory[0x00:0x40])] // @1CE1 storage[keccak256(memory[0x00:0x40])] // @1CE6 storage[0x016b] // } 1CB8 5B JUMPDEST 1CB9 61 PUSH2 0x016f 1CBC 54 SLOAD 1CBD 63 PUSH4 0xffffffff 1CC2 90 SWAP1 1CC3 81 DUP2 1CC4 16 AND 1CC5 60 PUSH1 0x00 1CC7 90 SWAP1 1CC8 81 DUP2 1CC9 52 MSTORE 1CCA 61 PUSH2 0x016e 1CCD 60 PUSH1 0x20 1CCF 81 DUP2 1CD0 90 SWAP1 1CD1 52 MSTORE 1CD2 60 PUSH1 0x40 1CD4 90 SWAP1 1CD5 91 SWAP2 1CD6 20 SHA3 1CD7 80 DUP1 1CD8 54 SLOAD 1CD9 90 SWAP1 1CDA 92 SWAP3 1CDB 16 AND 1CDC 61 PUSH2 0x0169 1CDF 55 SSTORE 1CE0 90 SWAP1 1CE1 54 SLOAD 1CE2 61 PUSH2 0x016b 1CE5 80 DUP1 1CE6 54 SLOAD 1CE7 60 PUSH1 0x01 1CE9 60 PUSH1 0x20 1CEB 1B SHL 1CEC 90 SWAP1 1CED 92 SWAP3 1CEE 04 DIV 1CEF 60 PUSH1 0x01 1CF1 60 PUSH1 0x01 1CF3 60 PUSH1 0x60 1CF5 1B SHL 1CF6 03 SUB 1CF7 16 AND 1CF8 90 SWAP1 1CF9 91 SWAP2 1CFA 01 ADD 1CFB 90 SWAP1 1CFC 55 SSTORE 1CFD 61 PUSH2 0x1d05 1D00 90 SWAP1 1D01 61 PUSH2 0x2ec3 1D04 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1CC9 memory[0x00:0x20] = 0xffffffff & storage[0x016f] // @1CD1 memory[0x20:0x40] = 0x016e // @1CDF storage[0x0169] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] // @1CFC storage[0x016b] = storage[0x016b] + ((0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20)) // @1D00 stack[0] = 0x1d05 // @1D00 stack[1] = 0x016e // } // Block ends with call to 0x2ec3, returns to 0x1D05 label_1D05: // Incoming return from call to 0x2EC3 at 0x1D04 1D05 5B JUMPDEST 1D06 50 POP 1D07 61 PUSH2 0x1c13 1D0A 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1c13 label_1D0B: // Incoming jump from 0x1C4B, if !stack[-1] // Incoming jump from 0x1C4B, if !(block.number > storage[keccak256(memory[0x00:0x40])] & 0xffffffff) // Inputs[1] { @1D0F storage[0x016b] } 1D0B 5B JUMPDEST 1D0C 61 PUSH2 0x016b 1D0F 54 SLOAD 1D10 61 PUSH2 0x1d1a 1D13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d1a, if storage[0x016b] label_1D14: // Incoming jump from 0x1D13, if not storage[0x016b] 1D14 60 PUSH1 0x00 1D16 61 PUSH2 0x1d5b 1D19 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D14 stack[0] = 0x00 } // Block ends with unconditional jump to 0x1d5b label_1D1A: // Incoming jump from 0x1D13, if storage[0x016b] // Inputs[3] // { // @1D1E storage[0x016b] // @1D22 storage[0x0169] // @1D34 block.number // } 1D1A 5B JUMPDEST 1D1B 61 PUSH2 0x016b 1D1E 54 SLOAD 1D1F 61 PUSH2 0x0169 1D22 54 SLOAD 1D23 6A PUSH11 0x084595161401484a000000 1D2F 90 SWAP1 1D30 61 PUSH2 0x1d39 1D33 90 SWAP1 1D34 43 NUMBER 1D35 61 PUSH2 0x22d7 1D38 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D1E stack[0] = storage[0x016b] // @1D2F stack[1] = 0x084595161401484a000000 // @1D33 stack[2] = 0x1d39 // @1D33 stack[3] = storage[0x0169] // @1D34 stack[4] = block.number // } // Block ends with call to 0x22d7, returns to 0x1D39 label_1D39: // Incoming return from call to 0x22D7 at 0x1D38 // Incoming return from call to 0x22D7 at 0x1D38 // Inputs[2] // { // @1D3D stack[-2] // @1D3E stack[-1] // } 1D39 5B JUMPDEST 1D3A 61 PUSH2 0x1d43 1D3D 91 SWAP2 1D3E 90 SWAP1 1D3F 61 PUSH2 0x3fa7 1D42 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D3D stack[-2] = 0x1d43 // @1D3E stack[-1] = stack[-2] // @1D3E stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x1D43 label_1D43: // Incoming return from call to 0x3FA7 at 0x1D42 // Inputs[2] // { // @1D47 stack[-2] // @1D48 stack[-1] // } 1D43 5B JUMPDEST 1D44 61 PUSH2 0x1d4d 1D47 91 SWAP2 1D48 90 SWAP1 1D49 61 PUSH2 0x3fc6 1D4C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D47 stack[-2] = 0x1d4d // @1D48 stack[-1] = stack[-2] // @1D48 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1D4D label_1D4D: // Incoming return from call to 0x3FC6 at 0x1D4C // Inputs[2] // { // @1D51 storage[0x0167] // @1D55 stack[-1] // } 1D4D 5B JUMPDEST 1D4E 61 PUSH2 0x0167 1D51 54 SLOAD 1D52 61 PUSH2 0x1d5b 1D55 91 SWAP2 1D56 90 SWAP1 1D57 61 PUSH2 0x3f5f 1D5A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D55 stack[-1] = 0x1d5b // @1D56 stack[1] = storage[0x0167] // @1D56 stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x1D5B label_1D5B: // Incoming jump from 0x1D19 // Incoming return from call to 0x3F5F at 0x1D5A // Inputs[1] { @1D5F stack[-1] } 1D5B 5B JUMPDEST 1D5C 61 PUSH2 0x0167 1D5F 55 SSTORE // Stack delta = -1 // Outputs[1] { @1D5F storage[0x0167] = stack[-1] } // Block continues label_1D60: // Incoming jump from 0x1BF5, if !stack[-1] // Incoming jump from 0x1BF5, if !(block.number > storage[0x0169]) // Incoming jump from 0x1D5F // Inputs[2] // { // @1D61 block.number // @1D66 stack[-1] // } 1D60 5B JUMPDEST 1D61 43 NUMBER 1D62 61 PUSH2 0x0169 1D65 55 SSTORE 1D66 56 *JUMP // Stack delta = -1 // Outputs[1] { @1D65 storage[0x0169] = block.number } // Block ends with unconditional jump to stack[-1] label_1D67: // Incoming call from 0x237B, returns to 0x237C // Incoming jump from 0x066F // Incoming call from 0x2350, returns to 0x2351 // Incoming call from 0x23B7, returns to 0x23B8 // Inputs[2] // { // @1D6D storage[0x0172] // @1D6E stack[-1] // } 1D67 5B JUMPDEST 1D68 60 PUSH1 0x00 1D6A 61 PUSH2 0x0172 1D6D 54 SLOAD 1D6E 82 DUP3 1D6F 11 GT 1D70 61 PUSH2 0x1d8b 1D73 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D68 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d8b, if stack[-1] > storage[0x0172] label_1D74: // Incoming jump from 0x1D73, if not stack[-1] > storage[0x0172] // Inputs[1] { @1D76 memory[0x40:0x60] } 1D74 60 PUSH1 0x40 1D76 51 MLOAD 1D77 62 PUSH3 0x461bcd 1D7B 60 PUSH1 0xe5 1D7D 1B SHL 1D7E 81 DUP2 1D7F 52 MSTORE 1D80 60 PUSH1 0x04 1D82 01 ADD 1D83 61 PUSH2 0x0817 1D86 90 SWAP1 1D87 61 PUSH2 0x4113 1D8A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D86 stack[0] = 0x0817 // @1D86 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4113, returns to 0x0817 label_1D8B: // Incoming jump from 0x1D73, if stack[-1] > storage[0x0172] // Inputs[3] // { // @1D8F storage[0x0171] // @1D93 storage[0x0172] // @1D98 stack[-2] // } 1D8B 5B JUMPDEST 1D8C 61 PUSH2 0x0171 1D8F 54 SLOAD 1D90 61 PUSH2 0x0172 1D93 54 SLOAD 1D94 61 PUSH2 0x1d9d 1D97 90 SWAP1 1D98 84 DUP5 1D99 61 PUSH2 0x3f77 1D9C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D8F stack[0] = storage[0x0171] // @1D97 stack[1] = 0x1d9d // @1D97 stack[2] = storage[0x0172] // @1D98 stack[3] = stack[-2] // } // Block ends with call to 0x3f77, returns to 0x1D9D label_1D9D: // Incoming return from call to 0x3F77 at 0x1D9C // Inputs[2] // { // @1DA1 stack[-2] // @1DA2 stack[-1] // } 1D9D 5B JUMPDEST 1D9E 61 PUSH2 0x1da7 1DA1 91 SWAP2 1DA2 90 SWAP1 1DA3 61 PUSH2 0x3fc6 1DA6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1DA1 stack[-2] = 0x1da7 // @1DA2 stack[-1] = stack[-2] // @1DA2 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x1DA7 label_1DA7: // Incoming return from call to 0x3FC6 at 0x1DA6 // Inputs[1] { @1DAB stack[-1] } 1DA7 5B JUMPDEST 1DA8 61 PUSH2 0x1db2 1DAB 90 SWAP1 1DAC 60 PUSH1 0x02 1DAE 61 PUSH2 0x4242 1DB1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DAB stack[0] = stack[-1] // @1DAB stack[-1] = 0x1db2 // @1DAC stack[1] = 0x02 // } // Block ends with call to 0x4242, returns to 0x1DB2 label_1DB2: // Incoming return from call to 0x4242 at 0x1DB1 // Inputs[2] // { // @1DB6 storage[0x0170] // @1DBA stack[-1] // } 1DB2 5B JUMPDEST 1DB3 61 PUSH2 0x0170 1DB6 54 SLOAD 1DB7 61 PUSH2 0x06a1 1DBA 91 SWAP2 1DBB 90 SWAP1 1DBC 61 PUSH2 0x3fc6 1DBF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DBA stack[-1] = 0x06a1 // @1DBB stack[1] = storage[0x0170] // @1DBB stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x06A1 label_1DC0: // Incoming call from 0x1481, returns to 0x0BD4 // Incoming jump from 0x0CF7 // Incoming call from 0x2898, returns to 0x22D1 // Incoming call from 0x0746, returns to 0x0747 // Inputs[1] { @1DC9 stack[-3] } 1DC0 5B JUMPDEST 1DC1 60 PUSH1 0x01 1DC3 60 PUSH1 0x01 1DC5 60 PUSH1 0xa0 1DC7 1B SHL 1DC8 03 SUB 1DC9 83 DUP4 1DCA 16 AND 1DCB 61 PUSH2 0x1e22 1DCE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e22, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1DCF: // Incoming jump from 0x1DCE, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DD1 memory[0x40:0x60] } 1DCF 60 PUSH1 0x40 1DD1 51 MLOAD 1DD2 62 PUSH3 0x461bcd 1DD6 60 PUSH1 0xe5 1DD8 1B SHL 1DD9 81 DUP2 1DDA 52 MSTORE 1DDB 60 PUSH1 0x20 1DDD 60 PUSH1 0x04 1DDF 82 DUP3 1DE0 01 ADD 1DE1 52 MSTORE 1DE2 60 PUSH1 0x24 1DE4 80 DUP1 1DE5 82 DUP3 1DE6 01 ADD 1DE7 52 MSTORE 1DE8 7F PUSH32 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 1E09 60 PUSH1 0x44 1E0B 82 DUP3 1E0C 01 ADD 1E0D 52 MSTORE 1E0E 63 PUSH4 0x72657373 1E13 60 PUSH1 0xe0 1E15 1B SHL 1E16 60 PUSH1 0x64 1E18 82 DUP3 1E19 01 ADD 1E1A 52 MSTORE 1E1B 60 PUSH1 0x84 1E1D 01 ADD 1E1E 61 PUSH2 0x0817 1E21 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1DDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DE1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DE7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1E0D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 // @1E1A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @1E1D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_1E22: // Incoming jump from 0x1DCE, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E2B stack[-2] } 1E22 5B JUMPDEST 1E23 60 PUSH1 0x01 1E25 60 PUSH1 0x01 1E27 60 PUSH1 0xa0 1E29 1B SHL 1E2A 03 SUB 1E2B 82 DUP3 1E2C 16 AND 1E2D 61 PUSH2 0x1e83 1E30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e83, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1E31: // Incoming jump from 0x1E30, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E33 memory[0x40:0x60] } 1E31 60 PUSH1 0x40 1E33 51 MLOAD 1E34 62 PUSH3 0x461bcd 1E38 60 PUSH1 0xe5 1E3A 1B SHL 1E3B 81 DUP2 1E3C 52 MSTORE 1E3D 60 PUSH1 0x20 1E3F 60 PUSH1 0x04 1E41 82 DUP3 1E42 01 ADD 1E43 52 MSTORE 1E44 60 PUSH1 0x22 1E46 60 PUSH1 0x24 1E48 82 DUP3 1E49 01 ADD 1E4A 52 MSTORE 1E4B 7F PUSH32 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 1E6C 60 PUSH1 0x44 1E6E 82 DUP3 1E6F 01 ADD 1E70 52 MSTORE 1E71 61 PUSH2 0x7373 1E74 60 PUSH1 0xf0 1E76 1B SHL 1E77 60 PUSH1 0x64 1E79 82 DUP3 1E7A 01 ADD 1E7B 52 MSTORE 1E7C 60 PUSH1 0x84 1E7E 01 ADD 1E7F 61 PUSH2 0x0817 1E82 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1E3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E43 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E4A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @1E70 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 // @1E7B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7373 << 0xf0 // @1E7E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_1E83: // Incoming jump from 0x1E30, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[9] // { // @1E8C stack[-3] // @1E9F memory[0x00:0x40] // @1EA1 stack[-2] // @1EAC memory[0x00:0x40] // @1EAD stack[-1] // @1EB1 memory[0x40:0x60] // @1EDA memory[0x40:0x60] // @1EDF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1EE3 stack[-4] // } 1E83 5B JUMPDEST 1E84 60 PUSH1 0x01 1E86 60 PUSH1 0x01 1E88 60 PUSH1 0xa0 1E8A 1B SHL 1E8B 03 SUB 1E8C 83 DUP4 1E8D 81 DUP2 1E8E 16 AND 1E8F 60 PUSH1 0x00 1E91 81 DUP2 1E92 81 DUP2 1E93 52 MSTORE 1E94 60 PUSH1 0x98 1E96 60 PUSH1 0x20 1E98 90 SWAP1 1E99 81 DUP2 1E9A 52 MSTORE 1E9B 60 PUSH1 0x40 1E9D 80 DUP1 1E9E 83 DUP4 1E9F 20 SHA3 1EA0 94 SWAP5 1EA1 87 DUP8 1EA2 16 AND 1EA3 80 DUP1 1EA4 84 DUP5 1EA5 52 MSTORE 1EA6 94 SWAP5 1EA7 82 DUP3 1EA8 52 MSTORE 1EA9 91 SWAP2 1EAA 82 DUP3 1EAB 90 SWAP1 1EAC 20 SHA3 1EAD 85 DUP6 1EAE 90 SWAP1 1EAF 55 SSTORE 1EB0 90 SWAP1 1EB1 51 MLOAD 1EB2 84 DUP5 1EB3 81 DUP2 1EB4 52 MSTORE 1EB5 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1ED6 91 SWAP2 1ED7 01 ADD 1ED8 60 PUSH1 0x40 1EDA 51 MLOAD 1EDB 80 DUP1 1EDC 91 SWAP2 1EDD 03 SUB 1EDE 90 SWAP1 1EDF A3 LOG3 1EE0 50 POP 1EE1 50 POP 1EE2 50 POP 1EE3 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1E93 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1E9A memory[0x20:0x40] = 0x98 // @1EA5 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1EA8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1EAF storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1EB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1EDF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_1EE4: // Incoming call from 0x075E, returns to 0x075F // Inputs[3] // { // @1EED stack[-3] // @1EFD memory[0x00:0x40] // @1EFF stack[-2] // } 1EE4 5B JUMPDEST 1EE5 60 PUSH1 0x01 1EE7 60 PUSH1 0x01 1EE9 60 PUSH1 0xa0 1EEB 1B SHL 1EEC 03 SUB 1EED 83 DUP4 1EEE 16 AND 1EEF 60 PUSH1 0x00 1EF1 90 SWAP1 1EF2 81 DUP2 1EF3 52 MSTORE 1EF4 61 PUSH2 0x0131 1EF7 60 PUSH1 0x20 1EF9 52 MSTORE 1EFA 60 PUSH1 0x40 1EFC 81 DUP2 1EFD 20 SHA3 1EFE 90 SWAP1 1EFF 83 DUP4 1F00 60 PUSH1 0x04 1F02 81 DUP2 1F03 11 GT 1F04 15 ISZERO 1F05 61 PUSH2 0x1f10 1F08 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1EF3 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1EF9 memory[0x20:0x40] = 0x0131 // @1EFE stack[0] = keccak256(memory[0x00:0x40]) // @1EFE stack[1] = 0x00 // @1EFF stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1f10, if !(stack[-2] > 0x04) label_1F09: // Incoming jump from 0x1F08, if not !(stack[-2] > 0x04) 1F09 61 PUSH2 0x1f10 1F0C 61 PUSH2 0x3e40 1F0F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F09 stack[0] = 0x1f10 } // Block ends with unconditional jump to 0x3e40 label_1F10: // Incoming jump from 0x1F08, if !(stack[-2] > 0x04) // Inputs[1] { @1F13 stack[-1] } 1F10 5B JUMPDEST 1F11 60 PUSH1 0x04 1F13 81 DUP2 1F14 11 GT 1F15 15 ISZERO 1F16 61 PUSH2 0x1f21 1F19 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f21, if !(stack[-1] > 0x04) label_1F1A: // Incoming jump from 0x1F19, if not !(stack[-1] > 0x04) 1F1A 61 PUSH2 0x1f21 1F1D 61 PUSH2 0x3e40 1F20 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F1A stack[0] = 0x1f21 } // Block ends with unconditional jump to 0x3e40 label_1F21: // Incoming jump from 0x1F19, if !(stack[-1] > 0x04) // Inputs[7] // { // @1F22 stack[-2] // @1F23 stack[-1] // @1F29 stack[-3] // @1F36 memory[0x00:0x00 + 0x40 + stack[-2]] // @1F37 stack[-4] // @1F3E memory[0x00:0x40] // @1F3F storage[keccak256(memory[0x00:0x40])] // } 1F21 5B JUMPDEST 1F22 81 DUP2 1F23 52 MSTORE 1F24 60 PUSH1 0x20 1F26 80 DUP1 1F27 82 DUP3 1F28 01 ADD 1F29 92 SWAP3 1F2A 90 SWAP1 1F2B 92 SWAP3 1F2C 52 MSTORE 1F2D 60 PUSH1 0x40 1F2F 90 SWAP1 1F30 81 DUP2 1F31 01 ADD 1F32 60 PUSH1 0x00 1F34 90 SWAP1 1F35 81 DUP2 1F36 20 SHA3 1F37 84 DUP5 1F38 82 DUP3 1F39 52 MSTORE 1F3A 90 SWAP1 1F3B 92 SWAP3 1F3C 52 MSTORE 1F3D 90 SWAP1 1F3E 20 SHA3 1F3F 54 SLOAD 1F40 60 PUSH1 0xff 1F42 16 AND 1F43 15 ISZERO 1F44 61 PUSH2 0x1fb5 1F47 57 *JUMPI // Stack delta = -3 // Outputs[4] // { // @1F23 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1F2C memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @1F39 memory[0x00:0x20] = stack[-4] // @1F3C memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // } // Block ends with conditional jump to 0x1fb5, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1F48: // Incoming jump from 0x1F47, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1F4A memory[0x40:0x60] } 1F48 60 PUSH1 0x40 1F4A 51 MLOAD 1F4B 62 PUSH3 0x461bcd 1F4F 60 PUSH1 0xe5 1F51 1B SHL 1F52 81 DUP2 1F53 52 MSTORE 1F54 60 PUSH1 0x20 1F56 60 PUSH1 0x04 1F58 82 DUP3 1F59 01 ADD 1F5A 52 MSTORE 1F5B 60 PUSH1 0x3f 1F5D 60 PUSH1 0x24 1F5F 82 DUP3 1F60 01 ADD 1F61 52 MSTORE 1F62 7F PUSH32 0x457874656e64656445524332303a20746865206e6f6e63652068617320616c72 1F83 60 PUSH1 0x44 1F85 82 DUP3 1F86 01 ADD 1F87 52 MSTORE 1F88 7F PUSH32 0x65616479206265656e207573656420666f722074686973206164647265737300 1FA9 60 PUSH1 0x64 1FAB 82 DUP3 1FAC 01 ADD 1FAD 52 MSTORE 1FAE 60 PUSH1 0x84 1FB0 01 ADD 1FB1 61 PUSH2 0x0817 1FB4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1F53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F5A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1F61 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x3f // @1F87 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x457874656e64656445524332303a20746865206e6f6e63652068617320616c72 // @1FAD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65616479206265656e207573656420666f722074686973206164647265737300 // @1FB0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_1FB5: // Incoming jump from 0x1F47, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @1FBE stack[-3] // @1FCE memory[0x00:0x40] // @1FD2 stack[-2] // } 1FB5 5B JUMPDEST 1FB6 60 PUSH1 0x01 1FB8 60 PUSH1 0x01 1FBA 60 PUSH1 0xa0 1FBC 1B SHL 1FBD 03 SUB 1FBE 83 DUP4 1FBF 16 AND 1FC0 60 PUSH1 0x00 1FC2 90 SWAP1 1FC3 81 DUP2 1FC4 52 MSTORE 1FC5 61 PUSH2 0x0131 1FC8 60 PUSH1 0x20 1FCA 52 MSTORE 1FCB 60 PUSH1 0x40 1FCD 81 DUP2 1FCE 20 SHA3 1FCF 60 PUSH1 0x01 1FD1 91 SWAP2 1FD2 84 DUP5 1FD3 60 PUSH1 0x04 1FD5 81 DUP2 1FD6 11 GT 1FD7 15 ISZERO 1FD8 61 PUSH2 0x1fe3 1FDB 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @1FC4 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1FCA memory[0x20:0x40] = 0x0131 // @1FCE stack[1] = keccak256(memory[0x00:0x40]) // @1FD1 stack[0] = 0x01 // @1FD1 stack[2] = 0x00 // @1FD2 stack[3] = stack[-2] // } // Block ends with conditional jump to 0x1fe3, if !(stack[-2] > 0x04) label_1FDC: // Incoming jump from 0x1FDB, if not !(stack[-2] > 0x04) 1FDC 61 PUSH2 0x1fe3 1FDF 61 PUSH2 0x3e40 1FE2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FDC stack[0] = 0x1fe3 } // Block ends with unconditional jump to 0x3e40 label_1FE3: // Incoming jump from 0x1FDB, if !(stack[-2] > 0x04) // Inputs[1] { @1FE6 stack[-1] } 1FE3 5B JUMPDEST 1FE4 60 PUSH1 0x04 1FE6 81 DUP2 1FE7 11 GT 1FE8 15 ISZERO 1FE9 61 PUSH2 0x1ff4 1FEC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ff4, if !(stack[-1] > 0x04) label_1FED: // Incoming jump from 0x1FEC, if not !(stack[-1] > 0x04) 1FED 61 PUSH2 0x1ff4 1FF0 61 PUSH2 0x3e40 1FF3 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FED stack[0] = 0x1ff4 } // Block ends with unconditional jump to 0x3e40 label_1FF4: // Incoming jump from 0x1FEC, if !(stack[-1] > 0x04) // Inputs[9] // { // @1FF5 stack[-2] // @1FF6 stack[-1] // @1FFC stack[-3] // @2009 memory[0x00:0x00 + 0x40 + stack[-2]] // @200A stack[-5] // @2011 stack[-4] // @2013 memory[0x00:0x40] // @2015 storage[keccak256(memory[0x00:0x40])] // @2025 stack[-8] // } 1FF4 5B JUMPDEST 1FF5 81 DUP2 1FF6 52 MSTORE 1FF7 60 PUSH1 0x20 1FF9 80 DUP1 1FFA 82 DUP3 1FFB 01 ADD 1FFC 92 SWAP3 1FFD 90 SWAP1 1FFE 92 SWAP3 1FFF 52 MSTORE 2000 60 PUSH1 0x40 2002 90 SWAP1 2003 81 DUP2 2004 01 ADD 2005 60 PUSH1 0x00 2007 90 SWAP1 2008 81 DUP2 2009 20 SHA3 200A 94 SWAP5 200B 81 DUP2 200C 52 MSTORE 200D 93 SWAP4 200E 90 SWAP1 200F 91 SWAP2 2010 52 MSTORE 2011 90 SWAP1 2012 91 SWAP2 2013 20 SHA3 2014 80 DUP1 2015 54 SLOAD 2016 60 PUSH1 0xff 2018 19 NOT 2019 16 AND 201A 91 SWAP2 201B 15 ISZERO 201C 15 ISZERO 201D 91 SWAP2 201E 90 SWAP1 201F 91 SWAP2 2020 17 OR 2021 90 SWAP1 2022 55 SSTORE 2023 50 POP 2024 50 POP 2025 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @1FF6 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1FFF memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @200C memory[0x00:0x20] = stack[-5] // @2010 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @2022 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-8] label_2026: // Incoming call from 0x07A6, returns to 0x07A7 // Inputs[5] // { // @202D stack[-3] // @2030 memory[0x40:0x60] // @2065 memory[0x40:0x60] // @2073 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2078 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 2026 5B JUMPDEST 2027 60 PUSH1 0x00 2029 80 DUP1 202A 61 PUSH2 0x207f 202D 85 DUP6 202E 60 PUSH1 0x40 2030 51 MLOAD 2031 7B PUSH28 0x0ca2ba3432b932bab69029b4b3b732b21026b2b9b9b0b3b29d051999 204E 60 PUSH1 0x21 2050 1B SHL 2051 60 PUSH1 0x20 2053 82 DUP3 2054 01 ADD 2055 52 MSTORE 2056 60 PUSH1 0x3c 2058 81 DUP2 2059 01 ADD 205A 82 DUP3 205B 90 SWAP1 205C 52 MSTORE 205D 60 PUSH1 0x00 205F 90 SWAP1 2060 60 PUSH1 0x5c 2062 01 ADD 2063 60 PUSH1 0x40 2065 51 MLOAD 2066 60 PUSH1 0x20 2068 81 DUP2 2069 83 DUP4 206A 03 SUB 206B 03 SUB 206C 81 DUP2 206D 52 MSTORE 206E 90 SWAP1 206F 60 PUSH1 0x40 2071 52 MSTORE 2072 80 DUP1 2073 51 MLOAD 2074 90 SWAP1 2075 60 PUSH1 0x20 2077 01 ADD 2078 20 SHA3 2079 90 SWAP1 207A 50 POP 207B 91 SWAP2 207C 90 SWAP1 207D 50 POP 207E 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @2027 stack[0] = 0x00 // @2029 stack[1] = 0x00 // @2055 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x0ca2ba3432b932bab69029b4b3b732b21026b2b9b9b0b3b29d051999 << 0x21 // @205C memory[memory[0x40:0x60] + 0x3c:memory[0x40:0x60] + 0x3c + 0x20] = stack[-3] // @206D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x5c + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @2071 memory[0x40:0x60] = 0x5c + memory[0x40:0x60] // @207B stack[2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x207f label_207F: // Incoming jump from 0x207E // Inputs[3] // { // @2080 stack[-2] // @2080 stack[-1] // @2088 stack[-4] // } 207F 5B JUMPDEST 2080 90 SWAP1 2081 50 POP 2082 60 PUSH1 0x00 2084 61 PUSH2 0x208d 2087 82 DUP3 2088 85 DUP6 2089 61 PUSH2 0x2fcf 208C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2080 stack[-2] = stack[-1] // @2082 stack[-1] = 0x00 // @2084 stack[0] = 0x208d // @2087 stack[1] = stack[-1] // @2088 stack[2] = stack[-4] // } // Block ends with call to 0x2fcf, returns to 0x208D label_208D: // Incoming return from call to 0x2FCF at 0x208C // Inputs[3] // { // @208E stack[-2] // @208E stack[-1] // @2090 stack[-6] // } 208D 5B JUMPDEST 208E 90 SWAP1 208F 50 POP 2090 84 DUP5 2091 60 PUSH1 0x01 2093 60 PUSH1 0x01 2095 60 PUSH1 0xa0 2097 1B SHL 2098 03 SUB 2099 16 AND 209A 81 DUP2 209B 60 PUSH1 0x01 209D 60 PUSH1 0x01 209F 60 PUSH1 0xa0 20A1 1B SHL 20A2 03 SUB 20A3 16 AND 20A4 14 EQ 20A5 61 PUSH2 0x20ee 20A8 57 *JUMPI // Stack delta = -1 // Outputs[1] { @208E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x20ee, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-6] label_20A9: // Incoming jump from 0x20A8, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[1] { @20AB memory[0x40:0x60] } 20A9 60 PUSH1 0x40 20AB 51 MLOAD 20AC 62 PUSH3 0x461bcd 20B0 60 PUSH1 0xe5 20B2 1B SHL 20B3 81 DUP2 20B4 52 MSTORE 20B5 60 PUSH1 0x20 20B7 60 PUSH1 0x04 20B9 82 DUP3 20BA 01 ADD 20BB 52 MSTORE 20BC 60 PUSH1 0x1b 20BE 60 PUSH1 0x24 20C0 82 DUP3 20C1 01 ADD 20C2 52 MSTORE 20C3 7A PUSH27 0x56616c69646174653a20696e76616c6964207369676e6174757265 20DF 60 PUSH1 0x28 20E1 1B SHL 20E2 60 PUSH1 0x44 20E4 82 DUP3 20E5 01 ADD 20E6 52 MSTORE 20E7 60 PUSH1 0x64 20E9 01 ADD 20EA 61 PUSH2 0x0817 20ED 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @20B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20BB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20C2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @20E6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x56616c69646174653a20696e76616c6964207369676e6174757265 << 0x28 // @20E9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_20EE: // Incoming jump from 0x20A8, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-6] // Inputs[2] // { // @20F2 stack[-7] // @20F3 stack[-6] // } 20EE 5B JUMPDEST 20EF 50 POP 20F0 60 PUSH1 0x01 20F2 95 SWAP6 20F3 94 SWAP5 20F4 50 POP 20F5 50 POP 20F6 50 POP 20F7 50 POP 20F8 50 POP 20F9 56 *JUMP // Stack delta = -6 // Outputs[1] { @20F2 stack[-7] = 0x01 } // Block ends with unconditional jump to stack[-7] label_20FA: // Incoming call from 0x07B2, returns to 0x07B3 // Inputs[1] { @20FB stack[-2] } 20FA 5B JUMPDEST 20FB 81 DUP2 20FC 15 ISZERO 20FD 61 PUSH2 0x0c10 2100 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c10, if !stack[-2] label_2101: // Incoming jump from 0x2100, if not !stack[-2] // Inputs[3] // { // @2104 stack[-3] // @2105 stack[-1] // @2106 stack[-2] // } 2101 61 PUSH2 0x0c10 2104 83 DUP4 2105 82 DUP3 2106 84 DUP5 // Stack delta = +4 // Outputs[4] // { // @2101 stack[0] = 0x0c10 // @2104 stack[1] = stack[-3] // @2105 stack[2] = stack[-1] // @2106 stack[3] = stack[-2] // } // Block continues label_2107: // Incoming call from 0x07BD, returns to 0x07BE // Incoming call from 0x0BD3, returns to 0x0BD4 // Incoming call from 0x148F, returns to 0x0747 // Incoming jump from 0x2106 // Inputs[1] { @2110 stack[-3] } 2107 5B JUMPDEST 2108 60 PUSH1 0x01 210A 60 PUSH1 0x01 210C 60 PUSH1 0xa0 210E 1B SHL 210F 03 SUB 2110 83 DUP4 2111 16 AND 2112 61 PUSH2 0x216b 2115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x216b, if stack[-3] & (0x01 << 0xa0) - 0x01 label_2116: // Incoming jump from 0x2115, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2118 memory[0x40:0x60] } 2116 60 PUSH1 0x40 2118 51 MLOAD 2119 62 PUSH3 0x461bcd 211D 60 PUSH1 0xe5 211F 1B SHL 2120 81 DUP2 2121 52 MSTORE 2122 60 PUSH1 0x20 2124 60 PUSH1 0x04 2126 82 DUP3 2127 01 ADD 2128 52 MSTORE 2129 60 PUSH1 0x25 212B 60 PUSH1 0x24 212D 82 DUP3 212E 01 ADD 212F 52 MSTORE 2130 7F PUSH32 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 2151 60 PUSH1 0x44 2153 82 DUP3 2154 01 ADD 2155 52 MSTORE 2156 64 PUSH5 0x6472657373 215C 60 PUSH1 0xd8 215E 1B SHL 215F 60 PUSH1 0x64 2161 82 DUP3 2162 01 ADD 2163 52 MSTORE 2164 60 PUSH1 0x84 2166 01 ADD 2167 61 PUSH2 0x0817 216A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2121 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2128 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @212F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @2155 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 // @2163 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @2166 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_216B: // Incoming jump from 0x2115, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2174 stack[-2] } 216B 5B JUMPDEST 216C 60 PUSH1 0x01 216E 60 PUSH1 0x01 2170 60 PUSH1 0xa0 2172 1B SHL 2173 03 SUB 2174 82 DUP3 2175 16 AND 2176 61 PUSH2 0x21cd 2179 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21cd, if stack[-2] & (0x01 << 0xa0) - 0x01 label_217A: // Incoming jump from 0x2179, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @217C memory[0x40:0x60] } 217A 60 PUSH1 0x40 217C 51 MLOAD 217D 62 PUSH3 0x461bcd 2181 60 PUSH1 0xe5 2183 1B SHL 2184 81 DUP2 2185 52 MSTORE 2186 60 PUSH1 0x20 2188 60 PUSH1 0x04 218A 82 DUP3 218B 01 ADD 218C 52 MSTORE 218D 60 PUSH1 0x23 218F 60 PUSH1 0x24 2191 82 DUP3 2192 01 ADD 2193 52 MSTORE 2194 7F PUSH32 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 21B5 60 PUSH1 0x44 21B7 82 DUP3 21B8 01 ADD 21B9 52 MSTORE 21BA 62 PUSH3 0x657373 21BE 60 PUSH1 0xe8 21C0 1B SHL 21C1 60 PUSH1 0x64 21C3 82 DUP3 21C4 01 ADD 21C5 52 MSTORE 21C6 60 PUSH1 0x84 21C8 01 ADD 21C9 61 PUSH2 0x0817 21CC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2185 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @218C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2193 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @21B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 // @21C5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @21C8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_21CD: // Incoming jump from 0x2179, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @21D6 stack[-3] // @21E5 memory[0x00:0x40] // @21E6 storage[keccak256(memory[0x00:0x40])] // @21E7 stack[-1] // } 21CD 5B JUMPDEST 21CE 60 PUSH1 0x01 21D0 60 PUSH1 0x01 21D2 60 PUSH1 0xa0 21D4 1B SHL 21D5 03 SUB 21D6 83 DUP4 21D7 16 AND 21D8 60 PUSH1 0x00 21DA 90 SWAP1 21DB 81 DUP2 21DC 52 MSTORE 21DD 60 PUSH1 0x97 21DF 60 PUSH1 0x20 21E1 52 MSTORE 21E2 60 PUSH1 0x40 21E4 90 SWAP1 21E5 20 SHA3 21E6 54 SLOAD 21E7 81 DUP2 21E8 81 DUP2 21E9 10 LT 21EA 15 ISZERO 21EB 61 PUSH2 0x2245 21EE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21DC memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @21E1 memory[0x20:0x40] = 0x97 // @21E6 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2245, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_21EF: // Incoming jump from 0x21EE, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @21F1 memory[0x40:0x60] } 21EF 60 PUSH1 0x40 21F1 51 MLOAD 21F2 62 PUSH3 0x461bcd 21F6 60 PUSH1 0xe5 21F8 1B SHL 21F9 81 DUP2 21FA 52 MSTORE 21FB 60 PUSH1 0x20 21FD 60 PUSH1 0x04 21FF 82 DUP3 2200 01 ADD 2201 52 MSTORE 2202 60 PUSH1 0x26 2204 60 PUSH1 0x24 2206 82 DUP3 2207 01 ADD 2208 52 MSTORE 2209 7F PUSH32 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 222A 60 PUSH1 0x44 222C 82 DUP3 222D 01 ADD 222E 52 MSTORE 222F 65 PUSH6 0x616c616e6365 2236 60 PUSH1 0xd0 2238 1B SHL 2239 60 PUSH1 0x64 223B 82 DUP3 223C 01 ADD 223D 52 MSTORE 223E 60 PUSH1 0x84 2240 01 ADD 2241 61 PUSH2 0x0817 2244 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @21FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2201 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2208 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @222E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 // @223D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616c616e6365 << 0xd0 // @2240 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_2245: // Incoming jump from 0x21EE, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[7] // { // @224F stack[-4] // @225F memory[0x00:0x40] // @2260 stack[-2] // @2261 stack[-1] // @2266 stack[-3] // @226C memory[0x00:0x40] // @226E storage[keccak256(memory[0x00:0x40])] // } 2245 5B JUMPDEST 2246 60 PUSH1 0x01 2248 60 PUSH1 0x01 224A 60 PUSH1 0xa0 224C 1B SHL 224D 03 SUB 224E 80 DUP1 224F 85 DUP6 2250 16 AND 2251 60 PUSH1 0x00 2253 90 SWAP1 2254 81 DUP2 2255 52 MSTORE 2256 60 PUSH1 0x97 2258 60 PUSH1 0x20 225A 52 MSTORE 225B 60 PUSH1 0x40 225D 80 DUP1 225E 82 DUP3 225F 20 SHA3 2260 85 DUP6 2261 85 DUP6 2262 03 SUB 2263 90 SWAP1 2264 55 SSTORE 2265 91 SWAP2 2266 85 DUP6 2267 16 AND 2268 81 DUP2 2269 52 MSTORE 226A 90 SWAP1 226B 81 DUP2 226C 20 SHA3 226D 80 DUP1 226E 54 SLOAD 226F 84 DUP5 2270 92 SWAP3 2271 90 SWAP1 2272 61 PUSH2 0x227c 2275 90 SWAP1 2276 84 DUP5 2277 90 SWAP1 2278 61 PUSH2 0x3f5f 227B 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @2255 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @225A memory[0x20:0x40] = 0x97 // @2264 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @2269 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @226C stack[1] = keccak256(memory[0x00:0x40]) // @2270 stack[0] = stack[-2] // @2271 stack[2] = 0x00 // @2275 stack[3] = 0x227c // @2277 stack[4] = stack[-2] // @2277 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3f5f, returns to 0x227C label_227C: // Incoming return from call to 0x3F5F at 0x227B // Inputs[7] // { // @227D stack[-4] // @227D stack[-1] // @2281 stack[-3] // @2284 stack[-7] // @228E stack[-8] // @22B9 stack[-6] // @22BC memory[0x40:0x60] // } 227C 5B JUMPDEST 227D 92 SWAP3 227E 50 POP 227F 50 POP 2280 81 DUP2 2281 90 SWAP1 2282 55 SSTORE 2283 50 POP 2284 82 DUP3 2285 60 PUSH1 0x01 2287 60 PUSH1 0x01 2289 60 PUSH1 0xa0 228B 1B SHL 228C 03 SUB 228D 16 AND 228E 84 DUP5 228F 60 PUSH1 0x01 2291 60 PUSH1 0x01 2293 60 PUSH1 0xa0 2295 1B SHL 2296 03 SUB 2297 16 AND 2298 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 22B9 84 DUP5 22BA 60 PUSH1 0x40 22BC 51 MLOAD 22BD 61 PUSH2 0x22c8 22C0 91 SWAP2 22C1 81 DUP2 22C2 52 MSTORE 22C3 60 PUSH1 0x20 22C5 01 ADD 22C6 90 SWAP1 22C7 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @2282 storage[stack[-3]] = stack[-1] // @228D stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-7] // @2297 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-8] // @2298 stack[-2] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @22C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6] // @22C6 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x22c8 label_22C8: // Incoming jump from 0x22C7 // Inputs[6] // { // @22CB memory[0x40:0x60] // @22CD stack[-1] // @22D0 stack[-4] // @22D0 stack[-2] // @22D0 stack[-3] // @22D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 22C8 5B JUMPDEST 22C9 60 PUSH1 0x40 22CB 51 MLOAD 22CC 80 DUP1 22CD 91 SWAP2 22CE 03 SUB 22CF 90 SWAP1 22D0 A3 LOG3 // Stack delta = -4 // Outputs[1] { @22D0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block continues label_22D1: // Incoming jump from 0x39C2, if !(stack[-1] > stack[-4]) // Incoming jump from 0x22D0 // Incoming return from call to 0x1DC0 at 0x2898 // Incoming jump from 0x283C, if stack[-1] == ~0x00 // Inputs[1] { @22D6 stack[-5] } 22D1 5B JUMPDEST 22D2 50 POP 22D3 50 POP 22D4 50 POP 22D5 50 POP 22D6 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_22D7: // Incoming call from 0x26B7, returns to 0x26B8 // Incoming call from 0x1C90, returns to 0x1C91 // Incoming call from 0x2D7F, returns to 0x2D80 // Incoming call from 0x1D38, returns to 0x1D39 // Incoming call from 0x1248, returns to 0x1249 // Incoming call from 0x07D8, returns to 0x07D9 // Inputs[1] { @22DE stack[-2] } 22D7 5B JUMPDEST 22D8 60 PUSH1 0x00 22DA 80 DUP1 22DB 61 PUSH2 0x22e3 22DE 84 DUP5 22DF 61 PUSH2 0x1371 22E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22D8 stack[0] = 0x00 // @22DA stack[1] = 0x00 // @22DB stack[2] = 0x22e3 // @22DE stack[3] = stack[-2] // } // Block ends with call to 0x1371, returns to 0x22E3 label_22E3: // Incoming return from call to 0x1371 at 0x22E2 // Inputs[4] // { // @22E7 storage[0x0173] // @22EB storage[0x016d] // @22EC stack[-1] // @22ED stack[-2] // } 22E3 5B JUMPDEST 22E4 61 PUSH2 0x0173 22E7 54 SLOAD 22E8 61 PUSH2 0x016d 22EB 54 SLOAD 22EC 91 SWAP2 22ED 92 SWAP3 22EE 50 POP 22EF 61 PUSH2 0x22f7 22F2 91 SWAP2 22F3 61 PUSH2 0x3f5f 22F6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @22E7 stack[0] = storage[0x0173] // @22ED stack[-2] = stack[-1] // @22F2 stack[1] = storage[0x016d] // @22F2 stack[-1] = 0x22f7 // } // Block ends with call to 0x3f5f, returns to 0x22F7 label_22F7: // Incoming return from call to 0x3F5F at 0x22F6 // Inputs[2] // { // @22F8 stack[-5] // @22F9 stack[-1] // } 22F7 5B JUMPDEST 22F8 84 DUP5 22F9 11 GT 22FA 61 PUSH2 0x2339 22FD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2339, if stack[-5] > stack[-1] label_22FE: // Incoming jump from 0x22FD, if not stack[-5] > stack[-1] // Inputs[2] // { // @2301 storage[0x0173] // @2305 storage[0x016d] // } 22FE 61 PUSH2 0x0173 2301 54 SLOAD 2302 61 PUSH2 0x016d 2305 54 SLOAD 2306 61 PUSH2 0x230f 2309 91 SWAP2 230A 90 SWAP1 230B 61 PUSH2 0x3f5f 230E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2309 stack[0] = 0x230f // @230A stack[1] = storage[0x0173] // @230A stack[2] = storage[0x016d] // } // Block ends with call to 0x3f5f, returns to 0x230F label_230F: // Incoming return from call to 0x3F5F at 0x230E // Inputs[2] // { // @2310 stack[-4] // @2311 stack[-1] // } 230F 5B JUMPDEST 2310 83 DUP4 2311 11 GT 2312 15 ISZERO 2313 61 PUSH2 0x232f 2316 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x232f, if !(stack[-4] > stack[-1]) label_2317: // Incoming jump from 0x2316, if not !(stack[-4] > stack[-1]) // Inputs[2] // { // @231A storage[0x0173] // @231E storage[0x016d] // } 2317 61 PUSH2 0x0173 231A 54 SLOAD 231B 61 PUSH2 0x016d 231E 54 SLOAD 231F 61 PUSH2 0x2328 2322 91 SWAP2 2323 90 SWAP1 2324 61 PUSH2 0x3f5f 2327 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2322 stack[0] = 0x2328 // @2323 stack[1] = storage[0x0173] // @2323 stack[2] = storage[0x016d] // } // Block ends with call to 0x3f5f, returns to 0x2328 label_2328: // Incoming return from call to 0x3F5F at 0x2327 // Inputs[2] // { // @2329 stack[-5] // @2329 stack[-1] // } 2328 5B JUMPDEST 2329 93 SWAP4 232A 50 POP 232B 61 PUSH2 0x2339 232E 56 *JUMP // Stack delta = -1 // Outputs[1] { @2329 stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x2339 label_232F: // Incoming jump from 0x2316, if !(stack[-4] > stack[-1]) // Inputs[1] { @2332 stack[-2] } 232F 5B JUMPDEST 2330 60 PUSH1 0x00 2332 91 SWAP2 2333 50 POP 2334 50 POP 2335 61 PUSH2 0x06a1 2338 56 *JUMP // Stack delta = -1 // Outputs[1] { @2332 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x06a1 label_2339: // Incoming jump from 0x232E // Incoming jump from 0x22FD, if stack[-5] > stack[-1] // Inputs[2] // { // @233A stack[-3] // @233B stack[-4] // } 2339 5B JUMPDEST 233A 82 DUP3 233B 84 DUP5 233C 11 GT 233D 61 PUSH2 0x23d9 2340 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23d9, if stack[-4] > stack[-3] label_2341: // Incoming jump from 0x2340, if not stack[-4] > stack[-3] // Inputs[2] // { // @2341 stack[-1] // @2342 stack[-3] // } 2341 80 DUP1 2342 83 DUP4 2343 10 LT 2344 15 ISZERO 2345 61 PUSH2 0x236c 2348 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x236c, if !(stack[-3] < stack[-1]) label_2349: // Incoming jump from 0x2348, if not !(stack[-3] < stack[-1]) // Inputs[1] { @234C stack[-4] } 2349 61 PUSH2 0x2351 234C 84 DUP5 234D 61 PUSH2 0x1d67 2350 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2349 stack[0] = 0x2351 // @234C stack[1] = stack[-4] // } // Block ends with call to 0x1d67, returns to 0x2351 label_2351: // Incoming return from call to 0x1D67 at 0x2350 // Inputs[2] // { // @2355 stack[-5] // @2356 stack[-4] // } 2351 5B JUMPDEST 2352 61 PUSH2 0x235b 2355 85 DUP6 2356 85 DUP6 2357 61 PUSH2 0x3f77 235A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2352 stack[0] = 0x235b // @2355 stack[1] = stack[-5] // @2356 stack[2] = stack[-4] // } // Block ends with call to 0x3f77, returns to 0x235B label_235B: // Incoming return from call to 0x3F77 at 0x235A // Inputs[2] // { // @235F stack[-2] // @2360 stack[-1] // } 235B 5B JUMPDEST 235C 61 PUSH2 0x2365 235F 91 SWAP2 2360 90 SWAP1 2361 61 PUSH2 0x3fa7 2364 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @235F stack[-2] = 0x2365 // @2360 stack[-1] = stack[-2] // @2360 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x2365 label_2365: // Incoming return from call to 0x3FA7 at 0x2364 // Inputs[2] // { // @2366 stack[-3] // @2366 stack[-1] // } 2365 5B JUMPDEST 2366 91 SWAP2 2367 50 POP 2368 61 PUSH2 0x23d9 236B 56 *JUMP // Stack delta = -1 // Outputs[1] { @2366 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x23d9 label_236C: // Incoming jump from 0x2348, if !(stack[-3] < stack[-1]) // Incoming jump from 0x23AE // Inputs[2] // { // @236D stack[-1] // @236E stack[-3] // } 236C 5B JUMPDEST 236D 80 DUP1 236E 83 DUP4 236F 10 LT 2370 61 PUSH2 0x23af 2373 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23af, if stack[-3] < stack[-1] label_2374: // Incoming jump from 0x2373, if not stack[-3] < stack[-1] // Inputs[1] { @2377 stack[-4] } 2374 61 PUSH2 0x237c 2377 84 DUP5 2378 61 PUSH2 0x1d67 237B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2374 stack[0] = 0x237c // @2377 stack[1] = stack[-4] // } // Block ends with call to 0x1d67, returns to 0x237C label_237C: // Incoming return from call to 0x1D67 at 0x237B // Inputs[2] // { // @2380 stack[-5] // @2381 stack[-2] // } 237C 5B JUMPDEST 237D 61 PUSH2 0x2386 2380 85 DUP6 2381 83 DUP4 2382 61 PUSH2 0x3f77 2385 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @237D stack[0] = 0x2386 // @2380 stack[1] = stack[-5] // @2381 stack[2] = stack[-2] // } // Block ends with call to 0x3f77, returns to 0x2386 label_2386: // Incoming return from call to 0x3F77 at 0x2385 // Inputs[2] // { // @238A stack[-2] // @238B stack[-1] // } 2386 5B JUMPDEST 2387 61 PUSH2 0x2390 238A 91 SWAP2 238B 90 SWAP1 238C 61 PUSH2 0x3fa7 238F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @238A stack[-2] = 0x2390 // @238B stack[-1] = stack[-2] // @238B stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x2390 label_2390: // Incoming return from call to 0x3FA7 at 0x238F // Inputs[2] // { // @2394 stack[-1] // @2395 stack[-3] // } 2390 5B JUMPDEST 2391 61 PUSH2 0x239a 2394 90 SWAP1 2395 83 DUP4 2396 61 PUSH2 0x3f5f 2399 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2394 stack[0] = stack[-1] // @2394 stack[-1] = 0x239a // @2395 stack[1] = stack[-3] // } // Block ends with call to 0x3f5f, returns to 0x239A label_239A: // Incoming return from call to 0x3F5F at 0x2399 // Inputs[4] // { // @239B stack[-1] // @239B stack[-3] // @239D stack[-2] // @239E stack[-5] // } 239A 5B JUMPDEST 239B 91 SWAP2 239C 50 POP 239D 80 DUP1 239E 93 SWAP4 239F 50 POP 23A0 61 PUSH2 0x23a8 23A3 81 DUP2 23A4 61 PUSH2 0x1371 23A7 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @239B stack[-3] = stack[-1] // @239E stack[-5] = stack[-2] // @23A0 stack[-1] = 0x23a8 // @23A3 stack[0] = stack[-2] // } // Block ends with call to 0x1371, returns to 0x23A8 label_23A8: // Incoming return from call to 0x1371 at 0x23A7 // Inputs[2] // { // @23A9 stack[-2] // @23A9 stack[-1] // } 23A8 5B JUMPDEST 23A9 90 SWAP1 23AA 50 POP 23AB 61 PUSH2 0x236c 23AE 56 *JUMP // Stack delta = -1 // Outputs[1] { @23A9 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x236c label_23AF: // Incoming jump from 0x2373, if stack[-3] < stack[-1] // Inputs[1] { @23B3 stack[-3] } 23AF 5B JUMPDEST 23B0 61 PUSH2 0x23b8 23B3 83 DUP4 23B4 61 PUSH2 0x1d67 23B7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23B0 stack[0] = 0x23b8 // @23B3 stack[1] = stack[-3] // } // Block ends with call to 0x1d67, returns to 0x23B8 label_23B8: // Incoming return from call to 0x1D67 at 0x23B7 // Inputs[2] // { // @23BC stack[-5] // @23BD stack[-4] // } 23B8 5B JUMPDEST 23B9 61 PUSH2 0x23c2 23BC 85 DUP6 23BD 85 DUP6 23BE 61 PUSH2 0x3f77 23C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23B9 stack[0] = 0x23c2 // @23BC stack[1] = stack[-5] // @23BD stack[2] = stack[-4] // } // Block ends with call to 0x3f77, returns to 0x23C2 label_23C2: // Incoming return from call to 0x3F77 at 0x23C1 // Inputs[2] // { // @23C6 stack[-2] // @23C7 stack[-1] // } 23C2 5B JUMPDEST 23C3 61 PUSH2 0x23cc 23C6 91 SWAP2 23C7 90 SWAP1 23C8 61 PUSH2 0x3fa7 23CB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @23C6 stack[-2] = 0x23cc // @23C7 stack[-1] = stack[-2] // @23C7 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x23CC label_23CC: // Incoming return from call to 0x3FA7 at 0x23CB // Inputs[2] // { // @23D0 stack[-1] // @23D1 stack[-3] // } 23CC 5B JUMPDEST 23CD 61 PUSH2 0x23d6 23D0 90 SWAP1 23D1 83 DUP4 23D2 61 PUSH2 0x3f5f 23D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23D0 stack[0] = stack[-1] // @23D0 stack[-1] = 0x23d6 // @23D1 stack[1] = stack[-3] // } // Block ends with call to 0x3f5f, returns to 0x23D6 label_23D6: // Incoming return from call to 0x3F5F at 0x23D5 // Inputs[2] // { // @23D7 stack[-1] // @23D7 stack[-3] // } 23D6 5B JUMPDEST 23D7 91 SWAP2 23D8 50 POP // Stack delta = -1 // Outputs[1] { @23D7 stack[-3] = stack[-1] } // Block continues label_23D9: // Incoming jump from 0x2340, if stack[-4] > stack[-3] // Incoming jump from 0x23D8 // Incoming jump from 0x236B // Inputs[3] // { // @23DB stack[-2] // @23DB stack[-5] // @23DC stack[-4] // } 23D9 5B JUMPDEST 23DA 50 POP 23DB 92 SWAP3 23DC 91 SWAP2 23DD 50 POP 23DE 50 POP 23DF 56 *JUMP // Stack delta = -4 // Outputs[1] { @23DB stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_23E0: // Incoming call from 0x088B, returns to 0x088C // Inputs[3] // { // @23E3 stack[-1] // @23E7 storage[0x01 + stack[-1]] // @23F8 stack[-2] // } 23E0 5B JUMPDEST 23E1 60 PUSH1 0x01 23E3 90 SWAP1 23E4 81 DUP2 23E5 01 ADD 23E6 80 DUP1 23E7 54 SLOAD 23E8 67 PUSH8 0xffffffffffffffff 23F1 19 NOT 23F2 16 AND 23F3 90 SWAP1 23F4 91 SWAP2 23F5 17 OR 23F6 90 SWAP1 23F7 55 SSTORE 23F8 56 *JUMP // Stack delta = -2 // Outputs[1] { @23F7 storage[0x01 + stack[-1]] = 0x01 | (~0xffffffffffffffff & storage[0x01 + stack[-1]]) } // Block ends with unconditional jump to stack[-2] label_23F9: // Incoming call from 0x1777, returns to 0x1778 // Incoming call from 0x0895, returns to 0x0896 // Inputs[3] // { // @2402 stack[-2] // @2412 memory[0x00:0x40] // @2416 storage[0x02 + keccak256(memory[0x00:0x40])] // } 23F9 5B JUMPDEST 23FA 60 PUSH1 0x01 23FC 60 PUSH1 0x01 23FE 60 PUSH1 0xa0 2400 1B SHL 2401 03 SUB 2402 82 DUP3 2403 16 AND 2404 60 PUSH1 0x00 2406 90 SWAP1 2407 81 DUP2 2408 52 MSTORE 2409 61 PUSH2 0x0166 240C 60 PUSH1 0x20 240E 52 MSTORE 240F 60 PUSH1 0x40 2411 81 DUP2 2412 20 SHA3 2413 60 PUSH1 0x02 2415 01 ADD 2416 54 SLOAD 2417 63 PUSH4 0xffffffff 241C 60 PUSH1 0x01 241E 60 PUSH1 0x20 2420 1B SHL 2421 82 DUP3 2422 04 DIV 2423 81 DUP2 2424 16 AND 2425 91 SWAP2 2426 16 AND 2427 5B JUMPDEST 2428 81 DUP2 2429 63 PUSH4 0xffffffff 242E 16 AND 242F 81 DUP2 2430 11 GT 2431 61 PUSH2 0x24be 2434 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2406 stack[0] = 0x00 // @2408 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @240E memory[0x20:0x40] = 0x0166 // @2425 stack[1] = 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // @2426 stack[2] = storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // } // Block ends with conditional jump to 0x24be, if storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) label_2435: // Incoming jump from 0x2434, if not storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // Incoming jump from 0x2434, if not stack[-1] > 0xffffffff & stack[-2] // Inputs[6] // { // @243D stack[-5] // @2450 memory[0x00:0x40] // @2451 stack[-1] // @245B memory[0x00:0x40] // @245C storage[keccak256(memory[0x00:0x40])] // @2463 stack[-4] // } 2435 60 PUSH1 0x01 2437 60 PUSH1 0x01 2439 60 PUSH1 0xa0 243B 1B SHL 243C 03 SUB 243D 85 DUP6 243E 16 AND 243F 60 PUSH1 0x00 2441 90 SWAP1 2442 81 DUP2 2443 52 MSTORE 2444 61 PUSH2 0x0166 2447 60 PUSH1 0x20 2449 90 SWAP1 244A 81 DUP2 244B 52 MSTORE 244C 60 PUSH1 0x40 244E 80 DUP1 244F 83 DUP4 2450 20 SHA3 2451 84 DUP5 2452 84 DUP5 2453 52 MSTORE 2454 60 PUSH1 0x01 2456 01 ADD 2457 90 SWAP1 2458 91 SWAP2 2459 52 MSTORE 245A 90 SWAP1 245B 20 SHA3 245C 54 SLOAD 245D 63 PUSH4 0xffffffff 2462 16 AND 2463 84 DUP5 2464 11 GT 2465 15 ISZERO 2466 61 PUSH2 0x24b1 2469 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2443 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @244B memory[0x20:0x40] = 0x0166 // @2453 memory[0x00:0x20] = stack[-1] // @2459 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x24b1, if !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) label_246A: // Incoming jump from 0x2469, if not !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2472 stack[-5] // @2482 memory[0x00:0x40] // } 246A 60 PUSH1 0x01 246C 60 PUSH1 0x01 246E 60 PUSH1 0xa0 2470 1B SHL 2471 03 SUB 2472 85 DUP6 2473 16 AND 2474 60 PUSH1 0x00 2476 90 SWAP1 2477 81 DUP2 2478 52 MSTORE 2479 61 PUSH2 0x0166 247C 60 PUSH1 0x20 247E 52 MSTORE 247F 60 PUSH1 0x40 2481 81 DUP2 2482 20 SHA3 2483 61 PUSH2 0x248e 2486 90 SWAP1 2487 60 PUSH1 0x01 2489 01 ADD 248A 61 PUSH2 0x2ec3 248D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2476 stack[0] = 0x00 // @2478 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @247E memory[0x20:0x40] = 0x0166 // @2486 stack[1] = 0x248e // @2489 stack[2] = 0x01 + keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2ec3, returns to 0x248E label_248E: // Incoming return from call to 0x2EC3 at 0x248D // Inputs[4] // { // @248F stack[-2] // @248F stack[-1] // @2495 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @249F stack[-5] // } 248E 5B JUMPDEST 248F 90 SWAP1 2490 50 POP 2491 80 DUP1 2492 60 PUSH1 0x20 2494 01 ADD 2495 51 MLOAD 2496 60 PUSH1 0x01 2498 60 PUSH1 0x01 249A 60 PUSH1 0x60 249C 1B SHL 249D 03 SUB 249E 16 AND 249F 84 DUP5 24A0 61 PUSH2 0x24a9 24A3 91 SWAP2 24A4 90 SWAP1 24A5 61 PUSH2 0x3f5f 24A8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @248F stack[-2] = stack[-1] // @24A3 stack[-1] = 0x24a9 // @24A4 stack[1] = stack[-5] // @24A4 stack[0] = (0x01 << 0x60) - 0x01 & memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } // Block ends with call to 0x3f5f, returns to 0x24A9 label_24A9: // Incoming return from call to 0x3F5F at 0x24A8 // Inputs[2] // { // @24AA stack[-5] // @24AA stack[-1] // } 24A9 5B JUMPDEST 24AA 93 SWAP4 24AB 50 POP 24AC 50 POP 24AD 61 PUSH2 0x24b6 24B0 56 *JUMP // Stack delta = -2 // Outputs[1] { @24AA stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x24b6 label_24B1: // Incoming jump from 0x2E4F, if !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2469, if !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) 24B1 5B JUMPDEST 24B2 61 PUSH2 0x24be 24B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x24be label_24B6: // Incoming jump from 0x24B0 // Inputs[1] { @24B9 stack[-1] } 24B6 5B JUMPDEST 24B7 60 PUSH1 0x01 24B9 01 ADD 24BA 61 PUSH2 0x2427 24BD 56 *JUMP // Stack delta = +0 // Outputs[1] { @24B9 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2427 label_24BE: // Incoming jump from 0x24B5 // Incoming jump from 0x2E1A, if storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // Incoming jump from 0x2434, if storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // Incoming jump from 0x2434, if stack[-1] > 0xffffffff & stack[-2] // Incoming jump from 0x2E1A, if stack[-1] > 0xffffffff & stack[-2] // Inputs[3] // { // @24C1 stack[-6] // @24C1 stack[-3] // @24C2 stack[-5] // } 24BE 5B JUMPDEST 24BF 50 POP 24C0 50 POP 24C1 92 SWAP3 24C2 91 SWAP2 24C3 50 POP 24C4 50 POP 24C5 56 *JUMP // Stack delta = -5 // Outputs[1] { @24C1 stack[-6] = stack[-3] } // Block ends with unconditional jump to stack[-6] label_24C6: // Incoming jump from 0x08DD // Inputs[1] { @24CE stack[-1] } 24C6 5B JUMPDEST 24C7 60 PUSH1 0x00 24C9 63 PUSH4 0xffffffff 24CE 82 DUP3 24CF 11 GT 24D0 15 ISZERO 24D1 61 PUSH2 0x252b 24D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24C7 stack[0] = 0x00 } // Block ends with conditional jump to 0x252b, if !(stack[-1] > 0xffffffff) label_24D5: // Incoming jump from 0x24D4, if not !(stack[-1] > 0xffffffff) // Inputs[1] { @24D7 memory[0x40:0x60] } 24D5 60 PUSH1 0x40 24D7 51 MLOAD 24D8 62 PUSH3 0x461bcd 24DC 60 PUSH1 0xe5 24DE 1B SHL 24DF 81 DUP2 24E0 52 MSTORE 24E1 60 PUSH1 0x20 24E3 60 PUSH1 0x04 24E5 82 DUP3 24E6 01 ADD 24E7 52 MSTORE 24E8 60 PUSH1 0x26 24EA 60 PUSH1 0x24 24EC 82 DUP3 24ED 01 ADD 24EE 52 MSTORE 24EF 7F PUSH32 0x53616665436173743a2076616c756520646f65736e27742066697420696e2033 2510 60 PUSH1 0x44 2512 82 DUP3 2513 01 ADD 2514 52 MSTORE 2515 65 PUSH6 0x322062697473 251C 60 PUSH1 0xd0 251E 1B SHL 251F 60 PUSH1 0x64 2521 82 DUP3 2522 01 ADD 2523 52 MSTORE 2524 60 PUSH1 0x84 2526 01 ADD 2527 61 PUSH2 0x0817 252A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @24E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @24E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @24EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @2514 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53616665436173743a2076616c756520646f65736e27742066697420696e2033 // @2523 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x322062697473 << 0xd0 // @2526 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_252B: // Incoming jump from 0x2540, if !(stack[-1] > (0x01 << 0x60) - 0x01) // Incoming call from 0x3969, returns to 0x252B, if !(stack[-4] > stack[-2]) // Incoming return from call to 0x252B at 0x3969 // Incoming jump from 0x3969, if !(stack[-2] > stack[-1]) // Incoming jump from 0x24D4, if !(stack[-1] > 0xffffffff) // Inputs[2] // { // @252D stack[-3] // @252D stack[-2] // } 252B 5B JUMPDEST 252C 50 POP 252D 90 SWAP1 252E 56 *JUMP // Stack delta = -2 // Outputs[1] { @252D stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_252F: // Incoming call from 0x17F9, returns to 0x17FA // Incoming call from 0x09B6, returns to 0x09B7 // Inputs[1] { @253A stack[-1] } 252F 5B JUMPDEST 2530 60 PUSH1 0x00 2532 60 PUSH1 0x01 2534 60 PUSH1 0x01 2536 60 PUSH1 0x60 2538 1B SHL 2539 03 SUB 253A 82 DUP3 253B 11 GT 253C 15 ISZERO 253D 61 PUSH2 0x252b 2540 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2530 stack[0] = 0x00 } // Block ends with conditional jump to 0x252b, if !(stack[-1] > (0x01 << 0x60) - 0x01) label_2541: // Incoming jump from 0x2540, if not !(stack[-1] > (0x01 << 0x60) - 0x01) // Inputs[1] { @2543 memory[0x40:0x60] } 2541 60 PUSH1 0x40 2543 51 MLOAD 2544 62 PUSH3 0x461bcd 2548 60 PUSH1 0xe5 254A 1B SHL 254B 81 DUP2 254C 52 MSTORE 254D 60 PUSH1 0x20 254F 60 PUSH1 0x04 2551 82 DUP3 2552 01 ADD 2553 52 MSTORE 2554 60 PUSH1 0x26 2556 60 PUSH1 0x24 2558 82 DUP3 2559 01 ADD 255A 52 MSTORE 255B 7F PUSH32 0x53616665436173743a2076616c756520646f65736e27742066697420696e2039 257C 60 PUSH1 0x44 257E 82 DUP3 257F 01 ADD 2580 52 MSTORE 2581 65 PUSH6 0x362062697473 2588 60 PUSH1 0xd0 258A 1B SHL 258B 60 PUSH1 0x64 258D 82 DUP3 258E 01 ADD 258F 52 MSTORE 2590 60 PUSH1 0x84 2592 01 ADD 2593 61 PUSH2 0x0817 2596 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @254C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2553 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @255A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @2580 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53616665436173743a2076616c756520646f65736e27742066697420696e2039 // @258F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x362062697473 << 0xd0 // @2592 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_2597: // Incoming call from 0x0A08, returns to 0x0A09 // Incoming call from 0x09D4, returns to 0x09D5 // Inputs[6] // { // @259A memory[0x40:0x60] // @25A3 stack[-3] // @25AF stack[-2] // @25BE stack[-1] // @25C8 stack[-4] // @25D7 storage[0x01 + stack[-4]] // } 2597 5B JUMPDEST 2598 60 PUSH1 0x40 259A 51 MLOAD 259B 80 DUP1 259C 60 PUSH1 0x60 259E 01 ADD 259F 60 PUSH1 0x40 25A1 52 MSTORE 25A2 80 DUP1 25A3 84 DUP5 25A4 63 PUSH4 0xffffffff 25A9 16 AND 25AA 81 DUP2 25AB 52 MSTORE 25AC 60 PUSH1 0x20 25AE 01 ADD 25AF 83 DUP4 25B0 60 PUSH1 0x01 25B2 60 PUSH1 0x01 25B4 60 PUSH1 0x60 25B6 1B SHL 25B7 03 SUB 25B8 16 AND 25B9 81 DUP2 25BA 52 MSTORE 25BB 60 PUSH1 0x20 25BD 01 ADD 25BE 82 DUP3 25BF 63 PUSH4 0xffffffff 25C4 16 AND 25C5 81 DUP2 25C6 52 MSTORE 25C7 50 POP 25C8 84 DUP5 25C9 60 PUSH1 0x00 25CB 01 ADD 25CC 60 PUSH1 0x00 25CE 86 DUP7 25CF 60 PUSH1 0x01 25D1 01 ADD 25D2 60 PUSH1 0x04 25D4 81 DUP2 25D5 81 DUP2 25D6 90 SWAP1 25D7 54 SLOAD 25D8 90 SWAP1 25D9 61 PUSH2 0x0100 25DC 0A EXP 25DD 90 SWAP1 25DE 04 DIV 25DF 63 PUSH4 0xffffffff 25E4 16 AND 25E5 61 PUSH2 0x25ed 25E8 90 SWAP1 25E9 61 PUSH2 0x4276 25EC 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @259A stack[0] = memory[0x40:0x60] // @25A1 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @25AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffff & stack[-3] // @25BA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x01 << 0x60) - 0x01 & stack[-2] // @25C6 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xffffffff & stack[-1] // @25CB stack[1] = 0x00 + stack[-4] // @25CC stack[2] = 0x00 // @25D1 stack[3] = 0x01 + stack[-4] // @25D2 stack[4] = 0x04 // @25E8 stack[5] = 0x25ed // @25E8 stack[6] = 0xffffffff & storage[0x01 + stack[-4]] / 0x0100 ** 0x04 // } // Block ends with call to 0x4276, returns to 0x25ED label_25ED: // Incoming return from call to 0x4276 at 0x25EC // Inputs[13] // { // @25EE stack[-3] // @25EF storage[stack[-3]] // @25F5 stack[-1] // @25FB stack[-2] // @260D stack[-4] // @2614 stack[-5] // @261F memory[0x00:0x00 + 0x40 + stack[-4]] // @2620 stack[-6] // @2621 memory[stack[-6]:stack[-6] + 0x20] // @2623 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] // @2627 memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @262C memory[0x40 + stack[-6]:0x40 + stack[-6] + 0x20] // @2672 stack[-11] // } 25ED 5B JUMPDEST 25EE 82 DUP3 25EF 54 SLOAD 25F0 63 PUSH4 0xffffffff 25F5 91 SWAP2 25F6 82 DUP3 25F7 16 AND 25F8 61 PUSH2 0x0100 25FB 93 SWAP4 25FC 90 SWAP1 25FD 93 SWAP4 25FE 0A EXP 25FF 83 DUP4 2600 81 DUP2 2601 02 MUL 2602 90 SWAP1 2603 83 DUP4 2604 02 MUL 2605 19 NOT 2606 90 SWAP1 2607 91 SWAP2 2608 16 AND 2609 17 OR 260A 90 SWAP1 260B 92 SWAP3 260C 55 SSTORE 260D 82 DUP3 260E 52 MSTORE 260F 60 PUSH1 0x20 2611 80 DUP1 2612 83 DUP4 2613 01 ADD 2614 93 SWAP4 2615 90 SWAP1 2616 93 SWAP4 2617 52 MSTORE 2618 60 PUSH1 0x40 261A 91 SWAP2 261B 82 DUP3 261C 01 ADD 261D 60 PUSH1 0x00 261F 20 SHA3 2620 84 DUP5 2621 51 MLOAD 2622 81 DUP2 2623 54 SLOAD 2624 94 SWAP5 2625 86 DUP7 2626 01 ADD 2627 51 MLOAD 2628 95 SWAP6 2629 90 SWAP1 262A 93 SWAP4 262B 01 ADD 262C 51 MLOAD 262D 82 DUP3 262E 16 AND 262F 60 PUSH1 0x01 2631 60 PUSH1 0x80 2633 1B SHL 2634 02 MUL 2635 63 PUSH4 0xffffffff 263A 60 PUSH1 0x80 263C 1B SHL 263D 19 NOT 263E 60 PUSH1 0x01 2640 60 PUSH1 0x01 2642 60 PUSH1 0x60 2644 1B SHL 2645 03 SUB 2646 90 SWAP1 2647 96 SWAP7 2648 16 AND 2649 60 PUSH1 0x01 264B 60 PUSH1 0x20 264D 1B SHL 264E 02 MUL 264F 60 PUSH1 0x01 2651 60 PUSH1 0x01 2653 60 PUSH1 0x80 2655 1B SHL 2656 03 SUB 2657 19 NOT 2658 90 SWAP1 2659 95 SWAP6 265A 16 AND 265B 93 SWAP4 265C 90 SWAP1 265D 92 SWAP3 265E 16 AND 265F 92 SWAP3 2660 90 SWAP1 2661 92 SWAP3 2662 17 OR 2663 92 SWAP3 2664 90 SWAP1 2665 92 SWAP3 2666 17 OR 2667 92 SWAP3 2668 90 SWAP1 2669 92 SWAP3 266A 16 AND 266B 17 OR 266C 90 SWAP1 266D 55 SSTORE 266E 50 POP 266F 50 POP 2670 50 POP 2671 50 POP 2672 56 *JUMP // Stack delta = -11 // Outputs[4] // { // @260C storage[stack[-3]] = (storage[stack[-3]] & ~(0xffffffff * 0x0100 ** stack[-2])) | 0x0100 ** stack[-2] * (0xffffffff & stack[-1]) // @260E memory[stack[-4]:stack[-4] + 0x20] = 0xffffffff & stack[-1] // @2617 memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] = stack[-5] // @266D storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] = (((0xffffffff & memory[stack[-6]:stack[-6] + 0x20]) | (storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-4]])] & ~((0x01 << 0x80) - 0x01)) | (0x01 << 0x20) * (memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01)) & ~(0xffffffff << 0x80)) | (0x01 << 0x80) * (0xffffffff & memory[0x40 + stack[-6]:0x40 + stack[-6] + 0x20]) // } // Block ends with unconditional jump to stack[-11] label_2673: // Incoming call from 0x0A5E, returns to 0x0A5F // Incoming call from 0x2CFF, returns to 0x2D00 // Incoming call from 0x2EE9, returns to 0x2EEA // Incoming call from 0x1C1D, returns to 0x1C1E // Incoming call from 0x1C1D, returns to 0x1C1E // Inputs[1] { @2679 stack[-1] } 2673 5B JUMPDEST 2674 60 PUSH1 0x00 2676 61 PUSH2 0x267e 2679 82 DUP3 267A 61 PUSH2 0x2c8c 267D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2674 stack[0] = 0x00 // @2676 stack[1] = 0x267e // @2679 stack[2] = stack[-1] // } // Block ends with call to 0x2c8c, returns to 0x267E label_267E: // Incoming return from call to 0x2C8C at 0x267D // Incoming return from call to 0x2C8C at 0x267D // Inputs[3] // { // @267F stack[-1] // @2680 stack[-4] // @2681 stack[-3] // } 267E 5B JUMPDEST 267F 15 ISZERO 2680 92 SWAP3 2681 91 SWAP2 2682 50 POP 2683 50 POP 2684 56 *JUMP // Stack delta = -3 // Outputs[1] { @2680 stack[-4] = !stack[-1] } // Block ends with unconditional jump to stack[-4] label_2685: // Incoming call from 0x0A9D, returns to 0x0A9E // Incoming jump from 0x13F7 // Inputs[1] { @268F stack[-1] } 2685 5B JUMPDEST 2686 60 PUSH1 0x00 2688 80 DUP1 2689 60 PUSH1 0x00 268B 80 DUP1 268C 61 PUSH2 0x2694 268F 85 DUP6 2690 61 PUSH2 0x2ce9 2693 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2686 stack[0] = 0x00 // @2688 stack[1] = 0x00 // @2689 stack[2] = 0x00 // @268B stack[3] = 0x00 // @268C stack[4] = 0x2694 // @268F stack[5] = stack[-1] // } // Block ends with call to 0x2ce9, returns to 0x2694 label_2694: // Incoming return from call to 0x2CE9 at 0x2693 // Inputs[6] // { // @2695 stack[-3] // @2695 stack[-1] // @2696 stack[-6] // @2698 stack[-5] // @2698 stack[-2] // @269A stack[-4] // } 2694 5B JUMPDEST 2695 91 SWAP2 2696 94 SWAP5 2697 50 POP 2698 92 SWAP3 2699 50 POP 269A 90 SWAP1 269B 50 POP 269C 81 DUP2 269D 15 ISZERO 269E 61 PUSH2 0x26d9 26A1 57 *JUMPI // Stack delta = -3 // Outputs[3] // { // @2696 stack[-6] = stack[-3] // @2698 stack[-5] = stack[-2] // @269A stack[-4] = stack[-1] // } // Block ends with conditional jump to 0x26d9, if !stack[-2] label_26A2: // Incoming jump from 0x26A1, if not !stack[-2] // Inputs[3] // { // @26A2 stack[-2] // @26B2 stack[-1] // @26B3 stack[-5] // } 26A2 81 DUP2 26A3 6A PUSH11 0x084595161401484a000000 26AF 61 PUSH2 0x26b8 26B2 83 DUP4 26B3 88 DUP9 26B4 61 PUSH2 0x22d7 26B7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @26A2 stack[0] = stack[-2] // @26A3 stack[1] = 0x084595161401484a000000 // @26AF stack[2] = 0x26b8 // @26B2 stack[3] = stack[-1] // @26B3 stack[4] = stack[-5] // } // Block ends with call to 0x22d7, returns to 0x26B8 label_26B8: // Incoming return from call to 0x22D7 at 0x26B7 // Incoming return from call to 0x22D7 at 0x26B7 // Inputs[2] // { // @26BC stack[-2] // @26BD stack[-1] // } 26B8 5B JUMPDEST 26B9 61 PUSH2 0x26c2 26BC 91 SWAP2 26BD 90 SWAP1 26BE 61 PUSH2 0x3fa7 26C1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @26BC stack[-2] = 0x26c2 // @26BD stack[-1] = stack[-2] // @26BD stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x26C2 label_26C2: // Incoming return from call to 0x3FA7 at 0x26C1 // Inputs[2] // { // @26C6 stack[-2] // @26C7 stack[-1] // } 26C2 5B JUMPDEST 26C3 61 PUSH2 0x26cc 26C6 91 SWAP2 26C7 90 SWAP1 26C8 61 PUSH2 0x3fc6 26CB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @26C6 stack[-2] = 0x26cc // @26C7 stack[-1] = stack[-2] // @26C7 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x26CC label_26CC: // Incoming return from call to 0x3FC6 at 0x26CB // Inputs[2] // { // @26D0 stack[-1] // @26D1 stack[-4] // } 26CC 5B JUMPDEST 26CD 61 PUSH2 0x26d6 26D0 90 SWAP1 26D1 84 DUP5 26D2 61 PUSH2 0x3f5f 26D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26D0 stack[0] = stack[-1] // @26D0 stack[-1] = 0x26d6 // @26D1 stack[1] = stack[-4] // } // Block ends with call to 0x3f5f, returns to 0x26D6 label_26D6: // Incoming return from call to 0x3F5F at 0x26D5 // Inputs[2] // { // @26D7 stack[-4] // @26D7 stack[-1] // } 26D6 5B JUMPDEST 26D7 92 SWAP3 26D8 50 POP // Stack delta = -1 // Outputs[1] { @26D7 stack[-4] = stack[-1] } // Block continues label_26D9: // Incoming jump from 0x26D8 // Incoming jump from 0x26A1, if !stack[-2] // Inputs[3] // { // @26E2 stack[-6] // @26F2 memory[0x00:0x40] // @26F6 storage[0x06 + keccak256(memory[0x00:0x40])] // } 26D9 5B JUMPDEST 26DA 60 PUSH1 0x01 26DC 60 PUSH1 0x01 26DE 60 PUSH1 0xa0 26E0 1B SHL 26E1 03 SUB 26E2 86 DUP7 26E3 16 AND 26E4 60 PUSH1 0x00 26E6 90 SWAP1 26E7 81 DUP2 26E8 52 MSTORE 26E9 61 PUSH2 0x0166 26EC 60 PUSH1 0x20 26EE 52 MSTORE 26EF 60 PUSH1 0x40 26F1 90 SWAP1 26F2 20 SHA3 26F3 60 PUSH1 0x06 26F5 01 ADD 26F6 54 SLOAD 26F7 5B JUMPDEST 26F8 80 DUP1 26F9 15 ISZERO 26FA 61 PUSH2 0x281b 26FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @26E8 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @26EE memory[0x20:0x40] = 0x0166 // @26F6 stack[0] = storage[0x06 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x281b, if !storage[0x06 + keccak256(memory[0x00:0x40])] label_26FE: // Incoming jump from 0x26FD, if not !stack[-1] // Incoming jump from 0x26FD, if not !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[3] // { // @2706 stack[-7] // @2716 memory[0x00:0x40] // @2720 stack[-1] // } 26FE 60 PUSH1 0x01 2700 60 PUSH1 0x01 2702 60 PUSH1 0xa0 2704 1B SHL 2705 03 SUB 2706 87 DUP8 2707 16 AND 2708 60 PUSH1 0x00 270A 90 SWAP1 270B 81 DUP2 270C 52 MSTORE 270D 61 PUSH2 0x0166 2710 60 PUSH1 0x20 2712 52 MSTORE 2713 60 PUSH1 0x40 2715 81 DUP2 2716 20 SHA3 2717 60 PUSH1 0x05 2719 01 ADD 271A 90 SWAP1 271B 61 PUSH2 0x2725 271E 60 PUSH1 0x01 2720 84 DUP5 2721 61 PUSH2 0x3f77 2724 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @270C memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @2712 memory[0x20:0x40] = 0x0166 // @271A stack[0] = 0x05 + keccak256(memory[0x00:0x40]) // @271A stack[1] = 0x00 // @271B stack[2] = 0x2725 // @271E stack[3] = 0x01 // @2720 stack[4] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x2725 label_2725: // Incoming return from call to 0x3F77 at 0x2724 // Inputs[6] // { // @2726 stack[-2] // @2727 stack[-1] // @272B stack[-3] // @2733 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2734 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2735 stack[-9] // } 2725 5B JUMPDEST 2726 81 DUP2 2727 52 MSTORE 2728 60 PUSH1 0x20 272A 01 ADD 272B 90 SWAP1 272C 81 DUP2 272D 52 MSTORE 272E 60 PUSH1 0x20 2730 01 ADD 2731 60 PUSH1 0x00 2733 20 SHA3 2734 54 SLOAD 2735 86 DUP7 2736 11 GT 2737 15 ISZERO 2738 61 PUSH2 0x2812 273B 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @2727 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @272D memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x2812, if !(stack[-9] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) label_273C: // Incoming jump from 0x273B, if not !(stack[-9] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[3] // { // @2744 stack[-7] // @2754 memory[0x00:0x40] // @275E stack[-1] // } 273C 60 PUSH1 0x01 273E 60 PUSH1 0x01 2740 60 PUSH1 0xa0 2742 1B SHL 2743 03 SUB 2744 87 DUP8 2745 16 AND 2746 60 PUSH1 0x00 2748 90 SWAP1 2749 81 DUP2 274A 52 MSTORE 274B 61 PUSH2 0x0166 274E 60 PUSH1 0x20 2750 52 MSTORE 2751 60 PUSH1 0x40 2753 81 DUP2 2754 20 SHA3 2755 60 PUSH1 0x04 2757 01 ADD 2758 90 SWAP1 2759 61 PUSH2 0x2763 275C 60 PUSH1 0x01 275E 84 DUP5 275F 61 PUSH2 0x3f77 2762 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @274A memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @2750 memory[0x20:0x40] = 0x0166 // @2758 stack[0] = 0x04 + keccak256(memory[0x00:0x40]) // @2758 stack[1] = 0x00 // @2759 stack[2] = 0x2763 // @275C stack[3] = 0x01 // @275E stack[4] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x2763 label_2763: // Incoming return from call to 0x3F77 at 0x2762 // Inputs[7] // { // @2764 stack[-2] // @2765 stack[-1] // @2769 stack[-3] // @2771 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2772 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2782 stack[-10] // @2783 stack[-9] // } 2763 5B JUMPDEST 2764 81 DUP2 2765 52 MSTORE 2766 60 PUSH1 0x20 2768 01 ADD 2769 90 SWAP1 276A 81 DUP2 276B 52 MSTORE 276C 60 PUSH1 0x20 276E 01 ADD 276F 60 PUSH1 0x00 2771 20 SHA3 2772 54 SLOAD 2773 6A PUSH11 0x084595161401484a000000 277F 61 PUSH2 0x2788 2782 89 DUP10 2783 89 DUP10 2784 61 PUSH2 0x2ddf 2787 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @2765 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @276B memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @2772 stack[-3] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2773 stack[-2] = 0x084595161401484a000000 // @277F stack[-1] = 0x2788 // @2782 stack[0] = stack[-10] // @2783 stack[1] = stack[-9] // } // Block ends with call to 0x2ddf, returns to 0x2788 label_2788: // Incoming return from call to 0x2DDF at 0x2787 // Inputs[4] // { // @2791 stack[-10] // @27A1 memory[0x00:0x40] // @27A2 storage[keccak256(memory[0x00:0x40])] // @27A6 stack[-1] // } 2788 5B JUMPDEST 2789 60 PUSH1 0x01 278B 60 PUSH1 0x01 278D 60 PUSH1 0xa0 278F 1B SHL 2790 03 SUB 2791 8A DUP11 2792 16 AND 2793 60 PUSH1 0x00 2795 90 SWAP1 2796 81 DUP2 2797 52 MSTORE 2798 61 PUSH2 0x0166 279B 60 PUSH1 0x20 279D 52 MSTORE 279E 60 PUSH1 0x40 27A0 90 SWAP1 27A1 20 SHA3 27A2 54 SLOAD 27A3 61 PUSH2 0x27ac 27A6 91 SWAP2 27A7 90 SWAP1 27A8 61 PUSH2 0x3f5f 27AB 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2797 memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @279D memory[0x20:0x40] = 0x0166 // @27A6 stack[-1] = 0x27ac // @27A7 stack[1] = storage[keccak256(memory[0x00:0x40])] // @27A7 stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x27AC label_27AC: // Incoming return from call to 0x3F5F at 0x27AB // Inputs[2] // { // @27B0 stack[-1] // @27B1 stack[-7] // } 27AC 5B JUMPDEST 27AD 61 PUSH2 0x27b6 27B0 90 SWAP1 27B1 87 DUP8 27B2 61 PUSH2 0x3fa7 27B5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @27B0 stack[0] = stack[-1] // @27B0 stack[-1] = 0x27b6 // @27B1 stack[1] = stack[-7] // } // Block ends with call to 0x3fa7, returns to 0x27B6 label_27B6: // Incoming return from call to 0x3FA7 at 0x27B5 // Inputs[2] // { // @27BA stack[-2] // @27BB stack[-1] // } 27B6 5B JUMPDEST 27B7 61 PUSH2 0x27c0 27BA 91 SWAP2 27BB 90 SWAP1 27BC 61 PUSH2 0x3fc6 27BF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @27BA stack[-2] = 0x27c0 // @27BB stack[-1] = stack[-2] // @27BB stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x27C0 label_27C0: // Incoming return from call to 0x3FC6 at 0x27BF // Inputs[3] // { // @27C9 stack[-9] // @27D9 memory[0x00:0x40] // @27E3 stack[-3] // } 27C0 5B JUMPDEST 27C1 60 PUSH1 0x01 27C3 60 PUSH1 0x01 27C5 60 PUSH1 0xa0 27C7 1B SHL 27C8 03 SUB 27C9 89 DUP10 27CA 16 AND 27CB 60 PUSH1 0x00 27CD 90 SWAP1 27CE 81 DUP2 27CF 52 MSTORE 27D0 61 PUSH2 0x0166 27D3 60 PUSH1 0x20 27D5 52 MSTORE 27D6 60 PUSH1 0x40 27D8 81 DUP2 27D9 20 SHA3 27DA 60 PUSH1 0x03 27DC 01 ADD 27DD 90 SWAP1 27DE 61 PUSH2 0x27e8 27E1 60 PUSH1 0x01 27E3 86 DUP7 27E4 61 PUSH2 0x3f77 27E7 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @27CF memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @27D5 memory[0x20:0x40] = 0x0166 // @27DD stack[0] = 0x03 + keccak256(memory[0x00:0x40]) // @27DD stack[1] = 0x00 // @27DE stack[2] = 0x27e8 // @27E1 stack[3] = 0x01 // @27E3 stack[4] = stack[-3] // } // Block ends with call to 0x3f77, returns to 0x27E8 label_27E8: // Incoming return from call to 0x3F77 at 0x27E7 // Inputs[6] // { // @27E9 stack[-2] // @27EA stack[-1] // @27EE stack[-3] // @27F6 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @27F7 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @27FB stack[-4] // } 27E8 5B JUMPDEST 27E9 81 DUP2 27EA 52 MSTORE 27EB 60 PUSH1 0x20 27ED 01 ADD 27EE 90 SWAP1 27EF 81 DUP2 27F0 52 MSTORE 27F1 60 PUSH1 0x20 27F3 01 ADD 27F4 60 PUSH1 0x00 27F6 20 SHA3 27F7 54 SLOAD 27F8 61 PUSH2 0x2801 27FB 91 SWAP2 27FC 90 SWAP1 27FD 61 PUSH2 0x3f5f 2800 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @27EA memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @27F0 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @27FB stack[-4] = 0x2801 // @27FC stack[-2] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @27FC stack[-3] = stack[-4] // } // Block ends with call to 0x3f5f, returns to 0x2801 label_2801: // Incoming return from call to 0x3F5F at 0x2800 // Inputs[2] // { // @2805 stack[-2] // @2806 stack[-1] // } 2801 5B JUMPDEST 2802 61 PUSH2 0x280b 2805 91 SWAP2 2806 90 SWAP1 2807 61 PUSH2 0x3f77 280A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2805 stack[-2] = 0x280b // @2806 stack[-1] = stack[-2] // @2806 stack[0] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x280B label_280B: // Incoming return from call to 0x3F77 at 0x280A // Inputs[2] // { // @280C stack[-6] // @280C stack[-1] // } 280B 5B JUMPDEST 280C 94 SWAP5 280D 50 POP 280E 61 PUSH2 0x281b 2811 56 *JUMP // Stack delta = -1 // Outputs[1] { @280C stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x281b label_2812: // Incoming jump from 0x273B, if !(stack[-9] > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[1] { @2816 stack[-1] } 2812 5B JUMPDEST 2813 60 PUSH1 0x00 2815 19 NOT 2816 01 ADD 2817 61 PUSH2 0x26f7 281A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2816 stack[-1] = ~0x00 + stack[-1] } // Block ends with unconditional jump to 0x26f7 label_281B: // Incoming jump from 0x26FD, if !storage[0x06 + keccak256(memory[0x00:0x40])] // Incoming jump from 0x26FD, if !stack[-1] // Incoming jump from 0x2811 // Inputs[3] // { // @2820 stack[-5] // @2820 stack[-8] // @2821 stack[-7] // } 281B 5B JUMPDEST 281C 50 POP 281D 50 POP 281E 50 POP 281F 50 POP 2820 92 SWAP3 2821 91 SWAP2 2822 50 POP 2823 50 POP 2824 56 *JUMP // Stack delta = -7 // Outputs[1] { @2820 stack[-8] = stack[-5] } // Block ends with unconditional jump to stack[-8] label_2825: // Incoming call from 0x0BC8, returns to 0x0BC9 // Inputs[2] // { // @282B stack[-3] // @282C stack[-2] // } 2825 5B JUMPDEST 2826 60 PUSH1 0x00 2828 61 PUSH2 0x2831 282B 84 DUP5 282C 84 DUP5 282D 61 PUSH2 0x1610 2830 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2826 stack[0] = 0x00 // @2828 stack[1] = 0x2831 // @282B stack[2] = stack[-3] // @282C stack[3] = stack[-2] // } // Block ends with call to 0x1610, returns to 0x2831 label_2831: // Incoming return from call to 0x1610 at 0x2830 // Inputs[2] // { // @2832 stack[-1] // @2832 stack[-2] // } 2831 5B JUMPDEST 2832 90 SWAP1 2833 50 POP 2834 60 PUSH1 0x00 2836 19 NOT 2837 81 DUP2 2838 14 EQ 2839 61 PUSH2 0x22d1 283C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2832 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x22d1, if stack[-1] == ~0x00 label_283D: // Incoming jump from 0x283C, if not stack[-1] == ~0x00 // Inputs[2] // { // @283D stack[-2] // @283E stack[-1] // } 283D 81 DUP2 283E 81 DUP2 283F 10 LT 2840 15 ISZERO 2841 61 PUSH2 0x288c 2844 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x288c, if !(stack[-1] < stack[-2]) label_2845: // Incoming jump from 0x2844, if not !(stack[-1] < stack[-2]) // Inputs[1] { @2847 memory[0x40:0x60] } 2845 60 PUSH1 0x40 2847 51 MLOAD 2848 62 PUSH3 0x461bcd 284C 60 PUSH1 0xe5 284E 1B SHL 284F 81 DUP2 2850 52 MSTORE 2851 60 PUSH1 0x20 2853 60 PUSH1 0x04 2855 82 DUP3 2856 01 ADD 2857 52 MSTORE 2858 60 PUSH1 0x1d 285A 60 PUSH1 0x24 285C 82 DUP3 285D 01 ADD 285E 52 MSTORE 285F 7F PUSH32 0x45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000 2880 60 PUSH1 0x44 2882 82 DUP3 2883 01 ADD 2884 52 MSTORE 2885 60 PUSH1 0x64 2887 01 ADD 2888 61 PUSH2 0x0817 288B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2850 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2857 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @285E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @2884 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000 // @2887 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_288C: // Incoming jump from 0x2844, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @2890 stack[-4] // @2891 stack[-3] // @2892 stack[-2] // @2893 stack[-1] // } 288C 5B JUMPDEST 288D 61 PUSH2 0x22d1 2890 84 DUP5 2891 84 DUP5 2892 84 DUP5 2893 84 DUP5 2894 03 SUB 2895 61 PUSH2 0x1dc0 2898 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @288D stack[0] = 0x22d1 // @2890 stack[1] = stack[-4] // @2891 stack[2] = stack[-3] // @2894 stack[3] = stack[-1] - stack[-2] // } // Block ends with call to 0x1dc0, returns to 0x22D1 label_2899: // Incoming call from 0x0C05, returns to 0x0C06 // Incoming call from 0x1605, returns to 0x1606 // Inputs[2] // { // @289D stack[-1] // @289E msg.sender // } 2899 5B JUMPDEST 289A 61 PUSH2 0x0cd3 289D 81 DUP2 289E 33 CALLER 289F 61 PUSH2 0x2ff3 28A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @289A stack[0] = 0x0cd3 // @289D stack[1] = stack[-1] // @289E stack[2] = msg.sender // } // Block ends with call to 0x2ff3, returns to 0x0CD3 label_28A3: // Incoming call from 0x0DD2, returns to 0x0DD3 // Incoming call from 0x0C0F, returns to 0x0C10 // Inputs[2] // { // @28A7 stack[-2] // @28A8 stack[-1] // } 28A3 5B JUMPDEST 28A4 61 PUSH2 0x28ad 28A7 82 DUP3 28A8 82 DUP3 28A9 61 PUSH2 0x13b7 28AC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28A4 stack[0] = 0x28ad // @28A7 stack[1] = stack[-2] // @28A8 stack[2] = stack[-1] // } // Block ends with call to 0x13b7, returns to 0x28AD label_28AD: // Incoming return from call to 0x13B7 at 0x28AC // Inputs[1] { @28B1 stack[-1] } 28AD 5B JUMPDEST 28AE 61 PUSH2 0x0c9e 28B1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c9e, if stack[-1] label_28B2: // Incoming jump from 0x28B1, if not stack[-1] // Inputs[6] // { // @28B4 stack[-2] // @28C2 memory[0x00:0x40] // @28CB stack[-1] // @28D3 memory[0x00:0x40] // @28D5 storage[keccak256(memory[0x00:0x40])] // @28E2 msg.sender // } 28B2 60 PUSH1 0x00 28B4 82 DUP3 28B5 81 DUP2 28B6 52 MSTORE 28B7 60 PUSH1 0x65 28B9 60 PUSH1 0x20 28BB 90 SWAP1 28BC 81 DUP2 28BD 52 MSTORE 28BE 60 PUSH1 0x40 28C0 80 DUP1 28C1 83 DUP4 28C2 20 SHA3 28C3 60 PUSH1 0x01 28C5 60 PUSH1 0x01 28C7 60 PUSH1 0xa0 28C9 1B SHL 28CA 03 SUB 28CB 85 DUP6 28CC 16 AND 28CD 84 DUP5 28CE 52 MSTORE 28CF 90 SWAP1 28D0 91 SWAP2 28D1 52 MSTORE 28D2 90 SWAP1 28D3 20 SHA3 28D4 80 DUP1 28D5 54 SLOAD 28D6 60 PUSH1 0xff 28D8 19 NOT 28D9 16 AND 28DA 60 PUSH1 0x01 28DC 17 OR 28DD 90 SWAP1 28DE 55 SSTORE 28DF 61 PUSH2 0x28e5 28E2 33 CALLER 28E3 90 SWAP1 28E4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @28B6 memory[0x00:0x20] = stack[-2] // @28BD memory[0x20:0x40] = 0x65 // @28CE memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @28D1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @28DE storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @28E3 stack[0] = msg.sender // } // Block ends with unconditional jump to 0x28e5 label_28E5: // Incoming jump from 0x28E4 // Inputs[7] // { // @28EE stack[-1] // @28EF stack[-2] // @28F9 stack[-3] // @291D memory[0x40:0x60] // @2920 memory[0x40:0x60] // @2925 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2928 stack[-4] // } 28E5 5B JUMPDEST 28E6 60 PUSH1 0x01 28E8 60 PUSH1 0x01 28EA 60 PUSH1 0xa0 28EC 1B SHL 28ED 03 SUB 28EE 16 AND 28EF 81 DUP2 28F0 60 PUSH1 0x01 28F2 60 PUSH1 0x01 28F4 60 PUSH1 0xa0 28F6 1B SHL 28F7 03 SUB 28F8 16 AND 28F9 83 DUP4 28FA 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 291B 60 PUSH1 0x40 291D 51 MLOAD 291E 60 PUSH1 0x40 2920 51 MLOAD 2921 80 DUP1 2922 91 SWAP2 2923 03 SUB 2924 90 SWAP1 2925 A4 LOG4 2926 50 POP 2927 50 POP 2928 56 *JUMP // Stack delta = -4 // Outputs[1] { @2925 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d, stack[-3], stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-4] label_2929: // Incoming jump from 0x0C1E // Incoming jump from 0x2C22 2929 5B JUMPDEST 292A 60 PUSH1 0x00 292C 61 PUSH2 0x0c1f 292F 7F PUSH32 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f 2950 61 PUSH2 0x2957 2953 61 PUSH2 0x3057 2956 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @292A stack[0] = 0x00 // @292C stack[1] = 0x0c1f // @292F stack[2] = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f // @2950 stack[3] = 0x2957 // } // Block ends with call to 0x3057, returns to 0x2957 label_2957: // Incoming return from call to 0x3057 at 0x2956 2957 5B JUMPDEST 2958 61 PUSH2 0x295f 295B 61 PUSH2 0x306d 295E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2958 stack[0] = 0x295f } // Block ends with unconditional jump to 0x306d 295F 5B JUMPDEST 2960 60 PUSH1 0x40 2962 80 DUP1 2963 51 MLOAD 2964 60 PUSH1 0x20 2966 81 DUP2 2967 01 ADD 2968 85 DUP6 2969 90 SWAP1 296A 52 MSTORE 296B 90 SWAP1 296C 81 DUP2 296D 01 ADD 296E 83 DUP4 296F 90 SWAP1 2970 52 MSTORE 2971 60 PUSH1 0x60 2973 81 DUP2 2974 01 ADD 2975 82 DUP3 2976 90 SWAP1 2977 52 MSTORE 2978 46 CHAINID 2979 60 PUSH1 0x80 297B 82 DUP3 297C 01 ADD 297D 52 MSTORE 297E 30 ADDRESS 297F 60 PUSH1 0xa0 2981 82 DUP3 2982 01 ADD 2983 52 MSTORE 2984 60 PUSH1 0x00 2986 90 SWAP1 2987 60 PUSH1 0xc0 2989 01 ADD 298A 60 PUSH1 0x40 298C 51 MLOAD 298D 60 PUSH1 0x20 298F 81 DUP2 2990 83 DUP4 2991 03 SUB 2992 03 SUB 2993 81 DUP2 2994 52 MSTORE 2995 90 SWAP1 2996 60 PUSH1 0x40 2998 52 MSTORE 2999 80 DUP1 299A 51 MLOAD 299B 90 SWAP1 299C 60 PUSH1 0x20 299E 01 ADD 299F 20 SHA3 29A0 90 SWAP1 29A1 50 POP 29A2 93 SWAP4 29A3 92 SWAP3 29A4 50 POP 29A5 50 POP 29A6 50 POP 29A7 56 *JUMP label_29A8: // Incoming call from 0x0C9D, returns to 0x0C9E // Incoming call from 0x160F, returns to 0x0C10 // Inputs[2] // { // @29AC stack[-2] // @29AD stack[-1] // } 29A8 5B JUMPDEST 29A9 61 PUSH2 0x29b2 29AC 82 DUP3 29AD 82 DUP3 29AE 61 PUSH2 0x13b7 29B1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @29A9 stack[0] = 0x29b2 // @29AC stack[1] = stack[-2] // @29AD stack[2] = stack[-1] // } // Block ends with call to 0x13b7, returns to 0x29B2 label_29B2: // Incoming return from call to 0x13B7 at 0x29B1 // Inputs[1] { @29B3 stack[-1] } 29B2 5B JUMPDEST 29B3 15 ISZERO 29B4 61 PUSH2 0x0c9e 29B7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c9e, if !stack[-1] label_29B8: // Incoming jump from 0x29B7, if not !stack[-1] // Inputs[9] // { // @29BA stack[-2] // @29C8 memory[0x00:0x40] // @29D1 stack[-1] // @29DA memory[0x00:0x40] // @29DC storage[keccak256(memory[0x00:0x40])] // @29E3 memory[0x40:0x60] // @29E4 msg.sender // @2A0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2A0E stack[-3] // } 29B8 60 PUSH1 0x00 29BA 82 DUP3 29BB 81 DUP2 29BC 52 MSTORE 29BD 60 PUSH1 0x65 29BF 60 PUSH1 0x20 29C1 90 SWAP1 29C2 81 DUP2 29C3 52 MSTORE 29C4 60 PUSH1 0x40 29C6 80 DUP1 29C7 83 DUP4 29C8 20 SHA3 29C9 60 PUSH1 0x01 29CB 60 PUSH1 0x01 29CD 60 PUSH1 0xa0 29CF 1B SHL 29D0 03 SUB 29D1 85 DUP6 29D2 16 AND 29D3 80 DUP1 29D4 85 DUP6 29D5 52 MSTORE 29D6 92 SWAP3 29D7 52 MSTORE 29D8 80 DUP1 29D9 83 DUP4 29DA 20 SHA3 29DB 80 DUP1 29DC 54 SLOAD 29DD 60 PUSH1 0xff 29DF 19 NOT 29E0 16 AND 29E1 90 SWAP1 29E2 55 SSTORE 29E3 51 MLOAD 29E4 33 CALLER 29E5 92 SWAP3 29E6 85 DUP6 29E7 91 SWAP2 29E8 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 2A09 91 SWAP2 2A0A 90 SWAP1 2A0B A4 LOG4 2A0C 50 POP 2A0D 50 POP 2A0E 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @29BC memory[0x00:0x20] = stack[-2] // @29C3 memory[0x20:0x40] = 0x65 // @29D5 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @29D7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @29E2 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @2A0B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-2], stack[-1] & (0x01 << 0xa0) - 0x01, msg.sender]); // } // Block ends with unconditional jump to stack[-3] label_2A0F: // Incoming call from 0x0DBF, returns to 0x0DC0 // Incoming call from 0x0DC7, returns to 0x0DC8 // Incoming call from 0x0DBF, returns to 0x0DC0 // Inputs[1] { @2A12 storage[0x00] } 2A0F 5B JUMPDEST 2A10 60 PUSH1 0x00 2A12 54 SLOAD 2A13 61 PUSH2 0x0100 2A16 90 SWAP1 2A17 04 DIV 2A18 60 PUSH1 0xff 2A1A 16 AND 2A1B 61 PUSH2 0x2a36 2A1E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a36, if 0xff & storage[0x00] / 0x0100 label_2A1F: // Incoming jump from 0x2A1E, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @2A21 memory[0x40:0x60] } 2A1F 60 PUSH1 0x40 2A21 51 MLOAD 2A22 62 PUSH3 0x461bcd 2A26 60 PUSH1 0xe5 2A28 1B SHL 2A29 81 DUP2 2A2A 52 MSTORE 2A2B 60 PUSH1 0x04 2A2D 01 ADD 2A2E 61 PUSH2 0x0817 2A31 90 SWAP1 2A32 61 PUSH2 0x42b1 2A35 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2A31 stack[0] = 0x0817 // @2A31 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42b1, returns to 0x0817 label_2A36: // Incoming jump from 0x2A1E, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @2A37 stack[-1] } 2A36 5B JUMPDEST 2A37 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2A38: // Incoming jump from 0x0DE2 // Inputs[1] { @2A3B storage[0x00] } 2A38 5B JUMPDEST 2A39 60 PUSH1 0x00 2A3B 54 SLOAD 2A3C 61 PUSH2 0x0100 2A3F 90 SWAP1 2A40 04 DIV 2A41 60 PUSH1 0xff 2A43 16 AND 2A44 61 PUSH2 0x2a5f 2A47 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a5f, if 0xff & storage[0x00] / 0x0100 label_2A48: // Incoming jump from 0x2A47, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @2A4A memory[0x40:0x60] } 2A48 60 PUSH1 0x40 2A4A 51 MLOAD 2A4B 62 PUSH3 0x461bcd 2A4F 60 PUSH1 0xe5 2A51 1B SHL 2A52 81 DUP2 2A53 52 MSTORE 2A54 60 PUSH1 0x04 2A56 01 ADD 2A57 61 PUSH2 0x0817 2A5A 90 SWAP1 2A5B 61 PUSH2 0x42b1 2A5E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2A5A stack[0] = 0x0817 // @2A5A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42b1, returns to 0x0817 label_2A5F: // Incoming jump from 0x2A47, if 0xff & storage[0x00] / 0x0100 // Inputs[3] // { // @2A63 stack[-8] // @2A64 stack[-7] // @2A65 stack[-6] // } 2A5F 5B JUMPDEST 2A60 61 PUSH2 0x2a6a 2A63 88 DUP9 2A64 88 DUP9 2A65 88 DUP9 2A66 61 PUSH2 0x3077 2A69 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A60 stack[0] = 0x2a6a // @2A63 stack[1] = stack[-8] // @2A64 stack[2] = stack[-7] // @2A65 stack[3] = stack[-6] // } // Block ends with unconditional jump to 0x3077 2A6A 5B JUMPDEST 2A6B 61 PUSH2 0x2a73 2A6E 85 DUP6 2A6F 61 PUSH2 0x30ca 2A72 56 *JUMP 2A73 5B JUMPDEST 2A74 61 PUSH2 0x0171 2A77 93 SWAP4 2A78 90 SWAP1 2A79 93 SWAP4 2A7A 55 SSTORE 2A7B 61 PUSH2 0x0170 2A7E 91 SWAP2 2A7F 90 SWAP1 2A80 91 SWAP2 2A81 55 SSTORE 2A82 61 PUSH2 0x0173 2A85 55 SSTORE 2A86 61 PUSH2 0x0172 2A89 55 SSTORE 2A8A 50 POP 2A8B 50 POP 2A8C 50 POP 2A8D 50 POP 2A8E 56 *JUMP 2A8F 5B JUMPDEST 2A90 60 PUSH1 0x00 2A92 54 SLOAD 2A93 61 PUSH2 0x0100 2A96 90 SWAP1 2A97 04 DIV 2A98 60 PUSH1 0xff 2A9A 16 AND 2A9B 61 PUSH2 0x2ab6 2A9E 57 *JUMPI 2A9F 60 PUSH1 0x40 2AA1 51 MLOAD 2AA2 62 PUSH3 0x461bcd 2AA6 60 PUSH1 0xe5 2AA8 1B SHL 2AA9 81 DUP2 2AAA 52 MSTORE 2AAB 60 PUSH1 0x04 2AAD 01 ADD 2AAE 61 PUSH2 0x0817 2AB1 90 SWAP1 2AB2 61 PUSH2 0x42b1 2AB5 56 *JUMP 2AB6 5B JUMPDEST 2AB7 61 PUSH2 0x2a36 2ABA 61 PUSH2 0x2a0f 2ABD 56 *JUMP label_2ABE: // Incoming call from 0x0E56, returns to 0x0E57 // Incoming call from 0x17C1, returns to 0x17C2 // Inputs[3] // { // @2AC7 stack[-1] // @2AD7 memory[0x00:0x40] // @2ADB storage[0x06 + keccak256(memory[0x00:0x40])] // } 2ABE 5B JUMPDEST 2ABF 60 PUSH1 0x01 2AC1 60 PUSH1 0x01 2AC3 60 PUSH1 0xa0 2AC5 1B SHL 2AC6 03 SUB 2AC7 81 DUP2 2AC8 16 AND 2AC9 60 PUSH1 0x00 2ACB 90 SWAP1 2ACC 81 DUP2 2ACD 52 MSTORE 2ACE 61 PUSH2 0x0166 2AD1 60 PUSH1 0x20 2AD3 52 MSTORE 2AD4 60 PUSH1 0x40 2AD6 81 DUP2 2AD7 20 SHA3 2AD8 60 PUSH1 0x06 2ADA 01 ADD 2ADB 54 SLOAD 2ADC 80 DUP1 2ADD 5B JUMPDEST 2ADE 80 DUP1 2ADF 15 ISZERO 2AE0 61 PUSH2 0x2c05 2AE3 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2ACB stack[0] = 0x00 // @2ACD memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @2AD3 memory[0x20:0x40] = 0x0166 // @2ADB stack[1] = storage[0x06 + keccak256(memory[0x00:0x40])] // @2ADC stack[2] = storage[0x06 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2c05, if !storage[0x06 + keccak256(memory[0x00:0x40])] label_2AE4: // Incoming jump from 0x2AE3, if not !stack[-1] // Incoming jump from 0x2AE3, if not !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[3] // { // @2AEC stack[-4] // @2AFC memory[0x00:0x40] // @2B06 stack[-1] // } 2AE4 60 PUSH1 0x01 2AE6 60 PUSH1 0x01 2AE8 60 PUSH1 0xa0 2AEA 1B SHL 2AEB 03 SUB 2AEC 84 DUP5 2AED 16 AND 2AEE 60 PUSH1 0x00 2AF0 90 SWAP1 2AF1 81 DUP2 2AF2 52 MSTORE 2AF3 61 PUSH2 0x0166 2AF6 60 PUSH1 0x20 2AF8 52 MSTORE 2AF9 60 PUSH1 0x40 2AFB 81 DUP2 2AFC 20 SHA3 2AFD 60 PUSH1 0x05 2AFF 01 ADD 2B00 90 SWAP1 2B01 61 PUSH2 0x2b0b 2B04 60 PUSH1 0x01 2B06 84 DUP5 2B07 61 PUSH2 0x3f77 2B0A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2AF2 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2AF8 memory[0x20:0x40] = 0x0166 // @2B00 stack[0] = 0x05 + keccak256(memory[0x00:0x40]) // @2B00 stack[1] = 0x00 // @2B01 stack[2] = 0x2b0b // @2B04 stack[3] = 0x01 // @2B06 stack[4] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x2B0B label_2B0B: // Incoming return from call to 0x3F77 at 0x2B0A // Inputs[6] // { // @2B0C stack[-2] // @2B0D stack[-1] // @2B11 stack[-3] // @2B19 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2B1A storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2B1B block.number // } 2B0B 5B JUMPDEST 2B0C 81 DUP2 2B0D 52 MSTORE 2B0E 60 PUSH1 0x20 2B10 01 ADD 2B11 90 SWAP1 2B12 81 DUP2 2B13 52 MSTORE 2B14 60 PUSH1 0x20 2B16 01 ADD 2B17 60 PUSH1 0x00 2B19 20 SHA3 2B1A 54 SLOAD 2B1B 43 NUMBER 2B1C 11 GT 2B1D 15 ISZERO 2B1E 61 PUSH2 0x2bfc 2B21 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @2B0D memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2B13 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x2bfc, if !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) label_2B22: // Incoming jump from 0x2B21, if not !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[3] // { // @2B2A stack[-4] // @2B3A memory[0x00:0x40] // @2B44 stack[-1] // } 2B22 60 PUSH1 0x01 2B24 60 PUSH1 0x01 2B26 60 PUSH1 0xa0 2B28 1B SHL 2B29 03 SUB 2B2A 84 DUP5 2B2B 16 AND 2B2C 60 PUSH1 0x00 2B2E 90 SWAP1 2B2F 81 DUP2 2B30 52 MSTORE 2B31 61 PUSH2 0x0166 2B34 60 PUSH1 0x20 2B36 52 MSTORE 2B37 60 PUSH1 0x40 2B39 81 DUP2 2B3A 20 SHA3 2B3B 60 PUSH1 0x04 2B3D 01 ADD 2B3E 90 SWAP1 2B3F 61 PUSH2 0x2b49 2B42 60 PUSH1 0x01 2B44 84 DUP5 2B45 61 PUSH2 0x3f77 2B48 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2B30 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2B36 memory[0x20:0x40] = 0x0166 // @2B3E stack[0] = 0x04 + keccak256(memory[0x00:0x40]) // @2B3E stack[1] = 0x00 // @2B3F stack[2] = 0x2b49 // @2B42 stack[3] = 0x01 // @2B44 stack[4] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x2B49 label_2B49: // Incoming return from call to 0x3F77 at 0x2B48 // Inputs[7] // { // @2B4A stack[-2] // @2B4B stack[-1] // @2B4F stack[-3] // @2B57 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2B58 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2B68 stack[-7] // @2B69 block.number // } 2B49 5B JUMPDEST 2B4A 81 DUP2 2B4B 52 MSTORE 2B4C 60 PUSH1 0x20 2B4E 01 ADD 2B4F 90 SWAP1 2B50 81 DUP2 2B51 52 MSTORE 2B52 60 PUSH1 0x20 2B54 01 ADD 2B55 60 PUSH1 0x00 2B57 20 SHA3 2B58 54 SLOAD 2B59 6A PUSH11 0x084595161401484a000000 2B65 61 PUSH2 0x2b6e 2B68 86 DUP7 2B69 43 NUMBER 2B6A 61 PUSH2 0x2ddf 2B6D 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @2B4B memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2B51 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @2B58 stack[-3] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2B59 stack[-2] = 0x084595161401484a000000 // @2B65 stack[-1] = 0x2b6e // @2B68 stack[0] = stack[-7] // @2B69 stack[1] = block.number // } // Block ends with call to 0x2ddf, returns to 0x2B6E label_2B6E: // Incoming return from call to 0x2DDF at 0x2B6D // Inputs[4] // { // @2B77 stack[-7] // @2B87 memory[0x00:0x40] // @2B88 storage[keccak256(memory[0x00:0x40])] // @2B8C stack[-1] // } 2B6E 5B JUMPDEST 2B6F 60 PUSH1 0x01 2B71 60 PUSH1 0x01 2B73 60 PUSH1 0xa0 2B75 1B SHL 2B76 03 SUB 2B77 87 DUP8 2B78 16 AND 2B79 60 PUSH1 0x00 2B7B 90 SWAP1 2B7C 81 DUP2 2B7D 52 MSTORE 2B7E 61 PUSH2 0x0166 2B81 60 PUSH1 0x20 2B83 52 MSTORE 2B84 60 PUSH1 0x40 2B86 90 SWAP1 2B87 20 SHA3 2B88 54 SLOAD 2B89 61 PUSH2 0x2b92 2B8C 91 SWAP2 2B8D 90 SWAP1 2B8E 61 PUSH2 0x3f5f 2B91 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2B7D memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @2B83 memory[0x20:0x40] = 0x0166 // @2B8C stack[-1] = 0x2b92 // @2B8D stack[1] = storage[keccak256(memory[0x00:0x40])] // @2B8D stack[0] = stack[-1] // } // Block ends with call to 0x3f5f, returns to 0x2B92 label_2B92: // Incoming return from call to 0x3F5F at 0x2B91 // Inputs[2] // { // @2B96 storage[0x0167] // @2B9A stack[-1] // } 2B92 5B JUMPDEST 2B93 61 PUSH2 0x0167 2B96 54 SLOAD 2B97 61 PUSH2 0x2ba0 2B9A 91 SWAP2 2B9B 90 SWAP1 2B9C 61 PUSH2 0x3fa7 2B9F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2B9A stack[-1] = 0x2ba0 // @2B9B stack[1] = storage[0x0167] // @2B9B stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x2BA0 label_2BA0: // Incoming return from call to 0x3FA7 at 0x2B9F // Inputs[2] // { // @2BA4 stack[-2] // @2BA5 stack[-1] // } 2BA0 5B JUMPDEST 2BA1 61 PUSH2 0x2baa 2BA4 91 SWAP2 2BA5 90 SWAP1 2BA6 61 PUSH2 0x3fc6 2BA9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2BA4 stack[-2] = 0x2baa // @2BA5 stack[-1] = stack[-2] // @2BA5 stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x2BAA label_2BAA: // Incoming return from call to 0x3FC6 at 0x2BA9 // Inputs[3] // { // @2BB3 stack[-6] // @2BC3 memory[0x00:0x40] // @2BCD stack[-3] // } 2BAA 5B JUMPDEST 2BAB 60 PUSH1 0x01 2BAD 60 PUSH1 0x01 2BAF 60 PUSH1 0xa0 2BB1 1B SHL 2BB2 03 SUB 2BB3 86 DUP7 2BB4 16 AND 2BB5 60 PUSH1 0x00 2BB7 90 SWAP1 2BB8 81 DUP2 2BB9 52 MSTORE 2BBA 61 PUSH2 0x0166 2BBD 60 PUSH1 0x20 2BBF 52 MSTORE 2BC0 60 PUSH1 0x40 2BC2 81 DUP2 2BC3 20 SHA3 2BC4 60 PUSH1 0x03 2BC6 01 ADD 2BC7 90 SWAP1 2BC8 61 PUSH2 0x2bd2 2BCB 60 PUSH1 0x01 2BCD 86 DUP7 2BCE 61 PUSH2 0x3f77 2BD1 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2BB9 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2BBF memory[0x20:0x40] = 0x0166 // @2BC7 stack[0] = 0x03 + keccak256(memory[0x00:0x40]) // @2BC7 stack[1] = 0x00 // @2BC8 stack[2] = 0x2bd2 // @2BCB stack[3] = 0x01 // @2BCD stack[4] = stack[-3] // } // Block ends with call to 0x3f77, returns to 0x2BD2 label_2BD2: // Incoming return from call to 0x3F77 at 0x2BD1 // Inputs[6] // { // @2BD3 stack[-2] // @2BD4 stack[-1] // @2BD8 stack[-3] // @2BE0 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2BE1 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2BE5 stack[-4] // } 2BD2 5B JUMPDEST 2BD3 81 DUP2 2BD4 52 MSTORE 2BD5 60 PUSH1 0x20 2BD7 01 ADD 2BD8 90 SWAP1 2BD9 81 DUP2 2BDA 52 MSTORE 2BDB 60 PUSH1 0x20 2BDD 01 ADD 2BDE 60 PUSH1 0x00 2BE0 20 SHA3 2BE1 54 SLOAD 2BE2 61 PUSH2 0x2beb 2BE5 91 SWAP2 2BE6 90 SWAP1 2BE7 61 PUSH2 0x3f5f 2BEA 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2BD4 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2BDA memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @2BE5 stack[-4] = 0x2beb // @2BE6 stack[-2] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @2BE6 stack[-3] = stack[-4] // } // Block ends with call to 0x3f5f, returns to 0x2BEB label_2BEB: // Incoming return from call to 0x3F5F at 0x2BEA // Inputs[2] // { // @2BEF stack[-2] // @2BF0 stack[-1] // } 2BEB 5B JUMPDEST 2BEC 61 PUSH2 0x2bf5 2BEF 91 SWAP2 2BF0 90 SWAP1 2BF1 61 PUSH2 0x3f77 2BF4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2BEF stack[-2] = 0x2bf5 // @2BF0 stack[-1] = stack[-2] // @2BF0 stack[0] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x2BF5 label_2BF5: // Incoming return from call to 0x3F77 at 0x2BF4 // Inputs[2] // { // @2BF6 stack[-4] // @2BF6 stack[-1] // } 2BF5 5B JUMPDEST 2BF6 92 SWAP3 2BF7 50 POP 2BF8 61 PUSH2 0x2c05 2BFB 56 *JUMP // Stack delta = -1 // Outputs[1] { @2BF6 stack[-4] = stack[-1] } // Block ends with unconditional jump to 0x2c05 label_2BFC: // Incoming jump from 0x2B21, if !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[1] { @2C00 stack[-1] } 2BFC 5B JUMPDEST 2BFD 60 PUSH1 0x00 2BFF 19 NOT 2C00 01 ADD 2C01 61 PUSH2 0x2add 2C04 56 *JUMP // Stack delta = +0 // Outputs[1] { @2C00 stack[-1] = ~0x00 + stack[-1] } // Block ends with unconditional jump to 0x2add label_2C05: // Incoming jump from 0x2BFB // Incoming jump from 0x2AE3, if !stack[-1] // Incoming jump from 0x2AE3, if !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[3] // { // @2C08 stack[-3] // @2C08 stack[-5] // @2C09 stack[-4] // } 2C05 5B JUMPDEST 2C06 50 POP 2C07 50 POP 2C08 91 SWAP2 2C09 90 SWAP1 2C0A 50 POP 2C0B 56 *JUMP // Stack delta = -4 // Outputs[1] { @2C08 stack[-5] = stack[-3] } // Block ends with unconditional jump to stack[-5] label_2C0C: // Incoming jump from 0x0E82 // Inputs[2] // { // @2C10 stack[-2] // @2C11 stack[-1] // } 2C0C 5B JUMPDEST 2C0D 61 PUSH2 0x0c9e 2C10 82 DUP3 2C11 82 DUP3 2C12 61 PUSH2 0x3118 2C15 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C0D stack[0] = 0x0c9e // @2C10 stack[1] = stack[-2] // @2C11 stack[2] = stack[-1] // } // Block ends with call to 0x3118, returns to 0x0C9E label_2C16: // Incoming jump from 0x0F31 2C16 5B JUMPDEST 2C17 60 PUSH1 0x00 2C19 61 PUSH2 0x06a1 2C1C 61 PUSH2 0x2c23 2C1F 61 PUSH2 0x2929 2C22 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C17 stack[0] = 0x00 // @2C19 stack[1] = 0x06a1 // @2C1C stack[2] = 0x2c23 // } // Block ends with unconditional jump to 0x2929 2C23 5B JUMPDEST 2C24 83 DUP4 2C25 60 PUSH1 0x40 2C27 51 MLOAD 2C28 61 PUSH2 0x1901 2C2B 60 PUSH1 0xf0 2C2D 1B SHL 2C2E 60 PUSH1 0x20 2C30 82 DUP3 2C31 01 ADD 2C32 52 MSTORE 2C33 60 PUSH1 0x22 2C35 81 DUP2 2C36 01 ADD 2C37 83 DUP4 2C38 90 SWAP1 2C39 52 MSTORE 2C3A 60 PUSH1 0x42 2C3C 81 DUP2 2C3D 01 ADD 2C3E 82 DUP3 2C3F 90 SWAP1 2C40 52 MSTORE 2C41 60 PUSH1 0x00 2C43 90 SWAP1 2C44 60 PUSH1 0x62 2C46 01 ADD 2C47 60 PUSH1 0x40 2C49 51 MLOAD 2C4A 60 PUSH1 0x20 2C4C 81 DUP2 2C4D 83 DUP4 2C4E 03 SUB 2C4F 03 SUB 2C50 81 DUP2 2C51 52 MSTORE 2C52 90 SWAP1 2C53 60 PUSH1 0x40 2C55 52 MSTORE 2C56 80 DUP1 2C57 51 MLOAD 2C58 90 SWAP1 2C59 60 PUSH1 0x20 2C5B 01 ADD 2C5C 20 SHA3 2C5D 90 SWAP1 2C5E 50 POP 2C5F 92 SWAP3 2C60 91 SWAP2 2C61 50 POP 2C62 50 POP 2C63 56 *JUMP 2C64 5B JUMPDEST 2C65 60 PUSH1 0x00 2C67 80 DUP1 2C68 60 PUSH1 0x00 2C6A 61 PUSH2 0x2c75 2C6D 87 DUP8 2C6E 87 DUP8 2C6F 87 DUP8 2C70 87 DUP8 2C71 61 PUSH2 0x3222 2C74 56 *JUMP 2C75 5B JUMPDEST 2C76 91 SWAP2 2C77 50 POP 2C78 91 SWAP2 2C79 50 POP 2C7A 61 PUSH2 0x2c82 2C7D 81 DUP2 2C7E 61 PUSH2 0x3305 2C81 56 *JUMP 2C82 5B JUMPDEST 2C83 50 POP 2C84 95 SWAP6 2C85 94 SWAP5 2C86 50 POP 2C87 50 POP 2C88 50 POP 2C89 50 POP 2C8A 50 POP 2C8B 56 *JUMP label_2C8C: // Incoming call from 0x267D, returns to 0x267E // Incoming call from 0x1093, returns to 0x1094 // Incoming call from 0x100B, returns to 0x100C // Inputs[2] // { // @2C8F stack[-1] // @2C91 storage[stack[-1] + 0x01] // } 2C8C 5B JUMPDEST 2C8D 60 PUSH1 0x01 2C8F 81 DUP2 2C90 01 ADD 2C91 54 SLOAD 2C92 60 PUSH1 0x00 2C94 90 SWAP1 2C95 63 PUSH4 0xffffffff 2C9A 80 DUP1 2C9B 82 DUP3 2C9C 16 AND 2C9D 60 PUSH1 0x01 2C9F 60 PUSH1 0x20 2CA1 1B SHL 2CA2 90 SWAP1 2CA3 92 SWAP3 2CA4 04 DIV 2CA5 16 AND 2CA6 10 LT 2CA7 15 ISZERO 2CA8 61 PUSH2 0x2cb3 2CAB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C94 stack[0] = 0x00 } // Block ends with conditional jump to 0x2cb3, if !(storage[stack[-1] + 0x01] / (0x01 << 0x20) & 0xffffffff < storage[stack[-1] + 0x01] & 0xffffffff) label_2CAC: // Incoming jump from 0x2CAB, if not !(storage[stack[-1] + 0x01] / (0x01 << 0x20) & 0xffffffff < storage[stack[-1] + 0x01] & 0xffffffff) // Inputs[2] // { // @2CAF stack[-3] // @2CB0 stack[-2] // } 2CAC 50 POP 2CAD 60 PUSH1 0x00 2CAF 91 SWAP2 2CB0 90 SWAP1 2CB1 50 POP 2CB2 56 *JUMP // Stack delta = -2 // Outputs[1] { @2CAF stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_2CB3: // Incoming jump from 0x2CAB, if !(storage[stack[-1] + 0x01] / (0x01 << 0x20) & 0xffffffff < storage[stack[-1] + 0x01] & 0xffffffff) // Inputs[2] // { // @2CB6 stack[-2] // @2CB8 storage[stack[-2] + 0x01] // } 2CB3 5B JUMPDEST 2CB4 60 PUSH1 0x01 2CB6 82 DUP3 2CB7 01 ADD 2CB8 54 SLOAD 2CB9 61 PUSH2 0x2cd2 2CBC 90 SWAP1 2CBD 63 PUSH4 0xffffffff 2CC2 80 DUP1 2CC3 82 DUP3 2CC4 16 AND 2CC5 91 SWAP2 2CC6 60 PUSH1 0x01 2CC8 60 PUSH1 0x20 2CCA 1B SHL 2CCB 90 SWAP1 2CCC 04 DIV 2CCD 16 AND 2CCE 61 PUSH2 0x42fc 2CD1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CBC stack[0] = 0x2cd2 // @2CC5 stack[1] = storage[stack[-2] + 0x01] & 0xffffffff // @2CCD stack[2] = storage[stack[-2] + 0x01] / (0x01 << 0x20) & 0xffffffff // } // Block ends with call to 0x42fc, returns to 0x2CD2 label_2CD2: // Incoming return from call to 0x42FC at 0x2CD1 // Inputs[1] { @2CD6 stack[-1] } 2CD2 5B JUMPDEST 2CD3 61 PUSH2 0x2cdd 2CD6 90 SWAP1 2CD7 60 PUSH1 0x01 2CD9 61 PUSH2 0x4319 2CDC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2CD6 stack[0] = stack[-1] // @2CD6 stack[-1] = 0x2cdd // @2CD7 stack[1] = 0x01 // } // Block ends with call to 0x4319, returns to 0x2CDD label_2CDD: // Incoming return from call to 0x4319 at 0x2CDC // Inputs[3] // { // @2CE3 stack[-1] // @2CE4 stack[-4] // @2CE5 stack[-3] // } 2CDD 5B JUMPDEST 2CDE 63 PUSH4 0xffffffff 2CE3 16 AND 2CE4 92 SWAP3 2CE5 91 SWAP2 2CE6 50 POP 2CE7 50 POP 2CE8 56 *JUMP // Stack delta = -3 // Outputs[1] { @2CE4 stack[-4] = 0xffffffff & stack[-1] } // Block ends with unconditional jump to stack[-4] label_2CE9: // Incoming call from 0x2693, returns to 0x2694 // Incoming jump from 0x1C0B // Incoming call from 0x1237, returns to 0x1238 // Inputs[3] // { // @2CED storage[0x0167] // @2CF1 storage[0x016b] // @2CF5 storage[0x0169] // } 2CE9 5B JUMPDEST 2CEA 61 PUSH2 0x0167 2CED 54 SLOAD 2CEE 61 PUSH2 0x016b 2CF1 54 SLOAD 2CF2 61 PUSH2 0x0169 2CF5 54 SLOAD 2CF6 61 PUSH2 0x2d00 2CF9 61 PUSH2 0x016e 2CFC 61 PUSH2 0x2673 2CFF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2CED stack[0] = storage[0x0167] // @2CF1 stack[1] = storage[0x016b] // @2CF5 stack[2] = storage[0x0169] // @2CF6 stack[3] = 0x2d00 // @2CF9 stack[4] = 0x016e // } // Block ends with call to 0x2673, returns to 0x2D00 label_2D00: // Incoming return from call to 0x2673 at 0x2CFF // Inputs[1] { @2D04 stack[-1] } 2D00 5B JUMPDEST 2D01 61 PUSH2 0x2dd8 2D04 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2dd8, if stack[-1] label_2D05: // Incoming jump from 0x2D04, if not stack[-1] // Inputs[2] // { // @2D08 storage[0x016f] // @2D13 storage[0x016f] // } 2D05 61 PUSH2 0x016f 2D08 54 SLOAD 2D09 63 PUSH4 0xffffffff 2D0E 16 AND 2D0F 5B JUMPDEST 2D10 61 PUSH2 0x016f 2D13 54 SLOAD 2D14 60 PUSH1 0x01 2D16 60 PUSH1 0x20 2D18 1B SHL 2D19 90 SWAP1 2D1A 04 DIV 2D1B 63 PUSH4 0xffffffff 2D20 16 AND 2D21 81 DUP2 2D22 11 GT 2D23 61 PUSH2 0x2dd6 2D26 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D0E stack[0] = 0xffffffff & storage[0x016f] } // Block ends with conditional jump to 0x2dd6, if 0xffffffff & storage[0x016f] > 0xffffffff & storage[0x016f] / (0x01 << 0x20) label_2D27: // Incoming jump from 0x2D26, if not stack[-1] > 0xffffffff & storage[0x016f] / (0x01 << 0x20) // Incoming jump from 0x2D26, if not 0xffffffff & storage[0x016f] > 0xffffffff & storage[0x016f] / (0x01 << 0x20) // Inputs[1] { @2D29 stack[-3] } 2D27 60 PUSH1 0x00 2D29 83 DUP4 2D2A 11 GT 2D2B 80 DUP1 2D2C 15 ISZERO 2D2D 61 PUSH2 0x2d4b 2D30 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D2A stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x2d4b, if !(stack[-3] > 0x00) label_2D31: // Incoming jump from 0x2D30, if not !(stack[-3] > 0x00) // Inputs[4] // { // @2D34 stack[-2] // @2D40 memory[0x00:0x40] // @2D41 storage[keccak256(memory[0x00:0x40])] // @2D48 stack[-6] // } 2D31 50 POP 2D32 60 PUSH1 0x00 2D34 81 DUP2 2D35 81 DUP2 2D36 52 MSTORE 2D37 61 PUSH2 0x016e 2D3A 60 PUSH1 0x20 2D3C 52 MSTORE 2D3D 60 PUSH1 0x40 2D3F 90 SWAP1 2D40 20 SHA3 2D41 54 SLOAD 2D42 63 PUSH4 0xffffffff 2D47 16 AND 2D48 85 DUP6 2D49 10 LT 2D4A 15 ISZERO 2D4B 5B JUMPDEST 2D4C 15 ISZERO 2D4D 61 PUSH2 0x2da1 2D50 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2D36 memory[0x00:0x20] = stack[-2] // @2D3C memory[0x20:0x40] = 0x016e // } // Block ends with conditional jump to 0x2da1, if !!(stack[-6] < 0xffffffff & storage[keccak256(memory[0x00:0x40])]) label_2D51: // Incoming jump from 0x2D50, if not !!(stack[-6] < 0xffffffff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2D50, if not !stack[-1] // Inputs[5] // { // @2D53 stack[-1] // @2D5F memory[0x00:0x40] // @2D60 storage[keccak256(memory[0x00:0x40])] // @2D61 stack[-3] // @2D74 stack[-2] // } 2D51 60 PUSH1 0x00 2D53 81 DUP2 2D54 81 DUP2 2D55 52 MSTORE 2D56 61 PUSH2 0x016e 2D59 60 PUSH1 0x20 2D5B 52 MSTORE 2D5C 60 PUSH1 0x40 2D5E 90 SWAP1 2D5F 20 SHA3 2D60 54 SLOAD 2D61 83 DUP4 2D62 90 SWAP1 2D63 6A PUSH11 0x084595161401484a000000 2D6F 90 SWAP1 2D70 61 PUSH2 0x2d80 2D73 90 SWAP1 2D74 85 DUP6 2D75 90 SWAP1 2D76 63 PUSH4 0xffffffff 2D7B 16 AND 2D7C 61 PUSH2 0x22d7 2D7F 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2D55 memory[0x00:0x20] = stack[-1] // @2D5B memory[0x20:0x40] = 0x016e // @2D62 stack[0] = stack[-3] // @2D6F stack[1] = 0x084595161401484a000000 // @2D73 stack[2] = 0x2d80 // @2D75 stack[3] = stack[-2] // @2D7B stack[4] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x22d7, returns to 0x2D80 label_2D80: // Incoming return from call to 0x22D7 at 0x2D7F // Incoming return from call to 0x22D7 at 0x2D7F // Inputs[2] // { // @2D84 stack[-2] // @2D85 stack[-1] // } 2D80 5B JUMPDEST 2D81 61 PUSH2 0x2d8a 2D84 91 SWAP2 2D85 90 SWAP1 2D86 61 PUSH2 0x3fa7 2D89 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2D84 stack[-2] = 0x2d8a // @2D85 stack[-1] = stack[-2] // @2D85 stack[0] = stack[-1] // } // Block ends with call to 0x3fa7, returns to 0x2D8A label_2D8A: // Incoming return from call to 0x3FA7 at 0x2D89 // Inputs[2] // { // @2D8E stack[-2] // @2D8F stack[-1] // } 2D8A 5B JUMPDEST 2D8B 61 PUSH2 0x2d94 2D8E 91 SWAP2 2D8F 90 SWAP1 2D90 61 PUSH2 0x3fc6 2D93 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2D8E stack[-2] = 0x2d94 // @2D8F stack[-1] = stack[-2] // @2D8F stack[0] = stack[-1] // } // Block ends with call to 0x3fc6, returns to 0x2D94 label_2D94: // Incoming return from call to 0x3FC6 at 0x2D93 // Inputs[2] // { // @2D98 stack[-1] // @2D99 stack[-5] // } 2D94 5B JUMPDEST 2D95 61 PUSH2 0x2d9e 2D98 90 SWAP1 2D99 85 DUP6 2D9A 61 PUSH2 0x3f5f 2D9D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2D98 stack[0] = stack[-1] // @2D98 stack[-1] = 0x2d9e // @2D99 stack[1] = stack[-5] // } // Block ends with call to 0x3f5f, returns to 0x2D9E label_2D9E: // Incoming return from call to 0x3F5F at 0x2D9D // Inputs[2] // { // @2D9F stack[-5] // @2D9F stack[-1] // } 2D9E 5B JUMPDEST 2D9F 93 SWAP4 2DA0 50 POP // Stack delta = -1 // Outputs[1] { @2D9F stack[-5] = stack[-1] } // Block continues label_2DA1: // Incoming jump from 0x2DA0 // Incoming jump from 0x2D50, if !stack[-1] // Incoming jump from 0x2D50, if !!(stack[-6] < 0xffffffff & storage[keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @2DA4 stack[-1] // @2DB0 memory[0x00:0x40] // @2DB1 storage[keccak256(memory[0x00:0x40])] // @2DC2 stack[-3] // @2DCD stack[-2] // } 2DA1 5B JUMPDEST 2DA2 60 PUSH1 0x00 2DA4 81 DUP2 2DA5 81 DUP2 2DA6 52 MSTORE 2DA7 61 PUSH2 0x016e 2DAA 60 PUSH1 0x20 2DAC 52 MSTORE 2DAD 60 PUSH1 0x40 2DAF 90 SWAP1 2DB0 20 SHA3 2DB1 54 SLOAD 2DB2 60 PUSH1 0x01 2DB4 60 PUSH1 0x01 2DB6 60 PUSH1 0x60 2DB8 1B SHL 2DB9 03 SUB 2DBA 60 PUSH1 0x01 2DBC 60 PUSH1 0x20 2DBE 1B SHL 2DBF 82 DUP3 2DC0 04 DIV 2DC1 16 AND 2DC2 93 SWAP4 2DC3 90 SWAP1 2DC4 93 SWAP4 2DC5 01 ADD 2DC6 92 SWAP3 2DC7 63 PUSH4 0xffffffff 2DCC 16 AND 2DCD 91 SWAP2 2DCE 50 POP 2DCF 60 PUSH1 0x01 2DD1 01 ADD 2DD2 61 PUSH2 0x2d0f 2DD5 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @2DA6 memory[0x00:0x20] = stack[-1] // @2DAC memory[0x20:0x40] = 0x016e // @2DC6 stack[-3] = (storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & (0x01 << 0x60) - 0x01) + stack[-3] // @2DCD stack[-2] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] // @2DD1 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2d0f label_2DD6: // Incoming jump from 0x2D26, if stack[-1] > 0xffffffff & storage[0x016f] / (0x01 << 0x20) // Incoming jump from 0x2D26, if 0xffffffff & storage[0x016f] > 0xffffffff & storage[0x016f] / (0x01 << 0x20) 2DD6 5B JUMPDEST 2DD7 50 POP // Stack delta = -1 // Block continues label_2DD8: // Incoming jump from 0x2D04, if stack[-1] // Incoming jump from 0x2DD7 // Inputs[5] // { // @2DD9 stack[-3] // @2DD9 stack[-1] // @2DDA stack[-5] // @2DDB stack[-2] // @2DDC stack[-4] // } 2DD8 5B JUMPDEST 2DD9 91 SWAP2 2DDA 93 SWAP4 2DDB 90 SWAP1 2DDC 92 SWAP3 2DDD 50 POP 2DDE 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2DD9 stack[-3] = stack[-1] // @2DDA stack[-5] = stack[-3] // @2DDC stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2DDF: // Incoming call from 0x2787, returns to 0x2788 // Incoming call from 0x2B6D, returns to 0x2B6E // Incoming call from 0x1287, returns to 0x1288 // Inputs[3] // { // @2DE8 stack[-2] // @2DF8 memory[0x00:0x40] // @2DFC storage[0x02 + keccak256(memory[0x00:0x40])] // } 2DDF 5B JUMPDEST 2DE0 60 PUSH1 0x01 2DE2 60 PUSH1 0x01 2DE4 60 PUSH1 0xa0 2DE6 1B SHL 2DE7 03 SUB 2DE8 82 DUP3 2DE9 16 AND 2DEA 60 PUSH1 0x00 2DEC 90 SWAP1 2DED 81 DUP2 2DEE 52 MSTORE 2DEF 61 PUSH2 0x0166 2DF2 60 PUSH1 0x20 2DF4 52 MSTORE 2DF5 60 PUSH1 0x40 2DF7 81 DUP2 2DF8 20 SHA3 2DF9 60 PUSH1 0x02 2DFB 01 ADD 2DFC 54 SLOAD 2DFD 63 PUSH4 0xffffffff 2E02 60 PUSH1 0x01 2E04 60 PUSH1 0x20 2E06 1B SHL 2E07 82 DUP3 2E08 04 DIV 2E09 81 DUP2 2E0A 16 AND 2E0B 91 SWAP2 2E0C 16 AND 2E0D 5B JUMPDEST 2E0E 81 DUP2 2E0F 63 PUSH4 0xffffffff 2E14 16 AND 2E15 81 DUP2 2E16 11 GT 2E17 61 PUSH2 0x24be 2E1A 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2DEC stack[0] = 0x00 // @2DEE memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2DF4 memory[0x20:0x40] = 0x0166 // @2E0B stack[1] = 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // @2E0C stack[2] = storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff // } // Block ends with conditional jump to 0x24be, if storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) label_2E1B: // Incoming jump from 0x2E1A, if not stack[-1] > 0xffffffff & stack[-2] // Incoming jump from 0x2E1A, if not storage[0x02 + keccak256(memory[0x00:0x40])] & 0xffffffff > 0xffffffff & 0xffffffff & storage[0x02 + keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // Inputs[6] // { // @2E23 stack[-5] // @2E36 memory[0x00:0x40] // @2E37 stack[-1] // @2E41 memory[0x00:0x40] // @2E42 storage[keccak256(memory[0x00:0x40])] // @2E49 stack[-4] // } 2E1B 60 PUSH1 0x01 2E1D 60 PUSH1 0x01 2E1F 60 PUSH1 0xa0 2E21 1B SHL 2E22 03 SUB 2E23 85 DUP6 2E24 16 AND 2E25 60 PUSH1 0x00 2E27 90 SWAP1 2E28 81 DUP2 2E29 52 MSTORE 2E2A 61 PUSH2 0x0166 2E2D 60 PUSH1 0x20 2E2F 90 SWAP1 2E30 81 DUP2 2E31 52 MSTORE 2E32 60 PUSH1 0x40 2E34 80 DUP1 2E35 83 DUP4 2E36 20 SHA3 2E37 84 DUP5 2E38 84 DUP5 2E39 52 MSTORE 2E3A 60 PUSH1 0x01 2E3C 01 ADD 2E3D 90 SWAP1 2E3E 91 SWAP2 2E3F 52 MSTORE 2E40 90 SWAP1 2E41 20 SHA3 2E42 54 SLOAD 2E43 63 PUSH4 0xffffffff 2E48 16 AND 2E49 84 DUP5 2E4A 11 GT 2E4B 15 ISZERO 2E4C 61 PUSH2 0x24b1 2E4F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2E29 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2E31 memory[0x20:0x40] = 0x0166 // @2E39 memory[0x00:0x20] = stack[-1] // @2E3F memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x24b1, if !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) label_2E50: // Incoming jump from 0x2E4F, if not !(stack[-4] > 0xffffffff & storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @2E58 stack[-5] // @2E6B memory[0x00:0x40] // @2E6C stack[-1] // @2E76 memory[0x00:0x40] // @2E77 storage[keccak256(memory[0x00:0x40])] // @2E8C stack[-3] // } 2E50 60 PUSH1 0x01 2E52 60 PUSH1 0x01 2E54 60 PUSH1 0xa0 2E56 1B SHL 2E57 03 SUB 2E58 85 DUP6 2E59 16 AND 2E5A 60 PUSH1 0x00 2E5C 90 SWAP1 2E5D 81 DUP2 2E5E 52 MSTORE 2E5F 61 PUSH2 0x0166 2E62 60 PUSH1 0x20 2E64 90 SWAP1 2E65 81 DUP2 2E66 52 MSTORE 2E67 60 PUSH1 0x40 2E69 80 DUP1 2E6A 83 DUP4 2E6B 20 SHA3 2E6C 84 DUP5 2E6D 84 DUP5 2E6E 52 MSTORE 2E6F 60 PUSH1 0x01 2E71 01 ADD 2E72 90 SWAP1 2E73 91 SWAP2 2E74 52 MSTORE 2E75 90 SWAP1 2E76 20 SHA3 2E77 54 SLOAD 2E78 61 PUSH2 0x2e91 2E7B 90 SWAP1 2E7C 60 PUSH1 0x01 2E7E 60 PUSH1 0x20 2E80 1B SHL 2E81 90 SWAP1 2E82 04 DIV 2E83 60 PUSH1 0x01 2E85 60 PUSH1 0x01 2E87 60 PUSH1 0x60 2E89 1B SHL 2E8A 03 SUB 2E8B 16 AND 2E8C 84 DUP5 2E8D 61 PUSH2 0x3f5f 2E90 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @2E5E memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2E66 memory[0x20:0x40] = 0x0166 // @2E6E memory[0x00:0x20] = stack[-1] // @2E74 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @2E7B stack[0] = 0x2e91 // @2E8B stack[1] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) // @2E8C stack[2] = stack[-3] // } // Block ends with call to 0x3f5f, returns to 0x2E91 label_2E91: // Incoming return from call to 0x3F5F at 0x2E90 // Inputs[3] // { // @2E92 stack[-4] // @2E92 stack[-1] // @2E96 stack[-2] // } 2E91 5B JUMPDEST 2E92 92 SWAP3 2E93 50 POP 2E94 60 PUSH1 0x01 2E96 01 ADD 2E97 61 PUSH2 0x2e0d 2E9A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2E92 stack[-4] = stack[-1] // @2E96 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x2e0d label_2E9B: // Incoming jump from 0x150E // Inputs[3] // { // @2EA4 stack[-1] // @2EB3 memory[0x00:0x40] // @2EB5 storage[keccak256(memory[0x00:0x40])] // } 2E9B 5B JUMPDEST 2E9C 60 PUSH1 0x01 2E9E 60 PUSH1 0x01 2EA0 60 PUSH1 0xa0 2EA2 1B SHL 2EA3 03 SUB 2EA4 81 DUP2 2EA5 16 AND 2EA6 60 PUSH1 0x00 2EA8 90 SWAP1 2EA9 81 DUP2 2EAA 52 MSTORE 2EAB 60 PUSH1 0xfd 2EAD 60 PUSH1 0x20 2EAF 52 MSTORE 2EB0 60 PUSH1 0x40 2EB2 90 SWAP1 2EB3 20 SHA3 2EB4 80 DUP1 2EB5 54 SLOAD 2EB6 60 PUSH1 0x01 2EB8 81 DUP2 2EB9 01 ADD 2EBA 82 DUP3 2EBB 55 SSTORE 2EBC 90 SWAP1 // Stack delta = +2 // Outputs[5] // { // @2EAA memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @2EAF memory[0x20:0x40] = 0xfd // @2EBB storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @2EBC stack[0] = storage[keccak256(memory[0x00:0x40])] // @2EBC stack[1] = keccak256(memory[0x00:0x40]) // } // Block continues label_2EBD: // Incoming jump from 0x3E2A, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x3E2A, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2EBC // Inputs[3] // { // @2EBF stack[-4] // @2EBF stack[-2] // @2EC0 stack[-3] // } 2EBD 5B JUMPDEST 2EBE 50 POP 2EBF 91 SWAP2 2EC0 90 SWAP1 2EC1 50 POP 2EC2 56 *JUMP // Stack delta = -3 // Outputs[1] { @2EBF stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2EC3: // Incoming call from 0x1D04, returns to 0x1D05 // Incoming call from 0x248D, returns to 0x248E // Inputs[2] // { // @2EC7 memory[0x40:0x60] // @2EE1 stack[-1] // } 2EC3 5B JUMPDEST 2EC4 60 PUSH1 0x40 2EC6 80 DUP1 2EC7 51 MLOAD 2EC8 60 PUSH1 0x60 2ECA 81 DUP2 2ECB 01 ADD 2ECC 82 DUP3 2ECD 52 MSTORE 2ECE 60 PUSH1 0x00 2ED0 80 DUP1 2ED1 82 DUP3 2ED2 52 MSTORE 2ED3 60 PUSH1 0x20 2ED5 82 DUP3 2ED6 01 ADD 2ED7 81 DUP2 2ED8 90 SWAP1 2ED9 52 MSTORE 2EDA 91 SWAP2 2EDB 81 DUP2 2EDC 01 ADD 2EDD 91 SWAP2 2EDE 90 SWAP1 2EDF 91 SWAP2 2EE0 52 MSTORE 2EE1 81 DUP2 2EE2 61 PUSH2 0x2eea 2EE5 81 DUP2 2EE6 61 PUSH2 0x2673 2EE9 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2ECD memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @2ED2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2ED9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @2EDF stack[0] = memory[0x40:0x60] // @2EE0 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @2EE1 stack[1] = stack[-1] // @2EE2 stack[2] = 0x2eea // @2EE5 stack[3] = stack[-1] // } // Block ends with call to 0x2673, returns to 0x2EEA label_2EEA: // Incoming return from call to 0x2673 at 0x2EE9 // Inputs[1] { @2EEB stack[-1] } 2EEA 5B JUMPDEST 2EEB 15 ISZERO 2EEC 61 PUSH2 0x2f29 2EEF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2f29, if !stack[-1] label_2EF0: // Incoming jump from 0x2EEF, if not !stack[-1] // Inputs[1] { @2EF2 memory[0x40:0x60] } 2EF0 60 PUSH1 0x40 2EF2 51 MLOAD 2EF3 62 PUSH3 0x461bcd 2EF7 60 PUSH1 0xe5 2EF9 1B SHL 2EFA 81 DUP2 2EFB 52 MSTORE 2EFC 60 PUSH1 0x20 2EFE 60 PUSH1 0x04 2F00 82 DUP3 2F01 01 ADD 2F02 52 MSTORE 2F03 60 PUSH1 0x0f 2F05 60 PUSH1 0x24 2F07 82 DUP3 2F08 01 ADD 2F09 52 MSTORE 2F0A 6E PUSH15 0x28bab2bab29034b99032b6b83a3c97 2F1A 60 PUSH1 0x89 2F1C 1B SHL 2F1D 60 PUSH1 0x44 2F1F 82 DUP3 2F20 01 ADD 2F21 52 MSTORE 2F22 60 PUSH1 0x64 2F24 01 ADD 2F25 61 PUSH2 0x0817 2F28 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2EFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2F02 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2F09 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @2F21 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x28bab2bab29034b99032b6b83a3c97 << 0x89 // @2F24 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_2F29: // Incoming jump from 0x2EEF, if !stack[-1] // Inputs[6] // { // @2F2C stack[-3] // @2F2F storage[stack[-3] + 0x01] // @2F46 memory[0x00:0x40] // @2F48 memory[0x40:0x60] // @2F50 storage[keccak256(memory[0x00:0x40])] // @2F80 stack[-2] // } 2F29 5B JUMPDEST 2F2A 60 PUSH1 0x01 2F2C 83 DUP4 2F2D 01 ADD 2F2E 80 DUP1 2F2F 54 SLOAD 2F30 63 PUSH4 0xffffffff 2F35 90 SWAP1 2F36 81 DUP2 2F37 16 AND 2F38 60 PUSH1 0x00 2F3A 81 DUP2 2F3B 81 DUP2 2F3C 52 MSTORE 2F3D 60 PUSH1 0x20 2F3F 87 DUP8 2F40 81 DUP2 2F41 52 MSTORE 2F42 60 PUSH1 0x40 2F44 80 DUP1 2F45 83 DUP4 2F46 20 SHA3 2F47 81 DUP2 2F48 51 MLOAD 2F49 60 PUSH1 0x60 2F4B 81 DUP2 2F4C 01 ADD 2F4D 83 DUP4 2F4E 52 MSTORE 2F4F 90 SWAP1 2F50 54 SLOAD 2F51 80 DUP1 2F52 87 DUP8 2F53 16 AND 2F54 82 DUP3 2F55 52 MSTORE 2F56 60 PUSH1 0x01 2F58 60 PUSH1 0x01 2F5A 60 PUSH1 0x60 2F5C 1B SHL 2F5D 03 SUB 2F5E 60 PUSH1 0x01 2F60 60 PUSH1 0x20 2F62 1B SHL 2F63 82 DUP3 2F64 04 DIV 2F65 16 AND 2F66 93 SWAP4 2F67 82 DUP3 2F68 01 ADD 2F69 93 SWAP4 2F6A 90 SWAP1 2F6B 93 SWAP4 2F6C 52 MSTORE 2F6D 60 PUSH1 0x01 2F6F 60 PUSH1 0x80 2F71 1B SHL 2F72 90 SWAP1 2F73 92 SWAP3 2F74 04 DIV 2F75 90 SWAP1 2F76 94 SWAP5 2F77 16 AND 2F78 93 SWAP4 2F79 81 DUP2 2F7A 01 ADD 2F7B 93 SWAP4 2F7C 90 SWAP1 2F7D 93 SWAP4 2F7E 52 MSTORE 2F7F 91 SWAP2 2F80 94 SWAP5 2F81 50 POP 2F82 85 DUP6 2F83 92 SWAP3 2F84 82 DUP3 2F85 61 PUSH2 0x2f8d 2F88 83 DUP4 2F89 61 PUSH2 0x4276 2F8C 56 *JUMP // Stack delta = +7 // Outputs[14] // { // @2F37 stack[2] = 0xffffffff & storage[stack[-3] + 0x01] // @2F3C memory[0x00:0x20] = 0xffffffff & storage[stack[-3] + 0x01] // @2F41 memory[0x20:0x40] = stack[-3] // @2F4E memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @2F55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] // @2F6C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x20) & (0x01 << 0x60) - 0x01 // @2F7E memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0xffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0x80) // @2F7F stack[1] = 0x00 // @2F80 stack[-2] = memory[0x40:0x60] // @2F83 stack[3] = stack[-3] + 0x01 // @2F83 stack[0] = stack[-3] // @2F84 stack[4] = 0x00 // @2F85 stack[5] = 0x2f8d // @2F88 stack[6] = 0xffffffff & storage[stack[-3] + 0x01] // } // Block ends with call to 0x4276, returns to 0x2F8D label_2F8D: // Incoming return from call to 0x4276 at 0x2F8C // Inputs[12] // { // @2F8E stack[-3] // @2F8F storage[stack[-3]] // @2F93 stack[-2] // @2FA3 stack[-1] // @2FAB stack[-4] // @2FAC stack[-5] // @2FB2 stack[-6] // @2FBB memory[0x00:0x00 + 0x40 + stack[-5]] // @2FBD storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-5]])] // @2FCB stack[-8] // @2FCB stack[-10] // @2FCC stack[-9] // } 2F8D 5B JUMPDEST 2F8E 82 DUP3 2F8F 54 SLOAD 2F90 61 PUSH2 0x0100 2F93 92 SWAP3 2F94 90 SWAP1 2F95 92 SWAP3 2F96 0A EXP 2F97 63 PUSH4 0xffffffff 2F9C 81 DUP2 2F9D 81 DUP2 2F9E 02 MUL 2F9F 19 NOT 2FA0 90 SWAP1 2FA1 93 SWAP4 2FA2 16 AND 2FA3 91 SWAP2 2FA4 83 DUP4 2FA5 16 AND 2FA6 02 MUL 2FA7 17 OR 2FA8 90 SWAP1 2FA9 91 SWAP2 2FAA 55 SSTORE 2FAB 16 AND 2FAC 81 DUP2 2FAD 52 MSTORE 2FAE 60 PUSH1 0x20 2FB0 81 DUP2 2FB1 01 ADD 2FB2 91 SWAP2 2FB3 90 SWAP1 2FB4 91 SWAP2 2FB5 52 MSTORE 2FB6 60 PUSH1 0x40 2FB8 01 ADD 2FB9 60 PUSH1 0x00 2FBB 20 SHA3 2FBC 80 DUP1 2FBD 54 SLOAD 2FBE 60 PUSH1 0x01 2FC0 60 PUSH1 0x01 2FC2 60 PUSH1 0xa0 2FC4 1B SHL 2FC5 03 SUB 2FC6 19 NOT 2FC7 16 AND 2FC8 90 SWAP1 2FC9 55 SSTORE 2FCA 50 POP 2FCB 91 SWAP2 2FCC 90 SWAP1 2FCD 50 POP 2FCE 56 *JUMP // Stack delta = -9 // Outputs[5] // { // @2FAA storage[stack[-3]] = (0xffffffff & stack[-1]) * 0x0100 ** stack[-2] | (storage[stack[-3]] & ~(0xffffffff * 0x0100 ** stack[-2])) // @2FAD memory[stack[-5]:stack[-5] + 0x20] = 0xffffffff & stack[-4] // @2FB5 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] = stack[-6] // @2FC9 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-5]])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-5]])] // @2FCB stack[-10] = stack[-8] // } // Block ends with unconditional jump to stack[-10] label_2FCF: // Incoming call from 0x208C, returns to 0x208D // Inputs[2] // { // @2FD8 stack[-2] // @2FD9 stack[-1] // } 2FCF 5B JUMPDEST 2FD0 60 PUSH1 0x00 2FD2 80 DUP1 2FD3 60 PUSH1 0x00 2FD5 61 PUSH2 0x2fde 2FD8 85 DUP6 2FD9 85 DUP6 2FDA 61 PUSH2 0x34bb 2FDD 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2FD0 stack[0] = 0x00 // @2FD2 stack[1] = 0x00 // @2FD3 stack[2] = 0x00 // @2FD5 stack[3] = 0x2fde // @2FD8 stack[4] = stack[-2] // @2FD9 stack[5] = stack[-1] // } // Block ends with call to 0x34bb, returns to 0x2FDE label_2FDE: // Incoming return from call to 0x34BB at 0x2FDD // Inputs[4] // { // @2FDF stack[-3] // @2FDF stack[-1] // @2FE1 stack[-2] // @2FE1 stack[-4] // } 2FDE 5B JUMPDEST 2FDF 91 SWAP2 2FE0 50 POP 2FE1 91 SWAP2 2FE2 50 POP 2FE3 61 PUSH2 0x2feb 2FE6 81 DUP2 2FE7 61 PUSH2 0x3305 2FEA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2FDF stack[-3] = stack[-1] // @2FE1 stack[-4] = stack[-2] // @2FE3 stack[-2] = 0x2feb // @2FE6 stack[-1] = stack[-1] // } // Block ends with call to 0x3305, returns to 0x2FEB label_2FEB: // Incoming return from call to 0x3305 at 0x2FEA // Inputs[3] // { // @2FED stack[-2] // @2FED stack[-6] // @2FEE stack[-5] // } 2FEB 5B JUMPDEST 2FEC 50 POP 2FED 93 SWAP4 2FEE 92 SWAP3 2FEF 50 POP 2FF0 50 POP 2FF1 50 POP 2FF2 56 *JUMP // Stack delta = -5 // Outputs[1] { @2FED stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_2FF3: // Incoming call from 0x28A2, returns to 0x0CD3 // Inputs[2] // { // @2FF7 stack[-2] // @2FF8 stack[-1] // } 2FF3 5B JUMPDEST 2FF4 61 PUSH2 0x2ffd 2FF7 82 DUP3 2FF8 82 DUP3 2FF9 61 PUSH2 0x13b7 2FFC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2FF4 stack[0] = 0x2ffd // @2FF7 stack[1] = stack[-2] // @2FF8 stack[2] = stack[-1] // } // Block ends with call to 0x13b7, returns to 0x2FFD label_2FFD: // Incoming return from call to 0x13B7 at 0x2FFC // Inputs[1] { @3001 stack[-1] } 2FFD 5B JUMPDEST 2FFE 61 PUSH2 0x0c9e 3001 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c9e, if stack[-1] label_3002: // Incoming jump from 0x3001, if not stack[-1] // Inputs[1] { @3005 stack[-1] } 3002 61 PUSH2 0x3015 3005 81 DUP2 3006 60 PUSH1 0x01 3008 60 PUSH1 0x01 300A 60 PUSH1 0xa0 300C 1B SHL 300D 03 SUB 300E 16 AND 300F 60 PUSH1 0x14 3011 61 PUSH2 0x3528 3014 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3002 stack[0] = 0x3015 // @300E stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @300F stack[2] = 0x14 // } // Block ends with call to 0x3528, returns to 0x3015 label_3015: // Incoming return from call to 0x3528 at 0x3014 // Inputs[1] { @3019 stack[-3] } 3015 5B JUMPDEST 3016 61 PUSH2 0x3020 3019 83 DUP4 301A 60 PUSH1 0x20 301C 61 PUSH2 0x3528 301F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3016 stack[0] = 0x3020 // @3019 stack[1] = stack[-3] // @301A stack[2] = 0x20 // } // Block ends with call to 0x3528, returns to 0x3020 label_3020: // Incoming return from call to 0x3528 at 0x301F // Inputs[3] // { // @3023 memory[0x40:0x60] // @302A stack[-2] // @302B stack[-1] // } 3020 5B JUMPDEST 3021 60 PUSH1 0x40 3023 51 MLOAD 3024 60 PUSH1 0x20 3026 01 ADD 3027 61 PUSH2 0x3031 302A 92 SWAP3 302B 91 SWAP2 302C 90 SWAP1 302D 61 PUSH2 0x4341 3030 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @302A stack[-2] = 0x3031 // @302B stack[-1] = stack[-2] // @302C stack[1] = 0x20 + memory[0x40:0x60] // @302C stack[0] = stack[-1] // } // Block ends with call to 0x4341, returns to 0x3031 label_3031: // Incoming return from call to 0x4341 at 0x3030 // Inputs[2] // { // @3035 memory[0x40:0x60] // @303A stack[-1] // } 3031 5B JUMPDEST 3032 60 PUSH1 0x40 3034 80 DUP1 3035 51 MLOAD 3036 60 PUSH1 0x1f 3038 19 NOT 3039 81 DUP2 303A 84 DUP5 303B 03 SUB 303C 01 ADD 303D 81 DUP2 303E 52 MSTORE 303F 90 SWAP1 3040 82 DUP3 3041 90 SWAP1 3042 52 MSTORE 3043 62 PUSH3 0x461bcd 3047 60 PUSH1 0xe5 3049 1B SHL 304A 82 DUP3 304B 52 MSTORE 304C 61 PUSH2 0x0817 304F 91 SWAP2 3050 60 PUSH1 0x04 3052 01 ADD 3053 61 PUSH2 0x39cb 3056 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @303E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @303F stack[0] = memory[0x40:0x60] // @3042 memory[0x40:0x60] = stack[-1] // @304B memory[stack[-1]:stack[-1] + 0x20] = 0x461bcd << 0xe5 // @304F stack[-1] = 0x0817 // @3052 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x39cb, returns to 0x0817 label_3057: // Incoming call from 0x2956, returns to 0x2957 3057 5B JUMPDEST 3058 60 PUSH1 0x00 305A 61 PUSH2 0x3061 305D 61 PUSH2 0x06a7 3060 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3058 stack[0] = 0x00 // @305A stack[1] = 0x3061 // } // Block ends with call to 0x06a7, returns to 0x3061 label_3061: // Incoming return from call to 0x0F9C at 0x3076 // Incoming return from call to 0x06A7 at 0x3060 // Inputs[5] // { // @3062 stack[-1] // @3063 memory[stack[-1]:stack[-1] + 0x20] // @3068 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // @3069 stack[-2] // @306B stack[-3] // } 3061 5B JUMPDEST 3062 80 DUP1 3063 51 MLOAD 3064 90 SWAP1 3065 60 PUSH1 0x20 3067 01 ADD 3068 20 SHA3 3069 90 SWAP1 306A 50 POP 306B 90 SWAP1 306C 56 *JUMP // Stack delta = -2 // Outputs[1] { @306B stack[-3] = keccak256(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]) } // Block ends with unconditional jump to stack[-3] label_306D: // Incoming jump from 0x295E 306D 5B JUMPDEST 306E 60 PUSH1 0x00 3070 61 PUSH2 0x3061 3073 61 PUSH2 0x0f9c 3076 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @306E stack[0] = 0x00 // @3070 stack[1] = 0x3061 // } // Block ends with call to 0x0f9c, returns to 0x3061 label_3077: // Incoming jump from 0x2A69 // Inputs[1] { @307A storage[0x00] } 3077 5B JUMPDEST 3078 60 PUSH1 0x00 307A 54 SLOAD 307B 61 PUSH2 0x0100 307E 90 SWAP1 307F 04 DIV 3080 60 PUSH1 0xff 3082 16 AND 3083 61 PUSH2 0x309e 3086 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x309e, if 0xff & storage[0x00] / 0x0100 label_3087: // Incoming jump from 0x3086, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @3089 memory[0x40:0x60] } 3087 60 PUSH1 0x40 3089 51 MLOAD 308A 62 PUSH3 0x461bcd 308E 60 PUSH1 0xe5 3090 1B SHL 3091 81 DUP2 3092 52 MSTORE 3093 60 PUSH1 0x04 3095 01 ADD 3096 61 PUSH2 0x0817 3099 90 SWAP1 309A 61 PUSH2 0x42b1 309D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3092 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3099 stack[0] = 0x0817 // @3099 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42b1, returns to 0x0817 label_309E: // Incoming jump from 0x3086, if 0xff & storage[0x00] / 0x0100 // Inputs[2] // { // @30A2 stack[-3] // @30A3 stack[-2] // } 309E 5B JUMPDEST 309F 61 PUSH2 0x30a8 30A2 83 DUP4 30A3 83 DUP4 30A4 61 PUSH2 0x36c3 30A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @309F stack[0] = 0x30a8 // @30A2 stack[1] = stack[-3] // @30A3 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x36c3 30A8 5B JUMPDEST 30A9 61 PUSH2 0x30b1 30AC 83 DUP4 30AD 61 PUSH2 0x36f4 30B0 56 *JUMP 30B1 5B JUMPDEST 30B2 61 PUSH2 0x0130 30B5 80 DUP1 30B6 54 SLOAD 30B7 60 PUSH1 0xff 30B9 19 NOT 30BA 16 AND 30BB 60 PUSH1 0xff 30BD 92 SWAP3 30BE 90 SWAP1 30BF 92 SWAP3 30C0 16 AND 30C1 91 SWAP2 30C2 90 SWAP1 30C3 91 SWAP2 30C4 17 OR 30C5 90 SWAP1 30C6 55 SSTORE 30C7 50 POP 30C8 50 POP 30C9 56 *JUMP 30CA 5B JUMPDEST 30CB 60 PUSH1 0x00 30CD 54 SLOAD 30CE 61 PUSH2 0x0100 30D1 90 SWAP1 30D2 04 DIV 30D3 60 PUSH1 0xff 30D5 16 AND 30D6 61 PUSH2 0x30f1 30D9 57 *JUMPI 30DA 60 PUSH1 0x40 30DC 51 MLOAD 30DD 62 PUSH3 0x461bcd 30E1 60 PUSH1 0xe5 30E3 1B SHL 30E4 81 DUP2 30E5 52 MSTORE 30E6 60 PUSH1 0x04 30E8 01 ADD 30E9 61 PUSH2 0x0817 30EC 90 SWAP1 30ED 61 PUSH2 0x42b1 30F0 56 *JUMP 30F1 5B JUMPDEST 30F2 61 PUSH2 0x0174 30F5 80 DUP1 30F6 54 SLOAD 30F7 60 PUSH1 0x01 30F9 60 PUSH1 0x01 30FB 60 PUSH1 0xa0 30FD 1B SHL 30FE 03 SUB 30FF 19 NOT 3100 16 AND 3101 60 PUSH1 0x01 3103 60 PUSH1 0x01 3105 60 PUSH1 0xa0 3107 1B SHL 3108 03 SUB 3109 83 DUP4 310A 16 AND 310B 17 OR 310C 90 SWAP1 310D 55 SSTORE 310E 61 PUSH2 0x0cd3 3111 61 PUSH2 0x016e 3114 61 PUSH2 0x23e0 3117 56 *JUMP label_3118: // Incoming call from 0x2C15, returns to 0x0C9E // Inputs[8] // { // @311B memory[0x40:0x60] // @311C stack[-1] // @3127 stack[-2] // @312A msg.sender // @3153 memory[0x40:0x60] // @3158 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3171 memory[0x00:0x40] // @3175 storage[0x06 + keccak256(memory[0x00:0x40])] // } 3118 5B JUMPDEST 3119 60 PUSH1 0x40 311B 51 MLOAD 311C 81 DUP2 311D 81 DUP2 311E 52 MSTORE 311F 60 PUSH1 0x01 3121 60 PUSH1 0x01 3123 60 PUSH1 0xa0 3125 1B SHL 3126 03 SUB 3127 83 DUP4 3128 16 AND 3129 90 SWAP1 312A 33 CALLER 312B 90 SWAP1 312C 7F PUSH32 0xab8530f87dc9b59234c4623bf917212bb2536d647574c8e7e5da92c2ede0c9f8 314D 90 SWAP1 314E 60 PUSH1 0x20 3150 01 ADD 3151 60 PUSH1 0x40 3153 51 MLOAD 3154 80 DUP1 3155 91 SWAP2 3156 03 SUB 3157 90 SWAP1 3158 A3 LOG3 3159 60 PUSH1 0x01 315B 60 PUSH1 0x01 315D 60 PUSH1 0xa0 315F 1B SHL 3160 03 SUB 3161 82 DUP3 3162 16 AND 3163 60 PUSH1 0x00 3165 90 SWAP1 3166 81 DUP2 3167 52 MSTORE 3168 61 PUSH2 0x0166 316B 60 PUSH1 0x20 316D 52 MSTORE 316E 60 PUSH1 0x40 3170 90 SWAP1 3171 20 SHA3 3172 60 PUSH1 0x06 3174 01 ADD 3175 54 SLOAD 3176 5B JUMPDEST 3177 80 DUP1 3178 15 ISZERO 3179 61 PUSH2 0x3217 317C 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @311E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @3158 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xab8530f87dc9b59234c4623bf917212bb2536d647574c8e7e5da92c2ede0c9f8, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // @3167 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @316D memory[0x20:0x40] = 0x0166 // @3175 stack[0] = storage[0x06 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x3217, if !storage[0x06 + keccak256(memory[0x00:0x40])] label_317D: // Incoming jump from 0x317C, if not !stack[-1] // Incoming jump from 0x317C, if not !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[3] // { // @3185 stack[-3] // @3195 memory[0x00:0x40] // @319F stack[-1] // } 317D 60 PUSH1 0x01 317F 60 PUSH1 0x01 3181 60 PUSH1 0xa0 3183 1B SHL 3184 03 SUB 3185 83 DUP4 3186 16 AND 3187 60 PUSH1 0x00 3189 90 SWAP1 318A 81 DUP2 318B 52 MSTORE 318C 61 PUSH2 0x0166 318F 60 PUSH1 0x20 3191 52 MSTORE 3192 60 PUSH1 0x40 3194 81 DUP2 3195 20 SHA3 3196 60 PUSH1 0x05 3198 01 ADD 3199 90 SWAP1 319A 61 PUSH2 0x31a4 319D 60 PUSH1 0x01 319F 84 DUP5 31A0 61 PUSH2 0x3f77 31A3 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @318B memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @3191 memory[0x20:0x40] = 0x0166 // @3199 stack[0] = 0x05 + keccak256(memory[0x00:0x40]) // @3199 stack[1] = 0x00 // @319A stack[2] = 0x31a4 // @319D stack[3] = 0x01 // @319F stack[4] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x31A4 label_31A4: // Incoming return from call to 0x3F77 at 0x31A3 // Inputs[6] // { // @31A5 stack[-2] // @31A6 stack[-1] // @31AA stack[-3] // @31B2 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @31B3 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @31B4 block.number // } 31A4 5B JUMPDEST 31A5 81 DUP2 31A6 52 MSTORE 31A7 60 PUSH1 0x20 31A9 01 ADD 31AA 90 SWAP1 31AB 81 DUP2 31AC 52 MSTORE 31AD 60 PUSH1 0x20 31AF 01 ADD 31B0 60 PUSH1 0x00 31B2 20 SHA3 31B3 54 SLOAD 31B4 43 NUMBER 31B5 11 GT 31B6 15 ISZERO 31B7 61 PUSH2 0x320e 31BA 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @31A6 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @31AC memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x320e, if !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) label_31BB: // Incoming jump from 0x31BA, if not !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[4] // { // @31C3 stack[-3] // @31D3 memory[0x00:0x40] // @31D4 stack[-2] // @31E1 stack[-1] // } 31BB 60 PUSH1 0x01 31BD 60 PUSH1 0x01 31BF 60 PUSH1 0xa0 31C1 1B SHL 31C2 03 SUB 31C3 83 DUP4 31C4 16 AND 31C5 60 PUSH1 0x00 31C7 90 SWAP1 31C8 81 DUP2 31C9 52 MSTORE 31CA 61 PUSH2 0x0166 31CD 60 PUSH1 0x20 31CF 52 MSTORE 31D0 60 PUSH1 0x40 31D2 81 DUP2 31D3 20 SHA3 31D4 83 DUP4 31D5 91 SWAP2 31D6 60 PUSH1 0x04 31D8 90 SWAP1 31D9 91 SWAP2 31DA 01 ADD 31DB 90 SWAP1 31DC 61 PUSH2 0x31e6 31DF 60 PUSH1 0x01 31E1 85 DUP6 31E2 61 PUSH2 0x3f77 31E5 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @31C9 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @31CF memory[0x20:0x40] = 0x0166 // @31D5 stack[0] = stack[-2] // @31DB stack[1] = keccak256(memory[0x00:0x40]) + 0x04 // @31DB stack[2] = 0x00 // @31DC stack[3] = 0x31e6 // @31DF stack[4] = 0x01 // @31E1 stack[5] = stack[-1] // } // Block ends with call to 0x3f77, returns to 0x31E6 label_31E6: // Incoming return from call to 0x3F77 at 0x31E5 // Inputs[6] // { // @31E7 stack[-2] // @31E8 stack[-1] // @31EC stack[-3] // @31F4 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @31F7 stack[-4] // @31F9 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // } 31E6 5B JUMPDEST 31E7 81 DUP2 31E8 52 MSTORE 31E9 60 PUSH1 0x20 31EB 01 ADD 31EC 90 SWAP1 31ED 81 DUP2 31EE 52 MSTORE 31EF 60 PUSH1 0x20 31F1 01 ADD 31F2 60 PUSH1 0x00 31F4 20 SHA3 31F5 60 PUSH1 0x00 31F7 82 DUP3 31F8 82 DUP3 31F9 54 SLOAD 31FA 61 PUSH2 0x3203 31FD 91 SWAP2 31FE 90 SWAP1 31FF 61 PUSH2 0x3f5f 3202 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @31E8 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @31EE memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @31F4 stack[-3] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @31F5 stack[-2] = 0x00 // @31FD stack[-1] = 0x3203 // @31FE stack[0] = stack[-4] // @31FE stack[1] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // } // Block ends with call to 0x3f5f, returns to 0x3203 label_3203: // Incoming return from call to 0x3F5F at 0x3202 // Inputs[4] // { // @3204 stack[-2] // @3204 stack[-1] // @3205 stack[-3] // @320B stack[-4] // } 3203 5B JUMPDEST 3204 90 SWAP1 3205 91 SWAP2 3206 55 SSTORE 3207 50 POP 3208 61 PUSH2 0x3217 320B 90 SWAP1 320C 50 POP 320D 56 *JUMP // Stack delta = -4 // Outputs[1] { @3206 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to 0x3217 label_320E: // Incoming jump from 0x31BA, if !(block.number > storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])]) // Inputs[1] { @3212 stack[-1] } 320E 5B JUMPDEST 320F 60 PUSH1 0x00 3211 19 NOT 3212 01 ADD 3213 61 PUSH2 0x3176 3216 56 *JUMP // Stack delta = +0 // Outputs[1] { @3212 stack[-1] = ~0x00 + stack[-1] } // Block ends with unconditional jump to 0x3176 label_3217: // Incoming jump from 0x317C, if !stack[-1] // Incoming jump from 0x320D // Incoming jump from 0x317C, if !storage[0x06 + keccak256(memory[0x00:0x40])] // Inputs[2] // { // @321C stack[-3] // @321D stack[-2] // } 3217 5B JUMPDEST 3218 50 POP 3219 61 PUSH2 0x0c9e 321C 82 DUP3 321D 82 DUP3 321E 61 PUSH2 0x373e 3221 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3219 stack[-1] = 0x0c9e // @321C stack[0] = stack[-3] // @321D stack[1] = stack[-2] // } // Block ends with call to 0x373e, returns to 0x0C9E label_3222: // Incoming call from 0x3847, returns to 0x3848 // Incoming call from 0x34E5, returns to 0x34E6 // Inputs[1] { @323D stack[-1] } 3222 5B JUMPDEST 3223 60 PUSH1 0x00 3225 80 DUP1 3226 6F PUSH16 0xa2a8918ca85bafe22016d0b997e4df60 3237 60 PUSH1 0x01 3239 60 PUSH1 0xff 323B 1B SHL 323C 03 SUB 323D 83 DUP4 323E 11 GT 323F 15 ISZERO 3240 61 PUSH2 0x324f 3243 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3223 stack[0] = 0x00 // @3225 stack[1] = 0x00 // } // Block ends with conditional jump to 0x324f, if !(stack[-1] > (0x01 << 0xff) - 0xa2a8918ca85bafe22016d0b997e4df60) label_3244: // Incoming jump from 0x3243, if not !(stack[-1] > (0x01 << 0xff) - 0xa2a8918ca85bafe22016d0b997e4df60) // Inputs[1] { @3247 stack[-2] } 3244 50 POP 3245 60 PUSH1 0x00 3247 90 SWAP1 3248 50 POP 3249 60 PUSH1 0x03 324B 61 PUSH2 0x32fc 324E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3247 stack[-2] = 0x00 // @3249 stack[-1] = 0x03 // } // Block ends with unconditional jump to 0x32fc label_324F: // Incoming jump from 0x3243, if !(stack[-1] > (0x01 << 0xff) - 0xa2a8918ca85bafe22016d0b997e4df60) // Inputs[1] { @3250 stack[-5] } 324F 5B JUMPDEST 3250 84 DUP5 3251 60 PUSH1 0xff 3253 16 AND 3254 60 PUSH1 0x1b 3256 14 EQ 3257 15 ISZERO 3258 80 DUP1 3259 15 ISZERO 325A 61 PUSH2 0x3267 325D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3257 stack[0] = !(0x1b == 0xff & stack[-5]) } // Block ends with conditional jump to 0x3267, if !!(0x1b == 0xff & stack[-5]) label_325E: // Incoming jump from 0x325D, if not !!(0x1b == 0xff & stack[-5]) // Inputs[1] { @325F stack[-6] } 325E 50 POP 325F 84 DUP5 3260 60 PUSH1 0xff 3262 16 AND 3263 60 PUSH1 0x1c 3265 14 EQ 3266 15 ISZERO 3267 5B JUMPDEST 3268 15 ISZERO 3269 61 PUSH2 0x3278 326C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3278, if !!(0x1c == 0xff & stack[-6]) label_326D: // Incoming jump from 0x326C, if not !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x326C, if not !stack[-1] // Inputs[1] { @3270 stack[-2] } 326D 50 POP 326E 60 PUSH1 0x00 3270 90 SWAP1 3271 50 POP 3272 60 PUSH1 0x04 3274 61 PUSH2 0x32fc 3277 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3270 stack[-2] = 0x00 // @3272 stack[-1] = 0x04 // } // Block ends with unconditional jump to 0x32fc label_3278: // Incoming jump from 0x326C, if !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x326C, if !stack[-1] // Inputs[9] // { // @327C memory[0x40:0x60] // @3289 stack[-6] // @328E stack[-5] // @329B stack[-4] // @32A2 stack[-3] // @32AF memory[0x40:0x60] // @32BA msg.gas // @32BB address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @32BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3278 5B JUMPDEST 3279 60 PUSH1 0x40 327B 80 DUP1 327C 51 MLOAD 327D 60 PUSH1 0x00 327F 80 DUP1 3280 82 DUP3 3281 52 MSTORE 3282 60 PUSH1 0x20 3284 82 DUP3 3285 01 ADD 3286 80 DUP1 3287 84 DUP5 3288 52 MSTORE 3289 89 DUP10 328A 90 SWAP1 328B 52 MSTORE 328C 60 PUSH1 0xff 328E 88 DUP9 328F 16 AND 3290 92 SWAP3 3291 82 DUP3 3292 01 ADD 3293 92 SWAP3 3294 90 SWAP1 3295 92 SWAP3 3296 52 MSTORE 3297 60 PUSH1 0x60 3299 81 DUP2 329A 01 ADD 329B 86 DUP7 329C 90 SWAP1 329D 52 MSTORE 329E 60 PUSH1 0x80 32A0 81 DUP2 32A1 01 ADD 32A2 85 DUP6 32A3 90 SWAP1 32A4 52 MSTORE 32A5 60 PUSH1 0x01 32A7 90 SWAP1 32A8 60 PUSH1 0xa0 32AA 01 ADD 32AB 60 PUSH1 0x20 32AD 60 PUSH1 0x40 32AF 51 MLOAD 32B0 60 PUSH1 0x20 32B2 81 DUP2 32B3 03 SUB 32B4 90 SWAP1 32B5 80 DUP1 32B6 84 DUP5 32B7 03 SUB 32B8 90 SWAP1 32B9 85 DUP6 32BA 5A GAS 32BB FA STATICCALL 32BC 15 ISZERO 32BD 80 DUP1 32BE 15 ISZERO 32BF 61 PUSH2 0x32cc 32C2 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @3281 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @3288 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @328B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @3295 stack[0] = 0x00 // @3296 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] & 0xff // @329D memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] // @32A4 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-3] // @32A7 stack[1] = 0x01 // @32AA stack[2] = 0xa0 + memory[0x40:0x60] // @32BB memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @32BC stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x32cc, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_32C3: // Incoming jump from 0x32C2, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @32C3 returndata.length // @32C7 returndata[0x00:0x00 + returndata.length] // @32C8 returndata.length // @32CB memory[0x00:0x00 + returndata.length] // } 32C3 3D RETURNDATASIZE 32C4 60 PUSH1 0x00 32C6 80 DUP1 32C7 3E RETURNDATACOPY 32C8 3D RETURNDATASIZE 32C9 60 PUSH1 0x00 32CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @32C7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @32CB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_32CC: // Incoming jump from 0x32C2, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @32D1 memory[0x40:0x60] // @32D6 memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @32D7 stack[-4] // } 32CC 5B JUMPDEST 32CD 50 POP 32CE 50 POP 32CF 60 PUSH1 0x40 32D1 51 MLOAD 32D2 60 PUSH1 0x1f 32D4 19 NOT 32D5 01 ADD 32D6 51 MLOAD 32D7 91 SWAP2 32D8 50 POP 32D9 50 POP 32DA 60 PUSH1 0x01 32DC 60 PUSH1 0x01 32DE 60 PUSH1 0xa0 32E0 1B SHL 32E1 03 SUB 32E2 81 DUP2 32E3 16 AND 32E4 61 PUSH2 0x32f5 32E7 57 *JUMPI // Stack delta = -3 // Outputs[1] { @32D7 stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x32f5, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_32E8: // Incoming jump from 0x32E7, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @32EC stack[-2] // @32EE stack[-3] // } 32E8 60 PUSH1 0x00 32EA 60 PUSH1 0x01 32EC 92 SWAP3 32ED 50 POP 32EE 92 SWAP3 32EF 50 POP 32F0 50 POP 32F1 61 PUSH2 0x32fc 32F4 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @32EC stack[-2] = 0x01 // @32EE stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x32fc label_32F5: // Incoming jump from 0x32E7, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @32F6 stack[-3] // @32F6 stack[-1] // @32FA stack[-2] // } 32F5 5B JUMPDEST 32F6 91 SWAP2 32F7 50 POP 32F8 60 PUSH1 0x00 32FA 90 SWAP1 32FB 50 POP // Stack delta = -1 // Outputs[2] // { // @32F6 stack[-3] = stack[-1] // @32FA stack[-2] = 0x00 // } // Block continues label_32FC: // Incoming jump from 0x32F4 // Incoming jump from 0x324E // Incoming jump from 0x3277 // Incoming jump from 0x32FB // Inputs[5] // { // @32FD stack[-1] // @32FD stack[-6] // @32FF stack[-2] // @32FF stack[-7] // @3300 stack[-5] // } 32FC 5B JUMPDEST 32FD 94 SWAP5 32FE 50 POP 32FF 94 SWAP5 3300 92 SWAP3 3301 50 POP 3302 50 POP 3303 50 POP 3304 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @32FD stack[-6] = stack[-1] // @32FF stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_3305: // Incoming call from 0x2FEA, returns to 0x2FEB // Inputs[1] { @3308 stack[-1] } 3305 5B JUMPDEST 3306 60 PUSH1 0x00 3308 81 DUP2 3309 60 PUSH1 0x04 330B 81 DUP2 330C 11 GT 330D 15 ISZERO 330E 61 PUSH2 0x3319 3311 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3306 stack[0] = 0x00 // @3308 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3319, if !(stack[-1] > 0x04) label_3312: // Incoming jump from 0x3311, if not !(stack[-1] > 0x04) 3312 61 PUSH2 0x3319 3315 61 PUSH2 0x3e40 3318 56 *JUMP // Stack delta = +1 // Outputs[1] { @3312 stack[0] = 0x3319 } // Block ends with unconditional jump to 0x3e40 label_3319: // Incoming jump from 0x3311, if !(stack[-1] > 0x04) // Inputs[2] // { // @331A stack[-1] // @331A stack[-2] // } 3319 5B JUMPDEST 331A 14 EQ 331B 15 ISZERO 331C 61 PUSH2 0x3322 331F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3322, if !(stack[-1] == stack[-2]) label_3320: // Incoming jump from 0x331F, if not !(stack[-1] == stack[-2]) // Inputs[1] { @3321 stack[-2] } 3320 50 POP 3321 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_3322: // Incoming jump from 0x331F, if !(stack[-1] == stack[-2]) // Inputs[1] { @3325 stack[-1] } 3322 5B JUMPDEST 3323 60 PUSH1 0x01 3325 81 DUP2 3326 60 PUSH1 0x04 3328 81 DUP2 3329 11 GT 332A 15 ISZERO 332B 61 PUSH2 0x3336 332E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3323 stack[0] = 0x01 // @3325 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3336, if !(stack[-1] > 0x04) label_332F: // Incoming jump from 0x332E, if not !(stack[-1] > 0x04) 332F 61 PUSH2 0x3336 3332 61 PUSH2 0x3e40 3335 56 *JUMP // Stack delta = +1 // Outputs[1] { @332F stack[0] = 0x3336 } // Block ends with unconditional jump to 0x3e40 label_3336: // Incoming jump from 0x332E, if !(stack[-1] > 0x04) // Inputs[2] // { // @3337 stack[-2] // @3337 stack[-1] // } 3336 5B JUMPDEST 3337 14 EQ 3338 15 ISZERO 3339 61 PUSH2 0x337f 333C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x337f, if !(stack[-1] == stack[-2]) label_333D: // Incoming jump from 0x333C, if not !(stack[-1] == stack[-2]) // Inputs[1] { @333F memory[0x40:0x60] } 333D 60 PUSH1 0x40 333F 51 MLOAD 3340 62 PUSH3 0x461bcd 3344 60 PUSH1 0xe5 3346 1B SHL 3347 81 DUP2 3348 52 MSTORE 3349 60 PUSH1 0x20 334B 60 PUSH1 0x04 334D 82 DUP3 334E 01 ADD 334F 52 MSTORE 3350 60 PUSH1 0x18 3352 60 PUSH1 0x24 3354 82 DUP3 3355 01 ADD 3356 52 MSTORE 3357 77 PUSH24 0x45434453413a20696e76616c6964207369676e6174757265 3370 60 PUSH1 0x40 3372 1B SHL 3373 60 PUSH1 0x44 3375 82 DUP3 3376 01 ADD 3377 52 MSTORE 3378 60 PUSH1 0x64 337A 01 ADD 337B 61 PUSH2 0x0817 337E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3348 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @334F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3356 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @3377 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265 << 0x40 // @337A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_337F: // Incoming jump from 0x333C, if !(stack[-1] == stack[-2]) // Inputs[1] { @3382 stack[-1] } 337F 5B JUMPDEST 3380 60 PUSH1 0x02 3382 81 DUP2 3383 60 PUSH1 0x04 3385 81 DUP2 3386 11 GT 3387 15 ISZERO 3388 61 PUSH2 0x3393 338B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3380 stack[0] = 0x02 // @3382 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3393, if !(stack[-1] > 0x04) label_338C: // Incoming jump from 0x338B, if not !(stack[-1] > 0x04) 338C 61 PUSH2 0x3393 338F 61 PUSH2 0x3e40 3392 56 *JUMP // Stack delta = +1 // Outputs[1] { @338C stack[0] = 0x3393 } // Block ends with unconditional jump to 0x3e40 label_3393: // Incoming jump from 0x338B, if !(stack[-1] > 0x04) // Inputs[2] // { // @3394 stack[-1] // @3394 stack[-2] // } 3393 5B JUMPDEST 3394 14 EQ 3395 15 ISZERO 3396 61 PUSH2 0x33e1 3399 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x33e1, if !(stack[-1] == stack[-2]) label_339A: // Incoming jump from 0x3399, if not !(stack[-1] == stack[-2]) // Inputs[1] { @339C memory[0x40:0x60] } 339A 60 PUSH1 0x40 339C 51 MLOAD 339D 62 PUSH3 0x461bcd 33A1 60 PUSH1 0xe5 33A3 1B SHL 33A4 81 DUP2 33A5 52 MSTORE 33A6 60 PUSH1 0x20 33A8 60 PUSH1 0x04 33AA 82 DUP3 33AB 01 ADD 33AC 52 MSTORE 33AD 60 PUSH1 0x1f 33AF 60 PUSH1 0x24 33B1 82 DUP3 33B2 01 ADD 33B3 52 MSTORE 33B4 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 33D5 60 PUSH1 0x44 33D7 82 DUP3 33D8 01 ADD 33D9 52 MSTORE 33DA 60 PUSH1 0x64 33DC 01 ADD 33DD 61 PUSH2 0x0817 33E0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @33A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @33AC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @33B3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @33D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @33DC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_33E1: // Incoming jump from 0x3399, if !(stack[-1] == stack[-2]) // Inputs[1] { @33E4 stack[-1] } 33E1 5B JUMPDEST 33E2 60 PUSH1 0x03 33E4 81 DUP2 33E5 60 PUSH1 0x04 33E7 81 DUP2 33E8 11 GT 33E9 15 ISZERO 33EA 61 PUSH2 0x33f5 33ED 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33E2 stack[0] = 0x03 // @33E4 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x33f5, if !(stack[-1] > 0x04) label_33EE: // Incoming jump from 0x33ED, if not !(stack[-1] > 0x04) 33EE 61 PUSH2 0x33f5 33F1 61 PUSH2 0x3e40 33F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @33EE stack[0] = 0x33f5 } // Block ends with unconditional jump to 0x3e40 label_33F5: // Incoming jump from 0x33ED, if !(stack[-1] > 0x04) // Inputs[2] // { // @33F6 stack[-2] // @33F6 stack[-1] // } 33F5 5B JUMPDEST 33F6 14 EQ 33F7 15 ISZERO 33F8 61 PUSH2 0x344e 33FB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x344e, if !(stack[-1] == stack[-2]) label_33FC: // Incoming jump from 0x33FB, if not !(stack[-1] == stack[-2]) // Inputs[1] { @33FE memory[0x40:0x60] } 33FC 60 PUSH1 0x40 33FE 51 MLOAD 33FF 62 PUSH3 0x461bcd 3403 60 PUSH1 0xe5 3405 1B SHL 3406 81 DUP2 3407 52 MSTORE 3408 60 PUSH1 0x20 340A 60 PUSH1 0x04 340C 82 DUP3 340D 01 ADD 340E 52 MSTORE 340F 60 PUSH1 0x22 3411 60 PUSH1 0x24 3413 82 DUP3 3414 01 ADD 3415 52 MSTORE 3416 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 3437 60 PUSH1 0x44 3439 82 DUP3 343A 01 ADD 343B 52 MSTORE 343C 61 PUSH2 0x7565 343F 60 PUSH1 0xf0 3441 1B SHL 3442 60 PUSH1 0x64 3444 82 DUP3 3445 01 ADD 3446 52 MSTORE 3447 60 PUSH1 0x84 3449 01 ADD 344A 61 PUSH2 0x0817 344D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @3407 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @340E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3415 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @343B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @3446 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @3449 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_344E: // Incoming jump from 0x33FB, if !(stack[-1] == stack[-2]) // Inputs[1] { @3451 stack[-1] } 344E 5B JUMPDEST 344F 60 PUSH1 0x04 3451 81 DUP2 3452 60 PUSH1 0x04 3454 81 DUP2 3455 11 GT 3456 15 ISZERO 3457 61 PUSH2 0x3462 345A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @344F stack[0] = 0x04 // @3451 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3462, if !(stack[-1] > 0x04) label_345B: // Incoming jump from 0x345A, if not !(stack[-1] > 0x04) 345B 61 PUSH2 0x3462 345E 61 PUSH2 0x3e40 3461 56 *JUMP // Stack delta = +1 // Outputs[1] { @345B stack[0] = 0x3462 } // Block ends with unconditional jump to 0x3e40 label_3462: // Incoming jump from 0x345A, if !(stack[-1] > 0x04) // Inputs[2] // { // @3463 stack[-1] // @3463 stack[-2] // } 3462 5B JUMPDEST 3463 14 EQ 3464 15 ISZERO 3465 61 PUSH2 0x0cd3 3468 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0cd3, if !(stack[-1] == stack[-2]) label_3469: // Incoming jump from 0x3468, if not !(stack[-1] == stack[-2]) // Inputs[1] { @346B memory[0x40:0x60] } 3469 60 PUSH1 0x40 346B 51 MLOAD 346C 62 PUSH3 0x461bcd 3470 60 PUSH1 0xe5 3472 1B SHL 3473 81 DUP2 3474 52 MSTORE 3475 60 PUSH1 0x20 3477 60 PUSH1 0x04 3479 82 DUP3 347A 01 ADD 347B 52 MSTORE 347C 60 PUSH1 0x22 347E 60 PUSH1 0x24 3480 82 DUP3 3481 01 ADD 3482 52 MSTORE 3483 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 34A4 60 PUSH1 0x44 34A6 82 DUP3 34A7 01 ADD 34A8 52 MSTORE 34A9 61 PUSH2 0x7565 34AC 60 PUSH1 0xf0 34AE 1B SHL 34AF 60 PUSH1 0x64 34B1 82 DUP3 34B2 01 ADD 34B3 52 MSTORE 34B4 60 PUSH1 0x84 34B6 01 ADD 34B7 61 PUSH2 0x0817 34BA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @3474 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @347B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3482 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @34A8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @34B3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @34B6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_34BB: // Incoming call from 0x2FDD, returns to 0x2FDE // Inputs[2] // { // @34BF stack[-1] // @34C0 memory[stack[-1]:stack[-1] + 0x20] // } 34BB 5B JUMPDEST 34BC 60 PUSH1 0x00 34BE 80 DUP1 34BF 82 DUP3 34C0 51 MLOAD 34C1 60 PUSH1 0x41 34C3 14 EQ 34C4 15 ISZERO 34C5 61 PUSH2 0x34f2 34C8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34BC stack[0] = 0x00 // @34BE stack[1] = 0x00 // } // Block ends with conditional jump to 0x34f2, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_34C9: // Incoming jump from 0x34C8, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @34CB stack[-3] // @34CD memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @34D2 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @34D7 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @34DE stack[-4] // } 34C9 60 PUSH1 0x20 34CB 83 DUP4 34CC 01 ADD 34CD 51 MLOAD 34CE 60 PUSH1 0x40 34D0 84 DUP5 34D1 01 ADD 34D2 51 MLOAD 34D3 60 PUSH1 0x60 34D5 85 DUP6 34D6 01 ADD 34D7 51 MLOAD 34D8 60 PUSH1 0x00 34DA 1A BYTE 34DB 61 PUSH2 0x34e6 34DE 87 DUP8 34DF 82 DUP3 34E0 85 DUP6 34E1 85 DUP6 34E2 61 PUSH2 0x3222 34E5 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @34CD stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @34D2 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @34DA stack[2] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @34DB stack[3] = 0x34e6 // @34DE stack[4] = stack[-4] // @34DF stack[5] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @34E0 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @34E1 stack[7] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x3222, returns to 0x34E6 label_34E6: // Incoming return from call to 0x3222 at 0x34E5 // Inputs[4] // { // @34E7 stack[-6] // @34E7 stack[-1] // @34E9 stack[-2] // @34E9 stack[-7] // } 34E6 5B JUMPDEST 34E7 94 SWAP5 34E8 50 POP 34E9 94 SWAP5 34EA 50 POP 34EB 50 POP 34EC 50 POP 34ED 50 POP 34EE 61 PUSH2 0x16ca 34F1 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @34E7 stack[-6] = stack[-1] // @34E9 stack[-7] = stack[-2] // } // Block ends with unconditional jump to 0x16ca label_34F2: // Incoming jump from 0x34C8, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @34F3 stack[-3] // @34F4 memory[stack[-3]:stack[-3] + 0x20] // } 34F2 5B JUMPDEST 34F3 82 DUP3 34F4 51 MLOAD 34F5 60 PUSH1 0x40 34F7 14 EQ 34F8 15 ISZERO 34F9 61 PUSH2 0x351c 34FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x351c, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) label_34FD: // Incoming jump from 0x34FC, if not !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @34FF stack[-3] // @3501 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3506 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @350A stack[-4] // } 34FD 60 PUSH1 0x20 34FF 83 DUP4 3500 01 ADD 3501 51 MLOAD 3502 60 PUSH1 0x40 3504 84 DUP5 3505 01 ADD 3506 51 MLOAD 3507 61 PUSH2 0x3511 350A 86 DUP7 350B 83 DUP4 350C 83 DUP4 350D 61 PUSH2 0x381d 3510 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3501 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3506 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @3507 stack[2] = 0x3511 // @350A stack[3] = stack[-4] // @350B stack[4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @350C stack[5] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x381d, returns to 0x3511 label_3511: // Incoming return from call to 0x381D at 0x3510 // Inputs[4] // { // @3512 stack[-1] // @3512 stack[-5] // @3514 stack[-2] // @3514 stack[-6] // } 3511 5B JUMPDEST 3512 93 SWAP4 3513 50 POP 3514 93 SWAP4 3515 50 POP 3516 50 POP 3517 50 POP 3518 61 PUSH2 0x16ca 351B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3512 stack[-5] = stack[-1] // @3514 stack[-6] = stack[-2] // } // Block ends with unconditional jump to 0x16ca label_351C: // Incoming jump from 0x34FC, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @3520 stack[-2] } 351C 5B JUMPDEST 351D 50 POP 351E 60 PUSH1 0x00 3520 90 SWAP1 3521 50 POP 3522 60 PUSH1 0x02 3524 61 PUSH2 0x16ca 3527 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3520 stack[-2] = 0x00 // @3522 stack[-1] = 0x02 // } // Block ends with unconditional jump to 0x16ca label_3528: // Incoming call from 0x3014, returns to 0x3015 // Incoming call from 0x301F, returns to 0x3020 // Inputs[1] { @3530 stack[-1] } 3528 5B JUMPDEST 3529 60 PUSH1 0x60 352B 60 PUSH1 0x00 352D 61 PUSH2 0x3537 3530 83 DUP4 3531 60 PUSH1 0x02 3533 61 PUSH2 0x3fa7 3536 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3529 stack[0] = 0x60 // @352B stack[1] = 0x00 // @352D stack[2] = 0x3537 // @3530 stack[3] = stack[-1] // @3531 stack[4] = 0x02 // } // Block ends with call to 0x3fa7, returns to 0x3537 label_3537: // Incoming return from call to 0x3FA7 at 0x3536 // Inputs[1] { @353B stack[-1] } 3537 5B JUMPDEST 3538 61 PUSH2 0x3542 353B 90 SWAP1 353C 60 PUSH1 0x02 353E 61 PUSH2 0x3f5f 3541 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @353B stack[0] = stack[-1] // @353B stack[-1] = 0x3542 // @353C stack[1] = 0x02 // } // Block ends with call to 0x3f5f, returns to 0x3542 label_3542: // Incoming return from call to 0x3F5F at 0x3541 // Inputs[1] { @354B stack[-1] } 3542 5B JUMPDEST 3543 60 PUSH1 0x01 3545 60 PUSH1 0x01 3547 60 PUSH1 0x40 3549 1B SHL 354A 03 SUB 354B 81 DUP2 354C 11 GT 354D 15 ISZERO 354E 61 PUSH2 0x3559 3551 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3559, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_3552: // Incoming jump from 0x3551, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 3552 61 PUSH2 0x3559 3555 61 PUSH2 0x3a44 3558 56 *JUMP // Stack delta = +1 // Outputs[1] { @3552 stack[0] = 0x3559 } // Block ends with unconditional jump to 0x3a44 label_3559: // Incoming jump from 0x3551, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @355C memory[0x40:0x60] // @355D stack[-1] // } 3559 5B JUMPDEST 355A 60 PUSH1 0x40 355C 51 MLOAD 355D 90 SWAP1 355E 80 DUP1 355F 82 DUP3 3560 52 MSTORE 3561 80 DUP1 3562 60 PUSH1 0x1f 3564 01 ADD 3565 60 PUSH1 0x1f 3567 19 NOT 3568 16 AND 3569 60 PUSH1 0x20 356B 01 ADD 356C 82 DUP3 356D 01 ADD 356E 60 PUSH1 0x40 3570 52 MSTORE 3571 80 DUP1 3572 15 ISZERO 3573 61 PUSH2 0x3583 3576 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @355D stack[-1] = memory[0x40:0x60] // @355D stack[0] = stack[-1] // @3560 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @3570 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x3583, if !stack[-1] label_3577: // Incoming jump from 0x3576, if not !stack[-1] // Inputs[6] // { // @3579 stack[-2] // @357B stack[-1] // @357D msg.data.length // @357F msg.data[msg.data.length:msg.data.length + stack[-1]] // @3585 stack[-3] // @3590 memory[stack[-2]:stack[-2] + 0x20] // } 3577 60 PUSH1 0x20 3579 82 DUP3 357A 01 ADD 357B 81 DUP2 357C 80 DUP1 357D 36 CALLDATASIZE 357E 83 DUP4 357F 37 CALLDATACOPY 3580 01 ADD 3581 90 SWAP1 3582 50 POP 3583 5B JUMPDEST 3584 50 POP 3585 90 SWAP1 3586 50 POP 3587 60 PUSH1 0x03 3589 60 PUSH1 0xfc 358B 1B SHL 358C 81 DUP2 358D 60 PUSH1 0x00 358F 81 DUP2 3590 51 MLOAD 3591 81 DUP2 3592 10 LT 3593 61 PUSH2 0x359e 3596 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @357F memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @3585 stack[-3] = stack[-2] // @358B stack[-2] = 0x03 << 0xfc // @358C stack[-1] = stack[-2] // @358D stack[0] = 0x00 // } // Block ends with conditional jump to 0x359e, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_3597: // Incoming jump from 0x3596, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x3596, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 3597 61 PUSH2 0x359e 359A 61 PUSH2 0x43b0 359D 56 *JUMP // Stack delta = +1 // Outputs[1] { @3597 stack[0] = 0x359e } // Block ends with unconditional jump to 0x43b0 label_359E: // Incoming jump from 0x3596, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x3596, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @35A1 stack[-1] // @35A2 stack[-2] // @35A3 stack[-3] // @35BB stack[-4] // @35BF memory[stack[-4]:stack[-4] + 0x20] // } 359E 5B JUMPDEST 359F 60 PUSH1 0x20 35A1 01 ADD 35A2 01 ADD 35A3 90 SWAP1 35A4 60 PUSH1 0x01 35A6 60 PUSH1 0x01 35A8 60 PUSH1 0xf8 35AA 1B SHL 35AB 03 SUB 35AC 19 NOT 35AD 16 AND 35AE 90 SWAP1 35AF 81 DUP2 35B0 60 PUSH1 0x00 35B2 1A BYTE 35B3 90 SWAP1 35B4 53 MSTORE8 35B5 50 POP 35B6 60 PUSH1 0x0f 35B8 60 PUSH1 0xfb 35BA 1B SHL 35BB 81 DUP2 35BC 60 PUSH1 0x01 35BE 81 DUP2 35BF 51 MLOAD 35C0 81 DUP2 35C1 10 LT 35C2 61 PUSH2 0x35cd 35C5 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @35B4 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @35BA stack[-3] = 0x0f << 0xfb // @35BB stack[-2] = stack[-4] // @35BC stack[-1] = 0x01 // } // Block ends with conditional jump to 0x35cd, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_35C6: // Incoming jump from 0x35C5, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 35C6 61 PUSH2 0x35cd 35C9 61 PUSH2 0x43b0 35CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @35C6 stack[0] = 0x35cd } // Block ends with unconditional jump to 0x43b0 label_35CD: // Incoming jump from 0x35C5, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @35D0 stack[-1] // @35D1 stack[-2] // @35D2 stack[-3] // @35EA stack[-6] // } 35CD 5B JUMPDEST 35CE 60 PUSH1 0x20 35D0 01 ADD 35D1 01 ADD 35D2 90 SWAP1 35D3 60 PUSH1 0x01 35D5 60 PUSH1 0x01 35D7 60 PUSH1 0xf8 35D9 1B SHL 35DA 03 SUB 35DB 19 NOT 35DC 16 AND 35DD 90 SWAP1 35DE 81 DUP2 35DF 60 PUSH1 0x00 35E1 1A BYTE 35E2 90 SWAP1 35E3 53 MSTORE8 35E4 50 POP 35E5 60 PUSH1 0x00 35E7 61 PUSH2 0x35f1 35EA 84 DUP5 35EB 60 PUSH1 0x02 35ED 61 PUSH2 0x3fa7 35F0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @35E3 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @35E5 stack[-3] = 0x00 // @35E7 stack[-2] = 0x35f1 // @35EA stack[-1] = stack[-6] // @35EB stack[0] = 0x02 // } // Block ends with call to 0x3fa7, returns to 0x35F1 label_35F1: // Incoming return from call to 0x3FA7 at 0x35F0 // Inputs[1] { @35F5 stack[-1] } 35F1 5B JUMPDEST 35F2 61 PUSH2 0x35fc 35F5 90 SWAP1 35F6 60 PUSH1 0x01 35F8 61 PUSH2 0x3f5f 35FB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @35F5 stack[0] = stack[-1] // @35F5 stack[-1] = 0x35fc // @35F6 stack[1] = 0x01 // } // Block ends with call to 0x3f5f, returns to 0x35FC label_35FC: // Incoming return from call to 0x3F5F at 0x35FB // Inputs[2] // { // @35FD stack[-2] // @35FD stack[-1] // } 35FC 5B JUMPDEST 35FD 90 SWAP1 35FE 50 POP 35FF 5B JUMPDEST 3600 60 PUSH1 0x01 3602 81 DUP2 3603 11 GT 3604 15 ISZERO 3605 61 PUSH2 0x3674 3608 57 *JUMPI // Stack delta = -1 // Outputs[1] { @35FD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x3674, if !(stack[-1] > 0x01) label_3609: // Incoming jump from 0x3608, if not !(stack[-1] > 0x01) // Incoming jump from 0x3608, if not !(stack[-1] > 0x01) // Inputs[1] { @361D stack[-5] } 3609 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 361A 60 PUSH1 0x81 361C 1B SHL 361D 85 DUP6 361E 60 PUSH1 0x0f 3620 16 AND 3621 60 PUSH1 0x10 3623 81 DUP2 3624 10 LT 3625 61 PUSH2 0x3630 3628 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @361C stack[0] = 0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81 // @3620 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x3630, if 0x0f & stack[-5] < 0x10 label_3629: // Incoming jump from 0x3628, if not 0x0f & stack[-5] < 0x10 3629 61 PUSH2 0x3630 362C 61 PUSH2 0x43b0 362F 56 *JUMP // Stack delta = +1 // Outputs[1] { @3629 stack[0] = 0x3630 } // Block ends with unconditional jump to 0x43b0 label_3630: // Incoming jump from 0x3628, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @3631 stack[-1] // @3631 stack[-2] // @3635 stack[-4] // @3636 stack[-3] // @3638 memory[stack[-4]:stack[-4] + 0x20] // } 3630 5B JUMPDEST 3631 1A BYTE 3632 60 PUSH1 0xf8 3634 1B SHL 3635 82 DUP3 3636 82 DUP3 3637 81 DUP2 3638 51 MLOAD 3639 81 DUP2 363A 10 LT 363B 61 PUSH2 0x3646 363E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @3634 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @3635 stack[-1] = stack[-4] // @3636 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x3646, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_363F: // Incoming jump from 0x363E, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 363F 61 PUSH2 0x3646 3642 61 PUSH2 0x43b0 3645 56 *JUMP // Stack delta = +1 // Outputs[1] { @363F stack[0] = 0x3646 } // Block ends with unconditional jump to 0x43b0 label_3646: // Incoming jump from 0x363E, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @3649 stack[-1] // @364A stack[-2] // @364B stack[-3] // @3660 stack[-8] // @3661 stack[-4] // } 3646 5B JUMPDEST 3647 60 PUSH1 0x20 3649 01 ADD 364A 01 ADD 364B 90 SWAP1 364C 60 PUSH1 0x01 364E 60 PUSH1 0x01 3650 60 PUSH1 0xf8 3652 1B SHL 3653 03 SUB 3654 19 NOT 3655 16 AND 3656 90 SWAP1 3657 81 DUP2 3658 60 PUSH1 0x00 365A 1A BYTE 365B 90 SWAP1 365C 53 MSTORE8 365D 50 POP 365E 60 PUSH1 0x04 3660 94 SWAP5 3661 90 SWAP1 3662 94 SWAP5 3663 1C SHR 3664 93 SWAP4 3665 61 PUSH2 0x366d 3668 81 DUP2 3669 61 PUSH2 0x429a 366C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @365C memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @3664 stack[-4] = stack[-4] // @3664 stack[-8] = stack[-8] >> 0x04 // @3665 stack[-3] = 0x366d // @3668 stack[-2] = stack[-4] // } // Block ends with call to 0x429a, returns to 0x366D label_366D: // Incoming return from call to 0x429A at 0x366C // Inputs[2] // { // @366E stack[-2] // @366E stack[-1] // } 366D 5B JUMPDEST 366E 90 SWAP1 366F 50 POP 3670 61 PUSH2 0x35ff 3673 56 *JUMP // Stack delta = -1 // Outputs[1] { @366E stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x35ff label_3674: // Incoming jump from 0x3608, if !(stack[-1] > 0x01) // Incoming jump from 0x3608, if !(stack[-1] > 0x01) // Inputs[1] { @3676 stack[-5] } 3674 5B JUMPDEST 3675 50 POP 3676 83 DUP4 3677 15 ISZERO 3678 61 PUSH2 0x07d9 367B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07d9, if !stack[-5] label_367C: // Incoming jump from 0x367B, if not !stack[-5] // Inputs[1] { @367E memory[0x40:0x60] } 367C 60 PUSH1 0x40 367E 51 MLOAD 367F 62 PUSH3 0x461bcd 3683 60 PUSH1 0xe5 3685 1B SHL 3686 81 DUP2 3687 52 MSTORE 3688 60 PUSH1 0x20 368A 60 PUSH1 0x04 368C 82 DUP3 368D 01 ADD 368E 81 DUP2 368F 90 SWAP1 3690 52 MSTORE 3691 60 PUSH1 0x24 3693 82 DUP3 3694 01 ADD 3695 52 MSTORE 3696 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 36B7 60 PUSH1 0x44 36B9 82 DUP3 36BA 01 ADD 36BB 52 MSTORE 36BC 60 PUSH1 0x64 36BE 01 ADD 36BF 61 PUSH2 0x0817 36C2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3687 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3690 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3695 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @36BB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @36BE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_36C3: // Incoming jump from 0x30A7 // Inputs[1] { @36C6 storage[0x00] } 36C3 5B JUMPDEST 36C4 60 PUSH1 0x00 36C6 54 SLOAD 36C7 61 PUSH2 0x0100 36CA 90 SWAP1 36CB 04 DIV 36CC 60 PUSH1 0xff 36CE 16 AND 36CF 61 PUSH2 0x36ea 36D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x36ea, if 0xff & storage[0x00] / 0x0100 label_36D3: // Incoming jump from 0x36D2, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @36D5 memory[0x40:0x60] } 36D3 60 PUSH1 0x40 36D5 51 MLOAD 36D6 62 PUSH3 0x461bcd 36DA 60 PUSH1 0xe5 36DC 1B SHL 36DD 81 DUP2 36DE 52 MSTORE 36DF 60 PUSH1 0x04 36E1 01 ADD 36E2 61 PUSH2 0x0817 36E5 90 SWAP1 36E6 61 PUSH2 0x42b1 36E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @36DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @36E5 stack[0] = 0x0817 // @36E5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42b1, returns to 0x0817 label_36EA: // Incoming jump from 0x36D2, if 0xff & storage[0x00] / 0x0100 // Inputs[2] // { // @36EE stack[-2] // @36EF stack[-1] // } 36EA 5B JUMPDEST 36EB 61 PUSH2 0x0c9e 36EE 82 DUP3 36EF 82 DUP3 36F0 61 PUSH2 0x3856 36F3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @36EB stack[0] = 0x0c9e // @36EE stack[1] = stack[-2] // @36EF stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x3856 36F4 5B JUMPDEST 36F5 60 PUSH1 0x00 36F7 54 SLOAD 36F8 61 PUSH2 0x0100 36FB 90 SWAP1 36FC 04 DIV 36FD 60 PUSH1 0xff 36FF 16 AND 3700 61 PUSH2 0x371b 3703 57 *JUMPI 3704 60 PUSH1 0x40 3706 51 MLOAD 3707 62 PUSH3 0x461bcd 370B 60 PUSH1 0xe5 370D 1B SHL 370E 81 DUP2 370F 52 MSTORE 3710 60 PUSH1 0x04 3712 01 ADD 3713 61 PUSH2 0x0817 3716 90 SWAP1 3717 61 PUSH2 0x42b1 371A 56 *JUMP 371B 5B JUMPDEST 371C 61 PUSH2 0x0cd3 371F 81 DUP2 3720 60 PUSH1 0x40 3722 51 MLOAD 3723 80 DUP1 3724 60 PUSH1 0x40 3726 01 ADD 3727 60 PUSH1 0x40 3729 52 MSTORE 372A 80 DUP1 372B 60 PUSH1 0x01 372D 81 DUP2 372E 52 MSTORE 372F 60 PUSH1 0x20 3731 01 ADD 3732 60 PUSH1 0x31 3734 60 PUSH1 0xf8 3736 1B SHL 3737 81 DUP2 3738 52 MSTORE 3739 50 POP 373A 61 PUSH2 0x38a4 373D 56 *JUMP label_373E: // Incoming call from 0x3221, returns to 0x0C9E // Inputs[1] { @3747 stack[-2] } 373E 5B JUMPDEST 373F 60 PUSH1 0x01 3741 60 PUSH1 0x01 3743 60 PUSH1 0xa0 3745 1B SHL 3746 03 SUB 3747 82 DUP3 3748 16 AND 3749 61 PUSH2 0x3794 374C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3794, if stack[-2] & (0x01 << 0xa0) - 0x01 label_374D: // Incoming jump from 0x374C, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @374F memory[0x40:0x60] } 374D 60 PUSH1 0x40 374F 51 MLOAD 3750 62 PUSH3 0x461bcd 3754 60 PUSH1 0xe5 3756 1B SHL 3757 81 DUP2 3758 52 MSTORE 3759 60 PUSH1 0x20 375B 60 PUSH1 0x04 375D 82 DUP3 375E 01 ADD 375F 52 MSTORE 3760 60 PUSH1 0x1f 3762 60 PUSH1 0x24 3764 82 DUP3 3765 01 ADD 3766 52 MSTORE 3767 7F PUSH32 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 3788 60 PUSH1 0x44 378A 82 DUP3 378B 01 ADD 378C 52 MSTORE 378D 60 PUSH1 0x64 378F 01 ADD 3790 61 PUSH2 0x0817 3793 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3758 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @375F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3766 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @378C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 // @378F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0817 label_3794: // Incoming jump from 0x374C, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @3795 stack[-1] // @379C storage[0x99] // } 3794 5B JUMPDEST 3795 80 DUP1 3796 60 PUSH1 0x99 3798 60 PUSH1 0x00 379A 82 DUP3 379B 82 DUP3 379C 54 SLOAD 379D 61 PUSH2 0x37a6 37A0 91 SWAP2 37A1 90 SWAP1 37A2 61 PUSH2 0x3f5f 37A5 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3795 stack[0] = stack[-1] // @3796 stack[1] = 0x99 // @3798 stack[2] = 0x00 // @37A0 stack[3] = 0x37a6 // @37A1 stack[4] = stack[-1] // @37A1 stack[5] = storage[0x99] // } // Block ends with call to 0x3f5f, returns to 0x37A6 label_37A6: // Incoming return from call to 0x3F5F at 0x37A5 // Inputs[7] // { // @37A7 stack[-1] // @37A7 stack[-2] // @37A8 stack[-3] // @37B4 stack[-6] // @37C3 memory[0x00:0x40] // @37C5 storage[keccak256(memory[0x00:0x40])] // @37C6 stack[-5] // } 37A6 5B JUMPDEST 37A7 90 SWAP1 37A8 91 SWAP2 37A9 55 SSTORE 37AA 50 POP 37AB 50 POP 37AC 60 PUSH1 0x01 37AE 60 PUSH1 0x01 37B0 60 PUSH1 0xa0 37B2 1B SHL 37B3 03 SUB 37B4 82 DUP3 37B5 16 AND 37B6 60 PUSH1 0x00 37B8 90 SWAP1 37B9 81 DUP2 37BA 52 MSTORE 37BB 60 PUSH1 0x97 37BD 60 PUSH1 0x20 37BF 52 MSTORE 37C0 60 PUSH1 0x40 37C2 81 DUP2 37C3 20 SHA3 37C4 80 DUP1 37C5 54 SLOAD 37C6 83 DUP4 37C7 92 SWAP3 37C8 90 SWAP1 37C9 61 PUSH2 0x37d3 37CC 90 SWAP1 37CD 84 DUP5 37CE 90 SWAP1 37CF 61 PUSH2 0x3f5f 37D2 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @37A9 storage[stack[-3]] = stack[-1] // @37BA memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @37BF memory[0x20:0x40] = 0x97 // @37C3 stack[-3] = keccak256(memory[0x00:0x40]) // @37C7 stack[-4] = stack[-5] // @37C8 stack[-2] = 0x00 // @37CC stack[-1] = 0x37d3 // @37CE stack[0] = stack[-5] // @37CE stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3f5f, returns to 0x37D3 label_37D3: // Incoming return from call to 0x3F5F at 0x37D2 // Inputs[9] // { // @37D4 stack[-1] // @37D4 stack[-2] // @37D5 stack[-3] // @37DB memory[0x40:0x60] // @37DC stack[-5] // @37E7 stack[-6] // @3814 memory[0x40:0x60] // @3819 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @381C stack[-7] // } 37D3 5B JUMPDEST 37D4 90 SWAP1 37D5 91 SWAP2 37D6 55 SSTORE 37D7 50 POP 37D8 50 POP 37D9 60 PUSH1 0x40 37DB 51 MLOAD 37DC 81 DUP2 37DD 81 DUP2 37DE 52 MSTORE 37DF 60 PUSH1 0x01 37E1 60 PUSH1 0x01 37E3 60 PUSH1 0xa0 37E5 1B SHL 37E6 03 SUB 37E7 83 DUP4 37E8 16 AND 37E9 90 SWAP1 37EA 60 PUSH1 0x00 37EC 90 SWAP1 37ED 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 380E 90 SWAP1 380F 60 PUSH1 0x20 3811 01 ADD 3812 60 PUSH1 0x40 3814 51 MLOAD 3815 80 DUP1 3816 91 SWAP2 3817 03 SUB 3818 90 SWAP1 3819 A3 LOG3 381A 50 POP 381B 50 POP 381C 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @37D6 storage[stack[-3]] = stack[-1] // @37DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @3819 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-7] label_381D: // Incoming call from 0x3510, returns to 0x3511 // Inputs[1] { @3829 stack[-1] } 381D 5B JUMPDEST 381E 60 PUSH1 0x00 3820 80 DUP1 3821 60 PUSH1 0x01 3823 60 PUSH1 0x01 3825 60 PUSH1 0xff 3827 1B SHL 3828 03 SUB 3829 83 DUP4 382A 16 AND 382B 81 DUP2 382C 61 PUSH2 0x383a 382F 60 PUSH1 0xff 3831 86 DUP7 3832 90 SWAP1 3833 1C SHR 3834 60 PUSH1 0x1b 3836 61 PUSH2 0x3f5f 3839 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @381E stack[0] = 0x00 // @3820 stack[1] = 0x00 // @382A stack[2] = stack[-1] & (0x01 << 0xff) - 0x01 // @382B stack[3] = 0x00 // @382C stack[4] = 0x383a // @3833 stack[5] = stack[-1] >> 0xff // @3834 stack[6] = 0x1b // } // Block ends with call to 0x3f5f, returns to 0x383A label_383A: // Incoming return from call to 0x3F5F at 0x3839 // Inputs[5] // { // @383B stack[-2] // @383B stack[-1] // @3840 stack[-8] // @3842 stack[-7] // @3843 stack[-3] // } 383A 5B JUMPDEST 383B 90 SWAP1 383C 50 POP 383D 61 PUSH2 0x3848 3840 87 DUP8 3841 82 DUP3 3842 88 DUP9 3843 85 DUP6 3844 61 PUSH2 0x3222 3847 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @383B stack[-2] = stack[-1] // @383D stack[-1] = 0x3848 // @3840 stack[0] = stack[-8] // @3841 stack[1] = stack[-1] // @3842 stack[2] = stack[-7] // @3843 stack[3] = stack[-3] // } // Block ends with call to 0x3222, returns to 0x3848 label_3848: // Incoming return from call to 0x3222 at 0x3847 // Inputs[7] // { // @3849 stack[-5] // @3849 stack[-1] // @384B stack[-6] // @384B stack[-2] // @384F stack[-9] // @3851 stack[-10] // @3852 stack[-8] // } 3848 5B JUMPDEST 3849 93 SWAP4 384A 50 POP 384B 93 SWAP4 384C 50 POP 384D 50 POP 384E 50 POP 384F 93 SWAP4 3850 50 POP 3851 93 SWAP4 3852 91 SWAP2 3853 50 POP 3854 50 POP 3855 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @384F stack[-9] = stack[-1] // @3851 stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_3856: // Incoming jump from 0x36F3 // Inputs[1] { @3859 storage[0x00] } 3856 5B JUMPDEST 3857 60 PUSH1 0x00 3859 54 SLOAD 385A 61 PUSH2 0x0100 385D 90 SWAP1 385E 04 DIV 385F 60 PUSH1 0xff 3861 16 AND 3862 61 PUSH2 0x387d 3865 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x387d, if 0xff & storage[0x00] / 0x0100 label_3866: // Incoming jump from 0x3865, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @3868 memory[0x40:0x60] } 3866 60 PUSH1 0x40 3868 51 MLOAD 3869 62 PUSH3 0x461bcd 386D 60 PUSH1 0xe5 386F 1B SHL 3870 81 DUP2 3871 52 MSTORE 3872 60 PUSH1 0x04 3874 01 ADD 3875 61 PUSH2 0x0817 3878 90 SWAP1 3879 61 PUSH2 0x42b1 387C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3871 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @3878 stack[0] = 0x0817 // @3878 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42b1, returns to 0x0817 label_387D: // Incoming jump from 0x3865, if 0xff & storage[0x00] / 0x0100 // Inputs[2] // { // @387E stack[-2] // @387F memory[stack[-2]:stack[-2] + 0x20] // } 387D 5B JUMPDEST 387E 81 DUP2 387F 51 MLOAD 3880 61 PUSH2 0x3890 3883 90 SWAP1 3884 60 PUSH1 0x9a 3886 90 SWAP1 3887 60 PUSH1 0x20 3889 85 DUP6 388A 01 ADD 388B 90 SWAP1 388C 61 PUSH2 0x38e5 388F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3883 stack[0] = 0x3890 // @3886 stack[1] = 0x9a // @388B stack[2] = stack[-2] + 0x20 // @388B stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x38e5 3890 5B JUMPDEST 3891 50 POP 3892 80 DUP1 3893 51 MLOAD 3894 61 PUSH2 0x0c10 3897 90 SWAP1 3898 60 PUSH1 0x9b 389A 90 SWAP1 389B 60 PUSH1 0x20 389D 84 DUP5 389E 01 ADD 389F 90 SWAP1 38A0 61 PUSH2 0x38e5 38A3 56 *JUMP 38A4 5B JUMPDEST 38A5 60 PUSH1 0x00 38A7 54 SLOAD 38A8 61 PUSH2 0x0100 38AB 90 SWAP1 38AC 04 DIV 38AD 60 PUSH1 0xff 38AF 16 AND 38B0 61 PUSH2 0x38cb 38B3 57 *JUMPI 38B4 60 PUSH1 0x40 38B6 51 MLOAD 38B7 62 PUSH3 0x461bcd 38BB 60 PUSH1 0xe5 38BD 1B SHL 38BE 81 DUP2 38BF 52 MSTORE 38C0 60 PUSH1 0x04 38C2 01 ADD 38C3 61 PUSH2 0x0817 38C6 90 SWAP1 38C7 61 PUSH2 0x42b1 38CA 56 *JUMP 38CB 5B JUMPDEST 38CC 81 DUP2 38CD 51 MLOAD 38CE 60 PUSH1 0x20 38D0 92 SWAP3 38D1 83 DUP4 38D2 01 ADD 38D3 20 SHA3 38D4 81 DUP2 38D5 51 MLOAD 38D6 91 SWAP2 38D7 90 SWAP1 38D8 92 SWAP3 38D9 01 ADD 38DA 20 SHA3 38DB 60 PUSH1 0xc9 38DD 91 SWAP2 38DE 90 SWAP1 38DF 91 SWAP2 38E0 55 SSTORE 38E1 60 PUSH1 0xca 38E3 55 SSTORE 38E4 56 *JUMP label_38E5: // Incoming jump from 0x388F // Inputs[2] // { // @38E6 stack[-3] // @38E8 storage[stack[-3]] // } 38E5 5B JUMPDEST 38E6 82 DUP3 38E7 80 DUP1 38E8 54 SLOAD 38E9 61 PUSH2 0x38f1 38EC 90 SWAP1 38ED 61 PUSH2 0x3e0b 38F0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @38E6 stack[0] = stack[-3] // @38EC stack[1] = 0x38f1 // @38EC stack[2] = storage[stack[-3]] // } // Block ends with call to 0x3e0b, returns to 0x38F1 label_38F1: // Incoming return from call to 0x3E0B at 0x38F0 // Inputs[5] // { // @38F2 stack[-2] // @38F2 stack[-1] // @38FA memory[0x00:0x20] // @3905 stack[-4] // @3906 stack[-3] // } 38F1 5B JUMPDEST 38F2 90 SWAP1 38F3 60 PUSH1 0x00 38F5 52 MSTORE 38F6 60 PUSH1 0x20 38F8 60 PUSH1 0x00 38FA 20 SHA3 38FB 90 SWAP1 38FC 60 PUSH1 0x1f 38FE 01 ADD 38FF 60 PUSH1 0x20 3901 90 SWAP1 3902 04 DIV 3903 81 DUP2 3904 01 ADD 3905 92 SWAP3 3906 82 DUP3 3907 61 PUSH2 0x3913 390A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @38F5 memory[0x00:0x20] = stack[-2] // @38FB stack[-2] = keccak256(memory[0x00:0x20]) // @3905 stack[-1] = stack[-4] // @3905 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x3913, if stack[-3] label_390B: // Incoming jump from 0x390A, if not stack[-3] // Inputs[1] { @390D stack[-5] } 390B 60 PUSH1 0x00 390D 85 DUP6 390E 55 SSTORE 390F 61 PUSH2 0x3959 3912 56 *JUMP // Stack delta = +0 // Outputs[1] { @390E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x3959 label_3913: // Incoming jump from 0x390A, if stack[-3] // Inputs[1] { @3914 stack[-3] } 3913 5B JUMPDEST 3914 82 DUP3 3915 60 PUSH1 0x1f 3917 10 LT 3918 61 PUSH2 0x392c 391B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x392c, if 0x1f < stack[-3] label_391C: // Incoming jump from 0x391B, if not 0x1f < stack[-3] // Inputs[4] // { // @391C stack[-1] // @391D memory[stack[-1]:stack[-1] + 0x20] // @3922 stack[-3] // @3926 stack[-5] // } 391C 80 DUP1 391D 51 MLOAD 391E 60 PUSH1 0xff 3920 19 NOT 3921 16 AND 3922 83 DUP4 3923 80 DUP1 3924 01 ADD 3925 17 OR 3926 85 DUP6 3927 55 SSTORE 3928 61 PUSH2 0x3959 392B 56 *JUMP // Stack delta = +0 // Outputs[1] { @3927 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x3959 label_392C: // Incoming jump from 0x391B, if 0x1f < stack[-3] // Inputs[2] // { // @392D stack[-3] // @3933 stack[-5] // } 392C 5B JUMPDEST 392D 82 DUP3 392E 80 DUP1 392F 01 ADD 3930 60 PUSH1 0x01 3932 01 ADD 3933 85 DUP6 3934 55 SSTORE 3935 82 DUP3 3936 15 ISZERO 3937 61 PUSH2 0x3959 393A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3934 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x3959, if !stack[-3] label_393B: // Incoming jump from 0x393A, if not !stack[-3] // Inputs[2] // { // @393B stack[-3] // @393B stack[-1] // } 393B 91 SWAP2 393C 82 DUP3 393D 01 ADD 393E 5B JUMPDEST 393F 82 DUP3 3940 81 DUP2 3941 11 GT 3942 15 ISZERO 3943 61 PUSH2 0x3959 3946 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @393B stack[-3] = stack[-1] // @393D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x3959, if !(stack[-1] + stack[-3] > stack[-1]) label_3947: // Incoming jump from 0x3946, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x3946, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @3947 stack[-3] // @3948 memory[stack[-3]:stack[-3] + 0x20] // @3949 stack[-2] // @394B stack[-1] // } 3947 82 DUP3 3948 51 MLOAD 3949 82 DUP3 394A 55 SSTORE 394B 91 SWAP2 394C 60 PUSH1 0x20 394E 01 ADD 394F 91 SWAP2 3950 90 SWAP1 3951 60 PUSH1 0x01 3953 01 ADD 3954 90 SWAP1 3955 61 PUSH2 0x393e 3958 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @394A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @394F stack[-3] = 0x20 + stack[-3] // @3954 stack[-2] = 0x01 + stack[-2] // @3954 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x393e label_3959: // Incoming jump from 0x3912 // Incoming jump from 0x3946, if !(stack[-1] > stack[-3]) // Incoming jump from 0x392B // Incoming jump from 0x3946, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x393A, if !stack[-3] // Inputs[3] // { // @395E stack[-4] // @395F stack[-3] // @3962 stack[-2] // } 3959 5B JUMPDEST 395A 50 POP 395B 61 PUSH2 0x252b 395E 92 SWAP3 395F 91 SWAP2 3960 50 POP 3961 5B JUMPDEST 3962 80 DUP1 3963 82 DUP3 3964 11 GT 3965 15 ISZERO 3966 61 PUSH2 0x252b 3969 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @395E stack[-4] = 0x252b // @395F stack[-3] = stack[-4] // } // Block ends with conditional call to 0x252b, returns to 0x252B, if !(stack[-4] > stack[-2]) label_396A: // Incoming jump from 0x3969, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x3969, if not !(stack[-4] > stack[-2]) // Inputs[1] { @396C stack[-1] } 396A 60 PUSH1 0x00 396C 81 DUP2 396D 55 SSTORE 396E 60 PUSH1 0x01 3970 01 ADD 3971 61 PUSH2 0x3961 3974 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @396D storage[stack[-1]] = 0x00 // @3970 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x3961 label_3975: // Incoming call from 0x0247, returns to 0x0248 // Inputs[2] // { // @397A stack[-1] // @397B stack[-2] // } 3975 5B JUMPDEST 3976 60 PUSH1 0x00 3978 60 PUSH1 0x20 397A 82 DUP3 397B 84 DUP5 397C 03 SUB 397D 12 SLT 397E 15 ISZERO 397F 61 PUSH2 0x3987 3982 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3976 stack[0] = 0x00 } // Block ends with conditional jump to 0x3987, if !(stack[-2] - stack[-1] i< 0x20) label_3983: // Incoming jump from 0x3982, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3986 memory[0x00:0x00] } 3983 60 PUSH1 0x00 3985 80 DUP1 3986 FD *REVERT // Stack delta = +0 // Outputs[1] { @3986 revert(memory[0x00:0x00]); } // Block terminates label_3987: // Incoming jump from 0x3982, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3988 stack[-2] // @3989 msg.data[stack[-2]:stack[-2] + 0x20] // } 3987 5B JUMPDEST 3988 81 DUP2 3989 35 CALLDATALOAD 398A 60 PUSH1 0x01 398C 60 PUSH1 0x01 398E 60 PUSH1 0xe0 3990 1B SHL 3991 03 SUB 3992 19 NOT 3993 81 DUP2 3994 16 AND 3995 81 DUP2 3996 14 EQ 3997 61 PUSH2 0x07d9 399A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3989 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x07d9, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) label_399B: // Incoming jump from 0x399A, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @399E memory[0x00:0x00] } 399B 60 PUSH1 0x00 399D 80 DUP1 399E FD *REVERT // Stack delta = +0 // Outputs[1] { @399E revert(memory[0x00:0x00]); } // Block terminates label_399F: // Incoming call from 0x4372, returns to 0x4373 // Incoming call from 0x39E9, returns to 0x39EA // Incoming call from 0x43A3, returns to 0x43A4 // Inputs[1] { @39A3 stack[-3] } 399F 5B JUMPDEST 39A0 60 PUSH1 0x00 39A2 5B JUMPDEST 39A3 83 DUP4 39A4 81 DUP2 39A5 10 LT 39A6 15 ISZERO 39A7 61 PUSH2 0x39ba 39AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @39A0 stack[0] = 0x00 } // Block ends with conditional jump to 0x39ba, if !(0x00 < stack[-3]) label_39AB: // Incoming jump from 0x39AA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x39AA, if not !(0x00 < stack[-3]) // Inputs[4] // { // @39AB stack[-2] // @39AC stack[-1] // @39AE memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @39AF stack[-3] // } 39AB 81 DUP2 39AC 81 DUP2 39AD 01 ADD 39AE 51 MLOAD 39AF 83 DUP4 39B0 82 DUP3 39B1 01 ADD 39B2 52 MSTORE 39B3 60 PUSH1 0x20 39B5 01 ADD 39B6 61 PUSH2 0x39a2 39B9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @39B2 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @39B5 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x39a2 label_39BA: // Incoming jump from 0x39AA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x39AA, if !(0x00 < stack[-3]) // Inputs[2] // { // @39BB stack[-4] // @39BC stack[-1] // } 39BA 5B JUMPDEST 39BB 83 DUP4 39BC 81 DUP2 39BD 11 GT 39BE 15 ISZERO 39BF 61 PUSH2 0x22d1 39C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22d1, if !(stack[-1] > stack[-4]) label_39C3: // Incoming jump from 0x39C2, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @39C7 stack[-4] // @39C8 stack[-3] // @39CA stack[-5] // } 39C3 50 POP 39C4 50 POP 39C5 60 PUSH1 0x00 39C7 91 SWAP2 39C8 01 ADD 39C9 52 MSTORE 39CA 56 *JUMP // Stack delta = -5 // Outputs[1] { @39C9 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_39CB: // Incoming call from 0x3056, returns to 0x0817 // Incoming call from 0x0276, returns to 0x0259 // Inputs[3] // { // @39CE stack[-1] // @39D2 stack[-2] // @39D3 memory[stack[-2]:stack[-2] + 0x20] // } 39CB 5B JUMPDEST 39CC 60 PUSH1 0x20 39CE 81 DUP2 39CF 52 MSTORE 39D0 60 PUSH1 0x00 39D2 82 DUP3 39D3 51 MLOAD 39D4 80 DUP1 39D5 60 PUSH1 0x20 39D7 84 DUP5 39D8 01 ADD 39D9 52 MSTORE 39DA 61 PUSH2 0x39ea 39DD 81 DUP2 39DE 60 PUSH1 0x40 39E0 85 DUP6 39E1 01 ADD 39E2 60 PUSH1 0x20 39E4 87 DUP8 39E5 01 ADD 39E6 61 PUSH2 0x399f 39E9 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @39CF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @39D0 stack[0] = 0x00 // @39D3 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @39D9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @39DA stack[2] = 0x39ea // @39DD stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @39E1 stack[4] = stack[-1] + 0x40 // @39E5 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x399f, returns to 0x39EA label_39EA: // Incoming return from call to 0x399F at 0x39E9 // Inputs[5] // { // @39ED stack[-1] // @39F2 stack[-3] // @39F3 stack[-2] // @39F9 stack[-5] // @39FA stack[-4] // } 39EA 5B JUMPDEST 39EB 60 PUSH1 0x1f 39ED 01 ADD 39EE 60 PUSH1 0x1f 39F0 19 NOT 39F1 16 AND 39F2 91 SWAP2 39F3 90 SWAP1 39F4 91 SWAP2 39F5 01 ADD 39F6 60 PUSH1 0x40 39F8 01 ADD 39F9 92 SWAP3 39FA 91 SWAP2 39FB 50 POP 39FC 50 POP 39FD 56 *JUMP // Stack delta = -4 // Outputs[1] { @39F9 stack[-5] = 0x40 + (~0x1f & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] label_39FE: // Incoming call from 0x3D9A, returns to 0x3D9B // Incoming call from 0x3D61, returns to 0x3D62 // Incoming call from 0x3BF5, returns to 0x3BF6 // Incoming call from 0x3CAF, returns to 0x3CB0 // Incoming call from 0x3D43, returns to 0x07D9 // Incoming call from 0x3DFC, returns to 0x3DFD // Incoming call from 0x3BA9, returns to 0x3BAA // Incoming call from 0x3AF0, returns to 0x3AF1 // Incoming call from 0x3B9B, returns to 0x3B9C // Incoming call from 0x3DA8, returns to 0x3DA9 // Incoming call from 0x3E0A, returns to 0x3BF6 // Incoming call from 0x3AFE, returns to 0x3AFF // Incoming call from 0x3A35, returns to 0x3A36 // Inputs[2] // { // @39FF stack[-1] // @3A00 msg.data[stack[-1]:stack[-1] + 0x20] // } 39FE 5B JUMPDEST 39FF 80 DUP1 3A00 35 CALLDATALOAD 3A01 60 PUSH1 0x01 3A03 60 PUSH1 0x01 3A05 60 PUSH1 0xa0 3A07 1B SHL 3A08 03 SUB 3A09 81 DUP2 3A0A 16 AND 3A0B 81 DUP2 3A0C 14 EQ 3A0D 61 PUSH2 0x3a15 3A10 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A00 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x3a15, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_3A11: // Incoming jump from 0x3A10, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3A14 memory[0x00:0x00] } 3A11 60 PUSH1 0x00 3A13 80 DUP1 3A14 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A14 revert(memory[0x00:0x00]); } // Block terminates label_3A15: // Incoming jump from 0x3A10, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x3C2B, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff // Inputs[3] // { // @3A16 stack[-1] // @3A16 stack[-3] // @3A17 stack[-2] // } 3A15 5B JUMPDEST 3A16 91 SWAP2 3A17 90 SWAP1 3A18 50 POP 3A19 56 *JUMP // Stack delta = -2 // Outputs[1] { @3A16 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_3A1A: // Incoming call from 0x04DD, returns to 0x04DE // Incoming call from 0x059C, returns to 0x059D // Incoming call from 0x064F, returns to 0x0650 // Incoming call from 0x05AF, returns to 0x05B0 // Incoming call from 0x0489, returns to 0x048A // Incoming call from 0x0284, returns to 0x0285 // Incoming call from 0x02CB, returns to 0x02CC // Incoming call from 0x0365, returns to 0x0366 // Incoming call from 0x0604, returns to 0x0605 // Inputs[2] // { // @3A20 stack[-1] // @3A21 stack[-2] // } 3A1A 5B JUMPDEST 3A1B 60 PUSH1 0x00 3A1D 80 DUP1 3A1E 60 PUSH1 0x40 3A20 83 DUP4 3A21 85 DUP6 3A22 03 SUB 3A23 12 SLT 3A24 15 ISZERO 3A25 61 PUSH2 0x3a2d 3A28 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3A1B stack[0] = 0x00 // @3A1D stack[1] = 0x00 // } // Block ends with conditional jump to 0x3a2d, if !(stack[-2] - stack[-1] i< 0x40) label_3A29: // Incoming jump from 0x3A28, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3A2C memory[0x00:0x00] } 3A29 60 PUSH1 0x00 3A2B 80 DUP1 3A2C FD *REVERT // Stack delta = +0 // Outputs[1] { @3A2C revert(memory[0x00:0x00]); } // Block terminates label_3A2D: // Incoming jump from 0x3A28, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3A31 stack[-3] } 3A2D 5B JUMPDEST 3A2E 61 PUSH2 0x3a36 3A31 83 DUP4 3A32 61 PUSH2 0x39fe 3A35 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3A2E stack[0] = 0x3a36 // @3A31 stack[1] = stack[-3] // } // Block ends with call to 0x39fe, returns to 0x3A36 label_3A36: // Incoming return from call to 0x39FE at 0x3A35 // Inputs[5] // { // @3A37 stack[-6] // @3A37 stack[-1] // @3A3A stack[-4] // @3A3E msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3A3F stack[-5] // } 3A36 5B JUMPDEST 3A37 94 SWAP5 3A38 60 PUSH1 0x20 3A3A 93 SWAP4 3A3B 90 SWAP1 3A3C 93 SWAP4 3A3D 01 ADD 3A3E 35 CALLDATALOAD 3A3F 93 SWAP4 3A40 50 POP 3A41 50 POP 3A42 50 POP 3A43 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3A37 stack[-6] = stack[-1] // @3A3F stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_3A44: // Incoming jump from 0x3A73 // Incoming jump from 0x3A9B // Incoming jump from 0x3558 // Inputs[1] { @3A59 memory[0x00:0x24] } 3A44 5B JUMPDEST 3A45 63 PUSH4 0x4e487b71 3A4A 60 PUSH1 0xe0 3A4C 1B SHL 3A4D 60 PUSH1 0x00 3A4F 52 MSTORE 3A50 60 PUSH1 0x41 3A52 60 PUSH1 0x04 3A54 52 MSTORE 3A55 60 PUSH1 0x24 3A57 60 PUSH1 0x00 3A59 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3A4F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3A54 memory[0x04:0x24] = 0x41 // @3A59 revert(memory[0x00:0x24]); // } // Block terminates label_3A5A: // Incoming call from 0x3B4E, returns to 0x3B4F // Incoming call from 0x3C1E, returns to 0x07D9 // Inputs[1] { @3A66 stack[-2] } 3A5A 5B JUMPDEST 3A5B 60 PUSH1 0x00 3A5D 60 PUSH1 0x01 3A5F 60 PUSH1 0x01 3A61 60 PUSH1 0x40 3A63 1B SHL 3A64 03 SUB 3A65 80 DUP1 3A66 84 DUP5 3A67 11 GT 3A68 15 ISZERO 3A69 61 PUSH2 0x3a74 3A6C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3A5B stack[0] = 0x00 // @3A64 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x3a74, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_3A6D: // Incoming jump from 0x3A6C, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 3A6D 61 PUSH2 0x3a74 3A70 61 PUSH2 0x3a44 3A73 56 *JUMP // Stack delta = +1 // Outputs[1] { @3A6D stack[0] = 0x3a74 } // Block ends with unconditional jump to 0x3a44 label_3A74: // Incoming jump from 0x3A6C, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @3A77 memory[0x40:0x60] // @3A7A stack[-4] // @3A89 stack[-1] // } 3A74 5B JUMPDEST 3A75 60 PUSH1 0x40 3A77 51 MLOAD 3A78 60 PUSH1 0x1f 3A7A 85 DUP6 3A7B 01 ADD 3A7C 60 PUSH1 0x1f 3A7E 19 NOT 3A7F 90 SWAP1 3A80 81 DUP2 3A81 16 AND 3A82 60 PUSH1 0x3f 3A84 01 ADD 3A85 16 AND 3A86 81 DUP2 3A87 01 ADD 3A88 90 SWAP1 3A89 82 DUP3 3A8A 82 DUP3 3A8B 11 GT 3A8C 81 DUP2 3A8D 83 DUP4 3A8E 10 LT 3A8F 17 OR 3A90 15 ISZERO 3A91 61 PUSH2 0x3a9c 3A94 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3A88 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @3A88 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x3a9c, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_3A95: // Incoming jump from 0x3A94, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 3A95 61 PUSH2 0x3a9c 3A98 61 PUSH2 0x3a44 3A9B 56 *JUMP // Stack delta = +1 // Outputs[1] { @3A95 stack[0] = 0x3a9c } // Block ends with unconditional jump to 0x3a44 label_3A9C: // Incoming jump from 0x3A94, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @3A9D stack[-2] // @3AA1 stack[-1] // @3AA2 stack[-4] // @3AA4 stack[-6] // @3AA7 stack[-7] // @3AA9 stack[-5] // } 3A9C 5B JUMPDEST 3A9D 81 DUP2 3A9E 60 PUSH1 0x40 3AA0 52 MSTORE 3AA1 80 DUP1 3AA2 93 SWAP4 3AA3 50 POP 3AA4 85 DUP6 3AA5 81 DUP2 3AA6 52 MSTORE 3AA7 86 DUP7 3AA8 86 DUP7 3AA9 86 DUP7 3AAA 01 ADD 3AAB 11 GT 3AAC 15 ISZERO 3AAD 61 PUSH2 0x3ab5 3AB0 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @3AA0 memory[0x40:0x60] = stack[-2] // @3AA2 stack[-4] = stack[-1] // @3AA6 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x3ab5, if !(stack[-5] + stack[-6] > stack[-7]) label_3AB1: // Incoming jump from 0x3AB0, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @3AB4 memory[0x00:0x00] } 3AB1 60 PUSH1 0x00 3AB3 80 DUP1 3AB4 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AB4 revert(memory[0x00:0x00]); } // Block terminates label_3AB5: // Incoming jump from 0x3AB0, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @3AB6 stack[-6] // @3AB7 stack[-5] // @3ABA stack[-1] // @3ABC msg.data[stack[-5]:stack[-5] + stack[-6]] // @3AC9 stack[-4] // @3AC9 stack[-8] // @3ACA stack[-7] // } 3AB5 5B JUMPDEST 3AB6 85 DUP6 3AB7 85 DUP6 3AB8 60 PUSH1 0x20 3ABA 83 DUP4 3ABB 01 ADD 3ABC 37 CALLDATACOPY 3ABD 60 PUSH1 0x00 3ABF 60 PUSH1 0x20 3AC1 87 DUP8 3AC2 83 DUP4 3AC3 01 ADD 3AC4 01 ADD 3AC5 52 MSTORE 3AC6 50 POP 3AC7 50 POP 3AC8 50 POP 3AC9 93 SWAP4 3ACA 92 SWAP3 3ACB 50 POP 3ACC 50 POP 3ACD 50 POP 3ACE 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @3ABC memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @3AC5 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @3AC9 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_3ACF: // Incoming call from 0x0297, returns to 0x0298 // Inputs[2] // { // @3ADB stack[-1] // @3ADC stack[-2] // } 3ACF 5B JUMPDEST 3AD0 60 PUSH1 0x00 3AD2 80 DUP1 3AD3 60 PUSH1 0x00 3AD5 80 DUP1 3AD6 60 PUSH1 0x00 3AD8 80 DUP1 3AD9 60 PUSH1 0xc0 3ADB 87 DUP8 3ADC 89 DUP10 3ADD 03 SUB 3ADE 12 SLT 3ADF 15 ISZERO 3AE0 61 PUSH2 0x3ae8 3AE3 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @3AD0 stack[0] = 0x00 // @3AD2 stack[1] = 0x00 // @3AD3 stack[2] = 0x00 // @3AD5 stack[3] = 0x00 // @3AD6 stack[4] = 0x00 // @3AD8 stack[5] = 0x00 // } // Block ends with conditional jump to 0x3ae8, if !(stack[-2] - stack[-1] i< 0xc0) label_3AE4: // Incoming jump from 0x3AE3, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @3AE7 memory[0x00:0x00] } 3AE4 60 PUSH1 0x00 3AE6 80 DUP1 3AE7 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AE7 revert(memory[0x00:0x00]); } // Block terminates label_3AE8: // Incoming jump from 0x3AE3, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @3AEC stack[-7] } 3AE8 5B JUMPDEST 3AE9 61 PUSH2 0x3af1 3AEC 87 DUP8 3AED 61 PUSH2 0x39fe 3AF0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3AE9 stack[0] = 0x3af1 // @3AEC stack[1] = stack[-7] // } // Block ends with call to 0x39fe, returns to 0x3AF1 label_3AF1: // Incoming return from call to 0x39FE at 0x3AF0 // Inputs[3] // { // @3AF2 stack[-1] // @3AF2 stack[-7] // @3AF9 stack[-8] // } 3AF1 5B JUMPDEST 3AF2 95 SWAP6 3AF3 50 POP 3AF4 61 PUSH2 0x3aff 3AF7 60 PUSH1 0x20 3AF9 88 DUP9 3AFA 01 ADD 3AFB 61 PUSH2 0x39fe 3AFE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3AF2 stack[-7] = stack[-1] // @3AF4 stack[-1] = 0x3aff // @3AFA stack[0] = stack[-8] + 0x20 // } // Block ends with call to 0x39fe, returns to 0x3AFF label_3AFF: // Incoming return from call to 0x39FE at 0x3AFE // Inputs[10] // { // @3B00 stack[-6] // @3B00 stack[-1] // @3B04 stack[-8] // @3B06 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @3B07 stack[-5] // @3B0D msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @3B0E stack[-4] // @3B14 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @3B15 stack[-3] // @3B1B msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // } 3AFF 5B JUMPDEST 3B00 94 SWAP5 3B01 50 POP 3B02 60 PUSH1 0x40 3B04 87 DUP8 3B05 01 ADD 3B06 35 CALLDATALOAD 3B07 93 SWAP4 3B08 50 POP 3B09 60 PUSH1 0x60 3B0B 87 DUP8 3B0C 01 ADD 3B0D 35 CALLDATALOAD 3B0E 92 SWAP3 3B0F 50 POP 3B10 60 PUSH1 0x80 3B12 87 DUP8 3B13 01 ADD 3B14 35 CALLDATALOAD 3B15 91 SWAP2 3B16 50 POP 3B17 60 PUSH1 0xa0 3B19 87 DUP8 3B1A 01 ADD 3B1B 35 CALLDATALOAD 3B1C 60 PUSH1 0x01 3B1E 60 PUSH1 0x01 3B20 60 PUSH1 0x40 3B22 1B SHL 3B23 03 SUB 3B24 81 DUP2 3B25 11 GT 3B26 15 ISZERO 3B27 61 PUSH2 0x3b2f 3B2A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @3B00 stack[-6] = stack[-1] // @3B07 stack[-5] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @3B0E stack[-4] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @3B15 stack[-3] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @3B1B stack[-1] = msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // } // Block ends with conditional jump to 0x3b2f, if !(msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] > (0x01 << 0x40) - 0x01) label_3B2B: // Incoming jump from 0x3B2A, if not !(msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @3B2E memory[0x00:0x00] } 3B2B 60 PUSH1 0x00 3B2D 80 DUP1 3B2E FD *REVERT // Stack delta = +0 // Outputs[1] { @3B2E revert(memory[0x00:0x00]); } // Block terminates label_3B2F: // Incoming jump from 0x3B2A, if !(msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @3B30 stack[-8] // @3B31 stack[-1] // @3B36 stack[-9] // } 3B2F 5B JUMPDEST 3B30 87 DUP8 3B31 01 ADD 3B32 60 PUSH1 0x1f 3B34 81 DUP2 3B35 01 ADD 3B36 89 DUP10 3B37 13 SGT 3B38 61 PUSH2 0x3b40 3B3B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3B31 stack[-1] = stack[-8] + stack[-1] } // Block ends with conditional jump to 0x3b40, if stack[-9] i> stack[-8] + stack[-1] + 0x1f label_3B3C: // Incoming jump from 0x3B3B, if not stack[-9] i> stack[-8] + stack[-1] + 0x1f // Inputs[1] { @3B3F memory[0x00:0x00] } 3B3C 60 PUSH1 0x00 3B3E 80 DUP1 3B3F FD *REVERT // Stack delta = +0 // Outputs[1] { @3B3F revert(memory[0x00:0x00]); } // Block terminates label_3B40: // Incoming jump from 0x3B3B, if stack[-9] i> stack[-8] + stack[-1] + 0x1f // Inputs[3] // { // @3B44 stack[-9] // @3B45 stack[-1] // @3B46 msg.data[stack[-1]:stack[-1] + 0x20] // } 3B40 5B JUMPDEST 3B41 61 PUSH2 0x3b4f 3B44 89 DUP10 3B45 82 DUP3 3B46 35 CALLDATALOAD 3B47 60 PUSH1 0x20 3B49 84 DUP5 3B4A 01 ADD 3B4B 61 PUSH2 0x3a5a 3B4E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3B41 stack[0] = 0x3b4f // @3B44 stack[1] = stack[-9] // @3B46 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @3B4A stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x3a5a, returns to 0x3B4F label_3B4F: // Incoming return from call to 0x3A5A at 0x3B4E // Inputs[10] // { // @3B50 stack[-1] // @3B50 stack[-3] // @3B53 stack[-6] // @3B54 stack[-9] // @3B56 stack[-7] // @3B56 stack[-4] // @3B57 stack[-10] // @3B59 stack[-8] // @3B59 stack[-5] // @3B5A stack[-11] // } 3B4F 5B JUMPDEST 3B50 91 SWAP2 3B51 50 POP 3B52 50 POP 3B53 92 SWAP3 3B54 95 SWAP6 3B55 50 POP 3B56 92 SWAP3 3B57 95 SWAP6 3B58 50 POP 3B59 92 SWAP3 3B5A 95 SWAP6 3B5B 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @3B53 stack[-6] = stack[-1] // @3B54 stack[-9] = stack[-6] // @3B56 stack[-7] = stack[-4] // @3B57 stack[-10] = stack[-7] // @3B59 stack[-8] = stack[-5] // @3B5A stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_3B5C: // Incoming call from 0x02AA, returns to 0x02AB // Incoming call from 0x04CA, returns to 0x04CB // Inputs[2] // { // @3B62 stack[-1] // @3B63 stack[-2] // } 3B5C 5B JUMPDEST 3B5D 60 PUSH1 0x00 3B5F 80 DUP1 3B60 60 PUSH1 0x40 3B62 83 DUP4 3B63 85 DUP6 3B64 03 SUB 3B65 12 SLT 3B66 15 ISZERO 3B67 61 PUSH2 0x3b6f 3B6A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3B5D stack[0] = 0x00 // @3B5F stack[1] = 0x00 // } // Block ends with conditional jump to 0x3b6f, if !(stack[-2] - stack[-1] i< 0x40) label_3B6B: // Incoming jump from 0x3B6A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3B6E memory[0x00:0x00] } 3B6B 60 PUSH1 0x00 3B6D 80 DUP1 3B6E FD *REVERT // Stack delta = +0 // Outputs[1] { @3B6E revert(memory[0x00:0x00]); } // Block terminates label_3B6F: // Incoming jump from 0x3B6A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @3B72 stack[-3] // @3B73 msg.data[stack[-3]:stack[-3] + 0x20] // @3B74 stack[-5] // @3B7A msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3B7B stack[-4] // } 3B6F 5B JUMPDEST 3B70 50 POP 3B71 50 POP 3B72 80 DUP1 3B73 35 CALLDATALOAD 3B74 92 SWAP3 3B75 60 PUSH1 0x20 3B77 90 SWAP1 3B78 91 SWAP2 3B79 01 ADD 3B7A 35 CALLDATALOAD 3B7B 91 SWAP2 3B7C 50 POP 3B7D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3B74 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @3B7B stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_3B7E: // Incoming call from 0x02E6, returns to 0x02E7 // Inputs[2] // { // @3B86 stack[-1] // @3B87 stack[-2] // } 3B7E 5B JUMPDEST 3B7F 60 PUSH1 0x00 3B81 80 DUP1 3B82 60 PUSH1 0x00 3B84 60 PUSH1 0x60 3B86 84 DUP5 3B87 86 DUP7 3B88 03 SUB 3B89 12 SLT 3B8A 15 ISZERO 3B8B 61 PUSH2 0x3b93 3B8E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3B7F stack[0] = 0x00 // @3B81 stack[1] = 0x00 // @3B82 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3b93, if !(stack[-2] - stack[-1] i< 0x60) label_3B8F: // Incoming jump from 0x3B8E, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3B92 memory[0x00:0x00] } 3B8F 60 PUSH1 0x00 3B91 80 DUP1 3B92 FD *REVERT // Stack delta = +0 // Outputs[1] { @3B92 revert(memory[0x00:0x00]); } // Block terminates label_3B93: // Incoming jump from 0x3B8E, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3B97 stack[-4] } 3B93 5B JUMPDEST 3B94 61 PUSH2 0x3b9c 3B97 84 DUP5 3B98 61 PUSH2 0x39fe 3B9B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3B94 stack[0] = 0x3b9c // @3B97 stack[1] = stack[-4] // } // Block ends with call to 0x39fe, returns to 0x3B9C label_3B9C: // Incoming return from call to 0x39FE at 0x3B9B // Inputs[3] // { // @3B9D stack[-4] // @3B9D stack[-1] // @3BA4 stack[-5] // } 3B9C 5B JUMPDEST 3B9D 92 SWAP3 3B9E 50 POP 3B9F 61 PUSH2 0x3baa 3BA2 60 PUSH1 0x20 3BA4 85 DUP6 3BA5 01 ADD 3BA6 61 PUSH2 0x39fe 3BA9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3B9D stack[-4] = stack[-1] // @3B9F stack[-1] = 0x3baa // @3BA5 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x39fe, returns to 0x3BAA label_3BAA: // Incoming return from call to 0x39FE at 0x3BA9 // Inputs[8] // { // @3BAB stack[-1] // @3BAB stack[-3] // @3BAF stack[-5] // @3BB1 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3BB2 stack[-2] // @3BB6 stack[-6] // @3BB8 stack[-7] // @3BB8 stack[-4] // } 3BAA 5B JUMPDEST 3BAB 91 SWAP2 3BAC 50 POP 3BAD 60 PUSH1 0x40 3BAF 84 DUP5 3BB0 01 ADD 3BB1 35 CALLDATALOAD 3BB2 90 SWAP1 3BB3 50 POP 3BB4 92 SWAP3 3BB5 50 POP 3BB6 92 SWAP3 3BB7 50 POP 3BB8 92 SWAP3 3BB9 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3BB4 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3BB6 stack[-6] = stack[-1] // @3BB8 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3BBA: // Incoming call from 0x0352, returns to 0x0353 // Incoming call from 0x051D, returns to 0x051E // Incoming call from 0x066A, returns to 0x066B // Incoming call from 0x054D, returns to 0x054E // Incoming call from 0x02F9, returns to 0x02FA // Inputs[2] // { // @3BBF stack[-1] // @3BC0 stack[-2] // } 3BBA 5B JUMPDEST 3BBB 60 PUSH1 0x00 3BBD 60 PUSH1 0x20 3BBF 82 DUP3 3BC0 84 DUP5 3BC1 03 SUB 3BC2 12 SLT 3BC3 15 ISZERO 3BC4 61 PUSH2 0x3bcc 3BC7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3BBB stack[0] = 0x00 } // Block ends with conditional jump to 0x3bcc, if !(stack[-2] - stack[-1] i< 0x20) label_3BC8: // Incoming jump from 0x3BC7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3BCB memory[0x00:0x00] } 3BC8 60 PUSH1 0x00 3BCA 80 DUP1 3BCB FD *REVERT // Stack delta = +0 // Outputs[1] { @3BCB revert(memory[0x00:0x00]); } // Block terminates label_3BCC: // Incoming jump from 0x3BC7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3BCE msg.data[stack[-2]:stack[-2] + 0x20] // @3BCE stack[-2] // @3BCF stack[-4] // @3BD0 stack[-3] // } 3BCC 5B JUMPDEST 3BCD 50 POP 3BCE 35 CALLDATALOAD 3BCF 91 SWAP2 3BD0 90 SWAP1 3BD1 50 POP 3BD2 56 *JUMP // Stack delta = -3 // Outputs[1] { @3BCF stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_3BD3: // Incoming call from 0x0560, returns to 0x0561 // Incoming call from 0x030C, returns to 0x030D // Incoming call from 0x05DE, returns to 0x05DF // Incoming call from 0x033F, returns to 0x0340 // Inputs[2] // { // @3BD9 stack[-1] // @3BDA stack[-2] // } 3BD3 5B JUMPDEST 3BD4 60 PUSH1 0x00 3BD6 80 DUP1 3BD7 60 PUSH1 0x40 3BD9 83 DUP4 3BDA 85 DUP6 3BDB 03 SUB 3BDC 12 SLT 3BDD 15 ISZERO 3BDE 61 PUSH2 0x3be6 3BE1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3BD4 stack[0] = 0x00 // @3BD6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3be6, if !(stack[-2] - stack[-1] i< 0x40) label_3BE2: // Incoming jump from 0x3BE1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3BE5 memory[0x00:0x00] } 3BE2 60 PUSH1 0x00 3BE4 80 DUP1 3BE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @3BE5 revert(memory[0x00:0x00]); } // Block terminates label_3BE6: // Incoming jump from 0x3BE1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @3BE7 stack[-3] // @3BE8 msg.data[stack[-3]:stack[-3] + 0x20] // @3BE9 stack[-2] // } 3BE6 5B JUMPDEST 3BE7 82 DUP3 3BE8 35 CALLDATALOAD 3BE9 91 SWAP2 3BEA 50 POP 3BEB 61 PUSH2 0x3bf6 3BEE 60 PUSH1 0x20 3BF0 84 DUP5 3BF1 01 ADD 3BF2 61 PUSH2 0x39fe 3BF5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3BE9 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @3BEB stack[0] = 0x3bf6 // @3BF1 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x39fe, returns to 0x3BF6 label_3BF6: // Incoming return from call to 0x39FE at 0x3E0A // Incoming return from call to 0x39FE at 0x3BF5 // Inputs[6] // { // @3BF7 stack[-1] // @3BF7 stack[-2] // @3BF9 stack[-5] // @3BFB stack[-3] // @3BFB stack[-6] // @3BFC stack[-4] // } 3BF6 5B JUMPDEST 3BF7 90 SWAP1 3BF8 50 POP 3BF9 92 SWAP3 3BFA 50 POP 3BFB 92 SWAP3 3BFC 90 SWAP1 3BFD 50 POP 3BFE 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3BF9 stack[-5] = stack[-1] // @3BFB stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3BFF: // Incoming call from 0x3C6F, returns to 0x3C70 // Incoming call from 0x3C92, returns to 0x3C93 // Inputs[2] // { // @3C02 stack[-2] // @3C05 stack[-1] // } 3BFF 5B JUMPDEST 3C00 60 PUSH1 0x00 3C02 82 DUP3 3C03 60 PUSH1 0x1f 3C05 83 DUP4 3C06 01 ADD 3C07 12 SLT 3C08 61 PUSH2 0x3c10 3C0B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3C00 stack[0] = 0x00 } // Block ends with conditional jump to 0x3c10, if stack[-1] + 0x1f i< stack[-2] label_3C0C: // Incoming jump from 0x3C0B, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @3C0F memory[0x00:0x00] } 3C0C 60 PUSH1 0x00 3C0E 80 DUP1 3C0F FD *REVERT // Stack delta = +0 // Outputs[1] { @3C0F revert(memory[0x00:0x00]); } // Block terminates label_3C10: // Incoming jump from 0x3C0B, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @3C14 stack[-3] // @3C15 stack[-2] // @3C16 msg.data[stack[-2]:stack[-2] + 0x20] // } 3C10 5B JUMPDEST 3C11 61 PUSH2 0x07d9 3C14 83 DUP4 3C15 83 DUP4 3C16 35 CALLDATALOAD 3C17 60 PUSH1 0x20 3C19 85 DUP6 3C1A 01 ADD 3C1B 61 PUSH2 0x3a5a 3C1E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3C11 stack[0] = 0x07d9 // @3C14 stack[1] = stack[-3] // @3C16 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @3C1A stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x3a5a, returns to 0x07D9 label_3C1F: // Incoming call from 0x3D0E, returns to 0x3D0F // Incoming call from 0x3CA1, returns to 0x3CA2 // Incoming call from 0x3DC4, returns to 0x3DC5 // Inputs[2] // { // @3C20 stack[-1] // @3C21 msg.data[stack[-1]:stack[-1] + 0x20] // } 3C1F 5B JUMPDEST 3C20 80 DUP1 3C21 35 CALLDATALOAD 3C22 60 PUSH1 0xff 3C24 81 DUP2 3C25 16 AND 3C26 81 DUP2 3C27 14 EQ 3C28 61 PUSH2 0x3a15 3C2B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3C21 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x3a15, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff label_3C2C: // Incoming jump from 0x3C2B, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff // Inputs[1] { @3C2F memory[0x00:0x00] } 3C2C 60 PUSH1 0x00 3C2E 80 DUP1 3C2F FD *REVERT // Stack delta = +0 // Outputs[1] { @3C2F revert(memory[0x00:0x00]); } // Block terminates label_3C30: // Incoming call from 0x0378, returns to 0x0379 // Inputs[2] // { // @3C40 stack[-1] // @3C41 stack[-2] // } 3C30 5B JUMPDEST 3C31 60 PUSH1 0x00 3C33 80 DUP1 3C34 60 PUSH1 0x00 3C36 80 DUP1 3C37 60 PUSH1 0x00 3C39 80 DUP1 3C3A 60 PUSH1 0x00 3C3C 80 DUP1 3C3D 61 PUSH2 0x0100 3C40 89 DUP10 3C41 8B DUP12 3C42 03 SUB 3C43 12 SLT 3C44 15 ISZERO 3C45 61 PUSH2 0x3c4d 3C48 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @3C31 stack[0] = 0x00 // @3C33 stack[1] = 0x00 // @3C34 stack[2] = 0x00 // @3C36 stack[3] = 0x00 // @3C37 stack[4] = 0x00 // @3C39 stack[5] = 0x00 // @3C3A stack[6] = 0x00 // @3C3C stack[7] = 0x00 // } // Block ends with conditional jump to 0x3c4d, if !(stack[-2] - stack[-1] i< 0x0100) label_3C49: // Incoming jump from 0x3C48, if not !(stack[-2] - stack[-1] i< 0x0100) // Inputs[1] { @3C4C memory[0x00:0x00] } 3C49 60 PUSH1 0x00 3C4B 80 DUP1 3C4C FD *REVERT // Stack delta = +0 // Outputs[1] { @3C4C revert(memory[0x00:0x00]); } // Block terminates label_3C4D: // Incoming jump from 0x3C48, if !(stack[-2] - stack[-1] i< 0x0100) // Inputs[2] // { // @3C4E stack[-9] // @3C4F msg.data[stack[-9]:stack[-9] + 0x20] // } 3C4D 5B JUMPDEST 3C4E 88 DUP9 3C4F 35 CALLDATALOAD 3C50 60 PUSH1 0x01 3C52 60 PUSH1 0x01 3C54 60 PUSH1 0x40 3C56 1B SHL 3C57 03 SUB 3C58 80 DUP1 3C59 82 DUP3 3C5A 11 GT 3C5B 15 ISZERO 3C5C 61 PUSH2 0x3c64 3C5F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3C4F stack[0] = msg.data[stack[-9]:stack[-9] + 0x20] // @3C57 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x3c64, if !(msg.data[stack[-9]:stack[-9] + 0x20] > (0x01 << 0x40) - 0x01) label_3C60: // Incoming jump from 0x3C5F, if not !(msg.data[stack[-9]:stack[-9] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @3C63 memory[0x00:0x00] } 3C60 60 PUSH1 0x00 3C62 80 DUP1 3C63 FD *REVERT // Stack delta = +0 // Outputs[1] { @3C63 revert(memory[0x00:0x00]); } // Block terminates label_3C64: // Incoming jump from 0x3C5F, if !(msg.data[stack[-9]:stack[-9] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @3C68 stack[-12] // @3C69 stack[-2] // @3C6A stack[-11] // } 3C64 5B JUMPDEST 3C65 61 PUSH2 0x3c70 3C68 8C DUP13 3C69 83 DUP4 3C6A 8D DUP14 3C6B 01 ADD 3C6C 61 PUSH2 0x3bff 3C6F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3C65 stack[0] = 0x3c70 // @3C68 stack[1] = stack[-12] // @3C6B stack[2] = stack[-11] + stack[-2] // } // Block ends with call to 0x3bff, returns to 0x3C70 label_3C70: // Incoming return from call to 0x3BFF at 0x3C6F // Inputs[6] // { // @3C71 stack[-11] // @3C71 stack[-1] // @3C75 stack[-12] // @3C77 msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] // @3C78 stack[-3] // @3C7A stack[-2] // } 3C70 5B JUMPDEST 3C71 99 SWAP10 3C72 50 POP 3C73 60 PUSH1 0x20 3C75 8B DUP12 3C76 01 ADD 3C77 35 CALLDATALOAD 3C78 91 SWAP2 3C79 50 POP 3C7A 80 DUP1 3C7B 82 DUP3 3C7C 11 GT 3C7D 15 ISZERO 3C7E 61 PUSH2 0x3c86 3C81 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @3C71 stack[-11] = stack[-1] // @3C78 stack[-3] = msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x3c86, if !(msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] > stack[-2]) label_3C82: // Incoming jump from 0x3C81, if not !(msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @3C85 memory[0x00:0x00] } 3C82 60 PUSH1 0x00 3C84 80 DUP1 3C85 FD *REVERT // Stack delta = +0 // Outputs[1] { @3C85 revert(memory[0x00:0x00]); } // Block terminates label_3C86: // Incoming jump from 0x3C81, if !(msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @3C8B stack[-12] // @3C8C stack[-2] // @3C8D stack[-11] // } 3C86 5B JUMPDEST 3C87 50 POP 3C88 61 PUSH2 0x3c93 3C8B 8B DUP12 3C8C 82 DUP3 3C8D 8C DUP13 3C8E 01 ADD 3C8F 61 PUSH2 0x3bff 3C92 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3C88 stack[-1] = 0x3c93 // @3C8B stack[0] = stack[-12] // @3C8E stack[1] = stack[-11] + stack[-2] // } // Block ends with call to 0x3bff, returns to 0x3C93 label_3C93: // Incoming return from call to 0x3BFF at 0x3C92 // Inputs[3] // { // @3C94 stack[-9] // @3C94 stack[-1] // @3C9C stack[-11] // } 3C93 5B JUMPDEST 3C94 97 SWAP8 3C95 50 POP 3C96 50 POP 3C97 61 PUSH2 0x3ca2 3C9A 60 PUSH1 0x40 3C9C 8A DUP11 3C9D 01 ADD 3C9E 61 PUSH2 0x3c1f 3CA1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @3C94 stack[-9] = stack[-1] // @3C97 stack[-2] = 0x3ca2 // @3C9D stack[-1] = stack[-11] + 0x40 // } // Block ends with call to 0x3c1f, returns to 0x3CA2 label_3CA2: // Incoming return from call to 0x3C1F at 0x3CA1 // Inputs[3] // { // @3CA3 stack[-1] // @3CA3 stack[-7] // @3CAA stack[-10] // } 3CA2 5B JUMPDEST 3CA3 95 SWAP6 3CA4 50 POP 3CA5 61 PUSH2 0x3cb0 3CA8 60 PUSH1 0x60 3CAA 8A DUP11 3CAB 01 ADD 3CAC 61 PUSH2 0x39fe 3CAF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3CA3 stack[-7] = stack[-1] // @3CA5 stack[-1] = 0x3cb0 // @3CAB stack[0] = stack[-10] + 0x60 // } // Block ends with call to 0x39fe, returns to 0x3CB0 label_3CB0: // Incoming return from call to 0x39FE at 0x3CAF // Inputs[15] // { // @3CB1 stack[-1] // @3CB1 stack[-9] // @3CB2 stack[-12] // @3CB3 stack[-8] // @3CB4 stack[-11] // @3CB6 stack[-2] // @3CB6 stack[-7] // @3CB7 stack[-10] // @3CBC msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @3CC2 msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @3CC9 msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @3CCA stack[-6] // @3CD1 msg.data[stack[-10] + 0xe0:stack[-10] + 0xe0 + 0x20] // @3CD2 stack[-5] // @3CD4 stack[-4] // } 3CB0 5B JUMPDEST 3CB1 97 SWAP8 3CB2 9A SWAP11 3CB3 96 SWAP7 3CB4 99 SWAP10 3CB5 50 POP 3CB6 94 SWAP5 3CB7 97 SWAP8 3CB8 60 PUSH1 0x80 3CBA 81 DUP2 3CBB 01 ADD 3CBC 35 CALLDATALOAD 3CBD 96 SWAP7 3CBE 60 PUSH1 0xa0 3CC0 82 DUP3 3CC1 01 ADD 3CC2 35 CALLDATALOAD 3CC3 96 SWAP7 3CC4 50 POP 3CC5 60 PUSH1 0xc0 3CC7 82 DUP3 3CC8 01 ADD 3CC9 35 CALLDATALOAD 3CCA 95 SWAP6 3CCB 50 POP 3CCC 60 PUSH1 0xe0 3CCE 90 SWAP1 3CCF 91 SWAP2 3CD0 01 ADD 3CD1 35 CALLDATALOAD 3CD2 93 SWAP4 3CD3 50 POP 3CD4 91 SWAP2 3CD5 50 POP 3CD6 50 POP 3CD7 56 *JUMP // Stack delta = -4 // Outputs[8] // { // @3CB1 stack[-9] = stack[-1] // @3CB2 stack[-12] = stack[-9] // @3CB4 stack[-11] = stack[-8] // @3CB7 stack[-10] = stack[-7] // @3CBD stack[-8] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @3CC3 stack[-7] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @3CCA stack[-6] = msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @3CD2 stack[-5] = msg.data[stack[-10] + 0xe0:stack[-10] + 0xe0 + 0x20] // } // Block ends with unconditional jump to stack[-12] label_3CD8: // Incoming call from 0x0393, returns to 0x0394 // Inputs[2] // { // @3CE4 stack[-1] // @3CE5 stack[-2] // } 3CD8 5B JUMPDEST 3CD9 60 PUSH1 0x00 3CDB 80 DUP1 3CDC 60 PUSH1 0x00 3CDE 80 DUP1 3CDF 60 PUSH1 0x00 3CE1 80 DUP1 3CE2 60 PUSH1 0xc0 3CE4 87 DUP8 3CE5 89 DUP10 3CE6 03 SUB 3CE7 12 SLT 3CE8 15 ISZERO 3CE9 61 PUSH2 0x3cf1 3CEC 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @3CD9 stack[0] = 0x00 // @3CDB stack[1] = 0x00 // @3CDC stack[2] = 0x00 // @3CDE stack[3] = 0x00 // @3CDF stack[4] = 0x00 // @3CE1 stack[5] = 0x00 // } // Block ends with conditional jump to 0x3cf1, if !(stack[-2] - stack[-1] i< 0xc0) label_3CED: // Incoming jump from 0x3CEC, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @3CF0 memory[0x00:0x00] } 3CED 60 PUSH1 0x00 3CEF 80 DUP1 3CF0 FD *REVERT // Stack delta = +0 // Outputs[1] { @3CF0 revert(memory[0x00:0x00]); } // Block terminates label_3CF1: // Incoming jump from 0x3CEC, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[7] // { // @3CF2 stack[-7] // @3CF3 msg.data[stack[-7]:stack[-7] + 0x20] // @3CF4 stack[-6] // @3CFA msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @3CFB stack[-5] // @3D01 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3D02 stack[-4] // } 3CF1 5B JUMPDEST 3CF2 86 DUP7 3CF3 35 CALLDATALOAD 3CF4 95 SWAP6 3CF5 50 POP 3CF6 60 PUSH1 0x20 3CF8 87 DUP8 3CF9 01 ADD 3CFA 35 CALLDATALOAD 3CFB 94 SWAP5 3CFC 50 POP 3CFD 60 PUSH1 0x40 3CFF 87 DUP8 3D00 01 ADD 3D01 35 CALLDATALOAD 3D02 93 SWAP4 3D03 50 POP 3D04 61 PUSH2 0x3d0f 3D07 60 PUSH1 0x60 3D09 88 DUP9 3D0A 01 ADD 3D0B 61 PUSH2 0x3c1f 3D0E 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3CF4 stack[-6] = msg.data[stack[-7]:stack[-7] + 0x20] // @3CFB stack[-5] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @3D02 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3D04 stack[0] = 0x3d0f // @3D0A stack[1] = stack[-7] + 0x60 // } // Block ends with call to 0x3c1f, returns to 0x3D0F label_3D0F: // Incoming return from call to 0x3C1F at 0x3D0E // Inputs[12] // { // @3D10 stack[-4] // @3D10 stack[-1] // @3D14 stack[-8] // @3D16 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @3D17 stack[-3] // @3D1D msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // @3D1E stack[-2] // @3D20 stack[-5] // @3D23 stack[-6] // @3D24 stack[-9] // @3D26 stack[-7] // @3D27 stack[-10] // } 3D0F 5B JUMPDEST 3D10 92 SWAP3 3D11 50 POP 3D12 60 PUSH1 0x80 3D14 87 DUP8 3D15 01 ADD 3D16 35 CALLDATALOAD 3D17 91 SWAP2 3D18 50 POP 3D19 60 PUSH1 0xa0 3D1B 87 DUP8 3D1C 01 ADD 3D1D 35 CALLDATALOAD 3D1E 90 SWAP1 3D1F 50 POP 3D20 92 SWAP3 3D21 95 SWAP6 3D22 50 POP 3D23 92 SWAP3 3D24 95 SWAP6 3D25 50 POP 3D26 92 SWAP3 3D27 95 SWAP6 3D28 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @3D20 stack[-5] = msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // @3D21 stack[-8] = stack[-5] // @3D23 stack[-6] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @3D24 stack[-9] = stack[-6] // @3D26 stack[-7] = stack[-1] // @3D27 stack[-10] = stack[-7] // } // Block ends with unconditional jump to stack[-10] label_3D29: // Incoming call from 0x0409, returns to 0x040A // Incoming call from 0x0573, returns to 0x0574 // Incoming call from 0x04B7, returns to 0x04B8 // Incoming call from 0x0460, returns to 0x0461 // Inputs[2] // { // @3D2E stack[-1] // @3D2F stack[-2] // } 3D29 5B JUMPDEST 3D2A 60 PUSH1 0x00 3D2C 60 PUSH1 0x20 3D2E 82 DUP3 3D2F 84 DUP5 3D30 03 SUB 3D31 12 SLT 3D32 15 ISZERO 3D33 61 PUSH2 0x3d3b 3D36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3D2A stack[0] = 0x00 } // Block ends with conditional jump to 0x3d3b, if !(stack[-2] - stack[-1] i< 0x20) label_3D37: // Incoming jump from 0x3D36, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3D3A memory[0x00:0x00] } 3D37 60 PUSH1 0x00 3D39 80 DUP1 3D3A FD *REVERT // Stack delta = +0 // Outputs[1] { @3D3A revert(memory[0x00:0x00]); } // Block terminates label_3D3B: // Incoming jump from 0x3D36, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3D3F stack[-2] } 3D3B 5B JUMPDEST 3D3C 61 PUSH2 0x07d9 3D3F 82 DUP3 3D40 61 PUSH2 0x39fe 3D43 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3D3C stack[0] = 0x07d9 // @3D3F stack[1] = stack[-2] // } // Block ends with call to 0x39fe, returns to 0x07D9 label_3D44: // Incoming call from 0x044D, returns to 0x044E // Inputs[2] // { // @3D4C stack[-1] // @3D4D stack[-2] // } 3D44 5B JUMPDEST 3D45 60 PUSH1 0x00 3D47 80 DUP1 3D48 60 PUSH1 0x00 3D4A 60 PUSH1 0x60 3D4C 84 DUP5 3D4D 86 DUP7 3D4E 03 SUB 3D4F 12 SLT 3D50 15 ISZERO 3D51 61 PUSH2 0x3d59 3D54 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3D45 stack[0] = 0x00 // @3D47 stack[1] = 0x00 // @3D48 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3d59, if !(stack[-2] - stack[-1] i< 0x60) label_3D55: // Incoming jump from 0x3D54, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3D58 memory[0x00:0x00] } 3D55 60 PUSH1 0x00 3D57 80 DUP1 3D58 FD *REVERT // Stack delta = +0 // Outputs[1] { @3D58 revert(memory[0x00:0x00]); } // Block terminates label_3D59: // Incoming jump from 0x3D54, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3D5D stack[-4] } 3D59 5B JUMPDEST 3D5A 61 PUSH2 0x3d62 3D5D 84 DUP5 3D5E 61 PUSH2 0x39fe 3D61 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3D5A stack[0] = 0x3d62 // @3D5D stack[1] = stack[-4] // } // Block ends with call to 0x39fe, returns to 0x3D62 label_3D62: // Incoming return from call to 0x39FE at 0x3D61 // Inputs[7] // { // @3D63 stack[-7] // @3D63 stack[-1] // @3D66 stack[-5] // @3D68 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3D69 stack[-6] // @3D70 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3D72 stack[-4] // } 3D62 5B JUMPDEST 3D63 95 SWAP6 3D64 60 PUSH1 0x20 3D66 85 DUP6 3D67 01 ADD 3D68 35 CALLDATALOAD 3D69 95 SWAP6 3D6A 50 POP 3D6B 60 PUSH1 0x40 3D6D 90 SWAP1 3D6E 94 SWAP5 3D6F 01 ADD 3D70 35 CALLDATALOAD 3D71 93 SWAP4 3D72 92 SWAP3 3D73 50 POP 3D74 50 POP 3D75 50 POP 3D76 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3D63 stack[-7] = stack[-1] // @3D69 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3D71 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_3D77: // Incoming call from 0x05CB, returns to 0x05CC // Inputs[2] // { // @3D85 stack[-1] // @3D86 stack[-2] // } 3D77 5B JUMPDEST 3D78 60 PUSH1 0x00 3D7A 80 DUP1 3D7B 60 PUSH1 0x00 3D7D 80 DUP1 3D7E 60 PUSH1 0x00 3D80 80 DUP1 3D81 60 PUSH1 0x00 3D83 60 PUSH1 0xe0 3D85 88 DUP9 3D86 8A DUP11 3D87 03 SUB 3D88 12 SLT 3D89 15 ISZERO 3D8A 61 PUSH2 0x3d92 3D8D 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @3D78 stack[0] = 0x00 // @3D7A stack[1] = 0x00 // @3D7B stack[2] = 0x00 // @3D7D stack[3] = 0x00 // @3D7E stack[4] = 0x00 // @3D80 stack[5] = 0x00 // @3D81 stack[6] = 0x00 // } // Block ends with conditional jump to 0x3d92, if !(stack[-2] - stack[-1] i< 0xe0) label_3D8E: // Incoming jump from 0x3D8D, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[1] { @3D91 memory[0x00:0x00] } 3D8E 60 PUSH1 0x00 3D90 80 DUP1 3D91 FD *REVERT // Stack delta = +0 // Outputs[1] { @3D91 revert(memory[0x00:0x00]); } // Block terminates label_3D92: // Incoming jump from 0x3D8D, if !(stack[-2] - stack[-1] i< 0xe0) // Inputs[1] { @3D96 stack[-8] } 3D92 5B JUMPDEST 3D93 61 PUSH2 0x3d9b 3D96 88 DUP9 3D97 61 PUSH2 0x39fe 3D9A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3D93 stack[0] = 0x3d9b // @3D96 stack[1] = stack[-8] // } // Block ends with call to 0x39fe, returns to 0x3D9B label_3D9B: // Incoming return from call to 0x39FE at 0x3D9A // Inputs[3] // { // @3D9C stack[-1] // @3D9C stack[-8] // @3DA3 stack[-9] // } 3D9B 5B JUMPDEST 3D9C 96 SWAP7 3D9D 50 POP 3D9E 61 PUSH2 0x3da9 3DA1 60 PUSH1 0x20 3DA3 89 DUP10 3DA4 01 ADD 3DA5 61 PUSH2 0x39fe 3DA8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3D9C stack[-8] = stack[-1] // @3D9E stack[-1] = 0x3da9 // @3DA4 stack[0] = stack[-9] + 0x20 // } // Block ends with call to 0x39fe, returns to 0x3DA9 label_3DA9: // Incoming return from call to 0x39FE at 0x3DA8 // Inputs[7] // { // @3DAA stack[-1] // @3DAA stack[-7] // @3DAE stack[-9] // @3DB0 msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @3DB1 stack[-6] // @3DB7 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @3DB8 stack[-5] // } 3DA9 5B JUMPDEST 3DAA 95 SWAP6 3DAB 50 POP 3DAC 60 PUSH1 0x40 3DAE 88 DUP9 3DAF 01 ADD 3DB0 35 CALLDATALOAD 3DB1 94 SWAP5 3DB2 50 POP 3DB3 60 PUSH1 0x60 3DB5 88 DUP9 3DB6 01 ADD 3DB7 35 CALLDATALOAD 3DB8 93 SWAP4 3DB9 50 POP 3DBA 61 PUSH2 0x3dc5 3DBD 60 PUSH1 0x80 3DBF 89 DUP10 3DC0 01 ADD 3DC1 61 PUSH2 0x3c1f 3DC4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3DAA stack[-7] = stack[-1] // @3DB1 stack[-6] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @3DB8 stack[-5] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @3DBA stack[-1] = 0x3dc5 // @3DC0 stack[0] = stack[-9] + 0x80 // } // Block ends with call to 0x3c1f, returns to 0x3DC5 label_3DC5: // Incoming return from call to 0x3C1F at 0x3DC4 // Inputs[13] // { // @3DC6 stack[-4] // @3DC6 stack[-1] // @3DCA stack[-9] // @3DCC msg.data[stack[-9] + 0xa0:stack[-9] + 0xa0 + 0x20] // @3DCD stack[-3] // @3DD3 msg.data[stack[-9] + 0xc0:stack[-9] + 0xc0 + 0x20] // @3DD4 stack[-2] // @3DD6 stack[-5] // @3DD7 stack[-8] // @3DD8 stack[-11] // @3DDA stack[-7] // @3DDB stack[-10] // @3DDD stack[-6] // } 3DC5 5B JUMPDEST 3DC6 92 SWAP3 3DC7 50 POP 3DC8 60 PUSH1 0xa0 3DCA 88 DUP9 3DCB 01 ADD 3DCC 35 CALLDATALOAD 3DCD 91 SWAP2 3DCE 50 POP 3DCF 60 PUSH1 0xc0 3DD1 88 DUP9 3DD2 01 ADD 3DD3 35 CALLDATALOAD 3DD4 90 SWAP1 3DD5 50 POP 3DD6 92 SWAP3 3DD7 95 SWAP6 3DD8 98 SWAP9 3DD9 91 SWAP2 3DDA 94 SWAP5 3DDB 97 SWAP8 3DDC 50 POP 3DDD 92 SWAP3 3DDE 95 SWAP6 3DDF 50 POP 3DE0 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @3DD6 stack[-5] = msg.data[stack[-9] + 0xc0:stack[-9] + 0xc0 + 0x20] // @3DD7 stack[-8] = stack[-5] // @3DD8 stack[-11] = stack[-8] // @3DDA stack[-7] = stack[-1] // @3DDB stack[-10] = stack[-7] // @3DDD stack[-6] = msg.data[stack[-9] + 0xa0:stack[-9] + 0xa0 + 0x20] // @3DDE stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-11] label_3DE1: // Incoming jump from 0x05F1 // Inputs[2] // { // @3DE7 stack[-1] // @3DE8 stack[-2] // } 3DE1 5B JUMPDEST 3DE2 60 PUSH1 0x00 3DE4 80 DUP1 3DE5 60 PUSH1 0x40 3DE7 83 DUP4 3DE8 85 DUP6 3DE9 03 SUB 3DEA 12 SLT 3DEB 15 ISZERO 3DEC 61 PUSH2 0x3df4 3DEF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3DE2 stack[0] = 0x00 // @3DE4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3df4, if !(stack[-2] - stack[-1] i< 0x40) label_3DF0: // Incoming jump from 0x3DEF, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3DF3 memory[0x00:0x00] } 3DF0 60 PUSH1 0x00 3DF2 80 DUP1 3DF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @3DF3 revert(memory[0x00:0x00]); } // Block terminates label_3DF4: // Incoming jump from 0x3DEF, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3DF8 stack[-3] } 3DF4 5B JUMPDEST 3DF5 61 PUSH2 0x3dfd 3DF8 83 DUP4 3DF9 61 PUSH2 0x39fe 3DFC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3DF5 stack[0] = 0x3dfd // @3DF8 stack[1] = stack[-3] // } // Block ends with call to 0x39fe, returns to 0x3DFD label_3DFD: // Incoming return from call to 0x39FE at 0x3DFC // Inputs[3] // { // @3DFE stack[-1] // @3DFE stack[-3] // @3E05 stack[-4] // } 3DFD 5B JUMPDEST 3DFE 91 SWAP2 3DFF 50 POP 3E00 61 PUSH2 0x3bf6 3E03 60 PUSH1 0x20 3E05 84 DUP5 3E06 01 ADD 3E07 61 PUSH2 0x39fe 3E0A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3DFE stack[-3] = stack[-1] // @3E00 stack[-1] = 0x3bf6 // @3E06 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x39fe, returns to 0x3BF6 label_3E0B: // Incoming call from 0x06E1, returns to 0x06E2 // Incoming call from 0x06B5, returns to 0x06B6 // Incoming call from 0x1406, returns to 0x06B6 // Incoming call from 0x38F0, returns to 0x38F1 // Inputs[1] { @3E0E stack[-1] } 3E0B 5B JUMPDEST 3E0C 60 PUSH1 0x01 3E0E 81 DUP2 3E0F 81 DUP2 3E10 1C SHR 3E11 90 SWAP1 3E12 82 DUP3 3E13 16 AND 3E14 80 DUP1 3E15 61 PUSH2 0x3e1f 3E18 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3E11 stack[0] = stack[-1] >> 0x01 // @3E13 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x3e1f, if stack[-1] & 0x01 label_3E19: // Incoming jump from 0x3E18, if not stack[-1] & 0x01 // Inputs[2] // { // @3E1B stack[-2] // @3E24 stack[-1] // } 3E19 60 PUSH1 0x7f 3E1B 82 DUP3 3E1C 16 AND 3E1D 91 SWAP2 3E1E 50 POP 3E1F 5B JUMPDEST 3E20 60 PUSH1 0x20 3E22 82 DUP3 3E23 10 LT 3E24 81 DUP2 3E25 14 EQ 3E26 15 ISZERO 3E27 61 PUSH2 0x2ebd 3E2A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3E1D stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2ebd, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_3E2B: // Incoming jump from 0x3E2A, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x3E2A, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @3E3F memory[0x00:0x24] } 3E2B 63 PUSH4 0x4e487b71 3E30 60 PUSH1 0xe0 3E32 1B SHL 3E33 60 PUSH1 0x00 3E35 52 MSTORE 3E36 60 PUSH1 0x22 3E38 60 PUSH1 0x04 3E3A 52 MSTORE 3E3B 60 PUSH1 0x24 3E3D 60 PUSH1 0x00 3E3F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3E35 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3E3A memory[0x04:0x24] = 0x22 // @3E3F revert(memory[0x00:0x24]); // } // Block terminates label_3E40: // Incoming jump from 0x3392 // Incoming jump from 0x1F20 // Incoming jump from 0x3461 // Incoming jump from 0x1F0F // Incoming jump from 0x3318 // Incoming jump from 0x3335 // Incoming jump from 0x33F4 // Incoming jump from 0x1FF3 // Incoming jump from 0x1FE2 // Inputs[1] { @3E55 memory[0x00:0x24] } 3E40 5B JUMPDEST 3E41 63 PUSH4 0x4e487b71 3E46 60 PUSH1 0xe0 3E48 1B SHL 3E49 60 PUSH1 0x00 3E4B 52 MSTORE 3E4C 60 PUSH1 0x21 3E4E 60 PUSH1 0x04 3E50 52 MSTORE 3E51 60 PUSH1 0x24 3E53 60 PUSH1 0x00 3E55 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3E4B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3E50 memory[0x04:0x24] = 0x21 // @3E55 revert(memory[0x00:0x24]); // } // Block terminates label_3E56: // Incoming call from 0x0783, returns to 0x0784 // Inputs[1] { @3E5B stack[-9] } 3E56 5B JUMPDEST 3E57 60 PUSH1 0x00 3E59 60 PUSH1 0x05 3E5B 8A DUP11 3E5C 10 LT 3E5D 61 PUSH2 0x3e76 3E60 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3E57 stack[0] = 0x00 } // Block ends with conditional jump to 0x3e76, if stack[-9] < 0x05 label_3E61: // Incoming jump from 0x3E60, if not stack[-9] < 0x05 // Inputs[1] { @3E75 memory[0x00:0x24] } 3E61 63 PUSH4 0x4e487b71 3E66 60 PUSH1 0xe0 3E68 1B SHL 3E69 60 PUSH1 0x00 3E6B 52 MSTORE 3E6C 60 PUSH1 0x21 3E6E 60 PUSH1 0x04 3E70 52 MSTORE 3E71 60 PUSH1 0x24 3E73 60 PUSH1 0x00 3E75 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3E6B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3E70 memory[0x04:0x24] = 0x21 // @3E75 revert(memory[0x00:0x24]); // } // Block terminates label_3E76: // Incoming jump from 0x3E60, if stack[-9] < 0x05 // Inputs[10] // { // @3E7A stack[-10] // @3E7B stack[-2] // @3E84 stack[-9] // @3E85 stack[-3] // @3E93 stack[-8] // @3E9D stack[-7] // @3EA7 stack[-4] // @3EA7 stack[-6] // @3EA8 stack[-5] // @3EC8 stack[-11] // } 3E76 5B JUMPDEST 3E77 50 POP 3E78 60 PUSH1 0xf8 3E7A 98 SWAP9 3E7B 90 SWAP1 3E7C 98 SWAP9 3E7D 1B SHL 3E7E 88 DUP9 3E7F 52 MSTORE 3E80 60 PUSH1 0x01 3E82 88 DUP9 3E83 01 ADD 3E84 96 SWAP7 3E85 90 SWAP1 3E86 96 SWAP7 3E87 52 MSTORE 3E88 60 PUSH1 0x01 3E8A 60 PUSH1 0x01 3E8C 60 PUSH1 0x60 3E8E 1B SHL 3E8F 03 SUB 3E90 19 NOT 3E91 60 PUSH1 0x60 3E93 95 SWAP6 3E94 86 DUP7 3E95 1B SHL 3E96 81 DUP2 3E97 16 AND 3E98 60 PUSH1 0x21 3E9A 89 DUP10 3E9B 01 ADD 3E9C 52 MSTORE 3E9D 93 SWAP4 3E9E 85 DUP6 3E9F 1B SHL 3EA0 84 DUP5 3EA1 16 AND 3EA2 60 PUSH1 0x35 3EA4 88 DUP9 3EA5 01 ADD 3EA6 52 MSTORE 3EA7 91 SWAP2 3EA8 90 SWAP1 3EA9 93 SWAP4 3EAA 1B SHL 3EAB 90 SWAP1 3EAC 91 SWAP2 3EAD 16 AND 3EAE 60 PUSH1 0x49 3EB0 85 DUP6 3EB1 01 ADD 3EB2 52 MSTORE 3EB3 60 PUSH1 0x5d 3EB5 84 DUP5 3EB6 01 ADD 3EB7 91 SWAP2 3EB8 90 SWAP1 3EB9 91 SWAP2 3EBA 52 MSTORE 3EBB 60 PUSH1 0x7d 3EBD 83 DUP4 3EBE 01 ADD 3EBF 52 MSTORE 3EC0 60 PUSH1 0x9d 3EC2 82 DUP3 3EC3 01 ADD 3EC4 52 MSTORE 3EC5 60 PUSH1 0xbd 3EC7 01 ADD 3EC8 90 SWAP1 3EC9 56 *JUMP // Stack delta = -10 // Outputs[9] // { // @3E7F memory[stack[-2]:stack[-2] + 0x20] = stack[-10] << 0xf8 // @3E87 memory[stack[-2] + 0x01:stack[-2] + 0x01 + 0x20] = stack[-9] // @3E9C memory[stack[-2] + 0x21:stack[-2] + 0x21 + 0x20] = ~((0x01 << 0x60) - 0x01) & (stack[-8] << 0x60) // @3EA6 memory[stack[-2] + 0x35:stack[-2] + 0x35 + 0x20] = ~((0x01 << 0x60) - 0x01) & (stack[-7] << 0x60) // @3EB2 memory[stack[-2] + 0x49:stack[-2] + 0x49 + 0x20] = ~((0x01 << 0x60) - 0x01) & (stack[-6] << 0x60) // @3EBA memory[stack[-2] + 0x5d:stack[-2] + 0x5d + 0x20] = stack[-5] // @3EBF memory[stack[-2] + 0x7d:stack[-2] + 0x7d + 0x20] = stack[-4] // @3EC4 memory[stack[-2] + 0x9d:stack[-2] + 0x9d + 0x20] = stack[-3] // @3EC8 stack[-11] = 0xbd + stack[-2] // } // Block ends with unconditional jump to stack[-11] label_3ECA: // Incoming call from 0x0816, returns to 0x0817 // Incoming call from 0x174D, returns to 0x0817 // Inputs[2] // { // @3ECE stack[-1] // @3EFD stack[-2] // } 3ECA 5B JUMPDEST 3ECB 60 PUSH1 0x20 3ECD 80 DUP1 3ECE 82 DUP3 3ECF 52 MSTORE 3ED0 60 PUSH1 0x1b 3ED2 90 SWAP1 3ED3 82 DUP3 3ED4 01 ADD 3ED5 52 MSTORE 3ED6 7A PUSH27 0x10d85b1b195c881b5d5cdd0818994811d5110818dbdb9d1c9858dd 3EF2 60 PUSH1 0x2a 3EF4 1B SHL 3EF5 60 PUSH1 0x40 3EF7 82 DUP3 3EF8 01 ADD 3EF9 52 MSTORE 3EFA 60 PUSH1 0x60 3EFC 01 ADD 3EFD 90 SWAP1 3EFE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3ECF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3ED5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1b // @3EF9 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x10d85b1b195c881b5d5cdd0818994811d5110818dbdb9d1c9858dd << 0x2a // @3EFD stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3EFF: // Incoming call from 0x176D, returns to 0x0817 // Incoming call from 0x083F, returns to 0x0817 // Inputs[2] // { // @3F03 stack[-1] // @3F47 stack[-2] // } 3EFF 5B JUMPDEST 3F00 60 PUSH1 0x20 3F02 80 DUP1 3F03 82 DUP3 3F04 52 MSTORE 3F05 60 PUSH1 0x2a 3F07 90 SWAP1 3F08 82 DUP3 3F09 01 ADD 3F0A 52 MSTORE 3F0B 7F PUSH32 0x45524332305265776172643a20616d6f756e74206d7573742062652067726561 3F2C 60 PUSH1 0x40 3F2E 82 DUP3 3F2F 01 ADD 3F30 52 MSTORE 3F31 69 PUSH10 0x0746572207468616e203 3F3C 60 PUSH1 0xb4 3F3E 1B SHL 3F3F 60 PUSH1 0x60 3F41 82 DUP3 3F42 01 ADD 3F43 52 MSTORE 3F44 60 PUSH1 0x80 3F46 01 ADD 3F47 90 SWAP1 3F48 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3F04 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3F0A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @3F30 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45524332305265776172643a20616d6f756e74206d7573742062652067726561 // @3F43 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x0746572207468616e203 << 0xb4 // @3F47 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3F49: // Incoming jump from 0x3FC0 // Incoming jump from 0x4337 // Incoming jump from 0x417E // Incoming jump from 0x4239 // Incoming jump from 0x3F88 // Incoming jump from 0x428F // Incoming jump from 0x4318 // Incoming jump from 0x42A8 // Incoming jump from 0x3F71 // Incoming jump from 0x41ED // Incoming jump from 0x426D // Inputs[1] { @3F5E memory[0x00:0x24] } 3F49 5B JUMPDEST 3F4A 63 PUSH4 0x4e487b71 3F4F 60 PUSH1 0xe0 3F51 1B SHL 3F52 60 PUSH1 0x00 3F54 52 MSTORE 3F55 60 PUSH1 0x11 3F57 60 PUSH1 0x04 3F59 52 MSTORE 3F5A 60 PUSH1 0x24 3F5C 60 PUSH1 0x00 3F5E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3F54 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3F59 memory[0x04:0x24] = 0x11 // @3F5E revert(memory[0x00:0x24]); // } // Block terminates label_3F5F: // Incoming call from 0x1386, returns to 0x1387 // Incoming call from 0x35FB, returns to 0x35FC // Incoming call from 0x1716, returns to 0x0C1F // Incoming call from 0x16E6, returns to 0x16E7 // Incoming call from 0x27AB, returns to 0x27AC // Incoming call from 0x3202, returns to 0x3203 // Incoming call from 0x2327, returns to 0x2328 // Incoming call from 0x1CB2, returns to 0x1CB3 // Incoming call from 0x26D5, returns to 0x26D6 // Incoming call from 0x17A0, returns to 0x17A1 // Incoming call from 0x08BE, returns to 0x08BF // Incoming call from 0x3839, returns to 0x383A // Incoming call from 0x127A, returns to 0x127B // Incoming call from 0x0CF2, returns to 0x0CF3 // Incoming call from 0x37D2, returns to 0x37D3 // Incoming call from 0x2B91, returns to 0x2B92 // Incoming call from 0x13F2, returns to 0x13F3 // Incoming call from 0x24A8, returns to 0x24A9 // Incoming call from 0x08D8, returns to 0x08D9 // Incoming call from 0x2BEA, returns to 0x2BEB // Incoming call from 0x1C06, returns to 0x1C07 // Incoming call from 0x2399, returns to 0x239A // Incoming call from 0x23D5, returns to 0x23D6 // Incoming call from 0x3541, returns to 0x3542 // Incoming call from 0x2D9D, returns to 0x2D9E // Incoming call from 0x22F6, returns to 0x22F7 // Incoming call from 0x227B, returns to 0x227C // Incoming call from 0x230E, returns to 0x230F // Incoming call from 0x13B6, returns to 0x06A1 // Incoming call from 0x2E90, returns to 0x2E91 // Incoming call from 0x1D5A, returns to 0x1D5B // Incoming call from 0x37A5, returns to 0x37A6 // Incoming call from 0x2800, returns to 0x2801 // Inputs[2] // { // @3F62 stack[-2] // @3F64 stack[-1] // } 3F5F 5B JUMPDEST 3F60 60 PUSH1 0x00 3F62 82 DUP3 3F63 19 NOT 3F64 82 DUP3 3F65 11 GT 3F66 15 ISZERO 3F67 61 PUSH2 0x3f72 3F6A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3F60 stack[0] = 0x00 } // Block ends with conditional jump to 0x3f72, if !(stack[-1] > ~stack[-2]) label_3F6B: // Incoming jump from 0x3F6A, if not !(stack[-1] > ~stack[-2]) 3F6B 61 PUSH2 0x3f72 3F6E 61 PUSH2 0x3f49 3F71 56 *JUMP // Stack delta = +1 // Outputs[1] { @3F6B stack[0] = 0x3f72 } // Block ends with unconditional jump to 0x3f49 label_3F72: // Incoming jump from 0x3F6A, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @3F74 stack[-3] // @3F74 stack[-2] // @3F75 stack[-4] // } 3F72 5B JUMPDEST 3F73 50 POP 3F74 01 ADD 3F75 90 SWAP1 3F76 56 *JUMP // Stack delta = -3 // Outputs[1] { @3F75 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_3F77: // Incoming call from 0x1AFB, returns to 0x1AFC // Incoming call from 0x2724, returns to 0x2725 // Incoming call from 0x280A, returns to 0x280B // Incoming call from 0x16F0, returns to 0x16F1 // Incoming call from 0x31A3, returns to 0x31A4 // Incoming call from 0x1D9C, returns to 0x1D9D // Incoming call from 0x2B48, returns to 0x2B49 // Incoming call from 0x0933, returns to 0x0934 // Incoming call from 0x2BF4, returns to 0x2BF5 // Incoming call from 0x134D, returns to 0x134E // Incoming call from 0x2B0A, returns to 0x2B0B // Incoming call from 0x2762, returns to 0x2763 // Incoming call from 0x31E5, returns to 0x31E6 // Incoming call from 0x1390, returns to 0x1391 // Incoming call from 0x27E7, returns to 0x27E8 // Incoming call from 0x235A, returns to 0x235B // Incoming call from 0x2385, returns to 0x2386 // Incoming call from 0x23C1, returns to 0x23C2 // Incoming call from 0x1B1F, returns to 0x1B20 // Incoming call from 0x2BD1, returns to 0x2BD2 // Inputs[2] // { // @3F7A stack[-2] // @3F7B stack[-1] // } 3F77 5B JUMPDEST 3F78 60 PUSH1 0x00 3F7A 82 DUP3 3F7B 82 DUP3 3F7C 10 LT 3F7D 15 ISZERO 3F7E 61 PUSH2 0x3f89 3F81 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3F78 stack[0] = 0x00 } // Block ends with conditional jump to 0x3f89, if !(stack[-1] < stack[-2]) label_3F82: // Incoming jump from 0x3F81, if not !(stack[-1] < stack[-2]) 3F82 61 PUSH2 0x3f89 3F85 61 PUSH2 0x3f49 3F88 56 *JUMP // Stack delta = +1 // Outputs[1] { @3F82 stack[0] = 0x3f89 } // Block ends with unconditional jump to 0x3f49 label_3F89: // Incoming jump from 0x3F81, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @3F8B stack[-3] // @3F8B stack[-2] // @3F8C stack[-4] // } 3F89 5B JUMPDEST 3F8A 50 POP 3F8B 03 SUB 3F8C 90 SWAP1 3F8D 56 *JUMP // Stack delta = -3 // Outputs[1] { @3F8C stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_3F8E: // Incoming call from 0x0B46, returns to 0x0B47 // Inputs[2] // { // @3F93 stack[-1] // @3F94 stack[-2] // } 3F8E 5B JUMPDEST 3F8F 60 PUSH1 0x00 3F91 60 PUSH1 0x20 3F93 82 DUP3 3F94 84 DUP5 3F95 03 SUB 3F96 12 SLT 3F97 15 ISZERO 3F98 61 PUSH2 0x3fa0 3F9B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3F8F stack[0] = 0x00 } // Block ends with conditional jump to 0x3fa0, if !(stack[-2] - stack[-1] i< 0x20) label_3F9C: // Incoming jump from 0x3F9B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3F9F memory[0x00:0x00] } 3F9C 60 PUSH1 0x00 3F9E 80 DUP1 3F9F FD *REVERT // Stack delta = +0 // Outputs[1] { @3F9F revert(memory[0x00:0x00]); } // Block terminates label_3FA0: // Incoming jump from 0x3F9B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3FA2 memory[stack[-2]:stack[-2] + 0x20] // @3FA2 stack[-2] // @3FA3 stack[-4] // @3FA4 stack[-3] // } 3FA0 5B JUMPDEST 3FA1 50 POP 3FA2 51 MLOAD 3FA3 91 SWAP2 3FA4 90 SWAP1 3FA5 50 POP 3FA6 56 *JUMP // Stack delta = -3 // Outputs[1] { @3FA3 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_3FA7: // Incoming call from 0x13A8, returns to 0x13A9 // Incoming call from 0x1B73, returns to 0x1B74 // Incoming call from 0x1266, returns to 0x1267 // Incoming call from 0x3536, returns to 0x3537 // Incoming call from 0x0B50, returns to 0x0B51 // Incoming call from 0x27B5, returns to 0x27B6 // Incoming call from 0x1D42, returns to 0x1D43 // Incoming call from 0x2D89, returns to 0x2D8A // Incoming call from 0x129F, returns to 0x12A0 // Incoming call from 0x1708, returns to 0x1709 // Incoming call from 0x238F, returns to 0x2390 // Incoming call from 0x1B73, returns to 0x1B74 // Incoming call from 0x35F0, returns to 0x35F1 // Incoming call from 0x2364, returns to 0x2365 // Incoming call from 0x26C1, returns to 0x26C2 // Incoming call from 0x1C9A, returns to 0x1C9B // Incoming call from 0x2B9F, returns to 0x2BA0 // Incoming call from 0x23CB, returns to 0x23CC // Inputs[2] // { // @3FAA stack[-1] // @3FAF stack[-2] // } 3FA7 5B JUMPDEST 3FA8 60 PUSH1 0x00 3FAA 81 DUP2 3FAB 60 PUSH1 0x00 3FAD 19 NOT 3FAE 04 DIV 3FAF 83 DUP4 3FB0 11 GT 3FB1 82 DUP3 3FB2 15 ISZERO 3FB3 15 ISZERO 3FB4 16 AND 3FB5 15 ISZERO 3FB6 61 PUSH2 0x3fc1 3FB9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3FA8 stack[0] = 0x00 } // Block ends with conditional jump to 0x3fc1, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_3FBA: // Incoming jump from 0x3FB9, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 3FBA 61 PUSH2 0x3fc1 3FBD 61 PUSH2 0x3f49 3FC0 56 *JUMP // Stack delta = +1 // Outputs[1] { @3FBA stack[0] = 0x3fc1 } // Block ends with unconditional jump to 0x3f49 label_3FC1: // Incoming jump from 0x3FB9, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @3FC3 stack[-3] // @3FC3 stack[-2] // @3FC4 stack[-4] // } 3FC1 5B JUMPDEST 3FC2 50 POP 3FC3 02 MUL 3FC4 90 SWAP1 3FC5 56 *JUMP // Stack delta = -3 // Outputs[1] { @3FC4 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_3FC6: // Incoming call from 0x12A9, returns to 0x12AA // Incoming call from 0x27BF, returns to 0x27C0 // Incoming call from 0x1B7D, returns to 0x1B7E // Incoming call from 0x26CB, returns to 0x26CC // Incoming call from 0x1370, returns to 0x0C1F // Incoming call from 0x16FA, returns to 0x16FB // Incoming call from 0x0B5A, returns to 0x0B5B // Incoming call from 0x2BA9, returns to 0x2BAA // Incoming call from 0x1357, returns to 0x1358 // Incoming call from 0x2D93, returns to 0x2D94 // Incoming call from 0x1CA4, returns to 0x1CA5 // Incoming call from 0x1DBF, returns to 0x06A1 // Incoming call from 0x1DA6, returns to 0x1DA7 // Incoming call from 0x139A, returns to 0x139B // Incoming call from 0x1D4C, returns to 0x1D4D // Incoming call from 0x1270, returns to 0x1271 // Inputs[1] { @3FC9 stack[-2] } 3FC6 5B JUMPDEST 3FC7 60 PUSH1 0x00 3FC9 82 DUP3 3FCA 61 PUSH2 0x3fe3 3FCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3FC7 stack[0] = 0x00 } // Block ends with conditional jump to 0x3fe3, if stack[-2] label_3FCE: // Incoming jump from 0x3FCD, if not stack[-2] // Inputs[1] { @3FE2 memory[0x00:0x24] } 3FCE 63 PUSH4 0x4e487b71 3FD3 60 PUSH1 0xe0 3FD5 1B SHL 3FD6 60 PUSH1 0x00 3FD8 52 MSTORE 3FD9 60 PUSH1 0x12 3FDB 60 PUSH1 0x04 3FDD 52 MSTORE 3FDE 60 PUSH1 0x24 3FE0 60 PUSH1 0x00 3FE2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3FD8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3FDD memory[0x04:0x24] = 0x12 // @3FE2 revert(memory[0x00:0x24]); // } // Block terminates label_3FE3: // Incoming jump from 0x3FCD, if stack[-2] // Inputs[3] // { // @3FE5 stack[-3] // @3FE5 stack[-2] // @3FE6 stack[-4] // } 3FE3 5B JUMPDEST 3FE4 50 POP 3FE5 04 DIV 3FE6 90 SWAP1 3FE7 56 *JUMP // Stack delta = -3 // Outputs[1] { @3FE6 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_3FE8: // Incoming call from 0x1218, returns to 0x0817 // Incoming call from 0x0CC8, returns to 0x0817 // Incoming call from 0x10FB, returns to 0x0817 // Inputs[2] // { // @3FEC stack[-1] // @4035 stack[-2] // } 3FE8 5B JUMPDEST 3FE9 60 PUSH1 0x20 3FEB 80 DUP1 3FEC 82 DUP3 3FED 52 MSTORE 3FEE 60 PUSH1 0x2f 3FF0 90 SWAP1 3FF1 82 DUP3 3FF2 01 ADD 3FF3 52 MSTORE 3FF4 7F PUSH32 0x41646d696e20526f6c653a2063616c6c657220646f6573206e6f742068617665 4015 60 PUSH1 0x40 4017 82 DUP3 4018 01 ADD 4019 52 MSTORE 401A 6E PUSH15 0x207468652041646d696e20726f6c65 402A 60 PUSH1 0x88 402C 1B SHL 402D 60 PUSH1 0x60 402F 82 DUP3 4030 01 ADD 4031 52 MSTORE 4032 60 PUSH1 0x80 4034 01 ADD 4035 90 SWAP1 4036 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3FED memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3FF3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2f // @4019 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x41646d696e20526f6c653a2063616c6c657220646f6573206e6f742068617665 // @4031 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x207468652041646d696e20726f6c65 << 0x88 // @4035 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4037: // Incoming call from 0x0E78, returns to 0x0817 // Inputs[2] // { // @403B stack[-1] // @408F stack[-2] // } 4037 5B JUMPDEST 4038 60 PUSH1 0x20 403A 80 DUP1 403B 82 DUP3 403C 52 MSTORE 403D 60 PUSH1 0x3a 403F 90 SWAP1 4040 82 DUP3 4041 01 ADD 4042 52 MSTORE 4043 7F PUSH32 0x45524332304d696e7461626c653a204d696e74696e6720616c6c6f77616e6365 4064 60 PUSH1 0x40 4066 82 DUP3 4067 01 ADD 4068 52 MSTORE 4069 79 PUSH26 0x0206e65656420746f2062652067726561746572207468616e203 4084 60 PUSH1 0x34 4086 1B SHL 4087 60 PUSH1 0x60 4089 82 DUP3 408A 01 ADD 408B 52 MSTORE 408C 60 PUSH1 0x80 408E 01 ADD 408F 90 SWAP1 4090 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @403C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4042 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x3a // @4068 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45524332304d696e7461626c653a204d696e74696e6720616c6c6f77616e6365 // @408B memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x0206e65656420746f2062652067726561746572207468616e203 << 0x34 // @408F stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4091: // Incoming call from 0x0F16, returns to 0x0F17 // Inputs[3] // { // @4092 stack[-7] // @4093 stack[-1] // @409B stack[-6] // } 4091 5B JUMPDEST 4092 86 DUP7 4093 81 DUP2 4094 52 MSTORE 4095 60 PUSH1 0xc0 4097 81 DUP2 4098 01 ADD 4099 60 PUSH1 0x05 409B 87 DUP8 409C 10 LT 409D 61 PUSH2 0x40b6 40A0 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @4094 memory[stack[-1]:stack[-1] + 0x20] = stack[-7] // @4098 stack[0] = stack[-1] + 0xc0 // } // Block ends with conditional jump to 0x40b6, if stack[-6] < 0x05 label_40A1: // Incoming jump from 0x40A0, if not stack[-6] < 0x05 // Inputs[1] { @40B5 memory[0x00:0x24] } 40A1 63 PUSH4 0x4e487b71 40A6 60 PUSH1 0xe0 40A8 1B SHL 40A9 60 PUSH1 0x00 40AB 52 MSTORE 40AC 60 PUSH1 0x21 40AE 60 PUSH1 0x04 40B0 52 MSTORE 40B1 60 PUSH1 0x24 40B3 60 PUSH1 0x00 40B5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @40AB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @40B0 memory[0x04:0x24] = 0x21 // @40B5 revert(memory[0x00:0x24]); // } // Block terminates label_40B6: // Incoming jump from 0x40A0, if stack[-6] < 0x05 // Inputs[9] // { // @40B9 stack[-2] // @40BB stack[-7] // @40BC stack[-1] // @40C3 stack[-6] // @40CF stack[-5] // @40D0 stack[-3] // @40DC stack[-4] // @40E3 stack[-9] // @40E4 stack[-8] // } 40B6 5B JUMPDEST 40B7 60 PUSH1 0x20 40B9 82 DUP3 40BA 01 ADD 40BB 96 SWAP7 40BC 90 SWAP1 40BD 96 SWAP7 40BE 52 MSTORE 40BF 60 PUSH1 0x40 40C1 81 DUP2 40C2 01 ADD 40C3 94 SWAP5 40C4 90 SWAP1 40C5 94 SWAP5 40C6 52 MSTORE 40C7 60 PUSH1 0x01 40C9 60 PUSH1 0x01 40CB 60 PUSH1 0xa0 40CD 1B SHL 40CE 03 SUB 40CF 92 SWAP3 40D0 90 SWAP1 40D1 92 SWAP3 40D2 16 AND 40D3 60 PUSH1 0x60 40D5 84 DUP5 40D6 01 ADD 40D7 52 MSTORE 40D8 60 PUSH1 0x80 40DA 83 DUP4 40DB 01 ADD 40DC 52 MSTORE 40DD 60 PUSH1 0xa0 40DF 90 SWAP1 40E0 91 SWAP2 40E1 01 ADD 40E2 52 MSTORE 40E3 91 SWAP2 40E4 90 SWAP1 40E5 50 POP 40E6 56 *JUMP // Stack delta = -8 // Outputs[6] // { // @40BE memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-7] // @40C6 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-6] // @40D7 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @40DC memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-4] // @40E2 memory[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] = stack[-3] // @40E3 stack[-9] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_40E7: // Incoming call from 0x12E9, returns to 0x0817 // Incoming call from 0x1686, returns to 0x0817 // Inputs[2] // { // @40EB stack[-1] // @4111 stack[-2] // } 40E7 5B JUMPDEST 40E8 60 PUSH1 0x20 40EA 80 DUP1 40EB 82 DUP3 40EC 52 MSTORE 40ED 60 PUSH1 0x12 40EF 90 SWAP1 40F0 82 DUP3 40F1 01 ADD 40F2 52 MSTORE 40F3 71 PUSH18 0x696e646578206f7574206f662072616e6765 4106 60 PUSH1 0x70 4108 1B SHL 4109 60 PUSH1 0x40 410B 82 DUP3 410C 01 ADD 410D 52 MSTORE 410E 60 PUSH1 0x60 4110 01 ADD 4111 90 SWAP1 4112 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @40EC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @40F2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x12 // @410D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x696e646578206f7574206f662072616e6765 << 0x70 // @4111 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4113: // Incoming call from 0x133B, returns to 0x0817 // Incoming call from 0x1D8A, returns to 0x0817 // Inputs[2] // { // @4117 stack[-1] // @415C stack[-2] // } 4113 5B JUMPDEST 4114 60 PUSH1 0x20 4116 80 DUP1 4117 82 DUP3 4118 52 MSTORE 4119 60 PUSH1 0x2b 411B 90 SWAP1 411C 82 DUP3 411D 01 ADD 411E 52 MSTORE 411F 7F PUSH32 0x45524332305265776172643a206e6f20726577617264206265666f726520696e 4140 60 PUSH1 0x40 4142 82 DUP3 4143 01 ADD 4144 52 MSTORE 4145 6A PUSH11 0x697469616c20626c6f636b 4151 60 PUSH1 0xa8 4153 1B SHL 4154 60 PUSH1 0x60 4156 82 DUP3 4157 01 ADD 4158 52 MSTORE 4159 60 PUSH1 0x80 415B 01 ADD 415C 90 SWAP1 415D 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @4118 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @411E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @4144 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45524332305265776172643a206e6f20726577617264206265666f726520696e // @4158 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x697469616c20626c6f636b << 0xa8 // @415C stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_415E: // Incoming call from 0x4225, returns to 0x4226 // Inputs[2] // { // @4161 stack[-1] // @4165 stack[-2] // } 415E 5B JUMPDEST 415F 60 PUSH1 0x01 4161 81 DUP2 4162 81 DUP2 4163 5B JUMPDEST 4164 80 DUP1 4165 85 DUP6 4166 11 GT 4167 15 ISZERO 4168 61 PUSH2 0x4199 416B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @415F stack[0] = 0x01 // @4161 stack[1] = stack[-1] // @4162 stack[2] = 0x01 // } // Block ends with conditional jump to 0x4199, if !(stack[-2] > 0x01) label_416C: // Incoming jump from 0x416B, if not !(stack[-5] > stack[-1]) // Incoming jump from 0x416B, if not !(stack[-2] > 0x01) // Inputs[1] { @416C stack[-2] } 416C 81 DUP2 416D 60 PUSH1 0x00 416F 19 NOT 4170 04 DIV 4171 82 DUP3 4172 11 GT 4173 15 ISZERO 4174 61 PUSH2 0x417f 4177 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x417f, if !(stack[-2] > ~0x00 / stack[-2]) label_4178: // Incoming jump from 0x4177, if not !(stack[-2] > ~0x00 / stack[-2]) 4178 61 PUSH2 0x417f 417B 61 PUSH2 0x3f49 417E 56 *JUMP // Stack delta = +1 // Outputs[1] { @4178 stack[0] = 0x417f } // Block ends with unconditional jump to 0x3f49 label_417F: // Incoming jump from 0x4177, if !(stack[-2] > ~0x00 / stack[-2]) // Inputs[2] // { // @4180 stack[-1] // @4181 stack[-5] // } 417F 5B JUMPDEST 4180 80 DUP1 4181 85 DUP6 4182 16 AND 4183 15 ISZERO 4184 61 PUSH2 0x418c 4187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x418c, if !(stack[-5] & stack[-1]) label_4188: // Incoming jump from 0x4187, if not !(stack[-5] & stack[-1]) // Inputs[4] // { // @4188 stack[-1] // @4188 stack[-3] // @4189 stack[-2] // @418D stack[-5] // } 4188 91 SWAP2 4189 81 DUP2 418A 02 MUL 418B 91 SWAP2 418C 5B JUMPDEST 418D 93 SWAP4 418E 84 DUP5 418F 1C SHR 4190 93 SWAP4 4191 90 SWAP1 4192 80 DUP1 4193 02 MUL 4194 90 SWAP1 4195 61 PUSH2 0x4163 4198 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @418B stack[-3] = stack[-2] * stack[-3] // @4190 stack[-5] = stack[-5] >> stack[-1] // @4194 stack[-2] = stack[-2] * stack[-2] // @4194 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x4163 label_4199: // Incoming jump from 0x416B, if !(stack[-5] > stack[-1]) // Incoming jump from 0x416B, if !(stack[-2] > 0x01) // Inputs[5] // { // @419B stack[-2] // @419B stack[-5] // @419D stack[-3] // @419D stack[-6] // @419E stack[-4] // } 4199 5B JUMPDEST 419A 50 POP 419B 92 SWAP3 419C 50 POP 419D 92 SWAP3 419E 90 SWAP1 419F 50 POP 41A0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @419B stack[-5] = stack[-2] // @419D stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_41A1: // Incoming call from 0x424D, returns to 0x07D9 // Inputs[1] { @41A4 stack[-2] } 41A1 5B JUMPDEST 41A2 60 PUSH1 0x00 41A4 82 DUP3 41A5 61 PUSH2 0x41b0 41A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @41A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x41b0, if stack[-2] label_41A9: // Incoming jump from 0x41A8, if not stack[-2] 41A9 50 POP 41AA 60 PUSH1 0x01 41AC 61 PUSH2 0x06a1 41AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @41AA stack[-1] = 0x01 } // Block ends with unconditional jump to 0x06a1 label_41B0: // Incoming jump from 0x41A8, if stack[-2] // Inputs[1] { @41B1 stack[-2] } 41B0 5B JUMPDEST 41B1 81 DUP2 41B2 61 PUSH2 0x41bd 41B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x41bd, if stack[-2] label_41B6: // Incoming jump from 0x41B5, if not stack[-2] 41B6 50 POP 41B7 60 PUSH1 0x00 41B9 61 PUSH2 0x06a1 41BC 56 *JUMP // Stack delta = +0 // Outputs[1] { @41B7 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x06a1 label_41BD: // Incoming jump from 0x41B5, if stack[-2] // Inputs[1] { @41BE stack[-2] } 41BD 5B JUMPDEST 41BE 81 DUP2 41BF 60 PUSH1 0x01 41C1 81 DUP2 41C2 14 EQ 41C3 61 PUSH2 0x41d3 41C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @41BE stack[0] = stack[-2] } // Block ends with conditional jump to 0x41d3, if stack[-2] == 0x01 label_41C7: // Incoming jump from 0x41C6, if not stack[-2] == 0x01 // Inputs[1] { @41C9 stack[-1] } 41C7 60 PUSH1 0x02 41C9 81 DUP2 41CA 14 EQ 41CB 61 PUSH2 0x41dd 41CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x41dd, if stack[-1] == 0x02 label_41CF: // Incoming jump from 0x41CE, if not stack[-1] == 0x02 41CF 61 PUSH2 0x41f9 41D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x41f9 label_41D3: // Incoming jump from 0x41C6, if stack[-2] == 0x01 // Inputs[1] { @41D6 stack[-2] } 41D3 5B JUMPDEST 41D4 60 PUSH1 0x01 41D6 91 SWAP2 41D7 50 POP 41D8 50 POP 41D9 61 PUSH2 0x06a1 41DC 56 *JUMP // Stack delta = -1 // Outputs[1] { @41D6 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x06a1 label_41DD: // Incoming jump from 0x41CE, if stack[-1] == 0x02 // Inputs[1] { @41E0 stack[-4] } 41DD 5B JUMPDEST 41DE 60 PUSH1 0xff 41E0 84 DUP5 41E1 11 GT 41E2 15 ISZERO 41E3 61 PUSH2 0x41ee 41E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x41ee, if !(stack[-4] > 0xff) label_41E7: // Incoming jump from 0x41E6, if not !(stack[-4] > 0xff) 41E7 61 PUSH2 0x41ee 41EA 61 PUSH2 0x3f49 41ED 56 *JUMP // Stack delta = +1 // Outputs[1] { @41E7 stack[0] = 0x41ee } // Block ends with unconditional jump to 0x3f49 label_41EE: // Incoming jump from 0x41E6, if !(stack[-4] > 0xff) // Inputs[1] { @41F3 stack[-4] } 41EE 5B JUMPDEST 41EF 50 POP 41F0 50 POP 41F1 60 PUSH1 0x01 41F3 82 DUP3 41F4 1B SHL 41F5 61 PUSH2 0x06a1 41F8 56 *JUMP // Stack delta = -1 // Outputs[1] { @41F4 stack[-2] = 0x01 << stack[-4] } // Block ends with unconditional jump to 0x06a1 label_41F9: // Incoming jump from 0x41D2 // Inputs[2] // { // @41FD stack[-4] // @4202 stack[-3] // } 41F9 5B JUMPDEST 41FA 50 POP 41FB 60 PUSH1 0x20 41FD 83 DUP4 41FE 10 LT 41FF 61 PUSH2 0x0133 4202 83 DUP4 4203 10 LT 4204 16 AND 4205 60 PUSH1 0x4e 4207 84 DUP5 4208 10 LT 4209 60 PUSH1 0x0b 420B 84 DUP5 420C 10 LT 420D 16 AND 420E 17 OR 420F 15 ISZERO 4210 61 PUSH2 0x421c 4213 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x421c, if !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) label_4214: // Incoming jump from 0x4213, if not !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) // Inputs[2] // { // @4215 stack[-3] // @4216 stack[-2] // } 4214 50 POP 4215 81 DUP2 4216 81 DUP2 4217 0A EXP 4218 61 PUSH2 0x06a1 421B 56 *JUMP // Stack delta = +0 // Outputs[1] { @4217 stack[-1] = stack[-2] ** stack[-3] } // Block ends with unconditional jump to 0x06a1 label_421C: // Incoming jump from 0x4213, if !(((stack[-3] < 0x0b) & (stack[-4] < 0x4e)) | ((stack[-3] < 0x0133) & (stack[-4] < 0x20))) // Inputs[2] // { // @4220 stack[-3] // @4221 stack[-2] // } 421C 5B JUMPDEST 421D 61 PUSH2 0x4226 4220 83 DUP4 4221 83 DUP4 4222 61 PUSH2 0x415e 4225 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @421D stack[0] = 0x4226 // @4220 stack[1] = stack[-3] // @4221 stack[2] = stack[-2] // } // Block ends with call to 0x415e, returns to 0x4226 label_4226: // Incoming return from call to 0x415E at 0x4225 // Inputs[2] // { // @4227 stack[-1] // @422C stack[-2] // } 4226 5B JUMPDEST 4227 80 DUP1 4228 60 PUSH1 0x00 422A 19 NOT 422B 04 DIV 422C 82 DUP3 422D 11 GT 422E 15 ISZERO 422F 61 PUSH2 0x423a 4232 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x423a, if !(stack[-2] > ~0x00 / stack[-1]) label_4233: // Incoming jump from 0x4232, if not !(stack[-2] > ~0x00 / stack[-1]) 4233 61 PUSH2 0x423a 4236 61 PUSH2 0x3f49 4239 56 *JUMP // Stack delta = +1 // Outputs[1] { @4233 stack[0] = 0x423a } // Block ends with unconditional jump to 0x3f49 label_423A: // Incoming jump from 0x4232, if !(stack[-2] > ~0x00 / stack[-1]) // Inputs[4] // { // @423B stack[-2] // @423B stack[-1] // @423C stack[-6] // @423D stack[-5] // } 423A 5B JUMPDEST 423B 02 MUL 423C 93 SWAP4 423D 92 SWAP3 423E 50 POP 423F 50 POP 4240 50 POP 4241 56 *JUMP // Stack delta = -5 // Outputs[1] { @423C stack[-6] = stack[-1] * stack[-2] } // Block ends with unconditional jump to stack[-6] label_4242: // Incoming call from 0x1362, returns to 0x1363 // Incoming call from 0x1DB1, returns to 0x1DB2 // Inputs[2] // { // @4248 stack[-2] // @4249 stack[-1] // } 4242 5B JUMPDEST 4243 60 PUSH1 0x00 4245 61 PUSH2 0x07d9 4248 83 DUP4 4249 83 DUP4 424A 61 PUSH2 0x41a1 424D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4243 stack[0] = 0x00 // @4245 stack[1] = 0x07d9 // @4248 stack[2] = stack[-2] // @4249 stack[3] = stack[-1] // } // Block ends with call to 0x41a1, returns to 0x07D9 label_424E: // Incoming call from 0x19CE, returns to 0x19CF // Incoming call from 0x1A3D, returns to 0x1A3E // Incoming call from 0x18FB, returns to 0x18FC // Inputs[2] // { // @4259 stack[-2] // @425D stack[-1] // } 424E 5B JUMPDEST 424F 60 PUSH1 0x00 4251 60 PUSH1 0x01 4253 60 PUSH1 0x01 4255 60 PUSH1 0x60 4257 1B SHL 4258 03 SUB 4259 83 DUP4 425A 81 DUP2 425B 16 AND 425C 90 SWAP1 425D 83 DUP4 425E 16 AND 425F 81 DUP2 4260 81 DUP2 4261 10 LT 4262 15 ISZERO 4263 61 PUSH2 0x426e 4266 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @424F stack[0] = 0x00 // @425C stack[1] = (0x01 << 0x60) - 0x01 & stack[-2] // @425E stack[2] = stack[-1] & (0x01 << 0x60) - 0x01 // } // Block ends with conditional jump to 0x426e, if !(stack[-1] & (0x01 << 0x60) - 0x01 < (0x01 << 0x60) - 0x01 & stack[-2]) label_4267: // Incoming jump from 0x4266, if not !(stack[-1] & (0x01 << 0x60) - 0x01 < (0x01 << 0x60) - 0x01 & stack[-2]) 4267 61 PUSH2 0x426e 426A 61 PUSH2 0x3f49 426D 56 *JUMP // Stack delta = +1 // Outputs[1] { @4267 stack[0] = 0x426e } // Block ends with unconditional jump to 0x3f49 label_426E: // Incoming jump from 0x4266, if !(stack[-1] & (0x01 << 0x60) - 0x01 < (0x01 << 0x60) - 0x01 & stack[-2]) // Incoming jump from 0x4311, if !(stack[-1] & 0xffffffff < 0xffffffff & stack[-2]) // Inputs[4] // { // @426F stack[-1] // @426F stack[-2] // @4270 stack[-6] // @4271 stack[-5] // } 426E 5B JUMPDEST 426F 03 SUB 4270 93 SWAP4 4271 92 SWAP3 4272 50 POP 4273 50 POP 4274 50 POP 4275 56 *JUMP // Stack delta = -5 // Outputs[1] { @4270 stack[-6] = stack[-1] - stack[-2] } // Block ends with unconditional jump to stack[-6] label_4276: // Incoming call from 0x193B, returns to 0x193C // Incoming call from 0x25EC, returns to 0x25ED // Incoming call from 0x2F8C, returns to 0x2F8D // Inputs[1] { @427F stack[-1] } 4276 5B JUMPDEST 4277 60 PUSH1 0x00 4279 63 PUSH4 0xffffffff 427E 80 DUP1 427F 83 DUP4 4280 16 AND 4281 81 DUP2 4282 81 DUP2 4283 14 EQ 4284 15 ISZERO 4285 61 PUSH2 0x4290 4288 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @4277 stack[0] = 0x00 // @4279 stack[1] = 0xffffffff // @4280 stack[2] = stack[-1] & 0xffffffff // } // Block ends with conditional jump to 0x4290, if !(stack[-1] & 0xffffffff == 0xffffffff) label_4289: // Incoming jump from 0x4288, if not !(stack[-1] & 0xffffffff == 0xffffffff) 4289 61 PUSH2 0x4290 428C 61 PUSH2 0x3f49 428F 56 *JUMP // Stack delta = +1 // Outputs[1] { @4289 stack[0] = 0x4290 } // Block ends with unconditional jump to 0x3f49 label_4290: // Incoming jump from 0x4288, if !(stack[-1] & 0xffffffff == 0xffffffff) // Inputs[3] // { // @4293 stack[-1] // @4294 stack[-5] // @4295 stack[-4] // } 4290 5B JUMPDEST 4291 60 PUSH1 0x01 4293 01 ADD 4294 93 SWAP4 4295 92 SWAP3 4296 50 POP 4297 50 POP 4298 50 POP 4299 56 *JUMP // Stack delta = -4 // Outputs[1] { @4294 stack[-5] = 0x01 + stack[-1] } // Block ends with unconditional jump to stack[-5] label_429A: // Incoming call from 0x1AB2, returns to 0x1AB3 // Incoming call from 0x366C, returns to 0x366D // Inputs[1] { @429D stack[-1] } 429A 5B JUMPDEST 429B 60 PUSH1 0x00 429D 81 DUP2 429E 61 PUSH2 0x42a9 42A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @429B stack[0] = 0x00 } // Block ends with conditional jump to 0x42a9, if stack[-1] label_42A2: // Incoming jump from 0x42A1, if not stack[-1] 42A2 61 PUSH2 0x42a9 42A5 61 PUSH2 0x3f49 42A8 56 *JUMP // Stack delta = +1 // Outputs[1] { @42A2 stack[0] = 0x42a9 } // Block ends with unconditional jump to 0x3f49 label_42A9: // Incoming jump from 0x42A1, if stack[-1] // Inputs[2] // { // @42AE stack[-2] // @42AF stack[-3] // } 42A9 5B JUMPDEST 42AA 50 POP 42AB 60 PUSH1 0x00 42AD 19 NOT 42AE 01 ADD 42AF 90 SWAP1 42B0 56 *JUMP // Stack delta = -2 // Outputs[1] { @42AF stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_42B1: // Incoming call from 0x2A5E, returns to 0x0817 // Incoming call from 0x36E9, returns to 0x0817 // Incoming call from 0x309D, returns to 0x0817 // Incoming call from 0x2A35, returns to 0x0817 // Incoming call from 0x387C, returns to 0x0817 // Inputs[2] // { // @42B5 stack[-1] // @42FA stack[-2] // } 42B1 5B JUMPDEST 42B2 60 PUSH1 0x20 42B4 80 DUP1 42B5 82 DUP3 42B6 52 MSTORE 42B7 60 PUSH1 0x2b 42B9 90 SWAP1 42BA 82 DUP3 42BB 01 ADD 42BC 52 MSTORE 42BD 7F PUSH32 0x496e697469616c697a61626c653a20636f6e7472616374206973206e6f742069 42DE 60 PUSH1 0x40 42E0 82 DUP3 42E1 01 ADD 42E2 52 MSTORE 42E3 6A PUSH11 0x6e697469616c697a696e67 42EF 60 PUSH1 0xa8 42F1 1B SHL 42F2 60 PUSH1 0x60 42F4 82 DUP3 42F5 01 ADD 42F6 52 MSTORE 42F7 60 PUSH1 0x80 42F9 01 ADD 42FA 90 SWAP1 42FB 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @42B6 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @42BC memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @42E2 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e697469616c697a61626c653a20636f6e7472616374206973206e6f742069 // @42F6 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6e697469616c697a696e67 << 0xa8 // @42FA stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_42FC: // Incoming call from 0x2CD1, returns to 0x2CD2 // Inputs[2] // { // @4304 stack[-2] // @4308 stack[-1] // } 42FC 5B JUMPDEST 42FD 60 PUSH1 0x00 42FF 63 PUSH4 0xffffffff 4304 83 DUP4 4305 81 DUP2 4306 16 AND 4307 90 SWAP1 4308 83 DUP4 4309 16 AND 430A 81 DUP2 430B 81 DUP2 430C 10 LT 430D 15 ISZERO 430E 61 PUSH2 0x426e 4311 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @42FD stack[0] = 0x00 // @4307 stack[1] = 0xffffffff & stack[-2] // @4309 stack[2] = stack[-1] & 0xffffffff // } // Block ends with conditional jump to 0x426e, if !(stack[-1] & 0xffffffff < 0xffffffff & stack[-2]) label_4312: // Incoming jump from 0x4311, if not !(stack[-1] & 0xffffffff < 0xffffffff & stack[-2]) 4312 61 PUSH2 0x426e 4315 61 PUSH2 0x3f49 4318 56 *JUMP // Stack delta = +1 // Outputs[1] { @4312 stack[0] = 0x426e } // Block ends with unconditional jump to 0x3f49 label_4319: // Incoming call from 0x2CDC, returns to 0x2CDD // Inputs[2] // { // @4322 stack[-1] // @4325 stack[-2] // } 4319 5B JUMPDEST 431A 60 PUSH1 0x00 431C 63 PUSH4 0xffffffff 4321 80 DUP1 4322 83 DUP4 4323 16 AND 4324 81 DUP2 4325 85 DUP6 4326 16 AND 4327 80 DUP1 4328 83 DUP4 4329 03 SUB 432A 82 DUP3 432B 11 GT 432C 15 ISZERO 432D 61 PUSH2 0x4338 4330 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @431A stack[0] = 0x00 // @431C stack[1] = 0xffffffff // @4323 stack[2] = stack[-1] & 0xffffffff // @4326 stack[3] = stack[-2] & 0xffffffff // } // Block ends with conditional jump to 0x4338, if !(stack[-1] & 0xffffffff > 0xffffffff - (stack[-2] & 0xffffffff)) label_4331: // Incoming jump from 0x4330, if not !(stack[-1] & 0xffffffff > 0xffffffff - (stack[-2] & 0xffffffff)) 4331 61 PUSH2 0x4338 4334 61 PUSH2 0x3f49 4337 56 *JUMP // Stack delta = +1 // Outputs[1] { @4331 stack[0] = 0x4338 } // Block ends with unconditional jump to 0x3f49 label_4338: // Incoming jump from 0x4330, if !(stack[-1] & 0xffffffff > 0xffffffff - (stack[-2] & 0xffffffff)) // Inputs[4] // { // @4339 stack[-2] // @4339 stack[-1] // @433A stack[-7] // @433B stack[-6] // } 4338 5B JUMPDEST 4339 01 ADD 433A 94 SWAP5 433B 93 SWAP4 433C 50 POP 433D 50 POP 433E 50 POP 433F 50 POP 4340 56 *JUMP // Stack delta = -6 // Outputs[1] { @433A stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_4341: // Incoming call from 0x3030, returns to 0x3031 // Inputs[3] // { // @435D stack[-1] // @4361 stack[-3] // @4362 memory[stack[-3]:stack[-3] + 0x20] // } 4341 5B JUMPDEST 4342 76 PUSH23 0x020b1b1b2b9b9a1b7b73a3937b61d1030b1b1b7bab73a1 435A 60 PUSH1 0x4d 435C 1B SHL 435D 81 DUP2 435E 52 MSTORE 435F 60 PUSH1 0x00 4361 83 DUP4 4362 51 MLOAD 4363 61 PUSH2 0x4373 4366 81 DUP2 4367 60 PUSH1 0x17 4369 85 DUP6 436A 01 ADD 436B 60 PUSH1 0x20 436D 88 DUP9 436E 01 ADD 436F 61 PUSH2 0x399f 4372 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @435E memory[stack[-1]:stack[-1] + 0x20] = 0x020b1b1b2b9b9a1b7b73a3937b61d1030b1b1b7bab73a1 << 0x4d // @435F stack[0] = 0x00 // @4362 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @4363 stack[2] = 0x4373 // @4366 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @436A stack[4] = stack[-1] + 0x17 // @436E stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x399f, returns to 0x4373 label_4373: // Incoming return from call to 0x399F at 0x4372 // Inputs[4] // { // @438B stack[-1] // @438C stack[-3] // @4392 stack[-4] // @4393 memory[stack[-4]:stack[-4] + 0x20] // } 4373 5B JUMPDEST 4374 70 PUSH17 0x01034b99036b4b9b9b4b733903937b6329 4386 60 PUSH1 0x7d 4388 1B SHL 4389 60 PUSH1 0x17 438B 91 SWAP2 438C 84 DUP5 438D 01 ADD 438E 91 SWAP2 438F 82 DUP3 4390 01 ADD 4391 52 MSTORE 4392 83 DUP4 4393 51 MLOAD 4394 61 PUSH2 0x43a4 4397 81 DUP2 4398 60 PUSH1 0x28 439A 84 DUP5 439B 01 ADD 439C 60 PUSH1 0x20 439E 88 DUP9 439F 01 ADD 43A0 61 PUSH2 0x399f 43A3 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @438E stack[-1] = stack[-3] + stack[-1] // @4391 memory[stack[-3] + stack[-1] + 0x17:stack[-3] + stack[-1] + 0x17 + 0x20] = 0x01034b99036b4b9b9b4b733903937b6329 << 0x7d // @4393 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @4394 stack[1] = 0x43a4 // @4397 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @439B stack[3] = stack[-3] + stack[-1] + 0x28 // @439F stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x399f, returns to 0x43A4 label_43A4: // Incoming return from call to 0x399F at 0x43A3 // Inputs[4] // { // @43A5 stack[-1] // @43A5 stack[-2] // @43A9 stack[-7] // @43AA stack[-6] // } 43A4 5B JUMPDEST 43A5 01 ADD 43A6 60 PUSH1 0x28 43A8 01 ADD 43A9 94 SWAP5 43AA 93 SWAP4 43AB 50 POP 43AC 50 POP 43AD 50 POP 43AE 50 POP 43AF 56 *JUMP // Stack delta = -6 // Outputs[1] { @43A9 stack[-7] = 0x28 + stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_43B0: // Incoming jump from 0x3645 // Incoming jump from 0x359D // Incoming jump from 0x35CC // Incoming jump from 0x362F // Inputs[1] { @43C5 memory[0x00:0x24] } 43B0 5B JUMPDEST 43B1 63 PUSH4 0x4e487b71 43B6 60 PUSH1 0xe0 43B8 1B SHL 43B9 60 PUSH1 0x00 43BB 52 MSTORE 43BC 60 PUSH1 0x32 43BE 60 PUSH1 0x04 43C0 52 MSTORE 43C1 60 PUSH1 0x24 43C3 60 PUSH1 0x00 43C5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @43BB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @43C0 memory[0x04:0x24] = 0x32 // @43C5 revert(memory[0x00:0x24]); // } // Block terminates 43C6 FE *ASSERT 43C7 A2 LOG2 43C8 64 PUSH5 0x6970667358 43CE 22 22 43CF 12 SLT 43D0 20 SHA3 43D1 82 DUP3 43D2 8C DUP13 43D3 3B EXTCODESIZE 43D4 20 SHA3 43D5 15 ISZERO 43D6 34 CALLVALUE 43D7 3F EXTCODEHASH 43D8 28 28 43D9 21 21 43DA 75 PUSH22 0xa220103e8ee94bae38bc97dac74e0c7dfff44b03a2dc 43F1 64 PUSH5 0x736f6c6343 43F7 00 *STOP 43F8 08 ADDMOD 43F9 0C 0C 43FA 00 *STOP 43FB 33 CALLER