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 0x01f9 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01f9, 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 0x715018a6 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb88d4fde 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0xb88d4fde > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xced33bc4 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xced33bc4 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xced33bc4 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xced33bc4 003A 14 EQ 003B 61 PUSH2 0x0570 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0570, if 0xced33bc4 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xced33bc4 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x0586 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0586, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xecba222a 0050 14 EQ 0051 61 PUSH2 0x05cf 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05cf, if 0xecba222a == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xecba222a == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x05f0 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f0, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf746d634 0066 14 EQ 0067 61 PUSH2 0x0610 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0610, if 0xf746d634 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf746d634 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xced33bc4 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x04f0 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f0, 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 0xb8d1e532 0081 14 EQ 0082 61 PUSH2 0x0503 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0503, if 0xb8d1e532 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb8d1e532 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc23dc68f 008C 14 EQ 008D 61 PUSH2 0x0523 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0523, if 0xc23dc68f == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc23dc68f == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x0550 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0550, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009F memory[0x00:0x00] } 009C 60 PUSH1 0x00 009E 80 DUP1 009F FD *REVERT // Stack delta = +0 // Outputs[1] { @009F revert(memory[0x00:0x00]); } // Block terminates label_00A0: // Incoming jump from 0x0028, if 0xb88d4fde > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x99a2557a 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x99a2557a > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x99a2557a > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x99a2557a 00B2 14 EQ 00B3 61 PUSH2 0x0476 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0476, if 0x99a2557a == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x99a2557a == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xa01ffdff 00BD 14 EQ 00BE 61 PUSH2 0x0496 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0496, if 0xa01ffdff == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xa01ffdff == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa22cb465 00C8 14 EQ 00C9 61 PUSH2 0x04b0 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b0, if 0xa22cb465 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xb0ccc31e 00D3 14 EQ 00D4 61 PUSH2 0x04d0 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d0, if 0xb0ccc31e == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xb0ccc31e == stack[-1] // Inputs[1] { @00DB memory[0x00:0x00] } 00D8 60 PUSH1 0x00 00DA 80 DUP1 00DB FD *REVERT // Stack delta = +0 // Outputs[1] { @00DB revert(memory[0x00:0x00]); } // Block terminates label_00DC: // Incoming jump from 0x00AB, if 0x99a2557a > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x715018a6 00E3 14 EQ 00E4 61 PUSH2 0x040a 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040a, 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 0x8462151c 00EE 14 EQ 00EF 61 PUSH2 0x041f 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041f, if 0x8462151c == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x8462151c == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x8da5cb5b 00F9 14 EQ 00FA 61 PUSH2 0x044c 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044c, if 0x8da5cb5b == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x95d89b41 0104 14 EQ 0105 61 PUSH2 0x0461 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0461, if 0x95d89b41 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x95d89b41 == stack[-1] // Inputs[1] { @010C memory[0x00:0x00] } 0109 60 PUSH1 0x00 010B 80 DUP1 010C FD *REVERT // Stack delta = +0 // Outputs[1] { @010C revert(memory[0x00:0x00]); } // Block terminates label_010D: // Incoming jump from 0x001D, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x3232deeb 0114 11 GT 0115 61 PUSH2 0x0190 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x3232deeb > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x3232deeb > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x5bbb2177 011F 11 GT 0120 61 PUSH2 0x015f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x5bbb2177 > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x5bbb2177 > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x5bbb2177 012A 14 EQ 012B 61 PUSH2 0x0368 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0368, if 0x5bbb2177 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x5bbb2177 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x5ef9432a 0135 14 EQ 0136 61 PUSH2 0x0395 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0395, if 0x5ef9432a == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x5ef9432a == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x6352211e 0140 14 EQ 0141 61 PUSH2 0x03aa 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03aa, if 0x6352211e == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x6352211e == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6e63b104 014B 14 EQ 014C 61 PUSH2 0x03ca 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0x6e63b104 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6e63b104 == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x70a08231 0156 14 EQ 0157 61 PUSH2 0x03ea 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ea, if 0x70a08231 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x70a08231 == stack[-1] // Inputs[1] { @015E memory[0x00:0x00] } 015B 60 PUSH1 0x00 015D 80 DUP1 015E FD *REVERT // Stack delta = +0 // Outputs[1] { @015E revert(memory[0x00:0x00]); } // Block terminates label_015F: // Incoming jump from 0x0123, if 0x5bbb2177 > stack[-1] // Inputs[1] { @0160 stack[-1] } 015F 5B JUMPDEST 0160 80 DUP1 0161 63 PUSH4 0x3232deeb 0166 14 EQ 0167 61 PUSH2 0x0318 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0318, if 0x3232deeb == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x3232deeb == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x33958a18 0171 14 EQ 0172 61 PUSH2 0x032d 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032d, if 0x33958a18 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x33958a18 == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x42842e0e 017C 14 EQ 017D 61 PUSH2 0x0335 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0335, if 0x42842e0e == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x42842e0e == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x4d2a1eb8 0187 14 EQ 0188 61 PUSH2 0x0348 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0348, if 0x4d2a1eb8 == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x4d2a1eb8 == stack[-1] // Inputs[1] { @018F memory[0x00:0x00] } 018C 60 PUSH1 0x00 018E 80 DUP1 018F FD *REVERT // Stack delta = +0 // Outputs[1] { @018F revert(memory[0x00:0x00]); } // Block terminates label_0190: // Incoming jump from 0x0118, if 0x3232deeb > stack[-1] // Inputs[1] { @0191 stack[-1] } 0190 5B JUMPDEST 0191 80 DUP1 0192 63 PUSH4 0x18160ddd 0197 11 GT 0198 61 PUSH2 0x01cc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, 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 0x18160ddd 01A2 14 EQ 01A3 61 PUSH2 0x02a2 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0x18160ddd == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x18160ddd == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x23b872dd 01AD 14 EQ 01AE 61 PUSH2 0x02c5 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x23b872dd == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x23b872dd == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x2775676c 01B8 14 EQ 01B9 61 PUSH2 0x02d8 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d8, if 0x2775676c == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x2775676c == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x2f40823b 01C3 14 EQ 01C4 61 PUSH2 0x02f8 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0x2f40823b == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x2f40823b == stack[-1] // Inputs[1] { @01CB memory[0x00:0x00] } 01C8 60 PUSH1 0x00 01CA 80 DUP1 01CB FD *REVERT // Stack delta = +0 // Outputs[1] { @01CB revert(memory[0x00:0x00]); } // Block terminates label_01CC: // Incoming jump from 0x019B, if 0x18160ddd > stack[-1] // Inputs[1] { @01CD stack[-1] } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 63 PUSH4 0x01ffc9a7 01D3 14 EQ 01D4 61 PUSH2 0x01fe 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fe, if 0x01ffc9a7 == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x06fdde03 01DE 14 EQ 01DF 61 PUSH2 0x0233 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0233, if 0x06fdde03 == stack[-1] label_01E3: // Incoming jump from 0x01E2, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01E3 stack[-1] } 01E3 80 DUP1 01E4 63 PUSH4 0x081812fc 01E9 14 EQ 01EA 61 PUSH2 0x0255 01ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0255, if 0x081812fc == stack[-1] label_01EE: // Incoming jump from 0x01ED, if not 0x081812fc == stack[-1] // Inputs[1] { @01EE stack[-1] } 01EE 80 DUP1 01EF 63 PUSH4 0x095ea7b3 01F4 14 EQ 01F5 61 PUSH2 0x028d 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028d, if 0x095ea7b3 == stack[-1] label_01F9: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x01F8, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01FD memory[0x00:0x00] } 01F9 5B JUMPDEST 01FA 60 PUSH1 0x00 01FC 80 DUP1 01FD FD *REVERT // Stack delta = +0 // Outputs[1] { @01FD revert(memory[0x00:0x00]); } // Block terminates label_01FE: // Incoming jump from 0x01D7, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01FF msg.value } 01FE 5B JUMPDEST 01FF 34 CALLVALUE 0200 80 DUP1 0201 15 ISZERO 0202 61 PUSH2 0x020a 0205 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01FF stack[0] = msg.value } // Block ends with conditional jump to 0x020a, if !msg.value label_0206: // Incoming jump from 0x0205, if not !msg.value // Inputs[1] { @0209 memory[0x00:0x00] } 0206 60 PUSH1 0x00 0208 80 DUP1 0209 FD *REVERT // Stack delta = +0 // Outputs[1] { @0209 revert(memory[0x00:0x00]); } // Block terminates label_020A: // Incoming jump from 0x0205, if !msg.value // Inputs[1] { @0212 msg.data.length } 020A 5B JUMPDEST 020B 50 POP 020C 61 PUSH2 0x021e 020F 61 PUSH2 0x0219 0212 36 CALLDATASIZE 0213 60 PUSH1 0x04 0215 61 PUSH2 0x19cf 0218 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @020C stack[-1] = 0x021e // @020F stack[0] = 0x0219 // @0212 stack[1] = msg.data.length // @0213 stack[2] = 0x04 // } // Block ends with call to 0x19cf, returns to 0x0219 label_0219: // Incoming return from call to 0x19CF at 0x0218 0219 5B JUMPDEST 021A 61 PUSH2 0x0630 021D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0630 label_021E: // Incoming return from call to 0x05A1 at 0x05A0 // Incoming jump from 0x05EF // Incoming return from call to 0x0219 at 0x0218 // Incoming jump from 0x04AF // Inputs[2] // { // @0221 memory[0x40:0x60] // @0222 stack[-1] // } 021E 5B JUMPDEST 021F 60 PUSH1 0x40 0221 51 MLOAD 0222 90 SWAP1 0223 15 ISZERO 0224 15 ISZERO 0225 81 DUP2 0226 52 MSTORE 0227 60 PUSH1 0x20 0229 01 ADD // Stack delta = +0 // Outputs[2] // { // @0226 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0229 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_022A: // Incoming jump from 0x02C4 // Incoming jump from 0x028C // Incoming return from call to 0x1CE7 at 0x044B // Incoming return from call to 0x1BB5 at 0x0394 // Incoming jump from 0x0229 // Incoming jump from 0x02C4 // Incoming return from call to 0x1E13 at 0x054F // Inputs[3] // { // @022D memory[0x40:0x60] // @022F stack[-1] // @0232 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 022A 5B JUMPDEST 022B 60 PUSH1 0x40 022D 51 MLOAD 022E 80 DUP1 022F 91 SWAP2 0230 03 SUB 0231 90 SWAP1 0232 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0232 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0233: // Incoming jump from 0x01E2, if 0x06fdde03 == stack[-1] // Inputs[1] { @0234 msg.value } 0233 5B JUMPDEST 0234 34 CALLVALUE 0235 80 DUP1 0236 15 ISZERO 0237 61 PUSH2 0x023f 023A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0234 stack[0] = msg.value } // Block ends with conditional jump to 0x023f, if !msg.value label_023B: // Incoming jump from 0x023A, if not !msg.value // Inputs[1] { @023E memory[0x00:0x00] } 023B 60 PUSH1 0x00 023D 80 DUP1 023E FD *REVERT // Stack delta = +0 // Outputs[1] { @023E revert(memory[0x00:0x00]); } // Block terminates label_023F: // Incoming jump from 0x023A, if !msg.value 023F 5B JUMPDEST 0240 50 POP 0241 61 PUSH2 0x0248 0244 61 PUSH2 0x0682 0247 56 *JUMP // Stack delta = +0 // Outputs[1] { @0241 stack[-1] = 0x0248 } // Block ends with call to 0x0682, returns to 0x0248 label_0248: // Incoming return from call to 0x0C73 at 0x0475 // Incoming return from call to 0x0682 at 0x0247 // Incoming return from call to 0x0818 at 0x032C // Inputs[2] // { // @024B memory[0x40:0x60] // @024F stack[-1] // } 0248 5B JUMPDEST 0249 60 PUSH1 0x40 024B 51 MLOAD 024C 61 PUSH2 0x022a 024F 91 SWAP2 0250 90 SWAP1 0251 61 PUSH2 0x1a3c 0254 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @024F stack[-1] = 0x022a // @0250 stack[1] = memory[0x40:0x60] // @0250 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1a3c label_0255: // Incoming jump from 0x01ED, if 0x081812fc == stack[-1] // Inputs[1] { @0256 msg.value } 0255 5B JUMPDEST 0256 34 CALLVALUE 0257 80 DUP1 0258 15 ISZERO 0259 61 PUSH2 0x0261 025C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0256 stack[0] = msg.value } // Block ends with conditional jump to 0x0261, if !msg.value label_025D: // Incoming jump from 0x025C, if not !msg.value // Inputs[1] { @0260 memory[0x00:0x00] } 025D 60 PUSH1 0x00 025F 80 DUP1 0260 FD *REVERT // Stack delta = +0 // Outputs[1] { @0260 revert(memory[0x00:0x00]); } // Block terminates label_0261: // Incoming jump from 0x025C, if !msg.value // Inputs[1] { @0269 msg.data.length } 0261 5B JUMPDEST 0262 50 POP 0263 61 PUSH2 0x0275 0266 61 PUSH2 0x0270 0269 36 CALLDATASIZE 026A 60 PUSH1 0x04 026C 61 PUSH2 0x1a4f 026F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0263 stack[-1] = 0x0275 // @0266 stack[0] = 0x0270 // @0269 stack[1] = msg.data.length // @026A stack[2] = 0x04 // } // Block ends with call to 0x1a4f, returns to 0x0270 label_0270: // Incoming return from call to 0x1A4F at 0x026F 0270 5B JUMPDEST 0271 61 PUSH2 0x0714 0274 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0714 label_0275: // Incoming jump from 0x04EF // Incoming return from call to 0x0C5A at 0x0460 // Incoming return from call to 0x0270 at 0x026F // Incoming return from call to 0x03C5 at 0x03C4 // Incoming jump from 0x02F7 // Inputs[2] // { // @0278 memory[0x40:0x60] // @0282 stack[-1] // } 0275 5B JUMPDEST 0276 60 PUSH1 0x40 0278 51 MLOAD 0279 60 PUSH1 0x01 027B 60 PUSH1 0x01 027D 60 PUSH1 0xa0 027F 1B SHL 0280 03 SUB 0281 90 SWAP1 0282 91 SWAP2 0283 16 AND 0284 81 DUP2 0285 52 MSTORE 0286 60 PUSH1 0x20 0288 01 ADD 0289 61 PUSH2 0x022a 028C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0285 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0288 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x022a label_028D: // Incoming jump from 0x01F8, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0294 msg.data.length } 028D 5B JUMPDEST 028E 61 PUSH2 0x02a0 0291 61 PUSH2 0x029b 0294 36 CALLDATASIZE 0295 60 PUSH1 0x04 0297 61 PUSH2 0x1a84 029A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @028E stack[0] = 0x02a0 // @0291 stack[1] = 0x029b // @0294 stack[2] = msg.data.length // @0295 stack[3] = 0x04 // } // Block ends with call to 0x1a84, returns to 0x029B label_029B: // Incoming return from call to 0x1A84 at 0x029A 029B 5B JUMPDEST 029C 61 PUSH2 0x0758 029F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0758 label_02A0: // Incoming return from call to 0x0313 at 0x0312 // Incoming return from call to 0x062B at 0x062A // Incoming return from call to 0x051E at 0x051D // Incoming return from call to 0x029B at 0x029A // Incoming return from call to 0x04CB at 0x04CA // Incoming return from call to 0x08A6 at 0x0334 // Incoming return from call to 0x0A26 at 0x03A9 02A0 5B JUMPDEST 02A1 00 *STOP // Stack delta = +0 // Outputs[1] { @02A1 stop(); } // Block terminates label_02A2: // Incoming jump from 0x01A6, if 0x18160ddd == stack[-1] // Inputs[1] { @02A3 msg.value } 02A2 5B JUMPDEST 02A3 34 CALLVALUE 02A4 80 DUP1 02A5 15 ISZERO 02A6 61 PUSH2 0x02ae 02A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ae, if !msg.value label_02AA: // Incoming jump from 0x02A9, if not !msg.value // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming jump from 0x02A9, if !msg.value // Inputs[3] // { // @02B2 storage[0x01] // @02B5 storage[0x00] // @02BA memory[0x40:0x60] // } 02AE 5B JUMPDEST 02AF 50 POP 02B0 60 PUSH1 0x01 02B2 54 SLOAD 02B3 60 PUSH1 0x00 02B5 54 SLOAD 02B6 03 SUB 02B7 5B JUMPDEST 02B8 60 PUSH1 0x40 02BA 51 MLOAD 02BB 90 SWAP1 02BC 81 DUP2 02BD 52 MSTORE 02BE 60 PUSH1 0x20 02C0 01 ADD 02C1 61 PUSH2 0x022a 02C4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x00] - storage[0x01] // @02C0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x022a label_02C5: // Incoming jump from 0x01B1, if 0x23b872dd == stack[-1] // Inputs[1] { @02CC msg.data.length } 02C5 5B JUMPDEST 02C6 61 PUSH2 0x02a0 02C9 61 PUSH2 0x02d3 02CC 36 CALLDATASIZE 02CD 60 PUSH1 0x04 02CF 61 PUSH2 0x1aae 02D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C6 stack[0] = 0x02a0 // @02C9 stack[1] = 0x02d3 // @02CC stack[2] = msg.data.length // @02CD stack[3] = 0x04 // } // Block ends with call to 0x1aae, returns to 0x02D3 label_02D3: // Incoming return from call to 0x1AAE at 0x02D2 02D3 5B JUMPDEST 02D4 61 PUSH2 0x0771 02D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0771 label_02D8: // Incoming jump from 0x01BC, if 0x2775676c == stack[-1] // Inputs[1] { @02D9 msg.value } 02D8 5B JUMPDEST 02D9 34 CALLVALUE 02DA 80 DUP1 02DB 15 ISZERO 02DC 61 PUSH2 0x02e4 02DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02D9 stack[0] = msg.value } // Block ends with conditional jump to 0x02e4, if !msg.value label_02E0: // Incoming jump from 0x02DF, if not !msg.value // Inputs[1] { @02E3 memory[0x00:0x00] } 02E0 60 PUSH1 0x00 02E2 80 DUP1 02E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E3 revert(memory[0x00:0x00]); } // Block terminates label_02E4: // Incoming jump from 0x02DF, if !msg.value // Inputs[1] { @02E8 storage[0x0a] } 02E4 5B JUMPDEST 02E5 50 POP 02E6 60 PUSH1 0x0a 02E8 54 SLOAD 02E9 61 PUSH2 0x0275 02EC 90 SWAP1 02ED 60 PUSH1 0x01 02EF 60 PUSH1 0x01 02F1 60 PUSH1 0xa0 02F3 1B SHL 02F4 03 SUB 02F5 16 AND 02F6 81 DUP2 02F7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02EC stack[-1] = 0x0275 // @02F5 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0a] // } // Block ends with unconditional jump to 0x0275 label_02F8: // Incoming jump from 0x01C7, if 0x2f40823b == stack[-1] // Inputs[1] { @02F9 msg.value } 02F8 5B JUMPDEST 02F9 34 CALLVALUE 02FA 80 DUP1 02FB 15 ISZERO 02FC 61 PUSH2 0x0304 02FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0304, if !msg.value label_0300: // Incoming jump from 0x02FF, if not !msg.value // Inputs[1] { @0303 memory[0x00:0x00] } 0300 60 PUSH1 0x00 0302 80 DUP1 0303 FD *REVERT // Stack delta = +0 // Outputs[1] { @0303 revert(memory[0x00:0x00]); } // Block terminates label_0304: // Incoming jump from 0x02FF, if !msg.value // Inputs[1] { @030C msg.data.length } 0304 5B JUMPDEST 0305 50 POP 0306 61 PUSH2 0x02a0 0309 61 PUSH2 0x0313 030C 36 CALLDATASIZE 030D 60 PUSH1 0x04 030F 61 PUSH2 0x1b36 0312 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0306 stack[-1] = 0x02a0 // @0309 stack[0] = 0x0313 // @030C stack[1] = msg.data.length // @030D stack[2] = 0x04 // } // Block ends with call to 0x1b36, returns to 0x0313 label_0313: // Incoming return from call to 0x1B36 at 0x0312 0313 5B JUMPDEST 0314 61 PUSH2 0x079c 0317 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x079c label_0318: // Incoming jump from 0x016A, if 0x3232deeb == stack[-1] // Inputs[1] { @0319 msg.value } 0318 5B JUMPDEST 0319 34 CALLVALUE 031A 80 DUP1 031B 15 ISZERO 031C 61 PUSH2 0x0324 031F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0319 stack[0] = msg.value } // Block ends with conditional jump to 0x0324, if !msg.value label_0320: // Incoming jump from 0x031F, if not !msg.value // Inputs[1] { @0323 memory[0x00:0x00] } 0320 60 PUSH1 0x00 0322 80 DUP1 0323 FD *REVERT // Stack delta = +0 // Outputs[1] { @0323 revert(memory[0x00:0x00]); } // Block terminates label_0324: // Incoming jump from 0x031F, if !msg.value 0324 5B JUMPDEST 0325 50 POP 0326 61 PUSH2 0x0248 0329 61 PUSH2 0x0818 032C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0326 stack[-1] = 0x0248 } // Block ends with call to 0x0818, returns to 0x0248 label_032D: // Incoming jump from 0x0175, if 0x33958a18 == stack[-1] 032D 5B JUMPDEST 032E 61 PUSH2 0x02a0 0331 61 PUSH2 0x08a6 0334 56 *JUMP // Stack delta = +1 // Outputs[1] { @032E stack[0] = 0x02a0 } // Block ends with call to 0x08a6, returns to 0x02A0 label_0335: // Incoming jump from 0x0180, if 0x42842e0e == stack[-1] // Inputs[1] { @033C msg.data.length } 0335 5B JUMPDEST 0336 61 PUSH2 0x02a0 0339 61 PUSH2 0x0343 033C 36 CALLDATASIZE 033D 60 PUSH1 0x04 033F 61 PUSH2 0x1aae 0342 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0336 stack[0] = 0x02a0 // @0339 stack[1] = 0x0343 // @033C stack[2] = msg.data.length // @033D stack[3] = 0x04 // } // Block ends with call to 0x1aae, returns to 0x0343 label_0343: // Incoming return from call to 0x1AAE at 0x0342 0343 5B JUMPDEST 0344 61 PUSH2 0x0906 0347 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0906 label_0348: // Incoming jump from 0x018B, if 0x4d2a1eb8 == stack[-1] // Inputs[1] { @0349 msg.value } 0348 5B JUMPDEST 0349 34 CALLVALUE 034A 80 DUP1 034B 15 ISZERO 034C 61 PUSH2 0x0354 034F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0349 stack[0] = msg.value } // Block ends with conditional jump to 0x0354, if !msg.value label_0350: // Incoming jump from 0x034F, if not !msg.value // Inputs[1] { @0353 memory[0x00:0x00] } 0350 60 PUSH1 0x00 0352 80 DUP1 0353 FD *REVERT // Stack delta = +0 // Outputs[1] { @0353 revert(memory[0x00:0x00]); } // Block terminates label_0354: // Incoming jump from 0x034F, if !msg.value // Inputs[1] { @035C msg.data.length } 0354 5B JUMPDEST 0355 50 POP 0356 61 PUSH2 0x02a0 0359 61 PUSH2 0x0363 035C 36 CALLDATASIZE 035D 60 PUSH1 0x04 035F 61 PUSH2 0x1a4f 0362 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0356 stack[-1] = 0x02a0 // @0359 stack[0] = 0x0363 // @035C stack[1] = msg.data.length // @035D stack[2] = 0x04 // } // Block ends with call to 0x1a4f, returns to 0x0363 label_0363: // Incoming return from call to 0x1A4F at 0x0362 0363 5B JUMPDEST 0364 61 PUSH2 0x092b 0367 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x092b label_0368: // Incoming jump from 0x012E, if 0x5bbb2177 == stack[-1] // Inputs[1] { @0369 msg.value } 0368 5B JUMPDEST 0369 34 CALLVALUE 036A 80 DUP1 036B 15 ISZERO 036C 61 PUSH2 0x0374 036F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0369 stack[0] = msg.value } // Block ends with conditional jump to 0x0374, if !msg.value label_0370: // Incoming jump from 0x036F, if not !msg.value // Inputs[1] { @0373 memory[0x00:0x00] } 0370 60 PUSH1 0x00 0372 80 DUP1 0373 FD *REVERT // Stack delta = +0 // Outputs[1] { @0373 revert(memory[0x00:0x00]); } // Block terminates label_0374: // Incoming jump from 0x036F, if !msg.value // Inputs[1] { @037C msg.data.length } 0374 5B JUMPDEST 0375 50 POP 0376 61 PUSH2 0x0388 0379 61 PUSH2 0x0383 037C 36 CALLDATASIZE 037D 60 PUSH1 0x04 037F 61 PUSH2 0x1b36 0382 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0376 stack[-1] = 0x0388 // @0379 stack[0] = 0x0383 // @037C stack[1] = msg.data.length // @037D stack[2] = 0x04 // } // Block ends with call to 0x1b36, returns to 0x0383 label_0383: // Incoming return from call to 0x1B36 at 0x0382 0383 5B JUMPDEST 0384 61 PUSH2 0x095a 0387 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x095a label_0388: // Incoming return from call to 0x0383 at 0x0382 // Inputs[2] // { // @038B memory[0x40:0x60] // @038F stack[-1] // } 0388 5B JUMPDEST 0389 60 PUSH1 0x40 038B 51 MLOAD 038C 61 PUSH2 0x022a 038F 91 SWAP2 0390 90 SWAP1 0391 61 PUSH2 0x1bb5 0394 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @038F stack[-1] = 0x022a // @0390 stack[1] = memory[0x40:0x60] // @0390 stack[0] = stack[-1] // } // Block ends with call to 0x1bb5, returns to 0x022A label_0395: // Incoming jump from 0x0139, if 0x5ef9432a == stack[-1] // Inputs[1] { @0396 msg.value } 0395 5B JUMPDEST 0396 34 CALLVALUE 0397 80 DUP1 0398 15 ISZERO 0399 61 PUSH2 0x03a1 039C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0396 stack[0] = msg.value } // Block ends with conditional jump to 0x03a1, if !msg.value label_039D: // Incoming jump from 0x039C, if not !msg.value // Inputs[1] { @03A0 memory[0x00:0x00] } 039D 60 PUSH1 0x00 039F 80 DUP1 03A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A0 revert(memory[0x00:0x00]); } // Block terminates label_03A1: // Incoming jump from 0x039C, if !msg.value 03A1 5B JUMPDEST 03A2 50 POP 03A3 61 PUSH2 0x02a0 03A6 61 PUSH2 0x0a26 03A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A3 stack[-1] = 0x02a0 } // Block ends with call to 0x0a26, returns to 0x02A0 label_03AA: // Incoming jump from 0x0144, if 0x6352211e == stack[-1] // Inputs[1] { @03AB msg.value } 03AA 5B JUMPDEST 03AB 34 CALLVALUE 03AC 80 DUP1 03AD 15 ISZERO 03AE 61 PUSH2 0x03b6 03B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AB stack[0] = msg.value } // Block ends with conditional jump to 0x03b6, if !msg.value label_03B2: // Incoming jump from 0x03B1, if not !msg.value // Inputs[1] { @03B5 memory[0x00:0x00] } 03B2 60 PUSH1 0x00 03B4 80 DUP1 03B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B5 revert(memory[0x00:0x00]); } // Block terminates label_03B6: // Incoming jump from 0x03B1, if !msg.value // Inputs[1] { @03BE msg.data.length } 03B6 5B JUMPDEST 03B7 50 POP 03B8 61 PUSH2 0x0275 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x1a4f 03C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B8 stack[-1] = 0x0275 // @03BB stack[0] = 0x03c5 // @03BE stack[1] = msg.data.length // @03BF stack[2] = 0x04 // } // Block ends with call to 0x1a4f, returns to 0x03C5 label_03C5: // Incoming return from call to 0x1A4F at 0x03C4 03C5 5B JUMPDEST 03C6 61 PUSH2 0x0acb 03C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0acb label_03CA: // Incoming jump from 0x014F, if 0x6e63b104 == stack[-1] // Inputs[1] { @03CB msg.value } 03CA 5B JUMPDEST 03CB 34 CALLVALUE 03CC 80 DUP1 03CD 15 ISZERO 03CE 61 PUSH2 0x03d6 03D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CB stack[0] = msg.value } // Block ends with conditional jump to 0x03d6, if !msg.value label_03D2: // Incoming jump from 0x03D1, if not !msg.value // Inputs[1] { @03D5 memory[0x00:0x00] } 03D2 60 PUSH1 0x00 03D4 80 DUP1 03D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D5 revert(memory[0x00:0x00]); } // Block terminates label_03D6: // Incoming jump from 0x03D1, if !msg.value // Inputs[1] { @03DE msg.data.length } 03D6 5B JUMPDEST 03D7 50 POP 03D8 61 PUSH2 0x02a0 03DB 61 PUSH2 0x03e5 03DE 36 CALLDATASIZE 03DF 60 PUSH1 0x04 03E1 61 PUSH2 0x1c83 03E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D8 stack[-1] = 0x02a0 // @03DB stack[0] = 0x03e5 // @03DE stack[1] = msg.data.length // @03DF stack[2] = 0x04 // } // Block ends with call to 0x1c83, returns to 0x03E5 label_03E5: // Incoming return from call to 0x1C83 at 0x03E4 03E5 5B JUMPDEST 03E6 61 PUSH2 0x0ad6 03E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ad6 label_03EA: // Incoming jump from 0x015A, if 0x70a08231 == stack[-1] // Inputs[1] { @03EB msg.value } 03EA 5B JUMPDEST 03EB 34 CALLVALUE 03EC 80 DUP1 03ED 15 ISZERO 03EE 61 PUSH2 0x03f6 03F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03EB stack[0] = msg.value } // Block ends with conditional jump to 0x03f6, if !msg.value label_03F2: // Incoming jump from 0x03F1, if not !msg.value // Inputs[1] { @03F5 memory[0x00:0x00] } 03F2 60 PUSH1 0x00 03F4 80 DUP1 03F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F5 revert(memory[0x00:0x00]); } // Block terminates label_03F6: // Incoming jump from 0x03F1, if !msg.value // Inputs[1] { @03FE msg.data.length } 03F6 5B JUMPDEST 03F7 50 POP 03F8 61 PUSH2 0x02b7 03FB 61 PUSH2 0x0405 03FE 36 CALLDATASIZE 03FF 60 PUSH1 0x04 0401 61 PUSH2 0x1ccc 0404 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F8 stack[-1] = 0x02b7 // @03FB stack[0] = 0x0405 // @03FE stack[1] = msg.data.length // @03FF stack[2] = 0x04 // } // Block ends with call to 0x1ccc, returns to 0x0405 label_0405: // Incoming return from call to 0x1CCC at 0x0404 0405 5B JUMPDEST 0406 61 PUSH2 0x0aee 0409 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aee label_040A: // Incoming jump from 0x00E7, if 0x715018a6 == stack[-1] // Inputs[1] { @040B msg.value } 040A 5B JUMPDEST 040B 34 CALLVALUE 040C 80 DUP1 040D 15 ISZERO 040E 61 PUSH2 0x0416 0411 57 *JUMPI // Stack delta = +1 // Outputs[1] { @040B stack[0] = msg.value } // Block ends with conditional jump to 0x0416, if !msg.value label_0412: // Incoming jump from 0x0411, if not !msg.value // Inputs[1] { @0415 memory[0x00:0x00] } 0412 60 PUSH1 0x00 0414 80 DUP1 0415 FD *REVERT // Stack delta = +0 // Outputs[1] { @0415 revert(memory[0x00:0x00]); } // Block terminates label_0416: // Incoming jump from 0x0411, if !msg.value 0416 5B JUMPDEST 0417 50 POP 0418 61 PUSH2 0x02a0 041B 61 PUSH2 0x0b3d 041E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0418 stack[-1] = 0x02a0 } // Block ends with unconditional jump to 0x0b3d label_041F: // Incoming jump from 0x00F2, if 0x8462151c == stack[-1] // Inputs[1] { @0420 msg.value } 041F 5B JUMPDEST 0420 34 CALLVALUE 0421 80 DUP1 0422 15 ISZERO 0423 61 PUSH2 0x042b 0426 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0420 stack[0] = msg.value } // Block ends with conditional jump to 0x042b, if !msg.value label_0427: // Incoming jump from 0x0426, if not !msg.value // Inputs[1] { @042A memory[0x00:0x00] } 0427 60 PUSH1 0x00 0429 80 DUP1 042A FD *REVERT // Stack delta = +0 // Outputs[1] { @042A revert(memory[0x00:0x00]); } // Block terminates label_042B: // Incoming jump from 0x0426, if !msg.value // Inputs[1] { @0433 msg.data.length } 042B 5B JUMPDEST 042C 50 POP 042D 61 PUSH2 0x043f 0430 61 PUSH2 0x043a 0433 36 CALLDATASIZE 0434 60 PUSH1 0x04 0436 61 PUSH2 0x1ccc 0439 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042D stack[-1] = 0x043f // @0430 stack[0] = 0x043a // @0433 stack[1] = msg.data.length // @0434 stack[2] = 0x04 // } // Block ends with call to 0x1ccc, returns to 0x043A label_043A: // Incoming return from call to 0x1CCC at 0x0439 043A 5B JUMPDEST 043B 61 PUSH2 0x0b51 043E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b51 label_043F: // Incoming return from call to 0x043A at 0x0439 // Incoming return from call to 0x0491 at 0x0490 // Inputs[2] // { // @0442 memory[0x40:0x60] // @0446 stack[-1] // } 043F 5B JUMPDEST 0440 60 PUSH1 0x40 0442 51 MLOAD 0443 61 PUSH2 0x022a 0446 91 SWAP2 0447 90 SWAP1 0448 61 PUSH2 0x1ce7 044B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0446 stack[-1] = 0x022a // @0447 stack[1] = memory[0x40:0x60] // @0447 stack[0] = stack[-1] // } // Block ends with call to 0x1ce7, returns to 0x022A label_044C: // Incoming jump from 0x00FD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @044D msg.value } 044C 5B JUMPDEST 044D 34 CALLVALUE 044E 80 DUP1 044F 15 ISZERO 0450 61 PUSH2 0x0458 0453 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044D stack[0] = msg.value } // Block ends with conditional jump to 0x0458, if !msg.value label_0454: // Incoming jump from 0x0453, if not !msg.value // Inputs[1] { @0457 memory[0x00:0x00] } 0454 60 PUSH1 0x00 0456 80 DUP1 0457 FD *REVERT // Stack delta = +0 // Outputs[1] { @0457 revert(memory[0x00:0x00]); } // Block terminates label_0458: // Incoming jump from 0x0453, if !msg.value 0458 5B JUMPDEST 0459 50 POP 045A 61 PUSH2 0x0275 045D 61 PUSH2 0x0c5a 0460 56 *JUMP // Stack delta = +0 // Outputs[1] { @045A stack[-1] = 0x0275 } // Block ends with call to 0x0c5a, returns to 0x0275 label_0461: // Incoming jump from 0x0108, if 0x95d89b41 == stack[-1] // Inputs[1] { @0462 msg.value } 0461 5B JUMPDEST 0462 34 CALLVALUE 0463 80 DUP1 0464 15 ISZERO 0465 61 PUSH2 0x046d 0468 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0462 stack[0] = msg.value } // Block ends with conditional jump to 0x046d, if !msg.value label_0469: // Incoming jump from 0x0468, if not !msg.value // Inputs[1] { @046C memory[0x00:0x00] } 0469 60 PUSH1 0x00 046B 80 DUP1 046C FD *REVERT // Stack delta = +0 // Outputs[1] { @046C revert(memory[0x00:0x00]); } // Block terminates label_046D: // Incoming jump from 0x0468, if !msg.value 046D 5B JUMPDEST 046E 50 POP 046F 61 PUSH2 0x0248 0472 61 PUSH2 0x0c73 0475 56 *JUMP // Stack delta = +0 // Outputs[1] { @046F stack[-1] = 0x0248 } // Block ends with call to 0x0c73, returns to 0x0248 label_0476: // Incoming jump from 0x00B6, if 0x99a2557a == stack[-1] // Inputs[1] { @0477 msg.value } 0476 5B JUMPDEST 0477 34 CALLVALUE 0478 80 DUP1 0479 15 ISZERO 047A 61 PUSH2 0x0482 047D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0477 stack[0] = msg.value } // Block ends with conditional jump to 0x0482, if !msg.value label_047E: // Incoming jump from 0x047D, if not !msg.value // Inputs[1] { @0481 memory[0x00:0x00] } 047E 60 PUSH1 0x00 0480 80 DUP1 0481 FD *REVERT // Stack delta = +0 // Outputs[1] { @0481 revert(memory[0x00:0x00]); } // Block terminates label_0482: // Incoming jump from 0x047D, if !msg.value // Inputs[1] { @048A msg.data.length } 0482 5B JUMPDEST 0483 50 POP 0484 61 PUSH2 0x043f 0487 61 PUSH2 0x0491 048A 36 CALLDATASIZE 048B 60 PUSH1 0x04 048D 61 PUSH2 0x1d1f 0490 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0484 stack[-1] = 0x043f // @0487 stack[0] = 0x0491 // @048A stack[1] = msg.data.length // @048B stack[2] = 0x04 // } // Block ends with call to 0x1d1f, returns to 0x0491 label_0491: // Incoming return from call to 0x1D1F at 0x0490 0491 5B JUMPDEST 0492 61 PUSH2 0x0c82 0495 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c82 label_0496: // Incoming jump from 0x00C1, if 0xa01ffdff == stack[-1] // Inputs[1] { @0497 msg.value } 0496 5B JUMPDEST 0497 34 CALLVALUE 0498 80 DUP1 0499 15 ISZERO 049A 61 PUSH2 0x04a2 049D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0497 stack[0] = msg.value } // Block ends with conditional jump to 0x04a2, if !msg.value label_049E: // Incoming jump from 0x049D, if not !msg.value // Inputs[1] { @04A1 memory[0x00:0x00] } 049E 60 PUSH1 0x00 04A0 80 DUP1 04A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A1 revert(memory[0x00:0x00]); } // Block terminates label_04A2: // Incoming jump from 0x049D, if !msg.value // Inputs[1] { @04A6 storage[0x0d] } 04A2 5B JUMPDEST 04A3 50 POP 04A4 60 PUSH1 0x0d 04A6 54 SLOAD 04A7 61 PUSH2 0x021e 04AA 90 SWAP1 04AB 60 PUSH1 0xff 04AD 16 AND 04AE 81 DUP2 04AF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04AA stack[-1] = 0x021e // @04AD stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x021e label_04B0: // Incoming jump from 0x00CC, if 0xa22cb465 == stack[-1] // Inputs[1] { @04B1 msg.value } 04B0 5B JUMPDEST 04B1 34 CALLVALUE 04B2 80 DUP1 04B3 15 ISZERO 04B4 61 PUSH2 0x04bc 04B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B1 stack[0] = msg.value } // Block ends with conditional jump to 0x04bc, if !msg.value label_04B8: // Incoming jump from 0x04B7, if not !msg.value // Inputs[1] { @04BB memory[0x00:0x00] } 04B8 60 PUSH1 0x00 04BA 80 DUP1 04BB FD *REVERT // Stack delta = +0 // Outputs[1] { @04BB revert(memory[0x00:0x00]); } // Block terminates label_04BC: // Incoming jump from 0x04B7, if !msg.value // Inputs[1] { @04C4 msg.data.length } 04BC 5B JUMPDEST 04BD 50 POP 04BE 61 PUSH2 0x02a0 04C1 61 PUSH2 0x04cb 04C4 36 CALLDATASIZE 04C5 60 PUSH1 0x04 04C7 61 PUSH2 0x1d60 04CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04BE stack[-1] = 0x02a0 // @04C1 stack[0] = 0x04cb // @04C4 stack[1] = msg.data.length // @04C5 stack[2] = 0x04 // } // Block ends with call to 0x1d60, returns to 0x04CB label_04CB: // Incoming return from call to 0x1D60 at 0x04CA 04CB 5B JUMPDEST 04CC 61 PUSH2 0x0dfc 04CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dfc label_04D0: // Incoming jump from 0x00D7, if 0xb0ccc31e == stack[-1] // Inputs[1] { @04D1 msg.value } 04D0 5B JUMPDEST 04D1 34 CALLVALUE 04D2 80 DUP1 04D3 15 ISZERO 04D4 61 PUSH2 0x04dc 04D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D1 stack[0] = msg.value } // Block ends with conditional jump to 0x04dc, if !msg.value label_04D8: // Incoming jump from 0x04D7, if not !msg.value // Inputs[1] { @04DB memory[0x00:0x00] } 04D8 60 PUSH1 0x00 04DA 80 DUP1 04DB FD *REVERT // Stack delta = +0 // Outputs[1] { @04DB revert(memory[0x00:0x00]); } // Block terminates label_04DC: // Incoming jump from 0x04D7, if !msg.value // Inputs[1] { @04E0 storage[0x09] } 04DC 5B JUMPDEST 04DD 50 POP 04DE 60 PUSH1 0x09 04E0 54 SLOAD 04E1 61 PUSH2 0x0275 04E4 90 SWAP1 04E5 60 PUSH1 0x01 04E7 60 PUSH1 0x01 04E9 60 PUSH1 0xa0 04EB 1B SHL 04EC 03 SUB 04ED 16 AND 04EE 81 DUP2 04EF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04E4 stack[-1] = 0x0275 // @04ED stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x09] // } // Block ends with unconditional jump to 0x0275 label_04F0: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @04F7 msg.data.length } 04F0 5B JUMPDEST 04F1 61 PUSH2 0x02a0 04F4 61 PUSH2 0x04fe 04F7 36 CALLDATASIZE 04F8 60 PUSH1 0x04 04FA 61 PUSH2 0x1d97 04FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04F1 stack[0] = 0x02a0 // @04F4 stack[1] = 0x04fe // @04F7 stack[2] = msg.data.length // @04F8 stack[3] = 0x04 // } // Block ends with call to 0x1d97, returns to 0x04FE label_04FE: // Incoming return from call to 0x1D97 at 0x04FD 04FE 5B JUMPDEST 04FF 61 PUSH2 0x0e10 0502 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e10 label_0503: // Incoming jump from 0x0085, if 0xb8d1e532 == stack[-1] // Inputs[1] { @0504 msg.value } 0503 5B JUMPDEST 0504 34 CALLVALUE 0505 80 DUP1 0506 15 ISZERO 0507 61 PUSH2 0x050f 050A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0504 stack[0] = msg.value } // Block ends with conditional jump to 0x050f, if !msg.value label_050B: // Incoming jump from 0x050A, if not !msg.value // Inputs[1] { @050E memory[0x00:0x00] } 050B 60 PUSH1 0x00 050D 80 DUP1 050E FD *REVERT // Stack delta = +0 // Outputs[1] { @050E revert(memory[0x00:0x00]); } // Block terminates label_050F: // Incoming jump from 0x050A, if !msg.value // Inputs[1] { @0517 msg.data.length } 050F 5B JUMPDEST 0510 50 POP 0511 61 PUSH2 0x02a0 0514 61 PUSH2 0x051e 0517 36 CALLDATASIZE 0518 60 PUSH1 0x04 051A 61 PUSH2 0x1ccc 051D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0511 stack[-1] = 0x02a0 // @0514 stack[0] = 0x051e // @0517 stack[1] = msg.data.length // @0518 stack[2] = 0x04 // } // Block ends with call to 0x1ccc, returns to 0x051E label_051E: // Incoming return from call to 0x1CCC at 0x051D 051E 5B JUMPDEST 051F 61 PUSH2 0x0e3d 0522 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e3d label_0523: // Incoming jump from 0x0090, if 0xc23dc68f == stack[-1] // Inputs[1] { @0524 msg.value } 0523 5B JUMPDEST 0524 34 CALLVALUE 0525 80 DUP1 0526 15 ISZERO 0527 61 PUSH2 0x052f 052A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0524 stack[0] = msg.value } // Block ends with conditional jump to 0x052f, if !msg.value label_052B: // Incoming jump from 0x052A, if not !msg.value // Inputs[1] { @052E memory[0x00:0x00] } 052B 60 PUSH1 0x00 052D 80 DUP1 052E FD *REVERT // Stack delta = +0 // Outputs[1] { @052E revert(memory[0x00:0x00]); } // Block terminates label_052F: // Incoming jump from 0x052A, if !msg.value // Inputs[1] { @0537 msg.data.length } 052F 5B JUMPDEST 0530 50 POP 0531 61 PUSH2 0x0543 0534 61 PUSH2 0x053e 0537 36 CALLDATASIZE 0538 60 PUSH1 0x04 053A 61 PUSH2 0x1a4f 053D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0531 stack[-1] = 0x0543 // @0534 stack[0] = 0x053e // @0537 stack[1] = msg.data.length // @0538 stack[2] = 0x04 // } // Block ends with call to 0x1a4f, returns to 0x053E label_053E: // Incoming return from call to 0x1A4F at 0x053D 053E 5B JUMPDEST 053F 61 PUSH2 0x0ef5 0542 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ef5 label_0543: // Incoming return from call to 0x053E at 0x053D // Incoming return from call to 0x053E at 0x053D // Inputs[2] // { // @0546 memory[0x40:0x60] // @054A stack[-1] // } 0543 5B JUMPDEST 0544 60 PUSH1 0x40 0546 51 MLOAD 0547 61 PUSH2 0x022a 054A 91 SWAP2 054B 90 SWAP1 054C 61 PUSH2 0x1e13 054F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @054A stack[-1] = 0x022a // @054B stack[1] = memory[0x40:0x60] // @054B stack[0] = stack[-1] // } // Block ends with call to 0x1e13, returns to 0x022A label_0550: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0551 msg.value } 0550 5B JUMPDEST 0551 34 CALLVALUE 0552 80 DUP1 0553 15 ISZERO 0554 61 PUSH2 0x055c 0557 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0551 stack[0] = msg.value } // Block ends with conditional jump to 0x055c, if !msg.value label_0558: // Incoming jump from 0x0557, if not !msg.value // Inputs[1] { @055B memory[0x00:0x00] } 0558 60 PUSH1 0x00 055A 80 DUP1 055B FD *REVERT // Stack delta = +0 // Outputs[1] { @055B revert(memory[0x00:0x00]); } // Block terminates label_055C: // Incoming jump from 0x0557, if !msg.value // Inputs[1] { @0564 msg.data.length } 055C 5B JUMPDEST 055D 50 POP 055E 61 PUSH2 0x0248 0561 61 PUSH2 0x056b 0564 36 CALLDATASIZE 0565 60 PUSH1 0x04 0567 61 PUSH2 0x1a4f 056A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055E stack[-1] = 0x0248 // @0561 stack[0] = 0x056b // @0564 stack[1] = msg.data.length // @0565 stack[2] = 0x04 // } // Block ends with call to 0x1a4f, returns to 0x056B label_056B: // Incoming return from call to 0x1A4F at 0x056A 056B 5B JUMPDEST 056C 61 PUSH2 0x0f6d 056F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f6d label_0570: // Incoming jump from 0x003E, if 0xced33bc4 == stack[-1] // Inputs[1] { @0571 msg.value } 0570 5B JUMPDEST 0571 34 CALLVALUE 0572 80 DUP1 0573 15 ISZERO 0574 61 PUSH2 0x057c 0577 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0571 stack[0] = msg.value } // Block ends with conditional jump to 0x057c, if !msg.value label_0578: // Incoming jump from 0x0577, if not !msg.value // Inputs[1] { @057B memory[0x00:0x00] } 0578 60 PUSH1 0x00 057A 80 DUP1 057B FD *REVERT // Stack delta = +0 // Outputs[1] { @057B revert(memory[0x00:0x00]); } // Block terminates label_057C: // Incoming jump from 0x0577, if !msg.value // Inputs[1] { @0583 storage[0x0c] } 057C 5B JUMPDEST 057D 50 POP 057E 61 PUSH2 0x02b7 0581 60 PUSH1 0x0c 0583 54 SLOAD 0584 81 DUP2 0585 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @057E stack[-1] = 0x02b7 // @0583 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x02b7 label_0586: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0587 msg.value } 0586 5B JUMPDEST 0587 34 CALLVALUE 0588 80 DUP1 0589 15 ISZERO 058A 61 PUSH2 0x0592 058D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0587 stack[0] = msg.value } // Block ends with conditional jump to 0x0592, if !msg.value label_058E: // Incoming jump from 0x058D, if not !msg.value // Inputs[1] { @0591 memory[0x00:0x00] } 058E 60 PUSH1 0x00 0590 80 DUP1 0591 FD *REVERT // Stack delta = +0 // Outputs[1] { @0591 revert(memory[0x00:0x00]); } // Block terminates label_0592: // Incoming jump from 0x058D, if !msg.value // Inputs[1] { @059A msg.data.length } 0592 5B JUMPDEST 0593 50 POP 0594 61 PUSH2 0x021e 0597 61 PUSH2 0x05a1 059A 36 CALLDATASIZE 059B 60 PUSH1 0x04 059D 61 PUSH2 0x1e21 05A0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0594 stack[-1] = 0x021e // @0597 stack[0] = 0x05a1 // @059A stack[1] = msg.data.length // @059B stack[2] = 0x04 // } // Block ends with call to 0x1e21, returns to 0x05A1 label_05A1: // Incoming return from call to 0x1E21 at 0x05A0 // Incoming call from 0x1798, returns to 0x1799 // Incoming call from 0x11B6, returns to 0x11B7 // Inputs[6] // { // @05AA stack[-2] // @05BD memory[0x00:0x40] // @05BE stack[-1] // @05C8 memory[0x00:0x40] // @05C9 storage[keccak256(memory[0x00:0x40])] // @05CD stack[-3] // } 05A1 5B JUMPDEST 05A2 60 PUSH1 0x01 05A4 60 PUSH1 0x01 05A6 60 PUSH1 0xa0 05A8 1B SHL 05A9 03 SUB 05AA 91 SWAP2 05AB 82 DUP3 05AC 16 AND 05AD 60 PUSH1 0x00 05AF 90 SWAP1 05B0 81 DUP2 05B1 52 MSTORE 05B2 60 PUSH1 0x07 05B4 60 PUSH1 0x20 05B6 90 SWAP1 05B7 81 DUP2 05B8 52 MSTORE 05B9 60 PUSH1 0x40 05BB 80 DUP1 05BC 83 DUP4 05BD 20 SHA3 05BE 93 SWAP4 05BF 90 SWAP1 05C0 94 SWAP5 05C1 16 AND 05C2 82 DUP3 05C3 52 MSTORE 05C4 91 SWAP2 05C5 90 SWAP1 05C6 91 SWAP2 05C7 52 MSTORE 05C8 20 SHA3 05C9 54 SLOAD 05CA 60 PUSH1 0xff 05CC 16 AND 05CD 90 SWAP1 05CE 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05B1 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05B8 memory[0x20:0x40] = 0x07 // @05C3 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @05C7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05CD stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05CF: // Incoming jump from 0x0054, if 0xecba222a == stack[-1] // Inputs[1] { @05D0 msg.value } 05CF 5B JUMPDEST 05D0 34 CALLVALUE 05D1 80 DUP1 05D2 15 ISZERO 05D3 61 PUSH2 0x05db 05D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D0 stack[0] = msg.value } // Block ends with conditional jump to 0x05db, if !msg.value label_05D7: // Incoming jump from 0x05D6, if not !msg.value // Inputs[1] { @05DA memory[0x00:0x00] } 05D7 60 PUSH1 0x00 05D9 80 DUP1 05DA FD *REVERT // Stack delta = +0 // Outputs[1] { @05DA revert(memory[0x00:0x00]); } // Block terminates label_05DB: // Incoming jump from 0x05D6, if !msg.value // Inputs[1] { @05DF storage[0x09] } 05DB 5B JUMPDEST 05DC 50 POP 05DD 60 PUSH1 0x09 05DF 54 SLOAD 05E0 61 PUSH2 0x021e 05E3 90 SWAP1 05E4 60 PUSH1 0x01 05E6 60 PUSH1 0xa0 05E8 1B SHL 05E9 90 SWAP1 05EA 04 DIV 05EB 60 PUSH1 0xff 05ED 16 AND 05EE 81 DUP2 05EF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05E3 stack[-1] = 0x021e // @05ED stack[0] = 0xff & storage[0x09] / (0x01 << 0xa0) // } // Block ends with unconditional jump to 0x021e label_05F0: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @05F1 msg.value } 05F0 5B JUMPDEST 05F1 34 CALLVALUE 05F2 80 DUP1 05F3 15 ISZERO 05F4 61 PUSH2 0x05fc 05F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F1 stack[0] = msg.value } // Block ends with conditional jump to 0x05fc, if !msg.value label_05F8: // Incoming jump from 0x05F7, if not !msg.value // Inputs[1] { @05FB memory[0x00:0x00] } 05F8 60 PUSH1 0x00 05FA 80 DUP1 05FB FD *REVERT // Stack delta = +0 // Outputs[1] { @05FB revert(memory[0x00:0x00]); } // Block terminates label_05FC: // Incoming jump from 0x05F7, if !msg.value // Inputs[1] { @0604 msg.data.length } 05FC 5B JUMPDEST 05FD 50 POP 05FE 61 PUSH2 0x02a0 0601 61 PUSH2 0x060b 0604 36 CALLDATASIZE 0605 60 PUSH1 0x04 0607 61 PUSH2 0x1ccc 060A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05FE stack[-1] = 0x02a0 // @0601 stack[0] = 0x060b // @0604 stack[1] = msg.data.length // @0605 stack[2] = 0x04 // } // Block ends with call to 0x1ccc, returns to 0x060B label_060B: // Incoming return from call to 0x1CCC at 0x060A 060B 5B JUMPDEST 060C 61 PUSH2 0x0ff0 060F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ff0 label_0610: // Incoming jump from 0x006A, if 0xf746d634 == stack[-1] // Inputs[1] { @0611 msg.value } 0610 5B JUMPDEST 0611 34 CALLVALUE 0612 80 DUP1 0613 15 ISZERO 0614 61 PUSH2 0x061c 0617 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0611 stack[0] = msg.value } // Block ends with conditional jump to 0x061c, if !msg.value label_0618: // Incoming jump from 0x0617, if not !msg.value // Inputs[1] { @061B memory[0x00:0x00] } 0618 60 PUSH1 0x00 061A 80 DUP1 061B FD *REVERT // Stack delta = +0 // Outputs[1] { @061B revert(memory[0x00:0x00]); } // Block terminates label_061C: // Incoming jump from 0x0617, if !msg.value // Inputs[1] { @0624 msg.data.length } 061C 5B JUMPDEST 061D 50 POP 061E 61 PUSH2 0x02a0 0621 61 PUSH2 0x062b 0624 36 CALLDATASIZE 0625 60 PUSH1 0x04 0627 61 PUSH2 0x1d60 062A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @061E stack[-1] = 0x02a0 // @0621 stack[0] = 0x062b // @0624 stack[1] = msg.data.length // @0625 stack[2] = 0x04 // } // Block ends with call to 0x1d60, returns to 0x062B label_062B: // Incoming return from call to 0x1D60 at 0x062A 062B 5B JUMPDEST 062C 61 PUSH2 0x106b 062F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x106b label_0630: // Incoming jump from 0x021D // Inputs[1] { @0644 stack[-1] } 0630 5B JUMPDEST 0631 60 PUSH1 0x00 0633 63 PUSH4 0x01ffc9a7 0638 60 PUSH1 0xe0 063A 1B SHL 063B 60 PUSH1 0x01 063D 60 PUSH1 0x01 063F 60 PUSH1 0xe0 0641 1B SHL 0642 03 SUB 0643 19 NOT 0644 83 DUP4 0645 16 AND 0646 14 EQ 0647 80 DUP1 0648 61 PUSH2 0x0661 064B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0631 stack[0] = 0x00 // @0646 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x0661, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_064C: // Incoming jump from 0x064B, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @065E stack[-3] } 064C 50 POP 064D 63 PUSH4 0x80ac58cd 0652 60 PUSH1 0xe0 0654 1B SHL 0655 60 PUSH1 0x01 0657 60 PUSH1 0x01 0659 60 PUSH1 0xe0 065B 1B SHL 065C 03 SUB 065D 19 NOT 065E 83 DUP4 065F 16 AND 0660 14 EQ 0661 5B JUMPDEST 0662 80 DUP1 0663 61 PUSH2 0x067c 0666 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0660 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x067c, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_0667: // Incoming jump from 0x0666, if not stack[-1] // Incoming jump from 0x0666, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[1] { @0679 stack[-3] } 0667 50 POP 0668 63 PUSH4 0x5b5e139f 066D 60 PUSH1 0xe0 066F 1B SHL 0670 60 PUSH1 0x01 0672 60 PUSH1 0x01 0674 60 PUSH1 0xe0 0676 1B SHL 0677 03 SUB 0678 19 NOT 0679 83 DUP4 067A 16 AND 067B 14 EQ // Stack delta = +0 // Outputs[1] { @067B stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f << 0xe0 } // Block continues label_067C: // Incoming jump from 0x0666, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x067B // Incoming return from call to 0x1B78 at 0x1E20 // Incoming jump from 0x1EAF, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming return from call to 0x1520 at 0x0AD5 // Incoming return from call to 0x16F5 at 0x16F4 // Incoming return from call to 0x1885 at 0x1614 // Incoming jump from 0x10B3, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0666, if stack[-1] // Inputs[3] // { // @067D stack[-1] // @067D stack[-4] // @067E stack[-3] // } 067C 5B JUMPDEST 067D 92 SWAP3 067E 91 SWAP2 067F 50 POP 0680 50 POP 0681 56 *JUMP // Stack delta = -3 // Outputs[1] { @067D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0682: // Incoming call from 0x0247, returns to 0x0248 // Inputs[1] { @0688 storage[0x02] } 0682 5B JUMPDEST 0683 60 PUSH1 0x60 0685 60 PUSH1 0x02 0687 80 DUP1 0688 54 SLOAD 0689 61 PUSH2 0x0691 068C 90 SWAP1 068D 61 PUSH2 0x1e54 0690 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0683 stack[0] = 0x60 // @0685 stack[1] = 0x02 // @068C stack[2] = 0x0691 // @068C stack[3] = storage[0x02] // } // Block ends with call to 0x1e54, returns to 0x0691 label_0691: // Incoming return from call to 0x1E54 at 0x0690 // Incoming return from call to 0x1E54 at 0x0C81 // Incoming return from call to 0x1E54 at 0x1708 // Inputs[4] // { // @0692 stack[-1] // @06A1 memory[0x40:0x60] // @06A9 stack[-2] // @06B4 storage[stack[-2]] // } 0691 5B JUMPDEST 0692 80 DUP1 0693 60 PUSH1 0x1f 0695 01 ADD 0696 60 PUSH1 0x20 0698 80 DUP1 0699 91 SWAP2 069A 04 DIV 069B 02 MUL 069C 60 PUSH1 0x20 069E 01 ADD 069F 60 PUSH1 0x40 06A1 51 MLOAD 06A2 90 SWAP1 06A3 81 DUP2 06A4 01 ADD 06A5 60 PUSH1 0x40 06A7 52 MSTORE 06A8 80 DUP1 06A9 92 SWAP3 06AA 91 SWAP2 06AB 90 SWAP1 06AC 81 DUP2 06AD 81 DUP2 06AE 52 MSTORE 06AF 60 PUSH1 0x20 06B1 01 ADD 06B2 82 DUP3 06B3 80 DUP1 06B4 54 SLOAD 06B5 61 PUSH2 0x06bd 06B8 90 SWAP1 06B9 61 PUSH2 0x1e54 06BC 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06A7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06A9 stack[-2] = memory[0x40:0x60] // @06AA stack[-1] = stack[-2] // @06AB stack[0] = stack[-1] // @06AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06B1 stack[1] = 0x20 + memory[0x40:0x60] // @06B2 stack[2] = stack[-2] // @06B8 stack[4] = storage[stack[-2]] // @06B8 stack[3] = 0x06bd // } // Block ends with call to 0x1e54, returns to 0x06BD label_06BD: // Incoming return from call to 0x1E54 at 0x06BC // Inputs[1] { @06BE stack[-1] } 06BD 5B JUMPDEST 06BE 80 DUP1 06BF 15 ISZERO 06C0 61 PUSH2 0x070a 06C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070a, if !stack[-1] label_06C4: // Incoming jump from 0x06C3, if not !stack[-1] // Inputs[1] { @06C4 stack[-1] } 06C4 80 DUP1 06C5 60 PUSH1 0x1f 06C7 10 LT 06C8 61 PUSH2 0x06df 06CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06df, if 0x1f < stack[-1] label_06CC: // Incoming jump from 0x06CB, if not 0x1f < stack[-1] // Inputs[4] // { // @06D0 stack[-2] // @06D1 storage[stack[-2]] // @06D4 stack[-3] // @06D6 stack[-1] // } 06CC 61 PUSH2 0x0100 06CF 80 DUP1 06D0 83 DUP4 06D1 54 SLOAD 06D2 04 DIV 06D3 02 MUL 06D4 83 DUP4 06D5 52 MSTORE 06D6 91 SWAP2 06D7 60 PUSH1 0x20 06D9 01 ADD 06DA 91 SWAP2 06DB 61 PUSH2 0x070a 06DE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06D5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06DA stack[-1] = stack[-1] // @06DA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x070a label_06DF: // Incoming jump from 0x06CB, if 0x1f < stack[-1] // Inputs[5] // { // @06E0 stack[-3] // @06E1 stack[-1] // @06E3 stack[-2] // @06EB memory[0x00:0x20] // @06EF storage[keccak256(memory[0x00:0x20])] // } 06DF 5B JUMPDEST 06E0 82 DUP3 06E1 01 ADD 06E2 91 SWAP2 06E3 90 SWAP1 06E4 60 PUSH1 0x00 06E6 52 MSTORE 06E7 60 PUSH1 0x20 06E9 60 PUSH1 0x00 06EB 20 SHA3 06EC 90 SWAP1 06ED 5B JUMPDEST 06EE 81 DUP2 06EF 54 SLOAD 06F0 81 DUP2 06F1 52 MSTORE 06F2 90 SWAP1 06F3 60 PUSH1 0x01 06F5 01 ADD 06F6 90 SWAP1 06F7 60 PUSH1 0x20 06F9 01 ADD 06FA 80 DUP1 06FB 83 DUP4 06FC 11 GT 06FD 61 PUSH2 0x06ed 0700 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06E2 stack[-3] = stack[-3] + stack[-1] // @06E6 memory[0x00:0x20] = stack[-2] // @06F1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06F6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06F9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06ed, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0701: // Incoming jump from 0x0700, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0700, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0701 stack[-3] // @0702 stack[-1] // } 0701 82 DUP3 0702 90 SWAP1 0703 03 SUB 0704 60 PUSH1 0x1f 0706 16 AND 0707 82 DUP3 0708 01 ADD 0709 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0709 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0709 stack[-1] = stack[-3] // } // Block continues label_070A: // Incoming jump from 0x06DE // Incoming jump from 0x06C3, if !stack[-1] // Incoming jump from 0x0709 // Inputs[3] // { // @0710 stack[-7] // @0710 stack[-6] // @0712 stack[-8] // } 070A 5B JUMPDEST 070B 50 POP 070C 50 POP 070D 50 POP 070E 50 POP 070F 50 POP 0710 90 SWAP1 0711 50 POP 0712 90 SWAP1 0713 56 *JUMP // Stack delta = -7 // Outputs[1] { @0712 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0714: // Incoming jump from 0x0274 // Inputs[1] { @071A stack[-1] } 0714 5B JUMPDEST 0715 60 PUSH1 0x00 0717 61 PUSH2 0x071f 071A 82 DUP3 071B 61 PUSH2 0x10a7 071E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0715 stack[0] = 0x00 // @0717 stack[1] = 0x071f // @071A stack[2] = stack[-1] // } // Block ends with call to 0x10a7, returns to 0x071F label_071F: // Incoming return from call to 0x10A7 at 0x071E // Inputs[1] { @0723 stack[-1] } 071F 5B JUMPDEST 0720 61 PUSH2 0x073c 0723 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x073c, if stack[-1] label_0724: // Incoming jump from 0x0723, if not stack[-1] // Inputs[3] // { // @0726 memory[0x40:0x60] // @0736 memory[0x40:0x60] // @073B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0724 60 PUSH1 0x40 0726 51 MLOAD 0727 63 PUSH4 0x33d1c039 072C 60 PUSH1 0xe2 072E 1B SHL 072F 81 DUP2 0730 52 MSTORE 0731 60 PUSH1 0x04 0733 01 ADD 0734 60 PUSH1 0x40 0736 51 MLOAD 0737 80 DUP1 0738 91 SWAP2 0739 03 SUB 073A 90 SWAP1 073B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0730 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @073B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_073C: // Incoming jump from 0x0723, if stack[-1] // Inputs[4] // { // @0740 stack[-2] // @074B memory[0x00:0x40] // @074C storage[keccak256(memory[0x00:0x40])] // @0756 stack[-3] // } 073C 5B JUMPDEST 073D 50 POP 073E 60 PUSH1 0x00 0740 90 SWAP1 0741 81 DUP2 0742 52 MSTORE 0743 60 PUSH1 0x06 0745 60 PUSH1 0x20 0747 52 MSTORE 0748 60 PUSH1 0x40 074A 90 SWAP1 074B 20 SHA3 074C 54 SLOAD 074D 60 PUSH1 0x01 074F 60 PUSH1 0x01 0751 60 PUSH1 0xa0 0753 1B SHL 0754 03 SUB 0755 16 AND 0756 90 SWAP1 0757 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0742 memory[0x00:0x20] = stack[-2] // @0747 memory[0x20:0x40] = 0x06 // @0756 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0758: // Incoming jump from 0x029F // Inputs[1] { @0759 stack[-2] } 0758 5B JUMPDEST 0759 81 DUP2 075A 61 PUSH2 0x0762 075D 81 DUP2 075E 61 PUSH2 0x10ce 0761 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0759 stack[0] = stack[-2] // @075A stack[1] = 0x0762 // @075D stack[2] = stack[-2] // } // Block ends with call to 0x10ce, returns to 0x0762 label_0762: // Incoming return from call to 0x10CE at 0x0761 // Inputs[2] // { // @0766 stack[-3] // @0767 stack[-2] // } 0762 5B JUMPDEST 0763 61 PUSH2 0x076c 0766 83 DUP4 0767 83 DUP4 0768 61 PUSH2 0x1190 076B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0763 stack[0] = 0x076c // @0766 stack[1] = stack[-3] // @0767 stack[2] = stack[-2] // } // Block ends with call to 0x1190, returns to 0x076C label_076C: // Incoming return from call to 0x1615 at 0x0E0F // Incoming jump from 0x1EEF, if !(stack[-2] > 0x1f) // Incoming jump from 0x07D5, if !(0x00 < stack[-1]) // Incoming jump from 0x07D5, if !(stack[-1] < stack[-2]) // Incoming return from call to 0x1190 at 0x076B // Inputs[1] { @0770 stack[-4] } 076C 5B JUMPDEST 076D 50 POP 076E 50 POP 076F 50 POP 0770 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0771: // Incoming jump from 0x168B // Incoming jump from 0x02D7 // Inputs[2] // { // @0772 stack[-3] // @077D msg.sender // } 0771 5B JUMPDEST 0772 82 DUP3 0773 60 PUSH1 0x01 0775 60 PUSH1 0x01 0777 60 PUSH1 0xa0 0779 1B SHL 077A 03 SUB 077B 81 DUP2 077C 16 AND 077D 33 CALLER 077E 14 EQ 077F 61 PUSH2 0x078b 0782 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0772 stack[0] = stack[-3] } // Block ends with conditional jump to 0x078b, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0783: // Incoming jump from 0x0782, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0786 msg.sender } 0783 61 PUSH2 0x078b 0786 33 CALLER 0787 61 PUSH2 0x10ce 078A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0783 stack[0] = 0x078b // @0786 stack[1] = msg.sender // } // Block ends with call to 0x10ce, returns to 0x078B label_078B: // Incoming return from call to 0x10CE at 0x078A // Incoming jump from 0x0782, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @078F stack[-4] // @0790 stack[-3] // @0791 stack[-2] // } 078B 5B JUMPDEST 078C 61 PUSH2 0x0796 078F 84 DUP5 0790 84 DUP5 0791 84 DUP5 0792 61 PUSH2 0x1230 0795 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @078C stack[0] = 0x0796 // @078F stack[1] = stack[-4] // @0790 stack[2] = stack[-3] // @0791 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1230 0796 5B JUMPDEST 0797 50 POP 0798 50 POP 0799 50 POP 079A 50 POP 079B 56 *JUMP label_079C: // Incoming jump from 0x0317 079C 5B JUMPDEST 079D 61 PUSH2 0x07a4 07A0 61 PUSH2 0x13c1 07A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @079D stack[0] = 0x07a4 } // Block ends with call to 0x13c1, returns to 0x07A4 label_07A4: // Incoming return from call to 0x13C1 at 0x07A3 // Inputs[4] // { // @07A7 storage[0x0c] // @07A8 stack[-1] // @07AE storage[0x01] // @07B1 storage[0x00] // } 07A4 5B JUMPDEST 07A5 60 PUSH1 0x0c 07A7 54 SLOAD 07A8 81 DUP2 07A9 61 PUSH2 0x07b5 07AC 60 PUSH1 0x01 07AE 54 SLOAD 07AF 60 PUSH1 0x00 07B1 54 SLOAD 07B2 03 SUB 07B3 90 SWAP1 07B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07A7 stack[0] = storage[0x0c] // @07A8 stack[1] = stack[-1] // @07B3 stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x07b5 label_07B5: // Incoming jump from 0x07B4 // Inputs[2] // { // @07B9 stack[-2] // @07BA stack[-1] // } 07B5 5B JUMPDEST 07B6 61 PUSH2 0x07bf 07B9 91 SWAP2 07BA 90 SWAP1 07BB 61 PUSH2 0x1ea4 07BE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07B9 stack[-2] = 0x07bf // @07BA stack[-1] = stack[-2] // @07BA stack[0] = stack[-1] // } // Block ends with call to 0x1ea4, returns to 0x07BF label_07BF: // Incoming return from call to 0x1EA4 at 0x07BE // Inputs[2] // { // @07C0 stack[-2] // @07C0 stack[-1] // } 07BF 5B JUMPDEST 07C0 11 GT 07C1 15 ISZERO 07C2 61 PUSH2 0x07ca 07C5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x07ca, if !(stack[-1] > stack[-2]) label_07C6: // Incoming jump from 0x07C5, if not !(stack[-1] > stack[-2]) // Inputs[1] { @07C9 memory[0x00:0x00] } 07C6 60 PUSH1 0x00 07C8 80 DUP1 07C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C9 revert(memory[0x00:0x00]); } // Block terminates label_07CA: // Incoming jump from 0x07C5, if !(stack[-1] > stack[-2]) // Inputs[1] { @07CE stack[-1] } 07CA 5B JUMPDEST 07CB 60 PUSH1 0x00 07CD 5B JUMPDEST 07CE 81 DUP2 07CF 81 DUP2 07D0 10 LT 07D1 15 ISZERO 07D2 61 PUSH2 0x076c 07D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07CB stack[0] = 0x00 } // Block ends with conditional jump to 0x076c, if !(0x00 < stack[-1]) label_07D6: // Incoming jump from 0x07D5, if not !(0x00 < stack[-1]) // Incoming jump from 0x07D5, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @07D9 stack[-3] // @07DA stack[-2] // @07DB stack[-1] // } 07D6 61 PUSH2 0x0806 07D9 83 DUP4 07DA 83 DUP4 07DB 83 DUP4 07DC 81 DUP2 07DD 81 DUP2 07DE 10 LT 07DF 61 PUSH2 0x07ea 07E2 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @07D6 stack[0] = 0x0806 // @07D9 stack[1] = stack[-3] // @07DA stack[2] = stack[-2] // @07DB stack[3] = stack[-1] // } // Block ends with conditional call to 0x07ea, returns to 0x0806, if stack[-1] < stack[-2] label_07E3: // Incoming jump from 0x07E2, if not stack[-1] < stack[-2] 07E3 61 PUSH2 0x07ea 07E6 61 PUSH2 0x1eb7 07E9 56 *JUMP // Stack delta = +1 // Outputs[1] { @07E3 stack[0] = 0x07ea } // Block ends with unconditional jump to 0x1eb7 label_07EA: // Incoming call from 0x07E2, returns to 0x0806, if stack[-1] < stack[-2] // Inputs[3] // { // @07EB stack[-1] // @07EB stack[-2] // @07F0 stack[-3] // } 07EA 5B JUMPDEST 07EB 90 SWAP1 07EC 50 POP 07ED 60 PUSH1 0x20 07EF 02 MUL 07F0 01 ADD 07F1 60 PUSH1 0x20 07F3 81 DUP2 07F4 01 ADD 07F5 90 SWAP1 07F6 61 PUSH2 0x07ff 07F9 91 SWAP2 07FA 90 SWAP1 07FB 61 PUSH2 0x1ccc 07FE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07F9 stack[-3] = 0x07ff // @07FA stack[-1] = 0x20 * stack[-1] + stack[-3] // @07FA stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x1ccc, returns to 0x07FF label_07FF: // Incoming return from call to 0x1CCC at 0x07FE 07FF 5B JUMPDEST 0800 60 PUSH1 0x01 0802 61 PUSH2 0x1420 0805 56 *JUMP // Stack delta = +1 // Outputs[1] { @0800 stack[0] = 0x01 } // Block ends with unconditional jump to 0x1420 label_0806: // Incoming return from call to 0x07EA at 0x07E2 // Inputs[1] { @0807 stack[-1] } 0806 5B JUMPDEST 0807 80 DUP1 0808 61 PUSH2 0x0810 080B 81 DUP2 080C 61 PUSH2 0x1ecd 080F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0807 stack[0] = stack[-1] // @0808 stack[1] = 0x0810 // @080B stack[2] = stack[-1] // } // Block ends with call to 0x1ecd, returns to 0x0810 label_0810: // Incoming return from call to 0x1ECD at 0x080F // Inputs[2] // { // @0811 stack[-1] // @0811 stack[-3] // } 0810 5B JUMPDEST 0811 91 SWAP2 0812 50 POP 0813 50 POP 0814 61 PUSH2 0x07cd 0817 56 *JUMP // Stack delta = -2 // Outputs[1] { @0811 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x07cd label_0818: // Incoming call from 0x032C, returns to 0x0248 // Inputs[1] { @081C storage[0x0b] } 0818 5B JUMPDEST 0819 60 PUSH1 0x0b 081B 80 DUP1 081C 54 SLOAD 081D 61 PUSH2 0x0825 0820 90 SWAP1 0821 61 PUSH2 0x1e54 0824 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0819 stack[0] = 0x0b // @0820 stack[1] = 0x0825 // @0820 stack[2] = storage[0x0b] // } // Block ends with call to 0x1e54, returns to 0x0825 label_0825: // Incoming return from call to 0x1E54 at 0x0824 // Inputs[4] // { // @0826 stack[-1] // @0835 memory[0x40:0x60] // @083D stack[-2] // @0848 storage[stack[-2]] // } 0825 5B JUMPDEST 0826 80 DUP1 0827 60 PUSH1 0x1f 0829 01 ADD 082A 60 PUSH1 0x20 082C 80 DUP1 082D 91 SWAP2 082E 04 DIV 082F 02 MUL 0830 60 PUSH1 0x20 0832 01 ADD 0833 60 PUSH1 0x40 0835 51 MLOAD 0836 90 SWAP1 0837 81 DUP2 0838 01 ADD 0839 60 PUSH1 0x40 083B 52 MSTORE 083C 80 DUP1 083D 92 SWAP3 083E 91 SWAP2 083F 90 SWAP1 0840 81 DUP2 0841 81 DUP2 0842 52 MSTORE 0843 60 PUSH1 0x20 0845 01 ADD 0846 82 DUP3 0847 80 DUP1 0848 54 SLOAD 0849 61 PUSH2 0x0851 084C 90 SWAP1 084D 61 PUSH2 0x1e54 0850 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @083B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @083D stack[-2] = memory[0x40:0x60] // @083E stack[-1] = stack[-2] // @083F stack[0] = stack[-1] // @0842 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0845 stack[1] = 0x20 + memory[0x40:0x60] // @0846 stack[2] = stack[-2] // @084C stack[4] = storage[stack[-2]] // @084C stack[3] = 0x0851 // } // Block ends with call to 0x1e54, returns to 0x0851 label_0851: // Incoming return from call to 0x1E54 at 0x0850 // Inputs[1] { @0852 stack[-1] } 0851 5B JUMPDEST 0852 80 DUP1 0853 15 ISZERO 0854 61 PUSH2 0x089e 0857 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x089e, if !stack[-1] label_0858: // Incoming jump from 0x0857, if not !stack[-1] // Inputs[1] { @0858 stack[-1] } 0858 80 DUP1 0859 60 PUSH1 0x1f 085B 10 LT 085C 61 PUSH2 0x0873 085F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0873, if 0x1f < stack[-1] label_0860: // Incoming jump from 0x085F, if not 0x1f < stack[-1] // Inputs[4] // { // @0864 stack[-2] // @0865 storage[stack[-2]] // @0868 stack[-3] // @086A stack[-1] // } 0860 61 PUSH2 0x0100 0863 80 DUP1 0864 83 DUP4 0865 54 SLOAD 0866 04 DIV 0867 02 MUL 0868 83 DUP4 0869 52 MSTORE 086A 91 SWAP2 086B 60 PUSH1 0x20 086D 01 ADD 086E 91 SWAP2 086F 61 PUSH2 0x089e 0872 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0869 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @086E stack[-1] = stack[-1] // @086E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x089e label_0873: // Incoming jump from 0x085F, if 0x1f < stack[-1] // Inputs[5] // { // @0874 stack[-3] // @0875 stack[-1] // @0877 stack[-2] // @087F memory[0x00:0x20] // @0883 storage[keccak256(memory[0x00:0x20])] // } 0873 5B JUMPDEST 0874 82 DUP3 0875 01 ADD 0876 91 SWAP2 0877 90 SWAP1 0878 60 PUSH1 0x00 087A 52 MSTORE 087B 60 PUSH1 0x20 087D 60 PUSH1 0x00 087F 20 SHA3 0880 90 SWAP1 0881 5B JUMPDEST 0882 81 DUP2 0883 54 SLOAD 0884 81 DUP2 0885 52 MSTORE 0886 90 SWAP1 0887 60 PUSH1 0x01 0889 01 ADD 088A 90 SWAP1 088B 60 PUSH1 0x20 088D 01 ADD 088E 80 DUP1 088F 83 DUP4 0890 11 GT 0891 61 PUSH2 0x0881 0894 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0876 stack[-3] = stack[-3] + stack[-1] // @087A memory[0x00:0x20] = stack[-2] // @0885 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @088A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @088D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0881, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0895: // Incoming jump from 0x0894, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0894, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0895 stack[-3] // @0896 stack[-1] // } 0895 82 DUP3 0896 90 SWAP1 0897 03 SUB 0898 60 PUSH1 0x1f 089A 16 AND 089B 82 DUP3 089C 01 ADD 089D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @089D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @089D stack[-1] = stack[-3] // } // Block continues label_089E: // Incoming jump from 0x089D // Incoming jump from 0x0872 // Incoming jump from 0x0857, if !stack[-1] // Inputs[1] { @08A4 stack[-7] } 089E 5B JUMPDEST 089F 50 POP 08A0 50 POP 08A1 50 POP 08A2 50 POP 08A3 50 POP 08A4 81 DUP2 08A5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_08A6: // Incoming call from 0x0334, returns to 0x02A0 08A6 5B JUMPDEST 08A7 61 PUSH2 0x08ae 08AA 61 PUSH2 0x13c1 08AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @08A7 stack[0] = 0x08ae } // Block ends with call to 0x13c1, returns to 0x08AE label_08AE: // Incoming return from call to 0x13C1 at 0x08AD // Inputs[8] // { // @08B1 memory[0x40:0x60] // @08B5 msg.sender // @08B7 address(this).balance // @08B7 address(this) // @08BF msg.gas // @08C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @08C0 address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @08C5 returndata.length // } 08AE 5B JUMPDEST 08AF 60 PUSH1 0x40 08B1 51 MLOAD 08B2 60 PUSH1 0x00 08B4 90 SWAP1 08B5 33 CALLER 08B6 90 SWAP1 08B7 47 SELFBALANCE 08B8 90 SWAP1 08B9 83 DUP4 08BA 81 DUP2 08BB 81 DUP2 08BC 81 DUP2 08BD 85 DUP6 08BE 87 DUP8 08BF 5A GAS 08C0 F1 CALL 08C1 92 SWAP3 08C2 50 POP 08C3 50 POP 08C4 50 POP 08C5 3D RETURNDATASIZE 08C6 80 DUP1 08C7 60 PUSH1 0x00 08C9 81 DUP2 08CA 14 EQ 08CB 61 PUSH2 0x08f0 08CE 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @08B4 stack[0] = 0x00 // @08C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @08C1 stack[1] = address(msg.sender).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @08C5 stack[2] = returndata.length // @08C6 stack[3] = returndata.length // } // Block ends with conditional jump to 0x08f0, if returndata.length == 0x00 label_08CF: // Incoming jump from 0x08CE, if not returndata.length == 0x00 // Inputs[6] // { // @08D1 memory[0x40:0x60] // @08D2 stack[-2] // @08D9 returndata.length // @08E1 returndata.length // @08E4 returndata.length // @08EB returndata[0x00:0x00 + returndata.length] // } 08CF 60 PUSH1 0x40 08D1 51 MLOAD 08D2 91 SWAP2 08D3 50 POP 08D4 60 PUSH1 0x1f 08D6 19 NOT 08D7 60 PUSH1 0x3f 08D9 3D RETURNDATASIZE 08DA 01 ADD 08DB 16 AND 08DC 82 DUP3 08DD 01 ADD 08DE 60 PUSH1 0x40 08E0 52 MSTORE 08E1 3D RETURNDATASIZE 08E2 82 DUP3 08E3 52 MSTORE 08E4 3D RETURNDATASIZE 08E5 60 PUSH1 0x00 08E7 60 PUSH1 0x20 08E9 84 DUP5 08EA 01 ADD 08EB 3E RETURNDATACOPY 08EC 61 PUSH2 0x08f5 08EF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @08D2 stack[-2] = memory[0x40:0x60] // @08E0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @08E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @08EB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x08f5 label_08F0: // Incoming jump from 0x08CE, if returndata.length == 0x00 // Inputs[3] // { // @08F3 stack[-2] // @08F8 stack[-4] // @08F8 stack[-3] // } 08F0 5B JUMPDEST 08F1 60 PUSH1 0x60 08F3 91 SWAP2 08F4 50 POP 08F5 5B JUMPDEST 08F6 50 POP 08F7 50 POP 08F8 90 SWAP1 08F9 50 POP 08FA 80 DUP1 08FB 61 PUSH2 0x0903 08FE 57 *JUMPI // Stack delta = -3 // Outputs[1] { @08F8 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0903, if stack[-3] label_08FF: // Incoming jump from 0x08FE, if not stack[-3] // Incoming jump from 0x08FE, if not stack[-3] // Inputs[1] { @0902 memory[0x00:0x00] } 08FF 60 PUSH1 0x00 0901 80 DUP1 0902 FD *REVERT // Stack delta = +0 // Outputs[1] { @0902 revert(memory[0x00:0x00]); } // Block terminates label_0903: // Incoming jump from 0x08FE, if stack[-3] // Incoming jump from 0x1D5B, if stack[-1] == !!stack[-1] // Incoming jump from 0x08FE, if stack[-3] // Incoming jump from 0x19CA, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1587 at 0x106A // Incoming return from call to 0x174D at 0x151F // Inputs[1] { @0905 stack[-2] } 0903 5B JUMPDEST 0904 50 POP 0905 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0906: // Incoming jump from 0x0347 // Inputs[2] // { // @0907 stack[-3] // @0912 msg.sender // } 0906 5B JUMPDEST 0907 82 DUP3 0908 60 PUSH1 0x01 090A 60 PUSH1 0x01 090C 60 PUSH1 0xa0 090E 1B SHL 090F 03 SUB 0910 81 DUP2 0911 16 AND 0912 33 CALLER 0913 14 EQ 0914 61 PUSH2 0x0920 0917 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0907 stack[0] = stack[-3] } // Block ends with conditional jump to 0x0920, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0918: // Incoming jump from 0x0917, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @091B msg.sender } 0918 61 PUSH2 0x0920 091B 33 CALLER 091C 61 PUSH2 0x10ce 091F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0918 stack[0] = 0x0920 // @091B stack[1] = msg.sender // } // Block ends with call to 0x10ce, returns to 0x0920 label_0920: // Incoming return from call to 0x10CE at 0x091F // Incoming jump from 0x0917, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0924 stack[-4] // @0925 stack[-3] // @0926 stack[-2] // } 0920 5B JUMPDEST 0921 61 PUSH2 0x0796 0924 84 DUP5 0925 84 DUP5 0926 84 DUP5 0927 61 PUSH2 0x14fa 092A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0921 stack[0] = 0x0796 // @0924 stack[1] = stack[-4] // @0925 stack[2] = stack[-3] // @0926 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x14fa label_092B: // Incoming jump from 0x0367 // Inputs[1] { @092E storage[0x0d] } 092B 5B JUMPDEST 092C 60 PUSH1 0x0d 092E 54 SLOAD 092F 60 PUSH1 0xff 0931 16 AND 0932 61 PUSH2 0x093a 0935 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x093a, if 0xff & storage[0x0d] label_0936: // Incoming jump from 0x0935, if not 0xff & storage[0x0d] // Inputs[1] { @0939 memory[0x00:0x00] } 0936 60 PUSH1 0x00 0938 80 DUP1 0939 FD *REVERT // Stack delta = +0 // Outputs[1] { @0939 revert(memory[0x00:0x00]); } // Block terminates label_093A: // Incoming jump from 0x0935, if 0xff & storage[0x0d] // Inputs[2] // { // @093D storage[0x0a] // @0947 msg.sender // } 093A 5B JUMPDEST 093B 60 PUSH1 0x0a 093D 54 SLOAD 093E 60 PUSH1 0x01 0940 60 PUSH1 0x01 0942 60 PUSH1 0xa0 0944 1B SHL 0945 03 SUB 0946 16 AND 0947 33 CALLER 0948 14 EQ 0949 61 PUSH2 0x0951 094C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0951, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] label_094D: // Incoming jump from 0x094C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0950 memory[0x00:0x00] } 094D 60 PUSH1 0x00 094F 80 DUP1 0950 FD *REVERT // Stack delta = +0 // Outputs[1] { @0950 revert(memory[0x00:0x00]); } // Block terminates label_0951: // Incoming jump from 0x094C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0a] // Inputs[1] { @0955 stack[-1] } 0951 5B JUMPDEST 0952 61 PUSH2 0x0903 0955 81 DUP2 0956 61 PUSH2 0x1515 0959 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0952 stack[0] = 0x0903 // @0955 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1515 label_095A: // Incoming jump from 0x0387 // Inputs[1] { @095D stack[-1] } 095A 5B JUMPDEST 095B 60 PUSH1 0x60 095D 81 DUP2 095E 60 PUSH1 0x00 0960 81 DUP2 0961 67 PUSH8 0xffffffffffffffff 096A 81 DUP2 096B 11 GT 096C 15 ISZERO 096D 61 PUSH2 0x0978 0970 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @095B stack[0] = 0x60 // @095D stack[1] = stack[-1] // @095E stack[2] = 0x00 // @0960 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0978, if !(stack[-1] > 0xffffffffffffffff) label_0971: // Incoming jump from 0x0970, if not !(stack[-1] > 0xffffffffffffffff) 0971 61 PUSH2 0x0978 0974 61 PUSH2 0x1bf7 0977 56 *JUMP // Stack delta = +1 // Outputs[1] { @0971 stack[0] = 0x0978 } // Block ends with unconditional jump to 0x1bf7 label_0978: // Incoming jump from 0x0970, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @097B memory[0x40:0x60] // @097C stack[-1] // } 0978 5B JUMPDEST 0979 60 PUSH1 0x40 097B 51 MLOAD 097C 90 SWAP1 097D 80 DUP1 097E 82 DUP3 097F 52 MSTORE 0980 80 DUP1 0981 60 PUSH1 0x20 0983 02 MUL 0984 60 PUSH1 0x20 0986 01 ADD 0987 82 DUP3 0988 01 ADD 0989 60 PUSH1 0x40 098B 52 MSTORE 098C 80 DUP1 098D 15 ISZERO 098E 61 PUSH2 0x09ca 0991 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @097C stack[-1] = memory[0x40:0x60] // @097C stack[0] = stack[-1] // @097F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @098B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x09ca, if !stack[-1] label_0992: // Incoming jump from 0x0991, if not !stack[-1] // Inputs[3] // { // @0992 stack[-2] // @099A memory[0x40:0x60] // @09BF stack[-1] // } 0992 81 DUP2 0993 60 PUSH1 0x20 0995 01 ADD 0996 5B JUMPDEST 0997 60 PUSH1 0x40 0999 80 DUP1 099A 51 MLOAD 099B 60 PUSH1 0x80 099D 81 DUP2 099E 01 ADD 099F 82 DUP3 09A0 52 MSTORE 09A1 60 PUSH1 0x00 09A3 80 DUP1 09A4 82 DUP3 09A5 52 MSTORE 09A6 60 PUSH1 0x20 09A8 80 DUP1 09A9 83 DUP4 09AA 01 ADD 09AB 82 DUP3 09AC 90 SWAP1 09AD 52 MSTORE 09AE 92 SWAP3 09AF 82 DUP3 09B0 01 ADD 09B1 81 DUP2 09B2 90 SWAP1 09B3 52 MSTORE 09B4 60 PUSH1 0x60 09B6 82 DUP3 09B7 01 ADD 09B8 52 MSTORE 09B9 82 DUP3 09BA 52 MSTORE 09BB 60 PUSH1 0x00 09BD 19 NOT 09BE 90 SWAP1 09BF 92 SWAP3 09C0 01 ADD 09C1 91 SWAP2 09C2 01 ADD 09C3 81 DUP2 09C4 61 PUSH2 0x0996 09C7 57 *JUMPI // Stack delta = +1 // Outputs[8] // { // @09A0 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @09A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @09AD memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @09B3 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @09B8 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @09BA memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = memory[0x40:0x60] // @09C1 stack[-1] = stack[-1] + ~0x00 // @09C2 stack[0] = 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0996, if stack[-1] + ~0x00 label_09C8: // Incoming jump from 0x09C7, if not stack[-2] + ~0x00 // Incoming jump from 0x09C7, if not stack[-1] + ~0x00 // Inputs[2] // { // @09C8 stack[-2] // @09C8 stack[-1] // } 09C8 90 SWAP1 09C9 50 POP // Stack delta = -1 // Outputs[1] { @09C8 stack[-2] = stack[-1] } // Block continues label_09CA: // Incoming jump from 0x0991, if !stack[-1] // Incoming jump from 0x09C9 // Inputs[3] // { // @09CC stack[-2] // @09CC stack[-3] // @09D1 stack[-4] // } 09CA 5B JUMPDEST 09CB 50 POP 09CC 90 SWAP1 09CD 50 POP 09CE 60 PUSH1 0x00 09D0 5B JUMPDEST 09D1 82 DUP3 09D2 81 DUP2 09D3 14 EQ 09D4 61 PUSH2 0x0a1d 09D7 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @09CC stack[-3] = stack[-2] // @09CE stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0a1d, if 0x00 == stack[-4] label_09D8: // Incoming jump from 0x09D7, if not 0x00 == stack[-4] // Incoming jump from 0x09D7, if not stack[-1] == stack[-3] // Inputs[3] // { // @09DB stack[-6] // @09DC stack[-5] // @09DD stack[-1] // } 09D8 61 PUSH2 0x09f8 09DB 86 DUP7 09DC 86 DUP7 09DD 83 DUP4 09DE 81 DUP2 09DF 81 DUP2 09E0 10 LT 09E1 61 PUSH2 0x09ec 09E4 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @09D8 stack[0] = 0x09f8 // @09DB stack[1] = stack[-6] // @09DC stack[2] = stack[-5] // @09DD stack[3] = stack[-1] // } // Block ends with conditional call to 0x09ec, returns to 0x09F8, if stack[-1] < stack[-5] label_09E5: // Incoming jump from 0x09E4, if not stack[-1] < stack[-5] 09E5 61 PUSH2 0x09ec 09E8 61 PUSH2 0x1eb7 09EB 56 *JUMP // Stack delta = +1 // Outputs[1] { @09E5 stack[0] = 0x09ec } // Block ends with unconditional jump to 0x1eb7 label_09EC: // Incoming call from 0x09E4, returns to 0x09F8, if stack[-1] < stack[-5] // Inputs[4] // { // @09ED stack[-1] // @09ED stack[-2] // @09F2 stack[-3] // @09F3 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 09EC 5B JUMPDEST 09ED 90 SWAP1 09EE 50 POP 09EF 60 PUSH1 0x20 09F1 02 MUL 09F2 01 ADD 09F3 35 CALLDATALOAD 09F4 61 PUSH2 0x0ef5 09F7 56 *JUMP // Stack delta = -2 // Outputs[1] { @09F3 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x0ef5 label_09F8: // Incoming return from call to 0x09EC at 0x09E4 // Incoming return from call to 0x09EC at 0x09E4 // Inputs[3] // { // @09F9 stack[-3] // @09FA stack[-2] // @09FC memory[stack[-3]:stack[-3] + 0x20] // } 09F8 5B JUMPDEST 09F9 82 DUP3 09FA 82 DUP3 09FB 81 DUP2 09FC 51 MLOAD 09FD 81 DUP2 09FE 10 LT 09FF 61 PUSH2 0x0a0a 0A02 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @09F9 stack[0] = stack[-3] // @09FA stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0a0a, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0A03: // Incoming jump from 0x0A02, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0A03 61 PUSH2 0x0a0a 0A06 61 PUSH2 0x1eb7 0A09 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A03 stack[0] = 0x0a0a } // Block ends with unconditional jump to 0x1eb7 label_0A0A: // Incoming jump from 0x0A02, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0A0D stack[-1] // @0A10 stack[-2] // @0A15 stack[-3] // @0A18 stack[-4] // } 0A0A 5B JUMPDEST 0A0B 60 PUSH1 0x20 0A0D 90 SWAP1 0A0E 81 DUP2 0A0F 02 MUL 0A10 91 SWAP2 0A11 90 SWAP1 0A12 91 SWAP2 0A13 01 ADD 0A14 01 ADD 0A15 52 MSTORE 0A16 60 PUSH1 0x01 0A18 01 ADD 0A19 61 PUSH2 0x09d0 0A1C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0A15 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0A18 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x09d0 label_0A1D: // Incoming jump from 0x09D7, if 0x00 == stack[-4] // Incoming jump from 0x09D7, if stack[-1] == stack[-3] // Inputs[3] // { // @0A1F stack[-2] // @0A1F stack[-7] // @0A20 stack[-6] // } 0A1D 5B JUMPDEST 0A1E 50 POP 0A1F 94 SWAP5 0A20 93 SWAP4 0A21 50 POP 0A22 50 POP 0A23 50 POP 0A24 50 POP 0A25 56 *JUMP // Stack delta = -6 // Outputs[1] { @0A1F stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_0A26: // Incoming call from 0x03A9, returns to 0x02A0 0A26 5B JUMPDEST 0A27 61 PUSH2 0x0a2e 0A2A 61 PUSH2 0x0c5a 0A2D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A27 stack[0] = 0x0a2e } // Block ends with call to 0x0c5a, returns to 0x0A2E label_0A2E: // Incoming return from call to 0x0C5A at 0x0A2D // Inputs[2] // { // @0A37 stack[-1] // @0A38 msg.sender // } 0A2E 5B JUMPDEST 0A2F 60 PUSH1 0x01 0A31 60 PUSH1 0x01 0A33 60 PUSH1 0xa0 0A35 1B SHL 0A36 03 SUB 0A37 16 AND 0A38 33 CALLER 0A39 60 PUSH1 0x01 0A3B 60 PUSH1 0x01 0A3D 60 PUSH1 0xa0 0A3F 1B SHL 0A40 03 SUB 0A41 16 AND 0A42 14 EQ 0A43 61 PUSH2 0x0a5f 0A46 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a5f, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] label_0A47: // Incoming jump from 0x0A46, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @0A49 memory[0x40:0x60] // @0A59 memory[0x40:0x60] // @0A5E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A47 60 PUSH1 0x40 0A49 51 MLOAD 0A4A 63 PUSH4 0x5fc483c5 0A4F 60 PUSH1 0xe0 0A51 1B SHL 0A52 81 DUP2 0A53 52 MSTORE 0A54 60 PUSH1 0x04 0A56 01 ADD 0A57 60 PUSH1 0x40 0A59 51 MLOAD 0A5A 80 DUP1 0A5B 91 SWAP2 0A5C 03 SUB 0A5D 90 SWAP1 0A5E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5fc483c5 << 0xe0 // @0A5E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A5F: // Incoming jump from 0x0A46, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @0A62 storage[0x09] } 0A5F 5B JUMPDEST 0A60 60 PUSH1 0x09 0A62 54 SLOAD 0A63 60 PUSH1 0x01 0A65 60 PUSH1 0xa0 0A67 1B SHL 0A68 90 SWAP1 0A69 04 DIV 0A6A 60 PUSH1 0xff 0A6C 16 AND 0A6D 15 ISZERO 0A6E 61 PUSH2 0x0a8a 0A71 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a8a, if !(0xff & storage[0x09] / (0x01 << 0xa0)) label_0A72: // Incoming jump from 0x0A71, if not !(0xff & storage[0x09] / (0x01 << 0xa0)) // Inputs[3] // { // @0A74 memory[0x40:0x60] // @0A84 memory[0x40:0x60] // @0A89 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A72 60 PUSH1 0x40 0A74 51 MLOAD 0A75 63 PUSH4 0x1551a48f 0A7A 60 PUSH1 0xe1 0A7C 1B SHL 0A7D 81 DUP2 0A7E 52 MSTORE 0A7F 60 PUSH1 0x04 0A81 01 ADD 0A82 60 PUSH1 0x40 0A84 51 MLOAD 0A85 80 DUP1 0A86 91 SWAP2 0A87 03 SUB 0A88 90 SWAP1 0A89 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1551a48f << 0xe1 // @0A89 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A8A: // Incoming jump from 0x0A71, if !(0xff & storage[0x09] / (0x01 << 0xa0)) // Inputs[4] // { // @0A8E storage[0x09] // @0AA3 memory[0x40:0x60] // @0AC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0ACA stack[-1] // } 0A8A 5B JUMPDEST 0A8B 60 PUSH1 0x09 0A8D 80 DUP1 0A8E 54 SLOAD 0A8F 60 PUSH1 0x01 0A91 60 PUSH1 0x01 0A93 60 PUSH1 0xa8 0A95 1B SHL 0A96 03 SUB 0A97 19 NOT 0A98 16 AND 0A99 60 PUSH1 0x01 0A9B 60 PUSH1 0xa0 0A9D 1B SHL 0A9E 17 OR 0A9F 90 SWAP1 0AA0 55 SSTORE 0AA1 60 PUSH1 0x40 0AA3 51 MLOAD 0AA4 7F PUSH32 0x51e2d870cc2e10853e38dc06fcdae46ad3c3f588f326608803dac6204541ad16 0AC5 90 SWAP1 0AC6 60 PUSH1 0x00 0AC8 90 SWAP1 0AC9 A1 LOG1 0ACA 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0AA0 storage[0x09] = (0x01 << 0xa0) | (~((0x01 << 0xa8) - 0x01) & storage[0x09]) // @0AC9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x51e2d870cc2e10853e38dc06fcdae46ad3c3f588f326608803dac6204541ad16]); // } // Block ends with unconditional jump to stack[-1] label_0ACB: // Incoming jump from 0x03C9 // Incoming call from 0x119A, returns to 0x119B // Inputs[1] { @0AD1 stack[-1] } 0ACB 5B JUMPDEST 0ACC 60 PUSH1 0x00 0ACE 61 PUSH2 0x067c 0AD1 82 DUP3 0AD2 61 PUSH2 0x1520 0AD5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0ACC stack[0] = 0x00 // @0ACE stack[1] = 0x067c // @0AD1 stack[2] = stack[-1] // } // Block ends with call to 0x1520, returns to 0x067C label_0AD6: // Incoming jump from 0x03E9 0AD6 5B JUMPDEST 0AD7 61 PUSH2 0x0ade 0ADA 61 PUSH2 0x13c1 0ADD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AD7 stack[0] = 0x0ade } // Block ends with call to 0x13c1, returns to 0x0ADE label_0ADE: // Incoming return from call to 0x13C1 at 0x0ADD // Inputs[1] { @0AE4 stack[-1] } 0ADE 5B JUMPDEST 0ADF 60 PUSH1 0x0b 0AE1 61 PUSH2 0x0aea 0AE4 82 DUP3 0AE5 82 DUP3 0AE6 61 PUSH2 0x1f2c 0AE9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0ADF stack[0] = 0x0b // @0AE1 stack[1] = 0x0aea // @0AE4 stack[2] = stack[-1] // @0AE5 stack[3] = 0x0b // } // Block ends with call to 0x1f2c, returns to 0x0AEA label_0AEA: // Incoming jump from 0x10F8, if !(address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length > 0x00) // Incoming jump from 0x10F8, if !stack[-1] // Incoming return from call to 0x1F2C at 0x0AE9 // Incoming jump from 0x116C, if stack[-1] // Inputs[1] { @0AED stack[-3] } 0AEA 5B JUMPDEST 0AEB 50 POP 0AEC 50 POP 0AED 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0AEE: // Incoming jump from 0x0409 // Incoming call from 0x0B60, returns to 0x0B61 // Incoming call from 0x0CC8, returns to 0x0CC9 // Incoming call from 0x0CC8, returns to 0x0CC9 // Inputs[1] { @0AF9 stack[-1] } 0AEE 5B JUMPDEST 0AEF 60 PUSH1 0x00 0AF1 60 PUSH1 0x01 0AF3 60 PUSH1 0x01 0AF5 60 PUSH1 0xa0 0AF7 1B SHL 0AF8 03 SUB 0AF9 82 DUP3 0AFA 16 AND 0AFB 61 PUSH2 0x0b17 0AFE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AEF stack[0] = 0x00 } // Block ends with conditional jump to 0x0b17, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0AFF: // Incoming jump from 0x0AFE, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B01 memory[0x40:0x60] // @0B11 memory[0x40:0x60] // @0B16 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AFF 60 PUSH1 0x40 0B01 51 MLOAD 0B02 63 PUSH4 0x23d3ad81 0B07 60 PUSH1 0xe2 0B09 1B SHL 0B0A 81 DUP2 0B0B 52 MSTORE 0B0C 60 PUSH1 0x04 0B0E 01 ADD 0B0F 60 PUSH1 0x40 0B11 51 MLOAD 0B12 80 DUP1 0B13 91 SWAP2 0B14 03 SUB 0B15 90 SWAP1 0B16 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0B16 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B17: // Incoming jump from 0x0AFE, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B21 stack[-2] // @0B2F memory[0x00:0x40] // @0B30 storage[keccak256(memory[0x00:0x40])] // @0B3B stack[-3] // } 0B17 5B JUMPDEST 0B18 50 POP 0B19 60 PUSH1 0x01 0B1B 60 PUSH1 0x01 0B1D 60 PUSH1 0xa0 0B1F 1B SHL 0B20 03 SUB 0B21 16 AND 0B22 60 PUSH1 0x00 0B24 90 SWAP1 0B25 81 DUP2 0B26 52 MSTORE 0B27 60 PUSH1 0x05 0B29 60 PUSH1 0x20 0B2B 52 MSTORE 0B2C 60 PUSH1 0x40 0B2E 90 SWAP1 0B2F 20 SHA3 0B30 54 SLOAD 0B31 67 PUSH8 0xffffffffffffffff 0B3A 16 AND 0B3B 90 SWAP1 0B3C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B26 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B2B memory[0x20:0x40] = 0x05 // @0B3B stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0B3D: // Incoming jump from 0x041E 0B3D 5B JUMPDEST 0B3E 61 PUSH2 0x0b45 0B41 61 PUSH2 0x13c1 0B44 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B3E stack[0] = 0x0b45 } // Block ends with call to 0x13c1, returns to 0x0B45 label_0B45: // Incoming return from call to 0x13C1 at 0x0B44 0B45 5B JUMPDEST 0B46 61 PUSH2 0x0b4f 0B49 60 PUSH1 0x00 0B4B 61 PUSH2 0x1587 0B4E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B46 stack[0] = 0x0b4f // @0B49 stack[1] = 0x00 // } // Block ends with call to 0x1587, returns to 0x0B4F label_0B4F: // Incoming jump from 0x13D8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Incoming return from call to 0x1587 at 0x0B4E // Inputs[1] { @0B50 stack[-1] } 0B4F 5B JUMPDEST 0B50 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0B51: // Incoming jump from 0x043E // Inputs[1] { @0B5C stack[-1] } 0B51 5B JUMPDEST 0B52 60 PUSH1 0x60 0B54 60 PUSH1 0x00 0B56 80 DUP1 0B57 60 PUSH1 0x00 0B59 61 PUSH2 0x0b61 0B5C 85 DUP6 0B5D 61 PUSH2 0x0aee 0B60 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0B52 stack[0] = 0x60 // @0B54 stack[1] = 0x00 // @0B56 stack[2] = 0x00 // @0B57 stack[3] = 0x00 // @0B59 stack[4] = 0x0b61 // @0B5C stack[5] = stack[-1] // } // Block ends with call to 0x0aee, returns to 0x0B61 label_0B61: // Incoming return from call to 0x0AEE at 0x0B60 // Inputs[2] // { // @0B62 stack[-1] // @0B62 stack[-2] // } 0B61 5B JUMPDEST 0B62 90 SWAP1 0B63 50 POP 0B64 60 PUSH1 0x00 0B66 81 DUP2 0B67 67 PUSH8 0xffffffffffffffff 0B70 81 DUP2 0B71 11 GT 0B72 15 ISZERO 0B73 61 PUSH2 0x0b7e 0B76 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B62 stack[-2] = stack[-1] // @0B64 stack[-1] = 0x00 // @0B66 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0b7e, if !(stack[-1] > 0xffffffffffffffff) label_0B77: // Incoming jump from 0x0B76, if not !(stack[-1] > 0xffffffffffffffff) 0B77 61 PUSH2 0x0b7e 0B7A 61 PUSH2 0x1bf7 0B7D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B77 stack[0] = 0x0b7e } // Block ends with unconditional jump to 0x1bf7 label_0B7E: // Incoming jump from 0x0B76, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0B81 memory[0x40:0x60] // @0B82 stack[-1] // } 0B7E 5B JUMPDEST 0B7F 60 PUSH1 0x40 0B81 51 MLOAD 0B82 90 SWAP1 0B83 80 DUP1 0B84 82 DUP3 0B85 52 MSTORE 0B86 80 DUP1 0B87 60 PUSH1 0x20 0B89 02 MUL 0B8A 60 PUSH1 0x20 0B8C 01 ADD 0B8D 82 DUP3 0B8E 01 ADD 0B8F 60 PUSH1 0x40 0B91 52 MSTORE 0B92 80 DUP1 0B93 15 ISZERO 0B94 61 PUSH2 0x0ba7 0B97 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B82 stack[-1] = memory[0x40:0x60] // @0B82 stack[0] = stack[-1] // @0B85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B91 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0ba7, if !stack[-1] label_0B98: // Incoming jump from 0x0B97, if not !stack[-1] // Inputs[6] // { // @0B98 stack[-2] // @0B9E stack[-1] // @0BA1 msg.data.length // @0BA3 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0BA9 stack[-3] // @0BB1 memory[0x40:0x60] // } 0B98 81 DUP2 0B99 60 PUSH1 0x20 0B9B 01 ADD 0B9C 60 PUSH1 0x20 0B9E 82 DUP3 0B9F 02 MUL 0BA0 80 DUP1 0BA1 36 CALLDATASIZE 0BA2 83 DUP4 0BA3 37 CALLDATACOPY 0BA4 01 ADD 0BA5 90 SWAP1 0BA6 50 POP 0BA7 5B JUMPDEST 0BA8 50 POP 0BA9 90 SWAP1 0BAA 50 POP 0BAB 61 PUSH2 0x0bd4 0BAE 60 PUSH1 0x40 0BB0 80 DUP1 0BB1 51 MLOAD 0BB2 60 PUSH1 0x80 0BB4 81 DUP2 0BB5 01 ADD 0BB6 82 DUP3 0BB7 52 MSTORE 0BB8 60 PUSH1 0x00 0BBA 80 DUP1 0BBB 82 DUP3 0BBC 52 MSTORE 0BBD 60 PUSH1 0x20 0BBF 82 DUP3 0BC0 01 ADD 0BC1 81 DUP2 0BC2 90 SWAP1 0BC3 52 MSTORE 0BC4 91 SWAP2 0BC5 81 DUP2 0BC6 01 ADD 0BC7 82 DUP3 0BC8 90 SWAP1 0BC9 52 MSTORE 0BCA 60 PUSH1 0x60 0BCC 81 DUP2 0BCD 01 ADD 0BCE 91 SWAP2 0BCF 90 SWAP1 0BD0 91 SWAP2 0BD1 52 MSTORE 0BD2 90 SWAP1 0BD3 56 *JUMP // Stack delta = -1 // Outputs[8] // { // @0BA3 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0BA9 stack[-3] = stack[-2] // @0BB7 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0BBC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0BC3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0BC9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0BD1 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0BD2 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0bd4 label_0BD4: // Incoming jump from 0x0BD3 // Incoming jump from 0x0BD3 // Inputs[2] // { // @0BD8 stack[-3] // @0BD9 stack[-5] // } 0BD4 5B JUMPDEST 0BD5 60 PUSH1 0x00 0BD7 5B JUMPDEST 0BD8 83 DUP4 0BD9 86 DUP7 0BDA 14 EQ 0BDB 61 PUSH2 0x0c4e 0BDE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BD5 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c4e, if stack[-5] == stack[-3] label_0BDF: // Incoming jump from 0x0BDE, if not stack[-5] == stack[-3] // Incoming jump from 0x0BDE, if not stack[-6] == stack[-4] // Inputs[1] { @0BE2 stack[-1] } 0BDF 61 PUSH2 0x0be7 0BE2 81 DUP2 0BE3 61 PUSH2 0x15d9 0BE6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BDF stack[0] = 0x0be7 // @0BE2 stack[1] = stack[-1] // } // Block ends with call to 0x15d9, returns to 0x0BE7 label_0BE7: // Incoming return from call to 0x15D9 at 0x0BE6 // Inputs[3] // { // @0BE8 stack[-3] // @0BE8 stack[-1] // @0BEE memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0BE7 5B JUMPDEST 0BE8 91 SWAP2 0BE9 50 POP 0BEA 81 DUP2 0BEB 60 PUSH1 0x40 0BED 01 ADD 0BEE 51 MLOAD 0BEF 61 PUSH2 0x0c46 0BF2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0BE8 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x0c46, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0BF3: // Incoming jump from 0x0BF2, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[2] // { // @0BF3 stack[-2] // @0BF4 memory[stack[-2]:stack[-2] + 0x20] // } 0BF3 81 DUP2 0BF4 51 MLOAD 0BF5 60 PUSH1 0x01 0BF7 60 PUSH1 0x01 0BF9 60 PUSH1 0xa0 0BFB 1B SHL 0BFC 03 SUB 0BFD 16 AND 0BFE 15 ISZERO 0BFF 61 PUSH2 0x0c07 0C02 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c07, if !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) label_0C03: // Incoming jump from 0x0C02, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @0C03 stack[-2] // @0C04 memory[stack[-2]:stack[-2] + 0x20] // @0C05 stack[-5] // @0C08 stack[-8] // } 0C03 81 DUP2 0C04 51 MLOAD 0C05 94 SWAP5 0C06 50 POP 0C07 5B JUMPDEST 0C08 87 DUP8 0C09 60 PUSH1 0x01 0C0B 60 PUSH1 0x01 0C0D 60 PUSH1 0xa0 0C0F 1B SHL 0C10 03 SUB 0C11 16 AND 0C12 85 DUP6 0C13 60 PUSH1 0x01 0C15 60 PUSH1 0x01 0C17 60 PUSH1 0xa0 0C19 1B SHL 0C1A 03 SUB 0C1B 16 AND 0C1C 03 SUB 0C1D 61 PUSH2 0x0c46 0C20 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C05 stack[-5] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0c46, if ((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) label_0C21: // Incoming jump from 0x0C20, if not ((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0C20, if not ((0x01 << 0xa0) - 0x01 & stack[-5]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[4] // { // @0C21 stack[-1] // @0C22 stack[-3] // @0C23 stack[-6] // @0C2B memory[stack[-3]:stack[-3] + 0x20] // } 0C21 80 DUP1 0C22 83 DUP4 0C23 87 DUP8 0C24 80 DUP1 0C25 60 PUSH1 0x01 0C27 01 ADD 0C28 98 SWAP9 0C29 50 POP 0C2A 81 DUP2 0C2B 51 MLOAD 0C2C 81 DUP2 0C2D 10 LT 0C2E 61 PUSH2 0x0c39 0C31 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0C21 stack[0] = stack[-1] // @0C22 stack[1] = stack[-3] // @0C23 stack[2] = stack[-6] // @0C28 stack[-6] = 0x01 + stack[-6] // } // Block ends with conditional jump to 0x0c39, if stack[-6] < memory[stack[-3]:stack[-3] + 0x20] label_0C32: // Incoming jump from 0x0C31, if not stack[-6] < memory[stack[-3]:stack[-3] + 0x20] 0C32 61 PUSH2 0x0c39 0C35 61 PUSH2 0x1eb7 0C38 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C32 stack[0] = 0x0c39 } // Block ends with unconditional jump to 0x1eb7 label_0C39: // Incoming jump from 0x0C31, if stack[-6] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[3] // { // @0C3C stack[-1] // @0C40 stack[-2] // @0C41 stack[-3] // } 0C39 5B JUMPDEST 0C3A 60 PUSH1 0x20 0C3C 02 MUL 0C3D 60 PUSH1 0x20 0C3F 01 ADD 0C40 01 ADD 0C41 81 DUP2 0C42 81 DUP2 0C43 52 MSTORE 0C44 50 POP 0C45 50 POP // Stack delta = -3 // Outputs[1] { @0C43 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_0C46: // Incoming jump from 0x0BF2, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Incoming jump from 0x0C20, if ((0x01 << 0xa0) - 0x01 & stack[-5]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0C45 // Incoming jump from 0x0C20, if ((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[1] { @0C49 stack[-1] } 0C46 5B JUMPDEST 0C47 60 PUSH1 0x01 0C49 01 ADD 0C4A 61 PUSH2 0x0bd7 0C4D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C49 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0bd7 label_0C4E: // Incoming jump from 0x0BDE, if stack[-5] == stack[-3] // Incoming jump from 0x1BD9, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1D0B, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1BD9, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1D0B, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0BDE, if stack[-6] == stack[-4] // Inputs[4] // { // @0C50 stack[-2] // @0C50 stack[-3] // @0C51 stack[-9] // @0C52 stack[-8] // } 0C4E 5B JUMPDEST 0C4F 50 POP 0C50 90 SWAP1 0C51 96 SWAP7 0C52 95 SWAP6 0C53 50 POP 0C54 50 POP 0C55 50 POP 0C56 50 POP 0C57 50 POP 0C58 50 POP 0C59 56 *JUMP // Stack delta = -8 // Outputs[1] { @0C51 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_0C5A: // Incoming call from 0x13C9, returns to 0x13CA // Incoming call from 0x0E44, returns to 0x0E45 // Incoming call from 0x0A2D, returns to 0x0A2E // Incoming call from 0x0460, returns to 0x0275 // Inputs[1] { @0C62 storage[0x08] } 0C5A 5B JUMPDEST 0C5B 60 PUSH1 0x00 0C5D 61 PUSH2 0x0c6e 0C60 60 PUSH1 0x08 0C62 54 SLOAD 0C63 60 PUSH1 0x01 0C65 60 PUSH1 0x01 0C67 60 PUSH1 0xa0 0C69 1B SHL 0C6A 03 SUB 0C6B 16 AND 0C6C 90 SWAP1 0C6D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C5B stack[0] = 0x00 // @0C6C stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x0c6e label_0C6E: // Incoming jump from 0x0C6D // Inputs[3] // { // @0C6F stack[-1] // @0C6F stack[-2] // @0C71 stack[-3] // } 0C6E 5B JUMPDEST 0C6F 90 SWAP1 0C70 50 POP 0C71 90 SWAP1 0C72 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C71 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0C73: // Incoming call from 0x0475, returns to 0x0248 // Inputs[1] { @0C79 storage[0x03] } 0C73 5B JUMPDEST 0C74 60 PUSH1 0x60 0C76 60 PUSH1 0x03 0C78 80 DUP1 0C79 54 SLOAD 0C7A 61 PUSH2 0x0691 0C7D 90 SWAP1 0C7E 61 PUSH2 0x1e54 0C81 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C74 stack[0] = 0x60 // @0C76 stack[1] = 0x03 // @0C7D stack[2] = 0x0691 // @0C7D stack[3] = storage[0x03] // } // Block ends with call to 0x1e54, returns to 0x0691 label_0C82: // Incoming jump from 0x0495 // Inputs[2] // { // @0C85 stack[-1] // @0C86 stack[-2] // } 0C82 5B JUMPDEST 0C83 60 PUSH1 0x60 0C85 81 DUP2 0C86 83 DUP4 0C87 10 LT 0C88 61 PUSH2 0x0ca4 0C8B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C83 stack[0] = 0x60 } // Block ends with conditional jump to 0x0ca4, if stack[-2] < stack[-1] label_0C8C: // Incoming jump from 0x0C8B, if not stack[-2] < stack[-1] // Inputs[3] // { // @0C8E memory[0x40:0x60] // @0C9E memory[0x40:0x60] // @0CA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C8C 60 PUSH1 0x40 0C8E 51 MLOAD 0C8F 63 PUSH4 0x1960ccad 0C94 60 PUSH1 0xe1 0C96 1B SHL 0C97 81 DUP2 0C98 52 MSTORE 0C99 60 PUSH1 0x04 0C9B 01 ADD 0C9C 60 PUSH1 0x40 0C9E 51 MLOAD 0C9F 80 DUP1 0CA0 91 SWAP2 0CA1 03 SUB 0CA2 90 SWAP1 0CA3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1960ccad << 0xe1 // @0CA3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CA4: // Incoming jump from 0x0C8B, if stack[-2] < stack[-1] // Inputs[1] { @0CAD storage[0x00] } 0CA4 5B JUMPDEST 0CA5 60 PUSH1 0x00 0CA7 80 DUP1 0CA8 61 PUSH2 0x0cb0 0CAB 60 PUSH1 0x00 0CAD 54 SLOAD 0CAE 90 SWAP1 0CAF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA5 stack[0] = 0x00 // @0CA7 stack[1] = 0x00 // @0CAE stack[2] = storage[0x00] // } // Block ends with unconditional jump to 0x0cb0 label_0CB0: // Incoming jump from 0x0CAF // Inputs[3] // { // @0CB1 stack[-1] // @0CB1 stack[-2] // @0CB4 stack[-5] // } 0CB0 5B JUMPDEST 0CB1 90 SWAP1 0CB2 50 POP 0CB3 80 DUP1 0CB4 84 DUP5 0CB5 11 GT 0CB6 15 ISZERO 0CB7 61 PUSH2 0x0cbe 0CBA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0CB1 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0cbe, if !(stack[-5] > stack[-1]) label_0CBB: // Incoming jump from 0x0CBA, if not !(stack[-5] > stack[-1]) // Inputs[3] // { // @0CBB stack[-1] // @0CBC stack[-4] // @0CC4 stack[-6] // } 0CBB 80 DUP1 0CBC 93 SWAP4 0CBD 50 POP 0CBE 5B JUMPDEST 0CBF 60 PUSH1 0x00 0CC1 61 PUSH2 0x0cc9 0CC4 87 DUP8 0CC5 61 PUSH2 0x0aee 0CC8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0CBC stack[-4] = stack[-1] // @0CBF stack[0] = 0x00 // @0CC1 stack[1] = 0x0cc9 // @0CC4 stack[2] = stack[-6] // } // Block ends with call to 0x0aee, returns to 0x0CC9 label_0CC9: // Incoming return from call to 0x0AEE at 0x0CC8 // Incoming return from call to 0x0AEE at 0x0CC8 // Inputs[4] // { // @0CCA stack[-1] // @0CCA stack[-2] // @0CCC stack[-6] // @0CCD stack[-7] // } 0CC9 5B JUMPDEST 0CCA 90 SWAP1 0CCB 50 POP 0CCC 84 DUP5 0CCD 86 DUP7 0CCE 10 LT 0CCF 15 ISZERO 0CD0 61 PUSH2 0x0ce8 0CD3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0CCA stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0ce8, if !(stack[-7] < stack[-6]) label_0CD4: // Incoming jump from 0x0CD3, if not !(stack[-7] < stack[-6]) // Inputs[3] // { // @0CD4 stack[-6] // @0CD5 stack[-5] // @0CD7 stack[-1] // } 0CD4 85 DUP6 0CD5 85 DUP6 0CD6 03 SUB 0CD7 81 DUP2 0CD8 81 DUP2 0CD9 10 LT 0CDA 15 ISZERO 0CDB 61 PUSH2 0x0ce2 0CDE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CD6 stack[0] = stack[-5] - stack[-6] } // Block ends with conditional jump to 0x0ce2, if !(stack[-5] - stack[-6] < stack[-1]) label_0CDF: // Incoming jump from 0x0CDE, if not !(stack[-5] - stack[-6] < stack[-1]) // Inputs[2] // { // @0CDF stack[-1] // @0CE0 stack[-2] // } 0CDF 80 DUP1 0CE0 91 SWAP2 0CE1 50 POP 0CE2 5B JUMPDEST 0CE3 50 POP 0CE4 61 PUSH2 0x0cec 0CE7 56 *JUMP // Stack delta = -1 // Outputs[1] { @0CE0 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0cec label_0CE8: // Incoming jump from 0x0CD3, if !(stack[-7] < stack[-6]) 0CE8 5B JUMPDEST 0CE9 50 POP 0CEA 60 PUSH1 0x00 0CEC 5B JUMPDEST 0CED 60 PUSH1 0x00 0CEF 81 DUP2 0CF0 67 PUSH8 0xffffffffffffffff 0CF9 81 DUP2 0CFA 11 GT 0CFB 15 ISZERO 0CFC 61 PUSH2 0x0d07 0CFF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0CEA stack[-1] = 0x00 // @0CED stack[0] = 0x00 // @0CEF stack[1] = 0x00 // } // Block ends with conditional jump to 0x0d07, if !(0x00 > 0xffffffffffffffff) label_0D00: // Incoming jump from 0x0CFF, if not !(stack[-1] > 0xffffffffffffffff) // Incoming jump from 0x0CFF, if not !(0x00 > 0xffffffffffffffff) 0D00 61 PUSH2 0x0d07 0D03 61 PUSH2 0x1bf7 0D06 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D00 stack[0] = 0x0d07 } // Block ends with unconditional jump to 0x1bf7 label_0D07: // Incoming jump from 0x0CFF, if !(stack[-1] > 0xffffffffffffffff) // Incoming jump from 0x0CFF, if !(0x00 > 0xffffffffffffffff) // Inputs[2] // { // @0D0A memory[0x40:0x60] // @0D0B stack[-1] // } 0D07 5B JUMPDEST 0D08 60 PUSH1 0x40 0D0A 51 MLOAD 0D0B 90 SWAP1 0D0C 80 DUP1 0D0D 82 DUP3 0D0E 52 MSTORE 0D0F 80 DUP1 0D10 60 PUSH1 0x20 0D12 02 MUL 0D13 60 PUSH1 0x20 0D15 01 ADD 0D16 82 DUP3 0D17 01 ADD 0D18 60 PUSH1 0x40 0D1A 52 MSTORE 0D1B 80 DUP1 0D1C 15 ISZERO 0D1D 61 PUSH2 0x0d30 0D20 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0D0B stack[-1] = memory[0x40:0x60] // @0D0B stack[0] = stack[-1] // @0D0E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D1A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0d30, if !stack[-1] label_0D21: // Incoming jump from 0x0D20, if not !stack[-1] // Inputs[6] // { // @0D21 stack[-2] // @0D27 stack[-1] // @0D2A msg.data.length // @0D2C msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0D32 stack[-3] // @0D34 stack[-4] // } 0D21 81 DUP2 0D22 60 PUSH1 0x20 0D24 01 ADD 0D25 60 PUSH1 0x20 0D27 82 DUP3 0D28 02 MUL 0D29 80 DUP1 0D2A 36 CALLDATASIZE 0D2B 83 DUP4 0D2C 37 CALLDATACOPY 0D2D 01 ADD 0D2E 90 SWAP1 0D2F 50 POP 0D30 5B JUMPDEST 0D31 50 POP 0D32 90 SWAP1 0D33 50 POP 0D34 81 DUP2 0D35 60 PUSH1 0x00 0D37 03 SUB 0D38 61 PUSH2 0x0d46 0D3B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0D2C memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0D32 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x0d46, if 0x00 - stack[-4] label_0D3C: // Incoming jump from 0x0D3B, if not 0x00 - stack[-4] // Incoming jump from 0x0D3B, if not 0x00 - stack[-4] // Inputs[3] // { // @0D3C stack[-5] // @0D3C stack[-1] // @0D41 stack[-4] // } 0D3C 93 SWAP4 0D3D 50 POP 0D3E 61 PUSH2 0x0df5 0D41 92 SWAP3 0D42 50 POP 0D43 50 POP 0D44 50 POP 0D45 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D3C stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x0df5 label_0D46: // Incoming jump from 0x0D3B, if 0x00 - stack[-4] // Incoming jump from 0x0D3B, if 0x00 - stack[-4] // Inputs[1] { @0D4C stack[-7] } 0D46 5B JUMPDEST 0D47 60 PUSH1 0x00 0D49 61 PUSH2 0x0d51 0D4C 88 DUP9 0D4D 61 PUSH2 0x0ef5 0D50 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D47 stack[0] = 0x00 // @0D49 stack[1] = 0x0d51 // @0D4C stack[2] = stack[-7] // } // Block ends with call to 0x0ef5, returns to 0x0D51 label_0D51: // Incoming return from call to 0x0EF5 at 0x0D50 // Inputs[3] // { // @0D52 stack[-2] // @0D52 stack[-1] // @0D5A memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0D51 5B JUMPDEST 0D52 90 SWAP1 0D53 50 POP 0D54 60 PUSH1 0x00 0D56 81 DUP2 0D57 60 PUSH1 0x40 0D59 01 ADD 0D5A 51 MLOAD 0D5B 61 PUSH2 0x0d62 0D5E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D52 stack[-2] = stack[-1] // @0D54 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0d62, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0D5F: // Incoming jump from 0x0D5E, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[4] // { // @0D60 stack[-2] // @0D61 memory[stack[-2]:stack[-2] + 0x20] // @0D63 stack[-9] // @0D65 stack[-8] // } 0D5F 50 POP 0D60 80 DUP1 0D61 51 MLOAD 0D62 5B JUMPDEST 0D63 88 DUP9 0D64 5B JUMPDEST 0D65 88 DUP9 0D66 81 DUP2 0D67 14 EQ 0D68 15 ISZERO 0D69 80 DUP1 0D6A 15 ISZERO 0D6B 61 PUSH2 0x0d74 0D6E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0D61 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @0D63 stack[0] = stack[-9] // @0D68 stack[1] = !(stack[-9] == stack[-8]) // } // Block ends with conditional jump to 0x0d74, if !!(stack[-9] == stack[-8]) label_0D6F: // Incoming jump from 0x0D6E, if not !!(stack[-9] == stack[-8]) // Incoming jump from 0x0D6E, if not !!(stack[-9] == stack[-8]) // Incoming jump from 0x0D6E, if not !!(stack[-1] == stack[-9]) // Inputs[2] // { // @0D70 stack[-6] // @0D71 stack[-8] // } 0D6F 50 POP 0D70 84 DUP5 0D71 87 DUP8 0D72 14 EQ 0D73 15 ISZERO 0D74 5B JUMPDEST 0D75 15 ISZERO 0D76 61 PUSH2 0x0de9 0D79 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0de9, if !!(stack[-8] == stack[-6]) label_0D7A: // Incoming jump from 0x0D79, if not !stack[-1] // Incoming jump from 0x0D79, if not !!(stack[-8] == stack[-6]) // Inputs[1] { @0D7D stack[-1] } 0D7A 61 PUSH2 0x0d82 0D7D 81 DUP2 0D7E 61 PUSH2 0x15d9 0D81 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D7A stack[0] = 0x0d82 // @0D7D stack[1] = stack[-1] // } // Block ends with call to 0x15d9, returns to 0x0D82 label_0D82: // Incoming return from call to 0x15D9 at 0x0D81 // Inputs[3] // { // @0D83 stack[-1] // @0D83 stack[-4] // @0D89 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0D82 5B JUMPDEST 0D83 92 SWAP3 0D84 50 POP 0D85 82 DUP3 0D86 60 PUSH1 0x40 0D88 01 ADD 0D89 51 MLOAD 0D8A 61 PUSH2 0x0de1 0D8D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D83 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x0de1, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0D8E: // Incoming jump from 0x0D8D, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[2] // { // @0D8E stack[-3] // @0D8F memory[stack[-3]:stack[-3] + 0x20] // } 0D8E 82 DUP3 0D8F 51 MLOAD 0D90 60 PUSH1 0x01 0D92 60 PUSH1 0x01 0D94 60 PUSH1 0xa0 0D96 1B SHL 0D97 03 SUB 0D98 16 AND 0D99 15 ISZERO 0D9A 61 PUSH2 0x0da2 0D9D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da2, if !((0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) label_0D9E: // Incoming jump from 0x0D9D, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @0D9E stack[-3] // @0D9F memory[stack[-3]:stack[-3] + 0x20] // @0DA0 stack[-2] // @0DA3 stack[-11] // } 0D9E 82 DUP3 0D9F 51 MLOAD 0DA0 91 SWAP2 0DA1 50 POP 0DA2 5B JUMPDEST 0DA3 8A DUP11 0DA4 60 PUSH1 0x01 0DA6 60 PUSH1 0x01 0DA8 60 PUSH1 0xa0 0DAA 1B SHL 0DAB 03 SUB 0DAC 16 AND 0DAD 82 DUP3 0DAE 60 PUSH1 0x01 0DB0 60 PUSH1 0x01 0DB2 60 PUSH1 0xa0 0DB4 1B SHL 0DB5 03 SUB 0DB6 16 AND 0DB7 03 SUB 0DB8 61 PUSH2 0x0de1 0DBB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DA0 stack[-2] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x0de1, if ((0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-11]) label_0DBC: // Incoming jump from 0x0DBB, if not ((0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-11]) // Incoming jump from 0x0DBB, if not ((0x01 << 0xa0) - 0x01 & stack[-2]) - ((0x01 << 0xa0) - 0x01 & stack[-11]) // Inputs[4] // { // @0DBC stack[-1] // @0DBD stack[-4] // @0DBE stack[-7] // @0DC6 memory[stack[-4]:stack[-4] + 0x20] // } 0DBC 80 DUP1 0DBD 84 DUP5 0DBE 88 DUP9 0DBF 80 DUP1 0DC0 60 PUSH1 0x01 0DC2 01 ADD 0DC3 99 SWAP10 0DC4 50 POP 0DC5 81 DUP2 0DC6 51 MLOAD 0DC7 81 DUP2 0DC8 10 LT 0DC9 61 PUSH2 0x0dd4 0DCC 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0DBC stack[0] = stack[-1] // @0DBD stack[1] = stack[-4] // @0DBE stack[2] = stack[-7] // @0DC3 stack[-7] = 0x01 + stack[-7] // } // Block ends with conditional jump to 0x0dd4, if stack[-7] < memory[stack[-4]:stack[-4] + 0x20] label_0DCD: // Incoming jump from 0x0DCC, if not stack[-7] < memory[stack[-4]:stack[-4] + 0x20] 0DCD 61 PUSH2 0x0dd4 0DD0 61 PUSH2 0x1eb7 0DD3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DCD stack[0] = 0x0dd4 } // Block ends with unconditional jump to 0x1eb7 label_0DD4: // Incoming jump from 0x0DCC, if stack[-7] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @0DD7 stack[-1] // @0DDB stack[-2] // @0DDC stack[-3] // } 0DD4 5B JUMPDEST 0DD5 60 PUSH1 0x20 0DD7 02 MUL 0DD8 60 PUSH1 0x20 0DDA 01 ADD 0DDB 01 ADD 0DDC 81 DUP2 0DDD 81 DUP2 0DDE 52 MSTORE 0DDF 50 POP 0DE0 50 POP // Stack delta = -3 // Outputs[1] { @0DDE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_0DE1: // Incoming jump from 0x0DBB, if ((0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) - ((0x01 << 0xa0) - 0x01 & stack[-11]) // Incoming jump from 0x0DBB, if ((0x01 << 0xa0) - 0x01 & stack[-2]) - ((0x01 << 0xa0) - 0x01 & stack[-11]) // Incoming jump from 0x0DE0 // Incoming jump from 0x0D8D, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[1] { @0DE4 stack[-1] } 0DE1 5B JUMPDEST 0DE2 60 PUSH1 0x01 0DE4 01 ADD 0DE5 61 PUSH2 0x0d64 0DE8 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DE4 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0d64 label_0DE9: // Incoming jump from 0x0D79, if !stack[-1] // Incoming jump from 0x0D79, if !!(stack[-8] == stack[-6]) // Inputs[4] // { // @0DED stack[-7] // @0DED stack[-4] // @0DF1 stack[-6] // @0DF2 stack[-8] // } 0DE9 5B JUMPDEST 0DEA 50 POP 0DEB 50 POP 0DEC 50 POP 0DED 92 SWAP3 0DEE 83 DUP4 0DEF 52 MSTORE 0DF0 50 POP 0DF1 90 SWAP1 0DF2 91 SWAP2 0DF3 50 POP 0DF4 50 POP // Stack delta = -7 // Outputs[2] // { // @0DEF memory[stack[-4]:stack[-4] + 0x20] = stack[-7] // @0DF2 stack[-8] = stack[-4] // } // Block continues label_0DF5: // Incoming jump from 0x1553, if 0x00 - stack[-1] // Incoming return from call to 0x1A10 at 0x1A4E // Incoming return from call to 0x19B9 at 0x19EB // Incoming return from call to 0x1A68 at 0x1CE6 // Incoming jump from 0x0DF4 // Incoming jump from 0x0D45 // Incoming return from call to 0x1D52 at 0x2037 // Inputs[3] // { // @0DF6 stack[-5] // @0DF6 stack[-1] // @0DF7 stack[-4] // } 0DF5 5B JUMPDEST 0DF6 93 SWAP4 0DF7 92 SWAP3 0DF8 50 POP 0DF9 50 POP 0DFA 50 POP 0DFB 56 *JUMP // Stack delta = -4 // Outputs[1] { @0DF6 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0DFC: // Incoming jump from 0x04CF // Inputs[1] { @0DFD stack[-2] } 0DFC 5B JUMPDEST 0DFD 81 DUP2 0DFE 61 PUSH2 0x0e06 0E01 81 DUP2 0E02 61 PUSH2 0x10ce 0E05 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DFD stack[0] = stack[-2] // @0DFE stack[1] = 0x0e06 // @0E01 stack[2] = stack[-2] // } // Block ends with call to 0x10ce, returns to 0x0E06 label_0E06: // Incoming return from call to 0x10CE at 0x0E05 // Inputs[2] // { // @0E0A stack[-3] // @0E0B stack[-2] // } 0E06 5B JUMPDEST 0E07 61 PUSH2 0x076c 0E0A 83 DUP4 0E0B 83 DUP4 0E0C 61 PUSH2 0x1615 0E0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E07 stack[0] = 0x076c // @0E0A stack[1] = stack[-3] // @0E0B stack[2] = stack[-2] // } // Block ends with call to 0x1615, returns to 0x076C label_0E10: // Incoming jump from 0x1514 // Incoming jump from 0x0502 // Inputs[2] // { // @0E11 stack[-4] // @0E1C msg.sender // } 0E10 5B JUMPDEST 0E11 83 DUP4 0E12 60 PUSH1 0x01 0E14 60 PUSH1 0x01 0E16 60 PUSH1 0xa0 0E18 1B SHL 0E19 03 SUB 0E1A 81 DUP2 0E1B 16 AND 0E1C 33 CALLER 0E1D 14 EQ 0E1E 61 PUSH2 0x0e2a 0E21 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E11 stack[0] = stack[-4] } // Block ends with conditional jump to 0x0e2a, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 label_0E22: // Incoming jump from 0x0E21, if not msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E25 msg.sender } 0E22 61 PUSH2 0x0e2a 0E25 33 CALLER 0E26 61 PUSH2 0x10ce 0E29 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E22 stack[0] = 0x0e2a // @0E25 stack[1] = msg.sender // } // Block ends with call to 0x10ce, returns to 0x0E2A label_0E2A: // Incoming jump from 0x0E21, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x10CE at 0x0E29 // Inputs[4] // { // @0E2E stack[-5] // @0E2F stack[-4] // @0E30 stack[-3] // @0E31 stack[-2] // } 0E2A 5B JUMPDEST 0E2B 61 PUSH2 0x0e36 0E2E 85 DUP6 0E2F 85 DUP6 0E30 85 DUP6 0E31 85 DUP6 0E32 61 PUSH2 0x1681 0E35 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0E2B stack[0] = 0x0e36 // @0E2E stack[1] = stack[-5] // @0E2F stack[2] = stack[-4] // @0E30 stack[3] = stack[-3] // @0E31 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x1681 0E36 5B JUMPDEST 0E37 50 POP 0E38 50 POP 0E39 50 POP 0E3A 50 POP 0E3B 50 POP 0E3C 56 *JUMP label_0E3D: // Incoming jump from 0x0522 0E3D 5B JUMPDEST 0E3E 61 PUSH2 0x0e45 0E41 61 PUSH2 0x0c5a 0E44 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E3E stack[0] = 0x0e45 } // Block ends with call to 0x0c5a, returns to 0x0E45 label_0E45: // Incoming return from call to 0x0C5A at 0x0E44 // Inputs[2] // { // @0E4E stack[-1] // @0E4F msg.sender // } 0E45 5B JUMPDEST 0E46 60 PUSH1 0x01 0E48 60 PUSH1 0x01 0E4A 60 PUSH1 0xa0 0E4C 1B SHL 0E4D 03 SUB 0E4E 16 AND 0E4F 33 CALLER 0E50 60 PUSH1 0x01 0E52 60 PUSH1 0x01 0E54 60 PUSH1 0xa0 0E56 1B SHL 0E57 03 SUB 0E58 16 AND 0E59 14 EQ 0E5A 61 PUSH2 0x0e76 0E5D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e76, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] label_0E5E: // Incoming jump from 0x0E5D, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @0E60 memory[0x40:0x60] // @0E70 memory[0x40:0x60] // @0E75 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E5E 60 PUSH1 0x40 0E60 51 MLOAD 0E61 63 PUSH4 0x5fc483c5 0E66 60 PUSH1 0xe0 0E68 1B SHL 0E69 81 DUP2 0E6A 52 MSTORE 0E6B 60 PUSH1 0x04 0E6D 01 ADD 0E6E 60 PUSH1 0x40 0E70 51 MLOAD 0E71 80 DUP1 0E72 91 SWAP2 0E73 03 SUB 0E74 90 SWAP1 0E75 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5fc483c5 << 0xe0 // @0E75 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E76: // Incoming jump from 0x0E5D, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @0E79 storage[0x09] } 0E76 5B JUMPDEST 0E77 60 PUSH1 0x09 0E79 54 SLOAD 0E7A 60 PUSH1 0x01 0E7C 60 PUSH1 0xa0 0E7E 1B SHL 0E7F 90 SWAP1 0E80 04 DIV 0E81 60 PUSH1 0xff 0E83 16 AND 0E84 15 ISZERO 0E85 61 PUSH2 0x0ea1 0E88 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ea1, if !(0xff & storage[0x09] / (0x01 << 0xa0)) label_0E89: // Incoming jump from 0x0E88, if not !(0xff & storage[0x09] / (0x01 << 0xa0)) // Inputs[3] // { // @0E8B memory[0x40:0x60] // @0E9B memory[0x40:0x60] // @0EA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E89 60 PUSH1 0x40 0E8B 51 MLOAD 0E8C 63 PUSH4 0x1551a48f 0E91 60 PUSH1 0xe1 0E93 1B SHL 0E94 81 DUP2 0E95 52 MSTORE 0E96 60 PUSH1 0x04 0E98 01 ADD 0E99 60 PUSH1 0x40 0E9B 51 MLOAD 0E9C 80 DUP1 0E9D 91 SWAP2 0E9E 03 SUB 0E9F 90 SWAP1 0EA0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1551a48f << 0xe1 // @0EA0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EA1: // Incoming jump from 0x0E88, if !(0xff & storage[0x09] / (0x01 << 0xa0)) // Inputs[6] // { // @0EA5 storage[0x09] // @0EB8 stack[-1] // @0EC2 memory[0x40:0x60] // @0EED memory[0x40:0x60] // @0EF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0EF4 stack[-2] // } 0EA1 5B JUMPDEST 0EA2 60 PUSH1 0x09 0EA4 80 DUP1 0EA5 54 SLOAD 0EA6 60 PUSH1 0x01 0EA8 60 PUSH1 0x01 0EAA 60 PUSH1 0xa0 0EAC 1B SHL 0EAD 03 SUB 0EAE 19 NOT 0EAF 16 AND 0EB0 60 PUSH1 0x01 0EB2 60 PUSH1 0x01 0EB4 60 PUSH1 0xa0 0EB6 1B SHL 0EB7 03 SUB 0EB8 83 DUP4 0EB9 16 AND 0EBA 90 SWAP1 0EBB 81 DUP2 0EBC 17 OR 0EBD 90 SWAP1 0EBE 91 SWAP2 0EBF 55 SSTORE 0EC0 60 PUSH1 0x40 0EC2 51 MLOAD 0EC3 90 SWAP1 0EC4 81 DUP2 0EC5 52 MSTORE 0EC6 7F PUSH32 0x9f513fe86dc42fdbac355fa4d9b1d5be7b5e6cd2df67e30db8003766568de476 0EE7 90 SWAP1 0EE8 60 PUSH1 0x20 0EEA 01 ADD 0EEB 60 PUSH1 0x40 0EED 51 MLOAD 0EEE 80 DUP1 0EEF 91 SWAP2 0EF0 03 SUB 0EF1 90 SWAP1 0EF2 A1 LOG1 0EF3 50 POP 0EF4 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0EBF storage[0x09] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x09]) // @0EC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0EF2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x9f513fe86dc42fdbac355fa4d9b1d5be7b5e6cd2df67e30db8003766568de476]); // } // Block ends with unconditional jump to stack[-2] label_0EF5: // Incoming jump from 0x09F7 // Incoming call from 0x0D50, returns to 0x0D51 // Incoming jump from 0x0542 // Inputs[4] // { // @0EF9 memory[0x40:0x60] // @0F1D memory[0x40:0x60] // @0F3D storage[0x00] // @0F3E stack[-1] // } 0EF5 5B JUMPDEST 0EF6 60 PUSH1 0x40 0EF8 80 DUP1 0EF9 51 MLOAD 0EFA 60 PUSH1 0x80 0EFC 80 DUP1 0EFD 82 DUP3 0EFE 01 ADD 0EFF 83 DUP4 0F00 52 MSTORE 0F01 60 PUSH1 0x00 0F03 80 DUP1 0F04 83 DUP4 0F05 52 MSTORE 0F06 60 PUSH1 0x20 0F08 80 DUP1 0F09 84 DUP5 0F0A 01 ADD 0F0B 82 DUP3 0F0C 90 SWAP1 0F0D 52 MSTORE 0F0E 83 DUP4 0F0F 85 DUP6 0F10 01 ADD 0F11 82 DUP3 0F12 90 SWAP1 0F13 52 MSTORE 0F14 60 PUSH1 0x60 0F16 80 DUP1 0F17 85 DUP6 0F18 01 ADD 0F19 83 DUP4 0F1A 90 SWAP1 0F1B 52 MSTORE 0F1C 85 DUP6 0F1D 51 MLOAD 0F1E 93 SWAP4 0F1F 84 DUP5 0F20 01 ADD 0F21 86 DUP7 0F22 52 MSTORE 0F23 82 DUP3 0F24 84 DUP5 0F25 52 MSTORE 0F26 90 SWAP1 0F27 83 DUP4 0F28 01 ADD 0F29 82 DUP3 0F2A 90 SWAP1 0F2B 52 MSTORE 0F2C 93 SWAP4 0F2D 82 DUP3 0F2E 01 ADD 0F2F 81 DUP2 0F30 90 SWAP1 0F31 52 MSTORE 0F32 92 SWAP3 0F33 81 DUP2 0F34 01 ADD 0F35 83 DUP4 0F36 90 SWAP1 0F37 52 MSTORE 0F38 90 SWAP1 0F39 91 SWAP2 0F3A 50 POP 0F3B 60 PUSH1 0x00 0F3D 54 SLOAD 0F3E 83 DUP4 0F3F 10 LT 0F40 61 PUSH2 0x0f49 0F43 57 *JUMPI // Stack delta = +2 // Outputs[12] // { // @0F00 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0F05 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0F0D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0F13 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0x00 // @0F1B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0F22 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0F25 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0F2B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0F31 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0F37 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0F38 stack[1] = memory[0x40:0x60] // @0F39 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0f49, if stack[-1] < storage[0x00] label_0F44: // Incoming jump from 0x0F43, if not stack[-1] < storage[0x00] // Inputs[3] // { // @0F44 stack[-4] // @0F44 stack[-1] // @0F45 stack[-3] // } 0F44 92 SWAP3 0F45 91 SWAP2 0F46 50 POP 0F47 50 POP 0F48 56 *JUMP // Stack delta = -3 // Outputs[1] { @0F44 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0F49: // Incoming jump from 0x0F43, if stack[-1] < storage[0x00] // Inputs[1] { @0F4D stack[-3] } 0F49 5B JUMPDEST 0F4A 61 PUSH2 0x0f52 0F4D 83 DUP4 0F4E 61 PUSH2 0x15d9 0F51 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F4A stack[0] = 0x0f52 // @0F4D stack[1] = stack[-3] // } // Block ends with call to 0x15d9, returns to 0x0F52 label_0F52: // Incoming return from call to 0x15D9 at 0x0F51 // Inputs[3] // { // @0F53 stack[-1] // @0F53 stack[-2] // @0F59 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0F52 5B JUMPDEST 0F53 90 SWAP1 0F54 50 POP 0F55 80 DUP1 0F56 60 PUSH1 0x40 0F58 01 ADD 0F59 51 MLOAD 0F5A 15 ISZERO 0F5B 61 PUSH2 0x0f64 0F5E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0F53 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0f64, if !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0F5F: // Incoming jump from 0x0F5E, if not !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[3] // { // @0F5F stack[-1] // @0F5F stack[-4] // @0F60 stack[-3] // } 0F5F 92 SWAP3 0F60 91 SWAP2 0F61 50 POP 0F62 50 POP 0F63 56 *JUMP // Stack delta = -3 // Outputs[1] { @0F5F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0F64: // Incoming jump from 0x0F5E, if !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[1] { @0F68 stack[-3] } 0F64 5B JUMPDEST 0F65 61 PUSH2 0x0df5 0F68 83 DUP4 0F69 61 PUSH2 0x16c5 0F6C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F65 stack[0] = 0x0df5 // @0F68 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x16c5 label_0F6D: // Incoming jump from 0x056F // Inputs[1] { @0F73 stack[-1] } 0F6D 5B JUMPDEST 0F6E 60 PUSH1 0x60 0F70 61 PUSH2 0x0f78 0F73 82 DUP3 0F74 61 PUSH2 0x10a7 0F77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F6E stack[0] = 0x60 // @0F70 stack[1] = 0x0f78 // @0F73 stack[2] = stack[-1] // } // Block ends with call to 0x10a7, returns to 0x0F78 label_0F78: // Incoming return from call to 0x10A7 at 0x0F77 // Inputs[1] { @0F7C stack[-1] } 0F78 5B JUMPDEST 0F79 61 PUSH2 0x0f95 0F7C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f95, if stack[-1] label_0F7D: // Incoming jump from 0x0F7C, if not stack[-1] // Inputs[3] // { // @0F7F memory[0x40:0x60] // @0F8F memory[0x40:0x60] // @0F94 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F7D 60 PUSH1 0x40 0F7F 51 MLOAD 0F80 63 PUSH4 0x0a14c4b5 0F85 60 PUSH1 0xe4 0F87 1B SHL 0F88 81 DUP2 0F89 52 MSTORE 0F8A 60 PUSH1 0x04 0F8C 01 ADD 0F8D 60 PUSH1 0x40 0F8F 51 MLOAD 0F90 80 DUP1 0F91 91 SWAP2 0F92 03 SUB 0F93 90 SWAP1 0F94 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @0F94 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F95: // Incoming jump from 0x0F7C, if stack[-1] 0F95 5B JUMPDEST 0F96 60 PUSH1 0x00 0F98 61 PUSH2 0x0f9f 0F9B 61 PUSH2 0x16fa 0F9E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F96 stack[0] = 0x00 // @0F98 stack[1] = 0x0f9f // } // Block ends with unconditional jump to 0x16fa 0F9F 5B JUMPDEST 0FA0 90 SWAP1 0FA1 50 POP 0FA2 80 DUP1 0FA3 51 MLOAD 0FA4 60 PUSH1 0x00 0FA6 03 SUB 0FA7 61 PUSH2 0x0fbf 0FAA 57 *JUMPI 0FAB 60 PUSH1 0x40 0FAD 51 MLOAD 0FAE 80 DUP1 0FAF 60 PUSH1 0x20 0FB1 01 ADD 0FB2 60 PUSH1 0x40 0FB4 52 MSTORE 0FB5 80 DUP1 0FB6 60 PUSH1 0x00 0FB8 81 DUP2 0FB9 52 MSTORE 0FBA 50 POP 0FBB 61 PUSH2 0x0df5 0FBE 56 *JUMP 0FBF 5B JUMPDEST 0FC0 80 DUP1 0FC1 61 PUSH2 0x0fc9 0FC4 84 DUP5 0FC5 61 PUSH2 0x1709 0FC8 56 *JUMP 0FC9 5B JUMPDEST 0FCA 60 PUSH1 0x40 0FCC 51 MLOAD 0FCD 60 PUSH1 0x20 0FCF 01 ADD 0FD0 61 PUSH2 0x0fda 0FD3 92 SWAP3 0FD4 91 SWAP2 0FD5 90 SWAP1 0FD6 61 PUSH2 0x1fec 0FD9 56 *JUMP 0FDA 5B JUMPDEST 0FDB 60 PUSH1 0x40 0FDD 51 MLOAD 0FDE 60 PUSH1 0x20 0FE0 81 DUP2 0FE1 83 DUP4 0FE2 03 SUB 0FE3 03 SUB 0FE4 81 DUP2 0FE5 52 MSTORE 0FE6 90 SWAP1 0FE7 60 PUSH1 0x40 0FE9 52 MSTORE 0FEA 93 SWAP4 0FEB 92 SWAP3 0FEC 50 POP 0FED 50 POP 0FEE 50 POP 0FEF 56 *JUMP label_0FF0: // Incoming jump from 0x060F 0FF0 5B JUMPDEST 0FF1 61 PUSH2 0x0ff8 0FF4 61 PUSH2 0x13c1 0FF7 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FF1 stack[0] = 0x0ff8 } // Block ends with call to 0x13c1, returns to 0x0FF8 label_0FF8: // Incoming return from call to 0x13C1 at 0x0FF7 // Inputs[1] { @1001 stack[-1] } 0FF8 5B JUMPDEST 0FF9 60 PUSH1 0x01 0FFB 60 PUSH1 0x01 0FFD 60 PUSH1 0xa0 0FFF 1B SHL 1000 03 SUB 1001 81 DUP2 1002 16 AND 1003 61 PUSH2 0x1062 1006 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1062, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1007: // Incoming jump from 0x1006, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1009 memory[0x40:0x60] } 1007 60 PUSH1 0x40 1009 51 MLOAD 100A 62 PUSH3 0x461bcd 100E 60 PUSH1 0xe5 1010 1B SHL 1011 81 DUP2 1012 52 MSTORE 1013 60 PUSH1 0x20 1015 60 PUSH1 0x04 1017 82 DUP3 1018 01 ADD 1019 52 MSTORE 101A 60 PUSH1 0x26 101C 60 PUSH1 0x24 101E 82 DUP3 101F 01 ADD 1020 52 MSTORE 1021 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1042 60 PUSH1 0x44 1044 82 DUP3 1045 01 ADD 1046 52 MSTORE 1047 65 PUSH6 0x646472657373 104E 60 PUSH1 0xd0 1050 1B SHL 1051 60 PUSH1 0x64 1053 82 DUP3 1054 01 ADD 1055 52 MSTORE 1056 60 PUSH1 0x84 1058 01 ADD // Stack delta = +1 // Outputs[6] // { // @1012 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1019 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1020 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1046 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1055 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1058 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_1059: // Incoming jump from 0x118F // Incoming jump from 0x141F // Incoming jump from 0x1058 // Inputs[3] // { // @105C memory[0x40:0x60] // @105E stack[-1] // @1061 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1059 5B JUMPDEST 105A 60 PUSH1 0x40 105C 51 MLOAD 105D 80 DUP1 105E 91 SWAP2 105F 03 SUB 1060 90 SWAP1 1061 FD *REVERT // Stack delta = -1 // Outputs[1] { @1061 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1062: // Incoming jump from 0x1006, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1066 stack[-1] } 1062 5B JUMPDEST 1063 61 PUSH2 0x0903 1066 81 DUP2 1067 61 PUSH2 0x1587 106A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1063 stack[0] = 0x0903 // @1066 stack[1] = stack[-1] // } // Block ends with call to 0x1587, returns to 0x0903 label_106B: // Incoming jump from 0x062F 106B 5B JUMPDEST 106C 61 PUSH2 0x1073 106F 61 PUSH2 0x13c1 1072 56 *JUMP // Stack delta = +1 // Outputs[1] { @106C stack[0] = 0x1073 } // Block ends with call to 0x13c1, returns to 0x1073 label_1073: // Incoming return from call to 0x13C1 at 0x1072 // Inputs[5] // { // @1077 storage[0x0a] // @108A stack[-2] // @1092 stack[-1] // @1098 storage[0x0d] // @10A6 stack[-3] // } 1073 5B JUMPDEST 1074 60 PUSH1 0x0a 1076 80 DUP1 1077 54 SLOAD 1078 60 PUSH1 0x01 107A 60 PUSH1 0x01 107C 60 PUSH1 0xa0 107E 1B SHL 107F 03 SUB 1080 19 NOT 1081 16 AND 1082 60 PUSH1 0x01 1084 60 PUSH1 0x01 1086 60 PUSH1 0xa0 1088 1B SHL 1089 03 SUB 108A 93 SWAP4 108B 90 SWAP1 108C 93 SWAP4 108D 16 AND 108E 92 SWAP3 108F 90 SWAP1 1090 92 SWAP3 1091 17 OR 1092 90 SWAP1 1093 91 SWAP2 1094 55 SSTORE 1095 60 PUSH1 0x0d 1097 80 DUP1 1098 54 SLOAD 1099 60 PUSH1 0xff 109B 19 NOT 109C 16 AND 109D 91 SWAP2 109E 15 ISZERO 109F 15 ISZERO 10A0 91 SWAP2 10A1 90 SWAP1 10A2 91 SWAP2 10A3 17 OR 10A4 90 SWAP1 10A5 55 SSTORE 10A6 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1094 storage[0x0a] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0a]) // @10A5 storage[0x0d] = !!stack[-1] | (~0xff & storage[0x0d]) // } // Block ends with unconditional jump to stack[-3] label_10A7: // Incoming call from 0x0F77, returns to 0x0F78 // Incoming call from 0x071E, returns to 0x071F // Inputs[2] // { // @10AB storage[0x00] // @10AC stack[-1] // } 10A7 5B JUMPDEST 10A8 60 PUSH1 0x00 10AA 80 DUP1 10AB 54 SLOAD 10AC 82 DUP3 10AD 10 LT 10AE 80 DUP1 10AF 15 ISZERO 10B0 61 PUSH2 0x067c 10B3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @10A8 stack[0] = 0x00 // @10AD stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x067c, if !(stack[-1] < storage[0x00]) label_10B4: // Incoming jump from 0x10B3, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @10B8 stack[-3] // @10C3 memory[0x00:0x40] // @10C4 storage[keccak256(memory[0x00:0x40])] // @10CC stack[-4] // } 10B4 50 POP 10B5 50 POP 10B6 60 PUSH1 0x00 10B8 90 SWAP1 10B9 81 DUP2 10BA 52 MSTORE 10BB 60 PUSH1 0x04 10BD 60 PUSH1 0x20 10BF 52 MSTORE 10C0 60 PUSH1 0x40 10C2 90 SWAP1 10C3 20 SHA3 10C4 54 SLOAD 10C5 60 PUSH1 0x01 10C7 60 PUSH1 0xe0 10C9 1B SHL 10CA 16 AND 10CB 15 ISZERO 10CC 90 SWAP1 10CD 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @10BA memory[0x00:0x20] = stack[-3] // @10BF memory[0x20:0x40] = 0x04 // @10CC stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_10CE: // Incoming call from 0x0E29, returns to 0x0E2A // Incoming call from 0x0761, returns to 0x0762 // Incoming call from 0x091F, returns to 0x0920 // Incoming call from 0x0E05, returns to 0x0E06 // Incoming call from 0x078A, returns to 0x078B // Inputs[1] { @10D1 storage[0x09] } 10CE 5B JUMPDEST 10CF 60 PUSH1 0x09 10D1 54 SLOAD 10D2 60 PUSH1 0x01 10D4 60 PUSH1 0x01 10D6 60 PUSH1 0xa0 10D8 1B SHL 10D9 03 SUB 10DA 16 AND 10DB 80 DUP1 10DC 15 ISZERO 10DD 80 DUP1 10DE 15 ISZERO 10DF 90 SWAP1 10E0 61 PUSH2 0x10f3 10E3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @10DA stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x09] // @10DF stack[1] = !!((0x01 << 0xa0) - 0x01 & storage[0x09]) // } // Block ends with conditional jump to 0x10f3, if !((0x01 << 0xa0) - 0x01 & storage[0x09]) label_10E4: // Incoming jump from 0x10E3, if not !((0x01 << 0xa0) - 0x01 & storage[0x09]) // Inputs[2] // { // @10E7 stack[-2] // @10F1 address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length // } 10E4 50 POP 10E5 60 PUSH1 0x00 10E7 81 DUP2 10E8 60 PUSH1 0x01 10EA 60 PUSH1 0x01 10EC 60 PUSH1 0xa0 10EE 1B SHL 10EF 03 SUB 10F0 16 AND 10F1 3B EXTCODESIZE 10F2 11 GT 10F3 5B JUMPDEST 10F4 15 ISZERO 10F5 61 PUSH2 0x0aea 10F8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0aea, if !(address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length > 0x00) label_10F9: // Incoming jump from 0x10F8, if not !(address((0x01 << 0xa0) - 0x01 & stack[-2]).code.length > 0x00) // Incoming jump from 0x10F8, if not !stack[-1] // Inputs[8] // { // @10FB memory[0x40:0x60] // @1106 address(this) // @1114 stack[-2] // @111C stack[-1] // @112C memory[0x40:0x60] // @1132 msg.gas // @1133 address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1133 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10F9 60 PUSH1 0x40 10FB 51 MLOAD 10FC 63 PUSH4 0x3185c44d 1101 60 PUSH1 0xe2 1103 1B SHL 1104 81 DUP2 1105 52 MSTORE 1106 30 ADDRESS 1107 60 PUSH1 0x04 1109 82 DUP3 110A 01 ADD 110B 52 MSTORE 110C 60 PUSH1 0x01 110E 60 PUSH1 0x01 1110 60 PUSH1 0xa0 1112 1B SHL 1113 03 SUB 1114 83 DUP4 1115 81 DUP2 1116 16 AND 1117 60 PUSH1 0x24 1119 83 DUP4 111A 01 ADD 111B 52 MSTORE 111C 82 DUP3 111D 16 AND 111E 90 SWAP1 111F 63 PUSH4 0xc6171134 1124 90 SWAP1 1125 60 PUSH1 0x44 1127 01 ADD 1128 60 PUSH1 0x20 112A 60 PUSH1 0x40 112C 51 MLOAD 112D 80 DUP1 112E 83 DUP4 112F 03 SUB 1130 81 DUP2 1131 86 DUP7 1132 5A GAS 1133 FA STATICCALL 1134 15 ISZERO 1135 80 DUP1 1136 15 ISZERO 1137 61 PUSH2 0x1144 113A 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @1105 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3185c44d << 0xe2 // @110B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @111B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @111E stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1124 stack[1] = 0xc6171134 // @1127 stack[2] = 0x44 + memory[0x40:0x60] // @1133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1134 stack[3] = !address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1144, if !!address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_113B: // Incoming jump from 0x113A, if not !!address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @113B returndata.length // @113F returndata[0x00:0x00 + returndata.length] // @1140 returndata.length // @1143 memory[0x00:0x00 + returndata.length] // } 113B 3D RETURNDATASIZE 113C 60 PUSH1 0x00 113E 80 DUP1 113F 3E RETURNDATACOPY 1140 3D RETURNDATASIZE 1141 60 PUSH1 0x00 1143 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @113F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1143 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1144: // Incoming jump from 0x113A, if !!address(stack[-1] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @114B memory[0x40:0x60] // @114C returndata.length // } 1144 5B JUMPDEST 1145 50 POP 1146 50 POP 1147 50 POP 1148 50 POP 1149 60 PUSH1 0x40 114B 51 MLOAD 114C 3D RETURNDATASIZE 114D 60 PUSH1 0x1f 114F 19 NOT 1150 60 PUSH1 0x1f 1152 82 DUP3 1153 01 ADD 1154 16 AND 1155 82 DUP3 1156 01 ADD 1157 80 DUP1 1158 60 PUSH1 0x40 115A 52 MSTORE 115B 50 POP 115C 81 DUP2 115D 01 ADD 115E 90 SWAP1 115F 61 PUSH2 0x1168 1162 91 SWAP2 1163 90 SWAP1 1164 61 PUSH2 0x201b 1167 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @115A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1162 stack[-4] = 0x1168 // @1163 stack[-2] = memory[0x40:0x60] // @1163 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x201b, returns to 0x1168 label_1168: // Incoming return from call to 0x201B at 0x1167 // Inputs[1] { @116C stack[-1] } 1168 5B JUMPDEST 1169 61 PUSH2 0x0aea 116C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0aea, if stack[-1] label_116D: // Incoming jump from 0x116C, if not stack[-1] // Inputs[2] // { // @116F memory[0x40:0x60] // @1182 stack[-2] // } 116D 60 PUSH1 0x40 116F 51 MLOAD 1170 63 PUSH4 0x3b79c773 1175 60 PUSH1 0xe2 1177 1B SHL 1178 81 DUP2 1179 52 MSTORE 117A 60 PUSH1 0x01 117C 60 PUSH1 0x01 117E 60 PUSH1 0xa0 1180 1B SHL 1181 03 SUB 1182 83 DUP4 1183 16 AND 1184 60 PUSH1 0x04 1186 82 DUP3 1187 01 ADD 1188 52 MSTORE 1189 60 PUSH1 0x24 118B 01 ADD 118C 61 PUSH2 0x1059 118F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1179 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b79c773 << 0xe2 // @1188 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @118B stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1059 label_1190: // Incoming call from 0x076B, returns to 0x076C // Inputs[1] { @1196 stack[-1] } 1190 5B JUMPDEST 1191 60 PUSH1 0x00 1193 61 PUSH2 0x119b 1196 82 DUP3 1197 61 PUSH2 0x0acb 119A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1191 stack[0] = 0x00 // @1193 stack[1] = 0x119b // @1196 stack[2] = stack[-1] // } // Block ends with call to 0x0acb, returns to 0x119B label_119B: // Incoming return from call to 0x0ACB at 0x119A // Inputs[3] // { // @119C stack[-1] // @119C stack[-2] // @119E msg.sender // } 119B 5B JUMPDEST 119C 90 SWAP1 119D 50 POP 119E 33 CALLER 119F 60 PUSH1 0x01 11A1 60 PUSH1 0x01 11A3 60 PUSH1 0xa0 11A5 1B SHL 11A6 03 SUB 11A7 82 DUP3 11A8 16 AND 11A9 14 EQ 11AA 61 PUSH2 0x11d4 11AD 57 *JUMPI // Stack delta = -1 // Outputs[1] { @119C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x11d4, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_11AE: // Incoming jump from 0x11AD, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @11B1 stack[-1] // @11B2 msg.sender // } 11AE 61 PUSH2 0x11b7 11B1 81 DUP2 11B2 33 CALLER 11B3 61 PUSH2 0x05a1 11B6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11AE stack[0] = 0x11b7 // @11B1 stack[1] = stack[-1] // @11B2 stack[2] = msg.sender // } // Block ends with call to 0x05a1, returns to 0x11B7 label_11B7: // Incoming return from call to 0x05A1 at 0x11B6 // Inputs[1] { @11BB stack[-1] } 11B7 5B JUMPDEST 11B8 61 PUSH2 0x11d4 11BB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11d4, if stack[-1] label_11BC: // Incoming jump from 0x11BB, if not stack[-1] // Inputs[3] // { // @11BE memory[0x40:0x60] // @11CE memory[0x40:0x60] // @11D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11BC 60 PUSH1 0x40 11BE 51 MLOAD 11BF 63 PUSH4 0x67d9dca1 11C4 60 PUSH1 0xe1 11C6 1B SHL 11C7 81 DUP2 11C8 52 MSTORE 11C9 60 PUSH1 0x04 11CB 01 ADD 11CC 60 PUSH1 0x40 11CE 51 MLOAD 11CF 80 DUP1 11D0 91 SWAP2 11D1 03 SUB 11D2 90 SWAP1 11D3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @11D3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11D4: // Incoming jump from 0x11AD, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x11BB, if stack[-1] // Inputs[8] // { // @11D7 stack[-2] // @11E3 memory[0x00:0x40] // @11E5 storage[keccak256(memory[0x00:0x40])] // @11F8 stack[-3] // @1202 memory[0x40:0x60] // @1206 stack[-1] // @122B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @122F stack[-4] // } 11D4 5B JUMPDEST 11D5 60 PUSH1 0x00 11D7 82 DUP3 11D8 81 DUP2 11D9 52 MSTORE 11DA 60 PUSH1 0x06 11DC 60 PUSH1 0x20 11DE 52 MSTORE 11DF 60 PUSH1 0x40 11E1 80 DUP1 11E2 82 DUP3 11E3 20 SHA3 11E4 80 DUP1 11E5 54 SLOAD 11E6 60 PUSH1 0x01 11E8 60 PUSH1 0x01 11EA 60 PUSH1 0xa0 11EC 1B SHL 11ED 03 SUB 11EE 19 NOT 11EF 16 AND 11F0 60 PUSH1 0x01 11F2 60 PUSH1 0x01 11F4 60 PUSH1 0xa0 11F6 1B SHL 11F7 03 SUB 11F8 87 DUP8 11F9 81 DUP2 11FA 16 AND 11FB 91 SWAP2 11FC 82 DUP3 11FD 17 OR 11FE 90 SWAP1 11FF 92 SWAP3 1200 55 SSTORE 1201 91 SWAP2 1202 51 MLOAD 1203 85 DUP6 1204 93 SWAP4 1205 91 SWAP2 1206 85 DUP6 1207 16 AND 1208 91 SWAP2 1209 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 122A 91 SWAP2 122B A4 LOG4 122C 50 POP 122D 50 POP 122E 50 POP 122F 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @11D9 memory[0x00:0x20] = stack[-2] // @11DE memory[0x20:0x40] = 0x06 // @1200 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @122B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1230: // Incoming jump from 0x0795 // Inputs[1] { @1236 stack[-1] } 1230 5B JUMPDEST 1231 60 PUSH1 0x00 1233 61 PUSH2 0x123b 1236 82 DUP3 1237 61 PUSH2 0x1520 123A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1231 stack[0] = 0x00 // @1233 stack[1] = 0x123b // @1236 stack[2] = stack[-1] // } // Block ends with call to 0x1520, returns to 0x123B label_123B: // Incoming return from call to 0x1520 at 0x123A // Inputs[3] // { // @123C stack[-1] // @123C stack[-2] // @123E stack[-5] // } 123B 5B JUMPDEST 123C 90 SWAP1 123D 50 POP 123E 83 DUP4 123F 60 PUSH1 0x01 1241 60 PUSH1 0x01 1243 60 PUSH1 0xa0 1245 1B SHL 1246 03 SUB 1247 16 AND 1248 81 DUP2 1249 60 PUSH1 0x01 124B 60 PUSH1 0x01 124D 60 PUSH1 0xa0 124F 1B SHL 1250 03 SUB 1251 16 AND 1252 14 EQ 1253 61 PUSH2 0x126e 1256 57 *JUMPI // Stack delta = -1 // Outputs[1] { @123C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x126e, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1257: // Incoming jump from 0x1256, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @1259 memory[0x40:0x60] // @1268 memory[0x40:0x60] // @126D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1257 60 PUSH1 0x40 1259 51 MLOAD 125A 62 PUSH3 0xa11481 125E 60 PUSH1 0xe8 1260 1B SHL 1261 81 DUP2 1262 52 MSTORE 1263 60 PUSH1 0x04 1265 01 ADD 1266 60 PUSH1 0x40 1268 51 MLOAD 1269 80 DUP1 126A 91 SWAP2 126B 03 SUB 126C 90 SWAP1 126D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1262 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @126D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_126E: // Incoming jump from 0x1256, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @1271 stack[-2] // @127C memory[0x00:0x40] // @127E storage[keccak256(memory[0x00:0x40])] // @1283 stack[-4] // @1284 msg.sender // } 126E 5B JUMPDEST 126F 60 PUSH1 0x00 1271 82 DUP3 1272 81 DUP2 1273 52 MSTORE 1274 60 PUSH1 0x06 1276 60 PUSH1 0x20 1278 52 MSTORE 1279 60 PUSH1 0x40 127B 90 SWAP1 127C 20 SHA3 127D 80 DUP1 127E 54 SLOAD 127F 61 PUSH2 0x129a 1282 81 DUP2 1283 87 DUP8 1284 33 CALLER // Stack delta = +6 // Outputs[8] // { // @1273 memory[0x00:0x20] = stack[-2] // @1278 memory[0x20:0x40] = 0x06 // @127C stack[0] = keccak256(memory[0x00:0x40]) // @127E stack[1] = storage[keccak256(memory[0x00:0x40])] // @127F stack[2] = 0x129a // @1282 stack[3] = storage[keccak256(memory[0x00:0x40])] // @1283 stack[4] = stack[-4] // @1284 stack[5] = msg.sender // } // Block continues label_1285: // Incoming jump from 0x1284 // Incoming call from 0x178A, returns to 0x178B // Inputs[4] // { // @128E stack[-1] // @1291 stack[-2] // @1295 stack[-3] // @1298 stack[-4] // } 1285 5B JUMPDEST 1286 60 PUSH1 0x01 1288 60 PUSH1 0x01 128A 60 PUSH1 0xa0 128C 1B SHL 128D 03 SUB 128E 90 SWAP1 128F 81 DUP2 1290 16 AND 1291 91 SWAP2 1292 16 AND 1293 81 DUP2 1294 14 EQ 1295 91 SWAP2 1296 14 EQ 1297 17 OR 1298 90 SWAP1 1299 56 *JUMP // Stack delta = -3 // Outputs[1] { @1298 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] 129A 5B JUMPDEST 129B 61 PUSH2 0x12c5 129E 57 *JUMPI 129F 61 PUSH2 0x12a8 12A2 86 DUP7 12A3 33 CALLER 12A4 61 PUSH2 0x05a1 12A7 56 *JUMP 12A8 5B JUMPDEST 12A9 61 PUSH2 0x12c5 12AC 57 *JUMPI 12AD 60 PUSH1 0x40 12AF 51 MLOAD 12B0 63 PUSH4 0x2ce44b5f 12B5 60 PUSH1 0xe1 12B7 1B SHL 12B8 81 DUP2 12B9 52 MSTORE 12BA 60 PUSH1 0x04 12BC 01 ADD 12BD 60 PUSH1 0x40 12BF 51 MLOAD 12C0 80 DUP1 12C1 91 SWAP2 12C2 03 SUB 12C3 90 SWAP1 12C4 FD *REVERT 12C5 5B JUMPDEST 12C6 60 PUSH1 0x01 12C8 60 PUSH1 0x01 12CA 60 PUSH1 0xa0 12CC 1B SHL 12CD 03 SUB 12CE 85 DUP6 12CF 16 AND 12D0 61 PUSH2 0x12ec 12D3 57 *JUMPI 12D4 60 PUSH1 0x40 12D6 51 MLOAD 12D7 63 PUSH4 0x3a954ecd 12DC 60 PUSH1 0xe2 12DE 1B SHL 12DF 81 DUP2 12E0 52 MSTORE 12E1 60 PUSH1 0x04 12E3 01 ADD 12E4 60 PUSH1 0x40 12E6 51 MLOAD 12E7 80 DUP1 12E8 91 SWAP2 12E9 03 SUB 12EA 90 SWAP1 12EB FD *REVERT 12EC 5B JUMPDEST 12ED 80 DUP1 12EE 15 ISZERO 12EF 61 PUSH2 0x12f7 12F2 57 *JUMPI 12F3 60 PUSH1 0x00 12F5 82 DUP3 12F6 55 SSTORE 12F7 5B JUMPDEST 12F8 60 PUSH1 0x01 12FA 60 PUSH1 0x01 12FC 60 PUSH1 0xa0 12FE 1B SHL 12FF 03 SUB 1300 86 DUP7 1301 81 DUP2 1302 16 AND 1303 60 PUSH1 0x00 1305 90 SWAP1 1306 81 DUP2 1307 52 MSTORE 1308 60 PUSH1 0x05 130A 60 PUSH1 0x20 130C 52 MSTORE 130D 60 PUSH1 0x40 130F 80 DUP1 1310 82 DUP3 1311 20 SHA3 1312 80 DUP1 1313 54 SLOAD 1314 60 PUSH1 0x00 1316 19 NOT 1317 01 ADD 1318 90 SWAP1 1319 55 SSTORE 131A 91 SWAP2 131B 87 DUP8 131C 16 AND 131D 80 DUP1 131E 82 DUP3 131F 52 MSTORE 1320 91 SWAP2 1321 90 SWAP1 1322 20 SHA3 1323 80 DUP1 1324 54 SLOAD 1325 60 PUSH1 0x01 1327 01 ADD 1328 90 SWAP1 1329 55 SSTORE 132A 42 TIMESTAMP 132B 60 PUSH1 0xa0 132D 1B SHL 132E 17 OR 132F 60 PUSH1 0x01 1331 60 PUSH1 0xe1 1333 1B SHL 1334 17 OR 1335 60 PUSH1 0x00 1337 85 DUP6 1338 81 DUP2 1339 52 MSTORE 133A 60 PUSH1 0x04 133C 60 PUSH1 0x20 133E 52 MSTORE 133F 60 PUSH1 0x40 1341 81 DUP2 1342 20 SHA3 1343 91 SWAP2 1344 90 SWAP1 1345 91 SWAP2 1346 55 SSTORE 1347 60 PUSH1 0x01 1349 60 PUSH1 0xe1 134B 1B SHL 134C 84 DUP5 134D 16 AND 134E 90 SWAP1 134F 03 SUB 1350 61 PUSH2 0x1389 1353 57 *JUMPI 1354 60 PUSH1 0x01 1356 84 DUP5 1357 01 ADD 1358 60 PUSH1 0x00 135A 81 DUP2 135B 81 DUP2 135C 52 MSTORE 135D 60 PUSH1 0x04 135F 60 PUSH1 0x20 1361 52 MSTORE 1362 60 PUSH1 0x40 1364 81 DUP2 1365 20 SHA3 1366 54 SLOAD 1367 90 SWAP1 1368 03 SUB 1369 61 PUSH2 0x1387 136C 57 *JUMPI 136D 60 PUSH1 0x00 136F 54 SLOAD 1370 81 DUP2 1371 14 EQ 1372 61 PUSH2 0x1387 1375 57 *JUMPI 1376 60 PUSH1 0x00 1378 81 DUP2 1379 81 DUP2 137A 52 MSTORE 137B 60 PUSH1 0x04 137D 60 PUSH1 0x20 137F 52 MSTORE 1380 60 PUSH1 0x40 1382 90 SWAP1 1383 20 SHA3 1384 84 DUP5 1385 90 SWAP1 1386 55 SSTORE 1387 5B JUMPDEST 1388 50 POP 1389 5B JUMPDEST 138A 83 DUP4 138B 85 DUP6 138C 60 PUSH1 0x01 138E 60 PUSH1 0x01 1390 60 PUSH1 0xa0 1392 1B SHL 1393 03 SUB 1394 16 AND 1395 87 DUP8 1396 60 PUSH1 0x01 1398 60 PUSH1 0x01 139A 60 PUSH1 0xa0 139C 1B SHL 139D 03 SUB 139E 16 AND 139F 60 PUSH1 0x00 13A1 80 DUP1 13A2 51 MLOAD 13A3 60 PUSH1 0x20 13A5 61 PUSH2 0x2093 13A8 83 DUP4 13A9 39 CODECOPY 13AA 81 DUP2 13AB 51 MLOAD 13AC 91 SWAP2 13AD 52 MSTORE 13AE 60 PUSH1 0x40 13B0 51 MLOAD 13B1 60 PUSH1 0x40 13B3 51 MLOAD 13B4 80 DUP1 13B5 91 SWAP2 13B6 03 SUB 13B7 90 SWAP1 13B8 A4 LOG4 label_13B9: // Incoming jump from 0x1F8E // Incoming jump from 0x1F21, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1F8E // Incoming jump from 0x1F21, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x1F21, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[1] { @13C0 stack[-7] } 13B9 5B JUMPDEST 13BA 50 POP 13BB 50 POP 13BC 50 POP 13BD 50 POP 13BE 50 POP 13BF 50 POP 13C0 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_13C1: // Incoming call from 0x1072, returns to 0x1073 // Incoming call from 0x08AD, returns to 0x08AE // Incoming call from 0x0B44, returns to 0x0B45 // Incoming call from 0x0ADD, returns to 0x0ADE // Incoming call from 0x0FF7, returns to 0x0FF8 // Incoming call from 0x07A3, returns to 0x07A4 // Inputs[1] { @13C2 msg.sender } 13C1 5B JUMPDEST 13C2 33 CALLER 13C3 61 PUSH2 0x13ca 13C6 61 PUSH2 0x0c5a 13C9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13C2 stack[0] = msg.sender // @13C3 stack[1] = 0x13ca // } // Block ends with call to 0x0c5a, returns to 0x13CA label_13CA: // Incoming return from call to 0x0C5A at 0x13C9 // Inputs[2] // { // @13D3 stack[-1] // @13D4 stack[-2] // } 13CA 5B JUMPDEST 13CB 60 PUSH1 0x01 13CD 60 PUSH1 0x01 13CF 60 PUSH1 0xa0 13D1 1B SHL 13D2 03 SUB 13D3 16 AND 13D4 14 EQ 13D5 61 PUSH2 0x0b4f 13D8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0b4f, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_13D9: // Incoming jump from 0x13D8, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @13DB memory[0x40:0x60] } 13D9 60 PUSH1 0x40 13DB 51 MLOAD 13DC 62 PUSH3 0x461bcd 13E0 60 PUSH1 0xe5 13E2 1B SHL 13E3 81 DUP2 13E4 52 MSTORE 13E5 60 PUSH1 0x20 13E7 60 PUSH1 0x04 13E9 82 DUP3 13EA 01 ADD 13EB 81 DUP2 13EC 90 SWAP1 13ED 52 MSTORE 13EE 60 PUSH1 0x24 13F0 82 DUP3 13F1 01 ADD 13F2 52 MSTORE 13F3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1414 60 PUSH1 0x44 1416 82 DUP3 1417 01 ADD 1418 52 MSTORE 1419 60 PUSH1 0x64 141B 01 ADD 141C 61 PUSH2 0x1059 141F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13ED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13F2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1418 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @141B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1059 label_1420: // Incoming jump from 0x0805 // Inputs[2] // { // @1424 storage[0x00] // @1426 stack[-1] // } 1420 5B JUMPDEST 1421 60 PUSH1 0x00 1423 80 DUP1 1424 54 SLOAD 1425 90 SWAP1 1426 82 DUP3 1427 90 SWAP1 1428 03 SUB 1429 61 PUSH2 0x1445 142C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1425 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1445, if 0x00 - stack[-1] label_142D: // Incoming jump from 0x142C, if not 0x00 - stack[-1] // Inputs[3] // { // @142F memory[0x40:0x60] // @143F memory[0x40:0x60] // @1444 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 142D 60 PUSH1 0x40 142F 51 MLOAD 1430 63 PUSH4 0xb562e8dd 1435 60 PUSH1 0xe0 1437 1B SHL 1438 81 DUP2 1439 52 MSTORE 143A 60 PUSH1 0x04 143C 01 ADD 143D 60 PUSH1 0x40 143F 51 MLOAD 1440 80 DUP1 1441 91 SWAP2 1442 03 SUB 1443 90 SWAP1 1444 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1439 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1444 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1445: // Incoming jump from 0x142C, if 0x00 - stack[-1] // Inputs[10] // { // @144E stack[-3] // @1460 memory[0x00:0x40] // @1462 storage[keccak256(memory[0x00:0x40])] // @146D stack[-2] // @1472 stack[-1] // @147B memory[0x00:0x40] // @1483 block.timestamp // @1497 memory[0x00:0x20] // @14A0 memory[0x00:0x20] // @14A5 memory[0x00:0x00] // } 1445 5B JUMPDEST 1446 60 PUSH1 0x01 1448 60 PUSH1 0x01 144A 60 PUSH1 0xa0 144C 1B SHL 144D 03 SUB 144E 83 DUP4 144F 16 AND 1450 60 PUSH1 0x00 1452 81 DUP2 1453 81 DUP2 1454 52 MSTORE 1455 60 PUSH1 0x05 1457 60 PUSH1 0x20 1459 90 SWAP1 145A 81 DUP2 145B 52 MSTORE 145C 60 PUSH1 0x40 145E 80 DUP1 145F 83 DUP4 1460 20 SHA3 1461 80 DUP1 1462 54 SLOAD 1463 68 PUSH9 0x010000000000000001 146D 88 DUP9 146E 02 MUL 146F 01 ADD 1470 90 SWAP1 1471 55 SSTORE 1472 84 DUP5 1473 83 DUP4 1474 52 MSTORE 1475 60 PUSH1 0x04 1477 90 SWAP1 1478 91 SWAP2 1479 52 MSTORE 147A 81 DUP2 147B 20 SHA3 147C 60 PUSH1 0x01 147E 85 DUP6 147F 14 EQ 1480 60 PUSH1 0xe1 1482 1B SHL 1483 42 TIMESTAMP 1484 60 PUSH1 0xa0 1486 1B SHL 1487 17 OR 1488 83 DUP4 1489 17 OR 148A 90 SWAP1 148B 55 SSTORE 148C 82 DUP3 148D 84 DUP5 148E 01 ADD 148F 90 SWAP1 1490 83 DUP4 1491 90 SWAP1 1492 83 DUP4 1493 90 SWAP1 1494 60 PUSH1 0x00 1496 80 DUP1 1497 51 MLOAD 1498 60 PUSH1 0x20 149A 61 PUSH2 0x2093 149D 83 DUP4 149E 39 CODECOPY 149F 81 DUP2 14A0 51 MLOAD 14A1 91 SWAP2 14A2 52 MSTORE 14A3 81 DUP2 14A4 80 DUP1 14A5 A4 LOG4 14A6 60 PUSH1 0x01 14A8 83 DUP4 14A9 01 ADD 14AA 5B JUMPDEST 14AB 81 DUP2 14AC 81 DUP2 14AD 14 EQ 14AE 61 PUSH2 0x14d0 14B1 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @144F stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1454 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @145B memory[0x20:0x40] = 0x05 // @1471 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1474 memory[0x00:0x20] = stack[-1] // @1479 memory[0x20:0x40] = 0x04 // @148B storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @148F stack[1] = stack[-2] + stack[-1] // @149E memory[0x00:0x20] = code[0x2093:0x20b3] // @14A2 memory[0x00:0x20] = memory[0x00:0x20] // @14A5 log(memory[0x00:0x00], [memory[0x00:0x20], 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @14A9 stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x14d0, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_14B2: // Incoming jump from 0x14B1, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x14B1, if not stack[-1] == stack[-2] // Inputs[5] // { // @14B2 stack[-1] // @14B3 stack[-3] // @14B9 memory[0x00:0x20] // @14C2 memory[0x00:0x20] // @14C8 memory[0x00:0x00] // } 14B2 80 DUP1 14B3 83 DUP4 14B4 60 PUSH1 0x00 14B6 60 PUSH1 0x00 14B8 80 DUP1 14B9 51 MLOAD 14BA 60 PUSH1 0x20 14BC 61 PUSH2 0x2093 14BF 83 DUP4 14C0 39 CODECOPY 14C1 81 DUP2 14C2 51 MLOAD 14C3 91 SWAP2 14C4 52 MSTORE 14C5 60 PUSH1 0x00 14C7 80 DUP1 14C8 A4 LOG4 14C9 60 PUSH1 0x01 14CB 01 ADD 14CC 61 PUSH2 0x14aa 14CF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @14C0 memory[0x00:0x20] = code[0x2093:0x20b3] // @14C4 memory[0x00:0x20] = memory[0x00:0x20] // @14C8 log(memory[0x00:0x00], [memory[0x00:0x20], 0x00, stack[-3], stack[-1]]); // @14CB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x14aa label_14D0: // Incoming jump from 0x14B1, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x14B1, if stack[-1] == stack[-2] // Inputs[1] { @14D2 stack[-3] } 14D0 5B JUMPDEST 14D1 50 POP 14D2 81 DUP2 14D3 60 PUSH1 0x00 14D5 03 SUB 14D6 61 PUSH2 0x14f1 14D9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14f1, if 0x00 - stack[-3] label_14DA: // Incoming jump from 0x14D9, if not 0x00 - stack[-3] // Inputs[3] // { // @14DC memory[0x40:0x60] // @14EB memory[0x40:0x60] // @14F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 14DA 60 PUSH1 0x40 14DC 51 MLOAD 14DD 62 PUSH3 0x2e0763 14E1 60 PUSH1 0xe8 14E3 1B SHL 14E4 81 DUP2 14E5 52 MSTORE 14E6 60 PUSH1 0x04 14E8 01 ADD 14E9 60 PUSH1 0x40 14EB 51 MLOAD 14EC 80 DUP1 14ED 91 SWAP2 14EE 03 SUB 14EF 90 SWAP1 14F0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @14F0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_14F1: // Incoming jump from 0x14D9, if 0x00 - stack[-3] // Inputs[2] // { // @14F4 stack[-1] // @14F9 stack[-6] // } 14F1 5B JUMPDEST 14F2 60 PUSH1 0x00 14F4 55 SSTORE 14F5 50 POP 14F6 50 POP 14F7 50 POP 14F8 50 POP 14F9 56 *JUMP // Stack delta = -6 // Outputs[1] { @14F4 storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_14FA: // Incoming jump from 0x092A // Inputs[4] // { // @14FE stack[-3] // @14FF stack[-2] // @1500 stack[-1] // @1503 memory[0x40:0x60] // } 14FA 5B JUMPDEST 14FB 61 PUSH2 0x076c 14FE 83 DUP4 14FF 83 DUP4 1500 83 DUP4 1501 60 PUSH1 0x40 1503 51 MLOAD 1504 80 DUP1 1505 60 PUSH1 0x20 1507 01 ADD 1508 60 PUSH1 0x40 150A 52 MSTORE 150B 80 DUP1 150C 60 PUSH1 0x00 150E 81 DUP2 150F 52 MSTORE 1510 50 POP 1511 61 PUSH2 0x0e10 1514 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @14FB stack[0] = 0x076c // @14FE stack[1] = stack[-3] // @14FF stack[2] = stack[-2] // @1500 stack[3] = stack[-1] // @1503 stack[4] = memory[0x40:0x60] // @150A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @150F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0e10 label_1515: // Incoming jump from 0x0959 // Inputs[1] { @1519 stack[-1] } 1515 5B JUMPDEST 1516 61 PUSH2 0x0903 1519 81 DUP2 151A 60 PUSH1 0x00 151C 61 PUSH2 0x174d 151F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1516 stack[0] = 0x0903 // @1519 stack[1] = stack[-1] // @151A stack[2] = 0x00 // } // Block ends with call to 0x174d, returns to 0x0903 label_1520: // Incoming call from 0x16F4, returns to 0x16F5 // Incoming call from 0x123A, returns to 0x123B // Incoming call from 0x0AD5, returns to 0x067C // Incoming call from 0x1757, returns to 0x1758 // Inputs[2] // { // @1523 stack[-1] // @1526 storage[0x00] // } 1520 5B JUMPDEST 1521 60 PUSH1 0x00 1523 81 DUP2 1524 60 PUSH1 0x00 1526 54 SLOAD 1527 81 DUP2 1528 10 LT 1529 15 ISZERO 152A 61 PUSH2 0x156e 152D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1521 stack[0] = 0x00 // @1523 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x156e, if !(stack[-1] < storage[0x00]) label_152E: // Incoming jump from 0x152D, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1530 stack[-1] // @153B memory[0x00:0x40] // @153C storage[keccak256(memory[0x00:0x40])] // } 152E 60 PUSH1 0x00 1530 81 DUP2 1531 81 DUP2 1532 52 MSTORE 1533 60 PUSH1 0x04 1535 60 PUSH1 0x20 1537 52 MSTORE 1538 60 PUSH1 0x40 153A 81 DUP2 153B 20 SHA3 153C 54 SLOAD 153D 90 SWAP1 153E 60 PUSH1 0x01 1540 60 PUSH1 0xe0 1542 1B SHL 1543 82 DUP3 1544 16 AND 1545 90 SWAP1 1546 03 SUB 1547 61 PUSH2 0x156c 154A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1532 memory[0x00:0x20] = stack[-1] // @1537 memory[0x20:0x40] = 0x04 // @153D stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x156c, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_154B: // Incoming jump from 0x156B // Incoming jump from 0x154A, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Inputs[1] { @154C stack[-1] } 154B 5B JUMPDEST 154C 80 DUP1 154D 60 PUSH1 0x00 154F 03 SUB 1550 61 PUSH2 0x0df5 1553 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df5, if 0x00 - stack[-1] label_1554: // Incoming jump from 0x1553, if not 0x00 - stack[-1] // Inputs[3] // { // @1558 stack[-2] // @1566 memory[0x00:0x40] // @1567 storage[keccak256(memory[0x00:0x40])] // } 1554 50 POP 1555 60 PUSH1 0x00 1557 19 NOT 1558 01 ADD 1559 60 PUSH1 0x00 155B 81 DUP2 155C 81 DUP2 155D 52 MSTORE 155E 60 PUSH1 0x04 1560 60 PUSH1 0x20 1562 52 MSTORE 1563 60 PUSH1 0x40 1565 90 SWAP1 1566 20 SHA3 1567 54 SLOAD 1568 61 PUSH2 0x154b 156B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1558 stack[-2] = ~0x00 + stack[-2] // @155D memory[0x00:0x20] = ~0x00 + stack[-2] // @1562 memory[0x20:0x40] = 0x04 // @1567 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x154b label_156C: // Incoming jump from 0x154A, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 156C 5B JUMPDEST 156D 50 POP // Stack delta = -1 // Block continues label_156E: // Incoming jump from 0x152D, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x156D // Inputs[3] // { // @1571 memory[0x40:0x60] // @1581 memory[0x40:0x60] // @1586 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 156E 5B JUMPDEST 156F 60 PUSH1 0x40 1571 51 MLOAD 1572 63 PUSH4 0x6f96cda1 1577 60 PUSH1 0xe1 1579 1B SHL 157A 81 DUP2 157B 52 MSTORE 157C 60 PUSH1 0x04 157E 01 ADD 157F 60 PUSH1 0x40 1581 51 MLOAD 1582 80 DUP1 1583 91 SWAP2 1584 03 SUB 1585 90 SWAP1 1586 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @157B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1586 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1587: // Incoming call from 0x106A, returns to 0x0903 // Incoming call from 0x0B4E, returns to 0x0B4F // Inputs[5] // { // @158B storage[0x08] // @1594 stack[-1] // @15A9 memory[0x40:0x60] // @15D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @15D8 stack[-2] // } 1587 5B JUMPDEST 1588 60 PUSH1 0x08 158A 80 DUP1 158B 54 SLOAD 158C 60 PUSH1 0x01 158E 60 PUSH1 0x01 1590 60 PUSH1 0xa0 1592 1B SHL 1593 03 SUB 1594 83 DUP4 1595 81 DUP2 1596 16 AND 1597 60 PUSH1 0x01 1599 60 PUSH1 0x01 159B 60 PUSH1 0xa0 159D 1B SHL 159E 03 SUB 159F 19 NOT 15A0 83 DUP4 15A1 16 AND 15A2 81 DUP2 15A3 17 OR 15A4 90 SWAP1 15A5 93 SWAP4 15A6 55 SSTORE 15A7 60 PUSH1 0x40 15A9 51 MLOAD 15AA 91 SWAP2 15AB 16 AND 15AC 91 SWAP2 15AD 90 SWAP1 15AE 82 DUP3 15AF 90 SWAP1 15B0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 15D1 90 SWAP1 15D2 60 PUSH1 0x00 15D4 90 SWAP1 15D5 A3 LOG3 15D6 50 POP 15D7 50 POP 15D8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @15A6 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @15D5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_15D9: // Incoming call from 0x0BE6, returns to 0x0BE7 // Incoming call from 0x0D81, returns to 0x0D82 // Incoming call from 0x0F51, returns to 0x0F52 // Inputs[4] // { // @15DD memory[0x40:0x60] // @1600 stack[-1] // @160B memory[0x00:0x40] // @160C storage[keccak256(memory[0x00:0x40])] // } 15D9 5B JUMPDEST 15DA 60 PUSH1 0x40 15DC 80 DUP1 15DD 51 MLOAD 15DE 60 PUSH1 0x80 15E0 81 DUP2 15E1 01 ADD 15E2 82 DUP3 15E3 52 MSTORE 15E4 60 PUSH1 0x00 15E6 80 DUP1 15E7 82 DUP3 15E8 52 MSTORE 15E9 60 PUSH1 0x20 15EB 82 DUP3 15EC 01 ADD 15ED 81 DUP2 15EE 90 SWAP1 15EF 52 MSTORE 15F0 91 SWAP2 15F1 81 DUP2 15F2 01 ADD 15F3 82 DUP3 15F4 90 SWAP1 15F5 52 MSTORE 15F6 60 PUSH1 0x60 15F8 81 DUP2 15F9 01 ADD 15FA 91 SWAP2 15FB 90 SWAP1 15FC 91 SWAP2 15FD 52 MSTORE 15FE 60 PUSH1 0x00 1600 82 DUP3 1601 81 DUP2 1602 52 MSTORE 1603 60 PUSH1 0x04 1605 60 PUSH1 0x20 1607 52 MSTORE 1608 60 PUSH1 0x40 160A 90 SWAP1 160B 20 SHA3 160C 54 SLOAD 160D 61 PUSH2 0x067c 1610 90 SWAP1 1611 61 PUSH2 0x1885 1614 56 *JUMP // Stack delta = +3 // Outputs[10] // { // @15E3 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @15E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @15EF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @15F5 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @15FC stack[0] = memory[0x40:0x60] // @15FD memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @1602 memory[0x00:0x20] = stack[-1] // @1607 memory[0x20:0x40] = 0x04 // @1610 stack[1] = 0x067c // @1610 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1885, returns to 0x067C label_1615: // Incoming call from 0x0E0F, returns to 0x076C // Inputs[10] // { // @1616 msg.sender // @1627 memory[0x00:0x40] // @1630 stack[-2] // @163B memory[0x00:0x40] // @163D storage[keccak256(memory[0x00:0x40])] // @1642 stack[-1] // @164C memory[0x40:0x60] // @1678 memory[0x40:0x60] // @167D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1680 stack[-3] // } 1615 5B JUMPDEST 1616 33 CALLER 1617 60 PUSH1 0x00 1619 81 DUP2 161A 81 DUP2 161B 52 MSTORE 161C 60 PUSH1 0x07 161E 60 PUSH1 0x20 1620 90 SWAP1 1621 81 DUP2 1622 52 MSTORE 1623 60 PUSH1 0x40 1625 80 DUP1 1626 83 DUP4 1627 20 SHA3 1628 60 PUSH1 0x01 162A 60 PUSH1 0x01 162C 60 PUSH1 0xa0 162E 1B SHL 162F 03 SUB 1630 87 DUP8 1631 16 AND 1632 80 DUP1 1633 85 DUP6 1634 52 MSTORE 1635 90 SWAP1 1636 83 DUP4 1637 52 MSTORE 1638 92 SWAP3 1639 81 DUP2 163A 90 SWAP1 163B 20 SHA3 163C 80 DUP1 163D 54 SLOAD 163E 60 PUSH1 0xff 1640 19 NOT 1641 16 AND 1642 86 DUP7 1643 15 ISZERO 1644 15 ISZERO 1645 90 SWAP1 1646 81 DUP2 1647 17 OR 1648 90 SWAP1 1649 91 SWAP2 164A 55 SSTORE 164B 90 SWAP1 164C 51 MLOAD 164D 90 SWAP1 164E 81 DUP2 164F 52 MSTORE 1650 91 SWAP2 1651 92 SWAP3 1652 91 SWAP2 1653 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1674 91 SWAP2 1675 01 ADD 1676 60 PUSH1 0x40 1678 51 MLOAD 1679 80 DUP1 167A 91 SWAP2 167B 03 SUB 167C 90 SWAP1 167D A3 LOG3 167E 50 POP 167F 50 POP 1680 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @161B memory[0x00:0x20] = msg.sender // @1622 memory[0x20:0x40] = 0x07 // @1634 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1637 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @164A storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @164F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @167D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_1681: // Incoming jump from 0x0E35 // Inputs[3] // { // @1685 stack[-4] // @1686 stack[-3] // @1687 stack[-2] // } 1681 5B JUMPDEST 1682 61 PUSH2 0x168c 1685 84 DUP5 1686 84 DUP5 1687 84 DUP5 1688 61 PUSH2 0x0771 168B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1682 stack[0] = 0x168c // @1685 stack[1] = stack[-4] // @1686 stack[2] = stack[-3] // @1687 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0771 168C 5B JUMPDEST 168D 60 PUSH1 0x01 168F 60 PUSH1 0x01 1691 60 PUSH1 0xa0 1693 1B SHL 1694 03 SUB 1695 83 DUP4 1696 16 AND 1697 3B EXTCODESIZE 1698 15 ISZERO 1699 61 PUSH2 0x0796 169C 57 *JUMPI 169D 61 PUSH2 0x16a8 16A0 84 DUP5 16A1 84 DUP5 16A2 84 DUP5 16A3 84 DUP5 16A4 61 PUSH2 0x18cd 16A7 56 *JUMP 16A8 5B JUMPDEST 16A9 61 PUSH2 0x0796 16AC 57 *JUMPI 16AD 60 PUSH1 0x40 16AF 51 MLOAD 16B0 63 PUSH4 0x68d2bf6b 16B5 60 PUSH1 0xe1 16B7 1B SHL 16B8 81 DUP2 16B9 52 MSTORE 16BA 60 PUSH1 0x04 16BC 01 ADD 16BD 60 PUSH1 0x40 16BF 51 MLOAD 16C0 80 DUP1 16C1 91 SWAP2 16C2 03 SUB 16C3 90 SWAP1 16C4 FD *REVERT label_16C5: // Incoming jump from 0x0F6C // Inputs[2] // { // @16C9 memory[0x40:0x60] // @16F0 stack[-1] // } 16C5 5B JUMPDEST 16C6 60 PUSH1 0x40 16C8 80 DUP1 16C9 51 MLOAD 16CA 60 PUSH1 0x80 16CC 81 DUP2 16CD 01 ADD 16CE 82 DUP3 16CF 52 MSTORE 16D0 60 PUSH1 0x00 16D2 80 DUP1 16D3 82 DUP3 16D4 52 MSTORE 16D5 60 PUSH1 0x20 16D7 82 DUP3 16D8 01 ADD 16D9 81 DUP2 16DA 90 SWAP1 16DB 52 MSTORE 16DC 91 SWAP2 16DD 81 DUP2 16DE 01 ADD 16DF 82 DUP3 16E0 90 SWAP1 16E1 52 MSTORE 16E2 60 PUSH1 0x60 16E4 81 DUP2 16E5 01 ADD 16E6 91 SWAP2 16E7 90 SWAP1 16E8 91 SWAP2 16E9 52 MSTORE 16EA 61 PUSH2 0x067c 16ED 61 PUSH2 0x16f5 16F0 83 DUP4 16F1 61 PUSH2 0x1520 16F4 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @16CF memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @16D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @16DB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @16E1 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @16E8 stack[0] = memory[0x40:0x60] // @16E9 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @16EA stack[1] = 0x067c // @16ED stack[2] = 0x16f5 // @16F0 stack[3] = stack[-1] // } // Block ends with call to 0x1520, returns to 0x16F5 label_16F5: // Incoming return from call to 0x1520 at 0x16F4 16F5 5B JUMPDEST 16F6 61 PUSH2 0x1885 16F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1885 label_16FA: // Incoming jump from 0x0F9E // Inputs[1] { @1700 storage[0x0b] } 16FA 5B JUMPDEST 16FB 60 PUSH1 0x60 16FD 60 PUSH1 0x0b 16FF 80 DUP1 1700 54 SLOAD 1701 61 PUSH2 0x0691 1704 90 SWAP1 1705 61 PUSH2 0x1e54 1708 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16FB stack[0] = 0x60 // @16FD stack[1] = 0x0b // @1704 stack[2] = 0x0691 // @1704 stack[3] = storage[0x0b] // } // Block ends with call to 0x1e54, returns to 0x0691 1709 5B JUMPDEST 170A 60 PUSH1 0x60 170C 60 PUSH1 0xa0 170E 60 PUSH1 0x40 1710 51 MLOAD 1711 01 ADD 1712 80 DUP1 1713 60 PUSH1 0x40 1715 52 MSTORE 1716 60 PUSH1 0x20 1718 81 DUP2 1719 03 SUB 171A 91 SWAP2 171B 50 POP 171C 50 POP 171D 60 PUSH1 0x00 171F 81 DUP2 1720 52 MSTORE 1721 80 DUP1 1722 82 DUP3 1723 5B JUMPDEST 1724 60 PUSH1 0x01 1726 83 DUP4 1727 03 SUB 1728 92 SWAP3 1729 50 POP 172A 60 PUSH1 0x0a 172C 81 DUP2 172D 06 MOD 172E 60 PUSH1 0x30 1730 01 ADD 1731 83 DUP4 1732 53 MSTORE8 1733 60 PUSH1 0x0a 1735 90 SWAP1 1736 04 DIV 1737 80 DUP1 1738 61 PUSH2 0x1723 173B 57 *JUMPI 173C 50 POP 173D 81 DUP2 173E 90 SWAP1 173F 03 SUB 1740 60 PUSH1 0x1f 1742 19 NOT 1743 90 SWAP1 1744 91 SWAP2 1745 01 ADD 1746 90 SWAP1 1747 81 DUP2 1748 52 MSTORE 1749 91 SWAP2 174A 90 SWAP1 174B 50 POP 174C 56 *JUMP label_174D: // Incoming call from 0x151F, returns to 0x0903 // Inputs[1] { @1753 stack[-2] } 174D 5B JUMPDEST 174E 60 PUSH1 0x00 1750 61 PUSH2 0x1758 1753 83 DUP4 1754 61 PUSH2 0x1520 1757 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @174E stack[0] = 0x00 // @1750 stack[1] = 0x1758 // @1753 stack[2] = stack[-2] // } // Block ends with call to 0x1520, returns to 0x1758 label_1758: // Incoming return from call to 0x1520 at 0x1757 // Inputs[5] // { // @1759 stack[-2] // @1759 stack[-1] // @1762 stack[-4] // @1770 memory[0x00:0x40] // @1772 storage[keccak256(memory[0x00:0x40])] // } 1758 5B JUMPDEST 1759 90 SWAP1 175A 50 POP 175B 80 DUP1 175C 60 PUSH1 0x00 175E 80 DUP1 175F 61 PUSH2 0x1776 1762 86 DUP7 1763 60 PUSH1 0x00 1765 90 SWAP1 1766 81 DUP2 1767 52 MSTORE 1768 60 PUSH1 0x06 176A 60 PUSH1 0x20 176C 52 MSTORE 176D 60 PUSH1 0x40 176F 90 SWAP1 1770 20 SHA3 1771 80 DUP1 1772 54 SLOAD 1773 90 SWAP1 1774 91 SWAP2 1775 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1759 stack[-2] = stack[-1] // @175B stack[-1] = stack[-1] // @175C stack[0] = 0x00 // @175E stack[1] = 0x00 // @1767 memory[0x00:0x20] = stack[-4] // @176C memory[0x20:0x40] = 0x06 // @1773 stack[3] = storage[keccak256(memory[0x00:0x40])] // @1774 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1776 label_1776: // Incoming jump from 0x1775 // Inputs[5] // { // @1777 stack[-3] // @1777 stack[-1] // @1779 stack[-2] // @1779 stack[-4] // @177B stack[-7] // } 1776 5B JUMPDEST 1777 91 SWAP2 1778 50 POP 1779 91 SWAP2 177A 50 POP 177B 84 DUP5 177C 15 ISZERO 177D 61 PUSH2 0x17b6 1780 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1777 stack[-3] = stack[-1] // @1779 stack[-4] = stack[-2] // } // Block ends with conditional jump to 0x17b6, if !stack[-7] label_1781: // Incoming jump from 0x1780, if not !stack[-7] // Inputs[3] // { // @1784 stack[-1] // @1785 stack[-3] // @1786 msg.sender // } 1781 61 PUSH2 0x178b 1784 81 DUP2 1785 84 DUP5 1786 33 CALLER 1787 61 PUSH2 0x1285 178A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1781 stack[0] = 0x178b // @1784 stack[1] = stack[-1] // @1785 stack[2] = stack[-3] // @1786 stack[3] = msg.sender // } // Block ends with call to 0x1285, returns to 0x178B label_178B: // Incoming return from call to 0x1285 at 0x178A // Inputs[1] { @178F stack[-1] } 178B 5B JUMPDEST 178C 61 PUSH2 0x17b6 178F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17b6, if stack[-1] label_1790: // Incoming jump from 0x178F, if not stack[-1] // Inputs[2] // { // @1793 stack[-3] // @1794 msg.sender // } 1790 61 PUSH2 0x1799 1793 83 DUP4 1794 33 CALLER 1795 61 PUSH2 0x05a1 1798 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1790 stack[0] = 0x1799 // @1793 stack[1] = stack[-3] // @1794 stack[2] = msg.sender // } // Block ends with call to 0x05a1, returns to 0x1799 label_1799: // Incoming return from call to 0x05A1 at 0x1798 // Inputs[1] { @179D stack[-1] } 1799 5B JUMPDEST 179A 61 PUSH2 0x17b6 179D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17b6, if stack[-1] label_179E: // Incoming jump from 0x179D, if not stack[-1] // Inputs[3] // { // @17A0 memory[0x40:0x60] // @17B0 memory[0x40:0x60] // @17B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 179E 60 PUSH1 0x40 17A0 51 MLOAD 17A1 63 PUSH4 0x2ce44b5f 17A6 60 PUSH1 0xe1 17A8 1B SHL 17A9 81 DUP2 17AA 52 MSTORE 17AB 60 PUSH1 0x04 17AD 01 ADD 17AE 60 PUSH1 0x40 17B0 51 MLOAD 17B1 80 DUP1 17B2 91 SWAP2 17B3 03 SUB 17B4 90 SWAP1 17B5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @17B5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17B6: // Incoming jump from 0x1780, if !stack[-7] // Incoming jump from 0x179D, if stack[-1] // Incoming jump from 0x178F, if stack[-1] // Inputs[1] { @17B7 stack[-1] } 17B6 5B JUMPDEST 17B7 80 DUP1 17B8 15 ISZERO 17B9 61 PUSH2 0x17c1 17BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17c1, if !stack[-1] label_17BD: // Incoming jump from 0x17BC, if not !stack[-1] // Inputs[8] // { // @17BF stack[-2] // @17CA stack[-3] // @17D9 memory[0x00:0x40] // @17DB storage[keccak256(memory[0x00:0x40])] // @17F0 block.timestamp // @17FD stack[-6] // @1808 memory[0x00:0x40] // @1812 stack[-4] // } 17BD 60 PUSH1 0x00 17BF 82 DUP3 17C0 55 SSTORE 17C1 5B JUMPDEST 17C2 60 PUSH1 0x01 17C4 60 PUSH1 0x01 17C6 60 PUSH1 0xa0 17C8 1B SHL 17C9 03 SUB 17CA 83 DUP4 17CB 16 AND 17CC 60 PUSH1 0x00 17CE 81 DUP2 17CF 81 DUP2 17D0 52 MSTORE 17D1 60 PUSH1 0x05 17D3 60 PUSH1 0x20 17D5 52 MSTORE 17D6 60 PUSH1 0x40 17D8 90 SWAP1 17D9 20 SHA3 17DA 80 DUP1 17DB 54 SLOAD 17DC 6F PUSH16 0xffffffffffffffffffffffffffffffff 17ED 01 ADD 17EE 90 SWAP1 17EF 55 SSTORE 17F0 42 TIMESTAMP 17F1 60 PUSH1 0xa0 17F3 1B SHL 17F4 17 OR 17F5 60 PUSH1 0x03 17F7 60 PUSH1 0xe0 17F9 1B SHL 17FA 17 OR 17FB 60 PUSH1 0x00 17FD 87 DUP8 17FE 81 DUP2 17FF 52 MSTORE 1800 60 PUSH1 0x04 1802 60 PUSH1 0x20 1804 52 MSTORE 1805 60 PUSH1 0x40 1807 81 DUP2 1808 20 SHA3 1809 91 SWAP2 180A 90 SWAP1 180B 91 SWAP2 180C 55 SSTORE 180D 60 PUSH1 0x01 180F 60 PUSH1 0xe1 1811 1B SHL 1812 85 DUP6 1813 16 AND 1814 90 SWAP1 1815 03 SUB 1816 61 PUSH2 0x184f 1819 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @17C0 storage[stack[-2]] = 0x00 // @17D0 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @17D5 memory[0x20:0x40] = 0x05 // @17EF storage[keccak256(memory[0x00:0x40])] = 0xffffffffffffffffffffffffffffffff + storage[keccak256(memory[0x00:0x40])] // @17FF memory[0x00:0x20] = stack[-6] // @1804 memory[0x20:0x40] = 0x04 // @180C storage[keccak256(memory[0x00:0x40])] = (0x03 << 0xe0) | (block.timestamp << 0xa0) | (stack[-3] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x184f, if 0x00 - (stack[-4] & (0x01 << 0xe1)) label_181A: // Incoming jump from 0x1819, if not 0x00 - (stack[-4] & (0x01 << 0xe1)) // Incoming jump from 0x1819, if not 0x00 - (stack[-4] & (0x01 << 0xe1)) // Inputs[3] // { // @181C stack[-6] // @182B memory[0x00:0x40] // @182C storage[keccak256(memory[0x00:0x40])] // } 181A 60 PUSH1 0x01 181C 86 DUP7 181D 01 ADD 181E 60 PUSH1 0x00 1820 81 DUP2 1821 81 DUP2 1822 52 MSTORE 1823 60 PUSH1 0x04 1825 60 PUSH1 0x20 1827 52 MSTORE 1828 60 PUSH1 0x40 182A 81 DUP2 182B 20 SHA3 182C 54 SLOAD 182D 90 SWAP1 182E 03 SUB 182F 61 PUSH2 0x184d 1832 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @181D stack[0] = stack[-6] + 0x01 // @1822 memory[0x00:0x20] = stack[-6] + 0x01 // @1827 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x184d, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_1833: // Incoming jump from 0x1832, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1835 storage[0x00] // @1836 stack[-1] // } 1833 60 PUSH1 0x00 1835 54 SLOAD 1836 81 DUP2 1837 14 EQ 1838 61 PUSH2 0x184d 183B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x184d, if stack[-1] == storage[0x00] label_183C: // Incoming jump from 0x183B, if not stack[-1] == storage[0x00] // Inputs[3] // { // @183E stack[-1] // @1849 memory[0x00:0x40] // @184A stack[-5] // } 183C 60 PUSH1 0x00 183E 81 DUP2 183F 81 DUP2 1840 52 MSTORE 1841 60 PUSH1 0x04 1843 60 PUSH1 0x20 1845 52 MSTORE 1846 60 PUSH1 0x40 1848 90 SWAP1 1849 20 SHA3 184A 85 DUP6 184B 90 SWAP1 184C 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1840 memory[0x00:0x20] = stack[-1] // @1845 memory[0x20:0x40] = 0x04 // @184C storage[keccak256(memory[0x00:0x40])] = stack[-5] // } // Block continues label_184D: // Incoming jump from 0x183B, if stack[-1] == storage[0x00] // Incoming jump from 0x1832, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x184C 184D 5B JUMPDEST 184E 50 POP // Stack delta = -1 // Block continues label_184F: // Incoming jump from 0x184E // Incoming jump from 0x1819, if 0x00 - (stack[-4] & (0x01 << 0xe1)) // Incoming jump from 0x1819, if 0x00 - (stack[-4] & (0x01 << 0xe1)) // Inputs[8] // { // @1852 memory[0x40:0x60] // @1853 stack[-6] // @1860 stack[-3] // @1866 memory[0x00:0x20] // @186F memory[0x00:0x20] // @1875 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @187B storage[0x01] // @1884 stack[-7] // } 184F 5B JUMPDEST 1850 60 PUSH1 0x40 1852 51 MLOAD 1853 86 DUP7 1854 90 SWAP1 1855 60 PUSH1 0x00 1857 90 SWAP1 1858 60 PUSH1 0x01 185A 60 PUSH1 0x01 185C 60 PUSH1 0xa0 185E 1B SHL 185F 03 SUB 1860 86 DUP7 1861 16 AND 1862 90 SWAP1 1863 60 PUSH1 0x00 1865 80 DUP1 1866 51 MLOAD 1867 60 PUSH1 0x20 1869 61 PUSH2 0x2093 186C 83 DUP4 186D 39 CODECOPY 186E 81 DUP2 186F 51 MLOAD 1870 91 SWAP2 1871 52 MSTORE 1872 90 SWAP1 1873 83 DUP4 1874 90 SWAP1 1875 A4 LOG4 1876 50 POP 1877 50 POP 1878 60 PUSH1 0x01 187A 80 DUP1 187B 54 SLOAD 187C 81 DUP2 187D 01 ADD 187E 90 SWAP1 187F 55 SSTORE 1880 50 POP 1881 50 POP 1882 50 POP 1883 50 POP 1884 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @186D memory[0x00:0x20] = code[0x2093:0x20b3] // @1871 memory[0x00:0x20] = memory[0x00:0x20] // @1875 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [memory[0x00:0x20], stack[-3] & (0x01 << 0xa0) - 0x01, 0x00, stack[-6]]); // @187F storage[0x01] = 0x01 + storage[0x01] // } // Block ends with unconditional jump to stack[-7] label_1885: // Incoming call from 0x1614, returns to 0x067C // Incoming jump from 0x16F9 // Inputs[3] // { // @1889 memory[0x40:0x60] // @1898 stack[-1] // @18CB stack[-2] // } 1885 5B JUMPDEST 1886 60 PUSH1 0x40 1888 80 DUP1 1889 51 MLOAD 188A 60 PUSH1 0x80 188C 81 DUP2 188D 01 ADD 188E 82 DUP3 188F 52 MSTORE 1890 60 PUSH1 0x01 1892 60 PUSH1 0x01 1894 60 PUSH1 0xa0 1896 1B SHL 1897 03 SUB 1898 83 DUP4 1899 16 AND 189A 81 DUP2 189B 52 MSTORE 189C 60 PUSH1 0xa0 189E 83 DUP4 189F 90 SWAP1 18A0 1C SHR 18A1 67 PUSH8 0xffffffffffffffff 18AA 16 AND 18AB 60 PUSH1 0x20 18AD 82 DUP3 18AE 01 ADD 18AF 52 MSTORE 18B0 60 PUSH1 0x01 18B2 60 PUSH1 0xe0 18B4 1B SHL 18B5 83 DUP4 18B6 16 AND 18B7 15 ISZERO 18B8 15 ISZERO 18B9 91 SWAP2 18BA 81 DUP2 18BB 01 ADD 18BC 91 SWAP2 18BD 90 SWAP1 18BE 91 SWAP2 18BF 52 MSTORE 18C0 60 PUSH1 0xe8 18C2 91 SWAP2 18C3 90 SWAP1 18C4 91 SWAP2 18C5 1C SHR 18C6 60 PUSH1 0x60 18C8 82 DUP3 18C9 01 ADD 18CA 52 MSTORE 18CB 90 SWAP1 18CC 56 *JUMP // Stack delta = -1 // Outputs[6] // { // @188F memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @189B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @18AF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & (stack[-1] >> 0xa0) // @18BF memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(stack[-1] & (0x01 << 0xe0)) // @18CA memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] >> 0xe8 // @18CB stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-2] 18CD 5B JUMPDEST 18CE 60 PUSH1 0x40 18D0 51 MLOAD 18D1 63 PUSH4 0x0a85bd01 18D6 60 PUSH1 0xe1 18D8 1B SHL 18D9 81 DUP2 18DA 52 MSTORE 18DB 60 PUSH1 0x00 18DD 90 SWAP1 18DE 60 PUSH1 0x01 18E0 60 PUSH1 0x01 18E2 60 PUSH1 0xa0 18E4 1B SHL 18E5 03 SUB 18E6 85 DUP6 18E7 16 AND 18E8 90 SWAP1 18E9 63 PUSH4 0x150b7a02 18EE 90 SWAP1 18EF 61 PUSH2 0x1902 18F2 90 SWAP1 18F3 33 CALLER 18F4 90 SWAP1 18F5 89 DUP10 18F6 90 SWAP1 18F7 88 DUP9 18F8 90 SWAP1 18F9 88 DUP9 18FA 90 SWAP1 18FB 60 PUSH1 0x04 18FD 01 ADD 18FE 61 PUSH2 0x2038 1901 56 *JUMP 1902 5B JUMPDEST 1903 60 PUSH1 0x20 1905 60 PUSH1 0x40 1907 51 MLOAD 1908 80 DUP1 1909 83 DUP4 190A 03 SUB 190B 81 DUP2 190C 60 PUSH1 0x00 190E 87 DUP8 190F 5A GAS 1910 F1 CALL 1911 92 SWAP3 1912 50 POP 1913 50 POP 1914 50 POP 1915 80 DUP1 1916 15 ISZERO 1917 61 PUSH2 0x193d 191A 57 *JUMPI 191B 50 POP 191C 60 PUSH1 0x40 191E 80 DUP1 191F 51 MLOAD 1920 60 PUSH1 0x1f 1922 3D RETURNDATASIZE 1923 90 SWAP1 1924 81 DUP2 1925 01 ADD 1926 60 PUSH1 0x1f 1928 19 NOT 1929 16 AND 192A 82 DUP3 192B 01 ADD 192C 90 SWAP1 192D 92 SWAP3 192E 52 MSTORE 192F 61 PUSH2 0x193a 1932 91 SWAP2 1933 81 DUP2 1934 01 ADD 1935 90 SWAP1 1936 61 PUSH2 0x2075 1939 56 *JUMP 193A 5B JUMPDEST 193B 60 PUSH1 0x01 193D 5B JUMPDEST 193E 61 PUSH2 0x199b 1941 57 *JUMPI 1942 3D RETURNDATASIZE 1943 80 DUP1 1944 80 DUP1 1945 15 ISZERO 1946 61 PUSH2 0x196b 1949 57 *JUMPI 194A 60 PUSH1 0x40 194C 51 MLOAD 194D 91 SWAP2 194E 50 POP 194F 60 PUSH1 0x1f 1951 19 NOT 1952 60 PUSH1 0x3f 1954 3D RETURNDATASIZE 1955 01 ADD 1956 16 AND 1957 82 DUP3 1958 01 ADD 1959 60 PUSH1 0x40 195B 52 MSTORE 195C 3D RETURNDATASIZE 195D 82 DUP3 195E 52 MSTORE 195F 3D RETURNDATASIZE 1960 60 PUSH1 0x00 1962 60 PUSH1 0x20 1964 84 DUP5 1965 01 ADD 1966 3E RETURNDATACOPY 1967 61 PUSH2 0x1970 196A 56 *JUMP 196B 5B JUMPDEST 196C 60 PUSH1 0x60 196E 91 SWAP2 196F 50 POP 1970 5B JUMPDEST 1971 50 POP 1972 80 DUP1 1973 51 MLOAD 1974 60 PUSH1 0x00 1976 03 SUB 1977 61 PUSH2 0x1993 197A 57 *JUMPI 197B 60 PUSH1 0x40 197D 51 MLOAD 197E 63 PUSH4 0x68d2bf6b 1983 60 PUSH1 0xe1 1985 1B SHL 1986 81 DUP2 1987 52 MSTORE 1988 60 PUSH1 0x04 198A 01 ADD 198B 60 PUSH1 0x40 198D 51 MLOAD 198E 80 DUP1 198F 91 SWAP2 1990 03 SUB 1991 90 SWAP1 1992 FD *REVERT 1993 5B JUMPDEST 1994 80 DUP1 1995 51 MLOAD 1996 81 DUP2 1997 60 PUSH1 0x20 1999 01 ADD 199A FD *REVERT 199B 5B JUMPDEST 199C 60 PUSH1 0x01 199E 60 PUSH1 0x01 19A0 60 PUSH1 0xe0 19A2 1B SHL 19A3 03 SUB 19A4 19 NOT 19A5 16 AND 19A6 63 PUSH4 0x0a85bd01 19AB 60 PUSH1 0xe1 19AD 1B SHL 19AE 14 EQ 19AF 90 SWAP1 19B0 50 POP label_19B1: // Incoming return from call to 0x1C0D at 0x1CCB // Inputs[3] // { // @19B2 stack[-1] // @19B2 stack[-6] // @19B3 stack[-5] // } 19B1 5B JUMPDEST 19B2 94 SWAP5 19B3 93 SWAP4 19B4 50 POP 19B5 50 POP 19B6 50 POP 19B7 50 POP 19B8 56 *JUMP // Stack delta = -5 // Outputs[1] { @19B2 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_19B9: // Incoming call from 0x19EB, returns to 0x0DF5 // Inputs[1] { @19C3 stack[-1] } 19B9 5B JUMPDEST 19BA 60 PUSH1 0x01 19BC 60 PUSH1 0x01 19BE 60 PUSH1 0xe0 19C0 1B SHL 19C1 03 SUB 19C2 19 NOT 19C3 81 DUP2 19C4 16 AND 19C5 81 DUP2 19C6 14 EQ 19C7 61 PUSH2 0x0903 19CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0903, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_19CB: // Incoming jump from 0x19CA, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @19CE memory[0x00:0x00] } 19CB 60 PUSH1 0x00 19CD 80 DUP1 19CE FD *REVERT // Stack delta = +0 // Outputs[1] { @19CE revert(memory[0x00:0x00]); } // Block terminates label_19CF: // Incoming call from 0x0218, returns to 0x0219 // Inputs[2] // { // @19D4 stack[-1] // @19D5 stack[-2] // } 19CF 5B JUMPDEST 19D0 60 PUSH1 0x00 19D2 60 PUSH1 0x20 19D4 82 DUP3 19D5 84 DUP5 19D6 03 SUB 19D7 12 SLT 19D8 15 ISZERO 19D9 61 PUSH2 0x19e1 19DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x19e1, if !(stack[-2] - stack[-1] i< 0x20) label_19DD: // Incoming jump from 0x19DC, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @19E0 memory[0x00:0x00] } 19DD 60 PUSH1 0x00 19DF 80 DUP1 19E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @19E0 revert(memory[0x00:0x00]); } // Block terminates label_19E1: // Incoming jump from 0x19DC, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @19E2 stack[-2] // @19E3 msg.data[stack[-2]:stack[-2] + 0x20] // } 19E1 5B JUMPDEST 19E2 81 DUP2 19E3 35 CALLDATALOAD 19E4 61 PUSH2 0x0df5 19E7 81 DUP2 19E8 61 PUSH2 0x19b9 19EB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19E3 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @19E4 stack[1] = 0x0df5 // @19E7 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x19b9, returns to 0x0DF5 label_19EC: // Incoming call from 0x1A27, returns to 0x1A28 // Inputs[1] { @19F0 stack[-3] } 19EC 5B JUMPDEST 19ED 60 PUSH1 0x00 19EF 5B JUMPDEST 19F0 83 DUP4 19F1 81 DUP2 19F2 10 LT 19F3 15 ISZERO 19F4 61 PUSH2 0x1a07 19F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19ED stack[0] = 0x00 } // Block ends with conditional jump to 0x1a07, if !(0x00 < stack[-3]) label_19F8: // Incoming jump from 0x19F7, if not !(0x00 < stack[-3]) // Incoming jump from 0x19F7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @19F8 stack[-2] // @19F9 stack[-1] // @19FB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @19FC stack[-3] // } 19F8 81 DUP2 19F9 81 DUP2 19FA 01 ADD 19FB 51 MLOAD 19FC 83 DUP4 19FD 82 DUP3 19FE 01 ADD 19FF 52 MSTORE 1A00 60 PUSH1 0x20 1A02 01 ADD 1A03 61 PUSH2 0x19ef 1A06 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @19FF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1A02 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x19ef label_1A07: // Incoming jump from 0x19F7, if !(0x00 < stack[-3]) // Incoming jump from 0x19F7, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1A0C stack[-4] // @1A0D stack[-3] // @1A0F stack[-5] // } 1A07 5B JUMPDEST 1A08 50 POP 1A09 50 POP 1A0A 60 PUSH1 0x00 1A0C 91 SWAP2 1A0D 01 ADD 1A0E 52 MSTORE 1A0F 56 *JUMP // Stack delta = -5 // Outputs[1] { @1A0E memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1A10: // Incoming call from 0x1A4E, returns to 0x0DF5 // Inputs[3] // { // @1A13 stack[-1] // @1A14 memory[stack[-1]:stack[-1] + 0x20] // @1A16 stack[-2] // } 1A10 5B JUMPDEST 1A11 60 PUSH1 0x00 1A13 81 DUP2 1A14 51 MLOAD 1A15 80 DUP1 1A16 84 DUP5 1A17 52 MSTORE 1A18 61 PUSH2 0x1a28 1A1B 81 DUP2 1A1C 60 PUSH1 0x20 1A1E 86 DUP7 1A1F 01 ADD 1A20 60 PUSH1 0x20 1A22 86 DUP7 1A23 01 ADD 1A24 61 PUSH2 0x19ec 1A27 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1A11 stack[0] = 0x00 // @1A14 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1A17 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1A18 stack[2] = 0x1a28 // @1A1B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1A1F stack[4] = stack[-2] + 0x20 // @1A23 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x19ec, returns to 0x1A28 label_1A28: // Incoming return from call to 0x19EC at 0x1A27 // Inputs[4] // { // @1A2B stack[-1] // @1A30 stack[-4] // @1A31 stack[-2] // @1A37 stack[-5] // } 1A28 5B JUMPDEST 1A29 60 PUSH1 0x1f 1A2B 01 ADD 1A2C 60 PUSH1 0x1f 1A2E 19 NOT 1A2F 16 AND 1A30 92 SWAP3 1A31 90 SWAP1 1A32 92 SWAP3 1A33 01 ADD 1A34 60 PUSH1 0x20 1A36 01 ADD 1A37 92 SWAP3 1A38 91 SWAP2 1A39 50 POP 1A3A 50 POP 1A3B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A37 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1A3C: // Incoming jump from 0x0254 // Inputs[2] // { // @1A3F stack[-1] // @1A4A stack[-2] // } 1A3C 5B JUMPDEST 1A3D 60 PUSH1 0x20 1A3F 81 DUP2 1A40 52 MSTORE 1A41 60 PUSH1 0x00 1A43 61 PUSH2 0x0df5 1A46 60 PUSH1 0x20 1A48 83 DUP4 1A49 01 ADD 1A4A 84 DUP5 1A4B 61 PUSH2 0x1a10 1A4E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1A40 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1A41 stack[0] = 0x00 // @1A43 stack[1] = 0x0df5 // @1A49 stack[2] = stack[-1] + 0x20 // @1A4A stack[3] = stack[-2] // } // Block ends with call to 0x1a10, returns to 0x0DF5 label_1A4F: // Incoming call from 0x0362, returns to 0x0363 // Incoming call from 0x056A, returns to 0x056B // Incoming call from 0x026F, returns to 0x0270 // Incoming call from 0x03C4, returns to 0x03C5 // Incoming call from 0x053D, returns to 0x053E // Inputs[2] // { // @1A54 stack[-1] // @1A55 stack[-2] // } 1A4F 5B JUMPDEST 1A50 60 PUSH1 0x00 1A52 60 PUSH1 0x20 1A54 82 DUP3 1A55 84 DUP5 1A56 03 SUB 1A57 12 SLT 1A58 15 ISZERO 1A59 61 PUSH2 0x1a61 1A5C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A50 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a61, if !(stack[-2] - stack[-1] i< 0x20) label_1A5D: // Incoming jump from 0x1A5C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A60 memory[0x00:0x00] } 1A5D 60 PUSH1 0x00 1A5F 80 DUP1 1A60 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A60 revert(memory[0x00:0x00]); } // Block terminates label_1A61: // Incoming jump from 0x1A5C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1A63 stack[-2] // @1A63 msg.data[stack[-2]:stack[-2] + 0x20] // @1A64 stack[-4] // @1A65 stack[-3] // } 1A61 5B JUMPDEST 1A62 50 POP 1A63 35 CALLDATALOAD 1A64 91 SWAP2 1A65 90 SWAP1 1A66 50 POP 1A67 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A64 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1A68: // Incoming call from 0x1ACB, returns to 0x1ACC // Incoming call from 0x1DC3, returns to 0x1DC4 // Incoming call from 0x1AD9, returns to 0x1ADA // Incoming call from 0x1E3C, returns to 0x1E3D // Incoming call from 0x1D7B, returns to 0x1D7C // Incoming call from 0x1E4A, returns to 0x1E4B // Incoming call from 0x1D3C, returns to 0x1D3D // Incoming call from 0x1DB5, returns to 0x1DB6 // Incoming call from 0x1A9F, returns to 0x1AA0 // Incoming call from 0x1CE6, returns to 0x0DF5 // Inputs[2] // { // @1A69 stack[-1] // @1A6A msg.data[stack[-1]:stack[-1] + 0x20] // } 1A68 5B JUMPDEST 1A69 80 DUP1 1A6A 35 CALLDATALOAD 1A6B 60 PUSH1 0x01 1A6D 60 PUSH1 0x01 1A6F 60 PUSH1 0xa0 1A71 1B SHL 1A72 03 SUB 1A73 81 DUP2 1A74 16 AND 1A75 81 DUP2 1A76 14 EQ 1A77 61 PUSH2 0x1a7f 1A7A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A6A stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1a7f, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1A7B: // Incoming jump from 0x1A7A, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A7E memory[0x00:0x00] } 1A7B 60 PUSH1 0x00 1A7D 80 DUP1 1A7E FD *REVERT // Stack delta = +0 // Outputs[1] { @1A7E revert(memory[0x00:0x00]); } // Block terminates label_1A7F: // Incoming jump from 0x1A7A, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A80 stack[-1] // @1A80 stack[-3] // @1A81 stack[-2] // } 1A7F 5B JUMPDEST 1A80 91 SWAP2 1A81 90 SWAP1 1A82 50 POP 1A83 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A80 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1A84: // Incoming call from 0x029A, returns to 0x029B // Inputs[2] // { // @1A8A stack[-1] // @1A8B stack[-2] // } 1A84 5B JUMPDEST 1A85 60 PUSH1 0x00 1A87 80 DUP1 1A88 60 PUSH1 0x40 1A8A 83 DUP4 1A8B 85 DUP6 1A8C 03 SUB 1A8D 12 SLT 1A8E 15 ISZERO 1A8F 61 PUSH2 0x1a97 1A92 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A85 stack[0] = 0x00 // @1A87 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a97, if !(stack[-2] - stack[-1] i< 0x40) label_1A93: // Incoming jump from 0x1A92, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A96 memory[0x00:0x00] } 1A93 60 PUSH1 0x00 1A95 80 DUP1 1A96 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A96 revert(memory[0x00:0x00]); } // Block terminates label_1A97: // Incoming jump from 0x1A92, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A9B stack[-3] } 1A97 5B JUMPDEST 1A98 61 PUSH2 0x1aa0 1A9B 83 DUP4 1A9C 61 PUSH2 0x1a68 1A9F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A98 stack[0] = 0x1aa0 // @1A9B stack[1] = stack[-3] // } // Block ends with call to 0x1a68, returns to 0x1AA0 label_1AA0: // Incoming return from call to 0x1A68 at 0x1A9F // Inputs[5] // { // @1AA1 stack[-1] // @1AA1 stack[-6] // @1AA4 stack[-4] // @1AA8 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1AA9 stack[-5] // } 1AA0 5B JUMPDEST 1AA1 94 SWAP5 1AA2 60 PUSH1 0x20 1AA4 93 SWAP4 1AA5 90 SWAP1 1AA6 93 SWAP4 1AA7 01 ADD 1AA8 35 CALLDATALOAD 1AA9 93 SWAP4 1AAA 50 POP 1AAB 50 POP 1AAC 50 POP 1AAD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1AA1 stack[-6] = stack[-1] // @1AA9 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1AAE: // Incoming call from 0x02D2, returns to 0x02D3 // Incoming call from 0x0342, returns to 0x0343 // Inputs[2] // { // @1AB6 stack[-1] // @1AB7 stack[-2] // } 1AAE 5B JUMPDEST 1AAF 60 PUSH1 0x00 1AB1 80 DUP1 1AB2 60 PUSH1 0x00 1AB4 60 PUSH1 0x60 1AB6 84 DUP5 1AB7 86 DUP7 1AB8 03 SUB 1AB9 12 SLT 1ABA 15 ISZERO 1ABB 61 PUSH2 0x1ac3 1ABE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1AAF stack[0] = 0x00 // @1AB1 stack[1] = 0x00 // @1AB2 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ac3, if !(stack[-2] - stack[-1] i< 0x60) label_1ABF: // Incoming jump from 0x1ABE, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1AC2 memory[0x00:0x00] } 1ABF 60 PUSH1 0x00 1AC1 80 DUP1 1AC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC2 revert(memory[0x00:0x00]); } // Block terminates label_1AC3: // Incoming jump from 0x1ABE, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1AC7 stack[-4] } 1AC3 5B JUMPDEST 1AC4 61 PUSH2 0x1acc 1AC7 84 DUP5 1AC8 61 PUSH2 0x1a68 1ACB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AC4 stack[0] = 0x1acc // @1AC7 stack[1] = stack[-4] // } // Block ends with call to 0x1a68, returns to 0x1ACC label_1ACC: // Incoming return from call to 0x1A68 at 0x1ACB // Inputs[3] // { // @1ACD stack[-4] // @1ACD stack[-1] // @1AD4 stack[-5] // } 1ACC 5B JUMPDEST 1ACD 92 SWAP3 1ACE 50 POP 1ACF 61 PUSH2 0x1ada 1AD2 60 PUSH1 0x20 1AD4 85 DUP6 1AD5 01 ADD 1AD6 61 PUSH2 0x1a68 1AD9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1ACD stack[-4] = stack[-1] // @1ACF stack[-1] = 0x1ada // @1AD5 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1a68, returns to 0x1ADA label_1ADA: // Incoming return from call to 0x1A68 at 0x1AD9 // Inputs[8] // { // @1ADB stack[-1] // @1ADB stack[-3] // @1ADF stack[-5] // @1AE1 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1AE2 stack[-2] // @1AE6 stack[-6] // @1AE8 stack[-4] // @1AE8 stack[-7] // } 1ADA 5B JUMPDEST 1ADB 91 SWAP2 1ADC 50 POP 1ADD 60 PUSH1 0x40 1ADF 84 DUP5 1AE0 01 ADD 1AE1 35 CALLDATALOAD 1AE2 90 SWAP1 1AE3 50 POP 1AE4 92 SWAP3 1AE5 50 POP 1AE6 92 SWAP3 1AE7 50 POP 1AE8 92 SWAP3 1AE9 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1AE4 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1AE6 stack[-6] = stack[-1] // @1AE8 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1AEA: // Incoming call from 0x1B6B, returns to 0x1B6C // Inputs[2] // { // @1AEE stack[-2] // @1AF1 stack[-1] // } 1AEA 5B JUMPDEST 1AEB 60 PUSH1 0x00 1AED 80 DUP1 1AEE 83 DUP4 1AEF 60 PUSH1 0x1f 1AF1 84 DUP5 1AF2 01 ADD 1AF3 12 SLT 1AF4 61 PUSH2 0x1afc 1AF7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AEB stack[0] = 0x00 // @1AED stack[1] = 0x00 // } // Block ends with conditional jump to 0x1afc, if stack[-1] + 0x1f i< stack[-2] label_1AF8: // Incoming jump from 0x1AF7, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1AFB memory[0x00:0x00] } 1AF8 60 PUSH1 0x00 1AFA 80 DUP1 1AFB FD *REVERT // Stack delta = +0 // Outputs[1] { @1AFB revert(memory[0x00:0x00]); } // Block terminates label_1AFC: // Incoming jump from 0x1AF7, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1AFE stack[-3] // @1AFF msg.data[stack[-3]:stack[-3] + 0x20] // } 1AFC 5B JUMPDEST 1AFD 50 POP 1AFE 81 DUP2 1AFF 35 CALLDATALOAD 1B00 67 PUSH8 0xffffffffffffffff 1B09 81 DUP2 1B0A 11 GT 1B0B 15 ISZERO 1B0C 61 PUSH2 0x1b14 1B0F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1AFF stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1b14, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1B10: // Incoming jump from 0x1B0F, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1B13 memory[0x00:0x00] } 1B10 60 PUSH1 0x00 1B12 80 DUP1 1B13 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B13 revert(memory[0x00:0x00]); } // Block terminates label_1B14: // Incoming jump from 0x1B0F, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @1B17 stack[-3] // @1B19 stack[-2] // @1B1B stack[-4] // @1B1E stack[-1] // } 1B14 5B JUMPDEST 1B15 60 PUSH1 0x20 1B17 83 DUP4 1B18 01 ADD 1B19 91 SWAP2 1B1A 50 POP 1B1B 83 DUP4 1B1C 60 PUSH1 0x20 1B1E 82 DUP3 1B1F 60 PUSH1 0x05 1B21 1B SHL 1B22 85 DUP6 1B23 01 ADD 1B24 01 ADD 1B25 11 GT 1B26 15 ISZERO 1B27 61 PUSH2 0x1b2f 1B2A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B19 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1b2f, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_1B2B: // Incoming jump from 0x1B2A, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @1B2E memory[0x00:0x00] } 1B2B 60 PUSH1 0x00 1B2D 80 DUP1 1B2E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B2E revert(memory[0x00:0x00]); } // Block terminates label_1B2F: // Incoming jump from 0x1B2A, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @1B30 stack[-4] // @1B30 stack[-1] // @1B32 stack[-5] // @1B32 stack[-2] // @1B33 stack[-3] // } 1B2F 5B JUMPDEST 1B30 92 SWAP3 1B31 50 POP 1B32 92 SWAP3 1B33 90 SWAP1 1B34 50 POP 1B35 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1B30 stack[-4] = stack[-1] // @1B32 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_1B36: // Incoming call from 0x0382, returns to 0x0383 // Incoming call from 0x0312, returns to 0x0313 // Inputs[2] // { // @1B3C stack[-1] // @1B3D stack[-2] // } 1B36 5B JUMPDEST 1B37 60 PUSH1 0x00 1B39 80 DUP1 1B3A 60 PUSH1 0x20 1B3C 83 DUP4 1B3D 85 DUP6 1B3E 03 SUB 1B3F 12 SLT 1B40 15 ISZERO 1B41 61 PUSH2 0x1b49 1B44 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B37 stack[0] = 0x00 // @1B39 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b49, if !(stack[-2] - stack[-1] i< 0x20) label_1B45: // Incoming jump from 0x1B44, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B48 memory[0x00:0x00] } 1B45 60 PUSH1 0x00 1B47 80 DUP1 1B48 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B48 revert(memory[0x00:0x00]); } // Block terminates label_1B49: // Incoming jump from 0x1B44, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B4A stack[-3] // @1B4B msg.data[stack[-3]:stack[-3] + 0x20] // } 1B49 5B JUMPDEST 1B4A 82 DUP3 1B4B 35 CALLDATALOAD 1B4C 67 PUSH8 0xffffffffffffffff 1B55 81 DUP2 1B56 11 GT 1B57 15 ISZERO 1B58 61 PUSH2 0x1b60 1B5B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B4B stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1b60, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1B5C: // Incoming jump from 0x1B5B, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1B5F memory[0x00:0x00] } 1B5C 60 PUSH1 0x00 1B5E 80 DUP1 1B5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1B5F revert(memory[0x00:0x00]); } // Block terminates label_1B60: // Incoming jump from 0x1B5B, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1B64 stack[-5] // @1B65 stack[-1] // @1B66 stack[-4] // } 1B60 5B JUMPDEST 1B61 61 PUSH2 0x1b6c 1B64 85 DUP6 1B65 82 DUP3 1B66 86 DUP7 1B67 01 ADD 1B68 61 PUSH2 0x1aea 1B6B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B61 stack[0] = 0x1b6c // @1B64 stack[1] = stack[-5] // @1B67 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1aea, returns to 0x1B6C label_1B6C: // Incoming return from call to 0x1AEA at 0x1B6B // Inputs[5] // { // @1B6D stack[-2] // @1B6D stack[-1] // @1B6E stack[-8] // @1B70 stack[-7] // @1B72 stack[-6] // } 1B6C 5B JUMPDEST 1B6D 90 SWAP1 1B6E 96 SWAP7 1B6F 90 SWAP1 1B70 95 SWAP6 1B71 50 POP 1B72 93 SWAP4 1B73 50 POP 1B74 50 POP 1B75 50 POP 1B76 50 POP 1B77 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1B6E stack[-8] = stack[-2] // @1B70 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_1B78: // Incoming call from 0x1E20, returns to 0x067C // Incoming call from 0x1BE3, returns to 0x1BE4 // Inputs[7] // { // @1B79 stack[-1] // @1B7A memory[stack[-1]:stack[-1] + 0x20] // @1B84 stack[-2] // @1B8B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @1B9F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @1BAB memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @1BB4 stack[-3] // } 1B78 5B JUMPDEST 1B79 80 DUP1 1B7A 51 MLOAD 1B7B 60 PUSH1 0x01 1B7D 60 PUSH1 0x01 1B7F 60 PUSH1 0xa0 1B81 1B SHL 1B82 03 SUB 1B83 16 AND 1B84 82 DUP3 1B85 52 MSTORE 1B86 60 PUSH1 0x20 1B88 80 DUP1 1B89 82 DUP3 1B8A 01 ADD 1B8B 51 MLOAD 1B8C 67 PUSH8 0xffffffffffffffff 1B95 16 AND 1B96 90 SWAP1 1B97 83 DUP4 1B98 01 ADD 1B99 52 MSTORE 1B9A 60 PUSH1 0x40 1B9C 80 DUP1 1B9D 82 DUP3 1B9E 01 ADD 1B9F 51 MLOAD 1BA0 15 ISZERO 1BA1 15 ISZERO 1BA2 90 SWAP1 1BA3 83 DUP4 1BA4 01 ADD 1BA5 52 MSTORE 1BA6 60 PUSH1 0x60 1BA8 90 SWAP1 1BA9 81 DUP2 1BAA 01 ADD 1BAB 51 MLOAD 1BAC 62 PUSH3 0xffffff 1BB0 16 AND 1BB1 91 SWAP2 1BB2 01 ADD 1BB3 52 MSTORE 1BB4 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1B85 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // @1B99 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = 0xffffffffffffffff & memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @1BA5 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = !!memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @1BB3 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = 0xffffff & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // } // Block ends with unconditional jump to stack[-3] label_1BB5: // Incoming call from 0x0394, returns to 0x022A // Inputs[3] // { // @1BB9 stack[-1] // @1BBB stack[-2] // @1BBC memory[stack[-2]:stack[-2] + 0x20] // } 1BB5 5B JUMPDEST 1BB6 60 PUSH1 0x20 1BB8 80 DUP1 1BB9 82 DUP3 1BBA 52 MSTORE 1BBB 82 DUP3 1BBC 51 MLOAD 1BBD 82 DUP3 1BBE 82 DUP3 1BBF 01 ADD 1BC0 81 DUP2 1BC1 90 SWAP1 1BC2 52 MSTORE 1BC3 60 PUSH1 0x00 1BC5 91 SWAP2 1BC6 90 SWAP1 1BC7 84 DUP5 1BC8 82 DUP3 1BC9 01 ADD 1BCA 90 SWAP1 1BCB 60 PUSH1 0x40 1BCD 85 DUP6 1BCE 01 ADD 1BCF 90 SWAP1 1BD0 84 DUP5 1BD1 5B JUMPDEST 1BD2 81 DUP2 1BD3 81 DUP2 1BD4 10 LT 1BD5 15 ISZERO 1BD6 61 PUSH2 0x0c4e 1BD9 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1BBA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1BC2 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1BC5 stack[0] = 0x00 // @1BC6 stack[1] = 0x20 // @1BCA stack[2] = 0x20 + stack[-2] // @1BCF stack[3] = stack[-1] + 0x40 // @1BCF stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @1BD0 stack[5] = 0x00 // } // Block ends with conditional jump to 0x0c4e, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1BDA: // Incoming jump from 0x1BD9, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x1BD9, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1BDD stack[-3] // @1BDE stack[-4] // @1BDF memory[stack[-4]:stack[-4] + 0x20] // } 1BDA 61 PUSH2 0x1be4 1BDD 83 DUP4 1BDE 85 DUP6 1BDF 51 MLOAD 1BE0 61 PUSH2 0x1b78 1BE3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BDA stack[0] = 0x1be4 // @1BDD stack[1] = stack[-3] // @1BDF stack[2] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x1b78, returns to 0x1BE4 label_1BE4: // Incoming return from call to 0x1B78 at 0x1BE3 // Inputs[4] // { // @1BE5 stack[-4] // @1BE5 stack[-1] // @1BE6 stack[-5] // @1BEB stack[-3] // } 1BE4 5B JUMPDEST 1BE5 92 SWAP3 1BE6 84 DUP5 1BE7 01 ADD 1BE8 92 SWAP3 1BE9 60 PUSH1 0x80 1BEB 92 SWAP3 1BEC 90 SWAP1 1BED 92 SWAP3 1BEE 01 ADD 1BEF 91 SWAP2 1BF0 60 PUSH1 0x01 1BF2 01 ADD 1BF3 61 PUSH2 0x1bd1 1BF6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1BE8 stack[-4] = stack[-5] + stack[-4] // @1BEF stack[-3] = 0x80 + stack[-3] // @1BF2 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1bd1 label_1BF7: // Incoming jump from 0x1C27 // Incoming jump from 0x1F45 // Incoming jump from 0x0977 // Incoming jump from 0x1C4F // Incoming jump from 0x0D06 // Incoming jump from 0x0B7D // Inputs[1] { @1C0C memory[0x00:0x24] } 1BF7 5B JUMPDEST 1BF8 63 PUSH4 0x4e487b71 1BFD 60 PUSH1 0xe0 1BFF 1B SHL 1C00 60 PUSH1 0x00 1C02 52 MSTORE 1C03 60 PUSH1 0x41 1C05 60 PUSH1 0x04 1C07 52 MSTORE 1C08 60 PUSH1 0x24 1C0A 60 PUSH1 0x00 1C0C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C02 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C07 memory[0x04:0x24] = 0x41 // @1C0C revert(memory[0x00:0x24]); // } // Block terminates label_1C0D: // Incoming call from 0x1E06, returns to 0x1E07 // Incoming call from 0x1CCB, returns to 0x19B1 // Inputs[1] { @1C1A stack[-2] } 1C0D 5B JUMPDEST 1C0E 60 PUSH1 0x00 1C10 67 PUSH8 0xffffffffffffffff 1C19 80 DUP1 1C1A 84 DUP5 1C1B 11 GT 1C1C 15 ISZERO 1C1D 61 PUSH2 0x1c28 1C20 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C0E stack[0] = 0x00 // @1C10 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1c28, if !(stack[-2] > 0xffffffffffffffff) label_1C21: // Incoming jump from 0x1C20, if not !(stack[-2] > 0xffffffffffffffff) 1C21 61 PUSH2 0x1c28 1C24 61 PUSH2 0x1bf7 1C27 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C21 stack[0] = 0x1c28 } // Block ends with unconditional jump to 0x1bf7 label_1C28: // Incoming jump from 0x1C20, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1C2B memory[0x40:0x60] // @1C2E stack[-4] // @1C3D stack[-1] // } 1C28 5B JUMPDEST 1C29 60 PUSH1 0x40 1C2B 51 MLOAD 1C2C 60 PUSH1 0x1f 1C2E 85 DUP6 1C2F 01 ADD 1C30 60 PUSH1 0x1f 1C32 19 NOT 1C33 90 SWAP1 1C34 81 DUP2 1C35 16 AND 1C36 60 PUSH1 0x3f 1C38 01 ADD 1C39 16 AND 1C3A 81 DUP2 1C3B 01 ADD 1C3C 90 SWAP1 1C3D 82 DUP3 1C3E 82 DUP3 1C3F 11 GT 1C40 81 DUP2 1C41 83 DUP4 1C42 10 LT 1C43 17 OR 1C44 15 ISZERO 1C45 61 PUSH2 0x1c50 1C48 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C3C stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1C3C stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1c50, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_1C49: // Incoming jump from 0x1C48, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 1C49 61 PUSH2 0x1c50 1C4C 61 PUSH2 0x1bf7 1C4F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C49 stack[0] = 0x1c50 } // Block ends with unconditional jump to 0x1bf7 label_1C50: // Incoming jump from 0x1C48, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @1C51 stack[-2] // @1C55 stack[-1] // @1C56 stack[-4] // @1C58 stack[-6] // @1C5B stack[-7] // @1C5D stack[-5] // } 1C50 5B JUMPDEST 1C51 81 DUP2 1C52 60 PUSH1 0x40 1C54 52 MSTORE 1C55 80 DUP1 1C56 93 SWAP4 1C57 50 POP 1C58 85 DUP6 1C59 81 DUP2 1C5A 52 MSTORE 1C5B 86 DUP7 1C5C 86 DUP7 1C5D 86 DUP7 1C5E 01 ADD 1C5F 11 GT 1C60 15 ISZERO 1C61 61 PUSH2 0x1c69 1C64 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1C54 memory[0x40:0x60] = stack[-2] // @1C56 stack[-4] = stack[-1] // @1C5A memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x1c69, if !(stack[-5] + stack[-6] > stack[-7]) label_1C65: // Incoming jump from 0x1C64, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @1C68 memory[0x00:0x00] } 1C65 60 PUSH1 0x00 1C67 80 DUP1 1C68 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C68 revert(memory[0x00:0x00]); } // Block terminates label_1C69: // Incoming jump from 0x1C64, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @1C6A stack[-6] // @1C6B stack[-5] // @1C6E stack[-1] // @1C70 msg.data[stack[-5]:stack[-5] + stack[-6]] // @1C7D stack[-4] // @1C7D stack[-8] // @1C7E stack[-7] // } 1C69 5B JUMPDEST 1C6A 85 DUP6 1C6B 85 DUP6 1C6C 60 PUSH1 0x20 1C6E 83 DUP4 1C6F 01 ADD 1C70 37 CALLDATACOPY 1C71 60 PUSH1 0x00 1C73 60 PUSH1 0x20 1C75 87 DUP8 1C76 83 DUP4 1C77 01 ADD 1C78 01 ADD 1C79 52 MSTORE 1C7A 50 POP 1C7B 50 POP 1C7C 50 POP 1C7D 93 SWAP4 1C7E 92 SWAP3 1C7F 50 POP 1C80 50 POP 1C81 50 POP 1C82 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @1C70 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @1C79 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @1C7D stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_1C83: // Incoming call from 0x03E4, returns to 0x03E5 // Inputs[2] // { // @1C88 stack[-1] // @1C89 stack[-2] // } 1C83 5B JUMPDEST 1C84 60 PUSH1 0x00 1C86 60 PUSH1 0x20 1C88 82 DUP3 1C89 84 DUP5 1C8A 03 SUB 1C8B 12 SLT 1C8C 15 ISZERO 1C8D 61 PUSH2 0x1c95 1C90 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C84 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c95, if !(stack[-2] - stack[-1] i< 0x20) label_1C91: // Incoming jump from 0x1C90, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1C94 memory[0x00:0x00] } 1C91 60 PUSH1 0x00 1C93 80 DUP1 1C94 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C94 revert(memory[0x00:0x00]); } // Block terminates label_1C95: // Incoming jump from 0x1C90, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1C96 stack[-2] // @1C97 msg.data[stack[-2]:stack[-2] + 0x20] // } 1C95 5B JUMPDEST 1C96 81 DUP2 1C97 35 CALLDATALOAD 1C98 67 PUSH8 0xffffffffffffffff 1CA1 81 DUP2 1CA2 11 GT 1CA3 15 ISZERO 1CA4 61 PUSH2 0x1cac 1CA7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C97 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1cac, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1CA8: // Incoming jump from 0x1CA7, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1CAB memory[0x00:0x00] } 1CA8 60 PUSH1 0x00 1CAA 80 DUP1 1CAB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CAB revert(memory[0x00:0x00]); } // Block terminates label_1CAC: // Incoming jump from 0x1CA7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1CAD stack[-3] // @1CAE stack[-1] // @1CB3 stack[-4] // } 1CAC 5B JUMPDEST 1CAD 82 DUP3 1CAE 01 ADD 1CAF 60 PUSH1 0x1f 1CB1 81 DUP2 1CB2 01 ADD 1CB3 84 DUP5 1CB4 13 SGT 1CB5 61 PUSH2 0x1cbd 1CB8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CAE stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1cbd, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1CB9: // Incoming jump from 0x1CB8, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1CBC memory[0x00:0x00] } 1CB9 60 PUSH1 0x00 1CBB 80 DUP1 1CBC FD *REVERT // Stack delta = +0 // Outputs[1] { @1CBC revert(memory[0x00:0x00]); } // Block terminates label_1CBD: // Incoming jump from 0x1CB8, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1CC1 stack[-4] // @1CC2 stack[-1] // @1CC3 msg.data[stack[-1]:stack[-1] + 0x20] // } 1CBD 5B JUMPDEST 1CBE 61 PUSH2 0x19b1 1CC1 84 DUP5 1CC2 82 DUP3 1CC3 35 CALLDATALOAD 1CC4 60 PUSH1 0x20 1CC6 84 DUP5 1CC7 01 ADD 1CC8 61 PUSH2 0x1c0d 1CCB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CBE stack[0] = 0x19b1 // @1CC1 stack[1] = stack[-4] // @1CC3 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1CC7 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1c0d, returns to 0x19B1 label_1CCC: // Incoming call from 0x07FE, returns to 0x07FF // Incoming call from 0x0404, returns to 0x0405 // Incoming call from 0x051D, returns to 0x051E // Incoming call from 0x0439, returns to 0x043A // Incoming call from 0x060A, returns to 0x060B // Inputs[2] // { // @1CD1 stack[-1] // @1CD2 stack[-2] // } 1CCC 5B JUMPDEST 1CCD 60 PUSH1 0x00 1CCF 60 PUSH1 0x20 1CD1 82 DUP3 1CD2 84 DUP5 1CD3 03 SUB 1CD4 12 SLT 1CD5 15 ISZERO 1CD6 61 PUSH2 0x1cde 1CD9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CCD stack[0] = 0x00 } // Block ends with conditional jump to 0x1cde, if !(stack[-2] - stack[-1] i< 0x20) label_1CDA: // Incoming jump from 0x1CD9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CDD memory[0x00:0x00] } 1CDA 60 PUSH1 0x00 1CDC 80 DUP1 1CDD FD *REVERT // Stack delta = +0 // Outputs[1] { @1CDD revert(memory[0x00:0x00]); } // Block terminates label_1CDE: // Incoming jump from 0x1CD9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CE2 stack[-2] } 1CDE 5B JUMPDEST 1CDF 61 PUSH2 0x0df5 1CE2 82 DUP3 1CE3 61 PUSH2 0x1a68 1CE6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CDF stack[0] = 0x0df5 // @1CE2 stack[1] = stack[-2] // } // Block ends with call to 0x1a68, returns to 0x0DF5 label_1CE7: // Incoming call from 0x044B, returns to 0x022A // Inputs[3] // { // @1CEB stack[-1] // @1CED stack[-2] // @1CEE memory[stack[-2]:stack[-2] + 0x20] // } 1CE7 5B JUMPDEST 1CE8 60 PUSH1 0x20 1CEA 80 DUP1 1CEB 82 DUP3 1CEC 52 MSTORE 1CED 82 DUP3 1CEE 51 MLOAD 1CEF 82 DUP3 1CF0 82 DUP3 1CF1 01 ADD 1CF2 81 DUP2 1CF3 90 SWAP1 1CF4 52 MSTORE 1CF5 60 PUSH1 0x00 1CF7 91 SWAP2 1CF8 90 SWAP1 1CF9 84 DUP5 1CFA 82 DUP3 1CFB 01 ADD 1CFC 90 SWAP1 1CFD 60 PUSH1 0x40 1CFF 85 DUP6 1D00 01 ADD 1D01 90 SWAP1 1D02 84 DUP5 1D03 5B JUMPDEST 1D04 81 DUP2 1D05 81 DUP2 1D06 10 LT 1D07 15 ISZERO 1D08 61 PUSH2 0x0c4e 1D0B 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1CEC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1CF4 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1CF7 stack[0] = 0x00 // @1CF8 stack[1] = 0x20 // @1CFC stack[2] = 0x20 + stack[-2] // @1D01 stack[3] = stack[-1] + 0x40 // @1D01 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @1D02 stack[5] = 0x00 // } // Block ends with conditional jump to 0x0c4e, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1D0C: // Incoming jump from 0x1D0B, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1D0B, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @1D0C stack[-4] // @1D0D memory[stack[-4]:stack[-4] + 0x20] // @1D0E stack[-3] // @1D10 stack[-1] // @1D11 stack[-5] // } 1D0C 83 DUP4 1D0D 51 MLOAD 1D0E 83 DUP4 1D0F 52 MSTORE 1D10 92 SWAP3 1D11 84 DUP5 1D12 01 ADD 1D13 92 SWAP3 1D14 91 SWAP2 1D15 84 DUP5 1D16 01 ADD 1D17 91 SWAP2 1D18 60 PUSH1 0x01 1D1A 01 ADD 1D1B 61 PUSH2 0x1d03 1D1E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1D0F memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @1D13 stack[-4] = stack[-5] + stack[-4] // @1D17 stack[-3] = stack[-5] + stack[-3] // @1D1A stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1d03 label_1D1F: // Incoming call from 0x0490, returns to 0x0491 // Inputs[2] // { // @1D27 stack[-1] // @1D28 stack[-2] // } 1D1F 5B JUMPDEST 1D20 60 PUSH1 0x00 1D22 80 DUP1 1D23 60 PUSH1 0x00 1D25 60 PUSH1 0x60 1D27 84 DUP5 1D28 86 DUP7 1D29 03 SUB 1D2A 12 SLT 1D2B 15 ISZERO 1D2C 61 PUSH2 0x1d34 1D2F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D20 stack[0] = 0x00 // @1D22 stack[1] = 0x00 // @1D23 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1d34, if !(stack[-2] - stack[-1] i< 0x60) label_1D30: // Incoming jump from 0x1D2F, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D33 memory[0x00:0x00] } 1D30 60 PUSH1 0x00 1D32 80 DUP1 1D33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D33 revert(memory[0x00:0x00]); } // Block terminates label_1D34: // Incoming jump from 0x1D2F, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D38 stack[-4] } 1D34 5B JUMPDEST 1D35 61 PUSH2 0x1d3d 1D38 84 DUP5 1D39 61 PUSH2 0x1a68 1D3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D35 stack[0] = 0x1d3d // @1D38 stack[1] = stack[-4] // } // Block ends with call to 0x1a68, returns to 0x1D3D label_1D3D: // Incoming return from call to 0x1A68 at 0x1D3C // Inputs[7] // { // @1D3E stack[-1] // @1D3E stack[-7] // @1D41 stack[-5] // @1D43 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1D44 stack[-6] // @1D4B msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1D4D stack[-4] // } 1D3D 5B JUMPDEST 1D3E 95 SWAP6 1D3F 60 PUSH1 0x20 1D41 85 DUP6 1D42 01 ADD 1D43 35 CALLDATALOAD 1D44 95 SWAP6 1D45 50 POP 1D46 60 PUSH1 0x40 1D48 90 SWAP1 1D49 94 SWAP5 1D4A 01 ADD 1D4B 35 CALLDATALOAD 1D4C 93 SWAP4 1D4D 92 SWAP3 1D4E 50 POP 1D4F 50 POP 1D50 50 POP 1D51 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1D3E stack[-7] = stack[-1] // @1D44 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1D4C stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_1D52: // Incoming call from 0x2037, returns to 0x0DF5 // Incoming call from 0x1D8B, returns to 0x1D8C // Inputs[1] { @1D53 stack[-1] } 1D52 5B JUMPDEST 1D53 80 DUP1 1D54 15 ISZERO 1D55 15 ISZERO 1D56 81 DUP2 1D57 14 EQ 1D58 61 PUSH2 0x0903 1D5B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0903, if stack[-1] == !!stack[-1] label_1D5C: // Incoming jump from 0x1D5B, if not stack[-1] == !!stack[-1] // Inputs[1] { @1D5F memory[0x00:0x00] } 1D5C 60 PUSH1 0x00 1D5E 80 DUP1 1D5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1D5F revert(memory[0x00:0x00]); } // Block terminates label_1D60: // Incoming call from 0x062A, returns to 0x062B // Incoming call from 0x04CA, returns to 0x04CB // Inputs[2] // { // @1D66 stack[-1] // @1D67 stack[-2] // } 1D60 5B JUMPDEST 1D61 60 PUSH1 0x00 1D63 80 DUP1 1D64 60 PUSH1 0x40 1D66 83 DUP4 1D67 85 DUP6 1D68 03 SUB 1D69 12 SLT 1D6A 15 ISZERO 1D6B 61 PUSH2 0x1d73 1D6E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D61 stack[0] = 0x00 // @1D63 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d73, if !(stack[-2] - stack[-1] i< 0x40) label_1D6F: // Incoming jump from 0x1D6E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D72 memory[0x00:0x00] } 1D6F 60 PUSH1 0x00 1D71 80 DUP1 1D72 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D72 revert(memory[0x00:0x00]); } // Block terminates label_1D73: // Incoming jump from 0x1D6E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D77 stack[-3] } 1D73 5B JUMPDEST 1D74 61 PUSH2 0x1d7c 1D77 83 DUP4 1D78 61 PUSH2 0x1a68 1D7B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D74 stack[0] = 0x1d7c // @1D77 stack[1] = stack[-3] // } // Block ends with call to 0x1a68, returns to 0x1D7C label_1D7C: // Incoming return from call to 0x1A68 at 0x1D7B // Inputs[4] // { // @1D7D stack[-3] // @1D7D stack[-1] // @1D81 stack[-4] // @1D83 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1D7C 5B JUMPDEST 1D7D 91 SWAP2 1D7E 50 POP 1D7F 60 PUSH1 0x20 1D81 83 DUP4 1D82 01 ADD 1D83 35 CALLDATALOAD 1D84 61 PUSH2 0x1d8c 1D87 81 DUP2 1D88 61 PUSH2 0x1d52 1D8B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1D7D stack[-3] = stack[-1] // @1D83 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1D84 stack[0] = 0x1d8c // @1D87 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x1d52, returns to 0x1D8C label_1D8C: // Incoming return from call to 0x1D52 at 0x1D8B // Inputs[6] // { // @1D8D stack[-1] // @1D8E stack[-2] // @1D91 stack[-5] // @1D93 stack[-3] // @1D93 stack[-6] // @1D94 stack[-4] // } 1D8C 5B JUMPDEST 1D8D 80 DUP1 1D8E 91 SWAP2 1D8F 50 POP 1D90 50 POP 1D91 92 SWAP3 1D92 50 POP 1D93 92 SWAP3 1D94 90 SWAP1 1D95 50 POP 1D96 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D91 stack[-5] = stack[-1] // @1D93 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1D97: // Incoming call from 0x04FD, returns to 0x04FE // Inputs[2] // { // @1DA0 stack[-1] // @1DA1 stack[-2] // } 1D97 5B JUMPDEST 1D98 60 PUSH1 0x00 1D9A 80 DUP1 1D9B 60 PUSH1 0x00 1D9D 80 DUP1 1D9E 60 PUSH1 0x80 1DA0 85 DUP6 1DA1 87 DUP8 1DA2 03 SUB 1DA3 12 SLT 1DA4 15 ISZERO 1DA5 61 PUSH2 0x1dad 1DA8 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1D98 stack[0] = 0x00 // @1D9A stack[1] = 0x00 // @1D9B stack[2] = 0x00 // @1D9D stack[3] = 0x00 // } // Block ends with conditional jump to 0x1dad, if !(stack[-2] - stack[-1] i< 0x80) label_1DA9: // Incoming jump from 0x1DA8, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1DAC memory[0x00:0x00] } 1DA9 60 PUSH1 0x00 1DAB 80 DUP1 1DAC FD *REVERT // Stack delta = +0 // Outputs[1] { @1DAC revert(memory[0x00:0x00]); } // Block terminates label_1DAD: // Incoming jump from 0x1DA8, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1DB1 stack[-5] } 1DAD 5B JUMPDEST 1DAE 61 PUSH2 0x1db6 1DB1 85 DUP6 1DB2 61 PUSH2 0x1a68 1DB5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DAE stack[0] = 0x1db6 // @1DB1 stack[1] = stack[-5] // } // Block ends with call to 0x1a68, returns to 0x1DB6 label_1DB6: // Incoming return from call to 0x1A68 at 0x1DB5 // Inputs[3] // { // @1DB7 stack[-5] // @1DB7 stack[-1] // @1DBE stack[-6] // } 1DB6 5B JUMPDEST 1DB7 93 SWAP4 1DB8 50 POP 1DB9 61 PUSH2 0x1dc4 1DBC 60 PUSH1 0x20 1DBE 86 DUP7 1DBF 01 ADD 1DC0 61 PUSH2 0x1a68 1DC3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1DB7 stack[-5] = stack[-1] // @1DB9 stack[-1] = 0x1dc4 // @1DBF stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1a68, returns to 0x1DC4 label_1DC4: // Incoming return from call to 0x1A68 at 0x1DC3 // Inputs[6] // { // @1DC5 stack[-1] // @1DC5 stack[-4] // @1DC9 stack[-6] // @1DCB msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1DCC stack[-3] // @1DD2 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1DC4 5B JUMPDEST 1DC5 92 SWAP3 1DC6 50 POP 1DC7 60 PUSH1 0x40 1DC9 85 DUP6 1DCA 01 ADD 1DCB 35 CALLDATALOAD 1DCC 91 SWAP2 1DCD 50 POP 1DCE 60 PUSH1 0x60 1DD0 85 DUP6 1DD1 01 ADD 1DD2 35 CALLDATALOAD 1DD3 67 PUSH8 0xffffffffffffffff 1DDC 81 DUP2 1DDD 11 GT 1DDE 15 ISZERO 1DDF 61 PUSH2 0x1de7 1DE2 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1DC5 stack[-4] = stack[-1] // @1DCC stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1DD2 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1de7, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1DE3: // Incoming jump from 0x1DE2, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1DE6 memory[0x00:0x00] } 1DE3 60 PUSH1 0x00 1DE5 80 DUP1 1DE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DE6 revert(memory[0x00:0x00]); } // Block terminates label_1DE7: // Incoming jump from 0x1DE2, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1DE8 stack[-6] // @1DE9 stack[-1] // @1DEE stack[-7] // } 1DE7 5B JUMPDEST 1DE8 85 DUP6 1DE9 01 ADD 1DEA 60 PUSH1 0x1f 1DEC 81 DUP2 1DED 01 ADD 1DEE 87 DUP8 1DEF 13 SGT 1DF0 61 PUSH2 0x1df8 1DF3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1DE9 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1df8, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1DF4: // Incoming jump from 0x1DF3, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1DF7 memory[0x00:0x00] } 1DF4 60 PUSH1 0x00 1DF6 80 DUP1 1DF7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DF7 revert(memory[0x00:0x00]); } // Block terminates label_1DF8: // Incoming jump from 0x1DF3, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1DFC stack[-7] // @1DFD stack[-1] // @1DFE msg.data[stack[-1]:stack[-1] + 0x20] // } 1DF8 5B JUMPDEST 1DF9 61 PUSH2 0x1e07 1DFC 87 DUP8 1DFD 82 DUP3 1DFE 35 CALLDATALOAD 1DFF 60 PUSH1 0x20 1E01 84 DUP5 1E02 01 ADD 1E03 61 PUSH2 0x1c0d 1E06 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DF9 stack[0] = 0x1e07 // @1DFC stack[1] = stack[-7] // @1DFE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1E02 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1c0d, returns to 0x1E07 label_1E07: // Incoming return from call to 0x1C0D at 0x1E06 // Inputs[8] // { // @1E08 stack[-1] // @1E08 stack[-3] // @1E0B stack[-6] // @1E0C stack[-9] // @1E0D stack[-5] // @1E0E stack[-8] // @1E10 stack[-4] // @1E10 stack[-7] // } 1E07 5B JUMPDEST 1E08 91 SWAP2 1E09 50 POP 1E0A 50 POP 1E0B 92 SWAP3 1E0C 95 SWAP6 1E0D 91 SWAP2 1E0E 94 SWAP5 1E0F 50 POP 1E10 92 SWAP3 1E11 50 POP 1E12 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1E0B stack[-6] = stack[-1] // @1E0C stack[-9] = stack[-6] // @1E0E stack[-8] = stack[-5] // @1E10 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1E13: // Incoming call from 0x054F, returns to 0x022A // Inputs[2] // { // @1E16 stack[-1] // @1E1C stack[-2] // } 1E13 5B JUMPDEST 1E14 60 PUSH1 0x80 1E16 81 DUP2 1E17 01 ADD 1E18 61 PUSH2 0x067c 1E1B 82 DUP3 1E1C 84 DUP5 1E1D 61 PUSH2 0x1b78 1E20 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E17 stack[0] = stack[-1] + 0x80 // @1E18 stack[1] = 0x067c // @1E1B stack[2] = stack[-1] // @1E1C stack[3] = stack[-2] // } // Block ends with call to 0x1b78, returns to 0x067C label_1E21: // Incoming call from 0x05A0, returns to 0x05A1 // Inputs[2] // { // @1E27 stack[-1] // @1E28 stack[-2] // } 1E21 5B JUMPDEST 1E22 60 PUSH1 0x00 1E24 80 DUP1 1E25 60 PUSH1 0x40 1E27 83 DUP4 1E28 85 DUP6 1E29 03 SUB 1E2A 12 SLT 1E2B 15 ISZERO 1E2C 61 PUSH2 0x1e34 1E2F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E22 stack[0] = 0x00 // @1E24 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e34, if !(stack[-2] - stack[-1] i< 0x40) label_1E30: // Incoming jump from 0x1E2F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E33 memory[0x00:0x00] } 1E30 60 PUSH1 0x00 1E32 80 DUP1 1E33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E33 revert(memory[0x00:0x00]); } // Block terminates label_1E34: // Incoming jump from 0x1E2F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E38 stack[-3] } 1E34 5B JUMPDEST 1E35 61 PUSH2 0x1e3d 1E38 83 DUP4 1E39 61 PUSH2 0x1a68 1E3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E35 stack[0] = 0x1e3d // @1E38 stack[1] = stack[-3] // } // Block ends with call to 0x1a68, returns to 0x1E3D label_1E3D: // Incoming return from call to 0x1A68 at 0x1E3C // Inputs[3] // { // @1E3E stack[-3] // @1E3E stack[-1] // @1E45 stack[-4] // } 1E3D 5B JUMPDEST 1E3E 91 SWAP2 1E3F 50 POP 1E40 61 PUSH2 0x1e4b 1E43 60 PUSH1 0x20 1E45 84 DUP5 1E46 01 ADD 1E47 61 PUSH2 0x1a68 1E4A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1E3E stack[-3] = stack[-1] // @1E40 stack[-1] = 0x1e4b // @1E46 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1a68, returns to 0x1E4B label_1E4B: // Incoming return from call to 0x1A68 at 0x1E4A // Inputs[6] // { // @1E4C stack[-2] // @1E4C stack[-1] // @1E4E stack[-5] // @1E50 stack[-3] // @1E50 stack[-6] // @1E51 stack[-4] // } 1E4B 5B JUMPDEST 1E4C 90 SWAP1 1E4D 50 POP 1E4E 92 SWAP3 1E4F 50 POP 1E50 92 SWAP3 1E51 90 SWAP1 1E52 50 POP 1E53 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1E4E stack[-5] = stack[-1] // @1E50 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1E54: // Incoming call from 0x0690, returns to 0x0691 // Incoming call from 0x0850, returns to 0x0851 // Incoming call from 0x1F53, returns to 0x1F54 // Incoming call from 0x0C81, returns to 0x0691 // Incoming call from 0x06BC, returns to 0x06BD // Incoming call from 0x0824, returns to 0x0825 // Incoming call from 0x1708, returns to 0x0691 // Inputs[1] { @1E57 stack[-1] } 1E54 5B JUMPDEST 1E55 60 PUSH1 0x01 1E57 81 DUP2 1E58 81 DUP2 1E59 1C SHR 1E5A 90 SWAP1 1E5B 82 DUP3 1E5C 16 AND 1E5D 80 DUP1 1E5E 61 PUSH2 0x1e68 1E61 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E5A stack[0] = stack[-1] >> 0x01 // @1E5C stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1e68, if stack[-1] & 0x01 label_1E62: // Incoming jump from 0x1E61, if not stack[-1] & 0x01 // Inputs[2] // { // @1E64 stack[-2] // @1E6D stack[-1] // } 1E62 60 PUSH1 0x7f 1E64 82 DUP3 1E65 16 AND 1E66 91 SWAP2 1E67 50 POP 1E68 5B JUMPDEST 1E69 60 PUSH1 0x20 1E6B 82 DUP3 1E6C 10 LT 1E6D 81 DUP2 1E6E 03 SUB 1E6F 61 PUSH2 0x1e88 1E72 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E66 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1e88, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1E73: // Incoming jump from 0x1E72, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x1E72, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @1E87 memory[0x00:0x24] } 1E73 63 PUSH4 0x4e487b71 1E78 60 PUSH1 0xe0 1E7A 1B SHL 1E7B 60 PUSH1 0x00 1E7D 52 MSTORE 1E7E 60 PUSH1 0x22 1E80 60 PUSH1 0x04 1E82 52 MSTORE 1E83 60 PUSH1 0x24 1E85 60 PUSH1 0x00 1E87 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E7D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E82 memory[0x04:0x24] = 0x22 // @1E87 revert(memory[0x00:0x24]); // } // Block terminates label_1E88: // Incoming jump from 0x1E72, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x1E72, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @1E8A stack[-4] // @1E8A stack[-2] // @1E8B stack[-3] // } 1E88 5B JUMPDEST 1E89 50 POP 1E8A 91 SWAP2 1E8B 90 SWAP1 1E8C 50 POP 1E8D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E8A stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1E8E: // Incoming jump from 0x1EB6 // Incoming jump from 0x1EDE // Inputs[1] { @1EA3 memory[0x00:0x24] } 1E8E 5B JUMPDEST 1E8F 63 PUSH4 0x4e487b71 1E94 60 PUSH1 0xe0 1E96 1B SHL 1E97 60 PUSH1 0x00 1E99 52 MSTORE 1E9A 60 PUSH1 0x11 1E9C 60 PUSH1 0x04 1E9E 52 MSTORE 1E9F 60 PUSH1 0x24 1EA1 60 PUSH1 0x00 1EA3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E99 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E9E memory[0x04:0x24] = 0x11 // @1EA3 revert(memory[0x00:0x24]); // } // Block terminates label_1EA4: // Incoming call from 0x07BE, returns to 0x07BF // Inputs[2] // { // @1EA5 stack[-1] // @1EA6 stack[-2] // } 1EA4 5B JUMPDEST 1EA5 80 DUP1 1EA6 82 DUP3 1EA7 01 ADD 1EA8 80 DUP1 1EA9 82 DUP3 1EAA 11 GT 1EAB 15 ISZERO 1EAC 61 PUSH2 0x067c 1EAF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EA7 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x067c, if !(stack[-1] > stack[-2] + stack[-1]) label_1EB0: // Incoming jump from 0x1EAF, if not !(stack[-1] > stack[-2] + stack[-1]) 1EB0 61 PUSH2 0x067c 1EB3 61 PUSH2 0x1e8e 1EB6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EB0 stack[0] = 0x067c } // Block ends with unconditional jump to 0x1e8e label_1EB7: // Incoming jump from 0x09EB // Incoming jump from 0x07E9 // Incoming jump from 0x0DD3 // Incoming jump from 0x0A09 // Incoming jump from 0x0C38 // Inputs[1] { @1ECC memory[0x00:0x24] } 1EB7 5B JUMPDEST 1EB8 63 PUSH4 0x4e487b71 1EBD 60 PUSH1 0xe0 1EBF 1B SHL 1EC0 60 PUSH1 0x00 1EC2 52 MSTORE 1EC3 60 PUSH1 0x32 1EC5 60 PUSH1 0x04 1EC7 52 MSTORE 1EC8 60 PUSH1 0x24 1ECA 60 PUSH1 0x00 1ECC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1EC2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1EC7 memory[0x04:0x24] = 0x32 // @1ECC revert(memory[0x00:0x24]); // } // Block terminates label_1ECD: // Incoming call from 0x080F, returns to 0x0810 // Inputs[1] { @1ED2 stack[-1] } 1ECD 5B JUMPDEST 1ECE 60 PUSH1 0x00 1ED0 60 PUSH1 0x01 1ED2 82 DUP3 1ED3 01 ADD 1ED4 61 PUSH2 0x1edf 1ED7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1ECE stack[0] = 0x00 } // Block ends with conditional jump to 0x1edf, if stack[-1] + 0x01 label_1ED8: // Incoming jump from 0x1ED7, if not stack[-1] + 0x01 1ED8 61 PUSH2 0x1edf 1EDB 61 PUSH2 0x1e8e 1EDE 56 *JUMP // Stack delta = +1 // Outputs[1] { @1ED8 stack[0] = 0x1edf } // Block ends with unconditional jump to 0x1e8e label_1EDF: // Incoming jump from 0x1ED7, if stack[-1] + 0x01 // Inputs[2] // { // @1EE3 stack[-2] // @1EE4 stack[-3] // } 1EDF 5B JUMPDEST 1EE0 50 POP 1EE1 60 PUSH1 0x01 1EE3 01 ADD 1EE4 90 SWAP1 1EE5 56 *JUMP // Stack delta = -2 // Outputs[1] { @1EE4 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1EE6: // Incoming jump from 0x1F59 // Inputs[1] { @1EE9 stack[-2] } 1EE6 5B JUMPDEST 1EE7 60 PUSH1 0x1f 1EE9 82 DUP3 1EEA 11 GT 1EEB 15 ISZERO 1EEC 61 PUSH2 0x076c 1EEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076c, if !(stack[-2] > 0x1f) label_1EF0: // Incoming jump from 0x1EEF, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @1EF2 stack[-1] // @1EF8 memory[0x00:0x20] // @1EFB stack[-3] // } 1EF0 60 PUSH1 0x00 1EF2 81 DUP2 1EF3 81 DUP2 1EF4 52 MSTORE 1EF5 60 PUSH1 0x20 1EF7 81 DUP2 1EF8 20 SHA3 1EF9 60 PUSH1 0x1f 1EFB 85 DUP6 1EFC 01 ADD 1EFD 60 PUSH1 0x05 1EFF 1C SHR 1F00 81 DUP2 1F01 01 ADD 1F02 60 PUSH1 0x20 1F04 86 DUP7 1F05 10 LT 1F06 15 ISZERO 1F07 61 PUSH2 0x1f0d 1F0A 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1EF0 stack[0] = 0x00 // @1EF4 memory[0x00:0x20] = stack[-1] // @1EF8 stack[1] = keccak256(memory[0x00:0x20]) // @1F01 stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1f0d, if !(stack[-3] < 0x20) label_1F0B: // Incoming jump from 0x1F0A, if not !(stack[-3] < 0x20) // Inputs[2] // { // @1F0C stack[-2] // @1F10 stack[-5] // } 1F0B 50 POP 1F0C 80 DUP1 1F0D 5B JUMPDEST 1F0E 60 PUSH1 0x1f 1F10 85 DUP6 1F11 01 ADD 1F12 60 PUSH1 0x05 1F14 1C SHR 1F15 82 DUP3 1F16 01 ADD 1F17 91 SWAP2 1F18 50 POP 1F19 5B JUMPDEST 1F1A 81 DUP2 1F1B 81 DUP2 1F1C 10 LT 1F1D 15 ISZERO 1F1E 61 PUSH2 0x13b9 1F21 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F0C stack[-1] = stack[-2] // @1F17 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x13b9, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_1F22: // Incoming jump from 0x1F21, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x1F21, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x1F21, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[2] // { // @1F22 stack[-3] // @1F23 stack[-1] // } 1F22 82 DUP3 1F23 81 DUP2 1F24 55 SSTORE 1F25 60 PUSH1 0x01 1F27 01 ADD 1F28 61 PUSH2 0x1f19 1F2B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F24 storage[stack[-1]] = stack[-3] // @1F27 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f19 label_1F2C: // Incoming call from 0x0AE9, returns to 0x0AEA // Inputs[2] // { // @1F2D stack[-2] // @1F2E memory[stack[-2]:stack[-2] + 0x20] // } 1F2C 5B JUMPDEST 1F2D 81 DUP2 1F2E 51 MLOAD 1F2F 67 PUSH8 0xffffffffffffffff 1F38 81 DUP2 1F39 11 GT 1F3A 15 ISZERO 1F3B 61 PUSH2 0x1f46 1F3E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F2E stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1f46, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1F3F: // Incoming jump from 0x1F3E, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1F3F 61 PUSH2 0x1f46 1F42 61 PUSH2 0x1bf7 1F45 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F3F stack[0] = 0x1f46 } // Block ends with unconditional jump to 0x1bf7 label_1F46: // Incoming jump from 0x1F3E, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1F4A stack[-1] // @1F4E stack[-2] // @1F4F storage[stack[-2]] // } 1F46 5B JUMPDEST 1F47 61 PUSH2 0x1f5a 1F4A 81 DUP2 1F4B 61 PUSH2 0x1f54 1F4E 84 DUP5 1F4F 54 SLOAD 1F50 61 PUSH2 0x1e54 1F53 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F47 stack[0] = 0x1f5a // @1F4A stack[1] = stack[-1] // @1F4B stack[2] = 0x1f54 // @1F4F stack[3] = storage[stack[-2]] // } // Block ends with call to 0x1e54, returns to 0x1F54 label_1F54: // Incoming return from call to 0x1E54 at 0x1F53 // Inputs[1] { @1F55 stack[-5] } 1F54 5B JUMPDEST 1F55 84 DUP5 1F56 61 PUSH2 0x1ee6 1F59 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F55 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x1ee6 label_1F5A: // Incoming return from call to 0x1F54 at 0x1F53 // Inputs[1] { @1F60 stack[-1] } 1F5A 5B JUMPDEST 1F5B 60 PUSH1 0x20 1F5D 80 DUP1 1F5E 60 PUSH1 0x1f 1F60 83 DUP4 1F61 11 GT 1F62 60 PUSH1 0x01 1F64 81 DUP2 1F65 14 EQ 1F66 61 PUSH2 0x1f8f 1F69 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1F5B stack[0] = 0x20 // @1F5D stack[1] = 0x20 // @1F61 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x1f8f, if (stack[-1] > 0x1f) == 0x01 label_1F6A: // Incoming jump from 0x1F69, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @1F6C stack[-4] } 1F6A 60 PUSH1 0x00 1F6C 84 DUP5 1F6D 15 ISZERO 1F6E 61 PUSH2 0x1f77 1F71 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F6A stack[0] = 0x00 } // Block ends with conditional jump to 0x1f77, if !stack[-4] label_1F72: // Incoming jump from 0x1F71, if not !stack[-4] // Inputs[5] // { // @1F73 stack[-7] // @1F74 stack[-4] // @1F76 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @1F7D stack[-5] // @1F89 stack[-6] // } 1F72 50 POP 1F73 85 DUP6 1F74 83 DUP4 1F75 01 ADD 1F76 51 MLOAD 1F77 5B JUMPDEST 1F78 60 PUSH1 0x00 1F7A 19 NOT 1F7B 60 PUSH1 0x03 1F7D 86 DUP7 1F7E 90 SWAP1 1F7F 1B SHL 1F80 1C SHR 1F81 19 NOT 1F82 16 AND 1F83 60 PUSH1 0x01 1F85 85 DUP6 1F86 90 SWAP1 1F87 1B SHL 1F88 17 OR 1F89 85 DUP6 1F8A 55 SSTORE 1F8B 61 PUSH2 0x13b9 1F8E 56 *JUMP // Stack delta = -1 // Outputs[1] { @1F8A storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x13b9 label_1F8F: // Incoming jump from 0x1F69, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @1F92 stack[-5] // @1F98 memory[0x00:0x20] // @1F9C stack[-4] // } 1F8F 5B JUMPDEST 1F90 60 PUSH1 0x00 1F92 85 DUP6 1F93 81 DUP2 1F94 52 MSTORE 1F95 60 PUSH1 0x20 1F97 81 DUP2 1F98 20 SHA3 1F99 60 PUSH1 0x1f 1F9B 19 NOT 1F9C 86 DUP7 1F9D 16 AND 1F9E 91 SWAP2 1F9F 5B JUMPDEST 1FA0 82 DUP3 1FA1 81 DUP2 1FA2 10 LT 1FA3 15 ISZERO 1FA4 61 PUSH2 0x1fbe 1FA7 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1F94 memory[0x00:0x20] = stack[-5] // @1F98 stack[1] = keccak256(memory[0x00:0x20]) // @1F9E stack[0] = stack[-4] & ~0x1f // @1F9E stack[2] = 0x00 // } // Block ends with conditional jump to 0x1fbe, if !(0x00 < stack[-4] & ~0x1f) label_1FA8: // Incoming jump from 0x1FA7, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x1FA7, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @1FA8 stack[-9] // @1FA9 stack[-6] // @1FAB memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @1FAC stack[-2] // @1FAE stack[-1] // @1FAF stack[-5] // } 1FA8 88 DUP9 1FA9 86 DUP7 1FAA 01 ADD 1FAB 51 MLOAD 1FAC 82 DUP3 1FAD 55 SSTORE 1FAE 94 SWAP5 1FAF 84 DUP5 1FB0 01 ADD 1FB1 94 SWAP5 1FB2 60 PUSH1 0x01 1FB4 90 SWAP1 1FB5 91 SWAP2 1FB6 01 ADD 1FB7 90 SWAP1 1FB8 84 DUP5 1FB9 01 ADD 1FBA 61 PUSH2 0x1f9f 1FBD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FAD storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @1FB1 stack[-6] = stack[-5] + stack[-6] // @1FB7 stack[-2] = stack[-2] + 0x01 // @1FB9 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x1f9f label_1FBE: // Incoming jump from 0x1FA7, if !(stack[-1] < stack[-3]) // Incoming jump from 0x1FA7, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @1FC0 stack[-7] // @1FC1 stack[-3] // } 1FBE 5B JUMPDEST 1FBF 50 POP 1FC0 85 DUP6 1FC1 82 DUP3 1FC2 10 LT 1FC3 15 ISZERO 1FC4 61 PUSH2 0x1fdc 1FC7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1fdc, if !(stack[-3] < stack[-7]) label_1FC8: // Incoming jump from 0x1FC7, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @1FC8 stack[-8] // @1FC9 stack[-5] // @1FCB memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @1FD1 stack[-6] // @1FDA stack[-1] // @1FE8 stack[-7] // @1FEB stack[-9] // } 1FC8 87 DUP8 1FC9 85 DUP6 1FCA 01 ADD 1FCB 51 MLOAD 1FCC 60 PUSH1 0x00 1FCE 19 NOT 1FCF 60 PUSH1 0x03 1FD1 88 DUP9 1FD2 90 SWAP1 1FD3 1B SHL 1FD4 60 PUSH1 0xf8 1FD6 16 AND 1FD7 1C SHR 1FD8 19 NOT 1FD9 16 AND 1FDA 81 DUP2 1FDB 55 SSTORE 1FDC 5B JUMPDEST 1FDD 50 POP 1FDE 50 POP 1FDF 50 POP 1FE0 50 POP 1FE1 50 POP 1FE2 60 PUSH1 0x01 1FE4 90 SWAP1 1FE5 81 DUP2 1FE6 1B SHL 1FE7 01 ADD 1FE8 90 SWAP1 1FE9 55 SSTORE 1FEA 50 POP 1FEB 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @1FDB storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @1FE9 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] 1FEC 5B JUMPDEST 1FED 60 PUSH1 0x00 1FEF 83 DUP4 1FF0 51 MLOAD 1FF1 61 PUSH2 0x1ffe 1FF4 81 DUP2 1FF5 84 DUP5 1FF6 60 PUSH1 0x20 1FF8 88 DUP9 1FF9 01 ADD 1FFA 61 PUSH2 0x19ec 1FFD 56 *JUMP 1FFE 5B JUMPDEST 1FFF 83 DUP4 2000 51 MLOAD 2001 90 SWAP1 2002 83 DUP4 2003 01 ADD 2004 90 SWAP1 2005 61 PUSH2 0x2012 2008 81 DUP2 2009 83 DUP4 200A 60 PUSH1 0x20 200C 88 DUP9 200D 01 ADD 200E 61 PUSH2 0x19ec 2011 56 *JUMP 2012 5B JUMPDEST 2013 01 ADD 2014 94 SWAP5 2015 93 SWAP4 2016 50 POP 2017 50 POP 2018 50 POP 2019 50 POP 201A 56 *JUMP label_201B: // Incoming call from 0x1167, returns to 0x1168 // Inputs[2] // { // @2020 stack[-1] // @2021 stack[-2] // } 201B 5B JUMPDEST 201C 60 PUSH1 0x00 201E 60 PUSH1 0x20 2020 82 DUP3 2021 84 DUP5 2022 03 SUB 2023 12 SLT 2024 15 ISZERO 2025 61 PUSH2 0x202d 2028 57 *JUMPI // Stack delta = +1 // Outputs[1] { @201C stack[0] = 0x00 } // Block ends with conditional jump to 0x202d, if !(stack[-2] - stack[-1] i< 0x20) label_2029: // Incoming jump from 0x2028, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @202C memory[0x00:0x00] } 2029 60 PUSH1 0x00 202B 80 DUP1 202C FD *REVERT // Stack delta = +0 // Outputs[1] { @202C revert(memory[0x00:0x00]); } // Block terminates label_202D: // Incoming jump from 0x2028, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @202E stack[-2] // @202F memory[stack[-2]:stack[-2] + 0x20] // } 202D 5B JUMPDEST 202E 81 DUP2 202F 51 MLOAD 2030 61 PUSH2 0x0df5 2033 81 DUP2 2034 61 PUSH2 0x1d52 2037 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @202F stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2030 stack[1] = 0x0df5 // @2033 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1d52, returns to 0x0DF5 2038 5B JUMPDEST 2039 60 PUSH1 0x01 203B 60 PUSH1 0x01 203D 60 PUSH1 0xa0 203F 1B SHL 2040 03 SUB 2041 85 DUP6 2042 81 DUP2 2043 16 AND 2044 82 DUP3 2045 52 MSTORE 2046 84 DUP5 2047 16 AND 2048 60 PUSH1 0x20 204A 82 DUP3 204B 01 ADD 204C 52 MSTORE 204D 60 PUSH1 0x40 204F 81 DUP2 2050 01 ADD 2051 83 DUP4 2052 90 SWAP1 2053 52 MSTORE 2054 60 PUSH1 0x80 2056 60 PUSH1 0x60 2058 82 DUP3 2059 01 ADD 205A 81 DUP2 205B 90 SWAP1 205C 52 MSTORE 205D 60 PUSH1 0x00 205F 90 SWAP1 2060 61 PUSH2 0x206b 2063 90 SWAP1 2064 83 DUP4 2065 01 ADD 2066 84 DUP5 2067 61 PUSH2 0x1a10 206A 56 *JUMP 206B 5B JUMPDEST 206C 96 SWAP7 206D 95 SWAP6 206E 50 POP 206F 50 POP 2070 50 POP 2071 50 POP 2072 50 POP 2073 50 POP 2074 56 *JUMP 2075 5B JUMPDEST 2076 60 PUSH1 0x00 2078 60 PUSH1 0x20 207A 82 DUP3 207B 84 DUP5 207C 03 SUB 207D 12 SLT 207E 15 ISZERO 207F 61 PUSH2 0x2087 2082 57 *JUMPI 2083 60 PUSH1 0x00 2085 80 DUP1 2086 FD *REVERT 2087 5B JUMPDEST 2088 81 DUP2 2089 51 MLOAD 208A 61 PUSH2 0x0df5 208D 81 DUP2 208E 61 PUSH2 0x19b9 2091 56 *JUMP 2092 FE *ASSERT 2093 DD DD 2094 F2 CALLCODE 2095 52 MSTORE 2096 AD AD 2097 1B SHL 2098 E2 E2 2099 C8 C8 209A 9B SWAP12 209B 69 PUSH10 0xc2b068fc378daa952ba7 20A6 F1 CALL 20A7 63 PUSH4 0xc4a11628 20AC F5 CREATE2 20AD 5A GAS 20AE 4D 4D 20AF F5 CREATE2 20B0 23 23 20B1 B3 B3 20B2 EF EF 20B3 A2 LOG2 20B4 64 PUSH5 0x6970667358 20BA 22 22 20BB 12 SLT 20BC 20 SHA3 20BD 4E 4E 20BE B5 B5 20BF 64 PUSH5 0xe2d07fd404 20C5 36 CALLDATASIZE 20C6 5B JUMPDEST 20C7 4D 4D 20C8 5C 5C 20C9 59 MSIZE 20CA 5C 5C 20CB D4 D4 20CC AB AB 20CD 17 OR 20CE 0E 0E 20CF E3 E3 20D0 1B SHL 20D1 99 SWAP10 20D2 2D 2D 20D3 1B SHL 20D4 AB AB 20D5 67 PUSH8 0x1a40a7ff914fde64 20DE 73 PUSH20 0x6f6c63430008120033