Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x01e3 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01e3, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0102 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0102, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd7bdd248 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xd7bdd248 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd7bdd248 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd7bdd248 003A 14 EQ 003B 61 PUSH2 0x0574 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0574, if 0xd7bdd248 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd7bdd248 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xd8496c3d 0045 14 EQ 0046 61 PUSH2 0x0594 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0594, if 0xd8496c3d == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xd8496c3d == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x05b4 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b4, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x05d4 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d4, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x0033, if 0xd7bdd248 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xa22cb465 006B 14 EQ 006C 61 PUSH2 0x0501 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0501, if 0xa22cb465 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x0521 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0521, if 0xb88d4fde == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc87b56dd 0081 14 EQ 0082 61 PUSH2 0x0534 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0534, if 0xc87b56dd == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xd547741f 008C 14 EQ 008D 61 PUSH2 0x0554 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0554, if 0xd547741f == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xd547741f == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0x8da5cb5b 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x8da5cb5b > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x8da5cb5b 00A7 14 EQ 00A8 61 PUSH2 0x0499 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0499, if 0x8da5cb5b == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x91d14854 00B2 14 EQ 00B3 61 PUSH2 0x04b7 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b7, if 0x91d14854 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x91d14854 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 14 EQ 00BE 61 PUSH2 0x04d7 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d7, if 0x95d89b41 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa217fddf 00C8 14 EQ 00C9 61 PUSH2 0x04ec 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if 0xa217fddf == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa217fddf == stack[-1] // Inputs[1] { @00D0 memory[0x00:0x00] } 00CD 60 PUSH1 0x00 00CF 80 DUP1 00D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D0 revert(memory[0x00:0x00]); } // Block terminates label_00D1: // Incoming jump from 0x00A0, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x70a08231 00D8 14 EQ 00D9 61 PUSH2 0x0424 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0424, if 0x70a08231 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x70a08231 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x715018a6 00E3 14 EQ 00E4 61 PUSH2 0x0444 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0444, if 0x715018a6 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x715018a6 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x7ec4a659 00EE 14 EQ 00EF 61 PUSH2 0x0459 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0459, if 0x7ec4a659 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x7ec4a659 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x8c7ea24b 00F9 14 EQ 00FA 61 PUSH2 0x0479 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0479, if 0x8c7ea24b == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x8c7ea24b == stack[-1] // Inputs[1] { @0101 memory[0x00:0x00] } 00FE 60 PUSH1 0x00 0100 80 DUP1 0101 FD *REVERT // Stack delta = +0 // Outputs[1] { @0101 revert(memory[0x00:0x00]); } // Block terminates label_0102: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0103 stack[-1] } 0102 5B JUMPDEST 0103 80 DUP1 0104 63 PUSH4 0x2a55205a 0109 11 GT 010A 61 PUSH2 0x017a 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017a, if 0x2a55205a > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x2a55205a > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x42842e0e 0114 11 GT 0115 61 PUSH2 0x0149 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0149, if 0x42842e0e > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x42842e0e > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x42842e0e 011F 14 EQ 0120 61 PUSH2 0x03b1 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if 0x42842e0e == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x42842e0e == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x4a8da402 012A 14 EQ 012B 61 PUSH2 0x03c4 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c4, if 0x4a8da402 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x4a8da402 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x6352211e 0135 14 EQ 0136 61 PUSH2 0x03e4 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e4, if 0x6352211e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x6352211e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x6c5deca6 0140 14 EQ 0141 61 PUSH2 0x0404 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0404, if 0x6c5deca6 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x6c5deca6 == stack[-1] // Inputs[1] { @0148 memory[0x00:0x00] } 0145 60 PUSH1 0x00 0147 80 DUP1 0148 FD *REVERT // Stack delta = +0 // Outputs[1] { @0148 revert(memory[0x00:0x00]); } // Block terminates label_0149: // Incoming jump from 0x0118, if 0x42842e0e > stack[-1] // Inputs[1] { @014A stack[-1] } 0149 5B JUMPDEST 014A 80 DUP1 014B 63 PUSH4 0x2a55205a 0150 14 EQ 0151 61 PUSH2 0x0312 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0312, if 0x2a55205a == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x2a55205a == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x2f2ff15d 015B 14 EQ 015C 61 PUSH2 0x0351 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0351, if 0x2f2ff15d == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x36568abe 0166 14 EQ 0167 61 PUSH2 0x0371 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0371, if 0x36568abe == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x36568abe == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x39ce84bb 0171 14 EQ 0172 61 PUSH2 0x0391 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0391, if 0x39ce84bb == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x39ce84bb == stack[-1] // Inputs[1] { @0179 memory[0x00:0x00] } 0176 60 PUSH1 0x00 0178 80 DUP1 0179 FD *REVERT // Stack delta = +0 // Outputs[1] { @0179 revert(memory[0x00:0x00]); } // Block terminates label_017A: // Incoming jump from 0x010D, if 0x2a55205a > stack[-1] // Inputs[1] { @017B stack[-1] } 017A 5B JUMPDEST 017B 80 DUP1 017C 63 PUSH4 0x16ba10e0 0181 11 GT 0182 61 PUSH2 0x01b6 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b6, if 0x16ba10e0 > stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x16ba10e0 > stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x16ba10e0 018C 14 EQ 018D 61 PUSH2 0x028c 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028c, if 0x16ba10e0 == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x16ba10e0 == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x18160ddd 0197 14 EQ 0198 61 PUSH2 0x02ac 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ac, if 0x18160ddd == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x18160ddd == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x23b872dd 01A2 14 EQ 01A3 61 PUSH2 0x02cf 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cf, if 0x23b872dd == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x23b872dd == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x248a9ca3 01AD 14 EQ 01AE 61 PUSH2 0x02e2 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e2, if 0x248a9ca3 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @01B5 memory[0x00:0x00] } 01B2 60 PUSH1 0x00 01B4 80 DUP1 01B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B5 revert(memory[0x00:0x00]); } // Block terminates label_01B6: // Incoming jump from 0x0185, if 0x16ba10e0 > stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B6 5B JUMPDEST 01B7 80 DUP1 01B8 63 PUSH4 0x01ffc9a7 01BD 14 EQ 01BE 61 PUSH2 0x01e8 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e8, if 0x01ffc9a7 == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C2 80 DUP1 01C3 63 PUSH4 0x06fdde03 01C8 14 EQ 01C9 61 PUSH2 0x021d 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021d, if 0x06fdde03 == stack[-1] label_01CD: // Incoming jump from 0x01CC, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01CD stack[-1] } 01CD 80 DUP1 01CE 63 PUSH4 0x081812fc 01D3 14 EQ 01D4 61 PUSH2 0x023f 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x081812fc == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x081812fc == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x095ea7b3 01DE 14 EQ 01DF 61 PUSH2 0x0277 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x095ea7b3 == stack[-1] label_01E3: // Incoming jump from 0x01E2, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @01E7 memory[0x00:0x00] } 01E3 5B JUMPDEST 01E4 60 PUSH1 0x00 01E6 80 DUP1 01E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E7 revert(memory[0x00:0x00]); } // Block terminates label_01E8: // Incoming jump from 0x01C1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E9 msg.value } 01E8 5B JUMPDEST 01E9 34 CALLVALUE 01EA 80 DUP1 01EB 15 ISZERO 01EC 61 PUSH2 0x01f4 01EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E9 stack[0] = msg.value } // Block ends with conditional jump to 0x01f4, if !msg.value label_01F0: // Incoming jump from 0x01EF, if not !msg.value // Inputs[1] { @01F3 memory[0x00:0x00] } 01F0 60 PUSH1 0x00 01F2 80 DUP1 01F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F3 revert(memory[0x00:0x00]); } // Block terminates label_01F4: // Incoming jump from 0x01EF, if !msg.value // Inputs[1] { @01FC msg.data.length } 01F4 5B JUMPDEST 01F5 50 POP 01F6 61 PUSH2 0x0208 01F9 61 PUSH2 0x0203 01FC 36 CALLDATASIZE 01FD 60 PUSH1 0x04 01FF 61 PUSH2 0x2351 0202 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01F6 stack[-1] = 0x0208 // @01F9 stack[0] = 0x0203 // @01FC stack[1] = msg.data.length // @01FD stack[2] = 0x04 // } // Block ends with call to 0x2351, returns to 0x0203 label_0203: // Incoming return from call to 0x2351 at 0x0202 0203 5B JUMPDEST 0204 61 PUSH2 0x05f4 0207 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05f4 label_0208: // Incoming return from call to 0x04D2 at 0x04D1 // Incoming return from call to 0x05AF at 0x05AE // Inputs[2] // { // @020B memory[0x40:0x60] // @020C stack[-1] // } 0208 5B JUMPDEST 0209 60 PUSH1 0x40 020B 51 MLOAD 020C 90 SWAP1 020D 15 ISZERO 020E 15 ISZERO 020F 81 DUP2 0210 52 MSTORE 0211 60 PUSH1 0x20 0213 01 ADD // Stack delta = +0 // Outputs[2] // { // @0210 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0213 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0214: // Incoming return from call to 0x23C6 at 0x023E // Incoming jump from 0x0213 // Incoming jump from 0x0276 // Incoming jump from 0x0350 // Incoming jump from 0x02CE // Inputs[3] // { // @0217 memory[0x40:0x60] // @0219 stack[-1] // @021C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0214 5B JUMPDEST 0215 60 PUSH1 0x40 0217 51 MLOAD 0218 80 DUP1 0219 91 SWAP2 021A 03 SUB 021B 90 SWAP1 021C F3 *RETURN // Stack delta = -1 // Outputs[1] { @021C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_021D: // Incoming jump from 0x01CC, if 0x06fdde03 == stack[-1] // Inputs[1] { @021E msg.value } 021D 5B JUMPDEST 021E 34 CALLVALUE 021F 80 DUP1 0220 15 ISZERO 0221 61 PUSH2 0x0229 0224 57 *JUMPI // Stack delta = +1 // Outputs[1] { @021E stack[0] = msg.value } // Block ends with conditional jump to 0x0229, if !msg.value label_0225: // Incoming jump from 0x0224, if not !msg.value // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming jump from 0x0224, if !msg.value 0229 5B JUMPDEST 022A 50 POP 022B 61 PUSH2 0x0232 022E 61 PUSH2 0x0605 0231 56 *JUMP // Stack delta = +0 // Outputs[1] { @022B stack[-1] = 0x0232 } // Block ends with call to 0x0605, returns to 0x0232 label_0232: // Incoming return from call to 0x0605 at 0x0231 // Incoming return from call to 0x0C0A at 0x04EB // Inputs[2] // { // @0235 memory[0x40:0x60] // @0239 stack[-1] // } 0232 5B JUMPDEST 0233 60 PUSH1 0x40 0235 51 MLOAD 0236 61 PUSH2 0x0214 0239 91 SWAP2 023A 90 SWAP1 023B 61 PUSH2 0x23c6 023E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0239 stack[-1] = 0x0214 // @023A stack[1] = memory[0x40:0x60] // @023A stack[0] = stack[-1] // } // Block ends with call to 0x23c6, returns to 0x0214 label_023F: // Incoming jump from 0x01D7, if 0x081812fc == stack[-1] // Inputs[1] { @0240 msg.value } 023F 5B JUMPDEST 0240 34 CALLVALUE 0241 80 DUP1 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0240 stack[0] = msg.value } // Block ends with conditional jump to 0x024b, if !msg.value label_0247: // Incoming jump from 0x0246, if not !msg.value // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0246, if !msg.value // Inputs[1] { @0253 msg.data.length } 024B 5B JUMPDEST 024C 50 POP 024D 61 PUSH2 0x025f 0250 61 PUSH2 0x025a 0253 36 CALLDATASIZE 0254 60 PUSH1 0x04 0256 61 PUSH2 0x23d9 0259 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @024D stack[-1] = 0x025f // @0250 stack[0] = 0x025a // @0253 stack[1] = msg.data.length // @0254 stack[2] = 0x04 // } // Block ends with call to 0x23d9, returns to 0x025A label_025A: // Incoming return from call to 0x23D9 at 0x0259 025A 5B JUMPDEST 025B 61 PUSH2 0x06a0 025E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06a0 label_025F: // Incoming return from call to 0x025A at 0x0259 // Incoming jump from 0x04B6 // Incoming return from call to 0x03FF at 0x03FE // Inputs[2] // { // @0262 memory[0x40:0x60] // @026C stack[-1] // } 025F 5B JUMPDEST 0260 60 PUSH1 0x40 0262 51 MLOAD 0263 60 PUSH1 0x01 0265 60 PUSH1 0x01 0267 60 PUSH1 0xa0 0269 1B SHL 026A 03 SUB 026B 90 SWAP1 026C 91 SWAP2 026D 16 AND 026E 81 DUP2 026F 52 MSTORE 0270 60 PUSH1 0x20 0272 01 ADD 0273 61 PUSH2 0x0214 0276 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @026F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0272 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_0277: // Incoming jump from 0x01E2, if 0x095ea7b3 == stack[-1] // Inputs[1] { @027E msg.data.length } 0277 5B JUMPDEST 0278 61 PUSH2 0x028a 027B 61 PUSH2 0x0285 027E 36 CALLDATASIZE 027F 60 PUSH1 0x04 0281 61 PUSH2 0x2409 0284 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0278 stack[0] = 0x028a // @027B stack[1] = 0x0285 // @027E stack[2] = msg.data.length // @027F stack[3] = 0x04 // } // Block ends with call to 0x2409, returns to 0x0285 label_0285: // Incoming return from call to 0x2409 at 0x0284 0285 5B JUMPDEST 0286 61 PUSH2 0x06ed 0289 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ed label_028A: // Incoming return from call to 0x058F at 0x058E // Incoming return from call to 0x05EF at 0x05EE // Incoming return from call to 0x038C at 0x038B // Incoming return from call to 0x051C at 0x051B 028A 5B JUMPDEST 028B 00 *STOP // Stack delta = +0 // Outputs[1] { @028B stop(); } // Block terminates label_028C: // Incoming jump from 0x0190, if 0x16ba10e0 == stack[-1] // Inputs[1] { @028D msg.value } 028C 5B JUMPDEST 028D 34 CALLVALUE 028E 80 DUP1 028F 15 ISZERO 0290 61 PUSH2 0x0298 0293 57 *JUMPI // Stack delta = +1 // Outputs[1] { @028D stack[0] = msg.value } // Block ends with conditional jump to 0x0298, if !msg.value label_0294: // Incoming jump from 0x0293, if not !msg.value // Inputs[1] { @0297 memory[0x00:0x00] } 0294 60 PUSH1 0x00 0296 80 DUP1 0297 FD *REVERT // Stack delta = +0 // Outputs[1] { @0297 revert(memory[0x00:0x00]); } // Block terminates label_0298: // Incoming jump from 0x0293, if !msg.value // Inputs[1] { @02A0 msg.data.length } 0298 5B JUMPDEST 0299 50 POP 029A 61 PUSH2 0x028a 029D 61 PUSH2 0x02a7 02A0 36 CALLDATASIZE 02A1 60 PUSH1 0x04 02A3 61 PUSH2 0x2518 02A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @029A stack[-1] = 0x028a // @029D stack[0] = 0x02a7 // @02A0 stack[1] = msg.data.length // @02A1 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2518 02A7 5B JUMPDEST 02A8 61 PUSH2 0x0706 02AB 56 *JUMP label_02AC: // Incoming jump from 0x019B, if 0x18160ddd == stack[-1] // Inputs[1] { @02AD msg.value } 02AC 5B JUMPDEST 02AD 34 CALLVALUE 02AE 80 DUP1 02AF 15 ISZERO 02B0 61 PUSH2 0x02b8 02B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02AD stack[0] = msg.value } // Block ends with conditional jump to 0x02b8, if !msg.value label_02B4: // Incoming jump from 0x02B3, if not !msg.value // Inputs[1] { @02B7 memory[0x00:0x00] } 02B4 60 PUSH1 0x00 02B6 80 DUP1 02B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B7 revert(memory[0x00:0x00]); } // Block terminates label_02B8: // Incoming jump from 0x02B3, if !msg.value 02B8 5B JUMPDEST 02B9 50 POP 02BA 61 PUSH2 0x02c1 02BD 61 PUSH2 0x071e 02C0 56 *JUMP // Stack delta = +0 // Outputs[1] { @02BA stack[-1] = 0x02c1 } // Block ends with call to 0x071e, returns to 0x02C1 label_02C1: // Incoming jump from 0x0500 // Incoming return from call to 0x02FD at 0x02FC // Incoming return from call to 0x071E at 0x02C0 // Incoming return from call to 0x043F at 0x043E // Inputs[2] // { // @02C4 memory[0x40:0x60] // @02C5 stack[-1] // } 02C1 5B JUMPDEST 02C2 60 PUSH1 0x40 02C4 51 MLOAD 02C5 90 SWAP1 02C6 81 DUP2 02C7 52 MSTORE 02C8 60 PUSH1 0x20 02CA 01 ADD 02CB 61 PUSH2 0x0214 02CE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02CA stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_02CF: // Incoming jump from 0x01A6, if 0x23b872dd == stack[-1] // Inputs[1] { @02D6 msg.data.length } 02CF 5B JUMPDEST 02D0 61 PUSH2 0x028a 02D3 61 PUSH2 0x02dd 02D6 36 CALLDATASIZE 02D7 60 PUSH1 0x04 02D9 61 PUSH2 0x254c 02DC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D0 stack[0] = 0x028a // @02D3 stack[1] = 0x02dd // @02D6 stack[2] = msg.data.length // @02D7 stack[3] = 0x04 // } // Block ends with call to 0x254c, returns to 0x02DD label_02DD: // Incoming return from call to 0x254C at 0x02DC 02DD 5B JUMPDEST 02DE 61 PUSH2 0x073e 02E1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x073e label_02E2: // Incoming jump from 0x01B1, if 0x248a9ca3 == stack[-1] // Inputs[1] { @02E3 msg.value } 02E2 5B JUMPDEST 02E3 34 CALLVALUE 02E4 80 DUP1 02E5 15 ISZERO 02E6 61 PUSH2 0x02ee 02E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ee, if !msg.value label_02EA: // Incoming jump from 0x02E9, if not !msg.value // Inputs[1] { @02ED memory[0x00:0x00] } 02EA 60 PUSH1 0x00 02EC 80 DUP1 02ED FD *REVERT // Stack delta = +0 // Outputs[1] { @02ED revert(memory[0x00:0x00]); } // Block terminates label_02EE: // Incoming jump from 0x02E9, if !msg.value // Inputs[1] { @02F6 msg.data.length } 02EE 5B JUMPDEST 02EF 50 POP 02F0 61 PUSH2 0x02c1 02F3 61 PUSH2 0x02fd 02F6 36 CALLDATASIZE 02F7 60 PUSH1 0x04 02F9 61 PUSH2 0x23d9 02FC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F0 stack[-1] = 0x02c1 // @02F3 stack[0] = 0x02fd // @02F6 stack[1] = msg.data.length // @02F7 stack[2] = 0x04 // } // Block ends with call to 0x23d9, returns to 0x02FD label_02FD: // Incoming return from call to 0x23D9 at 0x02FC // Inputs[4] // { // @0300 stack[-1] // @030B memory[0x00:0x40] // @030F storage[0x01 + keccak256(memory[0x00:0x40])] // @0310 stack[-2] // } 02FD 5B JUMPDEST 02FE 60 PUSH1 0x00 0300 90 SWAP1 0301 81 DUP2 0302 52 MSTORE 0303 60 PUSH1 0x97 0305 60 PUSH1 0x20 0307 52 MSTORE 0308 60 PUSH1 0x40 030A 90 SWAP1 030B 20 SHA3 030C 60 PUSH1 0x01 030E 01 ADD 030F 54 SLOAD 0310 90 SWAP1 0311 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0302 memory[0x00:0x20] = stack[-1] // @0307 memory[0x20:0x40] = 0x97 // @0310 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0312: // Incoming jump from 0x0154, if 0x2a55205a == stack[-1] // Inputs[1] { @0313 msg.value } 0312 5B JUMPDEST 0313 34 CALLVALUE 0314 80 DUP1 0315 15 ISZERO 0316 61 PUSH2 0x031e 0319 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0313 stack[0] = msg.value } // Block ends with conditional jump to 0x031e, if !msg.value label_031A: // Incoming jump from 0x0319, if not !msg.value // Inputs[1] { @031D memory[0x00:0x00] } 031A 60 PUSH1 0x00 031C 80 DUP1 031D FD *REVERT // Stack delta = +0 // Outputs[1] { @031D revert(memory[0x00:0x00]); } // Block terminates label_031E: // Incoming jump from 0x0319, if !msg.value // Inputs[1] { @0326 msg.data.length } 031E 5B JUMPDEST 031F 50 POP 0320 61 PUSH2 0x0332 0323 61 PUSH2 0x032d 0326 36 CALLDATASIZE 0327 60 PUSH1 0x04 0329 61 PUSH2 0x2588 032C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0320 stack[-1] = 0x0332 // @0323 stack[0] = 0x032d // @0326 stack[1] = msg.data.length // @0327 stack[2] = 0x04 // } // Block ends with call to 0x2588, returns to 0x032D label_032D: // Incoming return from call to 0x2588 at 0x032C 032D 5B JUMPDEST 032E 61 PUSH2 0x0769 0331 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0769 label_0332: // Incoming return from call to 0x032D at 0x032C // Inputs[3] // { // @0336 memory[0x40:0x60] // @0340 stack[-2] // @0348 stack[-1] // } 0332 5B JUMPDEST 0333 60 PUSH1 0x40 0335 80 DUP1 0336 51 MLOAD 0337 60 PUSH1 0x01 0339 60 PUSH1 0x01 033B 60 PUSH1 0xa0 033D 1B SHL 033E 03 SUB 033F 90 SWAP1 0340 93 SWAP4 0341 16 AND 0342 83 DUP4 0343 52 MSTORE 0344 60 PUSH1 0x20 0346 83 DUP4 0347 01 ADD 0348 91 SWAP2 0349 90 SWAP1 034A 91 SWAP2 034B 52 MSTORE 034C 01 ADD 034D 61 PUSH2 0x0214 0350 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @034B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @034C stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0214 label_0351: // Incoming jump from 0x015F, if 0x2f2ff15d == stack[-1] // Inputs[1] { @0352 msg.value } 0351 5B JUMPDEST 0352 34 CALLVALUE 0353 80 DUP1 0354 15 ISZERO 0355 61 PUSH2 0x035d 0358 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0352 stack[0] = msg.value } // Block ends with conditional jump to 0x035d, if !msg.value label_0359: // Incoming jump from 0x0358, if not !msg.value // Inputs[1] { @035C memory[0x00:0x00] } 0359 60 PUSH1 0x00 035B 80 DUP1 035C FD *REVERT // Stack delta = +0 // Outputs[1] { @035C revert(memory[0x00:0x00]); } // Block terminates label_035D: // Incoming jump from 0x0358, if !msg.value // Inputs[1] { @0365 msg.data.length } 035D 5B JUMPDEST 035E 50 POP 035F 61 PUSH2 0x028a 0362 61 PUSH2 0x036c 0365 36 CALLDATASIZE 0366 60 PUSH1 0x04 0368 61 PUSH2 0x25aa 036B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035F stack[-1] = 0x028a // @0362 stack[0] = 0x036c // @0365 stack[1] = msg.data.length // @0366 stack[2] = 0x04 // } // Block ends with call to 0x25aa, returns to 0x036C label_036C: // Incoming return from call to 0x25AA at 0x036B 036C 5B JUMPDEST 036D 61 PUSH2 0x07df 0370 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07df label_0371: // Incoming jump from 0x016A, if 0x36568abe == stack[-1] // Inputs[1] { @0372 msg.value } 0371 5B JUMPDEST 0372 34 CALLVALUE 0373 80 DUP1 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0372 stack[0] = msg.value } // Block ends with conditional jump to 0x037d, if !msg.value label_0379: // Incoming jump from 0x0378, if not !msg.value // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming jump from 0x0378, if !msg.value // Inputs[1] { @0385 msg.data.length } 037D 5B JUMPDEST 037E 50 POP 037F 61 PUSH2 0x028a 0382 61 PUSH2 0x038c 0385 36 CALLDATASIZE 0386 60 PUSH1 0x04 0388 61 PUSH2 0x25aa 038B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037F stack[-1] = 0x028a // @0382 stack[0] = 0x038c // @0385 stack[1] = msg.data.length // @0386 stack[2] = 0x04 // } // Block ends with call to 0x25aa, returns to 0x038C label_038C: // Incoming return from call to 0x25AA at 0x038B 038C 5B JUMPDEST 038D 61 PUSH2 0x0804 0390 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0804 label_0391: // Incoming jump from 0x0175, if 0x39ce84bb == stack[-1] // Inputs[1] { @0392 msg.value } 0391 5B JUMPDEST 0392 34 CALLVALUE 0393 80 DUP1 0394 15 ISZERO 0395 61 PUSH2 0x039d 0398 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0392 stack[0] = msg.value } // Block ends with conditional jump to 0x039d, if !msg.value label_0399: // Incoming jump from 0x0398, if not !msg.value // Inputs[1] { @039C memory[0x00:0x00] } 0399 60 PUSH1 0x00 039B 80 DUP1 039C FD *REVERT // Stack delta = +0 // Outputs[1] { @039C revert(memory[0x00:0x00]); } // Block terminates label_039D: // Incoming jump from 0x0398, if !msg.value // Inputs[1] { @03A5 msg.data.length } 039D 5B JUMPDEST 039E 50 POP 039F 61 PUSH2 0x028a 03A2 61 PUSH2 0x03ac 03A5 36 CALLDATASIZE 03A6 60 PUSH1 0x04 03A8 61 PUSH2 0x25d6 03AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039F stack[-1] = 0x028a // @03A2 stack[0] = 0x03ac // @03A5 stack[1] = msg.data.length // @03A6 stack[2] = 0x04 // } // Block ends with call to 0x25d6, returns to 0x03AC label_03AC: // Incoming return from call to 0x25D6 at 0x03AB 03AC 5B JUMPDEST 03AD 61 PUSH2 0x0883 03B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0883 label_03B1: // Incoming jump from 0x0123, if 0x42842e0e == stack[-1] // Inputs[1] { @03B8 msg.data.length } 03B1 5B JUMPDEST 03B2 61 PUSH2 0x028a 03B5 61 PUSH2 0x03bf 03B8 36 CALLDATASIZE 03B9 60 PUSH1 0x04 03BB 61 PUSH2 0x254c 03BE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B2 stack[0] = 0x028a // @03B5 stack[1] = 0x03bf // @03B8 stack[2] = msg.data.length // @03B9 stack[3] = 0x04 // } // Block ends with call to 0x254c, returns to 0x03BF label_03BF: // Incoming return from call to 0x254C at 0x03BE 03BF 5B JUMPDEST 03C0 61 PUSH2 0x09a0 03C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a0 label_03C4: // Incoming jump from 0x012E, if 0x4a8da402 == stack[-1] // Inputs[1] { @03C5 msg.value } 03C4 5B JUMPDEST 03C5 34 CALLVALUE 03C6 80 DUP1 03C7 15 ISZERO 03C8 61 PUSH2 0x03d0 03CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C5 stack[0] = msg.value } // Block ends with conditional jump to 0x03d0, if !msg.value label_03CC: // Incoming jump from 0x03CB, if not !msg.value // Inputs[1] { @03CF memory[0x00:0x00] } 03CC 60 PUSH1 0x00 03CE 80 DUP1 03CF FD *REVERT // Stack delta = +0 // Outputs[1] { @03CF revert(memory[0x00:0x00]); } // Block terminates label_03D0: // Incoming jump from 0x03CB, if !msg.value // Inputs[1] { @03D8 msg.data.length } 03D0 5B JUMPDEST 03D1 50 POP 03D2 61 PUSH2 0x028a 03D5 61 PUSH2 0x03df 03D8 36 CALLDATASIZE 03D9 60 PUSH1 0x04 03DB 61 PUSH2 0x2729 03DE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D2 stack[-1] = 0x028a // @03D5 stack[0] = 0x03df // @03D8 stack[1] = msg.data.length // @03D9 stack[2] = 0x04 // } // Block ends with call to 0x2729, returns to 0x03DF label_03DF: // Incoming return from call to 0x2729 at 0x03DE 03DF 5B JUMPDEST 03E0 61 PUSH2 0x09c5 03E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c5 label_03E4: // Incoming jump from 0x0139, if 0x6352211e == stack[-1] // Inputs[1] { @03E5 msg.value } 03E4 5B JUMPDEST 03E5 34 CALLVALUE 03E6 80 DUP1 03E7 15 ISZERO 03E8 61 PUSH2 0x03f0 03EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E5 stack[0] = msg.value } // Block ends with conditional jump to 0x03f0, if !msg.value label_03EC: // Incoming jump from 0x03EB, if not !msg.value // Inputs[1] { @03EF memory[0x00:0x00] } 03EC 60 PUSH1 0x00 03EE 80 DUP1 03EF FD *REVERT // Stack delta = +0 // Outputs[1] { @03EF revert(memory[0x00:0x00]); } // Block terminates label_03F0: // Incoming jump from 0x03EB, if !msg.value // Inputs[1] { @03F8 msg.data.length } 03F0 5B JUMPDEST 03F1 50 POP 03F2 61 PUSH2 0x025f 03F5 61 PUSH2 0x03ff 03F8 36 CALLDATASIZE 03F9 60 PUSH1 0x04 03FB 61 PUSH2 0x23d9 03FE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F2 stack[-1] = 0x025f // @03F5 stack[0] = 0x03ff // @03F8 stack[1] = msg.data.length // @03F9 stack[2] = 0x04 // } // Block ends with call to 0x23d9, returns to 0x03FF label_03FF: // Incoming return from call to 0x23D9 at 0x03FE 03FF 5B JUMPDEST 0400 61 PUSH2 0x09d9 0403 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09d9 label_0404: // Incoming jump from 0x0144, if 0x6c5deca6 == stack[-1] // Inputs[1] { @0405 msg.value } 0404 5B JUMPDEST 0405 34 CALLVALUE 0406 80 DUP1 0407 15 ISZERO 0408 61 PUSH2 0x0410 040B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0405 stack[0] = msg.value } // Block ends with conditional jump to 0x0410, if !msg.value label_040C: // Incoming jump from 0x040B, if not !msg.value // Inputs[1] { @040F memory[0x00:0x00] } 040C 60 PUSH1 0x00 040E 80 DUP1 040F FD *REVERT // Stack delta = +0 // Outputs[1] { @040F revert(memory[0x00:0x00]); } // Block terminates label_0410: // Incoming jump from 0x040B, if !msg.value // Inputs[1] { @0418 msg.data.length } 0410 5B JUMPDEST 0411 50 POP 0412 61 PUSH2 0x028a 0415 61 PUSH2 0x041f 0418 36 CALLDATASIZE 0419 60 PUSH1 0x04 041B 61 PUSH2 0x275d 041E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0412 stack[-1] = 0x028a // @0415 stack[0] = 0x041f // @0418 stack[1] = msg.data.length // @0419 stack[2] = 0x04 // } // Block ends with call to 0x275d, returns to 0x041F label_041F: // Incoming return from call to 0x275D at 0x041E 041F 5B JUMPDEST 0420 61 PUSH2 0x09e4 0423 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09e4 label_0424: // Incoming jump from 0x00DC, if 0x70a08231 == stack[-1] // Inputs[1] { @0425 msg.value } 0424 5B JUMPDEST 0425 34 CALLVALUE 0426 80 DUP1 0427 15 ISZERO 0428 61 PUSH2 0x0430 042B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0425 stack[0] = msg.value } // Block ends with conditional jump to 0x0430, if !msg.value label_042C: // Incoming jump from 0x042B, if not !msg.value // Inputs[1] { @042F memory[0x00:0x00] } 042C 60 PUSH1 0x00 042E 80 DUP1 042F FD *REVERT // Stack delta = +0 // Outputs[1] { @042F revert(memory[0x00:0x00]); } // Block terminates label_0430: // Incoming jump from 0x042B, if !msg.value // Inputs[1] { @0438 msg.data.length } 0430 5B JUMPDEST 0431 50 POP 0432 61 PUSH2 0x02c1 0435 61 PUSH2 0x043f 0438 36 CALLDATASIZE 0439 60 PUSH1 0x04 043B 61 PUSH2 0x27aa 043E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0432 stack[-1] = 0x02c1 // @0435 stack[0] = 0x043f // @0438 stack[1] = msg.data.length // @0439 stack[2] = 0x04 // } // Block ends with call to 0x27aa, returns to 0x043F label_043F: // Incoming return from call to 0x27AA at 0x043E 043F 5B JUMPDEST 0440 61 PUSH2 0x0b3a 0443 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b3a label_0444: // Incoming jump from 0x00E7, if 0x715018a6 == stack[-1] // Inputs[1] { @0445 msg.value } 0444 5B JUMPDEST 0445 34 CALLVALUE 0446 80 DUP1 0447 15 ISZERO 0448 61 PUSH2 0x0450 044B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0445 stack[0] = msg.value } // Block ends with conditional jump to 0x0450, if !msg.value label_044C: // Incoming jump from 0x044B, if not !msg.value // Inputs[1] { @044F memory[0x00:0x00] } 044C 60 PUSH1 0x00 044E 80 DUP1 044F FD *REVERT // Stack delta = +0 // Outputs[1] { @044F revert(memory[0x00:0x00]); } // Block terminates label_0450: // Incoming jump from 0x044B, if !msg.value 0450 5B JUMPDEST 0451 50 POP 0452 61 PUSH2 0x028a 0455 61 PUSH2 0x0ba2 0458 56 *JUMP // Stack delta = +0 // Outputs[1] { @0452 stack[-1] = 0x028a } // Block ends with unconditional jump to 0x0ba2 label_0459: // Incoming jump from 0x00F2, if 0x7ec4a659 == stack[-1] // Inputs[1] { @045A msg.value } 0459 5B JUMPDEST 045A 34 CALLVALUE 045B 80 DUP1 045C 15 ISZERO 045D 61 PUSH2 0x0465 0460 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045A stack[0] = msg.value } // Block ends with conditional jump to 0x0465, if !msg.value label_0461: // Incoming jump from 0x0460, if not !msg.value // Inputs[1] { @0464 memory[0x00:0x00] } 0461 60 PUSH1 0x00 0463 80 DUP1 0464 FD *REVERT // Stack delta = +0 // Outputs[1] { @0464 revert(memory[0x00:0x00]); } // Block terminates label_0465: // Incoming jump from 0x0460, if !msg.value // Inputs[1] { @046D msg.data.length } 0465 5B JUMPDEST 0466 50 POP 0467 61 PUSH2 0x028a 046A 61 PUSH2 0x0474 046D 36 CALLDATASIZE 046E 60 PUSH1 0x04 0470 61 PUSH2 0x2518 0473 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0467 stack[-1] = 0x028a // @046A stack[0] = 0x0474 // @046D stack[1] = msg.data.length // @046E stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2518 0474 5B JUMPDEST 0475 61 PUSH2 0x0bb6 0478 56 *JUMP label_0479: // Incoming jump from 0x00FD, if 0x8c7ea24b == stack[-1] // Inputs[1] { @047A msg.value } 0479 5B JUMPDEST 047A 34 CALLVALUE 047B 80 DUP1 047C 15 ISZERO 047D 61 PUSH2 0x0485 0480 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047A stack[0] = msg.value } // Block ends with conditional jump to 0x0485, if !msg.value label_0481: // Incoming jump from 0x0480, if not !msg.value // Inputs[1] { @0484 memory[0x00:0x00] } 0481 60 PUSH1 0x00 0483 80 DUP1 0484 FD *REVERT // Stack delta = +0 // Outputs[1] { @0484 revert(memory[0x00:0x00]); } // Block terminates label_0485: // Incoming jump from 0x0480, if !msg.value // Inputs[1] { @048D msg.data.length } 0485 5B JUMPDEST 0486 50 POP 0487 61 PUSH2 0x028a 048A 61 PUSH2 0x0494 048D 36 CALLDATASIZE 048E 60 PUSH1 0x04 0490 61 PUSH2 0x2409 0493 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0487 stack[-1] = 0x028a // @048A stack[0] = 0x0494 // @048D stack[1] = msg.data.length // @048E stack[2] = 0x04 // } // Block ends with call to 0x2409, returns to 0x0494 label_0494: // Incoming return from call to 0x2409 at 0x0493 0494 5B JUMPDEST 0495 61 PUSH2 0x0bca 0498 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bca label_0499: // Incoming jump from 0x00AB, if 0x8da5cb5b == stack[-1] // Inputs[1] { @049A msg.value } 0499 5B JUMPDEST 049A 34 CALLVALUE 049B 80 DUP1 049C 15 ISZERO 049D 61 PUSH2 0x04a5 04A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049A stack[0] = msg.value } // Block ends with conditional jump to 0x04a5, if !msg.value label_04A1: // Incoming jump from 0x04A0, if not !msg.value // Inputs[1] { @04A4 memory[0x00:0x00] } 04A1 60 PUSH1 0x00 04A3 80 DUP1 04A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A4 revert(memory[0x00:0x00]); } // Block terminates label_04A5: // Incoming jump from 0x04A0, if !msg.value // Inputs[1] { @04A9 storage[0x33] } 04A5 5B JUMPDEST 04A6 50 POP 04A7 60 PUSH1 0x33 04A9 54 SLOAD 04AA 60 PUSH1 0x01 04AC 60 PUSH1 0x01 04AE 60 PUSH1 0xa0 04B0 1B SHL 04B1 03 SUB 04B2 16 AND 04B3 61 PUSH2 0x025f 04B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @04B2 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x33] } // Block ends with unconditional jump to 0x025f label_04B7: // Incoming jump from 0x00B6, if 0x91d14854 == stack[-1] // Inputs[1] { @04B8 msg.value } 04B7 5B JUMPDEST 04B8 34 CALLVALUE 04B9 80 DUP1 04BA 15 ISZERO 04BB 61 PUSH2 0x04c3 04BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B8 stack[0] = msg.value } // Block ends with conditional jump to 0x04c3, if !msg.value label_04BF: // Incoming jump from 0x04BE, if not !msg.value // Inputs[1] { @04C2 memory[0x00:0x00] } 04BF 60 PUSH1 0x00 04C1 80 DUP1 04C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C2 revert(memory[0x00:0x00]); } // Block terminates label_04C3: // Incoming jump from 0x04BE, if !msg.value // Inputs[1] { @04CB msg.data.length } 04C3 5B JUMPDEST 04C4 50 POP 04C5 61 PUSH2 0x0208 04C8 61 PUSH2 0x04d2 04CB 36 CALLDATASIZE 04CC 60 PUSH1 0x04 04CE 61 PUSH2 0x25aa 04D1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04C5 stack[-1] = 0x0208 // @04C8 stack[0] = 0x04d2 // @04CB stack[1] = msg.data.length // @04CC stack[2] = 0x04 // } // Block ends with call to 0x25aa, returns to 0x04D2 label_04D2: // Incoming return from call to 0x25AA at 0x04D1 04D2 5B JUMPDEST 04D3 61 PUSH2 0x0bdf 04D6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bdf label_04D7: // Incoming jump from 0x00C1, if 0x95d89b41 == stack[-1] // Inputs[1] { @04D8 msg.value } 04D7 5B JUMPDEST 04D8 34 CALLVALUE 04D9 80 DUP1 04DA 15 ISZERO 04DB 61 PUSH2 0x04e3 04DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D8 stack[0] = msg.value } // Block ends with conditional jump to 0x04e3, if !msg.value label_04DF: // Incoming jump from 0x04DE, if not !msg.value // Inputs[1] { @04E2 memory[0x00:0x00] } 04DF 60 PUSH1 0x00 04E1 80 DUP1 04E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E2 revert(memory[0x00:0x00]); } // Block terminates label_04E3: // Incoming jump from 0x04DE, if !msg.value 04E3 5B JUMPDEST 04E4 50 POP 04E5 61 PUSH2 0x0232 04E8 61 PUSH2 0x0c0a 04EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @04E5 stack[-1] = 0x0232 } // Block ends with call to 0x0c0a, returns to 0x0232 label_04EC: // Incoming jump from 0x00CC, if 0xa217fddf == stack[-1] // Inputs[1] { @04ED msg.value } 04EC 5B JUMPDEST 04ED 34 CALLVALUE 04EE 80 DUP1 04EF 15 ISZERO 04F0 61 PUSH2 0x04f8 04F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04ED stack[0] = msg.value } // Block ends with conditional jump to 0x04f8, if !msg.value label_04F4: // Incoming jump from 0x04F3, if not !msg.value // Inputs[1] { @04F7 memory[0x00:0x00] } 04F4 60 PUSH1 0x00 04F6 80 DUP1 04F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F7 revert(memory[0x00:0x00]); } // Block terminates label_04F8: // Incoming jump from 0x04F3, if !msg.value 04F8 5B JUMPDEST 04F9 50 POP 04FA 61 PUSH2 0x02c1 04FD 60 PUSH1 0x00 04FF 81 DUP2 0500 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04FA stack[-1] = 0x02c1 // @04FD stack[0] = 0x00 // } // Block ends with unconditional jump to 0x02c1 label_0501: // Incoming jump from 0x006F, if 0xa22cb465 == stack[-1] // Inputs[1] { @0502 msg.value } 0501 5B JUMPDEST 0502 34 CALLVALUE 0503 80 DUP1 0504 15 ISZERO 0505 61 PUSH2 0x050d 0508 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0502 stack[0] = msg.value } // Block ends with conditional jump to 0x050d, if !msg.value label_0509: // Incoming jump from 0x0508, if not !msg.value // Inputs[1] { @050C memory[0x00:0x00] } 0509 60 PUSH1 0x00 050B 80 DUP1 050C FD *REVERT // Stack delta = +0 // Outputs[1] { @050C revert(memory[0x00:0x00]); } // Block terminates label_050D: // Incoming jump from 0x0508, if !msg.value // Inputs[1] { @0515 msg.data.length } 050D 5B JUMPDEST 050E 50 POP 050F 61 PUSH2 0x028a 0512 61 PUSH2 0x051c 0515 36 CALLDATASIZE 0516 60 PUSH1 0x04 0518 61 PUSH2 0x27d3 051B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @050F stack[-1] = 0x028a // @0512 stack[0] = 0x051c // @0515 stack[1] = msg.data.length // @0516 stack[2] = 0x04 // } // Block ends with call to 0x27d3, returns to 0x051C label_051C: // Incoming return from call to 0x27D3 at 0x051B 051C 5B JUMPDEST 051D 61 PUSH2 0x0c22 0520 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c22 label_0521: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @0528 msg.data.length } 0521 5B JUMPDEST 0522 61 PUSH2 0x028a 0525 61 PUSH2 0x052f 0528 36 CALLDATASIZE 0529 60 PUSH1 0x04 052B 61 PUSH2 0x280a 052E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0522 stack[0] = 0x028a // @0525 stack[1] = 0x052f // @0528 stack[2] = msg.data.length // @0529 stack[3] = 0x04 // } // Block ends with call to 0x280a, returns to 0x052F label_052F: // Incoming return from call to 0x280A at 0x052E 052F 5B JUMPDEST 0530 61 PUSH2 0x0c36 0533 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c36 label_0534: // Incoming jump from 0x0085, if 0xc87b56dd == stack[-1] // Inputs[1] { @0535 msg.value } 0534 5B JUMPDEST 0535 34 CALLVALUE 0536 80 DUP1 0537 15 ISZERO 0538 61 PUSH2 0x0540 053B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0535 stack[0] = msg.value } // Block ends with conditional jump to 0x0540, if !msg.value label_053C: // Incoming jump from 0x053B, if not !msg.value // Inputs[1] { @053F memory[0x00:0x00] } 053C 60 PUSH1 0x00 053E 80 DUP1 053F FD *REVERT // Stack delta = +0 // Outputs[1] { @053F revert(memory[0x00:0x00]); } // Block terminates label_0540: // Incoming jump from 0x053B, if !msg.value // Inputs[1] { @0548 msg.data.length } 0540 5B JUMPDEST 0541 50 POP 0542 61 PUSH2 0x0232 0545 61 PUSH2 0x054f 0548 36 CALLDATASIZE 0549 60 PUSH1 0x04 054B 61 PUSH2 0x23d9 054E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0542 stack[-1] = 0x0232 // @0545 stack[0] = 0x054f // @0548 stack[1] = msg.data.length // @0549 stack[2] = 0x04 // } // Block ends with call to 0x23d9, returns to 0x054F label_054F: // Incoming return from call to 0x23D9 at 0x054E 054F 5B JUMPDEST 0550 61 PUSH2 0x0c63 0553 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c63 label_0554: // Incoming jump from 0x0090, if 0xd547741f == stack[-1] // Inputs[1] { @0555 msg.value } 0554 5B JUMPDEST 0555 34 CALLVALUE 0556 80 DUP1 0557 15 ISZERO 0558 61 PUSH2 0x0560 055B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0555 stack[0] = msg.value } // Block ends with conditional jump to 0x0560, if !msg.value label_055C: // Incoming jump from 0x055B, if not !msg.value // Inputs[1] { @055F memory[0x00:0x00] } 055C 60 PUSH1 0x00 055E 80 DUP1 055F FD *REVERT // Stack delta = +0 // Outputs[1] { @055F revert(memory[0x00:0x00]); } // Block terminates label_0560: // Incoming jump from 0x055B, if !msg.value // Inputs[1] { @0568 msg.data.length } 0560 5B JUMPDEST 0561 50 POP 0562 61 PUSH2 0x028a 0565 61 PUSH2 0x056f 0568 36 CALLDATASIZE 0569 60 PUSH1 0x04 056B 61 PUSH2 0x25aa 056E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0562 stack[-1] = 0x028a // @0565 stack[0] = 0x056f // @0568 stack[1] = msg.data.length // @0569 stack[2] = 0x04 // } // Block ends with call to 0x25aa, returns to 0x056F label_056F: // Incoming return from call to 0x25AA at 0x056E 056F 5B JUMPDEST 0570 61 PUSH2 0x0c94 0573 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c94 label_0574: // Incoming jump from 0x003E, if 0xd7bdd248 == stack[-1] // Inputs[1] { @0575 msg.value } 0574 5B JUMPDEST 0575 34 CALLVALUE 0576 80 DUP1 0577 15 ISZERO 0578 61 PUSH2 0x0580 057B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0575 stack[0] = msg.value } // Block ends with conditional jump to 0x0580, if !msg.value label_057C: // Incoming jump from 0x057B, if not !msg.value // Inputs[1] { @057F memory[0x00:0x00] } 057C 60 PUSH1 0x00 057E 80 DUP1 057F FD *REVERT // Stack delta = +0 // Outputs[1] { @057F revert(memory[0x00:0x00]); } // Block terminates label_0580: // Incoming jump from 0x057B, if !msg.value // Inputs[1] { @0588 msg.data.length } 0580 5B JUMPDEST 0581 50 POP 0582 61 PUSH2 0x028a 0585 61 PUSH2 0x058f 0588 36 CALLDATASIZE 0589 60 PUSH1 0x04 058B 61 PUSH2 0x2885 058E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0582 stack[-1] = 0x028a // @0585 stack[0] = 0x058f // @0588 stack[1] = msg.data.length // @0589 stack[2] = 0x04 // } // Block ends with call to 0x2885, returns to 0x058F label_058F: // Incoming return from call to 0x2885 at 0x058E 058F 5B JUMPDEST 0590 61 PUSH2 0x0cb9 0593 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cb9 label_0594: // Incoming jump from 0x0049, if 0xd8496c3d == stack[-1] // Inputs[1] { @0595 msg.value } 0594 5B JUMPDEST 0595 34 CALLVALUE 0596 80 DUP1 0597 15 ISZERO 0598 61 PUSH2 0x05a0 059B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0595 stack[0] = msg.value } // Block ends with conditional jump to 0x05a0, if !msg.value label_059C: // Incoming jump from 0x059B, if not !msg.value // Inputs[1] { @059F memory[0x00:0x00] } 059C 60 PUSH1 0x00 059E 80 DUP1 059F FD *REVERT // Stack delta = +0 // Outputs[1] { @059F revert(memory[0x00:0x00]); } // Block terminates label_05A0: // Incoming jump from 0x059B, if !msg.value // Inputs[1] { @05A8 msg.data.length } 05A0 5B JUMPDEST 05A1 50 POP 05A2 61 PUSH2 0x0208 05A5 61 PUSH2 0x05af 05A8 36 CALLDATASIZE 05A9 60 PUSH1 0x04 05AB 61 PUSH2 0x27aa 05AE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A2 stack[-1] = 0x0208 // @05A5 stack[0] = 0x05af // @05A8 stack[1] = msg.data.length // @05A9 stack[2] = 0x04 // } // Block ends with call to 0x27aa, returns to 0x05AF label_05AF: // Incoming return from call to 0x27AA at 0x05AE 05AF 5B JUMPDEST 05B0 61 PUSH2 0x0cca 05B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cca label_05B4: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05B5 msg.value } 05B4 5B JUMPDEST 05B5 34 CALLVALUE 05B6 80 DUP1 05B7 15 ISZERO 05B8 61 PUSH2 0x05c0 05BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B5 stack[0] = msg.value } // Block ends with conditional jump to 0x05c0, if !msg.value label_05BC: // Incoming jump from 0x05BB, if not !msg.value // Inputs[1] { @05BF memory[0x00:0x00] } 05BC 60 PUSH1 0x00 05BE 80 DUP1 05BF FD *REVERT // Stack delta = +0 // Outputs[1] { @05BF revert(memory[0x00:0x00]); } // Block terminates label_05C0: // Incoming jump from 0x05BB, if !msg.value // Inputs[1] { @05C8 msg.data.length } 05C0 5B JUMPDEST 05C1 50 POP 05C2 61 PUSH2 0x0208 05C5 61 PUSH2 0x05cf 05C8 36 CALLDATASIZE 05C9 60 PUSH1 0x04 05CB 61 PUSH2 0x2941 05CE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C2 stack[-1] = 0x0208 // @05C5 stack[0] = 0x05cf // @05C8 stack[1] = msg.data.length // @05C9 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2941 05CF 5B JUMPDEST 05D0 61 PUSH2 0x0cf8 05D3 56 *JUMP label_05D4: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @05D5 msg.value } 05D4 5B JUMPDEST 05D5 34 CALLVALUE 05D6 80 DUP1 05D7 15 ISZERO 05D8 61 PUSH2 0x05e0 05DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D5 stack[0] = msg.value } // Block ends with conditional jump to 0x05e0, if !msg.value label_05DC: // Incoming jump from 0x05DB, if not !msg.value // Inputs[1] { @05DF memory[0x00:0x00] } 05DC 60 PUSH1 0x00 05DE 80 DUP1 05DF FD *REVERT // Stack delta = +0 // Outputs[1] { @05DF revert(memory[0x00:0x00]); } // Block terminates label_05E0: // Incoming jump from 0x05DB, if !msg.value // Inputs[1] { @05E8 msg.data.length } 05E0 5B JUMPDEST 05E1 50 POP 05E2 61 PUSH2 0x028a 05E5 61 PUSH2 0x05ef 05E8 36 CALLDATASIZE 05E9 60 PUSH1 0x04 05EB 61 PUSH2 0x27aa 05EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E2 stack[-1] = 0x028a // @05E5 stack[0] = 0x05ef // @05E8 stack[1] = msg.data.length // @05E9 stack[2] = 0x04 // } // Block ends with call to 0x27aa, returns to 0x05EF label_05EF: // Incoming return from call to 0x27AA at 0x05EE 05EF 5B JUMPDEST 05F0 61 PUSH2 0x0d35 05F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d35 label_05F4: // Incoming jump from 0x0207 // Inputs[1] { @05FA stack[-1] } 05F4 5B JUMPDEST 05F5 60 PUSH1 0x00 05F7 61 PUSH2 0x05ff 05FA 82 DUP3 05FB 61 PUSH2 0x0dab 05FE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05F5 stack[0] = 0x00 // @05F7 stack[1] = 0x05ff // @05FA stack[2] = stack[-1] // } // Block ends with call to 0x0dab, returns to 0x05FF label_05FF: // Incoming jump from 0x18FE, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x2299, if stack[-3] / 0x64 < 0x0a // Incoming jump from 0x1931, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x2299, if stack[-3] < 0x0a // Incoming return from call to 0x14E0 at 0x09E3 // Incoming jump from 0x1967, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1980 // Incoming return from call to 0x194C at 0x0DD3 // Incoming jump from 0x0DCA, if stack[-1] // Incoming return from call to 0x15BD at 0x15BC // Incoming jump from 0x0E18, if !stack[-1] // Incoming jump from 0x18FE, if stack[-1] // Incoming return from call to 0x0DAB at 0x05FE // Incoming return from call to 0x1DE5 at 0x1DE4 // Inputs[3] // { // @0600 stack[-1] // @0600 stack[-4] // @0601 stack[-3] // } 05FF 5B JUMPDEST 0600 92 SWAP3 0601 91 SWAP2 0602 50 POP 0603 50 POP 0604 56 *JUMP // Stack delta = -3 // Outputs[1] { @0600 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0605: // Incoming call from 0x0231, returns to 0x0232 0605 5B JUMPDEST 0606 60 PUSH1 0x60 0608 61 PUSH2 0x060f 060B 61 PUSH2 0x0dd4 060E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0606 stack[0] = 0x60 // @0608 stack[1] = 0x060f // } // Block ends with call to 0x0dd4, returns to 0x060F label_060F: // Incoming return from call to 0x0DD4 at 0x060E // Inputs[2] // { // @0612 stack[-1] // @0614 storage[0x02 + stack[-1]] // } 060F 5B JUMPDEST 0610 60 PUSH1 0x02 0612 01 ADD 0613 80 DUP1 0614 54 SLOAD 0615 61 PUSH2 0x061d 0618 90 SWAP1 0619 61 PUSH2 0x296b 061C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0612 stack[-1] = 0x02 + stack[-1] // @0618 stack[1] = storage[0x02 + stack[-1]] // @0618 stack[0] = 0x061d // } // Block ends with call to 0x296b, returns to 0x061D label_061D: // Incoming return from call to 0x296B at 0x0C21 // Incoming return from call to 0x296B at 0x061C // Inputs[4] // { // @061E stack[-1] // @062D memory[0x40:0x60] // @0635 stack[-2] // @0640 storage[stack[-2]] // } 061D 5B JUMPDEST 061E 80 DUP1 061F 60 PUSH1 0x1f 0621 01 ADD 0622 60 PUSH1 0x20 0624 80 DUP1 0625 91 SWAP2 0626 04 DIV 0627 02 MUL 0628 60 PUSH1 0x20 062A 01 ADD 062B 60 PUSH1 0x40 062D 51 MLOAD 062E 90 SWAP1 062F 81 DUP2 0630 01 ADD 0631 60 PUSH1 0x40 0633 52 MSTORE 0634 80 DUP1 0635 92 SWAP3 0636 91 SWAP2 0637 90 SWAP1 0638 81 DUP2 0639 81 DUP2 063A 52 MSTORE 063B 60 PUSH1 0x20 063D 01 ADD 063E 82 DUP3 063F 80 DUP1 0640 54 SLOAD 0641 61 PUSH2 0x0649 0644 90 SWAP1 0645 61 PUSH2 0x296b 0648 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0633 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0635 stack[-2] = memory[0x40:0x60] // @0636 stack[-1] = stack[-2] // @0637 stack[0] = stack[-1] // @063A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @063D stack[1] = 0x20 + memory[0x40:0x60] // @063E stack[2] = stack[-2] // @0644 stack[4] = storage[stack[-2]] // @0644 stack[3] = 0x0649 // } // Block ends with call to 0x296b, returns to 0x0649 label_0649: // Incoming return from call to 0x296B at 0x0648 // Inputs[1] { @064A stack[-1] } 0649 5B JUMPDEST 064A 80 DUP1 064B 15 ISZERO 064C 61 PUSH2 0x0696 064F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0696, if !stack[-1] label_0650: // Incoming jump from 0x064F, if not !stack[-1] // Inputs[1] { @0650 stack[-1] } 0650 80 DUP1 0651 60 PUSH1 0x1f 0653 10 LT 0654 61 PUSH2 0x066b 0657 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066b, if 0x1f < stack[-1] label_0658: // Incoming jump from 0x0657, if not 0x1f < stack[-1] // Inputs[4] // { // @065C stack[-2] // @065D storage[stack[-2]] // @0660 stack[-3] // @0662 stack[-1] // } 0658 61 PUSH2 0x0100 065B 80 DUP1 065C 83 DUP4 065D 54 SLOAD 065E 04 DIV 065F 02 MUL 0660 83 DUP4 0661 52 MSTORE 0662 91 SWAP2 0663 60 PUSH1 0x20 0665 01 ADD 0666 91 SWAP2 0667 61 PUSH2 0x0696 066A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0661 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0666 stack[-1] = stack[-1] // @0666 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0696 label_066B: // Incoming jump from 0x0657, if 0x1f < stack[-1] // Inputs[5] // { // @066C stack[-3] // @066D stack[-1] // @066F stack[-2] // @0677 memory[0x00:0x20] // @067B storage[keccak256(memory[0x00:0x20])] // } 066B 5B JUMPDEST 066C 82 DUP3 066D 01 ADD 066E 91 SWAP2 066F 90 SWAP1 0670 60 PUSH1 0x00 0672 52 MSTORE 0673 60 PUSH1 0x20 0675 60 PUSH1 0x00 0677 20 SHA3 0678 90 SWAP1 0679 5B JUMPDEST 067A 81 DUP2 067B 54 SLOAD 067C 81 DUP2 067D 52 MSTORE 067E 90 SWAP1 067F 60 PUSH1 0x01 0681 01 ADD 0682 90 SWAP1 0683 60 PUSH1 0x20 0685 01 ADD 0686 80 DUP1 0687 83 DUP4 0688 11 GT 0689 61 PUSH2 0x0679 068C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @066E stack[-3] = stack[-3] + stack[-1] // @0672 memory[0x00:0x20] = stack[-2] // @067D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0682 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0685 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0679, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_068D: // Incoming jump from 0x068C, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x068C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @068D stack[-3] // @068E stack[-1] // } 068D 82 DUP3 068E 90 SWAP1 068F 03 SUB 0690 60 PUSH1 0x1f 0692 16 AND 0693 82 DUP3 0694 01 ADD 0695 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0695 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0695 stack[-1] = stack[-3] // } // Block continues label_0696: // Incoming jump from 0x064F, if !stack[-1] // Incoming jump from 0x066A // Incoming jump from 0x0695 // Inputs[3] // { // @069C stack[-7] // @069C stack[-6] // @069E stack[-8] // } 0696 5B JUMPDEST 0697 50 POP 0698 50 POP 0699 50 POP 069A 50 POP 069B 50 POP 069C 90 SWAP1 069D 50 POP 069E 90 SWAP1 069F 56 *JUMP // Stack delta = -7 // Outputs[1] { @069E stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06A0: // Incoming jump from 0x025E // Inputs[1] { @06A6 stack[-1] } 06A0 5B JUMPDEST 06A1 60 PUSH1 0x00 06A3 61 PUSH2 0x06ab 06A6 82 DUP3 06A7 61 PUSH2 0x0df8 06AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06A1 stack[0] = 0x00 // @06A3 stack[1] = 0x06ab // @06A6 stack[2] = stack[-1] // } // Block ends with call to 0x0df8, returns to 0x06AB label_06AB: // Incoming return from call to 0x0DF8 at 0x06AA // Incoming return from call to 0x0DF8 at 0x06AA // Inputs[1] { @06AF stack[-1] } 06AB 5B JUMPDEST 06AC 61 PUSH2 0x06c8 06AF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06c8, if stack[-1] label_06B0: // Incoming jump from 0x06AF, if not stack[-1] // Inputs[3] // { // @06B2 memory[0x40:0x60] // @06C2 memory[0x40:0x60] // @06C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06B0 60 PUSH1 0x40 06B2 51 MLOAD 06B3 63 PUSH4 0x33d1c039 06B8 60 PUSH1 0xe2 06BA 1B SHL 06BB 81 DUP2 06BC 52 MSTORE 06BD 60 PUSH1 0x04 06BF 01 ADD 06C0 60 PUSH1 0x40 06C2 51 MLOAD 06C3 80 DUP1 06C4 91 SWAP2 06C5 03 SUB 06C6 90 SWAP1 06C7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @06BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @06C7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_06C8: // Incoming jump from 0x06AF, if stack[-1] 06C8 5B JUMPDEST 06C9 61 PUSH2 0x06d0 06CC 61 PUSH2 0x0dd4 06CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @06C9 stack[0] = 0x06d0 } // Block ends with call to 0x0dd4, returns to 0x06D0 label_06D0: // Incoming return from call to 0x0DD4 at 0x06CF // Inputs[5] // { // @06D3 stack[-3] // @06D8 stack[-1] // @06E0 memory[0x00:0x40] // @06E1 storage[keccak256(memory[0x00:0x40])] // @06EB stack[-4] // } 06D0 5B JUMPDEST 06D1 60 PUSH1 0x00 06D3 92 SWAP3 06D4 83 DUP4 06D5 52 MSTORE 06D6 60 PUSH1 0x06 06D8 01 ADD 06D9 60 PUSH1 0x20 06DB 52 MSTORE 06DC 50 POP 06DD 60 PUSH1 0x40 06DF 90 SWAP1 06E0 20 SHA3 06E1 54 SLOAD 06E2 60 PUSH1 0x01 06E4 60 PUSH1 0x01 06E6 60 PUSH1 0xa0 06E8 1B SHL 06E9 03 SUB 06EA 16 AND 06EB 90 SWAP1 06EC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @06D5 memory[0x00:0x20] = stack[-3] // @06DB memory[0x20:0x40] = 0x06 + stack[-1] // @06EB stack[-4] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_06ED: // Incoming jump from 0x0289 // Inputs[1] { @06EE stack[-2] } 06ED 5B JUMPDEST 06EE 81 DUP2 06EF 61 PUSH2 0x06f7 06F2 81 DUP2 06F3 61 PUSH2 0x0e41 06F6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06EE stack[0] = stack[-2] // @06EF stack[1] = 0x06f7 // @06F2 stack[2] = stack[-2] // } // Block ends with call to 0x0e41, returns to 0x06F7 label_06F7: // Incoming return from call to 0x0E41 at 0x06F6 // Inputs[2] // { // @06FB stack[-3] // @06FC stack[-2] // } 06F7 5B JUMPDEST 06F8 61 PUSH2 0x0701 06FB 83 DUP4 06FC 83 DUP4 06FD 61 PUSH2 0x0efa 0700 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06F8 stack[0] = 0x0701 // @06FB stack[1] = stack[-3] // @06FC stack[2] = stack[-2] // } // Block ends with call to 0x0efa, returns to 0x0701 label_0701: // Incoming return from call to 0x170E at 0x0C35 // Incoming return from call to 0x11CC at 0x0CB8 // Incoming return from call to 0x1687 at 0x0BDE // Incoming return from call to 0x1146 at 0x0803 // Incoming return from call to 0x0EFA at 0x0700 // Inputs[1] { @0705 stack[-4] } 0701 5B JUMPDEST 0702 50 POP 0703 50 POP 0704 50 POP 0705 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 0706 5B JUMPDEST 0707 60 PUSH1 0x00 0709 61 PUSH2 0x0711 070C 81 DUP2 070D 61 PUSH2 0x0f06 0710 56 *JUMP 0711 5B JUMPDEST 0712 61 PUSH2 0x071a 0715 82 DUP3 0716 61 PUSH2 0x0f10 0719 56 *JUMP label_071A: // Incoming jump from 0x1154, if stack[-1] // Incoming jump from 0x18C3, if !(memory[stack[-7]:stack[-7] + 0x20] - (0x01 + stack[-6])) // Incoming jump from 0x14DB, if !(memory[stack[-5]:stack[-5] + 0x20] - (0x01 + stack[-4])) // Incoming jump from 0x1A44, if stack[-1] // Incoming jump from 0x11DB, if !stack[-1] // Incoming return from call to 0x1981 at 0x0F05 // Incoming return from call to 0x11CC at 0x0882 // Inputs[1] { @071D stack[-3] } 071A 5B JUMPDEST 071B 50 POP 071C 50 POP 071D 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_071E: // Incoming call from 0x02C0, returns to 0x02C1 071E 5B JUMPDEST 071F 60 PUSH1 0x00 0721 60 PUSH1 0x01 0723 61 PUSH2 0x072a 0726 61 PUSH2 0x0dd4 0729 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @071F stack[0] = 0x00 // @0721 stack[1] = 0x01 // @0723 stack[2] = 0x072a // } // Block ends with call to 0x0dd4, returns to 0x072A label_072A: // Incoming return from call to 0x0DD4 at 0x0729 // Inputs[2] // { // @072D stack[-1] // @072E storage[0x01 + stack[-1]] // } 072A 5B JUMPDEST 072B 60 PUSH1 0x01 072D 01 ADD 072E 54 SLOAD 072F 61 PUSH2 0x0736 0732 61 PUSH2 0x0dd4 0735 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @072E stack[-1] = storage[0x01 + stack[-1]] // @072F stack[0] = 0x0736 // } // Block ends with call to 0x0dd4, returns to 0x0736 label_0736: // Incoming return from call to 0x0DD4 at 0x0735 // Inputs[6] // { // @0737 stack[-1] // @0737 storage[stack[-1]] // @0738 stack[-2] // @0739 stack[-3] // @073A stack[-5] // @073B stack[-4] // } 0736 5B JUMPDEST 0737 54 SLOAD 0738 03 SUB 0739 03 SUB 073A 91 SWAP2 073B 90 SWAP1 073C 50 POP 073D 56 *JUMP // Stack delta = -4 // Outputs[1] { @073A stack[-5] = storage[stack[-1]] - stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-5] label_073E: // Incoming jump from 0x1795 // Incoming jump from 0x02E1 // Inputs[2] // { // @073F stack[-3] // @074A msg.sender // } 073E 5B JUMPDEST 073F 82 DUP3 0740 60 PUSH1 0x01 0742 60 PUSH1 0x01 0744 60 PUSH1 0xa0 0746 1B SHL 0747 03 SUB 0748 81 DUP2 0749 16 AND 074A 33 CALLER 074B 14 EQ 074C 61 PUSH2 0x0758 074F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @073F stack[0] = stack[-3] } // Block ends with conditional jump to 0x0758, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0750: // Incoming jump from 0x074F, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0753 msg.sender } 0750 61 PUSH2 0x0758 0753 33 CALLER 0754 61 PUSH2 0x0e41 0757 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0750 stack[0] = 0x0758 // @0753 stack[1] = msg.sender // } // Block ends with call to 0x0e41, returns to 0x0758 label_0758: // Incoming return from call to 0x0E41 at 0x0757 // Incoming jump from 0x074F, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @075C stack[-4] // @075D stack[-3] // @075E stack[-2] // } 0758 5B JUMPDEST 0759 61 PUSH2 0x0763 075C 84 DUP5 075D 84 DUP5 075E 84 DUP5 075F 61 PUSH2 0x0f42 0762 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0759 stack[0] = 0x0763 // @075C stack[1] = stack[-4] // @075D stack[2] = stack[-3] // @075E stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0f42 label_0763: // Incoming jump from 0x2391, if !(stack[-1] > stack[-4]) // Inputs[1] { @0768 stack[-5] } 0763 5B JUMPDEST 0764 50 POP 0765 50 POP 0766 50 POP 0767 50 POP 0768 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0769: // Incoming jump from 0x0331 // Inputs[2] // { // @0795 storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b41] // @079A stack[-1] // } 0769 5B JUMPDEST 076A 60 PUSH1 0x00 076C 80 DUP1 076D 80 DUP1 076E 61 PUSH2 0x2710 0771 7F PUSH32 0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40 0792 60 PUSH1 0x01 0794 01 ADD 0795 54 SLOAD 0796 61 PUSH2 0x079f 0799 90 SWAP1 079A 86 DUP7 079B 61 PUSH2 0x29bb 079E 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @076A stack[0] = 0x00 // @076C stack[1] = 0x00 // @076D stack[2] = 0x00 // @076E stack[3] = 0x2710 // @0799 stack[4] = 0x079f // @0799 stack[5] = storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b41] // @079A stack[6] = stack[-1] // } // Block ends with call to 0x29bb, returns to 0x079F label_079F: // Incoming return from call to 0x29BB at 0x079E // Inputs[2] // { // @07A3 stack[-2] // @07A4 stack[-1] // } 079F 5B JUMPDEST 07A0 61 PUSH2 0x07a9 07A3 91 SWAP2 07A4 90 SWAP1 07A5 61 PUSH2 0x29da 07A8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07A3 stack[-2] = 0x07a9 // @07A4 stack[-1] = stack[-2] // @07A4 stack[0] = stack[-1] // } // Block ends with call to 0x29da, returns to 0x07A9 label_07A9: // Incoming return from call to 0x29DA at 0x07A8 // Inputs[5] // { // @07CB storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40] // @07D5 stack[-7] // @07D6 stack[-1] // @07D7 stack[-6] // @07D9 stack[-5] // } 07A9 5B JUMPDEST 07AA 7F PUSH32 0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40 07CB 54 SLOAD 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0x01 07D0 60 PUSH1 0xa0 07D2 1B SHL 07D3 03 SUB 07D4 16 AND 07D5 96 SWAP7 07D6 90 SWAP1 07D7 95 SWAP6 07D8 50 POP 07D9 93 SWAP4 07DA 50 POP 07DB 50 POP 07DC 50 POP 07DD 50 POP 07DE 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @07D5 stack[-7] = (0x01 << 0xa0) - 0x01 & storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40] // @07D7 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-7] label_07DF: // Incoming jump from 0x0370 // Inputs[3] // { // @07E2 stack[-2] // @07ED memory[0x00:0x40] // @07F1 storage[0x01 + keccak256(memory[0x00:0x40])] // } 07DF 5B JUMPDEST 07E0 60 PUSH1 0x00 07E2 82 DUP3 07E3 81 DUP2 07E4 52 MSTORE 07E5 60 PUSH1 0x97 07E7 60 PUSH1 0x20 07E9 52 MSTORE 07EA 60 PUSH1 0x40 07EC 90 SWAP1 07ED 20 SHA3 07EE 60 PUSH1 0x01 07F0 01 ADD 07F1 54 SLOAD 07F2 61 PUSH2 0x07fa 07F5 81 DUP2 07F6 61 PUSH2 0x0f06 07F9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @07E4 memory[0x00:0x20] = stack[-2] // @07E9 memory[0x20:0x40] = 0x97 // @07F1 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @07F2 stack[1] = 0x07fa // @07F5 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0f06, returns to 0x07FA label_07FA: // Incoming return from call to 0x0F06 at 0x07F9 // Inputs[2] // { // @07FE stack[-3] // @07FF stack[-2] // } 07FA 5B JUMPDEST 07FB 61 PUSH2 0x0701 07FE 83 DUP4 07FF 83 DUP4 0800 61 PUSH2 0x1146 0803 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07FB stack[0] = 0x0701 // @07FE stack[1] = stack[-3] // @07FF stack[2] = stack[-2] // } // Block ends with call to 0x1146, returns to 0x0701 label_0804: // Incoming jump from 0x0390 // Inputs[2] // { // @080D stack[-1] // @080F msg.sender // } 0804 5B JUMPDEST 0805 60 PUSH1 0x01 0807 60 PUSH1 0x01 0809 60 PUSH1 0xa0 080B 1B SHL 080C 03 SUB 080D 81 DUP2 080E 16 AND 080F 33 CALLER 0810 14 EQ 0811 61 PUSH2 0x0879 0814 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0879, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_0815: // Incoming jump from 0x0814, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0817 memory[0x40:0x60] } 0815 60 PUSH1 0x40 0817 51 MLOAD 0818 62 PUSH3 0x461bcd 081C 60 PUSH1 0xe5 081E 1B SHL 081F 81 DUP2 0820 52 MSTORE 0821 60 PUSH1 0x20 0823 60 PUSH1 0x04 0825 82 DUP3 0826 01 ADD 0827 52 MSTORE 0828 60 PUSH1 0x2f 082A 60 PUSH1 0x24 082C 82 DUP3 082D 01 ADD 082E 52 MSTORE 082F 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 0850 60 PUSH1 0x44 0852 82 DUP3 0853 01 ADD 0854 52 MSTORE 0855 6E PUSH15 0x103937b632b9903337b91039b2b633 0865 60 PUSH1 0x89 0867 1B SHL 0868 60 PUSH1 0x64 086A 82 DUP3 086B 01 ADD 086C 52 MSTORE 086D 60 PUSH1 0x84 086F 01 ADD // Stack delta = +1 // Outputs[6] // { // @0820 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0827 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @082E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0854 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @086C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103937b632b9903337b91039b2b633 << 0x89 // @086F stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0870: // Incoming jump from 0x0DA1 // Incoming jump from 0x091F // Incoming jump from 0x0EF9 // Incoming jump from 0x1F70 // Incoming return from call to 0x2A48 at 0x1F9E // Incoming jump from 0x12DD // Incoming return from call to 0x2A48 at 0x1340 // Incoming jump from 0x086F // Incoming jump from 0x141A // Incoming return from call to 0x2A48 at 0x1AF6 // Inputs[3] // { // @0873 memory[0x40:0x60] // @0875 stack[-1] // @0878 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0870 5B JUMPDEST 0871 60 PUSH1 0x40 0873 51 MLOAD 0874 80 DUP1 0875 91 SWAP2 0876 03 SUB 0877 90 SWAP1 0878 FD *REVERT // Stack delta = -1 // Outputs[1] { @0878 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0879: // Incoming jump from 0x0814, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @087D stack[-2] // @087E stack[-1] // } 0879 5B JUMPDEST 087A 61 PUSH2 0x071a 087D 82 DUP3 087E 82 DUP3 087F 61 PUSH2 0x11cc 0882 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @087A stack[0] = 0x071a // @087D stack[1] = stack[-2] // @087E stack[2] = stack[-1] // } // Block ends with call to 0x11cc, returns to 0x071A label_0883: // Incoming jump from 0x03B0 // Inputs[1] { @0886 storage[0x00] } 0883 5B JUMPDEST 0884 60 PUSH1 0x00 0886 54 SLOAD 0887 61 PUSH2 0x0100 088A 90 SWAP1 088B 04 DIV 088C 60 PUSH1 0xff 088E 16 AND 088F 15 ISZERO 0890 80 DUP1 0891 80 DUP1 0892 15 ISZERO 0893 61 PUSH2 0x08a3 0896 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @088F stack[0] = !(0xff & storage[0x00] / 0x0100) // @0890 stack[1] = !(0xff & storage[0x00] / 0x0100) // } // Block ends with conditional jump to 0x08a3, if !!(0xff & storage[0x00] / 0x0100) label_0897: // Incoming jump from 0x0896, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @089A storage[0x00] } 0897 50 POP 0898 60 PUSH1 0x00 089A 54 SLOAD 089B 60 PUSH1 0x01 089D 60 PUSH1 0xff 089F 90 SWAP1 08A0 91 SWAP2 08A1 16 AND 08A2 10 LT 08A3 5B JUMPDEST 08A4 80 DUP1 08A5 61 PUSH2 0x08bd 08A8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08A2 stack[-1] = storage[0x00] & 0xff < 0x01 } // Block ends with conditional jump to 0x08bd, if storage[0x00] & 0xff < 0x01 label_08A9: // Incoming jump from 0x08A8, if not storage[0x00] & 0xff < 0x01 // Incoming jump from 0x08A8, if not stack[-1] // Inputs[2] // { // @08AA address(this) // @08AB address(address(this)).code.length // } 08A9 50 POP 08AA 30 ADDRESS 08AB 3B EXTCODESIZE 08AC 15 ISZERO 08AD 80 DUP1 08AE 15 ISZERO 08AF 61 PUSH2 0x08bd 08B2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08AC stack[-1] = !address(address(this)).code.length } // Block ends with conditional jump to 0x08bd, if !!address(address(this)).code.length label_08B3: // Incoming jump from 0x08B2, if not !!address(address(this)).code.length // Inputs[1] { @08B6 storage[0x00] } 08B3 50 POP 08B4 60 PUSH1 0x00 08B6 54 SLOAD 08B7 60 PUSH1 0xff 08B9 16 AND 08BA 60 PUSH1 0x01 08BC 14 EQ // Stack delta = +0 // Outputs[1] { @08BC stack[-1] = 0x01 == 0xff & storage[0x00] } // Block continues label_08BD: // Incoming jump from 0x08A8, if stack[-1] // Incoming jump from 0x08BC // Incoming jump from 0x08A8, if storage[0x00] & 0xff < 0x01 // Incoming jump from 0x08B2, if !!address(address(this)).code.length // Inputs[1] { @08C1 stack[-1] } 08BD 5B JUMPDEST 08BE 61 PUSH2 0x0920 08C1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0920, if stack[-1] label_08C2: // Incoming jump from 0x08C1, if not stack[-1] // Inputs[1] { @08C4 memory[0x40:0x60] } 08C2 60 PUSH1 0x40 08C4 51 MLOAD 08C5 62 PUSH3 0x461bcd 08C9 60 PUSH1 0xe5 08CB 1B SHL 08CC 81 DUP2 08CD 52 MSTORE 08CE 60 PUSH1 0x20 08D0 60 PUSH1 0x04 08D2 82 DUP3 08D3 01 ADD 08D4 52 MSTORE 08D5 60 PUSH1 0x2e 08D7 60 PUSH1 0x24 08D9 82 DUP3 08DA 01 ADD 08DB 52 MSTORE 08DC 7F PUSH32 0x496e697469616c697a61626c653a20636f6e747261637420697320616c726561 08FD 60 PUSH1 0x44 08FF 82 DUP3 0900 01 ADD 0901 52 MSTORE 0902 6D PUSH14 0x191e481a5b9a5d1a585b1a5e9959 0911 60 PUSH1 0x92 0913 1B SHL 0914 60 PUSH1 0x64 0916 82 DUP3 0917 01 ADD 0918 52 MSTORE 0919 60 PUSH1 0x84 091B 01 ADD 091C 61 PUSH2 0x0870 091F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08D4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08DB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2e // @0901 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e697469616c697a61626c653a20636f6e747261637420697320616c726561 // @0918 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x191e481a5b9a5d1a585b1a5e9959 << 0x92 // @091B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_0920: // Incoming jump from 0x08C1, if stack[-1] // Inputs[2] // { // @0924 storage[0x00] // @092E stack[-1] // } 0920 5B JUMPDEST 0921 60 PUSH1 0x00 0923 80 DUP1 0924 54 SLOAD 0925 60 PUSH1 0xff 0927 19 NOT 0928 16 AND 0929 60 PUSH1 0x01 092B 17 OR 092C 90 SWAP1 092D 55 SSTORE 092E 80 DUP1 092F 15 ISZERO 0930 61 PUSH2 0x0943 0933 57 *JUMPI // Stack delta = +0 // Outputs[1] { @092D storage[0x00] = 0x01 | (~0xff & storage[0x00]) } // Block ends with conditional jump to 0x0943, if !stack[-1] label_0934: // Incoming jump from 0x0933, if not !stack[-1] // Inputs[7] // { // @0937 storage[0x00] // @0947 stack[-7] // @0948 stack[-6] // @0949 stack[-5] // @094A stack[-4] // @094B stack[-3] // @094C stack[-2] // } 0934 60 PUSH1 0x00 0936 80 DUP1 0937 54 SLOAD 0938 61 PUSH2 0xff00 093B 19 NOT 093C 16 AND 093D 61 PUSH2 0x0100 0940 17 OR 0941 90 SWAP1 0942 55 SSTORE 0943 5B JUMPDEST 0944 61 PUSH2 0x0951 0947 87 DUP8 0948 87 DUP8 0949 87 DUP8 094A 87 DUP8 094B 87 DUP8 094C 87 DUP8 094D 61 PUSH2 0x1233 0950 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @0942 storage[0x00] = 0x0100 | (~0xff00 & storage[0x00]) // @0944 stack[0] = 0x0951 // @0947 stack[1] = stack[-7] // @0948 stack[2] = stack[-6] // @0949 stack[3] = stack[-5] // @094A stack[4] = stack[-4] // @094B stack[5] = stack[-3] // @094C stack[6] = stack[-2] // } // Block ends with unconditional jump to 0x1233 0951 5B JUMPDEST 0952 80 DUP1 0953 15 ISZERO 0954 61 PUSH2 0x0997 0957 57 *JUMPI 0958 60 PUSH1 0x00 095A 80 DUP1 095B 54 SLOAD 095C 61 PUSH2 0xff00 095F 19 NOT 0960 16 AND 0961 90 SWAP1 0962 55 SSTORE 0963 60 PUSH1 0x40 0965 51 MLOAD 0966 60 PUSH1 0x01 0968 81 DUP2 0969 52 MSTORE 096A 7F PUSH32 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498 098B 90 SWAP1 098C 60 PUSH1 0x20 098E 01 ADD 098F 60 PUSH1 0x40 0991 51 MLOAD 0992 80 DUP1 0993 91 SWAP2 0994 03 SUB 0995 90 SWAP1 0996 A1 LOG1 0997 5B JUMPDEST 0998 50 POP 0999 50 POP 099A 50 POP 099B 50 POP 099C 50 POP 099D 50 POP 099E 50 POP 099F 56 *JUMP label_09A0: // Incoming jump from 0x03C3 // Inputs[2] // { // @09A1 stack[-3] // @09AC msg.sender // } 09A0 5B JUMPDEST 09A1 82 DUP3 09A2 60 PUSH1 0x01 09A4 60 PUSH1 0x01 09A6 60 PUSH1 0xa0 09A8 1B SHL 09A9 03 SUB 09AA 81 DUP2 09AB 16 AND 09AC 33 CALLER 09AD 14 EQ 09AE 61 PUSH2 0x09ba 09B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09A1 stack[0] = stack[-3] } // Block ends with conditional jump to 0x09ba, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_09B2: // Incoming jump from 0x09B1, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09B5 msg.sender } 09B2 61 PUSH2 0x09ba 09B5 33 CALLER 09B6 61 PUSH2 0x0e41 09B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09B2 stack[0] = 0x09ba // @09B5 stack[1] = msg.sender // } // Block ends with call to 0x0e41, returns to 0x09BA label_09BA: // Incoming jump from 0x09B1, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0E41 at 0x09B9 // Inputs[3] // { // @09BE stack[-4] // @09BF stack[-3] // @09C0 stack[-2] // } 09BA 5B JUMPDEST 09BB 61 PUSH2 0x0763 09BE 84 DUP5 09BF 84 DUP5 09C0 84 DUP5 09C1 61 PUSH2 0x13a6 09C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09BB stack[0] = 0x0763 // @09BE stack[1] = stack[-4] // @09BF stack[2] = stack[-3] // @09C0 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x13a6 label_09C5: // Incoming jump from 0x03E3 09C5 5B JUMPDEST 09C6 61 PUSH2 0x09cd 09C9 61 PUSH2 0x13c1 09CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @09C6 stack[0] = 0x09cd } // Block ends with call to 0x13c1, returns to 0x09CD label_09CD: // Incoming return from call to 0x13C1 at 0x09CC // Inputs[1] { @09D1 stack[-1] } 09CD 5B JUMPDEST 09CE 61 PUSH2 0x09d6 09D1 81 DUP2 09D2 61 PUSH2 0x141b 09D5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09CE stack[0] = 0x09d6 // @09D1 stack[1] = stack[-1] // } // Block ends with call to 0x141b, returns to 0x09D6 label_09D6: // Incoming return from call to 0x141B at 0x09D5 // Incoming jump from 0x234C, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x27CE, if stack[-1] == !!stack[-1] // Incoming return from call to 0x1604 at 0x0DAA // Incoming return from call to 0x1844 at 0x0CC9 // Incoming jump from 0x0E56, if !address(0xaaeb6d7670e522a718067333cd4e).code.length // Incoming jump from 0x0ED6, if stack[-1] // Incoming return from call to 0x1A36 at 0x0F0F // Inputs[1] { @09D8 stack[-2] } 09D6 5B JUMPDEST 09D7 50 POP 09D8 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_09D9: // Incoming call from 0x198B, returns to 0x198C // Incoming jump from 0x0403 // Inputs[1] { @09DF stack[-1] } 09D9 5B JUMPDEST 09DA 60 PUSH1 0x00 09DC 61 PUSH2 0x05ff 09DF 82 DUP3 09E0 61 PUSH2 0x14e0 09E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09DA stack[0] = 0x00 // @09DC stack[1] = 0x05ff // @09DF stack[2] = stack[-1] // } // Block ends with call to 0x14e0, returns to 0x05FF label_09E4: // Incoming jump from 0x0423 // Inputs[2] // { // @09EF stack[-1] // @09F2 memory[stack[-1]:stack[-1] + 0x20] // } 09E4 5B JUMPDEST 09E5 60 PUSH1 0x00 09E7 5B JUMPDEST 09E8 60 PUSH1 0x00 09EA 60 PUSH1 0xa0 09EC 61 PUSH2 0x0a0d 09EF 84 DUP5 09F0 84 DUP5 09F1 81 DUP2 09F2 51 MLOAD 09F3 81 DUP2 09F4 10 LT 09F5 61 PUSH2 0x0a00 09F8 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @09E5 stack[0] = 0x00 // @09E8 stack[1] = 0x00 // @09EA stack[2] = 0xa0 // @09EC stack[3] = 0x0a0d // @09EF stack[4] = stack[-1] // @09F0 stack[5] = 0x00 // } // Block ends with conditional jump to 0x0a00, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_09F9: // Incoming jump from 0x09F8, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 09F9 61 PUSH2 0x0a00 09FC 61 PUSH2 0x29fc 09FF 56 *JUMP // Stack delta = +1 // Outputs[1] { @09F9 stack[0] = 0x0a00 } // Block ends with unconditional jump to 0x29fc label_0A00: // Incoming jump from 0x09F8, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @0A03 stack[-1] // @0A07 stack[-2] // @0A08 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0A00 5B JUMPDEST 0A01 60 PUSH1 0x20 0A03 02 MUL 0A04 60 PUSH1 0x20 0A06 01 ADD 0A07 01 ADD 0A08 51 MLOAD 0A09 61 PUSH2 0x158d 0A0C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A08 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x158d 0A0D 5B JUMPDEST 0A0E 60 PUSH1 0x20 0A10 01 ADD 0A11 51 MLOAD 0A12 60 PUSH1 0x01 0A14 60 PUSH1 0x01 0A16 60 PUSH1 0x40 0A18 1B SHL 0A19 03 SUB 0A1A 16 AND 0A1B 90 SWAP1 0A1C 1B SHL 0A1D 90 SWAP1 0A1E 50 POP 0A1F 61 PUSH2 0x0a42 0A22 33 CALLER 0A23 85 DUP6 0A24 85 DUP6 0A25 85 DUP6 0A26 81 DUP2 0A27 51 MLOAD 0A28 81 DUP2 0A29 10 LT 0A2A 61 PUSH2 0x0a35 0A2D 57 *JUMPI 0A2E 61 PUSH2 0x0a35 0A31 61 PUSH2 0x29fc 0A34 56 *JUMP 0A35 5B JUMPDEST 0A36 60 PUSH1 0x20 0A38 02 MUL 0A39 60 PUSH1 0x20 0A3B 01 ADD 0A3C 01 ADD 0A3D 51 MLOAD 0A3E 61 PUSH2 0x09a0 0A41 56 *JUMP 0A42 5B JUMPDEST 0A43 80 DUP1 0A44 67 PUSH8 0xffffffffffffffff 0A4D 60 PUSH1 0xa0 0A4F 1B SHL 0A50 19 NOT 0A51 61 PUSH2 0x0a58 0A54 61 PUSH2 0x0dd4 0A57 56 *JUMP 0A58 5B JUMPDEST 0A59 60 PUSH1 0x04 0A5B 01 ADD 0A5C 60 PUSH1 0x00 0A5E 86 DUP7 0A5F 86 DUP7 0A60 81 DUP2 0A61 51 MLOAD 0A62 81 DUP2 0A63 10 LT 0A64 61 PUSH2 0x0a6f 0A67 57 *JUMPI 0A68 61 PUSH2 0x0a6f 0A6B 61 PUSH2 0x29fc 0A6E 56 *JUMP 0A6F 5B JUMPDEST 0A70 60 PUSH1 0x20 0A72 02 MUL 0A73 60 PUSH1 0x20 0A75 01 ADD 0A76 01 ADD 0A77 51 MLOAD 0A78 81 DUP2 0A79 52 MSTORE 0A7A 60 PUSH1 0x20 0A7C 01 ADD 0A7D 90 SWAP1 0A7E 81 DUP2 0A7F 52 MSTORE 0A80 60 PUSH1 0x20 0A82 01 ADD 0A83 60 PUSH1 0x00 0A85 20 SHA3 0A86 54 SLOAD 0A87 16 AND 0A88 17 OR 0A89 61 PUSH2 0x0a90 0A8C 61 PUSH2 0x0dd4 0A8F 56 *JUMP 0A90 5B JUMPDEST 0A91 60 PUSH1 0x04 0A93 01 ADD 0A94 60 PUSH1 0x00 0A96 85 DUP6 0A97 85 DUP6 0A98 81 DUP2 0A99 51 MLOAD 0A9A 81 DUP2 0A9B 10 LT 0A9C 61 PUSH2 0x0aa7 0A9F 57 *JUMPI 0AA0 61 PUSH2 0x0aa7 0AA3 61 PUSH2 0x29fc 0AA6 56 *JUMP 0AA7 5B JUMPDEST 0AA8 60 PUSH1 0x20 0AAA 02 MUL 0AAB 60 PUSH1 0x20 0AAD 01 ADD 0AAE 01 ADD 0AAF 51 MLOAD 0AB0 81 DUP2 0AB1 52 MSTORE 0AB2 60 PUSH1 0x20 0AB4 01 ADD 0AB5 90 SWAP1 0AB6 81 DUP2 0AB7 52 MSTORE 0AB8 60 PUSH1 0x20 0ABA 01 ADD 0ABB 60 PUSH1 0x00 0ABD 20 SHA3 0ABE 81 DUP2 0ABF 90 SWAP1 0AC0 55 SSTORE 0AC1 50 POP 0AC2 82 DUP3 0AC3 82 DUP3 0AC4 81 DUP2 0AC5 51 MLOAD 0AC6 81 DUP2 0AC7 10 LT 0AC8 61 PUSH2 0x0ad3 0ACB 57 *JUMPI 0ACC 61 PUSH2 0x0ad3 0ACF 61 PUSH2 0x29fc 0AD2 56 *JUMP 0AD3 5B JUMPDEST 0AD4 60 PUSH1 0x20 0AD6 02 MUL 0AD7 60 PUSH1 0x20 0AD9 01 ADD 0ADA 01 ADD 0ADB 51 MLOAD 0ADC 84 DUP5 0ADD 60 PUSH1 0x01 0ADF 60 PUSH1 0x01 0AE1 60 PUSH1 0xa0 0AE3 1B SHL 0AE4 03 SUB 0AE5 16 AND 0AE6 33 CALLER 0AE7 60 PUSH1 0x01 0AE9 60 PUSH1 0x01 0AEB 60 PUSH1 0xa0 0AED 1B SHL 0AEE 03 SUB 0AEF 16 AND 0AF0 7F PUSH32 0xe73b77795c13bee9883a40de3973381a54190f3bc777dcab3a8206d302afc784 0B11 60 PUSH1 0x40 0B13 51 MLOAD 0B14 60 PUSH1 0x40 0B16 51 MLOAD 0B17 80 DUP1 0B18 91 SWAP2 0B19 03 SUB 0B1A 90 SWAP1 0B1B A4 LOG4 0B1C 61 PUSH2 0x0b24 0B1F 82 DUP3 0B20 61 PUSH2 0x2a12 0B23 56 *JUMP 0B24 5B JUMPDEST 0B25 91 SWAP2 0B26 50 POP 0B27 81 DUP2 0B28 83 DUP4 0B29 51 MLOAD 0B2A 03 SUB 0B2B 61 PUSH2 0x0b34 0B2E 57 *JUMPI 0B2F 50 POP 0B30 50 POP 0B31 50 POP 0B32 50 POP 0B33 56 *JUMP 0B34 5B JUMPDEST 0B35 50 POP 0B36 61 PUSH2 0x09e7 0B39 56 *JUMP label_0B3A: // Incoming jump from 0x0443 // Inputs[1] { @0B45 stack[-1] } 0B3A 5B JUMPDEST 0B3B 60 PUSH1 0x00 0B3D 60 PUSH1 0x01 0B3F 60 PUSH1 0x01 0B41 60 PUSH1 0xa0 0B43 1B SHL 0B44 03 SUB 0B45 82 DUP3 0B46 16 AND 0B47 61 PUSH2 0x0b63 0B4A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B3B stack[0] = 0x00 } // Block ends with conditional jump to 0x0b63, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0B4B: // Incoming jump from 0x0B4A, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B4D memory[0x40:0x60] // @0B5D memory[0x40:0x60] // @0B62 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B4B 60 PUSH1 0x40 0B4D 51 MLOAD 0B4E 63 PUSH4 0x23d3ad81 0B53 60 PUSH1 0xe2 0B55 1B SHL 0B56 81 DUP2 0B57 52 MSTORE 0B58 60 PUSH1 0x04 0B5A 01 ADD 0B5B 60 PUSH1 0x40 0B5D 51 MLOAD 0B5E 80 DUP1 0B5F 91 SWAP2 0B60 03 SUB 0B61 90 SWAP1 0B62 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0B62 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B63: // Incoming jump from 0x0B4A, if stack[-1] & (0x01 << 0xa0) - 0x01 0B63 5B JUMPDEST 0B64 60 PUSH1 0x01 0B66 60 PUSH1 0x01 0B68 60 PUSH1 0x40 0B6A 1B SHL 0B6B 03 SUB 0B6C 61 PUSH2 0x0b73 0B6F 61 PUSH2 0x0dd4 0B72 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B6B stack[0] = (0x01 << 0x40) - 0x01 // @0B6C stack[1] = 0x0b73 // } // Block ends with call to 0x0dd4, returns to 0x0B73 label_0B73: // Incoming return from call to 0x0DD4 at 0x0B72 // Inputs[7] // { // @0B76 stack[-1] // @0B79 stack[-4] // @0B99 memory[0x00:0x40] // @0B9A storage[keccak256(memory[0x00:0x40])] // @0B9B stack[-2] // @0B9C stack[-3] // @0B9E stack[-5] // } 0B73 5B JUMPDEST 0B74 60 PUSH1 0x05 0B76 01 ADD 0B77 60 PUSH1 0x00 0B79 84 DUP5 0B7A 60 PUSH1 0x01 0B7C 60 PUSH1 0x01 0B7E 60 PUSH1 0xa0 0B80 1B SHL 0B81 03 SUB 0B82 16 AND 0B83 60 PUSH1 0x01 0B85 60 PUSH1 0x01 0B87 60 PUSH1 0xa0 0B89 1B SHL 0B8A 03 SUB 0B8B 16 AND 0B8C 81 DUP2 0B8D 52 MSTORE 0B8E 60 PUSH1 0x20 0B90 01 ADD 0B91 90 SWAP1 0B92 81 DUP2 0B93 52 MSTORE 0B94 60 PUSH1 0x20 0B96 01 ADD 0B97 60 PUSH1 0x00 0B99 20 SHA3 0B9A 54 SLOAD 0B9B 16 AND 0B9C 90 SWAP1 0B9D 50 POP 0B9E 91 SWAP2 0B9F 90 SWAP1 0BA0 50 POP 0BA1 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0B8D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-4] // @0B93 memory[0x20:0x40] = 0x05 + stack[-1] // @0B9E stack[-5] = storage[keccak256(memory[0x00:0x40])] & stack[-2] // } // Block ends with unconditional jump to stack[-5] label_0BA2: // Incoming jump from 0x0458 0BA2 5B JUMPDEST 0BA3 61 PUSH2 0x0baa 0BA6 61 PUSH2 0x13c1 0BA9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BA3 stack[0] = 0x0baa } // Block ends with call to 0x13c1, returns to 0x0BAA label_0BAA: // Incoming return from call to 0x13C1 at 0x0BA9 0BAA 5B JUMPDEST 0BAB 61 PUSH2 0x0bb4 0BAE 60 PUSH1 0x00 0BB0 61 PUSH2 0x1604 0BB3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BAB stack[0] = 0x0bb4 // @0BAE stack[1] = 0x00 // } // Block ends with call to 0x1604, returns to 0x0BB4 label_0BB4: // Incoming jump from 0x13D3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x33] // Incoming return from call to 0x1604 at 0x1FA7 // Incoming return from call to 0x1604 at 0x0BB3 // Inputs[1] { @0BB5 stack[-1] } 0BB4 5B JUMPDEST 0BB5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] 0BB6 5B JUMPDEST 0BB7 60 PUSH1 0x00 0BB9 61 PUSH2 0x0bc1 0BBC 81 DUP2 0BBD 61 PUSH2 0x0f06 0BC0 56 *JUMP 0BC1 5B JUMPDEST 0BC2 61 PUSH2 0x071a 0BC5 82 DUP3 0BC6 61 PUSH2 0x1656 0BC9 56 *JUMP label_0BCA: // Incoming jump from 0x0498 0BCA 5B JUMPDEST 0BCB 60 PUSH1 0x00 0BCD 61 PUSH2 0x0bd5 0BD0 81 DUP2 0BD1 61 PUSH2 0x0f06 0BD4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BCB stack[0] = 0x00 // @0BCD stack[1] = 0x0bd5 // @0BD0 stack[2] = 0x00 // } // Block ends with call to 0x0f06, returns to 0x0BD5 label_0BD5: // Incoming return from call to 0x0F06 at 0x0BD4 // Inputs[2] // { // @0BD9 stack[-3] // @0BDA stack[-2] // } 0BD5 5B JUMPDEST 0BD6 61 PUSH2 0x0701 0BD9 83 DUP4 0BDA 83 DUP4 0BDB 61 PUSH2 0x1687 0BDE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BD6 stack[0] = 0x0701 // @0BD9 stack[1] = stack[-3] // @0BDA stack[2] = stack[-2] // } // Block ends with call to 0x1687, returns to 0x0701 label_0BDF: // Incoming call from 0x114F, returns to 0x1150 // Incoming call from 0x1A3F, returns to 0x1A40 // Incoming jump from 0x04D6 // Incoming call from 0x11D5, returns to 0x11D6 // Inputs[6] // { // @0BE2 stack[-2] // @0BF0 memory[0x00:0x40] // @0BF9 stack[-1] // @0C03 memory[0x00:0x40] // @0C04 storage[keccak256(memory[0x00:0x40])] // @0C08 stack[-3] // } 0BDF 5B JUMPDEST 0BE0 60 PUSH1 0x00 0BE2 91 SWAP2 0BE3 82 DUP3 0BE4 52 MSTORE 0BE5 60 PUSH1 0x97 0BE7 60 PUSH1 0x20 0BE9 90 SWAP1 0BEA 81 DUP2 0BEB 52 MSTORE 0BEC 60 PUSH1 0x40 0BEE 80 DUP1 0BEF 84 DUP5 0BF0 20 SHA3 0BF1 60 PUSH1 0x01 0BF3 60 PUSH1 0x01 0BF5 60 PUSH1 0xa0 0BF7 1B SHL 0BF8 03 SUB 0BF9 93 SWAP4 0BFA 90 SWAP1 0BFB 93 SWAP4 0BFC 16 AND 0BFD 84 DUP5 0BFE 52 MSTORE 0BFF 91 SWAP2 0C00 90 SWAP1 0C01 52 MSTORE 0C02 90 SWAP1 0C03 20 SHA3 0C04 54 SLOAD 0C05 60 PUSH1 0xff 0C07 16 AND 0C08 90 SWAP1 0C09 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0BE4 memory[0x00:0x20] = stack[-2] // @0BEB memory[0x20:0x40] = 0x97 // @0BFE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0C01 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0C08 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C0A: // Incoming call from 0x04EB, returns to 0x0232 0C0A 5B JUMPDEST 0C0B 60 PUSH1 0x60 0C0D 61 PUSH2 0x0c14 0C10 61 PUSH2 0x0dd4 0C13 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C0B stack[0] = 0x60 // @0C0D stack[1] = 0x0c14 // } // Block ends with call to 0x0dd4, returns to 0x0C14 label_0C14: // Incoming return from call to 0x0DD4 at 0x0C13 // Inputs[2] // { // @0C17 stack[-1] // @0C19 storage[0x03 + stack[-1]] // } 0C14 5B JUMPDEST 0C15 60 PUSH1 0x03 0C17 01 ADD 0C18 80 DUP1 0C19 54 SLOAD 0C1A 61 PUSH2 0x061d 0C1D 90 SWAP1 0C1E 61 PUSH2 0x296b 0C21 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C17 stack[-1] = 0x03 + stack[-1] // @0C1D stack[1] = storage[0x03 + stack[-1]] // @0C1D stack[0] = 0x061d // } // Block ends with call to 0x296b, returns to 0x061D label_0C22: // Incoming jump from 0x0520 // Inputs[1] { @0C23 stack[-2] } 0C22 5B JUMPDEST 0C23 81 DUP2 0C24 61 PUSH2 0x0c2c 0C27 81 DUP2 0C28 61 PUSH2 0x0e41 0C2B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C23 stack[0] = stack[-2] // @0C24 stack[1] = 0x0c2c // @0C27 stack[2] = stack[-2] // } // Block ends with call to 0x0e41, returns to 0x0C2C label_0C2C: // Incoming return from call to 0x0E41 at 0x0C2B // Inputs[2] // { // @0C30 stack[-3] // @0C31 stack[-2] // } 0C2C 5B JUMPDEST 0C2D 61 PUSH2 0x0701 0C30 83 DUP4 0C31 83 DUP4 0C32 61 PUSH2 0x170e 0C35 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C2D stack[0] = 0x0701 // @0C30 stack[1] = stack[-3] // @0C31 stack[2] = stack[-2] // } // Block ends with call to 0x170e, returns to 0x0701 label_0C36: // Incoming jump from 0x0533 // Incoming jump from 0x13C0 // Inputs[2] // { // @0C37 stack[-4] // @0C42 msg.sender // } 0C36 5B JUMPDEST 0C37 83 DUP4 0C38 60 PUSH1 0x01 0C3A 60 PUSH1 0x01 0C3C 60 PUSH1 0xa0 0C3E 1B SHL 0C3F 03 SUB 0C40 81 DUP2 0C41 16 AND 0C42 33 CALLER 0C43 14 EQ 0C44 61 PUSH2 0x0c50 0C47 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C37 stack[0] = stack[-4] } // Block ends with conditional jump to 0x0c50, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 label_0C48: // Incoming jump from 0x0C47, if not msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C4B msg.sender } 0C48 61 PUSH2 0x0c50 0C4B 33 CALLER 0C4C 61 PUSH2 0x0e41 0C4F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C48 stack[0] = 0x0c50 // @0C4B stack[1] = msg.sender // } // Block ends with call to 0x0e41, returns to 0x0C50 label_0C50: // Incoming jump from 0x0C47, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0E41 at 0x0C4F // Inputs[4] // { // @0C54 stack[-5] // @0C55 stack[-4] // @0C56 stack[-3] // @0C57 stack[-2] // } 0C50 5B JUMPDEST 0C51 61 PUSH2 0x0c5c 0C54 85 DUP6 0C55 85 DUP6 0C56 85 DUP6 0C57 85 DUP6 0C58 61 PUSH2 0x178b 0C5B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0C51 stack[0] = 0x0c5c // @0C54 stack[1] = stack[-5] // @0C55 stack[2] = stack[-4] // @0C56 stack[3] = stack[-3] // @0C57 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x178b 0C5C 5B JUMPDEST 0C5D 50 POP 0C5E 50 POP 0C5F 50 POP 0C60 50 POP 0C61 50 POP 0C62 56 *JUMP label_0C63: // Incoming jump from 0x0553 // Inputs[1] { @0C69 stack[-1] } 0C63 5B JUMPDEST 0C64 60 PUSH1 0x60 0C66 61 PUSH2 0x0c6e 0C69 82 DUP3 0C6A 61 PUSH2 0x0df8 0C6D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C64 stack[0] = 0x60 // @0C66 stack[1] = 0x0c6e // @0C69 stack[2] = stack[-1] // } // Block ends with call to 0x0df8, returns to 0x0C6E label_0C6E: // Incoming return from call to 0x0DF8 at 0x0C6D // Incoming return from call to 0x0DF8 at 0x0C6D // Inputs[1] { @0C72 stack[-1] } 0C6E 5B JUMPDEST 0C6F 61 PUSH2 0x0c8b 0C72 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c8b, if stack[-1] label_0C73: // Incoming jump from 0x0C72, if not stack[-1] // Inputs[3] // { // @0C75 memory[0x40:0x60] // @0C85 memory[0x40:0x60] // @0C8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C73 60 PUSH1 0x40 0C75 51 MLOAD 0C76 63 PUSH4 0x0a14c4b5 0C7B 60 PUSH1 0xe4 0C7D 1B SHL 0C7E 81 DUP2 0C7F 52 MSTORE 0C80 60 PUSH1 0x04 0C82 01 ADD 0C83 60 PUSH1 0x40 0C85 51 MLOAD 0C86 80 DUP1 0C87 91 SWAP2 0C88 03 SUB 0C89 90 SWAP1 0C8A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @0C8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C8B: // Incoming jump from 0x0C72, if stack[-1] // Inputs[1] { @0C8F stack[-2] } 0C8B 5B JUMPDEST 0C8C 61 PUSH2 0x05ff 0C8F 82 DUP3 0C90 61 PUSH2 0x17cf 0C93 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C8C stack[0] = 0x05ff // @0C8F stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x17cf label_0C94: // Incoming jump from 0x0573 // Inputs[3] // { // @0C97 stack[-2] // @0CA2 memory[0x00:0x40] // @0CA6 storage[0x01 + keccak256(memory[0x00:0x40])] // } 0C94 5B JUMPDEST 0C95 60 PUSH1 0x00 0C97 82 DUP3 0C98 81 DUP2 0C99 52 MSTORE 0C9A 60 PUSH1 0x97 0C9C 60 PUSH1 0x20 0C9E 52 MSTORE 0C9F 60 PUSH1 0x40 0CA1 90 SWAP1 0CA2 20 SHA3 0CA3 60 PUSH1 0x01 0CA5 01 ADD 0CA6 54 SLOAD 0CA7 61 PUSH2 0x0caf 0CAA 81 DUP2 0CAB 61 PUSH2 0x0f06 0CAE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0C99 memory[0x00:0x20] = stack[-2] // @0C9E memory[0x20:0x40] = 0x97 // @0CA6 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @0CA7 stack[1] = 0x0caf // @0CAA stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0f06, returns to 0x0CAF label_0CAF: // Incoming return from call to 0x0F06 at 0x0CAE // Inputs[2] // { // @0CB3 stack[-3] // @0CB4 stack[-2] // } 0CAF 5B JUMPDEST 0CB0 61 PUSH2 0x0701 0CB3 83 DUP4 0CB4 83 DUP4 0CB5 61 PUSH2 0x11cc 0CB8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CB0 stack[0] = 0x0701 // @0CB3 stack[1] = stack[-3] // @0CB4 stack[2] = stack[-2] // } // Block ends with call to 0x11cc, returns to 0x0701 label_0CB9: // Incoming jump from 0x0593 0CB9 5B JUMPDEST 0CBA 61 PUSH2 0x0cc1 0CBD 61 PUSH2 0x13c1 0CC0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CBA stack[0] = 0x0cc1 } // Block ends with call to 0x13c1, returns to 0x0CC1 label_0CC1: // Incoming return from call to 0x13C1 at 0x0CC0 // Inputs[1] { @0CC5 stack[-1] } 0CC1 5B JUMPDEST 0CC2 61 PUSH2 0x09d6 0CC5 81 DUP2 0CC6 61 PUSH2 0x1844 0CC9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CC2 stack[0] = 0x09d6 // @0CC5 stack[1] = stack[-1] // } // Block ends with call to 0x1844, returns to 0x09D6 label_0CCA: // Incoming jump from 0x05B3 0CCA 5B JUMPDEST 0CCB 60 PUSH1 0x00 0CCD 61 PUSH2 0x0cd4 0CD0 61 PUSH2 0x0dd4 0CD3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CCB stack[0] = 0x00 // @0CCD stack[1] = 0x0cd4 // } // Block ends with call to 0x0dd4, returns to 0x0CD4 label_0CD4: // Incoming return from call to 0x0DD4 at 0x0CD3 // Inputs[5] // { // @0CDD stack[-1] // @0CDE stack[-3] // @0CF2 memory[0x00:0x40] // @0CF3 storage[keccak256(memory[0x00:0x40])] // @0CF6 stack[-4] // } 0CD4 5B JUMPDEST 0CD5 60 PUSH1 0x01 0CD7 60 PUSH1 0x01 0CD9 60 PUSH1 0xa0 0CDB 1B SHL 0CDC 03 SUB 0CDD 90 SWAP1 0CDE 92 SWAP3 0CDF 16 AND 0CE0 60 PUSH1 0x00 0CE2 90 SWAP1 0CE3 81 DUP2 0CE4 52 MSTORE 0CE5 60 PUSH1 0x05 0CE7 92 SWAP3 0CE8 90 SWAP1 0CE9 92 SWAP3 0CEA 01 ADD 0CEB 60 PUSH1 0x20 0CED 52 MSTORE 0CEE 50 POP 0CEF 60 PUSH1 0x40 0CF1 90 SWAP1 0CF2 20 SHA3 0CF3 54 SLOAD 0CF4 15 ISZERO 0CF5 15 ISZERO 0CF6 90 SWAP1 0CF7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0CE4 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0CED memory[0x20:0x40] = 0x05 + stack[-1] // @0CF6 stack[-4] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0CF8: // Incoming call from 0x0FBE, returns to 0x0FBF // Incoming call from 0x19AD, returns to 0x19AE 0CF8 5B JUMPDEST 0CF9 60 PUSH1 0x00 0CFB 61 PUSH2 0x0d02 0CFE 61 PUSH2 0x0dd4 0D01 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CF9 stack[0] = 0x00 // @0CFB stack[1] = 0x0d02 // } // Block ends with call to 0x0dd4, returns to 0x0D02 label_0D02: // Incoming return from call to 0x0DD4 at 0x0D01 // Inputs[7] // { // @0D0B stack[-4] // @0D15 stack[-1] // @0D22 memory[0x00:0x40] // @0D23 stack[-3] // @0D2E memory[0x00:0x40] // @0D2F storage[keccak256(memory[0x00:0x40])] // @0D33 stack[-5] // } 0D02 5B JUMPDEST 0D03 60 PUSH1 0x01 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0xa0 0D09 1B SHL 0D0A 03 SUB 0D0B 93 SWAP4 0D0C 84 DUP5 0D0D 16 AND 0D0E 60 PUSH1 0x00 0D10 90 SWAP1 0D11 81 DUP2 0D12 52 MSTORE 0D13 60 PUSH1 0x07 0D15 91 SWAP2 0D16 90 SWAP1 0D17 91 SWAP2 0D18 01 ADD 0D19 60 PUSH1 0x20 0D1B 90 SWAP1 0D1C 81 DUP2 0D1D 52 MSTORE 0D1E 60 PUSH1 0x40 0D20 80 DUP1 0D21 83 DUP4 0D22 20 SHA3 0D23 94 SWAP5 0D24 90 SWAP1 0D25 95 SWAP6 0D26 16 AND 0D27 82 DUP3 0D28 52 MSTORE 0D29 92 SWAP3 0D2A 90 SWAP1 0D2B 92 SWAP3 0D2C 52 MSTORE 0D2D 50 POP 0D2E 20 SHA3 0D2F 54 SLOAD 0D30 60 PUSH1 0xff 0D32 16 AND 0D33 90 SWAP1 0D34 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0D12 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @0D1D memory[0x20:0x40] = 0x07 + stack[-1] // @0D28 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0D2C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D33 stack[-5] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-5] label_0D35: // Incoming jump from 0x05F3 0D35 5B JUMPDEST 0D36 61 PUSH2 0x0d3d 0D39 61 PUSH2 0x13c1 0D3C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D36 stack[0] = 0x0d3d } // Block ends with call to 0x13c1, returns to 0x0D3D label_0D3D: // Incoming return from call to 0x13C1 at 0x0D3C // Inputs[1] { @0D46 stack[-1] } 0D3D 5B JUMPDEST 0D3E 60 PUSH1 0x01 0D40 60 PUSH1 0x01 0D42 60 PUSH1 0xa0 0D44 1B SHL 0D45 03 SUB 0D46 81 DUP2 0D47 16 AND 0D48 61 PUSH2 0x0da2 0D4B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da2, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0D4C: // Incoming jump from 0x0D4B, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D4E memory[0x40:0x60] } 0D4C 60 PUSH1 0x40 0D4E 51 MLOAD 0D4F 62 PUSH3 0x461bcd 0D53 60 PUSH1 0xe5 0D55 1B SHL 0D56 81 DUP2 0D57 52 MSTORE 0D58 60 PUSH1 0x20 0D5A 60 PUSH1 0x04 0D5C 82 DUP3 0D5D 01 ADD 0D5E 52 MSTORE 0D5F 60 PUSH1 0x26 0D61 60 PUSH1 0x24 0D63 82 DUP3 0D64 01 ADD 0D65 52 MSTORE 0D66 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0D87 60 PUSH1 0x44 0D89 82 DUP3 0D8A 01 ADD 0D8B 52 MSTORE 0D8C 65 PUSH6 0x646472657373 0D93 60 PUSH1 0xd0 0D95 1B SHL 0D96 60 PUSH1 0x64 0D98 82 DUP3 0D99 01 ADD 0D9A 52 MSTORE 0D9B 60 PUSH1 0x84 0D9D 01 ADD 0D9E 61 PUSH2 0x0870 0DA1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D5E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D65 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0D8B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0D9A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0D9D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_0DA2: // Incoming jump from 0x0D4B, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DA6 stack[-1] } 0DA2 5B JUMPDEST 0DA3 61 PUSH2 0x09d6 0DA6 81 DUP2 0DA7 61 PUSH2 0x1604 0DAA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DA3 stack[0] = 0x09d6 // @0DA6 stack[1] = stack[-1] // } // Block ends with call to 0x1604, returns to 0x09D6 label_0DAB: // Incoming call from 0x05FE, returns to 0x05FF // Inputs[1] { @0DB1 stack[-1] } 0DAB 5B JUMPDEST 0DAC 60 PUSH1 0x00 0DAE 61 PUSH2 0x0db6 0DB1 82 DUP3 0DB2 61 PUSH2 0x18c8 0DB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DAC stack[0] = 0x00 // @0DAE stack[1] = 0x0db6 // @0DB1 stack[2] = stack[-1] // } // Block ends with call to 0x18c8, returns to 0x0DB6 label_0DB6: // Incoming return from call to 0x18C8 at 0x0DB5 // Inputs[1] { @0DB7 stack[-1] } 0DB6 5B JUMPDEST 0DB7 80 DUP1 0DB8 61 PUSH2 0x0dc5 0DBB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc5, if stack[-1] label_0DBC: // Incoming jump from 0x0DBB, if not stack[-1] // Inputs[1] { @0DC0 stack[-3] } 0DBC 50 POP 0DBD 61 PUSH2 0x0dc5 0DC0 82 DUP3 0DC1 61 PUSH2 0x1916 0DC4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0DBD stack[-1] = 0x0dc5 // @0DC0 stack[0] = stack[-3] // } // Block ends with call to 0x1916, returns to 0x0DC5 label_0DC5: // Incoming jump from 0x0DBB, if stack[-1] // Incoming return from call to 0x1916 at 0x0DC4 // Inputs[1] { @0DC6 stack[-1] } 0DC5 5B JUMPDEST 0DC6 80 DUP1 0DC7 61 PUSH2 0x05ff 0DCA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ff, if stack[-1] label_0DCB: // Incoming jump from 0x0DCA, if not stack[-1] // Inputs[1] { @0DCF stack[-3] } 0DCB 50 POP 0DCC 61 PUSH2 0x05ff 0DCF 82 DUP3 0DD0 61 PUSH2 0x194c 0DD3 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0DCC stack[-1] = 0x05ff // @0DCF stack[0] = stack[-3] // } // Block ends with call to 0x194c, returns to 0x05FF label_0DD4: // Incoming call from 0x0E0D, returns to 0x0E0E // Incoming call from 0x143F, returns to 0x1440 // Incoming call from 0x14F1, returns to 0x14F2 // Incoming call from 0x186C, returns to 0x186D // Incoming call from 0x0D01, returns to 0x0D02 // Incoming call from 0x1A9B, returns to 0x1A9C // Incoming call from 0x144C, returns to 0x144D // Incoming call from 0x0B72, returns to 0x0B73 // Incoming call from 0x1466, returns to 0x1467 // Incoming call from 0x19D3, returns to 0x19D4 // Incoming call from 0x0CD3, returns to 0x0CD4 // Incoming call from 0x06CF, returns to 0x06D0 // Incoming call from 0x1523, returns to 0x1524 // Incoming call from 0x0C13, returns to 0x0C14 // Incoming call from 0x0E25, returns to 0x0E26 // Incoming call from 0x060E, returns to 0x060F // Incoming call from 0x0735, returns to 0x0736 // Incoming call from 0x154B, returns to 0x154C // Incoming call from 0x0729, returns to 0x072A // Incoming call from 0x1716, returns to 0x1717 // Inputs[1] { @0DF6 stack[-1] } 0DD4 5B JUMPDEST 0DD5 7F PUSH32 0x2569078dfb4b0305704d3008e7403993ae9601b85f7ae5e742de3de8f8011c40 0DF6 90 SWAP1 0DF7 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DF6 stack[-1] = 0x2569078dfb4b0305704d3008e7403993ae9601b85f7ae5e742de3de8f8011c40 } // Block ends with unconditional jump to stack[-1] label_0DF8: // Incoming call from 0x06AA, returns to 0x06AB // Incoming call from 0x0C6D, returns to 0x0C6E // Inputs[1] { @0DFB stack[-1] } 0DF8 5B JUMPDEST 0DF9 60 PUSH1 0x00 0DFB 81 DUP2 0DFC 60 PUSH1 0x01 0DFE 11 GT 0DFF 15 ISZERO 0E00 80 DUP1 0E01 15 ISZERO 0E02 61 PUSH2 0x0e12 0E05 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0DF9 stack[0] = 0x00 // @0DFF stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x0e12, if !!(0x01 > stack[-1]) label_0E06: // Incoming jump from 0x0E05, if not !!(0x01 > stack[-1]) 0E06 50 POP 0E07 61 PUSH2 0x0e0e 0E0A 61 PUSH2 0x0dd4 0E0D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E07 stack[-1] = 0x0e0e } // Block ends with call to 0x0dd4, returns to 0x0E0E label_0E0E: // Incoming return from call to 0x0DD4 at 0x0E0D // Inputs[3] // { // @0E0F stack[-1] // @0E0F storage[stack[-1]] // @0E10 stack[-3] // } 0E0E 5B JUMPDEST 0E0F 54 SLOAD 0E10 82 DUP3 0E11 10 LT // Stack delta = +0 // Outputs[1] { @0E11 stack[-1] = stack[-3] < storage[stack[-1]] } // Block continues label_0E12: // Incoming jump from 0x0E11 // Incoming jump from 0x0E05, if !!(0x01 > stack[-1]) // Inputs[1] { @0E13 stack[-1] } 0E12 5B JUMPDEST 0E13 80 DUP1 0E14 15 ISZERO 0E15 61 PUSH2 0x05ff 0E18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ff, if !stack[-1] label_0E19: // Incoming jump from 0x0E18, if not !stack[-1] 0E19 50 POP 0E1A 60 PUSH1 0x01 0E1C 60 PUSH1 0xe0 0E1E 1B SHL 0E1F 61 PUSH2 0x0e26 0E22 61 PUSH2 0x0dd4 0E25 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0E1E stack[-1] = 0x01 << 0xe0 // @0E1F stack[0] = 0x0e26 // } // Block ends with call to 0x0dd4, returns to 0x0E26 label_0E26: // Incoming return from call to 0x0DD4 at 0x0E25 // Inputs[6] // { // @0E29 stack[-4] // @0E2E stack[-1] // @0E38 memory[0x00:0x40] // @0E39 storage[keccak256(memory[0x00:0x40])] // @0E3A stack[-2] // @0E3C stack[-5] // } 0E26 5B JUMPDEST 0E27 60 PUSH1 0x00 0E29 84 DUP5 0E2A 81 DUP2 0E2B 52 MSTORE 0E2C 60 PUSH1 0x04 0E2E 91 SWAP2 0E2F 90 SWAP1 0E30 91 SWAP2 0E31 01 ADD 0E32 60 PUSH1 0x20 0E34 52 MSTORE 0E35 60 PUSH1 0x40 0E37 90 SWAP1 0E38 20 SHA3 0E39 54 SLOAD 0E3A 16 AND 0E3B 15 ISZERO 0E3C 92 SWAP3 0E3D 91 SWAP2 0E3E 50 POP 0E3F 50 POP 0E40 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0E2B memory[0x00:0x20] = stack[-4] // @0E34 memory[0x20:0x40] = 0x04 + stack[-1] // @0E3C stack[-5] = !(storage[keccak256(memory[0x00:0x40])] & stack[-2]) // } // Block ends with unconditional jump to stack[-5] label_0E41: // Incoming call from 0x06F6, returns to 0x06F7 // Incoming call from 0x0C2B, returns to 0x0C2C // Incoming call from 0x0C4F, returns to 0x0C50 // Incoming call from 0x0757, returns to 0x0758 // Incoming call from 0x09B9, returns to 0x09BA // Inputs[1] { @0E51 address(0xaaeb6d7670e522a718067333cd4e).code.length } 0E41 5B JUMPDEST 0E42 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0E51 3B EXTCODESIZE 0E52 15 ISZERO 0E53 61 PUSH2 0x09d6 0E56 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d6, if !address(0xaaeb6d7670e522a718067333cd4e).code.length label_0E57: // Incoming jump from 0x0E56, if not !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[7] // { // @0E59 memory[0x40:0x60] // @0E64 address(this) // @0E72 stack[-1] // @0E96 memory[0x40:0x60] // @0E9C msg.gas // @0E9D address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0E9D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E57 60 PUSH1 0x40 0E59 51 MLOAD 0E5A 63 PUSH4 0x3185c44d 0E5F 60 PUSH1 0xe2 0E61 1B SHL 0E62 81 DUP2 0E63 52 MSTORE 0E64 30 ADDRESS 0E65 60 PUSH1 0x04 0E67 82 DUP3 0E68 01 ADD 0E69 52 MSTORE 0E6A 60 PUSH1 0x01 0E6C 60 PUSH1 0x01 0E6E 60 PUSH1 0xa0 0E70 1B SHL 0E71 03 SUB 0E72 82 DUP3 0E73 16 AND 0E74 60 PUSH1 0x24 0E76 82 DUP3 0E77 01 ADD 0E78 52 MSTORE 0E79 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0E88 90 SWAP1 0E89 63 PUSH4 0xc6171134 0E8E 90 SWAP1 0E8F 60 PUSH1 0x44 0E91 01 ADD 0E92 60 PUSH1 0x20 0E94 60 PUSH1 0x40 0E96 51 MLOAD 0E97 80 DUP1 0E98 83 DUP4 0E99 03 SUB 0E9A 81 DUP2 0E9B 86 DUP7 0E9C 5A GAS 0E9D FA STATICCALL 0E9E 15 ISZERO 0E9F 80 DUP1 0EA0 15 ISZERO 0EA1 61 PUSH2 0x0eae 0EA4 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @0E63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3185c44d << 0xe2 // @0E69 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0E78 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0E88 stack[0] = 0xaaeb6d7670e522a718067333cd4e // @0E8E stack[1] = 0xc6171134 // @0E91 stack[2] = 0x44 + memory[0x40:0x60] // @0E9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0E9E stack[3] = !address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0eae, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0EA5: // Incoming jump from 0x0EA4, if not !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0EA5 returndata.length // @0EA9 returndata[0x00:0x00 + returndata.length] // @0EAA returndata.length // @0EAD memory[0x00:0x00 + returndata.length] // } 0EA5 3D RETURNDATASIZE 0EA6 60 PUSH1 0x00 0EA8 80 DUP1 0EA9 3E RETURNDATACOPY 0EAA 3D RETURNDATASIZE 0EAB 60 PUSH1 0x00 0EAD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EA9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0EAD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0EAE: // Incoming jump from 0x0EA4, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @0EB5 memory[0x40:0x60] // @0EB6 returndata.length // } 0EAE 5B JUMPDEST 0EAF 50 POP 0EB0 50 POP 0EB1 50 POP 0EB2 50 POP 0EB3 60 PUSH1 0x40 0EB5 51 MLOAD 0EB6 3D RETURNDATASIZE 0EB7 60 PUSH1 0x1f 0EB9 19 NOT 0EBA 60 PUSH1 0x1f 0EBC 82 DUP3 0EBD 01 ADD 0EBE 16 AND 0EBF 82 DUP3 0EC0 01 ADD 0EC1 80 DUP1 0EC2 60 PUSH1 0x40 0EC4 52 MSTORE 0EC5 50 POP 0EC6 81 DUP2 0EC7 01 ADD 0EC8 90 SWAP1 0EC9 61 PUSH2 0x0ed2 0ECC 91 SWAP2 0ECD 90 SWAP1 0ECE 61 PUSH2 0x2a2b 0ED1 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0EC4 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0ECC stack[-4] = 0x0ed2 // @0ECD stack[-2] = memory[0x40:0x60] // @0ECD stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2a2b, returns to 0x0ED2 label_0ED2: // Incoming return from call to 0x2A2B at 0x0ED1 // Inputs[1] { @0ED6 stack[-1] } 0ED2 5B JUMPDEST 0ED3 61 PUSH2 0x09d6 0ED6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09d6, if stack[-1] label_0ED7: // Incoming jump from 0x0ED6, if not stack[-1] // Inputs[2] // { // @0ED9 memory[0x40:0x60] // @0EEC stack[-1] // } 0ED7 60 PUSH1 0x40 0ED9 51 MLOAD 0EDA 63 PUSH4 0x3b79c773 0EDF 60 PUSH1 0xe2 0EE1 1B SHL 0EE2 81 DUP2 0EE3 52 MSTORE 0EE4 60 PUSH1 0x01 0EE6 60 PUSH1 0x01 0EE8 60 PUSH1 0xa0 0EEA 1B SHL 0EEB 03 SUB 0EEC 82 DUP3 0EED 16 AND 0EEE 60 PUSH1 0x04 0EF0 82 DUP3 0EF1 01 ADD 0EF2 52 MSTORE 0EF3 60 PUSH1 0x24 0EF5 01 ADD 0EF6 61 PUSH2 0x0870 0EF9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0EE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b79c773 << 0xe2 // @0EF2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0EF5 stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_0EFA: // Incoming call from 0x0700, returns to 0x0701 // Inputs[2] // { // @0EFE stack[-2] // @0EFF stack[-1] // } 0EFA 5B JUMPDEST 0EFB 61 PUSH2 0x071a 0EFE 82 DUP3 0EFF 82 DUP3 0F00 60 PUSH1 0x01 0F02 61 PUSH2 0x1981 0F05 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EFB stack[0] = 0x071a // @0EFE stack[1] = stack[-2] // @0EFF stack[2] = stack[-1] // @0F00 stack[3] = 0x01 // } // Block ends with call to 0x1981, returns to 0x071A label_0F06: // Incoming call from 0x0CAE, returns to 0x0CAF // Incoming call from 0x07F9, returns to 0x07FA // Incoming call from 0x0BD4, returns to 0x0BD5 // Inputs[2] // { // @0F0A stack[-1] // @0F0B msg.sender // } 0F06 5B JUMPDEST 0F07 61 PUSH2 0x09d6 0F0A 81 DUP2 0F0B 33 CALLER 0F0C 61 PUSH2 0x1a36 0F0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F07 stack[0] = 0x09d6 // @0F0A stack[1] = stack[-1] // @0F0B stack[2] = msg.sender // } // Block ends with call to 0x1a36, returns to 0x09D6 0F10 5B JUMPDEST 0F11 80 DUP1 0F12 51 MLOAD 0F13 61 PUSH2 0x071a 0F16 90 SWAP1 0F17 7F PUSH32 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c1 0F38 90 SWAP1 0F39 60 PUSH1 0x20 0F3B 84 DUP5 0F3C 01 ADD 0F3D 90 SWAP1 0F3E 61 PUSH2 0x22a2 0F41 56 *JUMP label_0F42: // Incoming jump from 0x0762 // Inputs[1] { @0F48 stack[-1] } 0F42 5B JUMPDEST 0F43 60 PUSH1 0x00 0F45 61 PUSH2 0x0f4d 0F48 82 DUP3 0F49 61 PUSH2 0x14e0 0F4C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F43 stack[0] = 0x00 // @0F45 stack[1] = 0x0f4d // @0F48 stack[2] = stack[-1] // } // Block ends with call to 0x14e0, returns to 0x0F4D label_0F4D: // Incoming return from call to 0x14E0 at 0x0F4C // Inputs[3] // { // @0F4E stack[-1] // @0F4E stack[-2] // @0F50 stack[-5] // } 0F4D 5B JUMPDEST 0F4E 90 SWAP1 0F4F 50 POP 0F50 83 DUP4 0F51 60 PUSH1 0x01 0F53 60 PUSH1 0x01 0F55 60 PUSH1 0xa0 0F57 1B SHL 0F58 03 SUB 0F59 16 AND 0F5A 81 DUP2 0F5B 60 PUSH1 0x01 0F5D 60 PUSH1 0x01 0F5F 60 PUSH1 0xa0 0F61 1B SHL 0F62 03 SUB 0F63 16 AND 0F64 14 EQ 0F65 61 PUSH2 0x0f80 0F68 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0F4E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0f80, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0F69: // Incoming jump from 0x0F68, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0F6B memory[0x40:0x60] // @0F7A memory[0x40:0x60] // @0F7F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F69 60 PUSH1 0x40 0F6B 51 MLOAD 0F6C 62 PUSH3 0xa11481 0F70 60 PUSH1 0xe8 0F72 1B SHL 0F73 81 DUP2 0F74 52 MSTORE 0F75 60 PUSH1 0x04 0F77 01 ADD 0F78 60 PUSH1 0x40 0F7A 51 MLOAD 0F7B 80 DUP1 0F7C 91 SWAP2 0F7D 03 SUB 0F7E 90 SWAP1 0F7F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @0F7F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F80: // Incoming jump from 0x0F68, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @0F87 stack[-2] } 0F80 5B JUMPDEST 0F81 60 PUSH1 0x00 0F83 80 DUP1 0F84 61 PUSH2 0x0f8c 0F87 84 DUP5 0F88 61 PUSH2 0x1a8f 0F8B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F81 stack[0] = 0x00 // @0F83 stack[1] = 0x00 // @0F84 stack[2] = 0x0f8c // @0F87 stack[3] = stack[-2] // } // Block ends with call to 0x1a8f, returns to 0x0F8C label_0F8C: // Incoming return from call to 0x1A8F at 0x0F8B // Inputs[6] // { // @0F8D stack[-3] // @0F8D stack[-1] // @0F8F stack[-2] // @0F8F stack[-4] // @0F95 stack[-8] // @0F99 msg.sender // } 0F8C 5B JUMPDEST 0F8D 91 SWAP2 0F8E 50 POP 0F8F 91 SWAP2 0F90 50 POP 0F91 61 PUSH2 0x0fb1 0F94 81 DUP2 0F95 87 DUP8 0F96 61 PUSH2 0x0f9c 0F99 33 CALLER 0F9A 90 SWAP1 0F9B 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0F8D stack[-3] = stack[-1] // @0F8F stack[-4] = stack[-2] // @0F91 stack[-2] = 0x0fb1 // @0F94 stack[-1] = stack[-1] // @0F95 stack[0] = stack[-8] // @0F9A stack[1] = msg.sender // } // Block ends with call to 0x0f9c, returns to 0x0FB1 label_0F9C: // Incoming call from 0x0F9B, returns to 0x0FB1 // Inputs[4] // { // @0FA5 stack[-1] // @0FA8 stack[-2] // @0FAC stack[-3] // @0FAF stack[-4] // } 0F9C 5B JUMPDEST 0F9D 60 PUSH1 0x01 0F9F 60 PUSH1 0x01 0FA1 60 PUSH1 0xa0 0FA3 1B SHL 0FA4 03 SUB 0FA5 90 SWAP1 0FA6 81 DUP2 0FA7 16 AND 0FA8 91 SWAP2 0FA9 16 AND 0FAA 81 DUP2 0FAB 14 EQ 0FAC 91 SWAP2 0FAD 14 EQ 0FAE 17 OR 0FAF 90 SWAP1 0FB0 56 *JUMP // Stack delta = -3 // Outputs[1] { @0FAF stack[-4] = (stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) | ((0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] & (0x01 << 0xa0) - 0x01) } // Block ends with unconditional jump to stack[-4] label_0FB1: // Incoming return from call to 0x0F9C at 0x0F9B // Inputs[1] { @0FB5 stack[-1] } 0FB1 5B JUMPDEST 0FB2 61 PUSH2 0x0fdc 0FB5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fdc, if stack[-1] label_0FB6: // Incoming jump from 0x0FB5, if not stack[-1] // Inputs[2] // { // @0FB9 stack[-6] // @0FBA msg.sender // } 0FB6 61 PUSH2 0x0fbf 0FB9 86 DUP7 0FBA 33 CALLER 0FBB 61 PUSH2 0x0cf8 0FBE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FB6 stack[0] = 0x0fbf // @0FB9 stack[1] = stack[-6] // @0FBA stack[2] = msg.sender // } // Block ends with call to 0x0cf8, returns to 0x0FBF label_0FBF: // Incoming return from call to 0x0CF8 at 0x0FBE // Inputs[1] { @0FC3 stack[-1] } 0FBF 5B JUMPDEST 0FC0 61 PUSH2 0x0fdc 0FC3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fdc, if stack[-1] label_0FC4: // Incoming jump from 0x0FC3, if not stack[-1] // Inputs[3] // { // @0FC6 memory[0x40:0x60] // @0FD6 memory[0x40:0x60] // @0FDB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FC4 60 PUSH1 0x40 0FC6 51 MLOAD 0FC7 63 PUSH4 0x2ce44b5f 0FCC 60 PUSH1 0xe1 0FCE 1B SHL 0FCF 81 DUP2 0FD0 52 MSTORE 0FD1 60 PUSH1 0x04 0FD3 01 ADD 0FD4 60 PUSH1 0x40 0FD6 51 MLOAD 0FD7 80 DUP1 0FD8 91 SWAP2 0FD9 03 SUB 0FDA 90 SWAP1 0FDB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @0FDB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FDC: // Incoming jump from 0x0FC3, if stack[-1] // Incoming jump from 0x0FB5, if stack[-1] // Inputs[1] { @0FE5 stack[-5] } 0FDC 5B JUMPDEST 0FDD 60 PUSH1 0x01 0FDF 60 PUSH1 0x01 0FE1 60 PUSH1 0xa0 0FE3 1B SHL 0FE4 03 SUB 0FE5 85 DUP6 0FE6 16 AND 0FE7 61 PUSH2 0x1003 0FEA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1003, if stack[-5] & (0x01 << 0xa0) - 0x01 label_0FEB: // Incoming jump from 0x0FEA, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0FED memory[0x40:0x60] // @0FFD memory[0x40:0x60] // @1002 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FEB 60 PUSH1 0x40 0FED 51 MLOAD 0FEE 63 PUSH4 0x3a954ecd 0FF3 60 PUSH1 0xe2 0FF5 1B SHL 0FF6 81 DUP2 0FF7 52 MSTORE 0FF8 60 PUSH1 0x04 0FFA 01 ADD 0FFB 60 PUSH1 0x40 0FFD 51 MLOAD 0FFE 80 DUP1 0FFF 91 SWAP2 1000 03 SUB 1001 90 SWAP1 1002 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @1002 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1003: // Incoming jump from 0x0FEA, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1007 stack[-6] // @1008 stack[-5] // @1009 stack[-4] // } 1003 5B JUMPDEST 1004 61 PUSH2 0x1010 1007 86 DUP7 1008 86 DUP7 1009 86 DUP7 100A 60 PUSH1 0x01 100C 61 PUSH2 0x1ab7 100F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1004 stack[0] = 0x1010 // @1007 stack[1] = stack[-6] // @1008 stack[2] = stack[-5] // @1009 stack[3] = stack[-4] // @100A stack[4] = 0x01 // } // Block ends with unconditional jump to 0x1ab7 1010 5B JUMPDEST 1011 80 DUP1 1012 15 ISZERO 1013 61 PUSH2 0x101b 1016 57 *JUMPI 1017 60 PUSH1 0x00 1019 82 DUP3 101A 55 SSTORE 101B 5B JUMPDEST 101C 61 PUSH2 0x1023 101F 61 PUSH2 0x0dd4 1022 56 *JUMP 1023 5B JUMPDEST 1024 60 PUSH1 0x01 1026 60 PUSH1 0x01 1028 60 PUSH1 0xa0 102A 1B SHL 102B 03 SUB 102C 87 DUP8 102D 16 AND 102E 60 PUSH1 0x00 1030 90 SWAP1 1031 81 DUP2 1032 52 MSTORE 1033 60 PUSH1 0x05 1035 91 SWAP2 1036 90 SWAP1 1037 91 SWAP2 1038 01 ADD 1039 60 PUSH1 0x20 103B 52 MSTORE 103C 60 PUSH1 0x40 103E 90 SWAP1 103F 20 SHA3 1040 80 DUP1 1041 54 SLOAD 1042 60 PUSH1 0x00 1044 19 NOT 1045 01 ADD 1046 90 SWAP1 1047 55 SSTORE 1048 61 PUSH2 0x104f 104B 61 PUSH2 0x0dd4 104E 56 *JUMP 104F 5B JUMPDEST 1050 60 PUSH1 0x01 1052 60 PUSH1 0x01 1054 60 PUSH1 0xa0 1056 1B SHL 1057 03 SUB 1058 86 DUP7 1059 16 AND 105A 60 PUSH1 0x00 105C 81 DUP2 105D 81 DUP2 105E 52 MSTORE 105F 60 PUSH1 0x05 1061 92 SWAP3 1062 90 SWAP1 1063 92 SWAP3 1064 01 ADD 1065 60 PUSH1 0x20 1067 52 MSTORE 1068 60 PUSH1 0x40 106A 90 SWAP1 106B 91 SWAP2 106C 20 SHA3 106D 80 DUP1 106E 54 SLOAD 106F 60 PUSH1 0x01 1071 01 ADD 1072 90 SWAP1 1073 55 SSTORE 1074 42 TIMESTAMP 1075 60 PUSH1 0xa0 1077 1B SHL 1078 17 OR 1079 60 PUSH1 0x01 107B 60 PUSH1 0xe1 107D 1B SHL 107E 17 OR 107F 61 PUSH2 0x1086 1082 61 PUSH2 0x0dd4 1085 56 *JUMP 1086 5B JUMPDEST 1087 60 PUSH1 0x00 1089 86 DUP7 108A 81 DUP2 108B 52 MSTORE 108C 60 PUSH1 0x04 108E 91 SWAP2 108F 90 SWAP1 1090 91 SWAP2 1091 01 ADD 1092 60 PUSH1 0x20 1094 52 MSTORE 1095 60 PUSH1 0x40 1097 81 DUP2 1098 20 SHA3 1099 91 SWAP2 109A 90 SWAP1 109B 91 SWAP2 109C 55 SSTORE 109D 60 PUSH1 0x01 109F 60 PUSH1 0xe1 10A1 1B SHL 10A2 84 DUP5 10A3 16 AND 10A4 90 SWAP1 10A5 03 SUB 10A6 61 PUSH2 0x10fc 10A9 57 *JUMPI 10AA 60 PUSH1 0x01 10AC 84 DUP5 10AD 01 ADD 10AE 61 PUSH2 0x10b5 10B1 61 PUSH2 0x0dd4 10B4 56 *JUMP 10B5 5B JUMPDEST 10B6 60 PUSH1 0x00 10B8 82 DUP3 10B9 81 DUP2 10BA 52 MSTORE 10BB 60 PUSH1 0x04 10BD 91 SWAP2 10BE 90 SWAP1 10BF 91 SWAP2 10C0 01 ADD 10C1 60 PUSH1 0x20 10C3 52 MSTORE 10C4 60 PUSH1 0x40 10C6 81 DUP2 10C7 20 SHA3 10C8 54 SLOAD 10C9 90 SWAP1 10CA 03 SUB 10CB 61 PUSH2 0x10fa 10CE 57 *JUMPI 10CF 61 PUSH2 0x10d6 10D2 61 PUSH2 0x0dd4 10D5 56 *JUMP 10D6 5B JUMPDEST 10D7 54 SLOAD 10D8 81 DUP2 10D9 14 EQ 10DA 61 PUSH2 0x10fa 10DD 57 *JUMPI 10DE 83 DUP4 10DF 61 PUSH2 0x10e6 10E2 61 PUSH2 0x0dd4 10E5 56 *JUMP 10E6 5B JUMPDEST 10E7 60 PUSH1 0x00 10E9 83 DUP4 10EA 81 DUP2 10EB 52 MSTORE 10EC 60 PUSH1 0x04 10EE 91 SWAP2 10EF 90 SWAP1 10F0 91 SWAP2 10F1 01 ADD 10F2 60 PUSH1 0x20 10F4 52 MSTORE 10F5 60 PUSH1 0x40 10F7 90 SWAP1 10F8 20 SHA3 10F9 55 SSTORE 10FA 5B JUMPDEST 10FB 50 POP 10FC 5B JUMPDEST 10FD 83 DUP4 10FE 85 DUP6 10FF 60 PUSH1 0x01 1101 60 PUSH1 0x01 1103 60 PUSH1 0xa0 1105 1B SHL 1106 03 SUB 1107 16 AND 1108 87 DUP8 1109 60 PUSH1 0x01 110B 60 PUSH1 0x01 110D 60 PUSH1 0xa0 110F 1B SHL 1110 03 SUB 1111 16 AND 1112 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1133 60 PUSH1 0x40 1135 51 MLOAD 1136 60 PUSH1 0x40 1138 51 MLOAD 1139 80 DUP1 113A 91 SWAP2 113B 03 SUB 113C 90 SWAP1 113D A4 LOG4 113E 5B JUMPDEST 113F 50 POP 1140 50 POP 1141 50 POP 1142 50 POP 1143 50 POP 1144 50 POP 1145 56 *JUMP label_1146: // Incoming call from 0x0803, returns to 0x0701 // Inputs[2] // { // @114A stack[-2] // @114B stack[-1] // } 1146 5B JUMPDEST 1147 61 PUSH2 0x1150 114A 82 DUP3 114B 82 DUP3 114C 61 PUSH2 0x0bdf 114F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1147 stack[0] = 0x1150 // @114A stack[1] = stack[-2] // @114B stack[2] = stack[-1] // } // Block ends with call to 0x0bdf, returns to 0x1150 label_1150: // Incoming return from call to 0x0BDF at 0x114F // Inputs[1] { @1154 stack[-1] } 1150 5B JUMPDEST 1151 61 PUSH2 0x071a 1154 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x071a, if stack[-1] label_1155: // Incoming jump from 0x1154, if not stack[-1] // Inputs[6] // { // @1157 stack[-2] // @1165 memory[0x00:0x40] // @116E stack[-1] // @1176 memory[0x00:0x40] // @1178 storage[keccak256(memory[0x00:0x40])] // @1185 msg.sender // } 1155 60 PUSH1 0x00 1157 82 DUP3 1158 81 DUP2 1159 52 MSTORE 115A 60 PUSH1 0x97 115C 60 PUSH1 0x20 115E 90 SWAP1 115F 81 DUP2 1160 52 MSTORE 1161 60 PUSH1 0x40 1163 80 DUP1 1164 83 DUP4 1165 20 SHA3 1166 60 PUSH1 0x01 1168 60 PUSH1 0x01 116A 60 PUSH1 0xa0 116C 1B SHL 116D 03 SUB 116E 85 DUP6 116F 16 AND 1170 84 DUP5 1171 52 MSTORE 1172 90 SWAP1 1173 91 SWAP2 1174 52 MSTORE 1175 90 SWAP1 1176 20 SHA3 1177 80 DUP1 1178 54 SLOAD 1179 60 PUSH1 0xff 117B 19 NOT 117C 16 AND 117D 60 PUSH1 0x01 117F 17 OR 1180 90 SWAP1 1181 55 SSTORE 1182 61 PUSH2 0x1188 1185 33 CALLER 1186 90 SWAP1 1187 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1159 memory[0x00:0x20] = stack[-2] // @1160 memory[0x20:0x40] = 0x97 // @1171 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1174 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1181 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1186 stack[0] = msg.sender // } // Block ends with unconditional jump to 0x1188 label_1188: // Incoming jump from 0x1187 // Inputs[7] // { // @1191 stack[-1] // @1192 stack[-2] // @119C stack[-3] // @11C0 memory[0x40:0x60] // @11C3 memory[0x40:0x60] // @11C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @11CB stack[-4] // } 1188 5B JUMPDEST 1189 60 PUSH1 0x01 118B 60 PUSH1 0x01 118D 60 PUSH1 0xa0 118F 1B SHL 1190 03 SUB 1191 16 AND 1192 81 DUP2 1193 60 PUSH1 0x01 1195 60 PUSH1 0x01 1197 60 PUSH1 0xa0 1199 1B SHL 119A 03 SUB 119B 16 AND 119C 83 DUP4 119D 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 11BE 60 PUSH1 0x40 11C0 51 MLOAD 11C1 60 PUSH1 0x40 11C3 51 MLOAD 11C4 80 DUP1 11C5 91 SWAP2 11C6 03 SUB 11C7 90 SWAP1 11C8 A4 LOG4 11C9 50 POP 11CA 50 POP 11CB 56 *JUMP // Stack delta = -4 // Outputs[1] { @11C8 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_11CC: // Incoming call from 0x0CB8, returns to 0x0701 // Incoming call from 0x0882, returns to 0x071A // Inputs[2] // { // @11D0 stack[-2] // @11D1 stack[-1] // } 11CC 5B JUMPDEST 11CD 61 PUSH2 0x11d6 11D0 82 DUP3 11D1 82 DUP3 11D2 61 PUSH2 0x0bdf 11D5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11CD stack[0] = 0x11d6 // @11D0 stack[1] = stack[-2] // @11D1 stack[2] = stack[-1] // } // Block ends with call to 0x0bdf, returns to 0x11D6 label_11D6: // Incoming return from call to 0x0BDF at 0x11D5 // Inputs[1] { @11D7 stack[-1] } 11D6 5B JUMPDEST 11D7 15 ISZERO 11D8 61 PUSH2 0x071a 11DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x071a, if !stack[-1] label_11DC: // Incoming jump from 0x11DB, if not !stack[-1] // Inputs[9] // { // @11DE stack[-2] // @11EC memory[0x00:0x40] // @11F5 stack[-1] // @11FE memory[0x00:0x40] // @1200 storage[keccak256(memory[0x00:0x40])] // @1207 memory[0x40:0x60] // @1208 msg.sender // @122F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1232 stack[-3] // } 11DC 60 PUSH1 0x00 11DE 82 DUP3 11DF 81 DUP2 11E0 52 MSTORE 11E1 60 PUSH1 0x97 11E3 60 PUSH1 0x20 11E5 90 SWAP1 11E6 81 DUP2 11E7 52 MSTORE 11E8 60 PUSH1 0x40 11EA 80 DUP1 11EB 83 DUP4 11EC 20 SHA3 11ED 60 PUSH1 0x01 11EF 60 PUSH1 0x01 11F1 60 PUSH1 0xa0 11F3 1B SHL 11F4 03 SUB 11F5 85 DUP6 11F6 16 AND 11F7 80 DUP1 11F8 85 DUP6 11F9 52 MSTORE 11FA 92 SWAP3 11FB 52 MSTORE 11FC 80 DUP1 11FD 83 DUP4 11FE 20 SHA3 11FF 80 DUP1 1200 54 SLOAD 1201 60 PUSH1 0xff 1203 19 NOT 1204 16 AND 1205 90 SWAP1 1206 55 SSTORE 1207 51 MLOAD 1208 33 CALLER 1209 92 SWAP3 120A 85 DUP6 120B 91 SWAP2 120C 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 122D 91 SWAP2 122E 90 SWAP1 122F A4 LOG4 1230 50 POP 1231 50 POP 1232 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @11E0 memory[0x00:0x20] = stack[-2] // @11E7 memory[0x20:0x40] = 0x97 // @11F9 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @11FB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1206 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @122F 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_1233: // Incoming jump from 0x0950 // Incoming jump from 0x0950 // Inputs[3] // { // @1237 memory[0x00:0x20] // @1240 memory[0x00:0x20] // @1243 storage[memory[0x00:0x20]] // } 1233 5B JUMPDEST 1234 60 PUSH1 0x00 1236 80 DUP1 1237 51 MLOAD 1238 60 PUSH1 0x20 123A 61 PUSH2 0x2ca7 123D 83 DUP4 123E 39 CODECOPY 123F 81 DUP2 1240 51 MLOAD 1241 91 SWAP2 1242 52 MSTORE 1243 54 SLOAD 1244 61 PUSH2 0x0100 1247 90 SWAP1 1248 04 DIV 1249 60 PUSH1 0xff 124B 16 AND 124C 61 PUSH2 0x1268 124F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @123E memory[0x00:0x20] = code[0x2ca7:0x2cc7] // @1242 memory[0x00:0x20] = memory[0x00:0x20] // } // Block ends with conditional jump to 0x1268, if 0xff & storage[memory[0x00:0x20]] / 0x0100 label_1250: // Incoming jump from 0x124F, if not 0xff & storage[memory[0x00:0x20]] / 0x0100 // Inputs[3] // { // @1253 memory[0x00:0x20] // @125C memory[0x00:0x20] // @125F storage[memory[0x00:0x20]] // } 1250 60 PUSH1 0x00 1252 80 DUP1 1253 51 MLOAD 1254 60 PUSH1 0x20 1256 61 PUSH2 0x2ca7 1259 83 DUP4 125A 39 CODECOPY 125B 81 DUP2 125C 51 MLOAD 125D 91 SWAP2 125E 52 MSTORE 125F 54 SLOAD 1260 60 PUSH1 0xff 1262 16 AND 1263 15 ISZERO 1264 61 PUSH2 0x126c 1267 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @125A memory[0x00:0x20] = code[0x2ca7:0x2cc7] // @125E memory[0x00:0x20] = memory[0x00:0x20] // @1263 stack[0] = !(0xff & storage[memory[0x00:0x20]]) // } // Block ends with unconditional jump to 0x126c label_1268: // Incoming jump from 0x124F, if 0xff & storage[memory[0x00:0x20]] / 0x0100 // Inputs[2] // { // @1269 address(this) // @126A address(address(this)).code.length // } 1268 5B JUMPDEST 1269 30 ADDRESS 126A 3B EXTCODESIZE 126B 15 ISZERO 126C 5B JUMPDEST 126D 61 PUSH2 0x12de 1270 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12de, if !address(address(this)).code.length label_1271: // Incoming jump from 0x1270, if not stack[-1] // Incoming jump from 0x1270, if not !address(address(this)).code.length // Inputs[1] { @1273 memory[0x40:0x60] } 1271 60 PUSH1 0x40 1273 51 MLOAD 1274 62 PUSH3 0x461bcd 1278 60 PUSH1 0xe5 127A 1B SHL 127B 81 DUP2 127C 52 MSTORE 127D 60 PUSH1 0x20 127F 60 PUSH1 0x04 1281 82 DUP3 1282 01 ADD 1283 52 MSTORE 1284 60 PUSH1 0x37 1286 60 PUSH1 0x24 1288 82 DUP3 1289 01 ADD 128A 52 MSTORE 128B 7F PUSH32 0x455243373231415f5f496e697469616c697a61626c653a20636f6e7472616374 12AC 60 PUSH1 0x44 12AE 82 DUP3 12AF 01 ADD 12B0 52 MSTORE 12B1 7F PUSH32 0x20697320616c726561647920696e697469616c697a6564000000000000000000 12D2 60 PUSH1 0x64 12D4 82 DUP3 12D5 01 ADD 12D6 52 MSTORE 12D7 60 PUSH1 0x84 12D9 01 ADD 12DA 61 PUSH2 0x0870 12DD 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @127C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1283 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @128A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x37 // @12B0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231415f5f496e697469616c697a61626c653a20636f6e7472616374 // @12D6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20697320616c726561647920696e697469616c697a6564000000000000000000 // @12D9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_12DE: // Incoming jump from 0x1270, if stack[-1] // Incoming jump from 0x1270, if !address(address(this)).code.length // Inputs[3] // { // @12E2 memory[0x00:0x20] // @12EB memory[0x00:0x20] // @12EE storage[memory[0x00:0x20]] // } 12DE 5B JUMPDEST 12DF 60 PUSH1 0x00 12E1 80 DUP1 12E2 51 MLOAD 12E3 60 PUSH1 0x20 12E5 61 PUSH2 0x2ca7 12E8 83 DUP4 12E9 39 CODECOPY 12EA 81 DUP2 12EB 51 MLOAD 12EC 91 SWAP2 12ED 52 MSTORE 12EE 54 SLOAD 12EF 61 PUSH2 0x0100 12F2 90 SWAP1 12F3 04 DIV 12F4 60 PUSH1 0xff 12F6 16 AND 12F7 15 ISZERO 12F8 80 DUP1 12F9 15 ISZERO 12FA 61 PUSH2 0x131a 12FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12E9 memory[0x00:0x20] = code[0x2ca7:0x2cc7] // @12ED memory[0x00:0x20] = memory[0x00:0x20] // @12F7 stack[0] = !(0xff & storage[memory[0x00:0x20]] / 0x0100) // } // Block ends with conditional jump to 0x131a, if !!(0xff & storage[memory[0x00:0x20]] / 0x0100) label_12FE: // Incoming jump from 0x12FD, if not !!(0xff & storage[memory[0x00:0x20]] / 0x0100) // Inputs[4] // { // @1301 memory[0x00:0x20] // @130A memory[0x00:0x20] // @130E storage[memory[0x00:0x20]] // @131D storage[0x00] // } 12FE 60 PUSH1 0x00 1300 80 DUP1 1301 51 MLOAD 1302 60 PUSH1 0x20 1304 61 PUSH2 0x2ca7 1307 83 DUP4 1308 39 CODECOPY 1309 81 DUP2 130A 51 MLOAD 130B 91 SWAP2 130C 52 MSTORE 130D 80 DUP1 130E 54 SLOAD 130F 61 PUSH2 0xffff 1312 19 NOT 1313 16 AND 1314 61 PUSH2 0x0101 1317 17 OR 1318 90 SWAP1 1319 55 SSTORE 131A 5B JUMPDEST 131B 60 PUSH1 0x00 131D 54 SLOAD 131E 61 PUSH2 0x0100 1321 90 SWAP1 1322 04 DIV 1323 60 PUSH1 0xff 1325 16 AND 1326 61 PUSH2 0x1341 1329 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1308 memory[0x00:0x20] = code[0x2ca7:0x2cc7] // @130C memory[0x00:0x20] = memory[0x00:0x20] // @1319 storage[memory[0x00:0x20]] = 0x0101 | (~0xffff & storage[memory[0x00:0x20]]) // } // Block ends with conditional jump to 0x1341, if 0xff & storage[0x00] / 0x0100 label_132A: // Incoming jump from 0x1329, if not 0xff & storage[0x00] / 0x0100 // Incoming jump from 0x1329, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @132C memory[0x40:0x60] } 132A 60 PUSH1 0x40 132C 51 MLOAD 132D 62 PUSH3 0x461bcd 1331 60 PUSH1 0xe5 1333 1B SHL 1334 81 DUP2 1335 52 MSTORE 1336 60 PUSH1 0x04 1338 01 ADD 1339 61 PUSH2 0x0870 133C 90 SWAP1 133D 61 PUSH2 0x2a48 1340 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1335 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @133C stack[0] = 0x0870 // @133C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a48, returns to 0x0870 label_1341: // Incoming jump from 0x1329, if 0xff & storage[0x00] / 0x0100 // Incoming jump from 0x1329, if 0xff & storage[0x00] / 0x0100 1341 5B JUMPDEST 1342 61 PUSH2 0x1349 1345 61 PUSH2 0x1ad0 1348 56 *JUMP // Stack delta = +1 // Outputs[1] { @1342 stack[0] = 0x1349 } // Block ends with unconditional jump to 0x1ad0 1349 5B JUMPDEST 134A 61 PUSH2 0x1351 134D 61 PUSH2 0x1aff 1350 56 *JUMP 1351 5B JUMPDEST 1352 61 PUSH2 0x135b 1355 87 DUP8 1356 87 DUP8 1357 61 PUSH2 0x1b26 135A 56 *JUMP 135B 5B JUMPDEST 135C 61 PUSH2 0x1363 135F 61 PUSH2 0x1b64 1362 56 *JUMP 1363 5B JUMPDEST 1364 61 PUSH2 0x136d 1367 83 DUP4 1368 83 DUP4 1369 61 PUSH2 0x1baa 136C 56 *JUMP 136D 5B JUMPDEST 136E 61 PUSH2 0x1377 1371 85 DUP6 1372 85 DUP6 1373 61 PUSH2 0x1be3 1376 56 *JUMP 1377 5B JUMPDEST 1378 61 PUSH2 0x137f 137B 61 PUSH2 0x1c14 137E 56 *JUMP 137F 5B JUMPDEST 1380 80 DUP1 1381 15 ISZERO 1382 61 PUSH2 0x0997 1385 57 *JUMPI 1386 50 POP 1387 50 POP 1388 60 PUSH1 0x00 138A 80 DUP1 138B 51 MLOAD 138C 60 PUSH1 0x20 138E 61 PUSH2 0x2ca7 1391 83 DUP4 1392 39 CODECOPY 1393 81 DUP2 1394 51 MLOAD 1395 91 SWAP2 1396 52 MSTORE 1397 80 DUP1 1398 54 SLOAD 1399 61 PUSH2 0xff00 139C 19 NOT 139D 16 AND 139E 90 SWAP1 139F 55 SSTORE 13A0 50 POP 13A1 50 POP 13A2 50 POP 13A3 50 POP 13A4 50 POP 13A5 56 *JUMP label_13A6: // Incoming jump from 0x09C4 // Inputs[4] // { // @13AA stack[-3] // @13AB stack[-2] // @13AC stack[-1] // @13AF memory[0x40:0x60] // } 13A6 5B JUMPDEST 13A7 61 PUSH2 0x0701 13AA 83 DUP4 13AB 83 DUP4 13AC 83 DUP4 13AD 60 PUSH1 0x40 13AF 51 MLOAD 13B0 80 DUP1 13B1 60 PUSH1 0x20 13B3 01 ADD 13B4 60 PUSH1 0x40 13B6 52 MSTORE 13B7 80 DUP1 13B8 60 PUSH1 0x00 13BA 81 DUP2 13BB 52 MSTORE 13BC 50 POP 13BD 61 PUSH2 0x0c36 13C0 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @13A7 stack[0] = 0x0701 // @13AA stack[1] = stack[-3] // @13AB stack[2] = stack[-2] // @13AC stack[3] = stack[-1] // @13AF stack[4] = memory[0x40:0x60] // @13B6 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @13BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0c36 label_13C1: // Incoming call from 0x0BA9, returns to 0x0BAA // Incoming call from 0x0D3C, returns to 0x0D3D // Incoming call from 0x09CC, returns to 0x09CD // Incoming call from 0x0CC0, returns to 0x0CC1 // Inputs[2] // { // @13C4 storage[0x33] // @13CE msg.sender // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x33 13C4 54 SLOAD 13C5 60 PUSH1 0x01 13C7 60 PUSH1 0x01 13C9 60 PUSH1 0xa0 13CB 1B SHL 13CC 03 SUB 13CD 16 AND 13CE 33 CALLER 13CF 14 EQ 13D0 61 PUSH2 0x0bb4 13D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bb4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x33] label_13D4: // Incoming jump from 0x13D3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x33] // Inputs[1] { @13D6 memory[0x40:0x60] } 13D4 60 PUSH1 0x40 13D6 51 MLOAD 13D7 62 PUSH3 0x461bcd 13DB 60 PUSH1 0xe5 13DD 1B SHL 13DE 81 DUP2 13DF 52 MSTORE 13E0 60 PUSH1 0x20 13E2 60 PUSH1 0x04 13E4 82 DUP3 13E5 01 ADD 13E6 81 DUP2 13E7 90 SWAP1 13E8 52 MSTORE 13E9 60 PUSH1 0x24 13EB 82 DUP3 13EC 01 ADD 13ED 52 MSTORE 13EE 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 140F 60 PUSH1 0x44 1411 82 DUP3 1412 01 ADD 1413 52 MSTORE 1414 60 PUSH1 0x64 1416 01 ADD 1417 61 PUSH2 0x0870 141A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13ED memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1413 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1416 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_141B: // Incoming call from 0x09D5, returns to 0x09D6 // Inputs[2] // { // @141F stack[-1] // @1422 memory[stack[-1]:stack[-1] + 0x20] // } 141B 5B JUMPDEST 141C 60 PUSH1 0x00 141E 5B JUMPDEST 141F 81 DUP2 1420 81 DUP2 1421 81 DUP2 1422 51 MLOAD 1423 81 DUP2 1424 10 LT 1425 61 PUSH2 0x1430 1428 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @141C stack[0] = 0x00 // @141F stack[1] = stack[-1] // @1420 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1430, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_1429: // Incoming jump from 0x1428, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1428, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 1429 61 PUSH2 0x1430 142C 61 PUSH2 0x29fc 142F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1429 stack[0] = 0x1430 } // Block ends with unconditional jump to 0x29fc label_1430: // Incoming jump from 0x1428, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1428, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1433 stack[-1] // @1437 stack[-2] // @1438 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1430 5B JUMPDEST 1431 60 PUSH1 0x20 1433 02 MUL 1434 60 PUSH1 0x20 1436 01 ADD 1437 01 ADD 1438 51 MLOAD 1439 61 PUSH2 0x1440 143C 61 PUSH2 0x0dd4 143F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1438 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1439 stack[-1] = 0x1440 // } // Block ends with call to 0x0dd4, returns to 0x1440 label_1440: // Incoming return from call to 0x0DD4 at 0x143F // Inputs[1] { @1443 stack[-1] } 1440 5B JUMPDEST 1441 60 PUSH1 0x04 1443 01 ADD 1444 60 PUSH1 0x00 1446 61 PUSH2 0x144d 1449 61 PUSH2 0x0dd4 144C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1443 stack[-1] = 0x04 + stack[-1] // @1444 stack[0] = 0x00 // @1446 stack[1] = 0x144d // } // Block ends with call to 0x0dd4, returns to 0x144D label_144D: // Incoming return from call to 0x0DD4 at 0x144C // Inputs[6] // { // @144E storage[stack[-1]] // @144E stack[-1] // @144F stack[-2] // @1455 stack[-3] // @145E memory[0x00:0x00 + 0x40 + stack[-2]] // @145F stack[-4] // } 144D 5B JUMPDEST 144E 54 SLOAD 144F 81 DUP2 1450 52 MSTORE 1451 60 PUSH1 0x20 1453 81 DUP2 1454 01 ADD 1455 91 SWAP2 1456 90 SWAP1 1457 91 SWAP2 1458 52 MSTORE 1459 60 PUSH1 0x40 145B 01 ADD 145C 60 PUSH1 0x00 145E 20 SHA3 145F 55 SSTORE 1460 61 PUSH2 0x1467 1463 61 PUSH2 0x0dd4 1466 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1450 memory[stack[-2]:stack[-2] + 0x20] = storage[stack[-1]] // @1458 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @145F storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] = stack[-4] // @1460 stack[-4] = 0x1467 // } // Block ends with call to 0x0dd4, returns to 0x1467 label_1467: // Incoming return from call to 0x0DD4 at 0x1466 // Inputs[5] // { // @1468 stack[-1] // @1469 storage[stack[-1]] // @1471 stack[-3] // @1472 memory[stack[-3]:stack[-3] + 0x20] // @1475 stack[-2] // } 1467 5B JUMPDEST 1468 80 DUP1 1469 54 SLOAD 146A 60 PUSH1 0x01 146C 81 DUP2 146D 01 ADD 146E 90 SWAP1 146F 91 SWAP2 1470 55 SSTORE 1471 82 DUP3 1472 51 MLOAD 1473 83 DUP4 1474 90 SWAP1 1475 83 DUP4 1476 90 SWAP1 1477 81 DUP2 1478 10 LT 1479 61 PUSH2 0x1484 147C 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @146F stack[-1] = storage[stack[-1]] // @1470 storage[stack[-1]] = storage[stack[-1]] + 0x01 // @1474 stack[0] = stack[-3] // @1476 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x1484, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_147D: // Incoming jump from 0x147C, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 147D 61 PUSH2 0x1484 1480 61 PUSH2 0x29fc 1483 56 *JUMP // Stack delta = +1 // Outputs[1] { @147D stack[0] = 0x1484 } // Block ends with unconditional jump to 0x29fc label_1484: // Incoming jump from 0x147C, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[10] // { // @1487 stack[-1] // @148B stack[-2] // @148C memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20] // @14C4 memory[0x40:0x60] // @14C7 memory[0x40:0x60] // @14CC stack[-3] // @14CC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @14CD stack[-4] // @14D4 stack[-5] // @14D5 memory[stack[-5]:stack[-5] + 0x20] // } 1484 5B JUMPDEST 1485 60 PUSH1 0x20 1487 02 MUL 1488 60 PUSH1 0x20 148A 01 ADD 148B 01 ADD 148C 51 MLOAD 148D 60 PUSH1 0x01 148F 60 PUSH1 0x01 1491 60 PUSH1 0xa0 1493 1B SHL 1494 03 SUB 1495 16 AND 1496 60 PUSH1 0x00 1498 60 PUSH1 0x01 149A 60 PUSH1 0x01 149C 60 PUSH1 0xa0 149E 1B SHL 149F 03 SUB 14A0 16 AND 14A1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 14C2 60 PUSH1 0x40 14C4 51 MLOAD 14C5 60 PUSH1 0x40 14C7 51 MLOAD 14C8 80 DUP1 14C9 91 SWAP2 14CA 03 SUB 14CB 90 SWAP1 14CC A4 LOG4 14CD 80 DUP1 14CE 60 PUSH1 0x01 14D0 01 ADD 14D1 90 SWAP1 14D2 50 POP 14D3 80 DUP1 14D4 82 DUP3 14D5 51 MLOAD 14D6 03 SUB 14D7 15 ISZERO 14D8 61 PUSH2 0x071a 14DB 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @14CC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, (0x01 << 0xa0) - 0x01 & 0x00, memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01, stack[-3]]); // @14D1 stack[-4] = 0x01 + stack[-4] // } // Block ends with conditional jump to 0x071a, if !(memory[stack[-5]:stack[-5] + 0x20] - (0x01 + stack[-4])) label_14DC: // Incoming jump from 0x14DB, if not !(memory[stack[-5]:stack[-5] + 0x20] - (0x01 + stack[-4])) 14DC 61 PUSH2 0x141e 14DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x141e label_14E0: // Incoming call from 0x0F4C, returns to 0x0F4D // Incoming call from 0x09E3, returns to 0x05FF // Incoming call from 0x15BC, returns to 0x15BD // Inputs[1] { @14E3 stack[-1] } 14E0 5B JUMPDEST 14E1 60 PUSH1 0x00 14E3 81 DUP2 14E4 60 PUSH1 0x01 14E6 11 GT 14E7 61 PUSH2 0x1574 14EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14E1 stack[0] = 0x00 } // Block ends with conditional jump to 0x1574, if 0x01 > stack[-1] label_14EB: // Incoming jump from 0x14EA, if not 0x01 > stack[-1] 14EB 61 PUSH2 0x14f2 14EE 61 PUSH2 0x0dd4 14F1 56 *JUMP // Stack delta = +1 // Outputs[1] { @14EB stack[0] = 0x14f2 } // Block ends with call to 0x0dd4, returns to 0x14F2 label_14F2: // Incoming return from call to 0x0DD4 at 0x14F1 // Inputs[5] // { // @14F5 stack[-3] // @14FA stack[-1] // @1504 memory[0x00:0x40] // @1505 storage[keccak256(memory[0x00:0x40])] // @1506 stack[-2] // } 14F2 5B JUMPDEST 14F3 60 PUSH1 0x00 14F5 83 DUP4 14F6 81 DUP2 14F7 52 MSTORE 14F8 60 PUSH1 0x04 14FA 91 SWAP2 14FB 90 SWAP1 14FC 91 SWAP2 14FD 01 ADD 14FE 60 PUSH1 0x20 1500 52 MSTORE 1501 60 PUSH1 0x40 1503 81 DUP2 1504 20 SHA3 1505 54 SLOAD 1506 91 SWAP2 1507 50 POP 1508 60 PUSH1 0x01 150A 60 PUSH1 0xe0 150C 1B SHL 150D 82 DUP3 150E 16 AND 150F 90 SWAP1 1510 03 SUB 1511 61 PUSH2 0x1574 1514 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @14F7 memory[0x00:0x20] = stack[-3] // @1500 memory[0x20:0x40] = 0x04 + stack[-1] // @1506 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1574, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_1515: // Incoming jump from 0x1514, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Inputs[1] { @1515 stack[-1] } 1515 80 DUP1 1516 60 PUSH1 0x00 1518 03 SUB 1519 61 PUSH2 0x156f 151C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x156f, if 0x00 - stack[-1] label_151D: // Incoming jump from 0x151C, if not 0x00 - stack[-1] 151D 61 PUSH2 0x1524 1520 61 PUSH2 0x0dd4 1523 56 *JUMP // Stack delta = +1 // Outputs[1] { @151D stack[0] = 0x1524 } // Block ends with call to 0x0dd4, returns to 0x1524 label_1524: // Incoming return from call to 0x0DD4 at 0x1523 // Inputs[3] // { // @1525 stack[-1] // @1525 storage[stack[-1]] // @1526 stack[-3] // } 1524 5B JUMPDEST 1525 54 SLOAD 1526 82 DUP3 1527 10 LT 1528 61 PUSH2 0x1544 152B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1544, if stack[-3] < storage[stack[-1]] label_152C: // Incoming jump from 0x152B, if not stack[-3] < storage[stack[-1]] // Inputs[3] // { // @152E memory[0x40:0x60] // @153E memory[0x40:0x60] // @1543 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 152C 60 PUSH1 0x40 152E 51 MLOAD 152F 63 PUSH4 0x6f96cda1 1534 60 PUSH1 0xe1 1536 1B SHL 1537 81 DUP2 1538 52 MSTORE 1539 60 PUSH1 0x04 153B 01 ADD 153C 60 PUSH1 0x40 153E 51 MLOAD 153F 80 DUP1 1540 91 SWAP2 1541 03 SUB 1542 90 SWAP1 1543 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1538 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1543 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1544: // Incoming jump from 0x156E, if !storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x152B, if stack[-3] < storage[stack[-1]] 1544 5B JUMPDEST 1545 61 PUSH2 0x154c 1548 61 PUSH2 0x0dd4 154B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1545 stack[0] = 0x154c } // Block ends with call to 0x0dd4, returns to 0x154C label_154C: // Incoming return from call to 0x0DD4 at 0x154B // Inputs[5] // { // @1550 stack[-1] // @1551 stack[-3] // @1565 memory[0x00:0x40] // @1566 storage[keccak256(memory[0x00:0x40])] // @1567 stack[-2] // } 154C 5B JUMPDEST 154D 60 PUSH1 0x00 154F 19 NOT 1550 90 SWAP1 1551 92 SWAP3 1552 01 ADD 1553 60 PUSH1 0x00 1555 81 DUP2 1556 81 DUP2 1557 52 MSTORE 1558 60 PUSH1 0x04 155A 93 SWAP4 155B 90 SWAP1 155C 93 SWAP4 155D 01 ADD 155E 60 PUSH1 0x20 1560 52 MSTORE 1561 60 PUSH1 0x40 1563 90 SWAP1 1564 92 SWAP3 1565 20 SHA3 1566 54 SLOAD 1567 90 SWAP1 1568 50 POP 1569 80 DUP1 156A 15 ISZERO 156B 61 PUSH2 0x1544 156E 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1557 memory[0x00:0x20] = stack[-3] + ~0x00 // @1560 memory[0x20:0x40] = 0x04 + stack[-1] // @1564 stack[-3] = stack[-3] + ~0x00 // @1567 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1544, if !storage[keccak256(memory[0x00:0x40])] label_156F: // Incoming jump from 0x2404, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x151C, if 0x00 - stack[-1] // Incoming jump from 0x156E, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @1570 stack[-3] // @1570 stack[-1] // @1571 stack[-2] // } 156F 5B JUMPDEST 1570 91 SWAP2 1571 90 SWAP1 1572 50 POP 1573 56 *JUMP // Stack delta = -2 // Outputs[1] { @1570 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1574: // Incoming jump from 0x14EA, if 0x01 > stack[-1] // Incoming jump from 0x1514, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Inputs[3] // { // @1577 memory[0x40:0x60] // @1587 memory[0x40:0x60] // @158C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1574 5B JUMPDEST 1575 60 PUSH1 0x40 1577 51 MLOAD 1578 63 PUSH4 0x6f96cda1 157D 60 PUSH1 0xe1 157F 1B SHL 1580 81 DUP2 1581 52 MSTORE 1582 60 PUSH1 0x04 1584 01 ADD 1585 60 PUSH1 0x40 1587 51 MLOAD 1588 80 DUP1 1589 91 SWAP2 158A 03 SUB 158B 90 SWAP1 158C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1581 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @158C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_158D: // Incoming jump from 0x0A0C // Inputs[2] // { // @1591 memory[0x40:0x60] // @15B8 stack[-1] // } 158D 5B JUMPDEST 158E 60 PUSH1 0x40 1590 80 DUP1 1591 51 MLOAD 1592 60 PUSH1 0x80 1594 81 DUP2 1595 01 ADD 1596 82 DUP3 1597 52 MSTORE 1598 60 PUSH1 0x00 159A 80 DUP1 159B 82 DUP3 159C 52 MSTORE 159D 60 PUSH1 0x20 159F 82 DUP3 15A0 01 ADD 15A1 81 DUP2 15A2 90 SWAP1 15A3 52 MSTORE 15A4 91 SWAP2 15A5 81 DUP2 15A6 01 ADD 15A7 82 DUP3 15A8 90 SWAP1 15A9 52 MSTORE 15AA 60 PUSH1 0x60 15AC 81 DUP2 15AD 01 ADD 15AE 91 SWAP2 15AF 90 SWAP1 15B0 91 SWAP2 15B1 52 MSTORE 15B2 61 PUSH2 0x05ff 15B5 61 PUSH2 0x15bd 15B8 83 DUP4 15B9 61 PUSH2 0x14e0 15BC 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1597 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @159C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @15A3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @15A9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @15B0 stack[0] = memory[0x40:0x60] // @15B1 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @15B2 stack[1] = 0x05ff // @15B5 stack[2] = 0x15bd // @15B8 stack[3] = stack[-1] // } // Block ends with call to 0x14e0, returns to 0x15BD label_15BD: // Incoming return from call to 0x14E0 at 0x15BC // Inputs[3] // { // @15C1 memory[0x40:0x60] // @15D0 stack[-1] // @1602 stack[-2] // } 15BD 5B JUMPDEST 15BE 60 PUSH1 0x40 15C0 80 DUP1 15C1 51 MLOAD 15C2 60 PUSH1 0x80 15C4 81 DUP2 15C5 01 ADD 15C6 82 DUP3 15C7 52 MSTORE 15C8 60 PUSH1 0x01 15CA 60 PUSH1 0x01 15CC 60 PUSH1 0xa0 15CE 1B SHL 15CF 03 SUB 15D0 83 DUP4 15D1 16 AND 15D2 81 DUP2 15D3 52 MSTORE 15D4 60 PUSH1 0xa0 15D6 83 DUP4 15D7 90 SWAP1 15D8 1C SHR 15D9 60 PUSH1 0x01 15DB 60 PUSH1 0x01 15DD 60 PUSH1 0x40 15DF 1B SHL 15E0 03 SUB 15E1 16 AND 15E2 60 PUSH1 0x20 15E4 82 DUP3 15E5 01 ADD 15E6 52 MSTORE 15E7 60 PUSH1 0x01 15E9 60 PUSH1 0xe0 15EB 1B SHL 15EC 83 DUP4 15ED 16 AND 15EE 15 ISZERO 15EF 15 ISZERO 15F0 91 SWAP2 15F1 81 DUP2 15F2 01 ADD 15F3 91 SWAP2 15F4 90 SWAP1 15F5 91 SWAP2 15F6 52 MSTORE 15F7 60 PUSH1 0xe8 15F9 91 SWAP2 15FA 90 SWAP1 15FB 91 SWAP2 15FC 1C SHR 15FD 60 PUSH1 0x60 15FF 82 DUP3 1600 01 ADD 1601 52 MSTORE 1602 90 SWAP1 1603 56 *JUMP // Stack delta = -1 // Outputs[6] // { // @15C7 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @15D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @15E6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & (stack[-1] >> 0xa0) // @15F6 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(stack[-1] & (0x01 << 0xe0)) // @1601 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] >> 0xe8 // @1602 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-2] label_1604: // Incoming call from 0x1FA7, returns to 0x0BB4 // Incoming call from 0x0DAA, returns to 0x09D6 // Incoming call from 0x0BB3, returns to 0x0BB4 // Inputs[5] // { // @1608 storage[0x33] // @1611 stack[-1] // @1626 memory[0x40:0x60] // @1652 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1655 stack[-2] // } 1604 5B JUMPDEST 1605 60 PUSH1 0x33 1607 80 DUP1 1608 54 SLOAD 1609 60 PUSH1 0x01 160B 60 PUSH1 0x01 160D 60 PUSH1 0xa0 160F 1B SHL 1610 03 SUB 1611 83 DUP4 1612 81 DUP2 1613 16 AND 1614 60 PUSH1 0x01 1616 60 PUSH1 0x01 1618 60 PUSH1 0xa0 161A 1B SHL 161B 03 SUB 161C 19 NOT 161D 83 DUP4 161E 16 AND 161F 81 DUP2 1620 17 OR 1621 90 SWAP1 1622 93 SWAP4 1623 55 SSTORE 1624 60 PUSH1 0x40 1626 51 MLOAD 1627 91 SWAP2 1628 16 AND 1629 91 SWAP2 162A 90 SWAP1 162B 82 DUP3 162C 90 SWAP1 162D 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 164E 90 SWAP1 164F 60 PUSH1 0x00 1651 90 SWAP1 1652 A3 LOG3 1653 50 POP 1654 50 POP 1655 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1623 storage[0x33] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x33] & ~((0x01 << 0xa0) - 0x01)) // @1652 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x33] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1656 5B JUMPDEST 1657 80 DUP1 1658 7F PUSH32 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c0 1679 81 DUP2 167A 51 MLOAD 167B 61 PUSH2 0x071a 167E 92 SWAP3 167F 60 PUSH1 0x20 1681 01 ADD 1682 90 SWAP1 1683 61 PUSH2 0x22a2 1686 56 *JUMP label_1687: // Incoming call from 0x0BDE, returns to 0x0701 // Inputs[1] { @168B stack[-1] } 1687 5B JUMPDEST 1688 61 PUSH2 0x2710 168B 81 DUP2 168C 11 GT 168D 15 ISZERO 168E 61 PUSH2 0x16aa 1691 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16aa, if !(stack[-1] > 0x2710) label_1692: // Incoming jump from 0x1691, if not !(stack[-1] > 0x2710) // Inputs[3] // { // @1694 memory[0x40:0x60] // @16A4 memory[0x40:0x60] // @16A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1692 60 PUSH1 0x40 1694 51 MLOAD 1695 63 PUSH4 0x2bd448e7 169A 60 PUSH1 0xe0 169C 1B SHL 169D 81 DUP2 169E 52 MSTORE 169F 60 PUSH1 0x04 16A1 01 ADD 16A2 60 PUSH1 0x40 16A4 51 MLOAD 16A5 80 DUP1 16A6 91 SWAP2 16A7 03 SUB 16A8 90 SWAP1 16A9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @169E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2bd448e7 << 0xe0 // @16A9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_16AA: // Incoming jump from 0x1691, if !(stack[-1] > 0x2710) // Inputs[4] // { // @16CD storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40] // @16E0 stack[-2] // @16E8 stack[-1] // @170D stack[-3] // } 16AA 5B JUMPDEST 16AB 7F PUSH32 0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40 16CC 80 DUP1 16CD 54 SLOAD 16CE 60 PUSH1 0x01 16D0 60 PUSH1 0x01 16D2 60 PUSH1 0xa0 16D4 1B SHL 16D5 03 SUB 16D6 19 NOT 16D7 16 AND 16D8 60 PUSH1 0x01 16DA 60 PUSH1 0x01 16DC 60 PUSH1 0xa0 16DE 1B SHL 16DF 03 SUB 16E0 93 SWAP4 16E1 90 SWAP1 16E2 93 SWAP4 16E3 16 AND 16E4 92 SWAP3 16E5 90 SWAP1 16E6 92 SWAP3 16E7 17 OR 16E8 90 SWAP1 16E9 91 SWAP2 16EA 55 SSTORE 16EB 7F PUSH32 0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b41 170C 55 SSTORE 170D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @16EA storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b40]) // @170C storage[0x317162611eb5bfbd492dc5934870b94626522f302cb20f4f0ee9d856d2ce9b41] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_170E: // Incoming call from 0x0C35, returns to 0x0701 // Inputs[1] { @170F stack[-1] } 170E 5B JUMPDEST 170F 80 DUP1 1710 61 PUSH2 0x1717 1713 61 PUSH2 0x0dd4 1716 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @170F stack[0] = stack[-1] // @1710 stack[1] = 0x1717 // } // Block ends with call to 0x0dd4, returns to 0x1717 label_1717: // Incoming return from call to 0x0DD4 at 0x1716 // Inputs[12] // { // @1718 msg.sender // @1720 stack[-1] // @172D memory[0x00:0x40] // @1736 stack[-4] // @1741 memory[0x00:0x40] // @1743 storage[keccak256(memory[0x00:0x40])] // @1748 stack[-2] // @1753 memory[0x40:0x60] // @1754 stack[-3] // @1782 memory[0x40:0x60] // @1787 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @178A stack[-5] // } 1717 5B JUMPDEST 1718 33 CALLER 1719 60 PUSH1 0x00 171B 81 DUP2 171C 81 DUP2 171D 52 MSTORE 171E 60 PUSH1 0x07 1720 92 SWAP3 1721 90 SWAP1 1722 92 SWAP3 1723 01 ADD 1724 60 PUSH1 0x20 1726 90 SWAP1 1727 81 DUP2 1728 52 MSTORE 1729 60 PUSH1 0x40 172B 80 DUP1 172C 84 DUP5 172D 20 SHA3 172E 60 PUSH1 0x01 1730 60 PUSH1 0x01 1732 60 PUSH1 0xa0 1734 1B SHL 1735 03 SUB 1736 88 DUP9 1737 16 AND 1738 80 DUP1 1739 86 DUP7 173A 52 MSTORE 173B 90 SWAP1 173C 83 DUP4 173D 52 MSTORE 173E 93 SWAP4 173F 81 DUP2 1740 90 SWAP1 1741 20 SHA3 1742 80 DUP1 1743 54 SLOAD 1744 60 PUSH1 0xff 1746 19 NOT 1747 16 AND 1748 95 SWAP6 1749 15 ISZERO 174A 15 ISZERO 174B 95 SWAP6 174C 90 SWAP1 174D 95 SWAP6 174E 17 OR 174F 90 SWAP1 1750 94 SWAP5 1751 55 SSTORE 1752 92 SWAP3 1753 51 MLOAD 1754 84 DUP5 1755 15 ISZERO 1756 15 ISZERO 1757 81 DUP2 1758 52 MSTORE 1759 91 SWAP2 175A 92 SWAP3 175B 90 SWAP1 175C 91 SWAP2 175D 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 177E 91 SWAP2 177F 01 ADD 1780 60 PUSH1 0x40 1782 51 MLOAD 1783 80 DUP1 1784 91 SWAP2 1785 03 SUB 1786 90 SWAP1 1787 A3 LOG3 1788 50 POP 1789 50 POP 178A 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @171D memory[0x00:0x20] = msg.sender // @1728 memory[0x20:0x40] = 0x07 + stack[-1] // @173A memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @173D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1751 storage[keccak256(memory[0x00:0x40])] = !!stack[-2] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1758 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-3] // @1787 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-4] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-5] label_178B: // Incoming jump from 0x0C5B // Inputs[3] // { // @178F stack[-4] // @1790 stack[-3] // @1791 stack[-2] // } 178B 5B JUMPDEST 178C 61 PUSH2 0x1796 178F 84 DUP5 1790 84 DUP5 1791 84 DUP5 1792 61 PUSH2 0x073e 1795 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @178C stack[0] = 0x1796 // @178F stack[1] = stack[-4] // @1790 stack[2] = stack[-3] // @1791 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x073e 1796 5B JUMPDEST 1797 60 PUSH1 0x01 1799 60 PUSH1 0x01 179B 60 PUSH1 0xa0 179D 1B SHL 179E 03 SUB 179F 83 DUP4 17A0 16 AND 17A1 3B EXTCODESIZE 17A2 15 ISZERO 17A3 61 PUSH2 0x0763 17A6 57 *JUMPI 17A7 61 PUSH2 0x17b2 17AA 84 DUP5 17AB 84 DUP5 17AC 84 DUP5 17AD 84 DUP5 17AE 61 PUSH2 0x1c46 17B1 56 *JUMP 17B2 5B JUMPDEST 17B3 61 PUSH2 0x0763 17B6 57 *JUMPI 17B7 60 PUSH1 0x40 17B9 51 MLOAD 17BA 63 PUSH4 0x68d2bf6b 17BF 60 PUSH1 0xe1 17C1 1B SHL 17C2 81 DUP2 17C3 52 MSTORE 17C4 60 PUSH1 0x04 17C6 01 ADD 17C7 60 PUSH1 0x40 17C9 51 MLOAD 17CA 80 DUP1 17CB 91 SWAP2 17CC 03 SUB 17CD 90 SWAP1 17CE FD *REVERT label_17CF: // Incoming jump from 0x0C93 // Inputs[1] { @17F6 stack[-1] } 17CF 5B JUMPDEST 17D0 60 PUSH1 0x60 17D2 7F PUSH32 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c0 17F3 61 PUSH2 0x17fb 17F6 83 DUP4 17F7 61 PUSH2 0x1d32 17FA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @17D0 stack[0] = 0x60 // @17D2 stack[1] = 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c0 // @17F3 stack[2] = 0x17fb // @17F6 stack[3] = stack[-1] // } // Block ends with call to 0x1d32, returns to 0x17FB label_17FB: // Incoming return from call to 0x1D32 at 0x17FA // Inputs[3] // { // @17FE memory[0x40:0x60] // @1802 stack[-2] // @1803 stack[-1] // } 17FB 5B JUMPDEST 17FC 60 PUSH1 0x40 17FE 51 MLOAD 17FF 61 PUSH2 0x182e 1802 92 SWAP3 1803 91 SWAP2 1804 90 SWAP1 1805 7F PUSH32 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c1 1826 90 SWAP1 1827 60 PUSH1 0x20 1829 01 ADD 182A 61 PUSH2 0x2b2c 182D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1802 stack[-2] = 0x182e // @1803 stack[-1] = stack[-2] // @1804 stack[0] = stack[-1] // @1826 stack[1] = 0x4671642b6ab8da4ed5997daf1cfd48bf3b770981cfb9aebd996e76b59bab67c1 // @1829 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b2c 182E 5B JUMPDEST 182F 60 PUSH1 0x40 1831 51 MLOAD 1832 60 PUSH1 0x20 1834 81 DUP2 1835 83 DUP4 1836 03 SUB 1837 03 SUB 1838 81 DUP2 1839 52 MSTORE 183A 90 SWAP1 183B 60 PUSH1 0x40 183D 52 MSTORE 183E 90 SWAP1 183F 50 POP 1840 91 SWAP2 1841 90 SWAP1 1842 50 POP 1843 56 *JUMP label_1844: // Incoming call from 0x0CC9, returns to 0x09D6 // Inputs[2] // { // @1848 stack[-1] // @184B memory[stack[-1]:stack[-1] + 0x20] // } 1844 5B JUMPDEST 1845 60 PUSH1 0x00 1847 5B JUMPDEST 1848 81 DUP2 1849 81 DUP2 184A 81 DUP2 184B 51 MLOAD 184C 81 DUP2 184D 10 LT 184E 61 PUSH2 0x1859 1851 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1845 stack[0] = 0x00 // @1848 stack[1] = stack[-1] // @1849 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1859, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_1852: // Incoming jump from 0x1851, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1851, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 1852 61 PUSH2 0x1859 1855 61 PUSH2 0x29fc 1858 56 *JUMP // Stack delta = +1 // Outputs[1] { @1852 stack[0] = 0x1859 } // Block ends with unconditional jump to 0x29fc label_1859: // Incoming jump from 0x1851, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1851, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @185C stack[-1] // @1860 stack[-2] // @1861 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1865 memory[0x20 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:0x20 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 1859 5B JUMPDEST 185A 60 PUSH1 0x20 185C 02 MUL 185D 60 PUSH1 0x20 185F 01 ADD 1860 01 ADD 1861 51 MLOAD 1862 60 PUSH1 0x20 1864 01 ADD 1865 51 MLOAD 1866 61 PUSH2 0x186d 1869 61 PUSH2 0x0dd4 186C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1865 stack[-2] = memory[0x20 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:0x20 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // @1866 stack[-1] = 0x186d // } // Block ends with call to 0x0dd4, returns to 0x186D label_186D: // Incoming return from call to 0x0DD4 at 0x186C // Inputs[4] // { // @1870 stack[-1] // @1873 stack[-4] // @1874 stack[-3] // @1876 memory[stack[-4]:stack[-4] + 0x20] // } 186D 5B JUMPDEST 186E 60 PUSH1 0x05 1870 01 ADD 1871 60 PUSH1 0x00 1873 84 DUP5 1874 84 DUP5 1875 81 DUP2 1876 51 MLOAD 1877 81 DUP2 1878 10 LT 1879 61 PUSH2 0x1884 187C 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1870 stack[-1] = 0x05 + stack[-1] // @1871 stack[0] = 0x00 // @1873 stack[1] = stack[-4] // @1874 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x1884, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_187D: // Incoming jump from 0x187C, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 187D 61 PUSH2 0x1884 1880 61 PUSH2 0x29fc 1883 56 *JUMP // Stack delta = +1 // Outputs[1] { @187D stack[0] = 0x1884 } // Block ends with unconditional jump to 0x29fc label_1884: // Incoming jump from 0x187C, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[11] // { // @1887 stack[-1] // @188B stack[-2] // @188C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1890 memory[0x00 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:0x00 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // @18A3 stack[-3] // @18A8 stack[-4] // @18B0 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @18B1 stack[-5] // @18B5 stack[-6] // @18BC stack[-7] // @18BD memory[stack[-7]:stack[-7] + 0x20] // } 1884 5B JUMPDEST 1885 60 PUSH1 0x20 1887 02 MUL 1888 60 PUSH1 0x20 188A 01 ADD 188B 01 ADD 188C 51 MLOAD 188D 60 PUSH1 0x00 188F 01 ADD 1890 51 MLOAD 1891 60 PUSH1 0x01 1893 60 PUSH1 0x01 1895 60 PUSH1 0xa0 1897 1B SHL 1898 03 SUB 1899 16 AND 189A 60 PUSH1 0x01 189C 60 PUSH1 0x01 189E 60 PUSH1 0xa0 18A0 1B SHL 18A1 03 SUB 18A2 16 AND 18A3 81 DUP2 18A4 52 MSTORE 18A5 60 PUSH1 0x20 18A7 01 ADD 18A8 90 SWAP1 18A9 81 DUP2 18AA 52 MSTORE 18AB 60 PUSH1 0x20 18AD 01 ADD 18AE 60 PUSH1 0x00 18B0 20 SHA3 18B1 81 DUP2 18B2 90 SWAP1 18B3 55 SSTORE 18B4 50 POP 18B5 80 DUP1 18B6 60 PUSH1 0x01 18B8 01 ADD 18B9 90 SWAP1 18BA 50 POP 18BB 80 DUP1 18BC 82 DUP3 18BD 51 MLOAD 18BE 03 SUB 18BF 15 ISZERO 18C0 61 PUSH2 0x071a 18C3 57 *JUMPI // Stack delta = -5 // Outputs[4] // { // @18A4 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x00 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:0x00 + memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // @18AA memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @18B3 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = stack[-5] // @18B9 stack[-6] = 0x01 + stack[-6] // } // Block ends with conditional jump to 0x071a, if !(memory[stack[-7]:stack[-7] + 0x20] - (0x01 + stack[-6])) label_18C4: // Incoming jump from 0x18C3, if not !(memory[stack[-7]:stack[-7] + 0x20] - (0x01 + stack[-6])) 18C4 61 PUSH2 0x1847 18C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1847 label_18C8: // Incoming call from 0x0DB5, returns to 0x0DB6 // Inputs[1] { @18DC stack[-1] } 18C8 5B JUMPDEST 18C9 60 PUSH1 0x00 18CB 63 PUSH4 0x01ffc9a7 18D0 60 PUSH1 0xe0 18D2 1B SHL 18D3 60 PUSH1 0x01 18D5 60 PUSH1 0x01 18D7 60 PUSH1 0xe0 18D9 1B SHL 18DA 03 SUB 18DB 19 NOT 18DC 83 DUP4 18DD 16 AND 18DE 14 EQ 18DF 80 DUP1 18E0 61 PUSH2 0x18f9 18E3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18C9 stack[0] = 0x00 // @18DE stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x18f9, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_18E4: // Incoming jump from 0x18E3, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @18F6 stack[-3] } 18E4 50 POP 18E5 63 PUSH4 0x80ac58cd 18EA 60 PUSH1 0xe0 18EC 1B SHL 18ED 60 PUSH1 0x01 18EF 60 PUSH1 0x01 18F1 60 PUSH1 0xe0 18F3 1B SHL 18F4 03 SUB 18F5 19 NOT 18F6 83 DUP4 18F7 16 AND 18F8 14 EQ 18F9 5B JUMPDEST 18FA 80 DUP1 18FB 61 PUSH2 0x05ff 18FE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @18F8 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x05ff, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_18FF: // Incoming jump from 0x18FE, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x18FE, if not stack[-1] // Inputs[2] // { // @190A stack[-3] // @1914 stack[-4] // } 18FF 50 POP 1900 50 POP 1901 60 PUSH1 0x01 1903 60 PUSH1 0x01 1905 60 PUSH1 0xe0 1907 1B SHL 1908 03 SUB 1909 19 NOT 190A 16 AND 190B 63 PUSH4 0x5b5e139f 1910 60 PUSH1 0xe0 1912 1B SHL 1913 14 EQ 1914 90 SWAP1 1915 56 *JUMP // Stack delta = -3 // Outputs[1] { @1914 stack[-4] = 0x5b5e139f << 0xe0 == ~((0x01 << 0xe0) - 0x01) & stack[-3] } // Block ends with unconditional jump to stack[-4] label_1916: // Incoming call from 0x0DC4, returns to 0x0DC5 // Inputs[1] { @1922 stack[-1] } 1916 5B JUMPDEST 1917 60 PUSH1 0x00 1919 60 PUSH1 0x01 191B 60 PUSH1 0x01 191D 60 PUSH1 0xe0 191F 1B SHL 1920 03 SUB 1921 19 NOT 1922 82 DUP3 1923 16 AND 1924 63 PUSH4 0x152a902d 1929 60 PUSH1 0xe1 192B 1B SHL 192C 14 EQ 192D 80 DUP1 192E 61 PUSH2 0x05ff 1931 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1917 stack[0] = 0x00 // @192C stack[1] = 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x05ff, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1932: // Incoming jump from 0x1931, if not 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[2] // { // @193C stack[-3] // @1947 stack[-4] // } 1932 50 POP 1933 60 PUSH1 0x01 1935 60 PUSH1 0x01 1937 60 PUSH1 0xe0 1939 1B SHL 193A 03 SUB 193B 19 NOT 193C 82 DUP3 193D 16 AND 193E 63 PUSH4 0x01ffc9a7 1943 60 PUSH1 0xe0 1945 1B SHL 1946 14 EQ 1947 92 SWAP3 1948 91 SWAP2 1949 50 POP 194A 50 POP 194B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1947 stack[-4] = 0x01ffc9a7 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to stack[-4] label_194C: // Incoming call from 0x0DD3, returns to 0x05FF // Inputs[1] { @1958 stack[-1] } 194C 5B JUMPDEST 194D 60 PUSH1 0x00 194F 60 PUSH1 0x01 1951 60 PUSH1 0x01 1953 60 PUSH1 0xe0 1955 1B SHL 1956 03 SUB 1957 19 NOT 1958 82 DUP3 1959 16 AND 195A 63 PUSH4 0x7965db0b 195F 60 PUSH1 0xe0 1961 1B SHL 1962 14 EQ 1963 80 DUP1 1964 61 PUSH2 0x05ff 1967 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @194D stack[0] = 0x00 // @1962 stack[1] = 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x05ff, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1968: // Incoming jump from 0x1967, if not 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @197A stack[-3] } 1968 50 POP 1969 63 PUSH4 0x01ffc9a7 196E 60 PUSH1 0xe0 1970 1B SHL 1971 60 PUSH1 0x01 1973 60 PUSH1 0x01 1975 60 PUSH1 0xe0 1977 1B SHL 1978 03 SUB 1979 19 NOT 197A 83 DUP4 197B 16 AND 197C 14 EQ 197D 61 PUSH2 0x05ff 1980 56 *JUMP // Stack delta = +0 // Outputs[1] { @197C stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x05ff label_1981: // Incoming call from 0x0F05, returns to 0x071A // Inputs[1] { @1987 stack[-2] } 1981 5B JUMPDEST 1982 60 PUSH1 0x00 1984 61 PUSH2 0x198c 1987 83 DUP4 1988 61 PUSH2 0x09d9 198B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1982 stack[0] = 0x00 // @1984 stack[1] = 0x198c // @1987 stack[2] = stack[-2] // } // Block ends with call to 0x09d9, returns to 0x198C label_198C: // Incoming return from call to 0x09D9 at 0x198B // Inputs[3] // { // @198D stack[-2] // @198D stack[-1] // @198F stack[-3] // } 198C 5B JUMPDEST 198D 90 SWAP1 198E 50 POP 198F 81 DUP2 1990 15 ISZERO 1991 61 PUSH2 0x19cb 1994 57 *JUMPI // Stack delta = -1 // Outputs[1] { @198D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x19cb, if !stack[-3] label_1995: // Incoming jump from 0x1994, if not !stack[-3] // Inputs[2] // { // @1995 msg.sender // @199E stack[-1] // } 1995 33 CALLER 1996 60 PUSH1 0x01 1998 60 PUSH1 0x01 199A 60 PUSH1 0xa0 199C 1B SHL 199D 03 SUB 199E 82 DUP3 199F 16 AND 19A0 14 EQ 19A1 61 PUSH2 0x19cb 19A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19cb, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_19A5: // Incoming jump from 0x19A4, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @19A8 stack[-1] // @19A9 msg.sender // } 19A5 61 PUSH2 0x19ae 19A8 81 DUP2 19A9 33 CALLER 19AA 61 PUSH2 0x0cf8 19AD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19A5 stack[0] = 0x19ae // @19A8 stack[1] = stack[-1] // @19A9 stack[2] = msg.sender // } // Block ends with call to 0x0cf8, returns to 0x19AE label_19AE: // Incoming return from call to 0x0CF8 at 0x19AD // Inputs[1] { @19B2 stack[-1] } 19AE 5B JUMPDEST 19AF 61 PUSH2 0x19cb 19B2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19cb, if stack[-1] label_19B3: // Incoming jump from 0x19B2, if not stack[-1] // Inputs[3] // { // @19B5 memory[0x40:0x60] // @19C5 memory[0x40:0x60] // @19CA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19B3 60 PUSH1 0x40 19B5 51 MLOAD 19B6 63 PUSH4 0x67d9dca1 19BB 60 PUSH1 0xe1 19BD 1B SHL 19BE 81 DUP2 19BF 52 MSTORE 19C0 60 PUSH1 0x04 19C2 01 ADD 19C3 60 PUSH1 0x40 19C5 51 MLOAD 19C6 80 DUP1 19C7 91 SWAP2 19C8 03 SUB 19C9 90 SWAP1 19CA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @19CA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19CB: // Incoming jump from 0x19A4, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x1994, if !stack[-3] // Incoming jump from 0x19B2, if stack[-1] // Inputs[1] { @19CC stack[-4] } 19CB 5B JUMPDEST 19CC 83 DUP4 19CD 61 PUSH2 0x19d4 19D0 61 PUSH2 0x0dd4 19D3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19CC stack[0] = stack[-4] // @19CD stack[1] = 0x19d4 // } // Block ends with call to 0x0dd4, returns to 0x19D4 label_19D4: // Incoming return from call to 0x0DD4 at 0x19D3 // Inputs[10] // { // @19D7 stack[-5] // @19DC stack[-1] // @19E7 memory[0x00:0x40] // @19E9 storage[keccak256(memory[0x00:0x40])] // @19FC stack[-2] // @1A02 memory[0x40:0x60] // @1A05 stack[-6] // @1A0A stack[-3] // @1A30 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A35 stack[-7] // } 19D4 5B JUMPDEST 19D5 60 PUSH1 0x00 19D7 85 DUP6 19D8 81 DUP2 19D9 52 MSTORE 19DA 60 PUSH1 0x06 19DC 91 SWAP2 19DD 90 SWAP1 19DE 91 SWAP2 19DF 01 ADD 19E0 60 PUSH1 0x20 19E2 52 MSTORE 19E3 60 PUSH1 0x40 19E5 80 DUP1 19E6 82 DUP3 19E7 20 SHA3 19E8 80 DUP1 19E9 54 SLOAD 19EA 60 PUSH1 0x01 19EC 60 PUSH1 0x01 19EE 60 PUSH1 0xa0 19F0 1B SHL 19F1 03 SUB 19F2 19 NOT 19F3 16 AND 19F4 60 PUSH1 0x01 19F6 60 PUSH1 0x01 19F8 60 PUSH1 0xa0 19FA 1B SHL 19FB 03 SUB 19FC 94 SWAP5 19FD 85 DUP6 19FE 16 AND 19FF 17 OR 1A00 90 SWAP1 1A01 55 SSTORE 1A02 51 MLOAD 1A03 85 DUP6 1A04 92 SWAP3 1A05 87 DUP8 1A06 81 DUP2 1A07 16 AND 1A08 92 SWAP3 1A09 90 SWAP1 1A0A 85 DUP6 1A0B 16 AND 1A0C 91 SWAP2 1A0D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1A2E 91 SWAP2 1A2F 90 SWAP1 1A30 A4 LOG4 1A31 50 POP 1A32 50 POP 1A33 50 POP 1A34 50 POP 1A35 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @19D9 memory[0x00:0x20] = stack[-5] // @19E2 memory[0x20:0x40] = 0x06 + stack[-1] // @1A01 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1A30 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_1A36: // Incoming call from 0x0F0F, returns to 0x09D6 // Inputs[2] // { // @1A3A stack[-2] // @1A3B stack[-1] // } 1A36 5B JUMPDEST 1A37 61 PUSH2 0x1a40 1A3A 82 DUP3 1A3B 82 DUP3 1A3C 61 PUSH2 0x0bdf 1A3F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A37 stack[0] = 0x1a40 // @1A3A stack[1] = stack[-2] // @1A3B stack[2] = stack[-1] // } // Block ends with call to 0x0bdf, returns to 0x1A40 label_1A40: // Incoming return from call to 0x0BDF at 0x1A3F // Inputs[1] { @1A44 stack[-1] } 1A40 5B JUMPDEST 1A41 61 PUSH2 0x071a 1A44 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x071a, if stack[-1] label_1A45: // Incoming jump from 0x1A44, if not stack[-1] // Inputs[1] { @1A48 stack[-1] } 1A45 61 PUSH2 0x1a4d 1A48 81 DUP2 1A49 61 PUSH2 0x1dc4 1A4C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A45 stack[0] = 0x1a4d // @1A48 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1dc4 1A4D 5B JUMPDEST 1A4E 61 PUSH2 0x1a58 1A51 83 DUP4 1A52 60 PUSH1 0x20 1A54 61 PUSH2 0x1dd6 1A57 56 *JUMP 1A58 5B JUMPDEST 1A59 60 PUSH1 0x40 1A5B 51 MLOAD 1A5C 60 PUSH1 0x20 1A5E 01 ADD 1A5F 61 PUSH2 0x1a69 1A62 92 SWAP3 1A63 91 SWAP2 1A64 90 SWAP1 1A65 61 PUSH2 0x2b54 1A68 56 *JUMP 1A69 5B JUMPDEST 1A6A 60 PUSH1 0x40 1A6C 80 DUP1 1A6D 51 MLOAD 1A6E 60 PUSH1 0x1f 1A70 19 NOT 1A71 81 DUP2 1A72 84 DUP5 1A73 03 SUB 1A74 01 ADD 1A75 81 DUP2 1A76 52 MSTORE 1A77 90 SWAP1 1A78 82 DUP3 1A79 90 SWAP1 1A7A 52 MSTORE 1A7B 62 PUSH3 0x461bcd 1A7F 60 PUSH1 0xe5 1A81 1B SHL 1A82 82 DUP3 1A83 52 MSTORE 1A84 61 PUSH2 0x0870 1A87 91 SWAP2 1A88 60 PUSH1 0x04 1A8A 01 ADD 1A8B 61 PUSH2 0x23c6 1A8E 56 *JUMP label_1A8F: // Incoming call from 0x0F8B, returns to 0x0F8C 1A8F 5B JUMPDEST 1A90 60 PUSH1 0x00 1A92 80 DUP1 1A93 60 PUSH1 0x00 1A95 61 PUSH2 0x1a9c 1A98 61 PUSH2 0x0dd4 1A9B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A90 stack[0] = 0x00 // @1A92 stack[1] = 0x00 // @1A93 stack[2] = 0x00 // @1A95 stack[3] = 0x1a9c // } // Block ends with call to 0x0dd4, returns to 0x1A9C label_1A9C: // Incoming return from call to 0x0DD4 at 0x1A9B // Inputs[6] // { // @1A9F stack[-5] // @1AA4 stack[-1] // @1AAC stack[-4] // @1AAE memory[0x00:0x40] // @1AB0 storage[keccak256(memory[0x00:0x40])] // @1AB2 stack[-6] // } 1A9C 5B JUMPDEST 1A9D 60 PUSH1 0x00 1A9F 94 SWAP5 1AA0 85 DUP6 1AA1 52 MSTORE 1AA2 60 PUSH1 0x06 1AA4 01 ADD 1AA5 60 PUSH1 0x20 1AA7 52 MSTORE 1AA8 50 POP 1AA9 50 POP 1AAA 60 PUSH1 0x40 1AAC 90 SWAP1 1AAD 91 SWAP2 1AAE 20 SHA3 1AAF 80 DUP1 1AB0 54 SLOAD 1AB1 90 SWAP1 1AB2 92 SWAP3 1AB3 90 SWAP1 1AB4 91 SWAP2 1AB5 50 POP 1AB6 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1AA1 memory[0x00:0x20] = stack[-5] // @1AA7 memory[0x20:0x40] = 0x06 + stack[-1] // @1AB2 stack[-6] = keccak256(memory[0x00:0x40]) // @1AB4 stack[-5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-6] label_1AB7: // Incoming jump from 0x100F // Inputs[3] // { // @1ABA memory[0x40:0x60] // @1ACA memory[0x40:0x60] // @1ACF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AB7 5B JUMPDEST 1AB8 60 PUSH1 0x40 1ABA 51 MLOAD 1ABB 63 PUSH4 0x38ef7a91 1AC0 60 PUSH1 0xe0 1AC2 1B SHL 1AC3 81 DUP2 1AC4 52 MSTORE 1AC5 60 PUSH1 0x04 1AC7 01 ADD 1AC8 60 PUSH1 0x40 1ACA 51 MLOAD 1ACB 80 DUP1 1ACC 91 SWAP2 1ACD 03 SUB 1ACE 90 SWAP1 1ACF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x38ef7a91 << 0xe0 // @1ACF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AD0: // Incoming jump from 0x1348 // Inputs[1] { @1AD3 storage[0x00] } 1AD0 5B JUMPDEST 1AD1 60 PUSH1 0x00 1AD3 54 SLOAD 1AD4 61 PUSH2 0x0100 1AD7 90 SWAP1 1AD8 04 DIV 1AD9 60 PUSH1 0xff 1ADB 16 AND 1ADC 61 PUSH2 0x1af7 1ADF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1af7, if 0xff & storage[0x00] / 0x0100 label_1AE0: // Incoming jump from 0x1ADF, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @1AE2 memory[0x40:0x60] } 1AE0 60 PUSH1 0x40 1AE2 51 MLOAD 1AE3 62 PUSH3 0x461bcd 1AE7 60 PUSH1 0xe5 1AE9 1B SHL 1AEA 81 DUP2 1AEB 52 MSTORE 1AEC 60 PUSH1 0x04 1AEE 01 ADD 1AEF 61 PUSH2 0x0870 1AF2 90 SWAP1 1AF3 61 PUSH2 0x2a48 1AF6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1AF2 stack[0] = 0x0870 // @1AF2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a48, returns to 0x0870 label_1AF7: // Incoming jump from 0x1ADF, if 0xff & storage[0x00] / 0x0100 1AF7 5B JUMPDEST 1AF8 61 PUSH2 0x0bb4 1AFB 61 PUSH2 0x1f78 1AFE 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AF8 stack[0] = 0x0bb4 } // Block ends with unconditional jump to 0x1f78 1AFF 5B JUMPDEST 1B00 60 PUSH1 0x00 1B02 54 SLOAD 1B03 61 PUSH2 0x0100 1B06 90 SWAP1 1B07 04 DIV 1B08 60 PUSH1 0xff 1B0A 16 AND 1B0B 61 PUSH2 0x0bb4 1B0E 57 *JUMPI 1B0F 60 PUSH1 0x40 1B11 51 MLOAD 1B12 62 PUSH3 0x461bcd 1B16 60 PUSH1 0xe5 1B18 1B SHL 1B19 81 DUP2 1B1A 52 MSTORE 1B1B 60 PUSH1 0x04 1B1D 01 ADD 1B1E 61 PUSH2 0x0870 1B21 90 SWAP1 1B22 61 PUSH2 0x2a48 1B25 56 *JUMP 1B26 5B JUMPDEST 1B27 60 PUSH1 0x00 1B29 80 DUP1 1B2A 51 MLOAD 1B2B 60 PUSH1 0x20 1B2D 61 PUSH2 0x2ca7 1B30 83 DUP4 1B31 39 CODECOPY 1B32 81 DUP2 1B33 51 MLOAD 1B34 91 SWAP2 1B35 52 MSTORE 1B36 54 SLOAD 1B37 61 PUSH2 0x0100 1B3A 90 SWAP1 1B3B 04 DIV 1B3C 60 PUSH1 0xff 1B3E 16 AND 1B3F 61 PUSH2 0x1b5a 1B42 57 *JUMPI 1B43 60 PUSH1 0x40 1B45 51 MLOAD 1B46 62 PUSH3 0x461bcd 1B4A 60 PUSH1 0xe5 1B4C 1B SHL 1B4D 81 DUP2 1B4E 52 MSTORE 1B4F 60 PUSH1 0x04 1B51 01 ADD 1B52 61 PUSH2 0x0870 1B55 90 SWAP1 1B56 61 PUSH2 0x2bc9 1B59 56 *JUMP 1B5A 5B JUMPDEST 1B5B 61 PUSH2 0x071a 1B5E 82 DUP3 1B5F 82 DUP3 1B60 61 PUSH2 0x1fa8 1B63 56 *JUMP 1B64 5B JUMPDEST 1B65 60 PUSH1 0x00 1B67 54 SLOAD 1B68 61 PUSH2 0x0100 1B6B 90 SWAP1 1B6C 04 DIV 1B6D 60 PUSH1 0xff 1B6F 16 AND 1B70 61 PUSH2 0x1b8b 1B73 57 *JUMPI 1B74 60 PUSH1 0x40 1B76 51 MLOAD 1B77 62 PUSH3 0x461bcd 1B7B 60 PUSH1 0xe5 1B7D 1B SHL 1B7E 81 DUP2 1B7F 52 MSTORE 1B80 60 PUSH1 0x04 1B82 01 ADD 1B83 61 PUSH2 0x0870 1B86 90 SWAP1 1B87 61 PUSH2 0x2a48 1B8A 56 *JUMP 1B8B 5B JUMPDEST 1B8C 61 PUSH2 0x0bb4 1B8F 73 PUSH20 0x3cc6cdda760b79bafa08df41ecfa224f810dceb6 1BA4 60 PUSH1 0x01 1BA6 61 PUSH2 0x202b 1BA9 56 *JUMP 1BAA 5B JUMPDEST 1BAB 60 PUSH1 0x00 1BAD 54 SLOAD 1BAE 61 PUSH2 0x0100 1BB1 90 SWAP1 1BB2 04 DIV 1BB3 60 PUSH1 0xff 1BB5 16 AND 1BB6 61 PUSH2 0x1bd1 1BB9 57 *JUMPI 1BBA 60 PUSH1 0x40 1BBC 51 MLOAD 1BBD 62 PUSH3 0x461bcd 1BC1 60 PUSH1 0xe5 1BC3 1B SHL 1BC4 81 DUP2 1BC5 52 MSTORE 1BC6 60 PUSH1 0x04 1BC8 01 ADD 1BC9 61 PUSH2 0x0870 1BCC 90 SWAP1 1BCD 61 PUSH2 0x2a48 1BD0 56 *JUMP 1BD1 5B JUMPDEST 1BD2 61 PUSH2 0x1bda 1BD5 82 DUP3 1BD6 61 PUSH2 0x1656 1BD9 56 *JUMP 1BDA 5B JUMPDEST 1BDB 61 PUSH2 0x071a 1BDE 81 DUP2 1BDF 61 PUSH2 0x0f10 1BE2 56 *JUMP 1BE3 5B JUMPDEST 1BE4 60 PUSH1 0x00 1BE6 54 SLOAD 1BE7 61 PUSH2 0x0100 1BEA 90 SWAP1 1BEB 04 DIV 1BEC 60 PUSH1 0xff 1BEE 16 AND 1BEF 61 PUSH2 0x1c0a 1BF2 57 *JUMPI 1BF3 60 PUSH1 0x40 1BF5 51 MLOAD 1BF6 62 PUSH3 0x461bcd 1BFA 60 PUSH1 0xe5 1BFC 1B SHL 1BFD 81 DUP2 1BFE 52 MSTORE 1BFF 60 PUSH1 0x04 1C01 01 ADD 1C02 61 PUSH2 0x0870 1C05 90 SWAP1 1C06 61 PUSH2 0x2a48 1C09 56 *JUMP 1C0A 5B JUMPDEST 1C0B 61 PUSH2 0x071a 1C0E 82 DUP3 1C0F 82 DUP3 1C10 61 PUSH2 0x1687 1C13 56 *JUMP 1C14 5B JUMPDEST 1C15 60 PUSH1 0x00 1C17 54 SLOAD 1C18 61 PUSH2 0x0100 1C1B 90 SWAP1 1C1C 04 DIV 1C1D 60 PUSH1 0xff 1C1F 16 AND 1C20 61 PUSH2 0x1c3b 1C23 57 *JUMPI 1C24 60 PUSH1 0x40 1C26 51 MLOAD 1C27 62 PUSH3 0x461bcd 1C2B 60 PUSH1 0xe5 1C2D 1B SHL 1C2E 81 DUP2 1C2F 52 MSTORE 1C30 60 PUSH1 0x04 1C32 01 ADD 1C33 61 PUSH2 0x0870 1C36 90 SWAP1 1C37 61 PUSH2 0x2a48 1C3A 56 *JUMP 1C3B 5B JUMPDEST 1C3C 61 PUSH2 0x0bb4 1C3F 60 PUSH1 0x00 1C41 33 CALLER 1C42 61 PUSH2 0x1146 1C45 56 *JUMP 1C46 5B JUMPDEST 1C47 60 PUSH1 0x40 1C49 51 MLOAD 1C4A 63 PUSH4 0x0a85bd01 1C4F 60 PUSH1 0xe1 1C51 1B SHL 1C52 81 DUP2 1C53 52 MSTORE 1C54 60 PUSH1 0x00 1C56 90 SWAP1 1C57 60 PUSH1 0x01 1C59 60 PUSH1 0x01 1C5B 60 PUSH1 0xa0 1C5D 1B SHL 1C5E 03 SUB 1C5F 85 DUP6 1C60 16 AND 1C61 90 SWAP1 1C62 63 PUSH4 0x150b7a02 1C67 90 SWAP1 1C68 61 PUSH2 0x1c7b 1C6B 90 SWAP1 1C6C 33 CALLER 1C6D 90 SWAP1 1C6E 89 DUP10 1C6F 90 SWAP1 1C70 88 DUP9 1C71 90 SWAP1 1C72 88 DUP9 1C73 90 SWAP1 1C74 60 PUSH1 0x04 1C76 01 ADD 1C77 61 PUSH2 0x2c1d 1C7A 56 *JUMP 1C7B 5B JUMPDEST 1C7C 60 PUSH1 0x20 1C7E 60 PUSH1 0x40 1C80 51 MLOAD 1C81 80 DUP1 1C82 83 DUP4 1C83 03 SUB 1C84 81 DUP2 1C85 60 PUSH1 0x00 1C87 87 DUP8 1C88 5A GAS 1C89 F1 CALL 1C8A 92 SWAP3 1C8B 50 POP 1C8C 50 POP 1C8D 50 POP 1C8E 80 DUP1 1C8F 15 ISZERO 1C90 61 PUSH2 0x1cb6 1C93 57 *JUMPI 1C94 50 POP 1C95 60 PUSH1 0x40 1C97 80 DUP1 1C98 51 MLOAD 1C99 60 PUSH1 0x1f 1C9B 3D RETURNDATASIZE 1C9C 90 SWAP1 1C9D 81 DUP2 1C9E 01 ADD 1C9F 60 PUSH1 0x1f 1CA1 19 NOT 1CA2 16 AND 1CA3 82 DUP3 1CA4 01 ADD 1CA5 90 SWAP1 1CA6 92 SWAP3 1CA7 52 MSTORE 1CA8 61 PUSH2 0x1cb3 1CAB 91 SWAP2 1CAC 81 DUP2 1CAD 01 ADD 1CAE 90 SWAP1 1CAF 61 PUSH2 0x2c5a 1CB2 56 *JUMP 1CB3 5B JUMPDEST 1CB4 60 PUSH1 0x01 1CB6 5B JUMPDEST 1CB7 61 PUSH2 0x1d14 1CBA 57 *JUMPI 1CBB 3D RETURNDATASIZE 1CBC 80 DUP1 1CBD 80 DUP1 1CBE 15 ISZERO 1CBF 61 PUSH2 0x1ce4 1CC2 57 *JUMPI 1CC3 60 PUSH1 0x40 1CC5 51 MLOAD 1CC6 91 SWAP2 1CC7 50 POP 1CC8 60 PUSH1 0x1f 1CCA 19 NOT 1CCB 60 PUSH1 0x3f 1CCD 3D RETURNDATASIZE 1CCE 01 ADD 1CCF 16 AND 1CD0 82 DUP3 1CD1 01 ADD 1CD2 60 PUSH1 0x40 1CD4 52 MSTORE 1CD5 3D RETURNDATASIZE 1CD6 82 DUP3 1CD7 52 MSTORE 1CD8 3D RETURNDATASIZE 1CD9 60 PUSH1 0x00 1CDB 60 PUSH1 0x20 1CDD 84 DUP5 1CDE 01 ADD 1CDF 3E RETURNDATACOPY 1CE0 61 PUSH2 0x1ce9 1CE3 56 *JUMP 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x60 1CE7 91 SWAP2 1CE8 50 POP 1CE9 5B JUMPDEST 1CEA 50 POP 1CEB 80 DUP1 1CEC 51 MLOAD 1CED 60 PUSH1 0x00 1CEF 03 SUB 1CF0 61 PUSH2 0x1d0c 1CF3 57 *JUMPI 1CF4 60 PUSH1 0x40 1CF6 51 MLOAD 1CF7 63 PUSH4 0x68d2bf6b 1CFC 60 PUSH1 0xe1 1CFE 1B SHL 1CFF 81 DUP2 1D00 52 MSTORE 1D01 60 PUSH1 0x04 1D03 01 ADD 1D04 60 PUSH1 0x40 1D06 51 MLOAD 1D07 80 DUP1 1D08 91 SWAP2 1D09 03 SUB 1D0A 90 SWAP1 1D0B FD *REVERT 1D0C 5B JUMPDEST 1D0D 80 DUP1 1D0E 51 MLOAD 1D0F 81 DUP2 1D10 60 PUSH1 0x20 1D12 01 ADD 1D13 FD *REVERT 1D14 5B JUMPDEST 1D15 60 PUSH1 0x01 1D17 60 PUSH1 0x01 1D19 60 PUSH1 0xe0 1D1B 1B SHL 1D1C 03 SUB 1D1D 19 NOT 1D1E 16 AND 1D1F 63 PUSH4 0x0a85bd01 1D24 60 PUSH1 0xe1 1D26 1B SHL 1D27 14 EQ 1D28 90 SWAP1 1D29 50 POP label_1D2A: // Incoming return from call to 0x24F8 at 0x254B // Incoming return from call to 0x26BE at 0x275C // Inputs[3] // { // @1D2B stack[-1] // @1D2B stack[-6] // @1D2C stack[-5] // } 1D2A 5B JUMPDEST 1D2B 94 SWAP5 1D2C 93 SWAP4 1D2D 50 POP 1D2E 50 POP 1D2F 50 POP 1D30 50 POP 1D31 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D2B stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1D32: // Incoming call from 0x17FA, returns to 0x17FB // Inputs[1] { @1D3A stack[-1] } 1D32 5B JUMPDEST 1D33 60 PUSH1 0x60 1D35 60 PUSH1 0x00 1D37 61 PUSH2 0x1d3f 1D3A 83 DUP4 1D3B 61 PUSH2 0x21ca 1D3E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D33 stack[0] = 0x60 // @1D35 stack[1] = 0x00 // @1D37 stack[2] = 0x1d3f // @1D3A stack[3] = stack[-1] // } // Block ends with call to 0x21ca, returns to 0x1D3F label_1D3F: // Incoming return from call to 0x21CA at 0x1D3E // Inputs[2] // { // @1D42 stack[-1] // @1D43 stack[-2] // } 1D3F 5B JUMPDEST 1D40 60 PUSH1 0x01 1D42 01 ADD 1D43 90 SWAP1 1D44 50 POP 1D45 60 PUSH1 0x00 1D47 81 DUP2 1D48 60 PUSH1 0x01 1D4A 60 PUSH1 0x01 1D4C 60 PUSH1 0x40 1D4E 1B SHL 1D4F 03 SUB 1D50 81 DUP2 1D51 11 GT 1D52 15 ISZERO 1D53 61 PUSH2 0x1d5e 1D56 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1D43 stack[-2] = 0x01 + stack[-1] // @1D45 stack[-1] = 0x00 // @1D47 stack[0] = 0x01 + stack[-1] // } // Block ends with conditional jump to 0x1d5e, if !(0x01 + stack[-1] > (0x01 << 0x40) - 0x01) label_1D57: // Incoming jump from 0x1D56, if not !(0x01 + stack[-1] > (0x01 << 0x40) - 0x01) 1D57 61 PUSH2 0x1d5e 1D5A 61 PUSH2 0x2433 1D5D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D57 stack[0] = 0x1d5e } // Block ends with unconditional jump to 0x2433 label_1D5E: // Incoming jump from 0x1D56, if !(0x01 + stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1D61 memory[0x40:0x60] // @1D62 stack[-1] // } 1D5E 5B JUMPDEST 1D5F 60 PUSH1 0x40 1D61 51 MLOAD 1D62 90 SWAP1 1D63 80 DUP1 1D64 82 DUP3 1D65 52 MSTORE 1D66 80 DUP1 1D67 60 PUSH1 0x1f 1D69 01 ADD 1D6A 60 PUSH1 0x1f 1D6C 19 NOT 1D6D 16 AND 1D6E 60 PUSH1 0x20 1D70 01 ADD 1D71 82 DUP3 1D72 01 ADD 1D73 60 PUSH1 0x40 1D75 52 MSTORE 1D76 80 DUP1 1D77 15 ISZERO 1D78 61 PUSH2 0x1d88 1D7B 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1D62 stack[-1] = memory[0x40:0x60] // @1D62 stack[0] = stack[-1] // @1D65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1D75 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1d88, if !stack[-1] label_1D7C: // Incoming jump from 0x1D7B, if not !stack[-1] // Inputs[7] // { // @1D7E stack[-2] // @1D80 stack[-1] // @1D82 msg.data.length // @1D84 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1D8A stack[-3] // @1D8C stack[-4] // @1DAD stack[-6] // } 1D7C 60 PUSH1 0x20 1D7E 82 DUP3 1D7F 01 ADD 1D80 81 DUP2 1D81 80 DUP1 1D82 36 CALLDATASIZE 1D83 83 DUP4 1D84 37 CALLDATACOPY 1D85 01 ADD 1D86 90 SWAP1 1D87 50 POP 1D88 5B JUMPDEST 1D89 50 POP 1D8A 90 SWAP1 1D8B 50 POP 1D8C 81 DUP2 1D8D 81 DUP2 1D8E 01 ADD 1D8F 60 PUSH1 0x20 1D91 01 ADD 1D92 5B JUMPDEST 1D93 60 PUSH1 0x00 1D95 19 NOT 1D96 01 ADD 1D97 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 1DA8 60 PUSH1 0x81 1DAA 1B SHL 1DAB 60 PUSH1 0x0a 1DAD 86 DUP7 1DAE 06 MOD 1DAF 1A BYTE 1DB0 81 DUP2 1DB1 53 MSTORE8 1DB2 60 PUSH1 0x0a 1DB4 85 DUP6 1DB5 04 DIV 1DB6 94 SWAP5 1DB7 50 POP 1DB8 84 DUP5 1DB9 61 PUSH2 0x1d92 1DBC 57 *JUMPI // Stack delta = -1 // Outputs[5] // { // @1D84 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1D8A stack[-3] = stack[-2] // @1D96 stack[-2] = ~0x00 + 0x20 + stack[-2] + stack[-4] // @1DB1 memory[~0x00 + 0x20 + stack[-2] + stack[-4]:~0x00 + 0x20 + stack[-2] + stack[-4] + 0x01] = byte(0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81, stack[-6] % 0x0a) // @1DB6 stack[-6] = stack[-6] / 0x0a // } // Block ends with conditional jump to 0x1d92, if stack[-6] / 0x0a label_1DBD: // Incoming jump from 0x1DBC, if not stack[-6] / 0x0a // Incoming jump from 0x1DBC, if not stack[-5] / 0x0a // Incoming jump from 0x1DBC, if not stack[-6] / 0x0a // Inputs[3] // { // @1DBE stack[-2] // @1DBE stack[-6] // @1DBF stack[-5] // } 1DBD 50 POP 1DBE 93 SWAP4 1DBF 92 SWAP3 1DC0 50 POP 1DC1 50 POP 1DC2 50 POP 1DC3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1DBE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1DC4: // Incoming jump from 0x1A4C // Inputs[1] { @1DD2 stack[-1] } 1DC4 5B JUMPDEST 1DC5 60 PUSH1 0x60 1DC7 61 PUSH2 0x05ff 1DCA 60 PUSH1 0x01 1DCC 60 PUSH1 0x01 1DCE 60 PUSH1 0xa0 1DD0 1B SHL 1DD1 03 SUB 1DD2 83 DUP4 1DD3 16 AND 1DD4 60 PUSH1 0x14 1DD6 5B JUMPDEST 1DD7 60 PUSH1 0x60 1DD9 60 PUSH1 0x00 1DDB 61 PUSH2 0x1de5 1DDE 83 DUP4 1DDF 60 PUSH1 0x02 1DE1 61 PUSH2 0x29bb 1DE4 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @1DC5 stack[0] = 0x60 // @1DC7 stack[1] = 0x05ff // @1DD3 stack[2] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1DD4 stack[3] = 0x14 // @1DD7 stack[4] = 0x60 // @1DD9 stack[5] = 0x00 // @1DDB stack[6] = 0x1de5 // @1DDE stack[7] = 0x14 // @1DDF stack[8] = 0x02 // } // Block ends with call to 0x29bb, returns to 0x1DE5 label_1DE5: // Incoming return from call to 0x29BB at 0x1DE4 // Inputs[1] { @1DE9 stack[-1] } 1DE5 5B JUMPDEST 1DE6 61 PUSH2 0x1df0 1DE9 90 SWAP1 1DEA 60 PUSH1 0x02 1DEC 61 PUSH2 0x2c77 1DEF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DE9 stack[0] = stack[-1] // @1DE9 stack[-1] = 0x1df0 // @1DEA stack[1] = 0x02 // } // Block ends with call to 0x2c77, returns to 0x1DF0 label_1DF0: // Incoming return from call to 0x2C77 at 0x1DEF // Inputs[1] { @1DF9 stack[-1] } 1DF0 5B JUMPDEST 1DF1 60 PUSH1 0x01 1DF3 60 PUSH1 0x01 1DF5 60 PUSH1 0x40 1DF7 1B SHL 1DF8 03 SUB 1DF9 81 DUP2 1DFA 11 GT 1DFB 15 ISZERO 1DFC 61 PUSH2 0x1e07 1DFF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e07, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1E00: // Incoming jump from 0x1DFF, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1E00 61 PUSH2 0x1e07 1E03 61 PUSH2 0x2433 1E06 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E00 stack[0] = 0x1e07 } // Block ends with unconditional jump to 0x2433 label_1E07: // Incoming jump from 0x1DFF, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1E0A memory[0x40:0x60] // @1E0B stack[-1] // } 1E07 5B JUMPDEST 1E08 60 PUSH1 0x40 1E0A 51 MLOAD 1E0B 90 SWAP1 1E0C 80 DUP1 1E0D 82 DUP3 1E0E 52 MSTORE 1E0F 80 DUP1 1E10 60 PUSH1 0x1f 1E12 01 ADD 1E13 60 PUSH1 0x1f 1E15 19 NOT 1E16 16 AND 1E17 60 PUSH1 0x20 1E19 01 ADD 1E1A 82 DUP3 1E1B 01 ADD 1E1C 60 PUSH1 0x40 1E1E 52 MSTORE 1E1F 80 DUP1 1E20 15 ISZERO 1E21 61 PUSH2 0x1e31 1E24 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1E0B stack[-1] = memory[0x40:0x60] // @1E0B stack[0] = stack[-1] // @1E0E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1E1E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1e31, if !stack[-1] label_1E25: // Incoming jump from 0x1E24, if not !stack[-1] // Inputs[6] // { // @1E27 stack[-2] // @1E29 stack[-1] // @1E2B msg.data.length // @1E2D msg.data[msg.data.length:msg.data.length + stack[-1]] // @1E33 stack[-3] // @1E3E memory[stack[-2]:stack[-2] + 0x20] // } 1E25 60 PUSH1 0x20 1E27 82 DUP3 1E28 01 ADD 1E29 81 DUP2 1E2A 80 DUP1 1E2B 36 CALLDATASIZE 1E2C 83 DUP4 1E2D 37 CALLDATACOPY 1E2E 01 ADD 1E2F 90 SWAP1 1E30 50 POP 1E31 5B JUMPDEST 1E32 50 POP 1E33 90 SWAP1 1E34 50 POP 1E35 60 PUSH1 0x03 1E37 60 PUSH1 0xfc 1E39 1B SHL 1E3A 81 DUP2 1E3B 60 PUSH1 0x00 1E3D 81 DUP2 1E3E 51 MLOAD 1E3F 81 DUP2 1E40 10 LT 1E41 61 PUSH2 0x1e4c 1E44 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1E2D memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1E33 stack[-3] = stack[-2] // @1E39 stack[-2] = 0x03 << 0xfc // @1E3A stack[-1] = stack[-2] // @1E3B stack[0] = 0x00 // } // Block ends with conditional jump to 0x1e4c, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_1E45: // Incoming jump from 0x1E44, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1E44, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 1E45 61 PUSH2 0x1e4c 1E48 61 PUSH2 0x29fc 1E4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E45 stack[0] = 0x1e4c } // Block ends with unconditional jump to 0x29fc label_1E4C: // Incoming jump from 0x1E44, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1E44, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @1E4F stack[-1] // @1E50 stack[-2] // @1E51 stack[-3] // @1E69 stack[-4] // @1E6D memory[stack[-4]:stack[-4] + 0x20] // } 1E4C 5B JUMPDEST 1E4D 60 PUSH1 0x20 1E4F 01 ADD 1E50 01 ADD 1E51 90 SWAP1 1E52 60 PUSH1 0x01 1E54 60 PUSH1 0x01 1E56 60 PUSH1 0xf8 1E58 1B SHL 1E59 03 SUB 1E5A 19 NOT 1E5B 16 AND 1E5C 90 SWAP1 1E5D 81 DUP2 1E5E 60 PUSH1 0x00 1E60 1A BYTE 1E61 90 SWAP1 1E62 53 MSTORE8 1E63 50 POP 1E64 60 PUSH1 0x0f 1E66 60 PUSH1 0xfb 1E68 1B SHL 1E69 81 DUP2 1E6A 60 PUSH1 0x01 1E6C 81 DUP2 1E6D 51 MLOAD 1E6E 81 DUP2 1E6F 10 LT 1E70 61 PUSH2 0x1e7b 1E73 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1E62 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1E68 stack[-3] = 0x0f << 0xfb // @1E69 stack[-2] = stack[-4] // @1E6A stack[-1] = 0x01 // } // Block ends with conditional jump to 0x1e7b, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_1E74: // Incoming jump from 0x1E73, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 1E74 61 PUSH2 0x1e7b 1E77 61 PUSH2 0x29fc 1E7A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E74 stack[0] = 0x1e7b } // Block ends with unconditional jump to 0x29fc label_1E7B: // Incoming jump from 0x1E73, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @1E7E stack[-1] // @1E7F stack[-2] // @1E80 stack[-3] // @1E98 stack[-6] // } 1E7B 5B JUMPDEST 1E7C 60 PUSH1 0x20 1E7E 01 ADD 1E7F 01 ADD 1E80 90 SWAP1 1E81 60 PUSH1 0x01 1E83 60 PUSH1 0x01 1E85 60 PUSH1 0xf8 1E87 1B SHL 1E88 03 SUB 1E89 19 NOT 1E8A 16 AND 1E8B 90 SWAP1 1E8C 81 DUP2 1E8D 60 PUSH1 0x00 1E8F 1A BYTE 1E90 90 SWAP1 1E91 53 MSTORE8 1E92 50 POP 1E93 60 PUSH1 0x00 1E95 61 PUSH2 0x1e9f 1E98 84 DUP5 1E99 60 PUSH1 0x02 1E9B 61 PUSH2 0x29bb 1E9E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1E91 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1E93 stack[-3] = 0x00 // @1E95 stack[-2] = 0x1e9f // @1E98 stack[-1] = stack[-6] // @1E99 stack[0] = 0x02 // } // Block ends with call to 0x29bb, returns to 0x1E9F label_1E9F: // Incoming return from call to 0x29BB at 0x1E9E // Inputs[1] { @1EA3 stack[-1] } 1E9F 5B JUMPDEST 1EA0 61 PUSH2 0x1eaa 1EA3 90 SWAP1 1EA4 60 PUSH1 0x01 1EA6 61 PUSH2 0x2c77 1EA9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1EA3 stack[0] = stack[-1] // @1EA3 stack[-1] = 0x1eaa // @1EA4 stack[1] = 0x01 // } // Block ends with call to 0x2c77, returns to 0x1EAA label_1EAA: // Incoming return from call to 0x2C77 at 0x1EA9 // Inputs[2] // { // @1EAB stack[-1] // @1EAB stack[-2] // } 1EAA 5B JUMPDEST 1EAB 90 SWAP1 1EAC 50 POP 1EAD 5B JUMPDEST 1EAE 60 PUSH1 0x01 1EB0 81 DUP2 1EB1 11 GT 1EB2 15 ISZERO 1EB3 61 PUSH2 0x1f22 1EB6 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1EAB stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1f22, if !(stack[-1] > 0x01) label_1EB7: // Incoming jump from 0x1EB6, if not !(stack[-1] > 0x01) // Incoming jump from 0x1EB6, if not !(stack[-1] > 0x01) // Inputs[1] { @1ECB stack[-5] } 1EB7 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 1EC8 60 PUSH1 0x81 1ECA 1B SHL 1ECB 85 DUP6 1ECC 60 PUSH1 0x0f 1ECE 16 AND 1ECF 60 PUSH1 0x10 1ED1 81 DUP2 1ED2 10 LT 1ED3 61 PUSH2 0x1ede 1ED6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ECA stack[0] = 0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81 // @1ECE stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x1ede, if 0x0f & stack[-5] < 0x10 label_1ED7: // Incoming jump from 0x1ED6, if not 0x0f & stack[-5] < 0x10 1ED7 61 PUSH2 0x1ede 1EDA 61 PUSH2 0x29fc 1EDD 56 *JUMP // Stack delta = +1 // Outputs[1] { @1ED7 stack[0] = 0x1ede } // Block ends with unconditional jump to 0x29fc label_1EDE: // Incoming jump from 0x1ED6, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @1EDF stack[-1] // @1EDF stack[-2] // @1EE3 stack[-4] // @1EE4 stack[-3] // @1EE6 memory[stack[-4]:stack[-4] + 0x20] // } 1EDE 5B JUMPDEST 1EDF 1A BYTE 1EE0 60 PUSH1 0xf8 1EE2 1B SHL 1EE3 82 DUP3 1EE4 82 DUP3 1EE5 81 DUP2 1EE6 51 MLOAD 1EE7 81 DUP2 1EE8 10 LT 1EE9 61 PUSH2 0x1ef4 1EEC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1EE2 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @1EE3 stack[-1] = stack[-4] // @1EE4 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1ef4, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_1EED: // Incoming jump from 0x1EEC, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 1EED 61 PUSH2 0x1ef4 1EF0 61 PUSH2 0x29fc 1EF3 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EED stack[0] = 0x1ef4 } // Block ends with unconditional jump to 0x29fc label_1EF4: // Incoming jump from 0x1EEC, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @1EF7 stack[-1] // @1EF8 stack[-2] // @1EF9 stack[-3] // @1F0E stack[-8] // @1F0F stack[-4] // } 1EF4 5B JUMPDEST 1EF5 60 PUSH1 0x20 1EF7 01 ADD 1EF8 01 ADD 1EF9 90 SWAP1 1EFA 60 PUSH1 0x01 1EFC 60 PUSH1 0x01 1EFE 60 PUSH1 0xf8 1F00 1B SHL 1F01 03 SUB 1F02 19 NOT 1F03 16 AND 1F04 90 SWAP1 1F05 81 DUP2 1F06 60 PUSH1 0x00 1F08 1A BYTE 1F09 90 SWAP1 1F0A 53 MSTORE8 1F0B 50 POP 1F0C 60 PUSH1 0x04 1F0E 94 SWAP5 1F0F 90 SWAP1 1F10 94 SWAP5 1F11 1C SHR 1F12 93 SWAP4 1F13 61 PUSH2 0x1f1b 1F16 81 DUP2 1F17 61 PUSH2 0x2c8f 1F1A 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1F0A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1F12 stack[-4] = stack[-4] // @1F12 stack[-8] = stack[-8] >> 0x04 // @1F13 stack[-3] = 0x1f1b // @1F16 stack[-2] = stack[-4] // } // Block ends with call to 0x2c8f, returns to 0x1F1B label_1F1B: // Incoming return from call to 0x2C8F at 0x1F1A // Inputs[2] // { // @1F1C stack[-1] // @1F1C stack[-2] // } 1F1B 5B JUMPDEST 1F1C 90 SWAP1 1F1D 50 POP 1F1E 61 PUSH2 0x1ead 1F21 56 *JUMP // Stack delta = -1 // Outputs[1] { @1F1C stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1ead label_1F22: // Incoming jump from 0x1EB6, if !(stack[-1] > 0x01) // Incoming jump from 0x1EB6, if !(stack[-1] > 0x01) // Inputs[1] { @1F24 stack[-5] } 1F22 5B JUMPDEST 1F23 50 POP 1F24 83 DUP4 1F25 15 ISZERO 1F26 61 PUSH2 0x1f71 1F29 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f71, if !stack[-5] label_1F2A: // Incoming jump from 0x1F29, if not !stack[-5] // Inputs[1] { @1F2C memory[0x40:0x60] } 1F2A 60 PUSH1 0x40 1F2C 51 MLOAD 1F2D 62 PUSH3 0x461bcd 1F31 60 PUSH1 0xe5 1F33 1B SHL 1F34 81 DUP2 1F35 52 MSTORE 1F36 60 PUSH1 0x20 1F38 60 PUSH1 0x04 1F3A 82 DUP3 1F3B 01 ADD 1F3C 81 DUP2 1F3D 90 SWAP1 1F3E 52 MSTORE 1F3F 60 PUSH1 0x24 1F41 82 DUP3 1F42 01 ADD 1F43 52 MSTORE 1F44 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 1F65 60 PUSH1 0x44 1F67 82 DUP3 1F68 01 ADD 1F69 52 MSTORE 1F6A 60 PUSH1 0x64 1F6C 01 ADD 1F6D 61 PUSH2 0x0870 1F70 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1F35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F3E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1F43 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1F69 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @1F6C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0870 label_1F71: // Incoming return from call to 0x233B at 0x236D // Incoming return from call to 0x239A at 0x23D8 // Incoming return from call to 0x27C5 at 0x2A47 // Incoming jump from 0x1F29, if !stack[-5] // Incoming return from call to 0x23F2 at 0x27C4 // Incoming return from call to 0x24A1 at 0x2517 // Inputs[3] // { // @1F72 stack[-1] // @1F72 stack[-5] // @1F73 stack[-4] // } 1F71 5B JUMPDEST 1F72 93 SWAP4 1F73 92 SWAP3 1F74 50 POP 1F75 50 POP 1F76 50 POP 1F77 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F72 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1F78: // Incoming jump from 0x1AFE // Inputs[1] { @1F7B storage[0x00] } 1F78 5B JUMPDEST 1F79 60 PUSH1 0x00 1F7B 54 SLOAD 1F7C 61 PUSH2 0x0100 1F7F 90 SWAP1 1F80 04 DIV 1F81 60 PUSH1 0xff 1F83 16 AND 1F84 61 PUSH2 0x1f9f 1F87 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f9f, if 0xff & storage[0x00] / 0x0100 label_1F88: // Incoming jump from 0x1F87, if not 0xff & storage[0x00] / 0x0100 // Inputs[1] { @1F8A memory[0x40:0x60] } 1F88 60 PUSH1 0x40 1F8A 51 MLOAD 1F8B 62 PUSH3 0x461bcd 1F8F 60 PUSH1 0xe5 1F91 1B SHL 1F92 81 DUP2 1F93 52 MSTORE 1F94 60 PUSH1 0x04 1F96 01 ADD 1F97 61 PUSH2 0x0870 1F9A 90 SWAP1 1F9B 61 PUSH2 0x2a48 1F9E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F9A stack[0] = 0x0870 // @1F9A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a48, returns to 0x0870 label_1F9F: // Incoming jump from 0x1F87, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @1FA3 msg.sender } 1F9F 5B JUMPDEST 1FA0 61 PUSH2 0x0bb4 1FA3 33 CALLER 1FA4 61 PUSH2 0x1604 1FA7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FA0 stack[0] = 0x0bb4 // @1FA3 stack[1] = msg.sender // } // Block ends with call to 0x1604, returns to 0x0BB4 1FA8 5B JUMPDEST 1FA9 60 PUSH1 0x00 1FAB 80 DUP1 1FAC 51 MLOAD 1FAD 60 PUSH1 0x20 1FAF 61 PUSH2 0x2ca7 1FB2 83 DUP4 1FB3 39 CODECOPY 1FB4 81 DUP2 1FB5 51 MLOAD 1FB6 91 SWAP2 1FB7 52 MSTORE 1FB8 54 SLOAD 1FB9 61 PUSH2 0x0100 1FBC 90 SWAP1 1FBD 04 DIV 1FBE 60 PUSH1 0xff 1FC0 16 AND 1FC1 61 PUSH2 0x1fdc 1FC4 57 *JUMPI 1FC5 60 PUSH1 0x40 1FC7 51 MLOAD 1FC8 62 PUSH3 0x461bcd 1FCC 60 PUSH1 0xe5 1FCE 1B SHL 1FCF 81 DUP2 1FD0 52 MSTORE 1FD1 60 PUSH1 0x04 1FD3 01 ADD 1FD4 61 PUSH2 0x0870 1FD7 90 SWAP1 1FD8 61 PUSH2 0x2bc9 1FDB 56 *JUMP 1FDC 5B JUMPDEST 1FDD 81 DUP2 1FDE 61 PUSH2 0x1fe5 1FE1 61 PUSH2 0x0dd4 1FE4 56 *JUMP 1FE5 5B JUMPDEST 1FE6 60 PUSH1 0x02 1FE8 01 ADD 1FE9 90 SWAP1 1FEA 80 DUP1 1FEB 51 MLOAD 1FEC 90 SWAP1 1FED 60 PUSH1 0x20 1FEF 01 ADD 1FF0 90 SWAP1 1FF1 61 PUSH2 0x1ffb 1FF4 92 SWAP3 1FF5 91 SWAP2 1FF6 90 SWAP1 1FF7 61 PUSH2 0x22a2 1FFA 56 *JUMP 1FFB 5B JUMPDEST 1FFC 50 POP 1FFD 80 DUP1 1FFE 61 PUSH2 0x2005 2001 61 PUSH2 0x0dd4 2004 56 *JUMP 2005 5B JUMPDEST 2006 60 PUSH1 0x03 2008 01 ADD 2009 90 SWAP1 200A 80 DUP1 200B 51 MLOAD 200C 90 SWAP1 200D 60 PUSH1 0x20 200F 01 ADD 2010 90 SWAP1 2011 61 PUSH2 0x201b 2014 92 SWAP3 2015 91 SWAP2 2016 90 SWAP1 2017 61 PUSH2 0x22a2 201A 56 *JUMP 201B 5B JUMPDEST 201C 50 POP 201D 60 PUSH1 0x01 201F 61 PUSH2 0x2026 2022 61 PUSH2 0x0dd4 2025 56 *JUMP 2026 5B JUMPDEST 2027 55 SSTORE 2028 50 POP 2029 50 POP 202A 56 *JUMP 202B 5B JUMPDEST 202C 60 PUSH1 0x00 202E 54 SLOAD 202F 61 PUSH2 0x0100 2032 90 SWAP1 2033 04 DIV 2034 60 PUSH1 0xff 2036 16 AND 2037 61 PUSH2 0x2052 203A 57 *JUMPI 203B 60 PUSH1 0x40 203D 51 MLOAD 203E 62 PUSH3 0x461bcd 2042 60 PUSH1 0xe5 2044 1B SHL 2045 81 DUP2 2046 52 MSTORE 2047 60 PUSH1 0x04 2049 01 ADD 204A 61 PUSH2 0x0870 204D 90 SWAP1 204E 61 PUSH2 0x2a48 2051 56 *JUMP 2052 5B JUMPDEST 2053 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 2062 3B EXTCODESIZE 2063 15 ISZERO 2064 61 PUSH2 0x071a 2067 57 *JUMPI 2068 60 PUSH1 0x40 206A 51 MLOAD 206B 63 PUSH4 0xc3c5a547 2070 60 PUSH1 0xe0 2072 1B SHL 2073 81 DUP2 2074 52 MSTORE 2075 30 ADDRESS 2076 60 PUSH1 0x04 2078 82 DUP3 2079 01 ADD 207A 52 MSTORE 207B 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 208A 90 SWAP1 208B 63 PUSH4 0xc3c5a547 2090 90 SWAP1 2091 60 PUSH1 0x24 2093 01 ADD 2094 60 PUSH1 0x20 2096 60 PUSH1 0x40 2098 51 MLOAD 2099 80 DUP1 209A 83 DUP4 209B 03 SUB 209C 81 DUP2 209D 60 PUSH1 0x00 209F 87 DUP8 20A0 5A GAS 20A1 F1 CALL 20A2 15 ISZERO 20A3 80 DUP1 20A4 15 ISZERO 20A5 61 PUSH2 0x20b2 20A8 57 *JUMPI 20A9 3D RETURNDATASIZE 20AA 60 PUSH1 0x00 20AC 80 DUP1 20AD 3E RETURNDATACOPY 20AE 3D RETURNDATASIZE 20AF 60 PUSH1 0x00 20B1 FD *REVERT 20B2 5B JUMPDEST 20B3 50 POP 20B4 50 POP 20B5 50 POP 20B6 50 POP 20B7 60 PUSH1 0x40 20B9 51 MLOAD 20BA 3D RETURNDATASIZE 20BB 60 PUSH1 0x1f 20BD 19 NOT 20BE 60 PUSH1 0x1f 20C0 82 DUP3 20C1 01 ADD 20C2 16 AND 20C3 82 DUP3 20C4 01 ADD 20C5 80 DUP1 20C6 60 PUSH1 0x40 20C8 52 MSTORE 20C9 50 POP 20CA 81 DUP2 20CB 01 ADD 20CC 90 SWAP1 20CD 61 PUSH2 0x20d6 20D0 91 SWAP2 20D1 90 SWAP1 20D2 61 PUSH2 0x2a2b 20D5 56 *JUMP 20D6 5B JUMPDEST 20D7 61 PUSH2 0x071a 20DA 57 *JUMPI 20DB 80 DUP1 20DC 15 ISZERO 20DD 61 PUSH2 0x214a 20E0 57 *JUMPI 20E1 60 PUSH1 0x40 20E3 51 MLOAD 20E4 63 PUSH4 0x3e9f1edf 20E9 60 PUSH1 0xe1 20EB 1B SHL 20EC 81 DUP2 20ED 52 MSTORE 20EE 30 ADDRESS 20EF 60 PUSH1 0x04 20F1 82 DUP3 20F2 01 ADD 20F3 52 MSTORE 20F4 60 PUSH1 0x01 20F6 60 PUSH1 0x01 20F8 60 PUSH1 0xa0 20FA 1B SHL 20FB 03 SUB 20FC 83 DUP4 20FD 16 AND 20FE 60 PUSH1 0x24 2100 82 DUP3 2101 01 ADD 2102 52 MSTORE 2103 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 2112 90 SWAP1 2113 63 PUSH4 0x7d3e3dbe 2118 90 SWAP1 2119 60 PUSH1 0x44 211B 01 ADD 211C 5B JUMPDEST 211D 60 PUSH1 0x00 211F 60 PUSH1 0x40 2121 51 MLOAD 2122 80 DUP1 2123 83 DUP4 2124 03 SUB 2125 81 DUP2 2126 60 PUSH1 0x00 2128 87 DUP8 2129 80 DUP1 212A 3B EXTCODESIZE 212B 15 ISZERO 212C 80 DUP1 212D 15 ISZERO 212E 61 PUSH2 0x2136 2131 57 *JUMPI 2132 60 PUSH1 0x00 2134 80 DUP1 2135 FD *REVERT 2136 5B JUMPDEST 2137 50 POP 2138 5A GAS 2139 F1 CALL 213A 15 ISZERO 213B 80 DUP1 213C 15 ISZERO 213D 61 PUSH2 0x113e 2140 57 *JUMPI 2141 3D RETURNDATASIZE 2142 60 PUSH1 0x00 2144 80 DUP1 2145 3E RETURNDATACOPY 2146 3D RETURNDATASIZE 2147 60 PUSH1 0x00 2149 FD *REVERT 214A 5B JUMPDEST 214B 60 PUSH1 0x01 214D 60 PUSH1 0x01 214F 60 PUSH1 0xa0 2151 1B SHL 2152 03 SUB 2153 82 DUP3 2154 16 AND 2155 15 ISZERO 2156 61 PUSH2 0x2199 2159 57 *JUMPI 215A 60 PUSH1 0x40 215C 51 MLOAD 215D 63 PUSH4 0xa0af2903 2162 60 PUSH1 0xe0 2164 1B SHL 2165 81 DUP2 2166 52 MSTORE 2167 30 ADDRESS 2168 60 PUSH1 0x04 216A 82 DUP3 216B 01 ADD 216C 52 MSTORE 216D 60 PUSH1 0x01 216F 60 PUSH1 0x01 2171 60 PUSH1 0xa0 2173 1B SHL 2174 03 SUB 2175 83 DUP4 2176 16 AND 2177 60 PUSH1 0x24 2179 82 DUP3 217A 01 ADD 217B 52 MSTORE 217C 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 218B 90 SWAP1 218C 63 PUSH4 0xa0af2903 2191 90 SWAP1 2192 60 PUSH1 0x44 2194 01 ADD 2195 61 PUSH2 0x211c 2198 56 *JUMP 2199 5B JUMPDEST 219A 60 PUSH1 0x40 219C 51 MLOAD 219D 63 PUSH4 0x22107243 21A2 60 PUSH1 0xe1 21A4 1B SHL 21A5 81 DUP2 21A6 52 MSTORE 21A7 30 ADDRESS 21A8 60 PUSH1 0x04 21AA 82 DUP3 21AB 01 ADD 21AC 52 MSTORE 21AD 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 21BC 90 SWAP1 21BD 63 PUSH4 0x4420e486 21C2 90 SWAP1 21C3 60 PUSH1 0x24 21C5 01 ADD 21C6 61 PUSH2 0x211c 21C9 56 *JUMP label_21CA: // Incoming call from 0x1D3E, returns to 0x1D3F // Inputs[1] { @21E5 stack[-1] } 21CA 5B JUMPDEST 21CB 60 PUSH1 0x00 21CD 80 DUP1 21CE 72 PUSH19 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 21E2 60 PUSH1 0x40 21E4 1B SHL 21E5 83 DUP4 21E6 10 LT 21E7 61 PUSH2 0x2209 21EA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21CB stack[0] = 0x00 // @21CD stack[1] = 0x00 // } // Block ends with conditional jump to 0x2209, if stack[-1] < 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40 label_21EB: // Incoming jump from 0x21EA, if not stack[-1] < 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40 // Inputs[2] // { // @2202 stack[-3] // @2208 stack[-1] // } 21EB 72 PUSH19 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 21FF 60 PUSH1 0x40 2201 1B SHL 2202 83 DUP4 2203 04 DIV 2204 92 SWAP3 2205 50 POP 2206 60 PUSH1 0x40 2208 01 ADD 2209 5B JUMPDEST 220A 6D PUSH14 0x04ee2d6d415b85acef8100000000 2219 83 DUP4 221A 10 LT 221B 61 PUSH2 0x2235 221E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2204 stack[-3] = stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) // @2208 stack[-1] = 0x40 + stack[-1] // } // Block ends with conditional jump to 0x2235, if stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) < 0x04ee2d6d415b85acef8100000000 label_221F: // Incoming jump from 0x221E, if not stack[-3] / (0x184f03e93ff9f4daa797ed6e38ed64bf6a1f01 << 0x40) < 0x04ee2d6d415b85acef8100000000 // Incoming jump from 0x221E, if not stack[-3] < 0x04ee2d6d415b85acef8100000000 // Inputs[2] // { // @222E stack[-3] // @2234 stack[-1] // } 221F 6D PUSH14 0x04ee2d6d415b85acef8100000000 222E 83 DUP4 222F 04 DIV 2230 92 SWAP3 2231 50 POP 2232 60 PUSH1 0x20 2234 01 ADD 2235 5B JUMPDEST 2236 66 PUSH7 0x2386f26fc10000 223E 83 DUP4 223F 10 LT 2240 61 PUSH2 0x2253 2243 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2230 stack[-3] = stack[-3] / 0x04ee2d6d415b85acef8100000000 // @2234 stack[-1] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x2253, if stack[-3] / 0x04ee2d6d415b85acef8100000000 < 0x2386f26fc10000 label_2244: // Incoming jump from 0x2243, if not stack[-3] < 0x2386f26fc10000 // Incoming jump from 0x2243, if not stack[-3] / 0x04ee2d6d415b85acef8100000000 < 0x2386f26fc10000 // Inputs[2] // { // @224C stack[-3] // @2252 stack[-1] // } 2244 66 PUSH7 0x2386f26fc10000 224C 83 DUP4 224D 04 DIV 224E 92 SWAP3 224F 50 POP 2250 60 PUSH1 0x10 2252 01 ADD 2253 5B JUMPDEST 2254 63 PUSH4 0x05f5e100 2259 83 DUP4 225A 10 LT 225B 61 PUSH2 0x226b 225E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @224E stack[-3] = stack[-3] / 0x2386f26fc10000 // @2252 stack[-1] = 0x10 + stack[-1] // } // Block ends with conditional jump to 0x226b, if stack[-3] / 0x2386f26fc10000 < 0x05f5e100 label_225F: // Incoming jump from 0x225E, if not stack[-3] < 0x05f5e100 // Incoming jump from 0x225E, if not stack[-3] / 0x2386f26fc10000 < 0x05f5e100 // Inputs[2] // { // @2264 stack[-3] // @226A stack[-1] // } 225F 63 PUSH4 0x05f5e100 2264 83 DUP4 2265 04 DIV 2266 92 SWAP3 2267 50 POP 2268 60 PUSH1 0x08 226A 01 ADD 226B 5B JUMPDEST 226C 61 PUSH2 0x2710 226F 83 DUP4 2270 10 LT 2271 61 PUSH2 0x227f 2274 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2266 stack[-3] = stack[-3] / 0x05f5e100 // @226A stack[-1] = 0x08 + stack[-1] // } // Block ends with conditional jump to 0x227f, if stack[-3] / 0x05f5e100 < 0x2710 label_2275: // Incoming jump from 0x2274, if not stack[-3] / 0x05f5e100 < 0x2710 // Incoming jump from 0x2274, if not stack[-3] < 0x2710 // Inputs[2] // { // @2278 stack[-3] // @227E stack[-1] // } 2275 61 PUSH2 0x2710 2278 83 DUP4 2279 04 DIV 227A 92 SWAP3 227B 50 POP 227C 60 PUSH1 0x04 227E 01 ADD 227F 5B JUMPDEST 2280 60 PUSH1 0x64 2282 83 DUP4 2283 10 LT 2284 61 PUSH2 0x2291 2287 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @227A stack[-3] = stack[-3] / 0x2710 // @227E stack[-1] = 0x04 + stack[-1] // } // Block ends with conditional jump to 0x2291, if stack[-3] / 0x2710 < 0x64 label_2288: // Incoming jump from 0x2287, if not stack[-3] < 0x64 // Incoming jump from 0x2287, if not stack[-3] / 0x2710 < 0x64 // Inputs[2] // { // @228A stack[-3] // @2290 stack[-1] // } 2288 60 PUSH1 0x64 228A 83 DUP4 228B 04 DIV 228C 92 SWAP3 228D 50 POP 228E 60 PUSH1 0x02 2290 01 ADD 2291 5B JUMPDEST 2292 60 PUSH1 0x0a 2294 83 DUP4 2295 10 LT 2296 61 PUSH2 0x05ff 2299 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @228C stack[-3] = stack[-3] / 0x64 // @2290 stack[-1] = 0x02 + stack[-1] // } // Block ends with conditional jump to 0x05ff, if stack[-3] / 0x64 < 0x0a label_229A: // Incoming jump from 0x2299, if not stack[-3] < 0x0a // Incoming jump from 0x2299, if not stack[-3] / 0x64 < 0x0a // Inputs[3] // { // @229C stack[-1] // @229D stack[-4] // @229E stack[-3] // } 229A 60 PUSH1 0x01 229C 01 ADD 229D 92 SWAP3 229E 91 SWAP2 229F 50 POP 22A0 50 POP 22A1 56 *JUMP // Stack delta = -3 // Outputs[1] { @229D stack[-4] = 0x01 + stack[-1] } // Block ends with unconditional jump to stack[-4] 22A2 5B JUMPDEST 22A3 82 DUP3 22A4 80 DUP1 22A5 54 SLOAD 22A6 61 PUSH2 0x22ae 22A9 90 SWAP1 22AA 61 PUSH2 0x296b 22AD 56 *JUMP 22AE 5B JUMPDEST 22AF 90 SWAP1 22B0 60 PUSH1 0x00 22B2 52 MSTORE 22B3 60 PUSH1 0x20 22B5 60 PUSH1 0x00 22B7 20 SHA3 22B8 90 SWAP1 22B9 60 PUSH1 0x1f 22BB 01 ADD 22BC 60 PUSH1 0x20 22BE 90 SWAP1 22BF 04 DIV 22C0 81 DUP2 22C1 01 ADD 22C2 92 SWAP3 22C3 82 DUP3 22C4 61 PUSH2 0x22d0 22C7 57 *JUMPI 22C8 60 PUSH1 0x00 22CA 85 DUP6 22CB 55 SSTORE 22CC 61 PUSH2 0x2316 22CF 56 *JUMP 22D0 5B JUMPDEST 22D1 82 DUP3 22D2 60 PUSH1 0x1f 22D4 10 LT 22D5 61 PUSH2 0x22e9 22D8 57 *JUMPI 22D9 80 DUP1 22DA 51 MLOAD 22DB 60 PUSH1 0xff 22DD 19 NOT 22DE 16 AND 22DF 83 DUP4 22E0 80 DUP1 22E1 01 ADD 22E2 17 OR 22E3 85 DUP6 22E4 55 SSTORE 22E5 61 PUSH2 0x2316 22E8 56 *JUMP 22E9 5B JUMPDEST 22EA 82 DUP3 22EB 80 DUP1 22EC 01 ADD 22ED 60 PUSH1 0x01 22EF 01 ADD 22F0 85 DUP6 22F1 55 SSTORE 22F2 82 DUP3 22F3 15 ISZERO 22F4 61 PUSH2 0x2316 22F7 57 *JUMPI 22F8 91 SWAP2 22F9 82 DUP3 22FA 01 ADD 22FB 5B JUMPDEST 22FC 82 DUP3 22FD 81 DUP2 22FE 11 GT 22FF 15 ISZERO 2300 61 PUSH2 0x2316 2303 57 *JUMPI 2304 82 DUP3 2305 51 MLOAD 2306 82 DUP3 2307 55 SSTORE 2308 91 SWAP2 2309 60 PUSH1 0x20 230B 01 ADD 230C 91 SWAP2 230D 90 SWAP1 230E 60 PUSH1 0x01 2310 01 ADD 2311 90 SWAP1 2312 61 PUSH2 0x22fb 2315 56 *JUMP 2316 5B JUMPDEST 2317 50 POP 2318 61 PUSH2 0x2322 231B 92 SWAP3 231C 91 SWAP2 231D 50 POP 231E 61 PUSH2 0x2326 2321 56 *JUMP 2322 5B JUMPDEST 2323 50 POP 2324 90 SWAP1 2325 56 *JUMP 2326 5B JUMPDEST 2327 5B JUMPDEST 2328 80 DUP1 2329 82 DUP3 232A 11 GT 232B 15 ISZERO 232C 61 PUSH2 0x2322 232F 57 *JUMPI 2330 60 PUSH1 0x00 2332 81 DUP2 2333 55 SSTORE 2334 60 PUSH1 0x01 2336 01 ADD 2337 61 PUSH2 0x2327 233A 56 *JUMP label_233B: // Incoming call from 0x236D, returns to 0x1F71 // Inputs[1] { @2345 stack[-1] } 233B 5B JUMPDEST 233C 60 PUSH1 0x01 233E 60 PUSH1 0x01 2340 60 PUSH1 0xe0 2342 1B SHL 2343 03 SUB 2344 19 NOT 2345 81 DUP2 2346 16 AND 2347 81 DUP2 2348 14 EQ 2349 61 PUSH2 0x09d6 234C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d6, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_234D: // Incoming jump from 0x234C, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2350 memory[0x00:0x00] } 234D 60 PUSH1 0x00 234F 80 DUP1 2350 FD *REVERT // Stack delta = +0 // Outputs[1] { @2350 revert(memory[0x00:0x00]); } // Block terminates label_2351: // Incoming call from 0x0202, returns to 0x0203 // Inputs[2] // { // @2356 stack[-1] // @2357 stack[-2] // } 2351 5B JUMPDEST 2352 60 PUSH1 0x00 2354 60 PUSH1 0x20 2356 82 DUP3 2357 84 DUP5 2358 03 SUB 2359 12 SLT 235A 15 ISZERO 235B 61 PUSH2 0x2363 235E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2352 stack[0] = 0x00 } // Block ends with conditional jump to 0x2363, if !(stack[-2] - stack[-1] i< 0x20) label_235F: // Incoming jump from 0x235E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2362 memory[0x00:0x00] } 235F 60 PUSH1 0x00 2361 80 DUP1 2362 FD *REVERT // Stack delta = +0 // Outputs[1] { @2362 revert(memory[0x00:0x00]); } // Block terminates label_2363: // Incoming jump from 0x235E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2364 stack[-2] // @2365 msg.data[stack[-2]:stack[-2] + 0x20] // } 2363 5B JUMPDEST 2364 81 DUP2 2365 35 CALLDATALOAD 2366 61 PUSH2 0x1f71 2369 81 DUP2 236A 61 PUSH2 0x233b 236D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2365 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2366 stack[1] = 0x1f71 // @2369 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x233b, returns to 0x1F71 label_236E: // Incoming call from 0x23B1, returns to 0x23B2 // Incoming call from 0x2B47, returns to 0x2B48 // Inputs[1] { @2372 stack[-3] } 236E 5B JUMPDEST 236F 60 PUSH1 0x00 2371 5B JUMPDEST 2372 83 DUP4 2373 81 DUP2 2374 10 LT 2375 15 ISZERO 2376 61 PUSH2 0x2389 2379 57 *JUMPI // Stack delta = +1 // Outputs[1] { @236F stack[0] = 0x00 } // Block ends with conditional jump to 0x2389, if !(0x00 < stack[-3]) label_237A: // Incoming jump from 0x2379, if not !(0x00 < stack[-3]) // Incoming jump from 0x2379, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @237A stack[-2] // @237B stack[-1] // @237D memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @237E stack[-3] // } 237A 81 DUP2 237B 81 DUP2 237C 01 ADD 237D 51 MLOAD 237E 83 DUP4 237F 82 DUP3 2380 01 ADD 2381 52 MSTORE 2382 60 PUSH1 0x20 2384 01 ADD 2385 61 PUSH2 0x2371 2388 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2381 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2384 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2371 label_2389: // Incoming jump from 0x2379, if !(0x00 < stack[-3]) // Incoming jump from 0x2379, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @238A stack[-4] // @238B stack[-1] // } 2389 5B JUMPDEST 238A 83 DUP4 238B 81 DUP2 238C 11 GT 238D 15 ISZERO 238E 61 PUSH2 0x0763 2391 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0763, if !(stack[-1] > stack[-4]) label_2392: // Incoming jump from 0x2391, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2396 stack[-4] // @2397 stack[-3] // @2399 stack[-5] // } 2392 50 POP 2393 50 POP 2394 60 PUSH1 0x00 2396 91 SWAP2 2397 01 ADD 2398 52 MSTORE 2399 56 *JUMP // Stack delta = -5 // Outputs[1] { @2398 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_239A: // Incoming call from 0x23D8, returns to 0x1F71 // Inputs[3] // { // @239D stack[-1] // @239E memory[stack[-1]:stack[-1] + 0x20] // @23A0 stack[-2] // } 239A 5B JUMPDEST 239B 60 PUSH1 0x00 239D 81 DUP2 239E 51 MLOAD 239F 80 DUP1 23A0 84 DUP5 23A1 52 MSTORE 23A2 61 PUSH2 0x23b2 23A5 81 DUP2 23A6 60 PUSH1 0x20 23A8 86 DUP7 23A9 01 ADD 23AA 60 PUSH1 0x20 23AC 86 DUP7 23AD 01 ADD 23AE 61 PUSH2 0x236e 23B1 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @239B stack[0] = 0x00 // @239E stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @23A1 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @23A2 stack[2] = 0x23b2 // @23A5 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @23A9 stack[4] = stack[-2] + 0x20 // @23AD stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x236e, returns to 0x23B2 label_23B2: // Incoming return from call to 0x236E at 0x23B1 // Inputs[4] // { // @23B5 stack[-1] // @23BA stack[-4] // @23BB stack[-2] // @23C1 stack[-5] // } 23B2 5B JUMPDEST 23B3 60 PUSH1 0x1f 23B5 01 ADD 23B6 60 PUSH1 0x1f 23B8 19 NOT 23B9 16 AND 23BA 92 SWAP3 23BB 90 SWAP1 23BC 92 SWAP3 23BD 01 ADD 23BE 60 PUSH1 0x20 23C0 01 ADD 23C1 92 SWAP3 23C2 91 SWAP2 23C3 50 POP 23C4 50 POP 23C5 56 *JUMP // Stack delta = -4 // Outputs[1] { @23C1 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_23C6: // Incoming call from 0x023E, returns to 0x0214 // Inputs[2] // { // @23C9 stack[-1] // @23D4 stack[-2] // } 23C6 5B JUMPDEST 23C7 60 PUSH1 0x20 23C9 81 DUP2 23CA 52 MSTORE 23CB 60 PUSH1 0x00 23CD 61 PUSH2 0x1f71 23D0 60 PUSH1 0x20 23D2 83 DUP4 23D3 01 ADD 23D4 84 DUP5 23D5 61 PUSH2 0x239a 23D8 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @23CA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23CB stack[0] = 0x00 // @23CD stack[1] = 0x1f71 // @23D3 stack[2] = stack[-1] + 0x20 // @23D4 stack[3] = stack[-2] // } // Block ends with call to 0x239a, returns to 0x1F71 label_23D9: // Incoming call from 0x0259, returns to 0x025A // Incoming call from 0x02FC, returns to 0x02FD // Incoming call from 0x03FE, returns to 0x03FF // Incoming call from 0x054E, returns to 0x054F // Inputs[2] // { // @23DE stack[-1] // @23DF stack[-2] // } 23D9 5B JUMPDEST 23DA 60 PUSH1 0x00 23DC 60 PUSH1 0x20 23DE 82 DUP3 23DF 84 DUP5 23E0 03 SUB 23E1 12 SLT 23E2 15 ISZERO 23E3 61 PUSH2 0x23eb 23E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23DA stack[0] = 0x00 } // Block ends with conditional jump to 0x23eb, if !(stack[-2] - stack[-1] i< 0x20) label_23E7: // Incoming jump from 0x23E6, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @23EA memory[0x00:0x00] } 23E7 60 PUSH1 0x00 23E9 80 DUP1 23EA FD *REVERT // Stack delta = +0 // Outputs[1] { @23EA revert(memory[0x00:0x00]); } // Block terminates label_23EB: // Incoming jump from 0x23E6, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @23ED msg.data[stack[-2]:stack[-2] + 0x20] // @23ED stack[-2] // @23EE stack[-4] // @23EF stack[-3] // } 23EB 5B JUMPDEST 23EC 50 POP 23ED 35 CALLDATALOAD 23EE 91 SWAP2 23EF 90 SWAP1 23F0 50 POP 23F1 56 *JUMP // Stack delta = -3 // Outputs[1] { @23EE stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_23F2: // Incoming call from 0x2424, returns to 0x2425 // Incoming call from 0x2577, returns to 0x2578 // Incoming call from 0x25CC, returns to 0x25CD // Incoming call from 0x295C, returns to 0x295D // Incoming call from 0x296A, returns to 0x25CD // Incoming call from 0x2828, returns to 0x2829 // Incoming call from 0x2641, returns to 0x2642 // Incoming call from 0x27C4, returns to 0x1F71 // Incoming call from 0x2778, returns to 0x2779 // Incoming call from 0x27EE, returns to 0x27EF // Incoming call from 0x2569, returns to 0x256A // Incoming call from 0x2836, returns to 0x2837 // Incoming call from 0x291A, returns to 0x291B // Inputs[2] // { // @23F3 stack[-1] // @23F4 msg.data[stack[-1]:stack[-1] + 0x20] // } 23F2 5B JUMPDEST 23F3 80 DUP1 23F4 35 CALLDATALOAD 23F5 60 PUSH1 0x01 23F7 60 PUSH1 0x01 23F9 60 PUSH1 0xa0 23FB 1B SHL 23FC 03 SUB 23FD 81 DUP2 23FE 16 AND 23FF 81 DUP2 2400 14 EQ 2401 61 PUSH2 0x156f 2404 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23F4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x156f, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2405: // Incoming jump from 0x2404, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2408 memory[0x00:0x00] } 2405 60 PUSH1 0x00 2407 80 DUP1 2408 FD *REVERT // Stack delta = +0 // Outputs[1] { @2408 revert(memory[0x00:0x00]); } // Block terminates label_2409: // Incoming call from 0x0493, returns to 0x0494 // Incoming call from 0x0284, returns to 0x0285 // Inputs[2] // { // @240F stack[-1] // @2410 stack[-2] // } 2409 5B JUMPDEST 240A 60 PUSH1 0x00 240C 80 DUP1 240D 60 PUSH1 0x40 240F 83 DUP4 2410 85 DUP6 2411 03 SUB 2412 12 SLT 2413 15 ISZERO 2414 61 PUSH2 0x241c 2417 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @240A stack[0] = 0x00 // @240C stack[1] = 0x00 // } // Block ends with conditional jump to 0x241c, if !(stack[-2] - stack[-1] i< 0x40) label_2418: // Incoming jump from 0x2417, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @241B memory[0x00:0x00] } 2418 60 PUSH1 0x00 241A 80 DUP1 241B FD *REVERT // Stack delta = +0 // Outputs[1] { @241B revert(memory[0x00:0x00]); } // Block terminates label_241C: // Incoming jump from 0x2417, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2420 stack[-3] } 241C 5B JUMPDEST 241D 61 PUSH2 0x2425 2420 83 DUP4 2421 61 PUSH2 0x23f2 2424 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @241D stack[0] = 0x2425 // @2420 stack[1] = stack[-3] // } // Block ends with call to 0x23f2, returns to 0x2425 label_2425: // Incoming return from call to 0x23F2 at 0x2424 // Inputs[5] // { // @2426 stack[-1] // @2426 stack[-6] // @2429 stack[-4] // @242D msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @242E stack[-5] // } 2425 5B JUMPDEST 2426 94 SWAP5 2427 60 PUSH1 0x20 2429 93 SWAP4 242A 90 SWAP1 242B 93 SWAP4 242C 01 ADD 242D 35 CALLDATALOAD 242E 93 SWAP4 242F 50 POP 2430 50 POP 2431 50 POP 2432 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2426 stack[-6] = stack[-1] // @242E stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2433: // Incoming jump from 0x1D5D // Incoming jump from 0x2498 // Incoming jump from 0x26B3 // Incoming jump from 0x246A // Incoming jump from 0x24B9 // Incoming jump from 0x1E06 // Inputs[1] { @2448 memory[0x00:0x24] } 2433 5B JUMPDEST 2434 63 PUSH4 0x4e487b71 2439 60 PUSH1 0xe0 243B 1B SHL 243C 60 PUSH1 0x00 243E 52 MSTORE 243F 60 PUSH1 0x41 2441 60 PUSH1 0x04 2443 52 MSTORE 2444 60 PUSH1 0x24 2446 60 PUSH1 0x00 2448 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @243E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2443 memory[0x04:0x24] = 0x41 // @2448 revert(memory[0x00:0x24]); // } // Block terminates label_2449: // Incoming call from 0x2911, returns to 0x2912 // Inputs[1] { @244D memory[0x40:0x60] } 2449 5B JUMPDEST 244A 60 PUSH1 0x40 244C 80 DUP1 244D 51 MLOAD 244E 90 SWAP1 244F 81 DUP2 2450 01 ADD 2451 60 PUSH1 0x01 2453 60 PUSH1 0x01 2455 60 PUSH1 0x40 2457 1B SHL 2458 03 SUB 2459 81 DUP2 245A 11 GT 245B 82 DUP3 245C 82 DUP3 245D 10 LT 245E 17 OR 245F 15 ISZERO 2460 61 PUSH2 0x246b 2463 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @244E stack[0] = memory[0x40:0x60] // @2450 stack[1] = memory[0x40:0x60] + 0x40 // } // Block ends with conditional jump to 0x246b, if !((memory[0x40:0x60] + 0x40 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0x40 > (0x01 << 0x40) - 0x01)) label_2464: // Incoming jump from 0x2463, if not !((memory[0x40:0x60] + 0x40 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0x40 > (0x01 << 0x40) - 0x01)) 2464 61 PUSH2 0x246b 2467 61 PUSH2 0x2433 246A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2464 stack[0] = 0x246b } // Block ends with unconditional jump to 0x2433 label_246B: // Incoming jump from 0x2463, if !((memory[0x40:0x60] + 0x40 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0x40 > (0x01 << 0x40) - 0x01)) // Inputs[3] // { // @246E stack[-1] // @246F stack[-3] // @246F stack[-2] // } 246B 5B JUMPDEST 246C 60 PUSH1 0x40 246E 52 MSTORE 246F 90 SWAP1 2470 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @246E memory[0x40:0x60] = stack[-1] // @246F stack[-3] = stack[-2] // } // Block ends with unconditional jump to stack[-3] label_2471: // Incoming call from 0x24CC, returns to 0x24CD // Incoming jump from 0x26E3 // Inputs[2] // { // @2474 memory[0x40:0x60] // @2477 stack[-1] // } 2471 5B JUMPDEST 2472 60 PUSH1 0x40 2474 51 MLOAD 2475 60 PUSH1 0x1f 2477 82 DUP3 2478 01 ADD 2479 60 PUSH1 0x1f 247B 19 NOT 247C 16 AND 247D 81 DUP2 247E 01 ADD 247F 60 PUSH1 0x01 2481 60 PUSH1 0x01 2483 60 PUSH1 0x40 2485 1B SHL 2486 03 SUB 2487 81 DUP2 2488 11 GT 2489 82 DUP3 248A 82 DUP3 248B 10 LT 248C 17 OR 248D 15 ISZERO 248E 61 PUSH2 0x2499 2491 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2474 stack[0] = memory[0x40:0x60] // @247E stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x2499, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) label_2492: // Incoming jump from 0x2491, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) 2492 61 PUSH2 0x2499 2495 61 PUSH2 0x2433 2498 56 *JUMP // Stack delta = +1 // Outputs[1] { @2492 stack[0] = 0x2499 } // Block ends with unconditional jump to 0x2433 label_2499: // Incoming jump from 0x2491, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[4] // { // @249C stack[-1] // @249D stack[-4] // @249D stack[-2] // @249E stack[-3] // } 2499 5B JUMPDEST 249A 60 PUSH1 0x40 249C 52 MSTORE 249D 91 SWAP2 249E 90 SWAP1 249F 50 POP 24A0 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @249C memory[0x40:0x60] = stack[-1] // @249D stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_24A1: // Incoming call from 0x2878, returns to 0x2879 // Incoming call from 0x2517, returns to 0x1F71 // Inputs[1] { @24AC stack[-2] } 24A1 5B JUMPDEST 24A2 60 PUSH1 0x00 24A4 60 PUSH1 0x01 24A6 60 PUSH1 0x01 24A8 60 PUSH1 0x40 24AA 1B SHL 24AB 03 SUB 24AC 83 DUP4 24AD 11 GT 24AE 15 ISZERO 24AF 61 PUSH2 0x24ba 24B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x24ba, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_24B3: // Incoming jump from 0x24B2, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 24B3 61 PUSH2 0x24ba 24B6 61 PUSH2 0x2433 24B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @24B3 stack[0] = 0x24ba } // Block ends with unconditional jump to 0x2433 label_24BA: // Incoming jump from 0x24B2, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[1] { @24C0 stack[-3] } 24BA 5B JUMPDEST 24BB 61 PUSH2 0x24cd 24BE 60 PUSH1 0x1f 24C0 84 DUP5 24C1 01 ADD 24C2 60 PUSH1 0x1f 24C4 19 NOT 24C5 16 AND 24C6 60 PUSH1 0x20 24C8 01 ADD 24C9 61 PUSH2 0x2471 24CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24BB stack[0] = 0x24cd // @24C8 stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x2471, returns to 0x24CD label_24CD: // Incoming return from call to 0x2471 at 0x24CC // Inputs[5] // { // @24CE stack[-1] // @24CE stack[-2] // @24D0 stack[-4] // @24D3 stack[-5] // @24D5 stack[-3] // } 24CD 5B JUMPDEST 24CE 90 SWAP1 24CF 50 POP 24D0 82 DUP3 24D1 81 DUP2 24D2 52 MSTORE 24D3 83 DUP4 24D4 83 DUP4 24D5 83 DUP4 24D6 01 ADD 24D7 11 GT 24D8 15 ISZERO 24D9 61 PUSH2 0x24e1 24DC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @24CE stack[-2] = stack[-1] // @24D2 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x24e1, if !(stack[-3] + stack[-4] > stack[-5]) label_24DD: // Incoming jump from 0x24DC, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @24E0 memory[0x00:0x00] } 24DD 60 PUSH1 0x00 24DF 80 DUP1 24E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @24E0 revert(memory[0x00:0x00]); } // Block terminates label_24E1: // Incoming jump from 0x24DC, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @24E2 stack[-3] // @24E3 stack[-2] // @24E6 stack[-1] // @24E8 msg.data[stack[-2]:stack[-2] + stack[-3]] // @24F2 stack[-5] // @24F3 stack[-4] // } 24E1 5B JUMPDEST 24E2 82 DUP3 24E3 82 DUP3 24E4 60 PUSH1 0x20 24E6 83 DUP4 24E7 01 ADD 24E8 37 CALLDATACOPY 24E9 60 PUSH1 0x00 24EB 60 PUSH1 0x20 24ED 84 DUP5 24EE 83 DUP4 24EF 01 ADD 24F0 01 ADD 24F1 52 MSTORE 24F2 93 SWAP4 24F3 92 SWAP3 24F4 50 POP 24F5 50 POP 24F6 50 POP 24F7 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @24E8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @24F1 memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @24F2 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_24F8: // Incoming call from 0x268D, returns to 0x268E // Incoming call from 0x2611, returns to 0x2612 // Incoming call from 0x254B, returns to 0x1D2A // Incoming call from 0x266A, returns to 0x266B // Incoming call from 0x2633, returns to 0x2634 // Inputs[2] // { // @24FB stack[-2] // @24FE stack[-1] // } 24F8 5B JUMPDEST 24F9 60 PUSH1 0x00 24FB 82 DUP3 24FC 60 PUSH1 0x1f 24FE 83 DUP4 24FF 01 ADD 2500 12 SLT 2501 61 PUSH2 0x2509 2504 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24F9 stack[0] = 0x00 } // Block ends with conditional jump to 0x2509, if stack[-1] + 0x1f i< stack[-2] label_2505: // Incoming jump from 0x2504, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2508 memory[0x00:0x00] } 2505 60 PUSH1 0x00 2507 80 DUP1 2508 FD *REVERT // Stack delta = +0 // Outputs[1] { @2508 revert(memory[0x00:0x00]); } // Block terminates label_2509: // Incoming jump from 0x2504, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @250D stack[-3] // @250E stack[-2] // @250F msg.data[stack[-2]:stack[-2] + 0x20] // } 2509 5B JUMPDEST 250A 61 PUSH2 0x1f71 250D 83 DUP4 250E 83 DUP4 250F 35 CALLDATALOAD 2510 60 PUSH1 0x20 2512 85 DUP6 2513 01 ADD 2514 61 PUSH2 0x24a1 2517 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @250A stack[0] = 0x1f71 // @250D stack[1] = stack[-3] // @250F stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @2513 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x24a1, returns to 0x1F71 label_2518: // Incoming jump from 0x02A6 // Incoming jump from 0x0473 // Inputs[2] // { // @251D stack[-1] // @251E stack[-2] // } 2518 5B JUMPDEST 2519 60 PUSH1 0x00 251B 60 PUSH1 0x20 251D 82 DUP3 251E 84 DUP5 251F 03 SUB 2520 12 SLT 2521 15 ISZERO 2522 61 PUSH2 0x252a 2525 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2519 stack[0] = 0x00 } // Block ends with conditional jump to 0x252a, if !(stack[-2] - stack[-1] i< 0x20) label_2526: // Incoming jump from 0x2525, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2529 memory[0x00:0x00] } 2526 60 PUSH1 0x00 2528 80 DUP1 2529 FD *REVERT // Stack delta = +0 // Outputs[1] { @2529 revert(memory[0x00:0x00]); } // Block terminates label_252A: // Incoming jump from 0x2525, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @252B stack[-2] // @252C msg.data[stack[-2]:stack[-2] + 0x20] // } 252A 5B JUMPDEST 252B 81 DUP2 252C 35 CALLDATALOAD 252D 60 PUSH1 0x01 252F 60 PUSH1 0x01 2531 60 PUSH1 0x40 2533 1B SHL 2534 03 SUB 2535 81 DUP2 2536 11 GT 2537 15 ISZERO 2538 61 PUSH2 0x2540 253B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @252C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2540, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_253C: // Incoming jump from 0x253B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @253F memory[0x00:0x00] } 253C 60 PUSH1 0x00 253E 80 DUP1 253F FD *REVERT // Stack delta = +0 // Outputs[1] { @253F revert(memory[0x00:0x00]); } // Block terminates label_2540: // Incoming jump from 0x253B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2544 stack[-4] // @2545 stack[-1] // @2546 stack[-3] // } 2540 5B JUMPDEST 2541 61 PUSH2 0x1d2a 2544 84 DUP5 2545 82 DUP3 2546 85 DUP6 2547 01 ADD 2548 61 PUSH2 0x24f8 254B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2541 stack[0] = 0x1d2a // @2544 stack[1] = stack[-4] // @2547 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x24f8, returns to 0x1D2A label_254C: // Incoming call from 0x02DC, returns to 0x02DD // Incoming call from 0x03BE, returns to 0x03BF // Inputs[2] // { // @2554 stack[-1] // @2555 stack[-2] // } 254C 5B JUMPDEST 254D 60 PUSH1 0x00 254F 80 DUP1 2550 60 PUSH1 0x00 2552 60 PUSH1 0x60 2554 84 DUP5 2555 86 DUP7 2556 03 SUB 2557 12 SLT 2558 15 ISZERO 2559 61 PUSH2 0x2561 255C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @254D stack[0] = 0x00 // @254F stack[1] = 0x00 // @2550 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2561, if !(stack[-2] - stack[-1] i< 0x60) label_255D: // Incoming jump from 0x255C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2560 memory[0x00:0x00] } 255D 60 PUSH1 0x00 255F 80 DUP1 2560 FD *REVERT // Stack delta = +0 // Outputs[1] { @2560 revert(memory[0x00:0x00]); } // Block terminates label_2561: // Incoming jump from 0x255C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2565 stack[-4] } 2561 5B JUMPDEST 2562 61 PUSH2 0x256a 2565 84 DUP5 2566 61 PUSH2 0x23f2 2569 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2562 stack[0] = 0x256a // @2565 stack[1] = stack[-4] // } // Block ends with call to 0x23f2, returns to 0x256A label_256A: // Incoming return from call to 0x23F2 at 0x2569 // Inputs[3] // { // @256B stack[-1] // @256B stack[-4] // @2572 stack[-5] // } 256A 5B JUMPDEST 256B 92 SWAP3 256C 50 POP 256D 61 PUSH2 0x2578 2570 60 PUSH1 0x20 2572 85 DUP6 2573 01 ADD 2574 61 PUSH2 0x23f2 2577 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @256B stack[-4] = stack[-1] // @256D stack[-1] = 0x2578 // @2573 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x23f2, returns to 0x2578 label_2578: // Incoming return from call to 0x23F2 at 0x2577 // Inputs[8] // { // @2579 stack[-1] // @2579 stack[-3] // @257D stack[-5] // @257F msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2580 stack[-2] // @2584 stack[-6] // @2586 stack[-4] // @2586 stack[-7] // } 2578 5B JUMPDEST 2579 91 SWAP2 257A 50 POP 257B 60 PUSH1 0x40 257D 84 DUP5 257E 01 ADD 257F 35 CALLDATALOAD 2580 90 SWAP1 2581 50 POP 2582 92 SWAP3 2583 50 POP 2584 92 SWAP3 2585 50 POP 2586 92 SWAP3 2587 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2582 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2584 stack[-6] = stack[-1] // @2586 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2588: // Incoming call from 0x032C, returns to 0x032D // Inputs[2] // { // @258E stack[-1] // @258F stack[-2] // } 2588 5B JUMPDEST 2589 60 PUSH1 0x00 258B 80 DUP1 258C 60 PUSH1 0x40 258E 83 DUP4 258F 85 DUP6 2590 03 SUB 2591 12 SLT 2592 15 ISZERO 2593 61 PUSH2 0x259b 2596 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2589 stack[0] = 0x00 // @258B stack[1] = 0x00 // } // Block ends with conditional jump to 0x259b, if !(stack[-2] - stack[-1] i< 0x40) label_2597: // Incoming jump from 0x2596, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @259A memory[0x00:0x00] } 2597 60 PUSH1 0x00 2599 80 DUP1 259A FD *REVERT // Stack delta = +0 // Outputs[1] { @259A revert(memory[0x00:0x00]); } // Block terminates label_259B: // Incoming jump from 0x2596, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @259E stack[-3] // @259F msg.data[stack[-3]:stack[-3] + 0x20] // @25A0 stack[-5] // @25A6 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @25A7 stack[-4] // } 259B 5B JUMPDEST 259C 50 POP 259D 50 POP 259E 80 DUP1 259F 35 CALLDATALOAD 25A0 92 SWAP3 25A1 60 PUSH1 0x20 25A3 90 SWAP1 25A4 91 SWAP2 25A5 01 ADD 25A6 35 CALLDATALOAD 25A7 91 SWAP2 25A8 50 POP 25A9 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @25A0 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @25A7 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_25AA: // Incoming call from 0x056E, returns to 0x056F // Incoming call from 0x036B, returns to 0x036C // Incoming call from 0x04D1, returns to 0x04D2 // Incoming call from 0x038B, returns to 0x038C // Inputs[2] // { // @25B0 stack[-1] // @25B1 stack[-2] // } 25AA 5B JUMPDEST 25AB 60 PUSH1 0x00 25AD 80 DUP1 25AE 60 PUSH1 0x40 25B0 83 DUP4 25B1 85 DUP6 25B2 03 SUB 25B3 12 SLT 25B4 15 ISZERO 25B5 61 PUSH2 0x25bd 25B8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25AB stack[0] = 0x00 // @25AD stack[1] = 0x00 // } // Block ends with conditional jump to 0x25bd, if !(stack[-2] - stack[-1] i< 0x40) label_25B9: // Incoming jump from 0x25B8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25BC memory[0x00:0x00] } 25B9 60 PUSH1 0x00 25BB 80 DUP1 25BC FD *REVERT // Stack delta = +0 // Outputs[1] { @25BC revert(memory[0x00:0x00]); } // Block terminates label_25BD: // Incoming jump from 0x25B8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @25BE stack[-3] // @25BF msg.data[stack[-3]:stack[-3] + 0x20] // @25C0 stack[-2] // } 25BD 5B JUMPDEST 25BE 82 DUP3 25BF 35 CALLDATALOAD 25C0 91 SWAP2 25C1 50 POP 25C2 61 PUSH2 0x25cd 25C5 60 PUSH1 0x20 25C7 84 DUP5 25C8 01 ADD 25C9 61 PUSH2 0x23f2 25CC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @25C0 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @25C2 stack[0] = 0x25cd // @25C8 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x23f2, returns to 0x25CD label_25CD: // Incoming return from call to 0x23F2 at 0x296A // Incoming return from call to 0x23F2 at 0x25CC // Inputs[6] // { // @25CE stack[-1] // @25CE stack[-2] // @25D0 stack[-5] // @25D2 stack[-3] // @25D2 stack[-6] // @25D3 stack[-4] // } 25CD 5B JUMPDEST 25CE 90 SWAP1 25CF 50 POP 25D0 92 SWAP3 25D1 50 POP 25D2 92 SWAP3 25D3 90 SWAP1 25D4 50 POP 25D5 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @25D0 stack[-5] = stack[-1] // @25D2 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_25D6: // Incoming call from 0x03AB, returns to 0x03AC // Inputs[2] // { // @25E2 stack[-1] // @25E3 stack[-2] // } 25D6 5B JUMPDEST 25D7 60 PUSH1 0x00 25D9 80 DUP1 25DA 60 PUSH1 0x00 25DC 80 DUP1 25DD 60 PUSH1 0x00 25DF 80 DUP1 25E0 60 PUSH1 0xc0 25E2 87 DUP8 25E3 89 DUP10 25E4 03 SUB 25E5 12 SLT 25E6 15 ISZERO 25E7 61 PUSH2 0x25ef 25EA 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @25D7 stack[0] = 0x00 // @25D9 stack[1] = 0x00 // @25DA stack[2] = 0x00 // @25DC stack[3] = 0x00 // @25DD stack[4] = 0x00 // @25DF stack[5] = 0x00 // } // Block ends with conditional jump to 0x25ef, if !(stack[-2] - stack[-1] i< 0xc0) label_25EB: // Incoming jump from 0x25EA, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @25EE memory[0x00:0x00] } 25EB 60 PUSH1 0x00 25ED 80 DUP1 25EE FD *REVERT // Stack delta = +0 // Outputs[1] { @25EE revert(memory[0x00:0x00]); } // Block terminates label_25EF: // Incoming jump from 0x25EA, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @25F0 stack[-7] // @25F1 msg.data[stack[-7]:stack[-7] + 0x20] // } 25EF 5B JUMPDEST 25F0 86 DUP7 25F1 35 CALLDATALOAD 25F2 60 PUSH1 0x01 25F4 60 PUSH1 0x01 25F6 60 PUSH1 0x40 25F8 1B SHL 25F9 03 SUB 25FA 80 DUP1 25FB 82 DUP3 25FC 11 GT 25FD 15 ISZERO 25FE 61 PUSH2 0x2606 2601 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25F1 stack[0] = msg.data[stack[-7]:stack[-7] + 0x20] // @25F9 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x2606, if !(msg.data[stack[-7]:stack[-7] + 0x20] > (0x01 << 0x40) - 0x01) label_2602: // Incoming jump from 0x2601, if not !(msg.data[stack[-7]:stack[-7] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2605 memory[0x00:0x00] } 2602 60 PUSH1 0x00 2604 80 DUP1 2605 FD *REVERT // Stack delta = +0 // Outputs[1] { @2605 revert(memory[0x00:0x00]); } // Block terminates label_2606: // Incoming jump from 0x2601, if !(msg.data[stack[-7]:stack[-7] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @260A stack[-10] // @260B stack[-2] // @260C stack[-9] // } 2606 5B JUMPDEST 2607 61 PUSH2 0x2612 260A 8A DUP11 260B 83 DUP4 260C 8B DUP12 260D 01 ADD 260E 61 PUSH2 0x24f8 2611 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2607 stack[0] = 0x2612 // @260A stack[1] = stack[-10] // @260D stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x24f8, returns to 0x2612 label_2612: // Incoming return from call to 0x24F8 at 0x2611 // Inputs[6] // { // @2613 stack[-9] // @2613 stack[-1] // @2617 stack[-10] // @2619 msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // @261A stack[-3] // @261C stack[-2] // } 2612 5B JUMPDEST 2613 97 SWAP8 2614 50 POP 2615 60 PUSH1 0x20 2617 89 DUP10 2618 01 ADD 2619 35 CALLDATALOAD 261A 91 SWAP2 261B 50 POP 261C 80 DUP1 261D 82 DUP3 261E 11 GT 261F 15 ISZERO 2620 61 PUSH2 0x2628 2623 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2613 stack[-9] = stack[-1] // @261A stack[-3] = msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2628, if !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) label_2624: // Incoming jump from 0x2623, if not !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @2627 memory[0x00:0x00] } 2624 60 PUSH1 0x00 2626 80 DUP1 2627 FD *REVERT // Stack delta = +0 // Outputs[1] { @2627 revert(memory[0x00:0x00]); } // Block terminates label_2628: // Incoming jump from 0x2623, if !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @262C stack[-10] // @262D stack[-2] // @262E stack[-9] // } 2628 5B JUMPDEST 2629 61 PUSH2 0x2634 262C 8A DUP11 262D 83 DUP4 262E 8B DUP12 262F 01 ADD 2630 61 PUSH2 0x24f8 2633 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2629 stack[0] = 0x2634 // @262C stack[1] = stack[-10] // @262F stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x24f8, returns to 0x2634 label_2634: // Incoming return from call to 0x24F8 at 0x2633 // Inputs[3] // { // @2635 stack[-8] // @2635 stack[-1] // @263C stack[-10] // } 2634 5B JUMPDEST 2635 96 SWAP7 2636 50 POP 2637 61 PUSH2 0x2642 263A 60 PUSH1 0x40 263C 8A DUP11 263D 01 ADD 263E 61 PUSH2 0x23f2 2641 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2635 stack[-8] = stack[-1] // @2637 stack[-1] = 0x2642 // @263D stack[0] = stack[-10] + 0x40 // } // Block ends with call to 0x23f2, returns to 0x2642 label_2642: // Incoming return from call to 0x23F2 at 0x2641 // Inputs[8] // { // @2643 stack[-7] // @2643 stack[-1] // @2647 stack[-10] // @2649 msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @264A stack[-6] // @2650 msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @2651 stack[-3] // @2653 stack[-2] // } 2642 5B JUMPDEST 2643 95 SWAP6 2644 50 POP 2645 60 PUSH1 0x60 2647 89 DUP10 2648 01 ADD 2649 35 CALLDATALOAD 264A 94 SWAP5 264B 50 POP 264C 60 PUSH1 0x80 264E 89 DUP10 264F 01 ADD 2650 35 CALLDATALOAD 2651 91 SWAP2 2652 50 POP 2653 80 DUP1 2654 82 DUP3 2655 11 GT 2656 15 ISZERO 2657 61 PUSH2 0x265f 265A 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @2643 stack[-7] = stack[-1] // @264A stack[-6] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @2651 stack[-3] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x265f, if !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) label_265B: // Incoming jump from 0x265A, if not !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @265E memory[0x00:0x00] } 265B 60 PUSH1 0x00 265D 80 DUP1 265E FD *REVERT // Stack delta = +0 // Outputs[1] { @265E revert(memory[0x00:0x00]); } // Block terminates label_265F: // Incoming jump from 0x265A, if !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @2663 stack[-10] // @2664 stack[-2] // @2665 stack[-9] // } 265F 5B JUMPDEST 2660 61 PUSH2 0x266b 2663 8A DUP11 2664 83 DUP4 2665 8B DUP12 2666 01 ADD 2667 61 PUSH2 0x24f8 266A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2660 stack[0] = 0x266b // @2663 stack[1] = stack[-10] // @2666 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x24f8, returns to 0x266B label_266B: // Incoming return from call to 0x24F8 at 0x266A // Inputs[6] // { // @266C stack[-1] // @266C stack[-5] // @2670 stack[-10] // @2672 msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @2673 stack[-3] // @2675 stack[-2] // } 266B 5B JUMPDEST 266C 93 SWAP4 266D 50 POP 266E 60 PUSH1 0xa0 2670 89 DUP10 2671 01 ADD 2672 35 CALLDATALOAD 2673 91 SWAP2 2674 50 POP 2675 80 DUP1 2676 82 DUP3 2677 11 GT 2678 15 ISZERO 2679 61 PUSH2 0x2681 267C 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @266C stack[-5] = stack[-1] // @2673 stack[-3] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // } // Block ends with conditional jump to 0x2681, if !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) label_267D: // Incoming jump from 0x267C, if not !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) // Inputs[1] { @2680 memory[0x00:0x00] } 267D 60 PUSH1 0x00 267F 80 DUP1 2680 FD *REVERT // Stack delta = +0 // Outputs[1] { @2680 revert(memory[0x00:0x00]); } // Block terminates label_2681: // Incoming jump from 0x267C, if !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) // Inputs[3] // { // @2686 stack[-10] // @2687 stack[-2] // @2688 stack[-9] // } 2681 5B JUMPDEST 2682 50 POP 2683 61 PUSH2 0x268e 2686 89 DUP10 2687 82 DUP3 2688 8A DUP11 2689 01 ADD 268A 61 PUSH2 0x24f8 268D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2683 stack[-1] = 0x268e // @2686 stack[0] = stack[-10] // @2689 stack[1] = stack[-9] + stack[-2] // } // Block ends with call to 0x24f8, returns to 0x268E label_268E: // Incoming return from call to 0x24F8 at 0x268D // Inputs[10] // { // @268F stack[-3] // @268F stack[-1] // @2692 stack[-6] // @2693 stack[-9] // @2695 stack[-7] // @2695 stack[-4] // @2696 stack[-10] // @2698 stack[-8] // @2698 stack[-5] // @2699 stack[-11] // } 268E 5B JUMPDEST 268F 91 SWAP2 2690 50 POP 2691 50 POP 2692 92 SWAP3 2693 95 SWAP6 2694 50 POP 2695 92 SWAP3 2696 95 SWAP6 2697 50 POP 2698 92 SWAP3 2699 95 SWAP6 269A 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @2692 stack[-6] = stack[-1] // @2693 stack[-9] = stack[-6] // @2695 stack[-7] = stack[-4] // @2696 stack[-10] = stack[-7] // @2698 stack[-8] = stack[-5] // @2699 stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_269B: // Incoming call from 0x28CC, returns to 0x26DF // Incoming call from 0x26DE, returns to 0x26DF // Inputs[1] { @26A6 stack[-1] } 269B 5B JUMPDEST 269C 60 PUSH1 0x00 269E 60 PUSH1 0x01 26A0 60 PUSH1 0x01 26A2 60 PUSH1 0x40 26A4 1B SHL 26A5 03 SUB 26A6 82 DUP3 26A7 11 GT 26A8 15 ISZERO 26A9 61 PUSH2 0x26b4 26AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @269C stack[0] = 0x00 } // Block ends with conditional jump to 0x26b4, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_26AD: // Incoming jump from 0x26AC, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 26AD 61 PUSH2 0x26b4 26B0 61 PUSH2 0x2433 26B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @26AD stack[0] = 0x26b4 } // Block ends with unconditional jump to 0x2433 label_26B4: // Incoming jump from 0x26AC, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @26B8 stack[-2] // @26BC stack[-3] // } 26B4 5B JUMPDEST 26B5 50 POP 26B6 60 PUSH1 0x05 26B8 1B SHL 26B9 60 PUSH1 0x20 26BB 01 ADD 26BC 90 SWAP1 26BD 56 *JUMP // Stack delta = -2 // Outputs[1] { @26BC stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_26BE: // Incoming call from 0x279F, returns to 0x27A0 // Incoming call from 0x275C, returns to 0x1D2A // Inputs[2] // { // @26C1 stack[-2] // @26C4 stack[-1] // } 26BE 5B JUMPDEST 26BF 60 PUSH1 0x00 26C1 82 DUP3 26C2 60 PUSH1 0x1f 26C4 83 DUP4 26C5 01 ADD 26C6 12 SLT 26C7 61 PUSH2 0x26cf 26CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26BF stack[0] = 0x00 } // Block ends with conditional jump to 0x26cf, if stack[-1] + 0x1f i< stack[-2] label_26CB: // Incoming jump from 0x26CA, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @26CE memory[0x00:0x00] } 26CB 60 PUSH1 0x00 26CD 80 DUP1 26CE FD *REVERT // Stack delta = +0 // Outputs[1] { @26CE revert(memory[0x00:0x00]); } // Block terminates label_26CF: // Incoming jump from 0x26CA, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @26D0 stack[-2] // @26D1 msg.data[stack[-2]:stack[-2] + 0x20] // } 26CF 5B JUMPDEST 26D0 81 DUP2 26D1 35 CALLDATALOAD 26D2 60 PUSH1 0x20 26D4 61 PUSH2 0x26e4 26D7 61 PUSH2 0x26df 26DA 83 DUP4 26DB 61 PUSH2 0x269b 26DE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @26D1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @26D2 stack[1] = 0x20 // @26D4 stack[2] = 0x26e4 // @26D7 stack[3] = 0x26df // @26DA stack[4] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x269b, returns to 0x26DF label_26DF: // Incoming return from call to 0x269B at 0x28CC // Incoming return from call to 0x269B at 0x26DE 26DF 5B JUMPDEST 26E0 61 PUSH2 0x2471 26E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2471 label_26E4: // Incoming return from call to 0x26DF at 0x26DE // Inputs[5] // { // @26E5 stack[-3] // @26E6 stack[-1] // @26EE stack[-5] // @26F0 stack[-2] // @26F7 stack[-6] // } 26E4 5B JUMPDEST 26E5 82 DUP3 26E6 81 DUP2 26E7 52 MSTORE 26E8 60 PUSH1 0x05 26EA 92 SWAP3 26EB 90 SWAP1 26EC 92 SWAP3 26ED 1B SHL 26EE 84 DUP5 26EF 01 ADD 26F0 81 DUP2 26F1 01 ADD 26F2 91 SWAP2 26F3 81 DUP2 26F4 81 DUP2 26F5 01 ADD 26F6 90 SWAP1 26F7 86 DUP7 26F8 84 DUP5 26F9 11 GT 26FA 15 ISZERO 26FB 61 PUSH2 0x2703 26FE 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @26E7 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @26F2 stack[-3] = stack[-2] + stack[-5] + (stack[-3] << 0x05) // @26F6 stack[-1] = stack[-1] + stack[-2] // @26F6 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x2703, if !(stack[-2] + stack[-5] + (stack[-3] << 0x05) > stack[-6]) label_26FF: // Incoming jump from 0x26FE, if not !(stack[-2] + stack[-5] + (stack[-3] << 0x05) > stack[-6]) // Inputs[1] { @2702 memory[0x00:0x00] } 26FF 60 PUSH1 0x00 2701 80 DUP1 2702 FD *REVERT // Stack delta = +0 // Outputs[1] { @2702 revert(memory[0x00:0x00]); } // Block terminates label_2703: // Incoming jump from 0x26FE, if !(stack[-2] + stack[-5] + (stack[-3] << 0x05) > stack[-6]) // Inputs[3] // { // @2704 stack[-3] // @2705 stack[-6] // @2708 stack[-4] // } 2703 5B JUMPDEST 2704 82 DUP3 2705 86 DUP7 2706 01 ADD 2707 5B JUMPDEST 2708 84 DUP5 2709 81 DUP2 270A 10 LT 270B 15 ISZERO 270C 61 PUSH2 0x271e 270F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2706 stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x271e, if !(stack[-6] + stack[-3] < stack[-4]) label_2710: // Incoming jump from 0x270F, if not !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x270F, if not !(stack[-1] < stack[-5]) // Inputs[4] // { // @2710 stack[-1] // @2711 msg.data[stack[-1]:stack[-1] + 0x20] // @2712 stack[-3] // @2715 stack[-4] // } 2710 80 DUP1 2711 35 CALLDATALOAD 2712 83 DUP4 2713 52 MSTORE 2714 91 SWAP2 2715 83 DUP4 2716 01 ADD 2717 91 SWAP2 2718 83 DUP4 2719 01 ADD 271A 61 PUSH2 0x2707 271D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2713 memory[stack[-3]:stack[-3] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @2717 stack[-3] = stack[-4] + stack[-3] // @2719 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2707 label_271E: // Incoming jump from 0x270F, if !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x270F, if !(stack[-1] < stack[-5]) // Inputs[3] // { // @2720 stack[-9] // @2720 stack[-2] // @2721 stack[-8] // } 271E 5B JUMPDEST 271F 50 POP 2720 96 SWAP7 2721 95 SWAP6 2722 50 POP 2723 50 POP 2724 50 POP 2725 50 POP 2726 50 POP 2727 50 POP 2728 56 *JUMP // Stack delta = -8 // Outputs[1] { @2720 stack[-9] = stack[-2] } // Block ends with unconditional jump to stack[-9] label_2729: // Incoming call from 0x03DE, returns to 0x03DF // Inputs[2] // { // @272E stack[-1] // @272F stack[-2] // } 2729 5B JUMPDEST 272A 60 PUSH1 0x00 272C 60 PUSH1 0x20 272E 82 DUP3 272F 84 DUP5 2730 03 SUB 2731 12 SLT 2732 15 ISZERO 2733 61 PUSH2 0x273b 2736 57 *JUMPI // Stack delta = +1 // Outputs[1] { @272A stack[0] = 0x00 } // Block ends with conditional jump to 0x273b, if !(stack[-2] - stack[-1] i< 0x20) label_2737: // Incoming jump from 0x2736, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @273A memory[0x00:0x00] } 2737 60 PUSH1 0x00 2739 80 DUP1 273A FD *REVERT // Stack delta = +0 // Outputs[1] { @273A revert(memory[0x00:0x00]); } // Block terminates label_273B: // Incoming jump from 0x2736, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @273C stack[-2] // @273D msg.data[stack[-2]:stack[-2] + 0x20] // } 273B 5B JUMPDEST 273C 81 DUP2 273D 35 CALLDATALOAD 273E 60 PUSH1 0x01 2740 60 PUSH1 0x01 2742 60 PUSH1 0x40 2744 1B SHL 2745 03 SUB 2746 81 DUP2 2747 11 GT 2748 15 ISZERO 2749 61 PUSH2 0x2751 274C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @273D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2751, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_274D: // Incoming jump from 0x274C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2750 memory[0x00:0x00] } 274D 60 PUSH1 0x00 274F 80 DUP1 2750 FD *REVERT // Stack delta = +0 // Outputs[1] { @2750 revert(memory[0x00:0x00]); } // Block terminates label_2751: // Incoming jump from 0x274C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2755 stack[-4] // @2756 stack[-1] // @2757 stack[-3] // } 2751 5B JUMPDEST 2752 61 PUSH2 0x1d2a 2755 84 DUP5 2756 82 DUP3 2757 85 DUP6 2758 01 ADD 2759 61 PUSH2 0x26be 275C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2752 stack[0] = 0x1d2a // @2755 stack[1] = stack[-4] // @2758 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x26be, returns to 0x1D2A label_275D: // Incoming call from 0x041E, returns to 0x041F // Inputs[2] // { // @2763 stack[-1] // @2764 stack[-2] // } 275D 5B JUMPDEST 275E 60 PUSH1 0x00 2760 80 DUP1 2761 60 PUSH1 0x40 2763 83 DUP4 2764 85 DUP6 2765 03 SUB 2766 12 SLT 2767 15 ISZERO 2768 61 PUSH2 0x2770 276B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @275E stack[0] = 0x00 // @2760 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2770, if !(stack[-2] - stack[-1] i< 0x40) label_276C: // Incoming jump from 0x276B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @276F memory[0x00:0x00] } 276C 60 PUSH1 0x00 276E 80 DUP1 276F FD *REVERT // Stack delta = +0 // Outputs[1] { @276F revert(memory[0x00:0x00]); } // Block terminates label_2770: // Incoming jump from 0x276B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2774 stack[-3] } 2770 5B JUMPDEST 2771 61 PUSH2 0x2779 2774 83 DUP4 2775 61 PUSH2 0x23f2 2778 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2771 stack[0] = 0x2779 // @2774 stack[1] = stack[-3] // } // Block ends with call to 0x23f2, returns to 0x2779 label_2779: // Incoming return from call to 0x23F2 at 0x2778 // Inputs[4] // { // @277A stack[-3] // @277A stack[-1] // @277E stack[-4] // @2780 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2779 5B JUMPDEST 277A 91 SWAP2 277B 50 POP 277C 60 PUSH1 0x20 277E 83 DUP4 277F 01 ADD 2780 35 CALLDATALOAD 2781 60 PUSH1 0x01 2783 60 PUSH1 0x01 2785 60 PUSH1 0x40 2787 1B SHL 2788 03 SUB 2789 81 DUP2 278A 11 GT 278B 15 ISZERO 278C 61 PUSH2 0x2794 278F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @277A stack[-3] = stack[-1] // @2780 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2794, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_2790: // Incoming jump from 0x278F, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2793 memory[0x00:0x00] } 2790 60 PUSH1 0x00 2792 80 DUP1 2793 FD *REVERT // Stack delta = +0 // Outputs[1] { @2793 revert(memory[0x00:0x00]); } // Block terminates label_2794: // Incoming jump from 0x278F, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2798 stack[-5] // @2799 stack[-1] // @279A stack[-4] // } 2794 5B JUMPDEST 2795 61 PUSH2 0x27a0 2798 85 DUP6 2799 82 DUP3 279A 86 DUP7 279B 01 ADD 279C 61 PUSH2 0x26be 279F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2795 stack[0] = 0x27a0 // @2798 stack[1] = stack[-5] // @279B stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x26be, returns to 0x27A0 label_27A0: // Incoming return from call to 0x26BE at 0x279F // Inputs[6] // { // @27A1 stack[-1] // @27A1 stack[-3] // @27A4 stack[-6] // @27A6 stack[-4] // @27A6 stack[-7] // @27A7 stack[-5] // } 27A0 5B JUMPDEST 27A1 91 SWAP2 27A2 50 POP 27A3 50 POP 27A4 92 SWAP3 27A5 50 POP 27A6 92 SWAP3 27A7 90 SWAP1 27A8 50 POP 27A9 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @27A4 stack[-6] = stack[-1] // @27A6 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_27AA: // Incoming call from 0x043E, returns to 0x043F // Incoming call from 0x05AE, returns to 0x05AF // Incoming call from 0x05EE, returns to 0x05EF // Inputs[2] // { // @27AF stack[-1] // @27B0 stack[-2] // } 27AA 5B JUMPDEST 27AB 60 PUSH1 0x00 27AD 60 PUSH1 0x20 27AF 82 DUP3 27B0 84 DUP5 27B1 03 SUB 27B2 12 SLT 27B3 15 ISZERO 27B4 61 PUSH2 0x27bc 27B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27AB stack[0] = 0x00 } // Block ends with conditional jump to 0x27bc, if !(stack[-2] - stack[-1] i< 0x20) label_27B8: // Incoming jump from 0x27B7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27BB memory[0x00:0x00] } 27B8 60 PUSH1 0x00 27BA 80 DUP1 27BB FD *REVERT // Stack delta = +0 // Outputs[1] { @27BB revert(memory[0x00:0x00]); } // Block terminates label_27BC: // Incoming jump from 0x27B7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27C0 stack[-2] } 27BC 5B JUMPDEST 27BD 61 PUSH2 0x1f71 27C0 82 DUP3 27C1 61 PUSH2 0x23f2 27C4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @27BD stack[0] = 0x1f71 // @27C0 stack[1] = stack[-2] // } // Block ends with call to 0x23f2, returns to 0x1F71 label_27C5: // Incoming call from 0x27FE, returns to 0x27FF // Incoming call from 0x2A47, returns to 0x1F71 // Inputs[1] { @27C6 stack[-1] } 27C5 5B JUMPDEST 27C6 80 DUP1 27C7 15 ISZERO 27C8 15 ISZERO 27C9 81 DUP2 27CA 14 EQ 27CB 61 PUSH2 0x09d6 27CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d6, if stack[-1] == !!stack[-1] label_27CF: // Incoming jump from 0x27CE, if not stack[-1] == !!stack[-1] // Inputs[1] { @27D2 memory[0x00:0x00] } 27CF 60 PUSH1 0x00 27D1 80 DUP1 27D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D2 revert(memory[0x00:0x00]); } // Block terminates label_27D3: // Incoming call from 0x051B, returns to 0x051C // Inputs[2] // { // @27D9 stack[-1] // @27DA stack[-2] // } 27D3 5B JUMPDEST 27D4 60 PUSH1 0x00 27D6 80 DUP1 27D7 60 PUSH1 0x40 27D9 83 DUP4 27DA 85 DUP6 27DB 03 SUB 27DC 12 SLT 27DD 15 ISZERO 27DE 61 PUSH2 0x27e6 27E1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27D4 stack[0] = 0x00 // @27D6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x27e6, if !(stack[-2] - stack[-1] i< 0x40) label_27E2: // Incoming jump from 0x27E1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @27E5 memory[0x00:0x00] } 27E2 60 PUSH1 0x00 27E4 80 DUP1 27E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @27E5 revert(memory[0x00:0x00]); } // Block terminates label_27E6: // Incoming jump from 0x27E1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @27EA stack[-3] } 27E6 5B JUMPDEST 27E7 61 PUSH2 0x27ef 27EA 83 DUP4 27EB 61 PUSH2 0x23f2 27EE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @27E7 stack[0] = 0x27ef // @27EA stack[1] = stack[-3] // } // Block ends with call to 0x23f2, returns to 0x27EF label_27EF: // Incoming return from call to 0x23F2 at 0x27EE // Inputs[4] // { // @27F0 stack[-3] // @27F0 stack[-1] // @27F4 stack[-4] // @27F6 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 27EF 5B JUMPDEST 27F0 91 SWAP2 27F1 50 POP 27F2 60 PUSH1 0x20 27F4 83 DUP4 27F5 01 ADD 27F6 35 CALLDATALOAD 27F7 61 PUSH2 0x27ff 27FA 81 DUP2 27FB 61 PUSH2 0x27c5 27FE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @27F0 stack[-3] = stack[-1] // @27F6 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @27F7 stack[0] = 0x27ff // @27FA stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x27c5, returns to 0x27FF label_27FF: // Incoming return from call to 0x27C5 at 0x27FE // Inputs[6] // { // @2800 stack[-1] // @2801 stack[-2] // @2804 stack[-5] // @2806 stack[-6] // @2806 stack[-3] // @2807 stack[-4] // } 27FF 5B JUMPDEST 2800 80 DUP1 2801 91 SWAP2 2802 50 POP 2803 50 POP 2804 92 SWAP3 2805 50 POP 2806 92 SWAP3 2807 90 SWAP1 2808 50 POP 2809 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2804 stack[-5] = stack[-1] // @2806 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_280A: // Incoming call from 0x052E, returns to 0x052F // Inputs[2] // { // @2813 stack[-1] // @2814 stack[-2] // } 280A 5B JUMPDEST 280B 60 PUSH1 0x00 280D 80 DUP1 280E 60 PUSH1 0x00 2810 80 DUP1 2811 60 PUSH1 0x80 2813 85 DUP6 2814 87 DUP8 2815 03 SUB 2816 12 SLT 2817 15 ISZERO 2818 61 PUSH2 0x2820 281B 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @280B stack[0] = 0x00 // @280D stack[1] = 0x00 // @280E stack[2] = 0x00 // @2810 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2820, if !(stack[-2] - stack[-1] i< 0x80) label_281C: // Incoming jump from 0x281B, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @281F memory[0x00:0x00] } 281C 60 PUSH1 0x00 281E 80 DUP1 281F FD *REVERT // Stack delta = +0 // Outputs[1] { @281F revert(memory[0x00:0x00]); } // Block terminates label_2820: // Incoming jump from 0x281B, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2824 stack[-5] } 2820 5B JUMPDEST 2821 61 PUSH2 0x2829 2824 85 DUP6 2825 61 PUSH2 0x23f2 2828 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2821 stack[0] = 0x2829 // @2824 stack[1] = stack[-5] // } // Block ends with call to 0x23f2, returns to 0x2829 label_2829: // Incoming return from call to 0x23F2 at 0x2828 // Inputs[3] // { // @282A stack[-5] // @282A stack[-1] // @2831 stack[-6] // } 2829 5B JUMPDEST 282A 93 SWAP4 282B 50 POP 282C 61 PUSH2 0x2837 282F 60 PUSH1 0x20 2831 86 DUP7 2832 01 ADD 2833 61 PUSH2 0x23f2 2836 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @282A stack[-5] = stack[-1] // @282C stack[-1] = 0x2837 // @2832 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x23f2, returns to 0x2837 label_2837: // Incoming return from call to 0x23F2 at 0x2836 // Inputs[6] // { // @2838 stack[-4] // @2838 stack[-1] // @283C stack[-6] // @283E msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @283F stack[-3] // @2845 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2837 5B JUMPDEST 2838 92 SWAP3 2839 50 POP 283A 60 PUSH1 0x40 283C 85 DUP6 283D 01 ADD 283E 35 CALLDATALOAD 283F 91 SWAP2 2840 50 POP 2841 60 PUSH1 0x60 2843 85 DUP6 2844 01 ADD 2845 35 CALLDATALOAD 2846 60 PUSH1 0x01 2848 60 PUSH1 0x01 284A 60 PUSH1 0x40 284C 1B SHL 284D 03 SUB 284E 81 DUP2 284F 11 GT 2850 15 ISZERO 2851 61 PUSH2 0x2859 2854 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2838 stack[-4] = stack[-1] // @283F stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2845 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2859, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_2855: // Incoming jump from 0x2854, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2858 memory[0x00:0x00] } 2855 60 PUSH1 0x00 2857 80 DUP1 2858 FD *REVERT // Stack delta = +0 // Outputs[1] { @2858 revert(memory[0x00:0x00]); } // Block terminates label_2859: // Incoming jump from 0x2854, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @285A stack[-6] // @285B stack[-1] // @2860 stack[-7] // } 2859 5B JUMPDEST 285A 85 DUP6 285B 01 ADD 285C 60 PUSH1 0x1f 285E 81 DUP2 285F 01 ADD 2860 87 DUP8 2861 13 SGT 2862 61 PUSH2 0x286a 2865 57 *JUMPI // Stack delta = +0 // Outputs[1] { @285B stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x286a, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2866: // Incoming jump from 0x2865, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2869 memory[0x00:0x00] } 2866 60 PUSH1 0x00 2868 80 DUP1 2869 FD *REVERT // Stack delta = +0 // Outputs[1] { @2869 revert(memory[0x00:0x00]); } // Block terminates label_286A: // Incoming jump from 0x2865, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @286E stack[-7] // @286F stack[-1] // @2870 msg.data[stack[-1]:stack[-1] + 0x20] // } 286A 5B JUMPDEST 286B 61 PUSH2 0x2879 286E 87 DUP8 286F 82 DUP3 2870 35 CALLDATALOAD 2871 60 PUSH1 0x20 2873 84 DUP5 2874 01 ADD 2875 61 PUSH2 0x24a1 2878 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @286B stack[0] = 0x2879 // @286E stack[1] = stack[-7] // @2870 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2874 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x24a1, returns to 0x2879 label_2879: // Incoming return from call to 0x24A1 at 0x2878 // Inputs[8] // { // @287A stack[-1] // @287A stack[-3] // @287D stack[-6] // @287E stack[-9] // @287F stack[-5] // @2880 stack[-8] // @2882 stack[-4] // @2882 stack[-7] // } 2879 5B JUMPDEST 287A 91 SWAP2 287B 50 POP 287C 50 POP 287D 92 SWAP3 287E 95 SWAP6 287F 91 SWAP2 2880 94 SWAP5 2881 50 POP 2882 92 SWAP3 2883 50 POP 2884 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @287D stack[-6] = stack[-1] // @287E stack[-9] = stack[-6] // @2880 stack[-8] = stack[-5] // @2882 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2885: // Incoming call from 0x058E, returns to 0x058F // Inputs[2] // { // @288B stack[-1] // @288C stack[-2] // } 2885 5B JUMPDEST 2886 60 PUSH1 0x00 2888 60 PUSH1 0x20 288A 80 DUP1 288B 83 DUP4 288C 85 DUP6 288D 03 SUB 288E 12 SLT 288F 15 ISZERO 2890 61 PUSH2 0x2898 2893 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2886 stack[0] = 0x00 // @2888 stack[1] = 0x20 // } // Block ends with conditional jump to 0x2898, if !(stack[-2] - stack[-1] i< 0x20) label_2894: // Incoming jump from 0x2893, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2897 memory[0x00:0x00] } 2894 60 PUSH1 0x00 2896 80 DUP1 2897 FD *REVERT // Stack delta = +0 // Outputs[1] { @2897 revert(memory[0x00:0x00]); } // Block terminates label_2898: // Incoming jump from 0x2893, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2899 stack[-3] // @289A msg.data[stack[-3]:stack[-3] + 0x20] // } 2898 5B JUMPDEST 2899 82 DUP3 289A 35 CALLDATALOAD 289B 60 PUSH1 0x01 289D 60 PUSH1 0x01 289F 60 PUSH1 0x40 28A1 1B SHL 28A2 03 SUB 28A3 81 DUP2 28A4 11 GT 28A5 15 ISZERO 28A6 61 PUSH2 0x28ae 28A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @289A stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x28ae, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_28AA: // Incoming jump from 0x28A9, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @28AD memory[0x00:0x00] } 28AA 60 PUSH1 0x00 28AC 80 DUP1 28AD FD *REVERT // Stack delta = +0 // Outputs[1] { @28AD revert(memory[0x00:0x00]); } // Block terminates label_28AE: // Incoming jump from 0x28A9, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @28AF stack[-4] // @28B0 stack[-1] // @28B5 stack[-5] // } 28AE 5B JUMPDEST 28AF 83 DUP4 28B0 01 ADD 28B1 60 PUSH1 0x1f 28B3 81 DUP2 28B4 01 ADD 28B5 85 DUP6 28B6 13 SGT 28B7 61 PUSH2 0x28bf 28BA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @28B0 stack[-1] = stack[-4] + stack[-1] } // Block ends with conditional jump to 0x28bf, if stack[-5] i> stack[-4] + stack[-1] + 0x1f label_28BB: // Incoming jump from 0x28BA, if not stack[-5] i> stack[-4] + stack[-1] + 0x1f // Inputs[1] { @28BE memory[0x00:0x00] } 28BB 60 PUSH1 0x00 28BD 80 DUP1 28BE FD *REVERT // Stack delta = +0 // Outputs[1] { @28BE revert(memory[0x00:0x00]); } // Block terminates label_28BF: // Incoming jump from 0x28BA, if stack[-5] i> stack[-4] + stack[-1] + 0x1f // Inputs[2] // { // @28C0 stack[-1] // @28C1 msg.data[stack[-1]:stack[-1] + 0x20] // } 28BF 5B JUMPDEST 28C0 80 DUP1 28C1 35 CALLDATALOAD 28C2 61 PUSH2 0x28cd 28C5 61 PUSH2 0x26df 28C8 82 DUP3 28C9 61 PUSH2 0x269b 28CC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28C1 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @28C2 stack[1] = 0x28cd // @28C5 stack[2] = 0x26df // @28C8 stack[3] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x269b, returns to 0x26DF label_28CD: // Incoming return from call to 0x26DF at 0x28CC // Inputs[5] // { // @28CE stack[-2] // @28CF stack[-1] // @28D7 stack[-3] // @28D9 stack[-4] // @28E0 stack[-7] // } 28CD 5B JUMPDEST 28CE 81 DUP2 28CF 81 DUP2 28D0 52 MSTORE 28D1 60 PUSH1 0x06 28D3 91 SWAP2 28D4 90 SWAP1 28D5 91 SWAP2 28D6 1B SHL 28D7 82 DUP3 28D8 01 ADD 28D9 83 DUP4 28DA 01 ADD 28DB 90 SWAP1 28DC 83 DUP4 28DD 81 DUP2 28DE 01 ADD 28DF 90 SWAP1 28E0 87 DUP8 28E1 83 DUP4 28E2 11 GT 28E3 15 ISZERO 28E4 61 PUSH2 0x28ec 28E7 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @28D0 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @28DB stack[-2] = stack[-4] + stack[-3] + (stack[-2] << 0x06) // @28DF stack[-1] = stack[-1] + stack[-4] // @28DF stack[0] = stack[-1] // } // Block ends with conditional jump to 0x28ec, if !(stack[-4] + stack[-3] + (stack[-2] << 0x06) > stack[-7]) label_28E8: // Incoming jump from 0x28E7, if not !(stack[-4] + stack[-3] + (stack[-2] << 0x06) > stack[-7]) // Inputs[1] { @28EB memory[0x00:0x00] } 28E8 60 PUSH1 0x00 28EA 80 DUP1 28EB FD *REVERT // Stack delta = +0 // Outputs[1] { @28EB revert(memory[0x00:0x00]); } // Block terminates label_28EC: // Incoming jump from 0x28E7, if !(stack[-4] + stack[-3] + (stack[-2] << 0x06) > stack[-7]) // Inputs[4] // { // @28ED stack[-1] // @28ED stack[-4] // @28EE stack[-5] // @28F2 stack[-3] // } 28EC 5B JUMPDEST 28ED 92 SWAP3 28EE 84 DUP5 28EF 01 ADD 28F0 92 SWAP3 28F1 5B JUMPDEST 28F2 82 DUP3 28F3 84 DUP5 28F4 10 LT 28F5 15 ISZERO 28F6 61 PUSH2 0x2936 28F9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @28F0 stack[-1] = stack[-1] // @28F0 stack[-4] = stack[-5] + stack[-4] // } // Block ends with conditional jump to 0x2936, if !(stack[-5] + stack[-4] < stack[-3]) label_28FA: // Incoming jump from 0x28F9, if not !(stack[-5] + stack[-4] < stack[-3]) // Incoming jump from 0x28F9, if not !(stack[-4] < stack[-3]) // Inputs[2] // { // @28FC stack[-4] // @28FD stack[-8] // } 28FA 60 PUSH1 0x40 28FC 84 DUP5 28FD 89 DUP10 28FE 03 SUB 28FF 12 SLT 2900 15 ISZERO 2901 61 PUSH2 0x290a 2904 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x290a, if !(stack[-8] - stack[-4] i< 0x40) label_2905: // Incoming jump from 0x2904, if not !(stack[-8] - stack[-4] i< 0x40) // Inputs[1] { @2909 memory[0x00:0x00] } 2905 60 PUSH1 0x00 2907 80 DUP1 2908 81 DUP2 2909 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @2905 stack[0] = 0x00 // @2909 revert(memory[0x00:0x00]); // } // Block terminates label_290A: // Incoming jump from 0x2904, if !(stack[-8] - stack[-4] i< 0x40) 290A 5B JUMPDEST 290B 61 PUSH2 0x2912 290E 61 PUSH2 0x2449 2911 56 *JUMP // Stack delta = +1 // Outputs[1] { @290B stack[0] = 0x2912 } // Block ends with call to 0x2449, returns to 0x2912 label_2912: // Incoming return from call to 0x2449 at 0x2911 // Inputs[1] { @2916 stack[-5] } 2912 5B JUMPDEST 2913 61 PUSH2 0x291b 2916 85 DUP6 2917 61 PUSH2 0x23f2 291A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2913 stack[0] = 0x291b // @2916 stack[1] = stack[-5] // } // Block ends with call to 0x23f2, returns to 0x291B label_291B: // Incoming return from call to 0x23F2 at 0x291A // Inputs[7] // { // @291C stack[-2] // @291D stack[-1] // @291E stack[-6] // @291F stack[-7] // @2921 msg.data[stack[-7] + stack[-6]:stack[-7] + stack[-6] + 0x20] // @2926 stack[-4] // @292A stack[-3] // } 291B 5B JUMPDEST 291C 81 DUP2 291D 52 MSTORE 291E 84 DUP5 291F 86 DUP7 2920 01 ADD 2921 35 CALLDATALOAD 2922 86 DUP7 2923 82 DUP3 2924 01 ADD 2925 52 MSTORE 2926 82 DUP3 2927 52 MSTORE 2928 60 PUSH1 0x40 292A 90 SWAP1 292B 93 SWAP4 292C 01 ADD 292D 92 SWAP3 292E 90 SWAP1 292F 84 DUP5 2930 01 ADD 2931 90 SWAP1 2932 61 PUSH2 0x28f1 2935 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @291D memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2925 memory[stack[-2] + stack[-7]:stack[-2] + stack[-7] + 0x20] = msg.data[stack[-7] + stack[-6]:stack[-7] + stack[-6] + 0x20] // @2927 memory[stack[-4]:stack[-4] + 0x20] = stack[-2] // @292D stack[-6] = stack[-6] + 0x40 // @2931 stack[-4] = stack[-7] + stack[-4] // @2931 stack[-3] = stack[-3] // } // Block ends with unconditional jump to 0x28f1 label_2936: // Incoming return from call to 0x2A93 at 0x2B53 // Incoming jump from 0x28F9, if !(stack[-5] + stack[-4] < stack[-3]) // Incoming jump from 0x28F9, if !(stack[-4] < stack[-3]) // Inputs[3] // { // @2937 stack[-1] // @2937 stack[-9] // @2938 stack[-8] // } 2936 5B JUMPDEST 2937 97 SWAP8 2938 96 SWAP7 2939 50 POP 293A 50 POP 293B 50 POP 293C 50 POP 293D 50 POP 293E 50 POP 293F 50 POP 2940 56 *JUMP // Stack delta = -8 // Outputs[1] { @2937 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_2941: // Incoming jump from 0x05CE // Inputs[2] // { // @2947 stack[-1] // @2948 stack[-2] // } 2941 5B JUMPDEST 2942 60 PUSH1 0x00 2944 80 DUP1 2945 60 PUSH1 0x40 2947 83 DUP4 2948 85 DUP6 2949 03 SUB 294A 12 SLT 294B 15 ISZERO 294C 61 PUSH2 0x2954 294F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2942 stack[0] = 0x00 // @2944 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2954, if !(stack[-2] - stack[-1] i< 0x40) label_2950: // Incoming jump from 0x294F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2953 memory[0x00:0x00] } 2950 60 PUSH1 0x00 2952 80 DUP1 2953 FD *REVERT // Stack delta = +0 // Outputs[1] { @2953 revert(memory[0x00:0x00]); } // Block terminates label_2954: // Incoming jump from 0x294F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2958 stack[-3] } 2954 5B JUMPDEST 2955 61 PUSH2 0x295d 2958 83 DUP4 2959 61 PUSH2 0x23f2 295C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2955 stack[0] = 0x295d // @2958 stack[1] = stack[-3] // } // Block ends with call to 0x23f2, returns to 0x295D label_295D: // Incoming return from call to 0x23F2 at 0x295C // Inputs[3] // { // @295E stack[-3] // @295E stack[-1] // @2965 stack[-4] // } 295D 5B JUMPDEST 295E 91 SWAP2 295F 50 POP 2960 61 PUSH2 0x25cd 2963 60 PUSH1 0x20 2965 84 DUP5 2966 01 ADD 2967 61 PUSH2 0x23f2 296A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @295E stack[-3] = stack[-1] // @2960 stack[-1] = 0x25cd // @2966 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x23f2, returns to 0x25CD label_296B: // Incoming call from 0x061C, returns to 0x061D // Incoming call from 0x0648, returns to 0x0649 // Incoming call from 0x0C21, returns to 0x061D // Inputs[1] { @296E stack[-1] } 296B 5B JUMPDEST 296C 60 PUSH1 0x01 296E 81 DUP2 296F 81 DUP2 2970 1C SHR 2971 90 SWAP1 2972 82 DUP3 2973 16 AND 2974 80 DUP1 2975 61 PUSH2 0x297f 2978 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2971 stack[0] = stack[-1] >> 0x01 // @2973 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x297f, if stack[-1] & 0x01 label_2979: // Incoming jump from 0x2978, if not stack[-1] & 0x01 // Inputs[2] // { // @297B stack[-2] // @2984 stack[-1] // } 2979 60 PUSH1 0x7f 297B 82 DUP3 297C 16 AND 297D 91 SWAP2 297E 50 POP 297F 5B JUMPDEST 2980 60 PUSH1 0x20 2982 82 DUP3 2983 10 LT 2984 81 DUP2 2985 03 SUB 2986 61 PUSH2 0x299f 2989 57 *JUMPI // Stack delta = +0 // Outputs[1] { @297D stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x299f, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_298A: // Incoming jump from 0x2989, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x2989, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @299E memory[0x00:0x24] } 298A 63 PUSH4 0x4e487b71 298F 60 PUSH1 0xe0 2991 1B SHL 2992 60 PUSH1 0x00 2994 52 MSTORE 2995 60 PUSH1 0x22 2997 60 PUSH1 0x04 2999 52 MSTORE 299A 60 PUSH1 0x24 299C 60 PUSH1 0x00 299E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2994 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2999 memory[0x04:0x24] = 0x22 // @299E revert(memory[0x00:0x24]); // } // Block terminates label_299F: // Incoming jump from 0x2989, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x2989, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @29A1 stack[-4] // @29A1 stack[-2] // @29A2 stack[-3] // } 299F 5B JUMPDEST 29A0 50 POP 29A1 91 SWAP2 29A2 90 SWAP1 29A3 50 POP 29A4 56 *JUMP // Stack delta = -3 // Outputs[1] { @29A1 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_29A5: // Incoming jump from 0x2C89 // Incoming jump from 0x29D4 // Incoming jump from 0x2C9D // Inputs[1] { @29BA memory[0x00:0x24] } 29A5 5B JUMPDEST 29A6 63 PUSH4 0x4e487b71 29AB 60 PUSH1 0xe0 29AD 1B SHL 29AE 60 PUSH1 0x00 29B0 52 MSTORE 29B1 60 PUSH1 0x11 29B3 60 PUSH1 0x04 29B5 52 MSTORE 29B6 60 PUSH1 0x24 29B8 60 PUSH1 0x00 29BA FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29B0 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29B5 memory[0x04:0x24] = 0x11 // @29BA revert(memory[0x00:0x24]); // } // Block terminates label_29BB: // Incoming call from 0x079E, returns to 0x079F // Incoming call from 0x1E9E, returns to 0x1E9F // Incoming call from 0x1DE4, returns to 0x1DE5 // Inputs[2] // { // @29BE stack[-1] // @29C3 stack[-2] // } 29BB 5B JUMPDEST 29BC 60 PUSH1 0x00 29BE 81 DUP2 29BF 60 PUSH1 0x00 29C1 19 NOT 29C2 04 DIV 29C3 83 DUP4 29C4 11 GT 29C5 82 DUP3 29C6 15 ISZERO 29C7 15 ISZERO 29C8 16 AND 29C9 15 ISZERO 29CA 61 PUSH2 0x29d5 29CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29BC stack[0] = 0x00 } // Block ends with conditional jump to 0x29d5, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_29CE: // Incoming jump from 0x29CD, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 29CE 61 PUSH2 0x29d5 29D1 61 PUSH2 0x29a5 29D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @29CE stack[0] = 0x29d5 } // Block ends with unconditional jump to 0x29a5 label_29D5: // Incoming jump from 0x29CD, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @29D7 stack[-3] // @29D7 stack[-2] // @29D8 stack[-4] // } 29D5 5B JUMPDEST 29D6 50 POP 29D7 02 MUL 29D8 90 SWAP1 29D9 56 *JUMP // Stack delta = -3 // Outputs[1] { @29D8 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_29DA: // Incoming call from 0x07A8, returns to 0x07A9 // Inputs[1] { @29DD stack[-2] } 29DA 5B JUMPDEST 29DB 60 PUSH1 0x00 29DD 82 DUP3 29DE 61 PUSH2 0x29f7 29E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29DB stack[0] = 0x00 } // Block ends with conditional jump to 0x29f7, if stack[-2] label_29E2: // Incoming jump from 0x29E1, if not stack[-2] // Inputs[1] { @29F6 memory[0x00:0x24] } 29E2 63 PUSH4 0x4e487b71 29E7 60 PUSH1 0xe0 29E9 1B SHL 29EA 60 PUSH1 0x00 29EC 52 MSTORE 29ED 60 PUSH1 0x12 29EF 60 PUSH1 0x04 29F1 52 MSTORE 29F2 60 PUSH1 0x24 29F4 60 PUSH1 0x00 29F6 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29EC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29F1 memory[0x04:0x24] = 0x12 // @29F6 revert(memory[0x00:0x24]); // } // Block terminates label_29F7: // Incoming jump from 0x29E1, if stack[-2] // Inputs[3] // { // @29F9 stack[-3] // @29F9 stack[-2] // @29FA stack[-4] // } 29F7 5B JUMPDEST 29F8 50 POP 29F9 04 DIV 29FA 90 SWAP1 29FB 56 *JUMP // Stack delta = -3 // Outputs[1] { @29FA stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_29FC: // Incoming jump from 0x1E7A // Incoming jump from 0x1E4B // Incoming jump from 0x1EDD // Incoming jump from 0x1858 // Incoming jump from 0x1483 // Incoming jump from 0x09FF // Incoming jump from 0x142F // Incoming jump from 0x1EF3 // Incoming jump from 0x1883 // Inputs[1] { @2A11 memory[0x00:0x24] } 29FC 5B JUMPDEST 29FD 63 PUSH4 0x4e487b71 2A02 60 PUSH1 0xe0 2A04 1B SHL 2A05 60 PUSH1 0x00 2A07 52 MSTORE 2A08 60 PUSH1 0x32 2A0A 60 PUSH1 0x04 2A0C 52 MSTORE 2A0D 60 PUSH1 0x24 2A0F 60 PUSH1 0x00 2A11 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2A07 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2A0C memory[0x04:0x24] = 0x32 // @2A11 revert(memory[0x00:0x24]); // } // Block terminates 2A12 5B JUMPDEST 2A13 60 PUSH1 0x00 2A15 60 PUSH1 0x01 2A17 82 DUP3 2A18 01 ADD 2A19 61 PUSH2 0x2a24 2A1C 57 *JUMPI 2A1D 61 PUSH2 0x2a24 2A20 61 PUSH2 0x29a5 2A23 56 *JUMP 2A24 5B JUMPDEST 2A25 50 POP 2A26 60 PUSH1 0x01 2A28 01 ADD 2A29 90 SWAP1 2A2A 56 *JUMP label_2A2B: // Incoming call from 0x0ED1, returns to 0x0ED2 // Inputs[2] // { // @2A30 stack[-1] // @2A31 stack[-2] // } 2A2B 5B JUMPDEST 2A2C 60 PUSH1 0x00 2A2E 60 PUSH1 0x20 2A30 82 DUP3 2A31 84 DUP5 2A32 03 SUB 2A33 12 SLT 2A34 15 ISZERO 2A35 61 PUSH2 0x2a3d 2A38 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A2C stack[0] = 0x00 } // Block ends with conditional jump to 0x2a3d, if !(stack[-2] - stack[-1] i< 0x20) label_2A39: // Incoming jump from 0x2A38, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A3C memory[0x00:0x00] } 2A39 60 PUSH1 0x00 2A3B 80 DUP1 2A3C FD *REVERT // Stack delta = +0 // Outputs[1] { @2A3C revert(memory[0x00:0x00]); } // Block terminates label_2A3D: // Incoming jump from 0x2A38, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A3E stack[-2] // @2A3F memory[stack[-2]:stack[-2] + 0x20] // } 2A3D 5B JUMPDEST 2A3E 81 DUP2 2A3F 51 MLOAD 2A40 61 PUSH2 0x1f71 2A43 81 DUP2 2A44 61 PUSH2 0x27c5 2A47 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A3F stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2A40 stack[1] = 0x1f71 // @2A43 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x27c5, returns to 0x1F71 label_2A48: // Incoming call from 0x1F9E, returns to 0x0870 // Incoming call from 0x1340, returns to 0x0870 // Incoming call from 0x1AF6, returns to 0x0870 // Inputs[2] // { // @2A4C stack[-1] // @2A91 stack[-2] // } 2A48 5B JUMPDEST 2A49 60 PUSH1 0x20 2A4B 80 DUP1 2A4C 82 DUP3 2A4D 52 MSTORE 2A4E 60 PUSH1 0x2b 2A50 90 SWAP1 2A51 82 DUP3 2A52 01 ADD 2A53 52 MSTORE 2A54 7F PUSH32 0x496e697469616c697a61626c653a20636f6e7472616374206973206e6f742069 2A75 60 PUSH1 0x40 2A77 82 DUP3 2A78 01 ADD 2A79 52 MSTORE 2A7A 6A PUSH11 0x6e697469616c697a696e67 2A86 60 PUSH1 0xa8 2A88 1B SHL 2A89 60 PUSH1 0x60 2A8B 82 DUP3 2A8C 01 ADD 2A8D 52 MSTORE 2A8E 60 PUSH1 0x80 2A90 01 ADD 2A91 90 SWAP1 2A92 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2A4D memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A53 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @2A79 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e697469616c697a61626c653a20636f6e7472616374206973206e6f742069 // @2A8D memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6e697469616c697a696e67 << 0xa8 // @2A91 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2A93: // Incoming call from 0x2B53, returns to 0x2936 // Incoming call from 0x2B37, returns to 0x2B38 // Inputs[2] // { // @2A94 stack[-1] // @2A95 storage[stack[-1]] // } 2A93 5B JUMPDEST 2A94 80 DUP1 2A95 54 SLOAD 2A96 60 PUSH1 0x00 2A98 90 SWAP1 2A99 60 PUSH1 0x01 2A9B 81 DUP2 2A9C 81 DUP2 2A9D 1C SHR 2A9E 90 SWAP1 2A9F 80 DUP1 2AA0 83 DUP4 2AA1 16 AND 2AA2 80 DUP1 2AA3 61 PUSH2 0x2aad 2AA6 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2A98 stack[0] = 0x00 // @2A98 stack[1] = storage[stack[-1]] // @2A9E stack[2] = storage[stack[-1]] >> 0x01 // @2A9E stack[3] = 0x01 // @2AA1 stack[4] = storage[stack[-1]] & 0x01 // } // Block ends with conditional jump to 0x2aad, if storage[stack[-1]] & 0x01 label_2AA7: // Incoming jump from 0x2AA6, if not storage[stack[-1]] & 0x01 // Inputs[2] // { // @2AA9 stack[-3] // @2AB3 stack[-1] // } 2AA7 60 PUSH1 0x7f 2AA9 83 DUP4 2AAA 16 AND 2AAB 92 SWAP3 2AAC 50 POP 2AAD 5B JUMPDEST 2AAE 60 PUSH1 0x20 2AB0 80 DUP1 2AB1 84 DUP5 2AB2 10 LT 2AB3 82 DUP3 2AB4 03 SUB 2AB5 61 PUSH2 0x2ace 2AB8 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2AAB stack[-3] = stack[-3] & 0x7f // @2AAE stack[0] = 0x20 // } // Block ends with conditional jump to 0x2ace, if stack[-1] - (stack[-3] & 0x7f < 0x20) label_2AB9: // Incoming jump from 0x2AB8, if not stack[-1] - (stack[-3] & 0x7f < 0x20) // Incoming jump from 0x2AB8, if not stack[-1] - (stack[-3] < 0x20) // Inputs[1] { @2ACD memory[0x00:0x24] } 2AB9 63 PUSH4 0x4e487b71 2ABE 60 PUSH1 0xe0 2AC0 1B SHL 2AC1 60 PUSH1 0x00 2AC3 52 MSTORE 2AC4 60 PUSH1 0x22 2AC6 60 PUSH1 0x04 2AC8 52 MSTORE 2AC9 60 PUSH1 0x24 2ACB 60 PUSH1 0x00 2ACD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2AC3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2AC8 memory[0x04:0x24] = 0x22 // @2ACD revert(memory[0x00:0x24]); // } // Block terminates label_2ACE: // Incoming jump from 0x2AB8, if stack[-1] - (stack[-3] & 0x7f < 0x20) // Incoming jump from 0x2AB8, if stack[-1] - (stack[-3] < 0x20) // Inputs[1] { @2ACF stack[-2] } 2ACE 5B JUMPDEST 2ACF 81 DUP2 2AD0 80 DUP1 2AD1 15 ISZERO 2AD2 61 PUSH2 0x2ae2 2AD5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2ACF stack[0] = stack[-2] } // Block ends with conditional jump to 0x2ae2, if !stack[-2] label_2AD6: // Incoming jump from 0x2AD5, if not !stack[-2] // Inputs[1] { @2AD8 stack[-1] } 2AD6 60 PUSH1 0x01 2AD8 81 DUP2 2AD9 14 EQ 2ADA 61 PUSH2 0x2af3 2ADD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2af3, if stack[-1] == 0x01 label_2ADE: // Incoming jump from 0x2ADD, if not stack[-1] == 0x01 2ADE 61 PUSH2 0x2b20 2AE1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2b20 label_2AE2: // Incoming jump from 0x2AD5, if !stack[-2] // Inputs[4] // { // @2AE6 stack[-6] // @2AE8 stack[-9] // @2AEA stack[-5] // @2AED stack[-7] // } 2AE2 5B JUMPDEST 2AE3 60 PUSH1 0xff 2AE5 19 NOT 2AE6 86 DUP7 2AE7 16 AND 2AE8 89 DUP10 2AE9 52 MSTORE 2AEA 84 DUP5 2AEB 89 DUP10 2AEC 01 ADD 2AED 96 SWAP7 2AEE 50 POP 2AEF 61 PUSH2 0x2b20 2AF2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2AE9 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @2AED stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x2b20 label_2AF3: // Incoming jump from 0x2ADD, if stack[-1] == 0x01 // Inputs[3] // { // @2AF6 stack[-8] // @2AFC memory[0x00:0x20] // @2B00 stack[-5] // } 2AF3 5B JUMPDEST 2AF4 60 PUSH1 0x00 2AF6 88 DUP9 2AF7 81 DUP2 2AF8 52 MSTORE 2AF9 60 PUSH1 0x20 2AFB 90 SWAP1 2AFC 20 SHA3 2AFD 60 PUSH1 0x00 2AFF 5B JUMPDEST 2B00 86 DUP7 2B01 81 DUP2 2B02 10 LT 2B03 15 ISZERO 2B04 61 PUSH2 0x2b18 2B07 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2AF8 memory[0x00:0x20] = stack[-8] // @2AFC stack[0] = keccak256(memory[0x00:0x20]) // @2AFD stack[1] = 0x00 // } // Block ends with conditional jump to 0x2b18, if !(0x00 < stack[-5]) label_2B08: // Incoming jump from 0x2B07, if not !(0x00 < stack[-5]) // Incoming jump from 0x2B07, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @2B08 stack[-2] // @2B09 storage[stack[-2]] // @2B0A stack[-11] // @2B0B stack[-1] // @2B0F stack[-6] // @2B12 stack[-4] // } 2B08 81 DUP2 2B09 54 SLOAD 2B0A 8B DUP12 2B0B 82 DUP3 2B0C 01 ADD 2B0D 52 MSTORE 2B0E 90 SWAP1 2B0F 85 DUP6 2B10 01 ADD 2B11 90 SWAP1 2B12 83 DUP4 2B13 01 ADD 2B14 61 PUSH2 0x2aff 2B17 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2B0D memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @2B11 stack[-2] = stack[-6] + stack[-2] // @2B13 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x2aff label_2B18: // Incoming jump from 0x2B07, if !(0x00 < stack[-5]) // Incoming jump from 0x2B07, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @2B1B stack[-7] // @2B1C stack[-11] // @2B1E stack[-9] // } 2B18 5B JUMPDEST 2B19 50 POP 2B1A 50 POP 2B1B 84 DUP5 2B1C 89 DUP10 2B1D 01 ADD 2B1E 96 SWAP7 2B1F 50 POP // Stack delta = -2 // Outputs[1] { @2B1E stack[-9] = stack[-11] + stack[-7] } // Block continues label_2B20: // Incoming jump from 0x2AE1 // Incoming jump from 0x2AF2 // Incoming jump from 0x2B1F // Inputs[3] // { // @2B27 stack[-10] // @2B27 stack[-7] // @2B28 stack[-9] // } 2B20 5B JUMPDEST 2B21 50 POP 2B22 50 POP 2B23 50 POP 2B24 50 POP 2B25 50 POP 2B26 50 POP 2B27 92 SWAP3 2B28 91 SWAP2 2B29 50 POP 2B2A 50 POP 2B2B 56 *JUMP // Stack delta = -9 // Outputs[1] { @2B27 stack[-10] = stack[-7] } // Block ends with unconditional jump to stack[-10] label_2B2C: // Incoming jump from 0x182D // Inputs[2] // { // @2B32 stack[-1] // @2B33 stack[-4] // } 2B2C 5B JUMPDEST 2B2D 60 PUSH1 0x00 2B2F 61 PUSH2 0x2b38 2B32 82 DUP3 2B33 86 DUP7 2B34 61 PUSH2 0x2a93 2B37 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B2D stack[0] = 0x00 // @2B2F stack[1] = 0x2b38 // @2B32 stack[2] = stack[-1] // @2B33 stack[3] = stack[-4] // } // Block ends with call to 0x2a93, returns to 0x2B38 label_2B38: // Incoming return from call to 0x2A93 at 0x2B37 // Inputs[3] // { // @2B39 stack[-5] // @2B3A memory[stack[-5]:stack[-5] + 0x20] // @2B3F stack[-1] // } 2B38 5B JUMPDEST 2B39 84 DUP5 2B3A 51 MLOAD 2B3B 61 PUSH2 0x2b48 2B3E 81 DUP2 2B3F 83 DUP4 2B40 60 PUSH1 0x20 2B42 89 DUP10 2B43 01 ADD 2B44 61 PUSH2 0x236e 2B47 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2B3A stack[0] = memory[stack[-5]:stack[-5] + 0x20] // @2B3B stack[1] = 0x2b48 // @2B3E stack[2] = memory[stack[-5]:stack[-5] + 0x20] // @2B3F stack[3] = stack[-1] // @2B43 stack[4] = stack[-5] + 0x20 // } // Block ends with call to 0x236e, returns to 0x2B48 label_2B48: // Incoming return from call to 0x236E at 0x2B47 // Inputs[3] // { // @2B4C stack[-1] // @2B4D stack[-2] // @2B4F stack[-5] // } 2B48 5B JUMPDEST 2B49 61 PUSH2 0x2936 2B4C 81 DUP2 2B4D 83 DUP4 2B4E 01 ADD 2B4F 86 DUP7 2B50 61 PUSH2 0x2a93 2B53 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B49 stack[0] = 0x2936 // @2B4E stack[1] = stack[-2] + stack[-1] // @2B4F stack[2] = stack[-5] // } // Block ends with call to 0x2a93, returns to 0x2936 2B54 5B JUMPDEST 2B55 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 2B76 81 DUP2 2B77 52 MSTORE 2B78 60 PUSH1 0x00 2B7A 83 DUP4 2B7B 51 MLOAD 2B7C 61 PUSH2 0x2b8c 2B7F 81 DUP2 2B80 60 PUSH1 0x17 2B82 85 DUP6 2B83 01 ADD 2B84 60 PUSH1 0x20 2B86 88 DUP9 2B87 01 ADD 2B88 61 PUSH2 0x236e 2B8B 56 *JUMP 2B8C 5B JUMPDEST 2B8D 70 PUSH17 0x01034b99036b4b9b9b4b733903937b6329 2B9F 60 PUSH1 0x7d 2BA1 1B SHL 2BA2 60 PUSH1 0x17 2BA4 91 SWAP2 2BA5 84 DUP5 2BA6 01 ADD 2BA7 91 SWAP2 2BA8 82 DUP3 2BA9 01 ADD 2BAA 52 MSTORE 2BAB 83 DUP4 2BAC 51 MLOAD 2BAD 61 PUSH2 0x2bbd 2BB0 81 DUP2 2BB1 60 PUSH1 0x28 2BB3 84 DUP5 2BB4 01 ADD 2BB5 60 PUSH1 0x20 2BB7 88 DUP9 2BB8 01 ADD 2BB9 61 PUSH2 0x236e 2BBC 56 *JUMP 2BBD 5B JUMPDEST 2BBE 01 ADD 2BBF 60 PUSH1 0x28 2BC1 01 ADD 2BC2 94 SWAP5 2BC3 93 SWAP4 2BC4 50 POP 2BC5 50 POP 2BC6 50 POP 2BC7 50 POP 2BC8 56 *JUMP 2BC9 5B JUMPDEST 2BCA 60 PUSH1 0x20 2BCC 80 DUP1 2BCD 82 DUP3 2BCE 52 MSTORE 2BCF 60 PUSH1 0x34 2BD1 90 SWAP1 2BD2 82 DUP3 2BD3 01 ADD 2BD4 52 MSTORE 2BD5 7F PUSH32 0x455243373231415f5f496e697469616c697a61626c653a20636f6e7472616374 2BF6 60 PUSH1 0x40 2BF8 82 DUP3 2BF9 01 ADD 2BFA 52 MSTORE 2BFB 73 PUSH20 0x206973206e6f7420696e697469616c697a696e67 2C10 60 PUSH1 0x60 2C12 1B SHL 2C13 60 PUSH1 0x60 2C15 82 DUP3 2C16 01 ADD 2C17 52 MSTORE 2C18 60 PUSH1 0x80 2C1A 01 ADD 2C1B 90 SWAP1 2C1C 56 *JUMP 2C1D 5B JUMPDEST 2C1E 60 PUSH1 0x01 2C20 60 PUSH1 0x01 2C22 60 PUSH1 0xa0 2C24 1B SHL 2C25 03 SUB 2C26 85 DUP6 2C27 81 DUP2 2C28 16 AND 2C29 82 DUP3 2C2A 52 MSTORE 2C2B 84 DUP5 2C2C 16 AND 2C2D 60 PUSH1 0x20 2C2F 82 DUP3 2C30 01 ADD 2C31 52 MSTORE 2C32 60 PUSH1 0x40 2C34 81 DUP2 2C35 01 ADD 2C36 83 DUP4 2C37 90 SWAP1 2C38 52 MSTORE 2C39 60 PUSH1 0x80 2C3B 60 PUSH1 0x60 2C3D 82 DUP3 2C3E 01 ADD 2C3F 81 DUP2 2C40 90 SWAP1 2C41 52 MSTORE 2C42 60 PUSH1 0x00 2C44 90 SWAP1 2C45 61 PUSH2 0x2c50 2C48 90 SWAP1 2C49 83 DUP4 2C4A 01 ADD 2C4B 84 DUP5 2C4C 61 PUSH2 0x239a 2C4F 56 *JUMP 2C50 5B JUMPDEST 2C51 96 SWAP7 2C52 95 SWAP6 2C53 50 POP 2C54 50 POP 2C55 50 POP 2C56 50 POP 2C57 50 POP 2C58 50 POP 2C59 56 *JUMP 2C5A 5B JUMPDEST 2C5B 60 PUSH1 0x00 2C5D 60 PUSH1 0x20 2C5F 82 DUP3 2C60 84 DUP5 2C61 03 SUB 2C62 12 SLT 2C63 15 ISZERO 2C64 61 PUSH2 0x2c6c 2C67 57 *JUMPI 2C68 60 PUSH1 0x00 2C6A 80 DUP1 2C6B FD *REVERT 2C6C 5B JUMPDEST 2C6D 81 DUP2 2C6E 51 MLOAD 2C6F 61 PUSH2 0x1f71 2C72 81 DUP2 2C73 61 PUSH2 0x233b 2C76 56 *JUMP label_2C77: // Incoming call from 0x1DEF, returns to 0x1DF0 // Incoming call from 0x1EA9, returns to 0x1EAA // Inputs[2] // { // @2C7A stack[-2] // @2C7C stack[-1] // } 2C77 5B JUMPDEST 2C78 60 PUSH1 0x00 2C7A 82 DUP3 2C7B 19 NOT 2C7C 82 DUP3 2C7D 11 GT 2C7E 15 ISZERO 2C7F 61 PUSH2 0x2c8a 2C82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C78 stack[0] = 0x00 } // Block ends with conditional jump to 0x2c8a, if !(stack[-1] > ~stack[-2]) label_2C83: // Incoming jump from 0x2C82, if not !(stack[-1] > ~stack[-2]) 2C83 61 PUSH2 0x2c8a 2C86 61 PUSH2 0x29a5 2C89 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C83 stack[0] = 0x2c8a } // Block ends with unconditional jump to 0x29a5 label_2C8A: // Incoming jump from 0x2C82, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2C8C stack[-3] // @2C8C stack[-2] // @2C8D stack[-4] // } 2C8A 5B JUMPDEST 2C8B 50 POP 2C8C 01 ADD 2C8D 90 SWAP1 2C8E 56 *JUMP // Stack delta = -3 // Outputs[1] { @2C8D stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2C8F: // Incoming call from 0x1F1A, returns to 0x1F1B // Inputs[1] { @2C92 stack[-1] } 2C8F 5B JUMPDEST 2C90 60 PUSH1 0x00 2C92 81 DUP2 2C93 61 PUSH2 0x2c9e 2C96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C90 stack[0] = 0x00 } // Block ends with conditional jump to 0x2c9e, if stack[-1] label_2C97: // Incoming jump from 0x2C96, if not stack[-1] 2C97 61 PUSH2 0x2c9e 2C9A 61 PUSH2 0x29a5 2C9D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2C97 stack[0] = 0x2c9e } // Block ends with unconditional jump to 0x29a5 label_2C9E: // Incoming jump from 0x2C96, if stack[-1] // Inputs[2] // { // @2CA3 stack[-2] // @2CA4 stack[-3] // } 2C9E 5B JUMPDEST 2C9F 50 POP 2CA0 60 PUSH1 0x00 2CA2 19 NOT 2CA3 01 ADD 2CA4 90 SWAP1 2CA5 56 *JUMP // Stack delta = -2 // Outputs[1] { @2CA4 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] 2CA6 FE *ASSERT 2CA7 EE EE 2CA8 15 ISZERO 2CA9 1C SHR 2CAA 84 DUP5 2CAB 01 ADD 2CAC 92 SWAP3 2CAD 8D DUP14 2CAE C2 C2 2CAF 23 23 2CB0 60 PUSH1 0x2b 2CB2 B1 DUP 2CB3 87 DUP8 2CB4 AF AF 2CB5 F9 F9 2CB6 1B SHL 2CB7 9A SWAP11 2CB8 56 *JUMP 2CB9 C7 C7 2CBA CA CA 2CBB E5 E5 2CBC 47 SELFBALANCE 2CBD 6E PUSH15 0xf1b3287b085a16c85fa26469706673 2CCD 58 PC 2CCE 22 22 2CCF 12 SLT 2CD0 20 SHA3 2CD1 D2 D2 2CD2 B4 B4 2CD3 CA CA 2CD4 A6 A6 2CD5 3C EXTCODECOPY 2CD6 96 SWAP7 2CD7 3C EXTCODECOPY 2CD8 35 CALLDATALOAD 2CD9 8B DUP12 2CDA 6A PUSH11 0x86be61f24e930c5c033855 2CE6 0C 0C 2CE7 9A SWAP11 2CE8 4C 4C 2CE9 B7 B7 2CEA D6 D6 2CEB AA AA 2CEC DD DD 2CED 7E PUSH31 0xde15b764736f6c634300080d0033