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 0x01f8 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01f8, 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 0xc40018b0 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0xc40018b0 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc40018b0 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xcfc86f7b 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xcfc86f7b > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xcfc86f7b > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xcfc86f7b 003A 14 EQ 003B 61 PUSH2 0x0535 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0535, if 0xcfc86f7b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xcfc86f7b == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe06f6b5c 0045 14 EQ 0046 61 PUSH2 0x054a 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054a, if 0xe06f6b5c == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe06f6b5c == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x0577 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0577, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xee318b8b 005B 14 EQ 005C 61 PUSH2 0x05c0 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c0, if 0xee318b8b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xee318b8b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x05d6 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d6, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == 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 0xcfc86f7b > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xc40018b0 0076 14 EQ 0077 61 PUSH2 0x04d6 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d6, if 0xc40018b0 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xc40018b0 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc61b5862 0081 14 EQ 0082 61 PUSH2 0x04ec 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if 0xc61b5862 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc61b5862 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc87b56dd 008C 14 EQ 008D 61 PUSH2 0x0502 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0502, if 0xc87b56dd == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xce6df2b9 0097 14 EQ 0098 61 PUSH2 0x0522 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0522, if 0xce6df2b9 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xce6df2b9 == 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 0xc40018b0 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x8da5cb5b 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x8da5cb5b > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8da5cb5b 00B2 14 EQ 00B3 61 PUSH2 0x0470 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0470, if 0x8da5cb5b == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 14 EQ 00BE 61 PUSH2 0x048e 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0x95d89b41 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa22cb465 00C8 14 EQ 00C9 61 PUSH2 0x04a3 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a3, 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 0xb88d4fde 00D3 14 EQ 00D4 61 PUSH2 0x04c3 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c3, if 0xb88d4fde == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xb88d4fde == 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 0x8da5cb5b > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x715018a6 00E3 14 EQ 00E4 61 PUSH2 0x0406 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0406, 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 0x791a2519 00EE 14 EQ 00EF 61 PUSH2 0x041b 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041b, if 0x791a2519 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x791a2519 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x7cb64759 00F9 14 EQ 00FA 61 PUSH2 0x043b 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043b, if 0x7cb64759 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x7cb64759 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x88084605 0104 14 EQ 0105 61 PUSH2 0x045b 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045b, if 0x88084605 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x88084605 == 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 0x23b872dd 0114 11 GT 0115 61 PUSH2 0x0190 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x23b872dd > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x23b872dd > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x3ccfd60b 011F 11 GT 0120 61 PUSH2 0x015f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x3ccfd60b > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x3ccfd60b 012A 14 EQ 012B 61 PUSH2 0x037e 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037e, if 0x3ccfd60b == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x42842e0e 0135 14 EQ 0136 61 PUSH2 0x0393 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0393, if 0x42842e0e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x42842e0e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x4cdb4400 0140 14 EQ 0141 61 PUSH2 0x03a6 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a6, if 0x4cdb4400 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x4cdb4400 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6352211e 014B 14 EQ 014C 61 PUSH2 0x03c6 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c6, if 0x6352211e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6352211e == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x70a08231 0156 14 EQ 0157 61 PUSH2 0x03e6 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e6, 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 0x3ccfd60b > stack[-1] // Inputs[1] { @0160 stack[-1] } 015F 5B JUMPDEST 0160 80 DUP1 0161 63 PUSH4 0x23b872dd 0166 14 EQ 0167 61 PUSH2 0x030b 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030b, if 0x23b872dd == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x23b872dd == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x264cf8dc 0171 14 EQ 0172 61 PUSH2 0x031e 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031e, if 0x264cf8dc == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x264cf8dc == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x295439e1 017C 14 EQ 017D 61 PUSH2 0x033e 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033e, if 0x295439e1 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x295439e1 == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x30176e13 0187 14 EQ 0188 61 PUSH2 0x035e 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035e, if 0x30176e13 == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x30176e13 == 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 0x23b872dd > stack[-1] // Inputs[1] { @0191 stack[-1] } 0190 5B JUMPDEST 0191 80 DUP1 0192 63 PUSH4 0x095ea7b3 0197 11 GT 0198 61 PUSH2 0x01cc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if 0x095ea7b3 > stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x095ea7b3 01A2 14 EQ 01A3 61 PUSH2 0x02a1 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a1, if 0x095ea7b3 == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x0eb3d16c 01AD 14 EQ 01AE 61 PUSH2 0x02b4 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b4, if 0x0eb3d16c == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x0eb3d16c == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x0fa87335 01B8 14 EQ 01B9 61 PUSH2 0x02d8 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d8, if 0x0fa87335 == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x0fa87335 == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x18160ddd 01C3 14 EQ 01C4 61 PUSH2 0x02f2 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f2, if 0x18160ddd == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x18160ddd == 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 0x095ea7b3 > stack[-1] // Inputs[1] { @01CD stack[-1] } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 62 PUSH3 0xff070b 01D2 14 EQ 01D3 61 PUSH2 0x01fd 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fd, if 0xff070b == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0xff070b == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0x01ffc9a7 01DD 14 EQ 01DE 61 PUSH2 0x0212 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0212, if 0x01ffc9a7 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0x06fdde03 01E8 14 EQ 01E9 61 PUSH2 0x0247 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0247, if 0x06fdde03 == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01ED stack[-1] } 01ED 80 DUP1 01EE 63 PUSH4 0x081812fc 01F3 14 EQ 01F4 61 PUSH2 0x0269 01F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0269, if 0x081812fc == stack[-1] label_01F8: // Incoming jump from 0x01F7, if not 0x081812fc == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @01FC memory[0x00:0x00] } 01F8 5B JUMPDEST 01F9 60 PUSH1 0x00 01FB 80 DUP1 01FC FD *REVERT // Stack delta = +0 // Outputs[1] { @01FC revert(memory[0x00:0x00]); } // Block terminates label_01FD: // Incoming jump from 0x01D6, if 0xff070b == stack[-1] // Inputs[1] { @0204 msg.data.length } 01FD 5B JUMPDEST 01FE 61 PUSH2 0x0210 0201 61 PUSH2 0x020b 0204 36 CALLDATASIZE 0205 60 PUSH1 0x04 0207 61 PUSH2 0x1766 020A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FE stack[0] = 0x0210 // @0201 stack[1] = 0x020b // @0204 stack[2] = msg.data.length // @0205 stack[3] = 0x04 // } // Block ends with call to 0x1766, returns to 0x020B label_020B: // Incoming return from call to 0x1766 at 0x020A 020B 5B JUMPDEST 020C 61 PUSH2 0x05f6 020F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05f6 label_0210: // Incoming return from call to 0x0C46 at 0x041A // Incoming return from call to 0x03C1 at 0x03C0 // Incoming return from call to 0x04D1 at 0x04D0 // Incoming return from call to 0x0339 at 0x0338 // Incoming return from call to 0x0456 at 0x0455 // Incoming return from call to 0x0436 at 0x0435 // Incoming return from call to 0x04BE at 0x04BD // Incoming return from call to 0x0A6E at 0x0392 // Incoming return from call to 0x0CDA at 0x046F // Incoming return from call to 0x0319 at 0x0318 0210 5B JUMPDEST 0211 00 *STOP // Stack delta = +0 // Outputs[1] { @0211 stop(); } // Block terminates label_0212: // Incoming jump from 0x01E1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0213 msg.value } 0212 5B JUMPDEST 0213 34 CALLVALUE 0214 80 DUP1 0215 15 ISZERO 0216 61 PUSH2 0x021e 0219 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0213 stack[0] = msg.value } // Block ends with conditional jump to 0x021e, if !msg.value label_021A: // Incoming jump from 0x0219, if not !msg.value // Inputs[1] { @021D memory[0x00:0x00] } 021A 60 PUSH1 0x00 021C 80 DUP1 021D FD *REVERT // Stack delta = +0 // Outputs[1] { @021D revert(memory[0x00:0x00]); } // Block terminates label_021E: // Incoming jump from 0x0219, if !msg.value // Inputs[1] { @0226 msg.data.length } 021E 5B JUMPDEST 021F 50 POP 0220 61 PUSH2 0x0232 0223 61 PUSH2 0x022d 0226 36 CALLDATASIZE 0227 60 PUSH1 0x04 0229 61 PUSH2 0x1813 022C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0220 stack[-1] = 0x0232 // @0223 stack[0] = 0x022d // @0226 stack[1] = msg.data.length // @0227 stack[2] = 0x04 // } // Block ends with call to 0x1813, returns to 0x022D label_022D: // Incoming return from call to 0x1813 at 0x022C 022D 5B JUMPDEST 022E 61 PUSH2 0x06ed 0231 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ed label_0232: // Incoming jump from 0x02F1 // Incoming return from call to 0x0592 at 0x0591 // Incoming return from call to 0x022D at 0x022C // Inputs[2] // { // @0235 memory[0x40:0x60] // @0236 stack[-1] // } 0232 5B JUMPDEST 0233 60 PUSH1 0x40 0235 51 MLOAD 0236 90 SWAP1 0237 15 ISZERO 0238 15 ISZERO 0239 81 DUP2 023A 52 MSTORE 023B 60 PUSH1 0x20 023D 01 ADD // Stack delta = +0 // Outputs[2] // { // @023A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @023D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_023E: // Incoming jump from 0x023D // Incoming jump from 0x02D7 // Incoming jump from 0x02A0 // Inputs[3] // { // @0241 memory[0x40:0x60] // @0243 stack[-1] // @0246 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 023E 5B JUMPDEST 023F 60 PUSH1 0x40 0241 51 MLOAD 0242 80 DUP1 0243 91 SWAP2 0244 03 SUB 0245 90 SWAP1 0246 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0246 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0247: // Incoming jump from 0x01EC, if 0x06fdde03 == stack[-1] // Inputs[1] { @0248 msg.value } 0247 5B JUMPDEST 0248 34 CALLVALUE 0249 80 DUP1 024A 15 ISZERO 024B 61 PUSH2 0x0253 024E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0248 stack[0] = msg.value } // Block ends with conditional jump to 0x0253, if !msg.value label_024F: // Incoming jump from 0x024E, if not !msg.value // Inputs[1] { @0252 memory[0x00:0x00] } 024F 60 PUSH1 0x00 0251 80 DUP1 0252 FD *REVERT // Stack delta = +0 // Outputs[1] { @0252 revert(memory[0x00:0x00]); } // Block terminates label_0253: // Incoming jump from 0x024E, if !msg.value 0253 5B JUMPDEST 0254 50 POP 0255 61 PUSH2 0x025c 0258 61 PUSH2 0x073f 025B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0255 stack[-1] = 0x025c } // Block ends with call to 0x073f, returns to 0x025C label_025C: // Incoming return from call to 0x073F at 0x025B // Incoming return from call to 0x0EC7 at 0x0549 // Incoming return from call to 0x0D18 at 0x04A2 // Inputs[2] // { // @025F memory[0x40:0x60] // @0263 stack[-1] // } 025C 5B JUMPDEST 025D 60 PUSH1 0x40 025F 51 MLOAD 0260 61 PUSH2 0x023e 0263 91 SWAP2 0264 90 SWAP1 0265 61 PUSH2 0x1888 0268 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0263 stack[-1] = 0x023e // @0264 stack[1] = memory[0x40:0x60] // @0264 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1888 label_0269: // Incoming jump from 0x01F7, if 0x081812fc == stack[-1] // Inputs[1] { @026A msg.value } 0269 5B JUMPDEST 026A 34 CALLVALUE 026B 80 DUP1 026C 15 ISZERO 026D 61 PUSH2 0x0275 0270 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026A stack[0] = msg.value } // Block ends with conditional jump to 0x0275, if !msg.value label_0271: // Incoming jump from 0x0270, if not !msg.value // Inputs[1] { @0274 memory[0x00:0x00] } 0271 60 PUSH1 0x00 0273 80 DUP1 0274 FD *REVERT // Stack delta = +0 // Outputs[1] { @0274 revert(memory[0x00:0x00]); } // Block terminates label_0275: // Incoming jump from 0x0270, if !msg.value // Inputs[1] { @027D msg.data.length } 0275 5B JUMPDEST 0276 50 POP 0277 61 PUSH2 0x0289 027A 61 PUSH2 0x0284 027D 36 CALLDATASIZE 027E 60 PUSH1 0x04 0280 61 PUSH2 0x189b 0283 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0277 stack[-1] = 0x0289 // @027A stack[0] = 0x0284 // @027D stack[1] = msg.data.length // @027E stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x0284 label_0284: // Incoming return from call to 0x189B at 0x0283 0284 5B JUMPDEST 0285 61 PUSH2 0x07d1 0288 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07d1 label_0289: // Incoming jump from 0x048D // Incoming return from call to 0x03E1 at 0x03E0 // Incoming return from call to 0x0284 at 0x0283 // Inputs[2] // { // @028C memory[0x40:0x60] // @0296 stack[-1] // } 0289 5B JUMPDEST 028A 60 PUSH1 0x40 028C 51 MLOAD 028D 60 PUSH1 0x01 028F 60 PUSH1 0x01 0291 60 PUSH1 0xa0 0293 1B SHL 0294 03 SUB 0295 90 SWAP1 0296 91 SWAP2 0297 16 AND 0298 81 DUP2 0299 52 MSTORE 029A 60 PUSH1 0x20 029C 01 ADD 029D 61 PUSH2 0x023e 02A0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0299 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @029C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x023e label_02A1: // Incoming jump from 0x01A6, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02A8 msg.data.length } 02A1 5B JUMPDEST 02A2 61 PUSH2 0x0210 02A5 61 PUSH2 0x02af 02A8 36 CALLDATASIZE 02A9 60 PUSH1 0x04 02AB 61 PUSH2 0x18cb 02AE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A2 stack[0] = 0x0210 // @02A5 stack[1] = 0x02af // @02A8 stack[2] = msg.data.length // @02A9 stack[3] = 0x04 // } // Block ends with call to 0x18cb, returns to 0x02AF label_02AF: // Incoming return from call to 0x18CB at 0x02AE 02AF 5B JUMPDEST 02B0 61 PUSH2 0x080c 02B3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x080c label_02B4: // Incoming jump from 0x01B1, if 0x0eb3d16c == stack[-1] // Inputs[1] { @02B5 msg.value } 02B4 5B JUMPDEST 02B5 34 CALLVALUE 02B6 80 DUP1 02B7 15 ISZERO 02B8 61 PUSH2 0x02c0 02BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B5 stack[0] = msg.value } // Block ends with conditional jump to 0x02c0, if !msg.value label_02BC: // Incoming jump from 0x02BB, if not !msg.value // Inputs[1] { @02BF memory[0x00:0x00] } 02BC 60 PUSH1 0x00 02BE 80 DUP1 02BF FD *REVERT // Stack delta = +0 // Outputs[1] { @02BF revert(memory[0x00:0x00]); } // Block terminates label_02C0: // Incoming jump from 0x02BB, if !msg.value // Inputs[1] { @02C7 storage[0x0a] } 02C0 5B JUMPDEST 02C1 50 POP 02C2 61 PUSH2 0x02ca 02C5 60 PUSH1 0x0a 02C7 54 SLOAD 02C8 81 DUP2 02C9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02C2 stack[-1] = 0x02ca // @02C7 stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x02ca label_02CA: // Incoming jump from 0x02C9 // Incoming return from call to 0x0565 at 0x0564 // Incoming jump from 0x04EB // Incoming return from call to 0x0401 at 0x0400 // Incoming jump from 0x05D5 // Incoming jump from 0x0501 // Incoming jump from 0x030A // Inputs[2] // { // @02CD memory[0x40:0x60] // @02CE stack[-1] // } 02CA 5B JUMPDEST 02CB 60 PUSH1 0x40 02CD 51 MLOAD 02CE 90 SWAP1 02CF 81 DUP2 02D0 52 MSTORE 02D1 60 PUSH1 0x20 02D3 01 ADD 02D4 61 PUSH2 0x023e 02D7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02D3 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x023e label_02D8: // Incoming jump from 0x01BC, if 0x0fa87335 == 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[0x0c] } 02E4 5B JUMPDEST 02E5 50 POP 02E6 60 PUSH1 0x0c 02E8 54 SLOAD 02E9 61 PUSH2 0x0232 02EC 90 SWAP1 02ED 60 PUSH1 0xff 02EF 16 AND 02F0 81 DUP2 02F1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02EC stack[-1] = 0x0232 // @02EF stack[0] = 0xff & storage[0x0c] // } // Block ends with unconditional jump to 0x0232 label_02F2: // Incoming jump from 0x01C7, if 0x18160ddd == stack[-1] // Inputs[1] { @02F3 msg.value } 02F2 5B JUMPDEST 02F3 34 CALLVALUE 02F4 80 DUP1 02F5 15 ISZERO 02F6 61 PUSH2 0x02fe 02F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F3 stack[0] = msg.value } // Block ends with conditional jump to 0x02fe, if !msg.value label_02FA: // Incoming jump from 0x02F9, if not !msg.value // Inputs[1] { @02FD memory[0x00:0x00] } 02FA 60 PUSH1 0x00 02FC 80 DUP1 02FD FD *REVERT // Stack delta = +0 // Outputs[1] { @02FD revert(memory[0x00:0x00]); } // Block terminates label_02FE: // Incoming jump from 0x02F9, if !msg.value // Inputs[2] // { // @0302 storage[0x01] // @0305 storage[0x00] // } 02FE 5B JUMPDEST 02FF 50 POP 0300 60 PUSH1 0x01 0302 54 SLOAD 0303 60 PUSH1 0x00 0305 54 SLOAD 0306 03 SUB 0307 61 PUSH2 0x02ca 030A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0306 stack[-1] = storage[0x00] - storage[0x01] } // Block ends with unconditional jump to 0x02ca label_030B: // Incoming jump from 0x016A, if 0x23b872dd == stack[-1] // Inputs[1] { @0312 msg.data.length } 030B 5B JUMPDEST 030C 61 PUSH2 0x0210 030F 61 PUSH2 0x0319 0312 36 CALLDATASIZE 0313 60 PUSH1 0x04 0315 61 PUSH2 0x18f5 0318 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @030C stack[0] = 0x0210 // @030F stack[1] = 0x0319 // @0312 stack[2] = msg.data.length // @0313 stack[3] = 0x04 // } // Block ends with call to 0x18f5, returns to 0x0319 label_0319: // Incoming return from call to 0x18F5 at 0x0318 0319 5B JUMPDEST 031A 61 PUSH2 0x081c 031D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x081c label_031E: // Incoming jump from 0x0175, if 0x264cf8dc == stack[-1] // Inputs[1] { @031F msg.value } 031E 5B JUMPDEST 031F 34 CALLVALUE 0320 80 DUP1 0321 15 ISZERO 0322 61 PUSH2 0x032a 0325 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031F stack[0] = msg.value } // Block ends with conditional jump to 0x032a, if !msg.value label_0326: // Incoming jump from 0x0325, if not !msg.value // Inputs[1] { @0329 memory[0x00:0x00] } 0326 60 PUSH1 0x00 0328 80 DUP1 0329 FD *REVERT // Stack delta = +0 // Outputs[1] { @0329 revert(memory[0x00:0x00]); } // Block terminates label_032A: // Incoming jump from 0x0325, if !msg.value // Inputs[1] { @0332 msg.data.length } 032A 5B JUMPDEST 032B 50 POP 032C 61 PUSH2 0x0210 032F 61 PUSH2 0x0339 0332 36 CALLDATASIZE 0333 60 PUSH1 0x04 0335 61 PUSH2 0x189b 0338 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @032C stack[-1] = 0x0210 // @032F stack[0] = 0x0339 // @0332 stack[1] = msg.data.length // @0333 stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x0339 label_0339: // Incoming return from call to 0x189B at 0x0338 0339 5B JUMPDEST 033A 61 PUSH2 0x0981 033D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0981 label_033E: // Incoming jump from 0x0180, if 0x295439e1 == stack[-1] // Inputs[1] { @033F msg.value } 033E 5B JUMPDEST 033F 34 CALLVALUE 0340 80 DUP1 0341 15 ISZERO 0342 61 PUSH2 0x034a 0345 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033F stack[0] = msg.value } // Block ends with conditional jump to 0x034a, if !msg.value label_0346: // Incoming jump from 0x0345, if not !msg.value // Inputs[1] { @0349 memory[0x00:0x00] } 0346 60 PUSH1 0x00 0348 80 DUP1 0349 FD *REVERT // Stack delta = +0 // Outputs[1] { @0349 revert(memory[0x00:0x00]); } // Block terminates label_034A: // Incoming jump from 0x0345, if !msg.value // Inputs[1] { @0352 msg.data.length } 034A 5B JUMPDEST 034B 50 POP 034C 61 PUSH2 0x0210 034F 61 PUSH2 0x0359 0352 36 CALLDATASIZE 0353 60 PUSH1 0x04 0355 61 PUSH2 0x1931 0358 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @034C stack[-1] = 0x0210 // @034F stack[0] = 0x0359 // @0352 stack[1] = msg.data.length // @0353 stack[2] = 0x04 // } // Block ends with call to 0x1931, returns to 0x0359 label_0359: // Incoming return from call to 0x1931 at 0x0358 0359 5B JUMPDEST 035A 61 PUSH2 0x09b0 035D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09b0 label_035E: // Incoming jump from 0x018B, if 0x30176e13 == stack[-1] // Inputs[1] { @035F msg.value } 035E 5B JUMPDEST 035F 34 CALLVALUE 0360 80 DUP1 0361 15 ISZERO 0362 61 PUSH2 0x036a 0365 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035F stack[0] = msg.value } // Block ends with conditional jump to 0x036a, if !msg.value label_0366: // Incoming jump from 0x0365, if not !msg.value // Inputs[1] { @0369 memory[0x00:0x00] } 0366 60 PUSH1 0x00 0368 80 DUP1 0369 FD *REVERT // Stack delta = +0 // Outputs[1] { @0369 revert(memory[0x00:0x00]); } // Block terminates label_036A: // Incoming jump from 0x0365, if !msg.value // Inputs[1] { @0372 msg.data.length } 036A 5B JUMPDEST 036B 50 POP 036C 61 PUSH2 0x0210 036F 61 PUSH2 0x0379 0372 36 CALLDATASIZE 0373 60 PUSH1 0x04 0375 61 PUSH2 0x1a03 0378 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @036C stack[-1] = 0x0210 // @036F stack[0] = 0x0379 // @0372 stack[1] = msg.data.length // @0373 stack[2] = 0x04 // } // Block ends with call to 0x1a03, returns to 0x0379 label_0379: // Incoming return from call to 0x1A03 at 0x0378 0379 5B JUMPDEST 037A 61 PUSH2 0x0a31 037D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a31 label_037E: // Incoming jump from 0x012E, if 0x3ccfd60b == stack[-1] // Inputs[1] { @037F msg.value } 037E 5B JUMPDEST 037F 34 CALLVALUE 0380 80 DUP1 0381 15 ISZERO 0382 61 PUSH2 0x038a 0385 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037F stack[0] = msg.value } // Block ends with conditional jump to 0x038a, if !msg.value label_0386: // Incoming jump from 0x0385, if not !msg.value // Inputs[1] { @0389 memory[0x00:0x00] } 0386 60 PUSH1 0x00 0388 80 DUP1 0389 FD *REVERT // Stack delta = +0 // Outputs[1] { @0389 revert(memory[0x00:0x00]); } // Block terminates label_038A: // Incoming jump from 0x0385, if !msg.value 038A 5B JUMPDEST 038B 50 POP 038C 61 PUSH2 0x0210 038F 61 PUSH2 0x0a6e 0392 56 *JUMP // Stack delta = +0 // Outputs[1] { @038C stack[-1] = 0x0210 } // Block ends with call to 0x0a6e, returns to 0x0210 label_0393: // Incoming jump from 0x0139, if 0x42842e0e == stack[-1] // Inputs[1] { @039A msg.data.length } 0393 5B JUMPDEST 0394 61 PUSH2 0x0210 0397 61 PUSH2 0x03a1 039A 36 CALLDATASIZE 039B 60 PUSH1 0x04 039D 61 PUSH2 0x18f5 03A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0394 stack[0] = 0x0210 // @0397 stack[1] = 0x03a1 // @039A stack[2] = msg.data.length // @039B stack[3] = 0x04 // } // Block ends with call to 0x18f5, returns to 0x03A1 label_03A1: // Incoming return from call to 0x18F5 at 0x03A0 03A1 5B JUMPDEST 03A2 61 PUSH2 0x0b11 03A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b11 label_03A6: // Incoming jump from 0x0144, if 0x4cdb4400 == stack[-1] // Inputs[1] { @03A7 msg.value } 03A6 5B JUMPDEST 03A7 34 CALLVALUE 03A8 80 DUP1 03A9 15 ISZERO 03AA 61 PUSH2 0x03b2 03AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A7 stack[0] = msg.value } // Block ends with conditional jump to 0x03b2, if !msg.value label_03AE: // Incoming jump from 0x03AD, if not !msg.value // Inputs[1] { @03B1 memory[0x00:0x00] } 03AE 60 PUSH1 0x00 03B0 80 DUP1 03B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B1 revert(memory[0x00:0x00]); } // Block terminates label_03B2: // Incoming jump from 0x03AD, if !msg.value // Inputs[1] { @03BA msg.data.length } 03B2 5B JUMPDEST 03B3 50 POP 03B4 61 PUSH2 0x0210 03B7 61 PUSH2 0x03c1 03BA 36 CALLDATASIZE 03BB 60 PUSH1 0x04 03BD 61 PUSH2 0x1a4c 03C0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B4 stack[-1] = 0x0210 // @03B7 stack[0] = 0x03c1 // @03BA stack[1] = msg.data.length // @03BB stack[2] = 0x04 // } // Block ends with call to 0x1a4c, returns to 0x03C1 label_03C1: // Incoming return from call to 0x1A4C at 0x03C0 03C1 5B JUMPDEST 03C2 61 PUSH2 0x0b31 03C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b31 label_03C6: // Incoming jump from 0x014F, if 0x6352211e == stack[-1] // Inputs[1] { @03C7 msg.value } 03C6 5B JUMPDEST 03C7 34 CALLVALUE 03C8 80 DUP1 03C9 15 ISZERO 03CA 61 PUSH2 0x03d2 03CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C7 stack[0] = msg.value } // Block ends with conditional jump to 0x03d2, if !msg.value label_03CE: // Incoming jump from 0x03CD, if not !msg.value // Inputs[1] { @03D1 memory[0x00:0x00] } 03CE 60 PUSH1 0x00 03D0 80 DUP1 03D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D1 revert(memory[0x00:0x00]); } // Block terminates label_03D2: // Incoming jump from 0x03CD, if !msg.value // Inputs[1] { @03DA msg.data.length } 03D2 5B JUMPDEST 03D3 50 POP 03D4 61 PUSH2 0x0289 03D7 61 PUSH2 0x03e1 03DA 36 CALLDATASIZE 03DB 60 PUSH1 0x04 03DD 61 PUSH2 0x189b 03E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D4 stack[-1] = 0x0289 // @03D7 stack[0] = 0x03e1 // @03DA stack[1] = msg.data.length // @03DB stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x03E1 label_03E1: // Incoming return from call to 0x189B at 0x03E0 03E1 5B JUMPDEST 03E2 61 PUSH2 0x0bf5 03E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf5 label_03E6: // Incoming jump from 0x015A, if 0x70a08231 == stack[-1] // Inputs[1] { @03E7 msg.value } 03E6 5B JUMPDEST 03E7 34 CALLVALUE 03E8 80 DUP1 03E9 15 ISZERO 03EA 61 PUSH2 0x03f2 03ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E7 stack[0] = msg.value } // Block ends with conditional jump to 0x03f2, if !msg.value label_03EE: // Incoming jump from 0x03ED, if not !msg.value // Inputs[1] { @03F1 memory[0x00:0x00] } 03EE 60 PUSH1 0x00 03F0 80 DUP1 03F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F1 revert(memory[0x00:0x00]); } // Block terminates label_03F2: // Incoming jump from 0x03ED, if !msg.value // Inputs[1] { @03FA msg.data.length } 03F2 5B JUMPDEST 03F3 50 POP 03F4 61 PUSH2 0x02ca 03F7 61 PUSH2 0x0401 03FA 36 CALLDATASIZE 03FB 60 PUSH1 0x04 03FD 61 PUSH2 0x1af9 0400 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F4 stack[-1] = 0x02ca // @03F7 stack[0] = 0x0401 // @03FA stack[1] = msg.data.length // @03FB stack[2] = 0x04 // } // Block ends with call to 0x1af9, returns to 0x0401 label_0401: // Incoming return from call to 0x1AF9 at 0x0400 0401 5B JUMPDEST 0402 61 PUSH2 0x0c00 0405 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c00 label_0406: // Incoming jump from 0x00E7, if 0x715018a6 == stack[-1] // Inputs[1] { @0407 msg.value } 0406 5B JUMPDEST 0407 34 CALLVALUE 0408 80 DUP1 0409 15 ISZERO 040A 61 PUSH2 0x0412 040D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0407 stack[0] = msg.value } // Block ends with conditional jump to 0x0412, if !msg.value label_040E: // Incoming jump from 0x040D, if not !msg.value // Inputs[1] { @0411 memory[0x00:0x00] } 040E 60 PUSH1 0x00 0410 80 DUP1 0411 FD *REVERT // Stack delta = +0 // Outputs[1] { @0411 revert(memory[0x00:0x00]); } // Block terminates label_0412: // Incoming jump from 0x040D, if !msg.value 0412 5B JUMPDEST 0413 50 POP 0414 61 PUSH2 0x0210 0417 61 PUSH2 0x0c46 041A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0414 stack[-1] = 0x0210 } // Block ends with call to 0x0c46, returns to 0x0210 label_041B: // Incoming jump from 0x00F2, if 0x791a2519 == stack[-1] // Inputs[1] { @041C msg.value } 041B 5B JUMPDEST 041C 34 CALLVALUE 041D 80 DUP1 041E 15 ISZERO 041F 61 PUSH2 0x0427 0422 57 *JUMPI // Stack delta = +1 // Outputs[1] { @041C stack[0] = msg.value } // Block ends with conditional jump to 0x0427, if !msg.value label_0423: // Incoming jump from 0x0422, if not !msg.value // Inputs[1] { @0426 memory[0x00:0x00] } 0423 60 PUSH1 0x00 0425 80 DUP1 0426 FD *REVERT // Stack delta = +0 // Outputs[1] { @0426 revert(memory[0x00:0x00]); } // Block terminates label_0427: // Incoming jump from 0x0422, if !msg.value // Inputs[1] { @042F msg.data.length } 0427 5B JUMPDEST 0428 50 POP 0429 61 PUSH2 0x0210 042C 61 PUSH2 0x0436 042F 36 CALLDATASIZE 0430 60 PUSH1 0x04 0432 61 PUSH2 0x189b 0435 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0429 stack[-1] = 0x0210 // @042C stack[0] = 0x0436 // @042F stack[1] = msg.data.length // @0430 stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x0436 label_0436: // Incoming return from call to 0x189B at 0x0435 0436 5B JUMPDEST 0437 61 PUSH2 0x0c7c 043A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c7c label_043B: // Incoming jump from 0x00FD, if 0x7cb64759 == stack[-1] // Inputs[1] { @043C msg.value } 043B 5B JUMPDEST 043C 34 CALLVALUE 043D 80 DUP1 043E 15 ISZERO 043F 61 PUSH2 0x0447 0442 57 *JUMPI // Stack delta = +1 // Outputs[1] { @043C stack[0] = msg.value } // Block ends with conditional jump to 0x0447, if !msg.value label_0443: // Incoming jump from 0x0442, if not !msg.value // Inputs[1] { @0446 memory[0x00:0x00] } 0443 60 PUSH1 0x00 0445 80 DUP1 0446 FD *REVERT // Stack delta = +0 // Outputs[1] { @0446 revert(memory[0x00:0x00]); } // Block terminates label_0447: // Incoming jump from 0x0442, if !msg.value // Inputs[1] { @044F msg.data.length } 0447 5B JUMPDEST 0448 50 POP 0449 61 PUSH2 0x0210 044C 61 PUSH2 0x0456 044F 36 CALLDATASIZE 0450 60 PUSH1 0x04 0452 61 PUSH2 0x189b 0455 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0449 stack[-1] = 0x0210 // @044C stack[0] = 0x0456 // @044F stack[1] = msg.data.length // @0450 stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x0456 label_0456: // Incoming return from call to 0x189B at 0x0455 0456 5B JUMPDEST 0457 61 PUSH2 0x0cab 045A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cab label_045B: // Incoming jump from 0x0108, if 0x88084605 == stack[-1] // Inputs[1] { @045C msg.value } 045B 5B JUMPDEST 045C 34 CALLVALUE 045D 80 DUP1 045E 15 ISZERO 045F 61 PUSH2 0x0467 0462 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045C stack[0] = msg.value } // Block ends with conditional jump to 0x0467, if !msg.value label_0463: // Incoming jump from 0x0462, if not !msg.value // Inputs[1] { @0466 memory[0x00:0x00] } 0463 60 PUSH1 0x00 0465 80 DUP1 0466 FD *REVERT // Stack delta = +0 // Outputs[1] { @0466 revert(memory[0x00:0x00]); } // Block terminates label_0467: // Incoming jump from 0x0462, if !msg.value 0467 5B JUMPDEST 0468 50 POP 0469 61 PUSH2 0x0210 046C 61 PUSH2 0x0cda 046F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0469 stack[-1] = 0x0210 } // Block ends with call to 0x0cda, returns to 0x0210 label_0470: // Incoming jump from 0x00B6, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0471 msg.value } 0470 5B JUMPDEST 0471 34 CALLVALUE 0472 80 DUP1 0473 15 ISZERO 0474 61 PUSH2 0x047c 0477 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0471 stack[0] = msg.value } // Block ends with conditional jump to 0x047c, if !msg.value label_0478: // Incoming jump from 0x0477, if not !msg.value // Inputs[1] { @047B memory[0x00:0x00] } 0478 60 PUSH1 0x00 047A 80 DUP1 047B FD *REVERT // Stack delta = +0 // Outputs[1] { @047B revert(memory[0x00:0x00]); } // Block terminates label_047C: // Incoming jump from 0x0477, if !msg.value // Inputs[1] { @0480 storage[0x08] } 047C 5B JUMPDEST 047D 50 POP 047E 60 PUSH1 0x08 0480 54 SLOAD 0481 60 PUSH1 0x01 0483 60 PUSH1 0x01 0485 60 PUSH1 0xa0 0487 1B SHL 0488 03 SUB 0489 16 AND 048A 61 PUSH2 0x0289 048D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0489 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x0289 label_048E: // Incoming jump from 0x00C1, if 0x95d89b41 == stack[-1] // Inputs[1] { @048F msg.value } 048E 5B JUMPDEST 048F 34 CALLVALUE 0490 80 DUP1 0491 15 ISZERO 0492 61 PUSH2 0x049a 0495 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048F stack[0] = msg.value } // Block ends with conditional jump to 0x049a, if !msg.value label_0496: // Incoming jump from 0x0495, if not !msg.value // Inputs[1] { @0499 memory[0x00:0x00] } 0496 60 PUSH1 0x00 0498 80 DUP1 0499 FD *REVERT // Stack delta = +0 // Outputs[1] { @0499 revert(memory[0x00:0x00]); } // Block terminates label_049A: // Incoming jump from 0x0495, if !msg.value 049A 5B JUMPDEST 049B 50 POP 049C 61 PUSH2 0x025c 049F 61 PUSH2 0x0d18 04A2 56 *JUMP // Stack delta = +0 // Outputs[1] { @049C stack[-1] = 0x025c } // Block ends with call to 0x0d18, returns to 0x025C label_04A3: // Incoming jump from 0x00CC, if 0xa22cb465 == stack[-1] // Inputs[1] { @04A4 msg.value } 04A3 5B JUMPDEST 04A4 34 CALLVALUE 04A5 80 DUP1 04A6 15 ISZERO 04A7 61 PUSH2 0x04af 04AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A4 stack[0] = msg.value } // Block ends with conditional jump to 0x04af, if !msg.value label_04AB: // Incoming jump from 0x04AA, if not !msg.value // Inputs[1] { @04AE memory[0x00:0x00] } 04AB 60 PUSH1 0x00 04AD 80 DUP1 04AE FD *REVERT // Stack delta = +0 // Outputs[1] { @04AE revert(memory[0x00:0x00]); } // Block terminates label_04AF: // Incoming jump from 0x04AA, if !msg.value // Inputs[1] { @04B7 msg.data.length } 04AF 5B JUMPDEST 04B0 50 POP 04B1 61 PUSH2 0x0210 04B4 61 PUSH2 0x04be 04B7 36 CALLDATASIZE 04B8 60 PUSH1 0x04 04BA 61 PUSH2 0x1b14 04BD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B1 stack[-1] = 0x0210 // @04B4 stack[0] = 0x04be // @04B7 stack[1] = msg.data.length // @04B8 stack[2] = 0x04 // } // Block ends with call to 0x1b14, returns to 0x04BE label_04BE: // Incoming return from call to 0x1B14 at 0x04BD 04BE 5B JUMPDEST 04BF 61 PUSH2 0x0d27 04C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d27 label_04C3: // Incoming jump from 0x00D7, if 0xb88d4fde == stack[-1] // Inputs[1] { @04CA msg.data.length } 04C3 5B JUMPDEST 04C4 61 PUSH2 0x0210 04C7 61 PUSH2 0x04d1 04CA 36 CALLDATASIZE 04CB 60 PUSH1 0x04 04CD 61 PUSH2 0x1b50 04D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04C4 stack[0] = 0x0210 // @04C7 stack[1] = 0x04d1 // @04CA stack[2] = msg.data.length // @04CB stack[3] = 0x04 // } // Block ends with call to 0x1b50, returns to 0x04D1 label_04D1: // Incoming return from call to 0x1B50 at 0x04D0 04D1 5B JUMPDEST 04D2 61 PUSH2 0x0d93 04D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d93 label_04D6: // Incoming jump from 0x007A, if 0xc40018b0 == stack[-1] // Inputs[1] { @04D7 msg.value } 04D6 5B JUMPDEST 04D7 34 CALLVALUE 04D8 80 DUP1 04D9 15 ISZERO 04DA 61 PUSH2 0x04e2 04DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D7 stack[0] = msg.value } // Block ends with conditional jump to 0x04e2, if !msg.value label_04DE: // Incoming jump from 0x04DD, if not !msg.value // Inputs[1] { @04E1 memory[0x00:0x00] } 04DE 60 PUSH1 0x00 04E0 80 DUP1 04E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E1 revert(memory[0x00:0x00]); } // Block terminates label_04E2: // Incoming jump from 0x04DD, if !msg.value // Inputs[1] { @04E9 storage[0x09] } 04E2 5B JUMPDEST 04E3 50 POP 04E4 61 PUSH2 0x02ca 04E7 60 PUSH1 0x09 04E9 54 SLOAD 04EA 81 DUP2 04EB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04E4 stack[-1] = 0x02ca // @04E9 stack[0] = storage[0x09] // } // Block ends with unconditional jump to 0x02ca label_04EC: // Incoming jump from 0x0085, if 0xc61b5862 == stack[-1] // Inputs[1] { @04ED msg.value } 04EC 5B JUMPDEST 04ED 34 CALLVALUE 04EE 80 DUP1 04EF 15 ISZERO 04F0 61 PUSH2 0x04f8 04F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04ED stack[0] = msg.value } // Block ends with conditional jump to 0x04f8, if !msg.value label_04F4: // Incoming jump from 0x04F3, if not !msg.value // Inputs[1] { @04F7 memory[0x00:0x00] } 04F4 60 PUSH1 0x00 04F6 80 DUP1 04F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F7 revert(memory[0x00:0x00]); } // Block terminates label_04F8: // Incoming jump from 0x04F3, if !msg.value // Inputs[1] { @04FF storage[0x0e] } 04F8 5B JUMPDEST 04F9 50 POP 04FA 61 PUSH2 0x02ca 04FD 60 PUSH1 0x0e 04FF 54 SLOAD 0500 81 DUP2 0501 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04FA stack[-1] = 0x02ca // @04FF stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x02ca label_0502: // Incoming jump from 0x0090, if 0xc87b56dd == stack[-1] // Inputs[1] { @0503 msg.value } 0502 5B JUMPDEST 0503 34 CALLVALUE 0504 80 DUP1 0505 15 ISZERO 0506 61 PUSH2 0x050e 0509 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0503 stack[0] = msg.value } // Block ends with conditional jump to 0x050e, if !msg.value label_050A: // Incoming jump from 0x0509, if not !msg.value // Inputs[1] { @050D memory[0x00:0x00] } 050A 60 PUSH1 0x00 050C 80 DUP1 050D FD *REVERT // Stack delta = +0 // Outputs[1] { @050D revert(memory[0x00:0x00]); } // Block terminates label_050E: // Incoming jump from 0x0509, if !msg.value // Inputs[1] { @0516 msg.data.length } 050E 5B JUMPDEST 050F 50 POP 0510 61 PUSH2 0x025c 0513 61 PUSH2 0x051d 0516 36 CALLDATASIZE 0517 60 PUSH1 0x04 0519 61 PUSH2 0x189b 051C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0510 stack[-1] = 0x025c // @0513 stack[0] = 0x051d // @0516 stack[1] = msg.data.length // @0517 stack[2] = 0x04 // } // Block ends with call to 0x189b, returns to 0x051D label_051D: // Incoming return from call to 0x189B at 0x051C 051D 5B JUMPDEST 051E 61 PUSH2 0x0dd4 0521 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd4 label_0522: // Incoming jump from 0x009B, if 0xce6df2b9 == stack[-1] // Inputs[1] { @0529 msg.data.length } 0522 5B JUMPDEST 0523 61 PUSH2 0x0210 0526 61 PUSH2 0x0530 0529 36 CALLDATASIZE 052A 60 PUSH1 0x04 052C 61 PUSH2 0x18cb 052F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0523 stack[0] = 0x0210 // @0526 stack[1] = 0x0530 // @0529 stack[2] = msg.data.length // @052A stack[3] = 0x04 // } // Block ends with call to 0x18cb, returns to 0x0530 label_0530: // Incoming return from call to 0x18CB at 0x052F 0530 5B JUMPDEST 0531 61 PUSH2 0x0e7b 0534 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e7b label_0535: // Incoming jump from 0x003E, if 0xcfc86f7b == stack[-1] // Inputs[1] { @0536 msg.value } 0535 5B JUMPDEST 0536 34 CALLVALUE 0537 80 DUP1 0538 15 ISZERO 0539 61 PUSH2 0x0541 053C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0536 stack[0] = msg.value } // Block ends with conditional jump to 0x0541, if !msg.value label_053D: // Incoming jump from 0x053C, if not !msg.value // Inputs[1] { @0540 memory[0x00:0x00] } 053D 60 PUSH1 0x00 053F 80 DUP1 0540 FD *REVERT // Stack delta = +0 // Outputs[1] { @0540 revert(memory[0x00:0x00]); } // Block terminates label_0541: // Incoming jump from 0x053C, if !msg.value 0541 5B JUMPDEST 0542 50 POP 0543 61 PUSH2 0x025c 0546 61 PUSH2 0x0ec7 0549 56 *JUMP // Stack delta = +0 // Outputs[1] { @0543 stack[-1] = 0x025c } // Block ends with call to 0x0ec7, returns to 0x025C label_054A: // Incoming jump from 0x0049, if 0xe06f6b5c == stack[-1] // Inputs[1] { @054B msg.value } 054A 5B JUMPDEST 054B 34 CALLVALUE 054C 80 DUP1 054D 15 ISZERO 054E 61 PUSH2 0x0556 0551 57 *JUMPI // Stack delta = +1 // Outputs[1] { @054B stack[0] = msg.value } // Block ends with conditional jump to 0x0556, if !msg.value label_0552: // Incoming jump from 0x0551, if not !msg.value // Inputs[1] { @0555 memory[0x00:0x00] } 0552 60 PUSH1 0x00 0554 80 DUP1 0555 FD *REVERT // Stack delta = +0 // Outputs[1] { @0555 revert(memory[0x00:0x00]); } // Block terminates label_0556: // Incoming jump from 0x0551, if !msg.value // Inputs[1] { @055E msg.data.length } 0556 5B JUMPDEST 0557 50 POP 0558 61 PUSH2 0x02ca 055B 61 PUSH2 0x0565 055E 36 CALLDATASIZE 055F 60 PUSH1 0x04 0561 61 PUSH2 0x1af9 0564 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0558 stack[-1] = 0x02ca // @055B stack[0] = 0x0565 // @055E stack[1] = msg.data.length // @055F stack[2] = 0x04 // } // Block ends with call to 0x1af9, returns to 0x0565 label_0565: // Incoming return from call to 0x1AF9 at 0x0564 // Inputs[4] // { // @056D stack[-1] // @0573 memory[0x00:0x40] // @0574 storage[keccak256(memory[0x00:0x40])] // @0575 stack[-2] // } 0565 5B JUMPDEST 0566 60 PUSH1 0x0f 0568 60 PUSH1 0x20 056A 52 MSTORE 056B 60 PUSH1 0x00 056D 90 SWAP1 056E 81 DUP2 056F 52 MSTORE 0570 60 PUSH1 0x40 0572 90 SWAP1 0573 20 SHA3 0574 54 SLOAD 0575 81 DUP2 0576 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @056A memory[0x20:0x40] = 0x0f // @056F memory[0x00:0x20] = stack[-1] // @0574 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0577: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0578 msg.value } 0577 5B JUMPDEST 0578 34 CALLVALUE 0579 80 DUP1 057A 15 ISZERO 057B 61 PUSH2 0x0583 057E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0578 stack[0] = msg.value } // Block ends with conditional jump to 0x0583, if !msg.value label_057F: // Incoming jump from 0x057E, if not !msg.value // Inputs[1] { @0582 memory[0x00:0x00] } 057F 60 PUSH1 0x00 0581 80 DUP1 0582 FD *REVERT // Stack delta = +0 // Outputs[1] { @0582 revert(memory[0x00:0x00]); } // Block terminates label_0583: // Incoming jump from 0x057E, if !msg.value // Inputs[1] { @058B msg.data.length } 0583 5B JUMPDEST 0584 50 POP 0585 61 PUSH2 0x0232 0588 61 PUSH2 0x0592 058B 36 CALLDATASIZE 058C 60 PUSH1 0x04 058E 61 PUSH2 0x1bcc 0591 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0585 stack[-1] = 0x0232 // @0588 stack[0] = 0x0592 // @058B stack[1] = msg.data.length // @058C stack[2] = 0x04 // } // Block ends with call to 0x1bcc, returns to 0x0592 label_0592: // Incoming call from 0x10CD, returns to 0x10CE // Incoming call from 0x087C, returns to 0x087D // Incoming return from call to 0x1BCC at 0x0591 // Inputs[6] // { // @059B stack[-2] // @05AE memory[0x00:0x40] // @05AF stack[-1] // @05B9 memory[0x00:0x40] // @05BA storage[keccak256(memory[0x00:0x40])] // @05BE stack[-3] // } 0592 5B JUMPDEST 0593 60 PUSH1 0x01 0595 60 PUSH1 0x01 0597 60 PUSH1 0xa0 0599 1B SHL 059A 03 SUB 059B 91 SWAP2 059C 82 DUP3 059D 16 AND 059E 60 PUSH1 0x00 05A0 90 SWAP1 05A1 81 DUP2 05A2 52 MSTORE 05A3 60 PUSH1 0x07 05A5 60 PUSH1 0x20 05A7 90 SWAP1 05A8 81 DUP2 05A9 52 MSTORE 05AA 60 PUSH1 0x40 05AC 80 DUP1 05AD 83 DUP4 05AE 20 SHA3 05AF 93 SWAP4 05B0 90 SWAP1 05B1 94 SWAP5 05B2 16 AND 05B3 82 DUP3 05B4 52 MSTORE 05B5 91 SWAP2 05B6 90 SWAP1 05B7 91 SWAP2 05B8 52 MSTORE 05B9 20 SHA3 05BA 54 SLOAD 05BB 60 PUSH1 0xff 05BD 16 AND 05BE 90 SWAP1 05BF 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05A2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05A9 memory[0x20:0x40] = 0x07 // @05B4 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @05B8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05BE stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05C0: // Incoming jump from 0x005F, if 0xee318b8b == stack[-1] // Inputs[1] { @05C1 msg.value } 05C0 5B JUMPDEST 05C1 34 CALLVALUE 05C2 80 DUP1 05C3 15 ISZERO 05C4 61 PUSH2 0x05cc 05C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C1 stack[0] = msg.value } // Block ends with conditional jump to 0x05cc, if !msg.value label_05C8: // Incoming jump from 0x05C7, if not !msg.value // Inputs[1] { @05CB memory[0x00:0x00] } 05C8 60 PUSH1 0x00 05CA 80 DUP1 05CB FD *REVERT // Stack delta = +0 // Outputs[1] { @05CB revert(memory[0x00:0x00]); } // Block terminates label_05CC: // Incoming jump from 0x05C7, if !msg.value // Inputs[1] { @05D3 storage[0x0b] } 05CC 5B JUMPDEST 05CD 50 POP 05CE 61 PUSH2 0x02ca 05D1 60 PUSH1 0x0b 05D3 54 SLOAD 05D4 81 DUP2 05D5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05CE stack[-1] = 0x02ca // @05D3 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x02ca label_05D6: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @05D7 msg.value } 05D6 5B JUMPDEST 05D7 34 CALLVALUE 05D8 80 DUP1 05D9 15 ISZERO 05DA 61 PUSH2 0x05e2 05DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D7 stack[0] = msg.value } // Block ends with conditional jump to 0x05e2, if !msg.value label_05DE: // Incoming jump from 0x05DD, if not !msg.value // Inputs[1] { @05E1 memory[0x00:0x00] } 05DE 60 PUSH1 0x00 05E0 80 DUP1 05E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E1 revert(memory[0x00:0x00]); } // Block terminates label_05E2: // Incoming jump from 0x05DD, if !msg.value // Inputs[1] { @05EA msg.data.length } 05E2 5B JUMPDEST 05E3 50 POP 05E4 61 PUSH2 0x0210 05E7 61 PUSH2 0x05f1 05EA 36 CALLDATASIZE 05EB 60 PUSH1 0x04 05ED 61 PUSH2 0x1af9 05F0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E4 stack[-1] = 0x0210 // @05E7 stack[0] = 0x05f1 // @05EA stack[1] = msg.data.length // @05EB stack[2] = 0x04 // } // Block ends with call to 0x1af9, returns to 0x05F1 label_05F1: // Incoming return from call to 0x1AF9 at 0x05F0 05F1 5B JUMPDEST 05F2 61 PUSH2 0x0f55 05F5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f55 label_05F6: // Incoming jump from 0x020F // Inputs[12] // { // @05FA stack[-2] // @05FB stack[-1] // @0606 memory[0x40:0x60] // @0620 msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @062D storage[0x0e] // @0631 memory[0x40:0x60] // @0632 msg.sender // @063B stack[-5] // @0642 stack[-3] // @064F memory[0x40:0x60] // @065D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0662 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 05F6 5B JUMPDEST 05F7 61 PUSH2 0x0667 05FA 82 DUP3 05FB 82 DUP3 05FC 80 DUP1 05FD 80 DUP1 05FE 60 PUSH1 0x20 0600 02 MUL 0601 60 PUSH1 0x20 0603 01 ADD 0604 60 PUSH1 0x40 0606 51 MLOAD 0607 90 SWAP1 0608 81 DUP2 0609 01 ADD 060A 60 PUSH1 0x40 060C 52 MSTORE 060D 80 DUP1 060E 93 SWAP4 060F 92 SWAP3 0610 91 SWAP2 0611 90 SWAP1 0612 81 DUP2 0613 81 DUP2 0614 52 MSTORE 0615 60 PUSH1 0x20 0617 01 ADD 0618 83 DUP4 0619 83 DUP4 061A 60 PUSH1 0x20 061C 02 MUL 061D 80 DUP1 061E 82 DUP3 061F 84 DUP5 0620 37 CALLDATACOPY 0621 60 PUSH1 0x00 0623 92 SWAP3 0624 01 ADD 0625 91 SWAP2 0626 90 SWAP1 0627 91 SWAP2 0628 52 MSTORE 0629 50 POP 062A 50 POP 062B 60 PUSH1 0x0e 062D 54 SLOAD 062E 60 PUSH1 0x40 0630 80 DUP1 0631 51 MLOAD 0632 33 CALLER 0633 60 PUSH1 0x20 0635 82 DUP3 0636 01 ADD 0637 52 MSTORE 0638 90 SWAP1 0639 81 DUP2 063A 01 ADD 063B 8B DUP12 063C 90 SWAP1 063D 52 MSTORE 063E 60 PUSH1 0x60 0640 81 DUP2 0641 01 ADD 0642 89 DUP10 0643 90 SWAP1 0644 52 MSTORE 0645 90 SWAP1 0646 92 SWAP3 0647 50 POP 0648 60 PUSH1 0x80 064A 01 ADD 064B 90 SWAP1 064C 50 POP 064D 60 PUSH1 0x40 064F 51 MLOAD 0650 60 PUSH1 0x20 0652 81 DUP2 0653 83 DUP4 0654 03 SUB 0655 03 SUB 0656 81 DUP2 0657 52 MSTORE 0658 90 SWAP1 0659 60 PUSH1 0x40 065B 52 MSTORE 065C 80 DUP1 065D 51 MLOAD 065E 90 SWAP1 065F 60 PUSH1 0x20 0661 01 ADD 0662 20 SHA3 0663 61 PUSH2 0x0fed 0666 56 *JUMP // Stack delta = +4 // Outputs[13] // { // @05F7 stack[0] = 0x0667 // @060C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // @060E stack[1] = memory[0x40:0x60] // @0614 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0620 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @0628 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-1]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1] + 0x20] = 0x00 // @0637 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.sender // @063D memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] // @0644 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-3] // @0646 stack[2] = storage[0x0e] // @0657 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x80 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @065B memory[0x40:0x60] = 0x80 + memory[0x40:0x60] // @0662 stack[3] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x0fed, returns to 0x0667 label_0667: // Incoming return from call to 0x0FED at 0x0666 // Inputs[1] { @066B stack[-1] } 0667 5B JUMPDEST 0668 61 PUSH2 0x06a1 066B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06a1, if stack[-1] label_066C: // Incoming jump from 0x066B, if not stack[-1] // Inputs[1] { @066E memory[0x40:0x60] } 066C 60 PUSH1 0x40 066E 51 MLOAD 066F 62 PUSH3 0x461bcd 0673 60 PUSH1 0xe5 0675 1B SHL 0676 81 DUP2 0677 52 MSTORE 0678 60 PUSH1 0x20 067A 60 PUSH1 0x04 067C 82 DUP3 067D 01 ADD 067E 52 MSTORE 067F 60 PUSH1 0x06 0681 60 PUSH1 0x24 0683 82 DUP3 0684 01 ADD 0685 52 MSTORE 0686 65 PUSH6 0x10b83937b7b3 068D 60 PUSH1 0xd1 068F 1B SHL 0690 60 PUSH1 0x44 0692 82 DUP3 0693 01 ADD 0694 52 MSTORE 0695 60 PUSH1 0x64 0697 01 ADD // Stack delta = +1 // Outputs[5] // { // @0677 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @067E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0685 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @0694 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x10b83937b7b3 << 0xd1 // @0697 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0698: // Incoming jump from 0x0B0D // Incoming return from call to 0x1C30 at 0x0D03 // Incoming jump from 0x1272 // Incoming jump from 0x06DA // Incoming jump from 0x105F // Incoming return from call to 0x1C30 at 0x0A5A // Incoming jump from 0x12B1 // Incoming return from call to 0x1C30 at 0x0F7E // Incoming jump from 0x0A24 // Incoming return from call to 0x1C30 at 0x0CD4 // Incoming return from call to 0x1C30 at 0x09AA // Incoming jump from 0x0BB2 // Incoming return from call to 0x1C30 at 0x0CA5 // Incoming return from call to 0x1C30 at 0x0C6F // Incoming jump from 0x0E42 // Incoming jump from 0x0697 // Incoming return from call to 0x1C30 at 0x09D9 // Incoming jump from 0x0EB9 // Incoming jump from 0x1216 // Incoming jump from 0x0FE3 // Incoming return from call to 0x1C30 at 0x0B5A // Inputs[3] // { // @069B memory[0x40:0x60] // @069D stack[-1] // @06A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0698 5B JUMPDEST 0699 60 PUSH1 0x40 069B 51 MLOAD 069C 80 DUP1 069D 91 SWAP2 069E 03 SUB 069F 90 SWAP1 06A0 FD *REVERT // Stack delta = -1 // Outputs[1] { @06A0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_06A1: // Incoming jump from 0x066B, if stack[-1] // Inputs[2] // { // @06A4 storage[0x0a] // @06A5 stack[-3] // } 06A1 5B JUMPDEST 06A2 60 PUSH1 0x0a 06A4 54 SLOAD 06A5 83 DUP4 06A6 11 GT 06A7 15 ISZERO 06A8 61 PUSH2 0x06db 06AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06db, if !(stack[-3] > storage[0x0a]) label_06AC: // Incoming jump from 0x06AB, if not !(stack[-3] > storage[0x0a]) // Inputs[1] { @06AE memory[0x40:0x60] } 06AC 60 PUSH1 0x40 06AE 51 MLOAD 06AF 62 PUSH3 0x461bcd 06B3 60 PUSH1 0xe5 06B5 1B SHL 06B6 81 DUP2 06B7 52 MSTORE 06B8 60 PUSH1 0x20 06BA 60 PUSH1 0x04 06BC 82 DUP3 06BD 01 ADD 06BE 52 MSTORE 06BF 60 PUSH1 0x05 06C1 60 PUSH1 0x24 06C3 82 DUP3 06C4 01 ADD 06C5 52 MSTORE 06C6 64 PUSH5 0x217065726d 06CC 60 PUSH1 0xd8 06CE 1B SHL 06CF 60 PUSH1 0x44 06D1 82 DUP3 06D2 01 ADD 06D3 52 MSTORE 06D4 60 PUSH1 0x64 06D6 01 ADD 06D7 61 PUSH2 0x0698 06DA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @06B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06BE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06C5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x05 // @06D3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x217065726d << 0xd8 // @06D6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_06DB: // Incoming jump from 0x06AB, if !(stack[-3] > storage[0x0a]) // Inputs[3] // { // @06DF msg.sender // @06E0 stack[-5] // @06E1 stack[-4] // } 06DB 5B JUMPDEST 06DC 61 PUSH2 0x06e6 06DF 33 CALLER 06E0 86 DUP7 06E1 86 DUP7 06E2 61 PUSH2 0x1003 06E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06DC stack[0] = 0x06e6 // @06DF stack[1] = msg.sender // @06E0 stack[2] = stack[-5] // @06E1 stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x1003 06E6 5B JUMPDEST 06E7 50 POP 06E8 50 POP 06E9 50 POP 06EA 50 POP 06EB 50 POP 06EC 56 *JUMP label_06ED: // Incoming jump from 0x0231 // Inputs[1] { @0701 stack[-1] } 06ED 5B JUMPDEST 06EE 60 PUSH1 0x00 06F0 63 PUSH4 0x01ffc9a7 06F5 60 PUSH1 0xe0 06F7 1B SHL 06F8 60 PUSH1 0x01 06FA 60 PUSH1 0x01 06FC 60 PUSH1 0xe0 06FE 1B SHL 06FF 03 SUB 0700 19 NOT 0701 83 DUP4 0702 16 AND 0703 14 EQ 0704 80 DUP1 0705 61 PUSH2 0x071e 0708 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @06EE stack[0] = 0x00 // @0703 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x071e, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_0709: // Incoming jump from 0x0708, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @071B stack[-3] } 0709 50 POP 070A 63 PUSH4 0x80ac58cd 070F 60 PUSH1 0xe0 0711 1B SHL 0712 60 PUSH1 0x01 0714 60 PUSH1 0x01 0716 60 PUSH1 0xe0 0718 1B SHL 0719 03 SUB 071A 19 NOT 071B 83 DUP4 071C 16 AND 071D 14 EQ 071E 5B JUMPDEST 071F 80 DUP1 0720 61 PUSH2 0x0739 0723 57 *JUMPI // Stack delta = +0 // Outputs[1] { @071D stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x0739, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_0724: // Incoming jump from 0x0723, if not stack[-1] // Incoming jump from 0x0723, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[1] { @0736 stack[-3] } 0724 50 POP 0725 63 PUSH4 0x5b5e139f 072A 60 PUSH1 0xe0 072C 1B SHL 072D 60 PUSH1 0x01 072F 60 PUSH1 0x01 0731 60 PUSH1 0xe0 0733 1B SHL 0734 03 SUB 0735 19 NOT 0736 83 DUP4 0737 16 AND 0738 14 EQ // Stack delta = +0 // Outputs[1] { @0738 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f << 0xe0 } // Block continues label_0739: // Incoming jump from 0x0723, if stack[-1] // Incoming jump from 0x1077, if !(stack[-1] < storage[0x00]) // Incoming return from call to 0x113F at 0x0BFF // Incoming jump from 0x0723, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x0738 // Inputs[3] // { // @073A stack[-1] // @073A stack[-4] // @073B stack[-3] // } 0739 5B JUMPDEST 073A 92 SWAP3 073B 91 SWAP2 073C 50 POP 073D 50 POP 073E 56 *JUMP // Stack delta = -3 // Outputs[1] { @073A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_073F: // Incoming call from 0x025B, returns to 0x025C // Inputs[1] { @0745 storage[0x02] } 073F 5B JUMPDEST 0740 60 PUSH1 0x60 0742 60 PUSH1 0x02 0744 80 DUP1 0745 54 SLOAD 0746 61 PUSH2 0x074e 0749 90 SWAP1 074A 61 PUSH2 0x1bf6 074D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0740 stack[0] = 0x60 // @0742 stack[1] = 0x02 // @0749 stack[2] = 0x074e // @0749 stack[3] = storage[0x02] // } // Block ends with call to 0x1bf6, returns to 0x074E label_074E: // Incoming return from call to 0x1BF6 at 0x0D26 // Incoming return from call to 0x1BF6 at 0x074D // Incoming return from call to 0x1BF6 at 0x1419 // Inputs[4] // { // @074F stack[-1] // @075E memory[0x40:0x60] // @0766 stack[-2] // @0771 storage[stack[-2]] // } 074E 5B JUMPDEST 074F 80 DUP1 0750 60 PUSH1 0x1f 0752 01 ADD 0753 60 PUSH1 0x20 0755 80 DUP1 0756 91 SWAP2 0757 04 DIV 0758 02 MUL 0759 60 PUSH1 0x20 075B 01 ADD 075C 60 PUSH1 0x40 075E 51 MLOAD 075F 90 SWAP1 0760 81 DUP2 0761 01 ADD 0762 60 PUSH1 0x40 0764 52 MSTORE 0765 80 DUP1 0766 92 SWAP3 0767 91 SWAP2 0768 90 SWAP1 0769 81 DUP2 076A 81 DUP2 076B 52 MSTORE 076C 60 PUSH1 0x20 076E 01 ADD 076F 82 DUP3 0770 80 DUP1 0771 54 SLOAD 0772 61 PUSH2 0x077a 0775 90 SWAP1 0776 61 PUSH2 0x1bf6 0779 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0764 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0766 stack[-2] = memory[0x40:0x60] // @0767 stack[-1] = stack[-2] // @0768 stack[0] = stack[-1] // @076B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @076E stack[1] = 0x20 + memory[0x40:0x60] // @076F stack[2] = stack[-2] // @0775 stack[4] = storage[stack[-2]] // @0775 stack[3] = 0x077a // } // Block ends with call to 0x1bf6, returns to 0x077A label_077A: // Incoming return from call to 0x1BF6 at 0x0779 // Inputs[1] { @077B stack[-1] } 077A 5B JUMPDEST 077B 80 DUP1 077C 15 ISZERO 077D 61 PUSH2 0x07c7 0780 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c7, if !stack[-1] label_0781: // Incoming jump from 0x0780, if not !stack[-1] // Inputs[1] { @0781 stack[-1] } 0781 80 DUP1 0782 60 PUSH1 0x1f 0784 10 LT 0785 61 PUSH2 0x079c 0788 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079c, if 0x1f < stack[-1] label_0789: // Incoming jump from 0x0788, if not 0x1f < stack[-1] // Inputs[4] // { // @078D stack[-2] // @078E storage[stack[-2]] // @0791 stack[-3] // @0793 stack[-1] // } 0789 61 PUSH2 0x0100 078C 80 DUP1 078D 83 DUP4 078E 54 SLOAD 078F 04 DIV 0790 02 MUL 0791 83 DUP4 0792 52 MSTORE 0793 91 SWAP2 0794 60 PUSH1 0x20 0796 01 ADD 0797 91 SWAP2 0798 61 PUSH2 0x07c7 079B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0792 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0797 stack[-1] = stack[-1] // @0797 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07c7 label_079C: // Incoming jump from 0x0788, if 0x1f < stack[-1] // Inputs[5] // { // @079D stack[-3] // @079E stack[-1] // @07A0 stack[-2] // @07A8 memory[0x00:0x20] // @07AC storage[keccak256(memory[0x00:0x20])] // } 079C 5B JUMPDEST 079D 82 DUP3 079E 01 ADD 079F 91 SWAP2 07A0 90 SWAP1 07A1 60 PUSH1 0x00 07A3 52 MSTORE 07A4 60 PUSH1 0x20 07A6 60 PUSH1 0x00 07A8 20 SHA3 07A9 90 SWAP1 07AA 5B JUMPDEST 07AB 81 DUP2 07AC 54 SLOAD 07AD 81 DUP2 07AE 52 MSTORE 07AF 90 SWAP1 07B0 60 PUSH1 0x01 07B2 01 ADD 07B3 90 SWAP1 07B4 60 PUSH1 0x20 07B6 01 ADD 07B7 80 DUP1 07B8 83 DUP4 07B9 11 GT 07BA 61 PUSH2 0x07aa 07BD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @079F stack[-3] = stack[-3] + stack[-1] // @07A3 memory[0x00:0x20] = stack[-2] // @07AE memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07B3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07B6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07aa, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07BE: // Incoming jump from 0x07BD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x07BD, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @07BE stack[-3] // @07BF stack[-1] // } 07BE 82 DUP3 07BF 90 SWAP1 07C0 03 SUB 07C1 60 PUSH1 0x1f 07C3 16 AND 07C4 82 DUP3 07C5 01 ADD 07C6 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07C6 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07C6 stack[-1] = stack[-3] // } // Block continues label_07C7: // Incoming jump from 0x0780, if !stack[-1] // Incoming jump from 0x07C6 // Incoming jump from 0x079B // Inputs[3] // { // @07CD stack[-7] // @07CD stack[-6] // @07CF stack[-8] // } 07C7 5B JUMPDEST 07C8 50 POP 07C9 50 POP 07CA 50 POP 07CB 50 POP 07CC 50 POP 07CD 90 SWAP1 07CE 50 POP 07CF 90 SWAP1 07D0 56 *JUMP // Stack delta = -7 // Outputs[1] { @07CF stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07D1: // Incoming jump from 0x0288 // Inputs[1] { @07D7 stack[-1] } 07D1 5B JUMPDEST 07D2 60 PUSH1 0x00 07D4 61 PUSH2 0x07dc 07D7 82 DUP3 07D8 61 PUSH2 0x106b 07DB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07D2 stack[0] = 0x00 // @07D4 stack[1] = 0x07dc // @07D7 stack[2] = stack[-1] // } // Block ends with call to 0x106b, returns to 0x07DC label_07DC: // Incoming return from call to 0x106B at 0x07DB // Inputs[1] { @07E0 stack[-1] } 07DC 5B JUMPDEST 07DD 61 PUSH2 0x07f0 07E0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07f0, if stack[-1] label_07E1: // Incoming jump from 0x07E0, if not stack[-1] 07E1 61 PUSH2 0x07f0 07E4 63 PUSH4 0x33d1c039 07E9 60 PUSH1 0xe2 07EB 1B SHL 07EC 61 PUSH2 0x1092 07EF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07E1 stack[0] = 0x07f0 // @07EB stack[1] = 0x33d1c039 << 0xe2 // } // Block ends with unconditional jump to 0x1092 label_07F0: // Incoming jump from 0x07E0, if stack[-1] // Inputs[4] // { // @07F4 stack[-2] // @07FF memory[0x00:0x40] // @0800 storage[keccak256(memory[0x00:0x40])] // @080A stack[-3] // } 07F0 5B JUMPDEST 07F1 50 POP 07F2 60 PUSH1 0x00 07F4 90 SWAP1 07F5 81 DUP2 07F6 52 MSTORE 07F7 60 PUSH1 0x06 07F9 60 PUSH1 0x20 07FB 52 MSTORE 07FC 60 PUSH1 0x40 07FE 90 SWAP1 07FF 20 SHA3 0800 54 SLOAD 0801 60 PUSH1 0x01 0803 60 PUSH1 0x01 0805 60 PUSH1 0xa0 0807 1B SHL 0808 03 SUB 0809 16 AND 080A 90 SWAP1 080B 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @07F6 memory[0x00:0x20] = stack[-2] // @07FB memory[0x20:0x40] = 0x06 // @080A stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_080C: // Incoming jump from 0x02B3 // Inputs[2] // { // @0810 stack[-2] // @0811 stack[-1] // } 080C 5B JUMPDEST 080D 61 PUSH2 0x0818 0810 82 DUP3 0811 82 DUP3 0812 60 PUSH1 0x01 0814 61 PUSH2 0x109c 0817 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @080D stack[0] = 0x0818 // @0810 stack[1] = stack[-2] // @0811 stack[2] = stack[-1] // @0812 stack[3] = 0x01 // } // Block ends with call to 0x109c, returns to 0x0818 label_0818: // Incoming return from call to 0x1568 at 0x12D5 // Incoming return from call to 0x109C at 0x0817 // Incoming jump from 0x0BBF, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @081B stack[-3] } 0818 5B JUMPDEST 0819 50 POP 081A 50 POP 081B 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_081C: // Incoming jump from 0x031D // Incoming call from 0x0D9D, returns to 0x0D9E // Inputs[1] { @0822 stack[-1] } 081C 5B JUMPDEST 081D 60 PUSH1 0x00 081F 61 PUSH2 0x0827 0822 82 DUP3 0823 61 PUSH2 0x113f 0826 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @081D stack[0] = 0x00 // @081F stack[1] = 0x0827 // @0822 stack[2] = stack[-1] // } // Block ends with call to 0x113f, returns to 0x0827 label_0827: // Incoming return from call to 0x113F at 0x0826 // Inputs[3] // { // @0830 stack[-5] // @0834 stack[-1] // @0835 stack[-2] // } 0827 5B JUMPDEST 0828 60 PUSH1 0x01 082A 60 PUSH1 0x01 082C 60 PUSH1 0xa0 082E 1B SHL 082F 03 SUB 0830 94 SWAP5 0831 85 DUP6 0832 16 AND 0833 94 SWAP5 0834 90 SWAP1 0835 91 SWAP2 0836 50 POP 0837 81 DUP2 0838 16 AND 0839 84 DUP5 083A 14 EQ 083B 61 PUSH2 0x084d 083E 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0833 stack[-5] = (0x01 << 0xa0) - 0x01 & stack[-5] // @0835 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x084d, if (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 label_083F: // Incoming jump from 0x083E, if not (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 083F 61 PUSH2 0x084d 0842 62 PUSH3 0xa11481 0846 60 PUSH1 0xe8 0848 1B SHL 0849 61 PUSH2 0x1092 084C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @083F stack[0] = 0x084d // @0848 stack[1] = 0xa11481 << 0xe8 // } // Block ends with unconditional jump to 0x1092 label_084D: // Incoming jump from 0x083E, if (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @0850 stack[-2] // @085B memory[0x00:0x40] // @085D storage[keccak256(memory[0x00:0x40])] // @085E msg.sender // @086A stack[-4] // } 084D 5B JUMPDEST 084E 60 PUSH1 0x00 0850 82 DUP3 0851 81 DUP2 0852 52 MSTORE 0853 60 PUSH1 0x06 0855 60 PUSH1 0x20 0857 52 MSTORE 0858 60 PUSH1 0x40 085A 90 SWAP1 085B 20 SHA3 085C 80 DUP1 085D 54 SLOAD 085E 33 CALLER 085F 80 DUP1 0860 82 DUP3 0861 14 EQ 0862 60 PUSH1 0x01 0864 60 PUSH1 0x01 0866 60 PUSH1 0xa0 0868 1B SHL 0869 03 SUB 086A 88 DUP9 086B 16 AND 086C 90 SWAP1 086D 91 SWAP2 086E 14 EQ 086F 17 OR 0870 61 PUSH2 0x0891 0873 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0852 memory[0x00:0x20] = stack[-2] // @0857 memory[0x20:0x40] = 0x06 // @085B stack[0] = keccak256(memory[0x00:0x40]) // @085D stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0891, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_0874: // Incoming jump from 0x0873, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @0877 stack[-6] // @0878 msg.sender // } 0874 61 PUSH2 0x087d 0877 86 DUP7 0878 33 CALLER 0879 61 PUSH2 0x0592 087C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0874 stack[0] = 0x087d // @0877 stack[1] = stack[-6] // @0878 stack[2] = msg.sender // } // Block ends with call to 0x0592, returns to 0x087D label_087D: // Incoming return from call to 0x0592 at 0x087C // Inputs[1] { @0881 stack[-1] } 087D 5B JUMPDEST 087E 61 PUSH2 0x0891 0881 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0891, if stack[-1] label_0882: // Incoming jump from 0x0881, if not stack[-1] 0882 61 PUSH2 0x0891 0885 63 PUSH4 0x2ce44b5f 088A 60 PUSH1 0xe1 088C 1B SHL 088D 61 PUSH2 0x1092 0890 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0882 stack[0] = 0x0891 // @088C stack[1] = 0x2ce44b5f << 0xe1 // } // Block ends with unconditional jump to 0x1092 label_0891: // Incoming jump from 0x0881, if stack[-1] // Incoming jump from 0x0873, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[1] { @0892 stack[-1] } 0891 5B JUMPDEST 0892 80 DUP1 0893 15 ISZERO 0894 61 PUSH2 0x089c 0897 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x089c, if !stack[-1] label_0898: // Incoming jump from 0x0897, if not !stack[-1] // Inputs[11] // { // @089A stack[-2] // @08A5 stack[-6] // @08B6 memory[0x00:0x40] // @08B8 storage[keccak256(memory[0x00:0x40])] // @08C0 stack[-5] // @08C7 memory[0x00:0x40] // @08C9 storage[keccak256(memory[0x00:0x40])] // @08CF block.timestamp // @08DC stack[-4] // @08E7 memory[0x00:0x40] // @08F1 stack[-3] // } 0898 60 PUSH1 0x00 089A 82 DUP3 089B 55 SSTORE 089C 5B JUMPDEST 089D 60 PUSH1 0x01 089F 60 PUSH1 0x01 08A1 60 PUSH1 0xa0 08A3 1B SHL 08A4 03 SUB 08A5 86 DUP7 08A6 81 DUP2 08A7 16 AND 08A8 60 PUSH1 0x00 08AA 90 SWAP1 08AB 81 DUP2 08AC 52 MSTORE 08AD 60 PUSH1 0x05 08AF 60 PUSH1 0x20 08B1 52 MSTORE 08B2 60 PUSH1 0x40 08B4 80 DUP1 08B5 82 DUP3 08B6 20 SHA3 08B7 80 DUP1 08B8 54 SLOAD 08B9 60 PUSH1 0x00 08BB 19 NOT 08BC 01 ADD 08BD 90 SWAP1 08BE 55 SSTORE 08BF 91 SWAP2 08C0 87 DUP8 08C1 16 AND 08C2 80 DUP1 08C3 82 DUP3 08C4 52 MSTORE 08C5 91 SWAP2 08C6 90 SWAP1 08C7 20 SHA3 08C8 80 DUP1 08C9 54 SLOAD 08CA 60 PUSH1 0x01 08CC 01 ADD 08CD 90 SWAP1 08CE 55 SSTORE 08CF 42 TIMESTAMP 08D0 60 PUSH1 0xa0 08D2 1B SHL 08D3 17 OR 08D4 60 PUSH1 0x01 08D6 60 PUSH1 0xe1 08D8 1B SHL 08D9 17 OR 08DA 60 PUSH1 0x00 08DC 85 DUP6 08DD 81 DUP2 08DE 52 MSTORE 08DF 60 PUSH1 0x04 08E1 60 PUSH1 0x20 08E3 52 MSTORE 08E4 60 PUSH1 0x40 08E6 81 DUP2 08E7 20 SHA3 08E8 91 SWAP2 08E9 90 SWAP1 08EA 91 SWAP2 08EB 55 SSTORE 08EC 60 PUSH1 0x01 08EE 60 PUSH1 0xe1 08F0 1B SHL 08F1 84 DUP5 08F2 16 AND 08F3 90 SWAP1 08F4 03 SUB 08F5 61 PUSH2 0x092e 08F8 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @089B storage[stack[-2]] = 0x00 // @08AC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @08B1 memory[0x20:0x40] = 0x05 // @08BE storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @08C4 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @08CE storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @08DE memory[0x00:0x20] = stack[-4] // @08E3 memory[0x20:0x40] = 0x04 // @08EB storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x092e, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_08F9: // Incoming jump from 0x08F8, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x08F8, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @08FB stack[-4] // @090A memory[0x00:0x40] // @090B storage[keccak256(memory[0x00:0x40])] // } 08F9 60 PUSH1 0x01 08FB 84 DUP5 08FC 01 ADD 08FD 60 PUSH1 0x00 08FF 81 DUP2 0900 81 DUP2 0901 52 MSTORE 0902 60 PUSH1 0x04 0904 60 PUSH1 0x20 0906 52 MSTORE 0907 60 PUSH1 0x40 0909 81 DUP2 090A 20 SHA3 090B 54 SLOAD 090C 90 SWAP1 090D 03 SUB 090E 61 PUSH2 0x092c 0911 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08FC stack[0] = stack[-4] + 0x01 // @0901 memory[0x00:0x20] = stack[-4] + 0x01 // @0906 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x092c, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_0912: // Incoming jump from 0x0911, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0914 storage[0x00] // @0915 stack[-1] // } 0912 60 PUSH1 0x00 0914 54 SLOAD 0915 81 DUP2 0916 14 EQ 0917 61 PUSH2 0x092c 091A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x092c, if stack[-1] == storage[0x00] label_091B: // Incoming jump from 0x091A, if not stack[-1] == storage[0x00] // Inputs[3] // { // @091D stack[-1] // @0928 memory[0x00:0x40] // @0929 stack[-4] // } 091B 60 PUSH1 0x00 091D 81 DUP2 091E 81 DUP2 091F 52 MSTORE 0920 60 PUSH1 0x04 0922 60 PUSH1 0x20 0924 52 MSTORE 0925 60 PUSH1 0x40 0927 90 SWAP1 0928 20 SHA3 0929 84 DUP5 092A 90 SWAP1 092B 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @091F memory[0x00:0x20] = stack[-1] // @0924 memory[0x20:0x40] = 0x04 // @092B storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_092C: // Incoming jump from 0x091A, if stack[-1] == storage[0x00] // Incoming jump from 0x0911, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x092B 092C 5B JUMPDEST 092D 50 POP // Stack delta = -1 // Block continues label_092E: // Incoming jump from 0x092D // Incoming jump from 0x08F8, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x08F8, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[4] // { // @0937 stack[-5] // @0939 stack[-4] // @093B stack[-6] // @0960 memory[0x00:0x00] // } 092E 5B JUMPDEST 092F 60 PUSH1 0x01 0931 60 PUSH1 0x01 0933 60 PUSH1 0xa0 0935 1B SHL 0936 03 SUB 0937 85 DUP6 0938 16 AND 0939 84 DUP5 093A 81 DUP2 093B 88 DUP9 093C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 095D 60 PUSH1 0x00 095F 80 DUP1 0960 A4 LOG4 0961 80 DUP1 0962 60 PUSH1 0x00 0964 03 SUB 0965 61 PUSH2 0x0978 0968 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0938 stack[0] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0960 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6], stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); // } // Block ends with conditional jump to 0x0978, if 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) label_0969: // Incoming jump from 0x0968, if not 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) 0969 61 PUSH2 0x0978 096C 63 PUSH4 0x3a954ecd 0971 60 PUSH1 0xe2 0973 1B SHL 0974 61 PUSH2 0x1092 0977 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0969 stack[0] = 0x0978 // @0973 stack[1] = 0x3a954ecd << 0xe2 // } // Block ends with unconditional jump to 0x1092 label_0978: // Incoming jump from 0x0968, if 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @0980 stack[-8] } 0978 5B JUMPDEST 0979 50 POP 097A 50 POP 097B 50 POP 097C 50 POP 097D 50 POP 097E 50 POP 097F 50 POP 0980 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0981: // Incoming jump from 0x033D // Inputs[2] // { // @0984 storage[0x08] // @098E msg.sender // } 0981 5B JUMPDEST 0982 60 PUSH1 0x08 0984 54 SLOAD 0985 60 PUSH1 0x01 0987 60 PUSH1 0x01 0989 60 PUSH1 0xa0 098B 1B SHL 098C 03 SUB 098D 16 AND 098E 33 CALLER 098F 14 EQ 0990 61 PUSH2 0x09ab 0993 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ab, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0994: // Incoming jump from 0x0993, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0996 memory[0x40:0x60] } 0994 60 PUSH1 0x40 0996 51 MLOAD 0997 62 PUSH3 0x461bcd 099B 60 PUSH1 0xe5 099D 1B SHL 099E 81 DUP2 099F 52 MSTORE 09A0 60 PUSH1 0x04 09A2 01 ADD 09A3 61 PUSH2 0x0698 09A6 90 SWAP1 09A7 61 PUSH2 0x1c30 09AA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @099F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09A6 stack[0] = 0x0698 // @09A6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_09AB: // Incoming jump from 0x0993, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @09AE stack[-1] // @09AF stack[-2] // } 09AB 5B JUMPDEST 09AC 60 PUSH1 0x0a 09AE 55 SSTORE 09AF 56 *JUMP // Stack delta = -2 // Outputs[1] { @09AE storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_09B0: // Incoming jump from 0x035D // Inputs[2] // { // @09B3 storage[0x08] // @09BD msg.sender // } 09B0 5B JUMPDEST 09B1 60 PUSH1 0x08 09B3 54 SLOAD 09B4 60 PUSH1 0x01 09B6 60 PUSH1 0x01 09B8 60 PUSH1 0xa0 09BA 1B SHL 09BB 03 SUB 09BC 16 AND 09BD 33 CALLER 09BE 14 EQ 09BF 61 PUSH2 0x09da 09C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09da, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09C3: // Incoming jump from 0x09C2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09C5 memory[0x40:0x60] } 09C3 60 PUSH1 0x40 09C5 51 MLOAD 09C6 62 PUSH3 0x461bcd 09CA 60 PUSH1 0xe5 09CC 1B SHL 09CD 81 DUP2 09CE 52 MSTORE 09CF 60 PUSH1 0x04 09D1 01 ADD 09D2 61 PUSH2 0x0698 09D5 90 SWAP1 09D6 61 PUSH2 0x1c30 09D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D5 stack[0] = 0x0698 // @09D5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_09DA: // Incoming jump from 0x09C2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @09DE storage[0x0b] // @09E2 stack[-1] // } 09DA 5B JUMPDEST 09DB 60 PUSH1 0x0b 09DD 80 DUP1 09DE 54 SLOAD 09DF 61 PUSH2 0xffff 09E2 83 DUP4 09E3 16 AND 09E4 01 ADD 09E5 90 SWAP1 09E6 81 DUP2 09E7 90 SWAP1 09E8 55 SSTORE 09E9 61 PUSH2 0x015d 09EC 10 LT 09ED 15 ISZERO 09EE 61 PUSH2 0x0a25 09F1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09E8 storage[0x0b] = (stack[-1] & 0xffff) + storage[0x0b] } // Block ends with conditional jump to 0x0a25, if !(0x015d < (stack[-1] & 0xffff) + storage[0x0b]) label_09F2: // Incoming jump from 0x09F1, if not !(0x015d < (stack[-1] & 0xffff) + storage[0x0b]) // Inputs[1] { @09F4 memory[0x40:0x60] } 09F2 60 PUSH1 0x40 09F4 51 MLOAD 09F5 62 PUSH3 0x461bcd 09F9 60 PUSH1 0xe5 09FB 1B SHL 09FC 81 DUP2 09FD 52 MSTORE 09FE 60 PUSH1 0x20 0A00 60 PUSH1 0x04 0A02 82 DUP3 0A03 01 ADD 0A04 52 MSTORE 0A05 60 PUSH1 0x09 0A07 60 PUSH1 0x24 0A09 82 DUP3 0A0A 01 ADD 0A0B 52 MSTORE 0A0C 68 PUSH9 0x216d617873686f6573 0A16 60 PUSH1 0xb8 0A18 1B SHL 0A19 60 PUSH1 0x44 0A1B 82 DUP3 0A1C 01 ADD 0A1D 52 MSTORE 0A1E 60 PUSH1 0x64 0A20 01 ADD 0A21 61 PUSH2 0x0698 0A24 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A04 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A0B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0A1D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x216d617873686f6573 << 0xb8 // @0A20 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0A25: // Incoming jump from 0x09F1, if !(0x015d < (stack[-1] & 0xffff) + storage[0x0b]) // Inputs[2] // { // @0A29 stack[-2] // @0A2C stack[-1] // } 0A25 5B JUMPDEST 0A26 61 PUSH2 0x0818 0A29 82 DUP3 0A2A 60 PUSH1 0x00 0A2C 83 DUP4 0A2D 61 PUSH2 0x11da 0A30 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A26 stack[0] = 0x0818 // @0A29 stack[1] = stack[-2] // @0A2A stack[2] = 0x00 // @0A2C stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x11da label_0A31: // Incoming jump from 0x037D // Inputs[2] // { // @0A34 storage[0x08] // @0A3E msg.sender // } 0A31 5B JUMPDEST 0A32 60 PUSH1 0x08 0A34 54 SLOAD 0A35 60 PUSH1 0x01 0A37 60 PUSH1 0x01 0A39 60 PUSH1 0xa0 0A3B 1B SHL 0A3C 03 SUB 0A3D 16 AND 0A3E 33 CALLER 0A3F 14 EQ 0A40 61 PUSH2 0x0a5b 0A43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a5b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0A44: // Incoming jump from 0x0A43, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A46 memory[0x40:0x60] } 0A44 60 PUSH1 0x40 0A46 51 MLOAD 0A47 62 PUSH3 0x461bcd 0A4B 60 PUSH1 0xe5 0A4D 1B SHL 0A4E 81 DUP2 0A4F 52 MSTORE 0A50 60 PUSH1 0x04 0A52 01 ADD 0A53 61 PUSH2 0x0698 0A56 90 SWAP1 0A57 61 PUSH2 0x1c30 0A5A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A56 stack[0] = 0x0698 // @0A56 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0A5B: // Incoming jump from 0x0A43, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0A5C stack[-1] // @0A5D memory[stack[-1]:stack[-1] + 0x20] // } 0A5B 5B JUMPDEST 0A5C 80 DUP1 0A5D 51 MLOAD 0A5E 61 PUSH2 0x0818 0A61 90 SWAP1 0A62 60 PUSH1 0x0d 0A64 90 SWAP1 0A65 60 PUSH1 0x20 0A67 84 DUP5 0A68 01 ADD 0A69 90 SWAP1 0A6A 61 PUSH2 0x16bb 0A6D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A61 stack[0] = 0x0818 // @0A64 stack[1] = 0x0d // @0A69 stack[2] = stack[-1] + 0x20 // @0A69 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x16bb label_0A6E: // Incoming call from 0x0392, returns to 0x0210 // Inputs[1] { @0A76 storage[0x08] } 0A6E 5B JUMPDEST 0A6F 60 PUSH1 0x00 0A71 61 PUSH2 0x0a82 0A74 60 PUSH1 0x08 0A76 54 SLOAD 0A77 60 PUSH1 0x01 0A79 60 PUSH1 0x01 0A7B 60 PUSH1 0xa0 0A7D 1B SHL 0A7E 03 SUB 0A7F 16 AND 0A80 90 SWAP1 0A81 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A6F stack[0] = 0x00 // @0A80 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x0a82 label_0A82: // Incoming jump from 0x0A81 // Inputs[9] // { // @0A8B stack[-1] // @0A8C address(this) // @0A8C address(this).balance // @0A8F memory[0x40:0x60] // @0A94 memory[0x40:0x60] // @0A9B msg.gas // @0A9C address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0A9C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0AA1 returndata.length // } 0A82 5B JUMPDEST 0A83 60 PUSH1 0x01 0A85 60 PUSH1 0x01 0A87 60 PUSH1 0xa0 0A89 1B SHL 0A8A 03 SUB 0A8B 16 AND 0A8C 47 SELFBALANCE 0A8D 60 PUSH1 0x40 0A8F 51 MLOAD 0A90 60 PUSH1 0x00 0A92 60 PUSH1 0x40 0A94 51 MLOAD 0A95 80 DUP1 0A96 83 DUP4 0A97 03 SUB 0A98 81 DUP2 0A99 85 DUP6 0A9A 87 DUP8 0A9B 5A GAS 0A9C F1 CALL 0A9D 92 SWAP3 0A9E 50 POP 0A9F 50 POP 0AA0 50 POP 0AA1 3D RETURNDATASIZE 0AA2 80 DUP1 0AA3 60 PUSH1 0x00 0AA5 81 DUP2 0AA6 14 EQ 0AA7 61 PUSH2 0x0acc 0AAA 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0A9D stack[-1] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0AA1 stack[0] = returndata.length // @0AA2 stack[1] = returndata.length // } // Block ends with conditional jump to 0x0acc, if returndata.length == 0x00 label_0AAB: // Incoming jump from 0x0AAA, if not returndata.length == 0x00 // Inputs[6] // { // @0AAD memory[0x40:0x60] // @0AAE stack[-2] // @0AB5 returndata.length // @0ABD returndata.length // @0AC0 returndata.length // @0AC7 returndata[0x00:0x00 + returndata.length] // } 0AAB 60 PUSH1 0x40 0AAD 51 MLOAD 0AAE 91 SWAP2 0AAF 50 POP 0AB0 60 PUSH1 0x1f 0AB2 19 NOT 0AB3 60 PUSH1 0x3f 0AB5 3D RETURNDATASIZE 0AB6 01 ADD 0AB7 16 AND 0AB8 82 DUP3 0AB9 01 ADD 0ABA 60 PUSH1 0x40 0ABC 52 MSTORE 0ABD 3D RETURNDATASIZE 0ABE 82 DUP3 0ABF 52 MSTORE 0AC0 3D RETURNDATASIZE 0AC1 60 PUSH1 0x00 0AC3 60 PUSH1 0x20 0AC5 84 DUP5 0AC6 01 ADD 0AC7 3E RETURNDATACOPY 0AC8 61 PUSH2 0x0ad1 0ACB 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0AAE stack[-2] = memory[0x40:0x60] // @0ABC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0ABF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0AC7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0ad1 label_0ACC: // Incoming jump from 0x0AAA, if returndata.length == 0x00 // Inputs[3] // { // @0ACF stack[-2] // @0AD4 stack[-4] // @0AD4 stack[-3] // } 0ACC 5B JUMPDEST 0ACD 60 PUSH1 0x60 0ACF 91 SWAP2 0AD0 50 POP 0AD1 5B JUMPDEST 0AD2 50 POP 0AD3 50 POP 0AD4 90 SWAP1 0AD5 50 POP 0AD6 80 DUP1 0AD7 61 PUSH2 0x0b0e 0ADA 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0AD4 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0b0e, if stack[-3] label_0ADB: // Incoming jump from 0x0ADA, if not stack[-3] // Incoming jump from 0x0ADA, if not stack[-3] // Inputs[1] { @0ADD memory[0x40:0x60] } 0ADB 60 PUSH1 0x40 0ADD 51 MLOAD 0ADE 62 PUSH3 0x461bcd 0AE2 60 PUSH1 0xe5 0AE4 1B SHL 0AE5 81 DUP2 0AE6 52 MSTORE 0AE7 60 PUSH1 0x20 0AE9 60 PUSH1 0x04 0AEB 82 DUP3 0AEC 01 ADD 0AED 52 MSTORE 0AEE 60 PUSH1 0x09 0AF0 60 PUSH1 0x24 0AF2 82 DUP3 0AF3 01 ADD 0AF4 52 MSTORE 0AF5 68 PUSH9 0x10ba3930b739b332b9 0AFF 60 PUSH1 0xb9 0B01 1B SHL 0B02 60 PUSH1 0x44 0B04 82 DUP3 0B05 01 ADD 0B06 52 MSTORE 0B07 60 PUSH1 0x64 0B09 01 ADD 0B0A 61 PUSH2 0x0698 0B0D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AF4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0B06 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x10ba3930b739b332b9 << 0xb9 // @0B09 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0B0E: // Incoming jump from 0x0ADA, if stack[-3] // Incoming jump from 0x180E, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x12D6 at 0x0FEC // Incoming jump from 0x0ADA, if stack[-3] // Inputs[1] { @0B10 stack[-2] } 0B0E 5B JUMPDEST 0B0F 50 POP 0B10 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0B11: // Incoming jump from 0x03A5 // Inputs[4] // { // @0B15 stack[-3] // @0B16 stack[-2] // @0B17 stack[-1] // @0B1A memory[0x40:0x60] // } 0B11 5B JUMPDEST 0B12 61 PUSH2 0x0b2c 0B15 83 DUP4 0B16 83 DUP4 0B17 83 DUP4 0B18 60 PUSH1 0x40 0B1A 51 MLOAD 0B1B 80 DUP1 0B1C 60 PUSH1 0x20 0B1E 01 ADD 0B1F 60 PUSH1 0x40 0B21 52 MSTORE 0B22 80 DUP1 0B23 60 PUSH1 0x00 0B25 81 DUP2 0B26 52 MSTORE 0B27 50 POP 0B28 61 PUSH2 0x0d93 0B2B 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B12 stack[0] = 0x0b2c // @0B15 stack[1] = stack[-3] // @0B16 stack[2] = stack[-2] // @0B17 stack[3] = stack[-1] // @0B1A stack[4] = memory[0x40:0x60] // @0B21 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0B26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0d93, returns to 0x0B2C label_0B2C: // Incoming jump from 0x1582, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Incoming return from call to 0x0D93 at 0x0B2B // Inputs[1] { @0B30 stack[-4] } 0B2C 5B JUMPDEST 0B2D 50 POP 0B2E 50 POP 0B2F 50 POP 0B30 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0B31: // Incoming jump from 0x03C5 // Inputs[2] // { // @0B34 storage[0x08] // @0B3E msg.sender // } 0B31 5B JUMPDEST 0B32 60 PUSH1 0x08 0B34 54 SLOAD 0B35 60 PUSH1 0x01 0B37 60 PUSH1 0x01 0B39 60 PUSH1 0xa0 0B3B 1B SHL 0B3C 03 SUB 0B3D 16 AND 0B3E 33 CALLER 0B3F 14 EQ 0B40 61 PUSH2 0x0b5b 0B43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b5b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0B44: // Incoming jump from 0x0B43, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0B46 memory[0x40:0x60] } 0B44 60 PUSH1 0x40 0B46 51 MLOAD 0B47 62 PUSH3 0x461bcd 0B4B 60 PUSH1 0xe5 0B4D 1B SHL 0B4E 81 DUP2 0B4F 52 MSTORE 0B50 60 PUSH1 0x04 0B52 01 ADD 0B53 61 PUSH2 0x0698 0B56 90 SWAP1 0B57 61 PUSH2 0x1c30 0B5A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B56 stack[0] = 0x0698 // @0B56 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0B5B: // Incoming jump from 0x0B43, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0B5C stack[-1] // @0B5D memory[stack[-1]:stack[-1] + 0x20] // @0B64 storage[0x0b] // } 0B5B 5B JUMPDEST 0B5C 80 DUP1 0B5D 51 MLOAD 0B5E 60 PUSH1 0x0b 0B60 60 PUSH1 0x00 0B62 82 DUP3 0B63 82 DUP3 0B64 54 SLOAD 0B65 61 PUSH2 0x0b6e 0B68 91 SWAP2 0B69 90 SWAP1 0B6A 61 PUSH2 0x1c7b 0B6D 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0B5D stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @0B5E stack[1] = 0x0b // @0B60 stack[2] = 0x00 // @0B68 stack[3] = 0x0b6e // @0B69 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0B69 stack[5] = storage[0x0b] // } // Block ends with call to 0x1c7b, returns to 0x0B6E label_0B6E: // Incoming return from call to 0x1C7B at 0x0B6D // Inputs[4] // { // @0B6F stack[-1] // @0B6F stack[-2] // @0B70 stack[-3] // @0B76 storage[0x0b] // } 0B6E 5B JUMPDEST 0B6F 90 SWAP1 0B70 91 SWAP2 0B71 55 SSTORE 0B72 50 POP 0B73 50 POP 0B74 60 PUSH1 0x0b 0B76 54 SLOAD 0B77 61 PUSH2 0x015d 0B7A 10 LT 0B7B 15 ISZERO 0B7C 61 PUSH2 0x0bb3 0B7F 57 *JUMPI // Stack delta = -4 // Outputs[1] { @0B71 storage[stack[-3]] = stack[-1] } // Block ends with conditional jump to 0x0bb3, if !(0x015d < storage[0x0b]) label_0B80: // Incoming jump from 0x0B7F, if not !(0x015d < storage[0x0b]) // Inputs[1] { @0B82 memory[0x40:0x60] } 0B80 60 PUSH1 0x40 0B82 51 MLOAD 0B83 62 PUSH3 0x461bcd 0B87 60 PUSH1 0xe5 0B89 1B SHL 0B8A 81 DUP2 0B8B 52 MSTORE 0B8C 60 PUSH1 0x20 0B8E 60 PUSH1 0x04 0B90 82 DUP3 0B91 01 ADD 0B92 52 MSTORE 0B93 60 PUSH1 0x09 0B95 60 PUSH1 0x24 0B97 82 DUP3 0B98 01 ADD 0B99 52 MSTORE 0B9A 68 PUSH9 0x216d617873686f6573 0BA4 60 PUSH1 0xb8 0BA6 1B SHL 0BA7 60 PUSH1 0x44 0BA9 82 DUP3 0BAA 01 ADD 0BAB 52 MSTORE 0BAC 60 PUSH1 0x64 0BAE 01 ADD 0BAF 61 PUSH2 0x0698 0BB2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B92 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B99 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0BAB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x216d617873686f6573 << 0xb8 // @0BAE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0BB3: // Incoming jump from 0x0B7F, if !(0x015d < storage[0x0b]) // Inputs[2] // { // @0BB7 stack[-1] // @0BB8 memory[stack[-1]:stack[-1] + 0x20] // } 0BB3 5B JUMPDEST 0BB4 60 PUSH1 0x00 0BB6 5B JUMPDEST 0BB7 81 DUP2 0BB8 51 MLOAD 0BB9 81 DUP2 0BBA 10 LT 0BBB 15 ISZERO 0BBC 61 PUSH2 0x0818 0BBF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BB4 stack[0] = 0x00 } // Block ends with conditional jump to 0x0818, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0BC0: // Incoming jump from 0x0BBF, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0BC3 stack[-2] // @0BC4 stack[-1] // @0BC6 memory[stack[-2]:stack[-2] + 0x20] // } 0BC0 61 PUSH2 0x0be3 0BC3 82 DUP3 0BC4 82 DUP3 0BC5 81 DUP2 0BC6 51 MLOAD 0BC7 81 DUP2 0BC8 10 LT 0BC9 61 PUSH2 0x0bd4 0BCC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0BC0 stack[0] = 0x0be3 // @0BC3 stack[1] = stack[-2] // @0BC4 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0bd4, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0BCD: // Incoming jump from 0x0BCC, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0BCD 61 PUSH2 0x0bd4 0BD0 61 PUSH2 0x1c93 0BD3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BCD stack[0] = 0x0bd4 } // Block ends with unconditional jump to 0x1c93 label_0BD4: // Incoming jump from 0x0BCC, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0BD7 stack[-1] // @0BDB stack[-2] // @0BDC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0BD4 5B JUMPDEST 0BD5 60 PUSH1 0x20 0BD7 02 MUL 0BD8 60 PUSH1 0x20 0BDA 01 ADD 0BDB 01 ADD 0BDC 51 MLOAD 0BDD 60 PUSH1 0x01 0BDF 61 PUSH2 0x12bc 0BE2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0BDC stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0BDD stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x12bc 0BE3 5B JUMPDEST 0BE4 80 DUP1 0BE5 61 PUSH2 0x0bed 0BE8 81 DUP2 0BE9 61 PUSH2 0x1ca9 0BEC 56 *JUMP 0BED 5B JUMPDEST 0BEE 91 SWAP2 0BEF 50 POP 0BF0 50 POP 0BF1 61 PUSH2 0x0bb6 0BF4 56 *JUMP label_0BF5: // Incoming jump from 0x03E5 // Incoming call from 0x10A6, returns to 0x10A7 // Inputs[1] { @0BFB stack[-1] } 0BF5 5B JUMPDEST 0BF6 60 PUSH1 0x00 0BF8 61 PUSH2 0x0739 0BFB 82 DUP3 0BFC 61 PUSH2 0x113f 0BFF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BF6 stack[0] = 0x00 // @0BF8 stack[1] = 0x0739 // @0BFB stack[2] = stack[-1] // } // Block ends with call to 0x113f, returns to 0x0739 label_0C00: // Incoming jump from 0x0405 // Inputs[1] { @0C0B stack[-1] } 0C00 5B JUMPDEST 0C01 60 PUSH1 0x00 0C03 60 PUSH1 0x01 0C05 60 PUSH1 0x01 0C07 60 PUSH1 0xa0 0C09 1B SHL 0C0A 03 SUB 0C0B 82 DUP3 0C0C 16 AND 0C0D 61 PUSH2 0x0c20 0C10 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C01 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c20, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0C11: // Incoming jump from 0x0C10, if not stack[-1] & (0x01 << 0xa0) - 0x01 0C11 61 PUSH2 0x0c20 0C14 63 PUSH4 0x23d3ad81 0C19 60 PUSH1 0xe2 0C1B 1B SHL 0C1C 61 PUSH2 0x1092 0C1F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C11 stack[0] = 0x0c20 // @0C1B stack[1] = 0x23d3ad81 << 0xe2 // } // Block ends with unconditional jump to 0x1092 label_0C20: // Incoming jump from 0x0C10, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0C2A stack[-2] // @0C38 memory[0x00:0x40] // @0C39 storage[keccak256(memory[0x00:0x40])] // @0C44 stack[-3] // } 0C20 5B JUMPDEST 0C21 50 POP 0C22 60 PUSH1 0x01 0C24 60 PUSH1 0x01 0C26 60 PUSH1 0xa0 0C28 1B SHL 0C29 03 SUB 0C2A 16 AND 0C2B 60 PUSH1 0x00 0C2D 90 SWAP1 0C2E 81 DUP2 0C2F 52 MSTORE 0C30 60 PUSH1 0x05 0C32 60 PUSH1 0x20 0C34 52 MSTORE 0C35 60 PUSH1 0x40 0C37 90 SWAP1 0C38 20 SHA3 0C39 54 SLOAD 0C3A 67 PUSH8 0xffffffffffffffff 0C43 16 AND 0C44 90 SWAP1 0C45 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C2F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0C34 memory[0x20:0x40] = 0x05 // @0C44 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C46: // Incoming call from 0x041A, returns to 0x0210 // Inputs[2] // { // @0C49 storage[0x08] // @0C53 msg.sender // } 0C46 5B JUMPDEST 0C47 60 PUSH1 0x08 0C49 54 SLOAD 0C4A 60 PUSH1 0x01 0C4C 60 PUSH1 0x01 0C4E 60 PUSH1 0xa0 0C50 1B SHL 0C51 03 SUB 0C52 16 AND 0C53 33 CALLER 0C54 14 EQ 0C55 61 PUSH2 0x0c70 0C58 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c70, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C59: // Incoming jump from 0x0C58, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C5B memory[0x40:0x60] } 0C59 60 PUSH1 0x40 0C5B 51 MLOAD 0C5C 62 PUSH3 0x461bcd 0C60 60 PUSH1 0xe5 0C62 1B SHL 0C63 81 DUP2 0C64 52 MSTORE 0C65 60 PUSH1 0x04 0C67 01 ADD 0C68 61 PUSH2 0x0698 0C6B 90 SWAP1 0C6C 61 PUSH2 0x1c30 0C6F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C6B stack[0] = 0x0698 // @0C6B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0C70: // Incoming jump from 0x0C58, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0C70 5B JUMPDEST 0C71 61 PUSH2 0x0c7a 0C74 60 PUSH1 0x00 0C76 61 PUSH2 0x12d6 0C79 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C71 stack[0] = 0x0c7a // @0C74 stack[1] = 0x00 // } // Block ends with call to 0x12d6, returns to 0x0C7A label_0C7A: // Incoming return from call to 0x12D6 at 0x0C79 // Inputs[1] { @0C7B stack[-1] } 0C7A 5B JUMPDEST 0C7B 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C7C: // Incoming jump from 0x043A // Inputs[2] // { // @0C7F storage[0x08] // @0C89 msg.sender // } 0C7C 5B JUMPDEST 0C7D 60 PUSH1 0x08 0C7F 54 SLOAD 0C80 60 PUSH1 0x01 0C82 60 PUSH1 0x01 0C84 60 PUSH1 0xa0 0C86 1B SHL 0C87 03 SUB 0C88 16 AND 0C89 33 CALLER 0C8A 14 EQ 0C8B 61 PUSH2 0x0ca6 0C8E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ca6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C8F: // Incoming jump from 0x0C8E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C91 memory[0x40:0x60] } 0C8F 60 PUSH1 0x40 0C91 51 MLOAD 0C92 62 PUSH3 0x461bcd 0C96 60 PUSH1 0xe5 0C98 1B SHL 0C99 81 DUP2 0C9A 52 MSTORE 0C9B 60 PUSH1 0x04 0C9D 01 ADD 0C9E 61 PUSH2 0x0698 0CA1 90 SWAP1 0CA2 61 PUSH2 0x1c30 0CA5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CA1 stack[0] = 0x0698 // @0CA1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0CA6: // Incoming jump from 0x0C8E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CA9 stack[-1] // @0CAA stack[-2] // } 0CA6 5B JUMPDEST 0CA7 60 PUSH1 0x09 0CA9 55 SSTORE 0CAA 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CA9 storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0CAB: // Incoming jump from 0x045A // Inputs[2] // { // @0CAE storage[0x08] // @0CB8 msg.sender // } 0CAB 5B JUMPDEST 0CAC 60 PUSH1 0x08 0CAE 54 SLOAD 0CAF 60 PUSH1 0x01 0CB1 60 PUSH1 0x01 0CB3 60 PUSH1 0xa0 0CB5 1B SHL 0CB6 03 SUB 0CB7 16 AND 0CB8 33 CALLER 0CB9 14 EQ 0CBA 61 PUSH2 0x0cd5 0CBD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CBE: // Incoming jump from 0x0CBD, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CC0 memory[0x40:0x60] } 0CBE 60 PUSH1 0x40 0CC0 51 MLOAD 0CC1 62 PUSH3 0x461bcd 0CC5 60 PUSH1 0xe5 0CC7 1B SHL 0CC8 81 DUP2 0CC9 52 MSTORE 0CCA 60 PUSH1 0x04 0CCC 01 ADD 0CCD 61 PUSH2 0x0698 0CD0 90 SWAP1 0CD1 61 PUSH2 0x1c30 0CD4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CD0 stack[0] = 0x0698 // @0CD0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0CD5: // Incoming jump from 0x0CBD, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0CD8 stack[-1] // @0CD9 stack[-2] // } 0CD5 5B JUMPDEST 0CD6 60 PUSH1 0x0e 0CD8 55 SSTORE 0CD9 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CD8 storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0CDA: // Incoming call from 0x046F, returns to 0x0210 // Inputs[2] // { // @0CDD storage[0x08] // @0CE7 msg.sender // } 0CDA 5B JUMPDEST 0CDB 60 PUSH1 0x08 0CDD 54 SLOAD 0CDE 60 PUSH1 0x01 0CE0 60 PUSH1 0x01 0CE2 60 PUSH1 0xa0 0CE4 1B SHL 0CE5 03 SUB 0CE6 16 AND 0CE7 33 CALLER 0CE8 14 EQ 0CE9 61 PUSH2 0x0d04 0CEC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d04, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0CED: // Incoming jump from 0x0CEC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0CEF memory[0x40:0x60] } 0CED 60 PUSH1 0x40 0CEF 51 MLOAD 0CF0 62 PUSH3 0x461bcd 0CF4 60 PUSH1 0xe5 0CF6 1B SHL 0CF7 81 DUP2 0CF8 52 MSTORE 0CF9 60 PUSH1 0x04 0CFB 01 ADD 0CFC 61 PUSH2 0x0698 0CFF 90 SWAP1 0D00 61 PUSH2 0x1c30 0D03 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CFF stack[0] = 0x0698 // @0CFF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0D04: // Incoming jump from 0x0CEC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0D08 storage[0x0c] // @0D17 stack[-1] // } 0D04 5B JUMPDEST 0D05 60 PUSH1 0x0c 0D07 80 DUP1 0D08 54 SLOAD 0D09 60 PUSH1 0xff 0D0B 19 NOT 0D0C 81 DUP2 0D0D 16 AND 0D0E 60 PUSH1 0xff 0D10 90 SWAP1 0D11 91 SWAP2 0D12 16 AND 0D13 15 ISZERO 0D14 17 OR 0D15 90 SWAP1 0D16 55 SSTORE 0D17 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D16 storage[0x0c] = !(storage[0x0c] & 0xff) | (storage[0x0c] & ~0xff) } // Block ends with unconditional jump to stack[-1] label_0D18: // Incoming call from 0x04A2, returns to 0x025C // Inputs[1] { @0D1E storage[0x03] } 0D18 5B JUMPDEST 0D19 60 PUSH1 0x60 0D1B 60 PUSH1 0x03 0D1D 80 DUP1 0D1E 54 SLOAD 0D1F 61 PUSH2 0x074e 0D22 90 SWAP1 0D23 61 PUSH2 0x1bf6 0D26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D19 stack[0] = 0x60 // @0D1B stack[1] = 0x03 // @0D22 stack[2] = 0x074e // @0D22 stack[3] = storage[0x03] // } // Block ends with call to 0x1bf6, returns to 0x074E label_0D27: // Incoming jump from 0x04C2 // Inputs[10] // { // @0D28 msg.sender // @0D39 memory[0x00:0x40] // @0D42 stack[-2] // @0D4D memory[0x00:0x40] // @0D4F storage[keccak256(memory[0x00:0x40])] // @0D54 stack[-1] // @0D5E memory[0x40:0x60] // @0D8A memory[0x40:0x60] // @0D8F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D92 stack[-3] // } 0D27 5B JUMPDEST 0D28 33 CALLER 0D29 60 PUSH1 0x00 0D2B 81 DUP2 0D2C 81 DUP2 0D2D 52 MSTORE 0D2E 60 PUSH1 0x07 0D30 60 PUSH1 0x20 0D32 90 SWAP1 0D33 81 DUP2 0D34 52 MSTORE 0D35 60 PUSH1 0x40 0D37 80 DUP1 0D38 83 DUP4 0D39 20 SHA3 0D3A 60 PUSH1 0x01 0D3C 60 PUSH1 0x01 0D3E 60 PUSH1 0xa0 0D40 1B SHL 0D41 03 SUB 0D42 87 DUP8 0D43 16 AND 0D44 80 DUP1 0D45 85 DUP6 0D46 52 MSTORE 0D47 90 SWAP1 0D48 83 DUP4 0D49 52 MSTORE 0D4A 92 SWAP3 0D4B 81 DUP2 0D4C 90 SWAP1 0D4D 20 SHA3 0D4E 80 DUP1 0D4F 54 SLOAD 0D50 60 PUSH1 0xff 0D52 19 NOT 0D53 16 AND 0D54 86 DUP7 0D55 15 ISZERO 0D56 15 ISZERO 0D57 90 SWAP1 0D58 81 DUP2 0D59 17 OR 0D5A 90 SWAP1 0D5B 91 SWAP2 0D5C 55 SSTORE 0D5D 90 SWAP1 0D5E 51 MLOAD 0D5F 90 SWAP1 0D60 81 DUP2 0D61 52 MSTORE 0D62 91 SWAP2 0D63 92 SWAP3 0D64 91 SWAP2 0D65 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D86 91 SWAP2 0D87 01 ADD 0D88 60 PUSH1 0x40 0D8A 51 MLOAD 0D8B 80 DUP1 0D8C 91 SWAP2 0D8D 03 SUB 0D8E 90 SWAP1 0D8F A3 LOG3 0D90 50 POP 0D91 50 POP 0D92 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D2D memory[0x00:0x20] = msg.sender // @0D34 memory[0x20:0x40] = 0x07 // @0D46 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D49 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D5C storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0D61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0D8F 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_0D93: // Incoming jump from 0x04D5 // Incoming call from 0x0B2B, returns to 0x0B2C // Inputs[3] // { // @0D97 stack[-4] // @0D98 stack[-3] // @0D99 stack[-2] // } 0D93 5B JUMPDEST 0D94 61 PUSH2 0x0d9e 0D97 84 DUP5 0D98 84 DUP5 0D99 84 DUP5 0D9A 61 PUSH2 0x081c 0D9D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D94 stack[0] = 0x0d9e // @0D97 stack[1] = stack[-4] // @0D98 stack[2] = stack[-3] // @0D99 stack[3] = stack[-2] // } // Block ends with call to 0x081c, returns to 0x0D9E label_0D9E: // Incoming return from call to 0x081C at 0x0D9D // Inputs[2] // { // @0DA7 stack[-3] // @0DA9 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 0D9E 5B JUMPDEST 0D9F 60 PUSH1 0x01 0DA1 60 PUSH1 0x01 0DA3 60 PUSH1 0xa0 0DA5 1B SHL 0DA6 03 SUB 0DA7 83 DUP4 0DA8 16 AND 0DA9 3B EXTCODESIZE 0DAA 15 ISZERO 0DAB 61 PUSH2 0x0dce 0DAE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dce, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_0DAF: // Incoming jump from 0x0DAE, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0DB2 stack[-4] // @0DB3 stack[-3] // @0DB4 stack[-2] // @0DB5 stack[-1] // } 0DAF 61 PUSH2 0x0dba 0DB2 84 DUP5 0DB3 84 DUP5 0DB4 84 DUP5 0DB5 84 DUP5 0DB6 61 PUSH2 0x1328 0DB9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DAF stack[0] = 0x0dba // @0DB2 stack[1] = stack[-4] // @0DB3 stack[2] = stack[-3] // @0DB4 stack[3] = stack[-2] // @0DB5 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1328 0DBA 5B JUMPDEST 0DBB 61 PUSH2 0x0dce 0DBE 57 *JUMPI 0DBF 61 PUSH2 0x0dce 0DC2 63 PUSH4 0x68d2bf6b 0DC7 60 PUSH1 0xe1 0DC9 1B SHL 0DCA 61 PUSH2 0x1092 0DCD 56 *JUMP label_0DCE: // Incoming jump from 0x1853, if !(stack[-1] > stack[-4]) // Incoming jump from 0x0DAE, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0DD3 stack[-5] } 0DCE 5B JUMPDEST 0DCF 50 POP 0DD0 50 POP 0DD1 50 POP 0DD2 50 POP 0DD3 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0DD4: // Incoming jump from 0x0521 // Inputs[1] { @0DDA stack[-1] } 0DD4 5B JUMPDEST 0DD5 60 PUSH1 0x60 0DD7 61 PUSH2 0x0ddf 0DDA 82 DUP3 0DDB 61 PUSH2 0x106b 0DDE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DD5 stack[0] = 0x60 // @0DD7 stack[1] = 0x0ddf // @0DDA stack[2] = stack[-1] // } // Block ends with call to 0x106b, returns to 0x0DDF label_0DDF: // Incoming return from call to 0x106B at 0x0DDE // Inputs[1] { @0DE3 stack[-1] } 0DDF 5B JUMPDEST 0DE0 61 PUSH2 0x0e43 0DE3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e43, if stack[-1] label_0DE4: // Incoming jump from 0x0DE3, if not stack[-1] // Inputs[1] { @0DE6 memory[0x40:0x60] } 0DE4 60 PUSH1 0x40 0DE6 51 MLOAD 0DE7 62 PUSH3 0x461bcd 0DEB 60 PUSH1 0xe5 0DED 1B SHL 0DEE 81 DUP2 0DEF 52 MSTORE 0DF0 60 PUSH1 0x20 0DF2 60 PUSH1 0x04 0DF4 82 DUP3 0DF5 01 ADD 0DF6 52 MSTORE 0DF7 60 PUSH1 0x2f 0DF9 60 PUSH1 0x24 0DFB 82 DUP3 0DFC 01 ADD 0DFD 52 MSTORE 0DFE 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 0E1F 60 PUSH1 0x44 0E21 82 DUP3 0E22 01 ADD 0E23 52 MSTORE 0E24 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 0E34 60 PUSH1 0x89 0E36 1B SHL 0E37 60 PUSH1 0x64 0E39 82 DUP3 0E3A 01 ADD 0E3B 52 MSTORE 0E3C 60 PUSH1 0x84 0E3E 01 ADD 0E3F 61 PUSH2 0x0698 0E42 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DFD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0E23 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @0E3B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @0E3E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0E43: // Incoming jump from 0x0DE3, if stack[-1] 0E43 5B JUMPDEST 0E44 61 PUSH2 0x0e4b 0E47 61 PUSH2 0x140b 0E4A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E44 stack[0] = 0x0e4b } // Block ends with unconditional jump to 0x140b 0E4B 5B JUMPDEST 0E4C 61 PUSH2 0x0e54 0E4F 83 DUP4 0E50 61 PUSH2 0x141a 0E53 56 *JUMP 0E54 5B JUMPDEST 0E55 60 PUSH1 0x40 0E57 51 MLOAD 0E58 60 PUSH1 0x20 0E5A 01 ADD 0E5B 61 PUSH2 0x0e65 0E5E 92 SWAP3 0E5F 91 SWAP2 0E60 90 SWAP1 0E61 61 PUSH2 0x1cc2 0E64 56 *JUMP 0E65 5B JUMPDEST 0E66 60 PUSH1 0x40 0E68 51 MLOAD 0E69 60 PUSH1 0x20 0E6B 81 DUP2 0E6C 83 DUP4 0E6D 03 SUB 0E6E 03 SUB 0E6F 81 DUP2 0E70 52 MSTORE 0E71 90 SWAP1 0E72 60 PUSH1 0x40 0E74 52 MSTORE 0E75 90 SWAP1 0E76 50 POP 0E77 91 SWAP2 0E78 90 SWAP1 0E79 50 POP 0E7A 56 *JUMP label_0E7B: // Incoming jump from 0x0534 // Inputs[1] { @0E7E storage[0x0c] } 0E7B 5B JUMPDEST 0E7C 60 PUSH1 0x0c 0E7E 54 SLOAD 0E7F 60 PUSH1 0xff 0E81 16 AND 0E82 15 ISZERO 0E83 15 ISZERO 0E84 60 PUSH1 0x01 0E86 14 EQ 0E87 61 PUSH2 0x0eba 0E8A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eba, if 0x01 == !!(0xff & storage[0x0c]) label_0E8B: // Incoming jump from 0x0E8A, if not 0x01 == !!(0xff & storage[0x0c]) // Inputs[1] { @0E8D memory[0x40:0x60] } 0E8B 60 PUSH1 0x40 0E8D 51 MLOAD 0E8E 62 PUSH3 0x461bcd 0E92 60 PUSH1 0xe5 0E94 1B SHL 0E95 81 DUP2 0E96 52 MSTORE 0E97 60 PUSH1 0x20 0E99 60 PUSH1 0x04 0E9B 82 DUP3 0E9C 01 ADD 0E9D 52 MSTORE 0E9E 60 PUSH1 0x05 0EA0 60 PUSH1 0x24 0EA2 82 DUP3 0EA3 01 ADD 0EA4 52 MSTORE 0EA5 64 PUSH5 0x10b7b832b7 0EAB 60 PUSH1 0xd9 0EAD 1B SHL 0EAE 60 PUSH1 0x44 0EB0 82 DUP3 0EB1 01 ADD 0EB2 52 MSTORE 0EB3 60 PUSH1 0x64 0EB5 01 ADD 0EB6 61 PUSH2 0x0698 0EB9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E9D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EA4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x05 // @0EB2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x10b7b832b7 << 0xd9 // @0EB5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0EBA: // Incoming jump from 0x0E8A, if 0x01 == !!(0xff & storage[0x0c]) // Inputs[3] // { // @0EBE stack[-2] // @0EC1 storage[0x09] // @0EC2 stack[-1] // } 0EBA 5B JUMPDEST 0EBB 61 PUSH2 0x0818 0EBE 82 DUP3 0EBF 60 PUSH1 0x09 0EC1 54 SLOAD 0EC2 83 DUP4 0EC3 61 PUSH2 0x1003 0EC6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EBB stack[0] = 0x0818 // @0EBE stack[1] = stack[-2] // @0EC1 stack[2] = storage[0x09] // @0EC2 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1003 label_0EC7: // Incoming call from 0x0549, returns to 0x025C // Inputs[1] { @0ECB storage[0x0d] } 0EC7 5B JUMPDEST 0EC8 60 PUSH1 0x0d 0ECA 80 DUP1 0ECB 54 SLOAD 0ECC 61 PUSH2 0x0ed4 0ECF 90 SWAP1 0ED0 61 PUSH2 0x1bf6 0ED3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EC8 stack[0] = 0x0d // @0ECF stack[1] = 0x0ed4 // @0ECF stack[2] = storage[0x0d] // } // Block ends with call to 0x1bf6, returns to 0x0ED4 label_0ED4: // Incoming return from call to 0x1BF6 at 0x0ED3 // Inputs[4] // { // @0ED5 stack[-1] // @0EE4 memory[0x40:0x60] // @0EEC stack[-2] // @0EF7 storage[stack[-2]] // } 0ED4 5B JUMPDEST 0ED5 80 DUP1 0ED6 60 PUSH1 0x1f 0ED8 01 ADD 0ED9 60 PUSH1 0x20 0EDB 80 DUP1 0EDC 91 SWAP2 0EDD 04 DIV 0EDE 02 MUL 0EDF 60 PUSH1 0x20 0EE1 01 ADD 0EE2 60 PUSH1 0x40 0EE4 51 MLOAD 0EE5 90 SWAP1 0EE6 81 DUP2 0EE7 01 ADD 0EE8 60 PUSH1 0x40 0EEA 52 MSTORE 0EEB 80 DUP1 0EEC 92 SWAP3 0EED 91 SWAP2 0EEE 90 SWAP1 0EEF 81 DUP2 0EF0 81 DUP2 0EF1 52 MSTORE 0EF2 60 PUSH1 0x20 0EF4 01 ADD 0EF5 82 DUP3 0EF6 80 DUP1 0EF7 54 SLOAD 0EF8 61 PUSH2 0x0f00 0EFB 90 SWAP1 0EFC 61 PUSH2 0x1bf6 0EFF 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0EEA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0EEC stack[-2] = memory[0x40:0x60] // @0EED stack[-1] = stack[-2] // @0EEE stack[0] = stack[-1] // @0EF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0EF4 stack[1] = 0x20 + memory[0x40:0x60] // @0EF5 stack[2] = stack[-2] // @0EFB stack[4] = storage[stack[-2]] // @0EFB stack[3] = 0x0f00 // } // Block ends with call to 0x1bf6, returns to 0x0F00 label_0F00: // Incoming return from call to 0x1BF6 at 0x0EFF // Inputs[1] { @0F01 stack[-1] } 0F00 5B JUMPDEST 0F01 80 DUP1 0F02 15 ISZERO 0F03 61 PUSH2 0x0f4d 0F06 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f4d, if !stack[-1] label_0F07: // Incoming jump from 0x0F06, if not !stack[-1] // Inputs[1] { @0F07 stack[-1] } 0F07 80 DUP1 0F08 60 PUSH1 0x1f 0F0A 10 LT 0F0B 61 PUSH2 0x0f22 0F0E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f22, if 0x1f < stack[-1] label_0F0F: // Incoming jump from 0x0F0E, if not 0x1f < stack[-1] // Inputs[4] // { // @0F13 stack[-2] // @0F14 storage[stack[-2]] // @0F17 stack[-3] // @0F19 stack[-1] // } 0F0F 61 PUSH2 0x0100 0F12 80 DUP1 0F13 83 DUP4 0F14 54 SLOAD 0F15 04 DIV 0F16 02 MUL 0F17 83 DUP4 0F18 52 MSTORE 0F19 91 SWAP2 0F1A 60 PUSH1 0x20 0F1C 01 ADD 0F1D 91 SWAP2 0F1E 61 PUSH2 0x0f4d 0F21 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F18 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0F1D stack[-1] = stack[-1] // @0F1D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0f4d label_0F22: // Incoming jump from 0x0F0E, if 0x1f < stack[-1] // Inputs[5] // { // @0F23 stack[-3] // @0F24 stack[-1] // @0F26 stack[-2] // @0F2E memory[0x00:0x20] // @0F32 storage[keccak256(memory[0x00:0x20])] // } 0F22 5B JUMPDEST 0F23 82 DUP3 0F24 01 ADD 0F25 91 SWAP2 0F26 90 SWAP1 0F27 60 PUSH1 0x00 0F29 52 MSTORE 0F2A 60 PUSH1 0x20 0F2C 60 PUSH1 0x00 0F2E 20 SHA3 0F2F 90 SWAP1 0F30 5B JUMPDEST 0F31 81 DUP2 0F32 54 SLOAD 0F33 81 DUP2 0F34 52 MSTORE 0F35 90 SWAP1 0F36 60 PUSH1 0x01 0F38 01 ADD 0F39 90 SWAP1 0F3A 60 PUSH1 0x20 0F3C 01 ADD 0F3D 80 DUP1 0F3E 83 DUP4 0F3F 11 GT 0F40 61 PUSH2 0x0f30 0F43 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F25 stack[-3] = stack[-3] + stack[-1] // @0F29 memory[0x00:0x20] = stack[-2] // @0F34 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0F39 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0F3C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f30, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0F44: // Incoming jump from 0x0F43, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0F43, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0F44 stack[-3] // @0F45 stack[-1] // } 0F44 82 DUP3 0F45 90 SWAP1 0F46 03 SUB 0F47 60 PUSH1 0x1f 0F49 16 AND 0F4A 82 DUP3 0F4B 01 ADD 0F4C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0F4C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0F4C stack[-1] = stack[-3] // } // Block continues label_0F4D: // Incoming jump from 0x0F21 // Incoming jump from 0x0F06, if !stack[-1] // Incoming jump from 0x0F4C // Inputs[1] { @0F53 stack[-7] } 0F4D 5B JUMPDEST 0F4E 50 POP 0F4F 50 POP 0F50 50 POP 0F51 50 POP 0F52 50 POP 0F53 81 DUP2 0F54 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0F55: // Incoming jump from 0x05F5 // Inputs[2] // { // @0F58 storage[0x08] // @0F62 msg.sender // } 0F55 5B JUMPDEST 0F56 60 PUSH1 0x08 0F58 54 SLOAD 0F59 60 PUSH1 0x01 0F5B 60 PUSH1 0x01 0F5D 60 PUSH1 0xa0 0F5F 1B SHL 0F60 03 SUB 0F61 16 AND 0F62 33 CALLER 0F63 14 EQ 0F64 61 PUSH2 0x0f7f 0F67 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f7f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0F68: // Incoming jump from 0x0F67, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0F6A memory[0x40:0x60] } 0F68 60 PUSH1 0x40 0F6A 51 MLOAD 0F6B 62 PUSH3 0x461bcd 0F6F 60 PUSH1 0xe5 0F71 1B SHL 0F72 81 DUP2 0F73 52 MSTORE 0F74 60 PUSH1 0x04 0F76 01 ADD 0F77 61 PUSH2 0x0698 0F7A 90 SWAP1 0F7B 61 PUSH2 0x1c30 0F7E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F7A stack[0] = 0x0698 // @0F7A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1c30, returns to 0x0698 label_0F7F: // Incoming jump from 0x0F67, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0F88 stack[-1] } 0F7F 5B JUMPDEST 0F80 60 PUSH1 0x01 0F82 60 PUSH1 0x01 0F84 60 PUSH1 0xa0 0F86 1B SHL 0F87 03 SUB 0F88 81 DUP2 0F89 16 AND 0F8A 61 PUSH2 0x0fe4 0F8D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fe4, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F8E: // Incoming jump from 0x0F8D, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F90 memory[0x40:0x60] } 0F8E 60 PUSH1 0x40 0F90 51 MLOAD 0F91 62 PUSH3 0x461bcd 0F95 60 PUSH1 0xe5 0F97 1B SHL 0F98 81 DUP2 0F99 52 MSTORE 0F9A 60 PUSH1 0x20 0F9C 60 PUSH1 0x04 0F9E 82 DUP3 0F9F 01 ADD 0FA0 52 MSTORE 0FA1 60 PUSH1 0x26 0FA3 60 PUSH1 0x24 0FA5 82 DUP3 0FA6 01 ADD 0FA7 52 MSTORE 0FA8 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0FC9 60 PUSH1 0x44 0FCB 82 DUP3 0FCC 01 ADD 0FCD 52 MSTORE 0FCE 65 PUSH6 0x646472657373 0FD5 60 PUSH1 0xd0 0FD7 1B SHL 0FD8 60 PUSH1 0x64 0FDA 82 DUP3 0FDB 01 ADD 0FDC 52 MSTORE 0FDD 60 PUSH1 0x84 0FDF 01 ADD 0FE0 61 PUSH2 0x0698 0FE3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0F99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FA0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FA7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0FCD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0FDC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0FDF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_0FE4: // Incoming jump from 0x0F8D, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0FE8 stack[-1] } 0FE4 5B JUMPDEST 0FE5 61 PUSH2 0x0b0e 0FE8 81 DUP2 0FE9 61 PUSH2 0x12d6 0FEC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FE5 stack[0] = 0x0b0e // @0FE8 stack[1] = stack[-1] // } // Block ends with call to 0x12d6, returns to 0x0B0E label_0FED: // Incoming call from 0x0666, returns to 0x0667 // Inputs[3] // { // @0FF0 stack[-2] // @0FF4 stack[-3] // @0FF5 stack[-1] // } 0FED 5B JUMPDEST 0FEE 60 PUSH1 0x00 0FF0 82 DUP3 0FF1 61 PUSH2 0x0ffa 0FF4 85 DUP6 0FF5 84 DUP5 0FF6 61 PUSH2 0x151b 0FF9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0FEE stack[0] = 0x00 // @0FF0 stack[1] = stack[-2] // @0FF1 stack[2] = 0x0ffa // @0FF4 stack[3] = stack[-3] // @0FF5 stack[4] = stack[-1] // } // Block ends with call to 0x151b, returns to 0x0FFA label_0FFA: // Incoming return from call to 0x151B at 0x0FF9 // Inputs[4] // { // @0FFB stack[-2] // @0FFB stack[-1] // @0FFC stack[-7] // @0FFD stack[-6] // } 0FFA 5B JUMPDEST 0FFB 14 EQ 0FFC 94 SWAP5 0FFD 93 SWAP4 0FFE 50 POP 0FFF 50 POP 1000 50 POP 1001 50 POP 1002 56 *JUMP // Stack delta = -6 // Outputs[1] { @0FFC stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1003: // Incoming jump from 0x06E5 // Incoming jump from 0x0EC6 // Inputs[4] // { // @100C stack[-3] // @101B memory[0x00:0x40] // @101D storage[keccak256(memory[0x00:0x40])] // @1021 stack[-1] // } 1003 5B JUMPDEST 1004 60 PUSH1 0x01 1006 60 PUSH1 0x01 1008 60 PUSH1 0xa0 100A 1B SHL 100B 03 SUB 100C 83 DUP4 100D 16 AND 100E 60 PUSH1 0x00 1010 90 SWAP1 1011 81 DUP2 1012 52 MSTORE 1013 60 PUSH1 0x0f 1015 60 PUSH1 0x20 1017 52 MSTORE 1018 60 PUSH1 0x40 101A 90 SWAP1 101B 20 SHA3 101C 80 DUP1 101D 54 SLOAD 101E 61 PUSH2 0xffff 1021 83 DUP4 1022 16 AND 1023 01 ADD 1024 90 SWAP1 1025 81 DUP2 1026 90 SWAP1 1027 55 SSTORE 1028 60 PUSH1 0x02 102A 10 LT 102B 15 ISZERO 102C 61 PUSH2 0x1060 102F 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1012 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1017 memory[0x20:0x40] = 0x0f // @1027 storage[keccak256(memory[0x00:0x40])] = (stack[-1] & 0xffff) + storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1060, if !(0x02 < (stack[-1] & 0xffff) + storage[keccak256(memory[0x00:0x40])]) label_1030: // Incoming jump from 0x102F, if not !(0x02 < (stack[-1] & 0xffff) + storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1032 memory[0x40:0x60] } 1030 60 PUSH1 0x40 1032 51 MLOAD 1033 62 PUSH3 0x461bcd 1037 60 PUSH1 0xe5 1039 1B SHL 103A 81 DUP2 103B 52 MSTORE 103C 60 PUSH1 0x04 103E 01 ADD 103F 61 PUSH2 0x0698 1042 90 SWAP1 1043 60 PUSH1 0x20 1045 80 DUP1 1046 82 DUP3 1047 52 MSTORE 1048 60 PUSH1 0x04 104A 90 SWAP1 104B 82 DUP3 104C 01 ADD 104D 52 MSTORE 104E 63 PUSH4 0x042dac2f 1053 60 PUSH1 0xe3 1055 1B SHL 1056 60 PUSH1 0x40 1058 82 DUP3 1059 01 ADD 105A 52 MSTORE 105B 60 PUSH1 0x60 105D 01 ADD 105E 90 SWAP1 105F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @103B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1047 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @104D memory[0x04 + memory[0x40:0x60] + 0x20:0x04 + memory[0x40:0x60] + 0x20 + 0x20] = 0x04 // @105A memory[0x04 + memory[0x40:0x60] + 0x40:0x04 + memory[0x40:0x60] + 0x40 + 0x20] = 0x042dac2f << 0xe3 // @105E stack[0] = 0x60 + 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_1060: // Incoming jump from 0x102F, if !(0x02 < (stack[-1] & 0xffff) + storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @1064 stack[-3] // @1065 stack[-2] // @1066 stack[-1] // } 1060 5B JUMPDEST 1061 61 PUSH2 0x0b2c 1064 83 DUP4 1065 83 DUP4 1066 83 DUP4 1067 61 PUSH2 0x11da 106A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1061 stack[0] = 0x0b2c // @1064 stack[1] = stack[-3] // @1065 stack[2] = stack[-2] // @1066 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x11da label_106B: // Incoming call from 0x0DDE, returns to 0x0DDF // Incoming call from 0x07DB, returns to 0x07DC // Inputs[2] // { // @106F storage[0x00] // @1070 stack[-1] // } 106B 5B JUMPDEST 106C 60 PUSH1 0x00 106E 80 DUP1 106F 54 SLOAD 1070 82 DUP3 1071 10 LT 1072 80 DUP1 1073 15 ISZERO 1074 61 PUSH2 0x0739 1077 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @106C stack[0] = 0x00 // @1071 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x0739, if !(stack[-1] < storage[0x00]) label_1078: // Incoming jump from 0x1077, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @107C stack[-3] // @1087 memory[0x00:0x40] // @1088 storage[keccak256(memory[0x00:0x40])] // @1090 stack[-4] // } 1078 50 POP 1079 50 POP 107A 60 PUSH1 0x00 107C 90 SWAP1 107D 81 DUP2 107E 52 MSTORE 107F 60 PUSH1 0x04 1081 60 PUSH1 0x20 1083 52 MSTORE 1084 60 PUSH1 0x40 1086 90 SWAP1 1087 20 SHA3 1088 54 SLOAD 1089 60 PUSH1 0x01 108B 60 PUSH1 0xe0 108D 1B SHL 108E 16 AND 108F 15 ISZERO 1090 90 SWAP1 1091 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @107E memory[0x00:0x20] = stack[-3] // @1083 memory[0x20:0x40] = 0x04 // @1090 stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_1092: // Incoming jump from 0x1675 // Incoming jump from 0x07EF // Incoming jump from 0x116E // Incoming jump from 0x0C1F // Incoming jump from 0x1617 // Incoming jump from 0x13E4 // Incoming jump from 0x11D4 // Incoming jump from 0x10E1 // Incoming jump from 0x084C // Incoming jump from 0x0977 // Incoming jump from 0x0890 // Incoming jump from 0x11AC // Inputs[2] // { // @1093 stack[-1] // @109B memory[0x00:0x04] // } 1092 5B JUMPDEST 1093 80 DUP1 1094 60 PUSH1 0x00 1096 52 MSTORE 1097 60 PUSH1 0x04 1099 60 PUSH1 0x00 109B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1096 memory[0x00:0x20] = stack[-1] // @109B revert(memory[0x00:0x04]); // } // Block terminates label_109C: // Incoming call from 0x0817, returns to 0x0818 // Inputs[1] { @10A2 stack[-2] } 109C 5B JUMPDEST 109D 60 PUSH1 0x00 109F 61 PUSH2 0x10a7 10A2 83 DUP4 10A3 61 PUSH2 0x0bf5 10A6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @109D stack[0] = 0x00 // @109F stack[1] = 0x10a7 // @10A2 stack[2] = stack[-2] // } // Block ends with call to 0x0bf5, returns to 0x10A7 label_10A7: // Incoming return from call to 0x0BF5 at 0x10A6 // Inputs[3] // { // @10A8 stack[-1] // @10A8 stack[-2] // @10AA stack[-3] // } 10A7 5B JUMPDEST 10A8 90 SWAP1 10A9 50 POP 10AA 81 DUP2 10AB 80 DUP1 10AC 15 ISZERO 10AD 61 PUSH2 0x10bf 10B0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10A8 stack[-2] = stack[-1] // @10AA stack[-1] = stack[-3] // } // Block ends with conditional jump to 0x10bf, if !stack[-3] label_10B1: // Incoming jump from 0x10B0, if not !stack[-3] // Inputs[2] // { // @10B2 msg.sender // @10BB stack[-2] // } 10B1 50 POP 10B2 33 CALLER 10B3 60 PUSH1 0x01 10B5 60 PUSH1 0x01 10B7 60 PUSH1 0xa0 10B9 1B SHL 10BA 03 SUB 10BB 82 DUP3 10BC 16 AND 10BD 14 EQ 10BE 15 ISZERO 10BF 5B JUMPDEST 10C0 15 ISZERO 10C1 61 PUSH2 0x10e2 10C4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10e2, if !!(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_10C5: // Incoming jump from 0x10C4, if not !!(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Incoming jump from 0x10C4, if not !stack[-1] // Inputs[2] // { // @10C8 stack[-1] // @10C9 msg.sender // } 10C5 61 PUSH2 0x10ce 10C8 81 DUP2 10C9 33 CALLER 10CA 61 PUSH2 0x0592 10CD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10C5 stack[0] = 0x10ce // @10C8 stack[1] = stack[-1] // @10C9 stack[2] = msg.sender // } // Block ends with call to 0x0592, returns to 0x10CE label_10CE: // Incoming return from call to 0x0592 at 0x10CD // Inputs[1] { @10D2 stack[-1] } 10CE 5B JUMPDEST 10CF 61 PUSH2 0x10e2 10D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10e2, if stack[-1] label_10D3: // Incoming jump from 0x10D2, if not stack[-1] 10D3 61 PUSH2 0x10e2 10D6 63 PUSH4 0x67d9dca1 10DB 60 PUSH1 0xe1 10DD 1B SHL 10DE 61 PUSH2 0x1092 10E1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10D3 stack[0] = 0x10e2 // @10DD stack[1] = 0x67d9dca1 << 0xe1 // } // Block ends with unconditional jump to 0x1092 label_10E2: // Incoming jump from 0x10D2, if stack[-1] // Incoming jump from 0x10C4, if !!(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Incoming jump from 0x10C4, if !stack[-1] // Inputs[8] // { // @10E5 stack[-3] // @10F1 memory[0x00:0x40] // @10F3 storage[keccak256(memory[0x00:0x40])] // @1106 stack[-4] // @1110 memory[0x40:0x60] // @1114 stack[-1] // @1139 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @113E stack[-5] // } 10E2 5B JUMPDEST 10E3 60 PUSH1 0x00 10E5 83 DUP4 10E6 81 DUP2 10E7 52 MSTORE 10E8 60 PUSH1 0x06 10EA 60 PUSH1 0x20 10EC 52 MSTORE 10ED 60 PUSH1 0x40 10EF 80 DUP1 10F0 82 DUP3 10F1 20 SHA3 10F2 80 DUP1 10F3 54 SLOAD 10F4 60 PUSH1 0x01 10F6 60 PUSH1 0x01 10F8 60 PUSH1 0xa0 10FA 1B SHL 10FB 03 SUB 10FC 19 NOT 10FD 16 AND 10FE 60 PUSH1 0x01 1100 60 PUSH1 0x01 1102 60 PUSH1 0xa0 1104 1B SHL 1105 03 SUB 1106 88 DUP9 1107 81 DUP2 1108 16 AND 1109 91 SWAP2 110A 82 DUP3 110B 17 OR 110C 90 SWAP1 110D 92 SWAP3 110E 55 SSTORE 110F 91 SWAP2 1110 51 MLOAD 1111 86 DUP7 1112 93 SWAP4 1113 91 SWAP2 1114 85 DUP6 1115 16 AND 1116 91 SWAP2 1117 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1138 91 SWAP2 1139 A4 LOG4 113A 50 POP 113B 50 POP 113C 50 POP 113D 50 POP 113E 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @10E7 memory[0x00:0x20] = stack[-3] // @10EC memory[0x20:0x40] = 0x06 // @110E storage[keccak256(memory[0x00:0x40])] = (stack[-4] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1139 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3]]); // } // Block ends with unconditional jump to stack[-5] label_113F: // Incoming call from 0x0826, returns to 0x0827 // Incoming call from 0x0BFF, returns to 0x0739 // Inputs[3] // { // @1142 stack[-1] // @114D memory[0x00:0x40] // @114E storage[keccak256(memory[0x00:0x40])] // } 113F 5B JUMPDEST 1140 60 PUSH1 0x00 1142 81 DUP2 1143 81 DUP2 1144 52 MSTORE 1145 60 PUSH1 0x04 1147 60 PUSH1 0x20 1149 52 MSTORE 114A 60 PUSH1 0x40 114C 81 DUP2 114D 20 SHA3 114E 54 SLOAD 114F 90 SWAP1 1150 81 DUP2 1151 90 SWAP1 1152 03 SUB 1153 61 PUSH2 0x11b2 1156 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1144 memory[0x00:0x20] = stack[-1] // @1149 memory[0x20:0x40] = 0x04 // @114F stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x11b2, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_1157: // Incoming jump from 0x1156, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1159 storage[0x00] // @115A stack[-2] // } 1157 60 PUSH1 0x00 1159 54 SLOAD 115A 82 DUP3 115B 10 LT 115C 61 PUSH2 0x116f 115F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x116f, if stack[-2] < storage[0x00] label_1160: // Incoming jump from 0x115F, if not stack[-2] < storage[0x00] 1160 61 PUSH2 0x116f 1163 63 PUSH4 0x6f96cda1 1168 60 PUSH1 0xe1 116A 1B SHL 116B 61 PUSH2 0x1092 116E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1160 stack[0] = 0x116f // @116A stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x1092 label_116F: // Incoming jump from 0x115F, if stack[-2] < storage[0x00] // Inputs[3] // { // @1175 stack[-2] // @1183 memory[0x00:0x40] // @1184 storage[keccak256(memory[0x00:0x40])] // } 116F 5B JUMPDEST 1170 5B JUMPDEST 1171 50 POP 1172 60 PUSH1 0x00 1174 19 NOT 1175 01 ADD 1176 60 PUSH1 0x00 1178 81 DUP2 1179 81 DUP2 117A 52 MSTORE 117B 60 PUSH1 0x04 117D 60 PUSH1 0x20 117F 52 MSTORE 1180 60 PUSH1 0x40 1182 90 SWAP1 1183 20 SHA3 1184 54 SLOAD 1185 80 DUP1 1186 15 ISZERO 1187 61 PUSH2 0x1170 118A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1175 stack[-2] = ~0x00 + stack[-2] // @117A memory[0x00:0x20] = ~0x00 + stack[-2] // @117F memory[0x20:0x40] = 0x04 // @1184 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1170, if !storage[keccak256(memory[0x00:0x40])] label_118B: // Incoming jump from 0x118A, if not !storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x118A, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1190 stack[-1] } 118B 60 PUSH1 0x01 118D 60 PUSH1 0xe0 118F 1B SHL 1190 81 DUP2 1191 16 AND 1192 60 PUSH1 0x00 1194 03 SUB 1195 61 PUSH2 0x119d 1198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x119d, if 0x00 - (stack[-1] & (0x01 << 0xe0)) label_1199: // Incoming jump from 0x1198, if not 0x00 - (stack[-1] & (0x01 << 0xe0)) // Inputs[3] // { // @1199 stack[-3] // @1199 stack[-1] // @119A stack[-2] // } 1199 91 SWAP2 119A 90 SWAP1 119B 50 POP 119C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1199 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_119D: // Incoming jump from 0x1198, if 0x00 - (stack[-1] & (0x01 << 0xe0)) 119D 5B JUMPDEST 119E 61 PUSH2 0x11ad 11A1 63 PUSH4 0x6f96cda1 11A6 60 PUSH1 0xe1 11A8 1B SHL 11A9 61 PUSH2 0x1092 11AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @119E stack[0] = 0x11ad // @11A8 stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x1092 11AD 5B JUMPDEST 11AE 61 PUSH2 0x1170 11B1 56 *JUMP label_11B2: // Incoming jump from 0x1156, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @11B8 stack[-1] } 11B2 5B JUMPDEST 11B3 60 PUSH1 0x01 11B5 60 PUSH1 0xe0 11B7 1B SHL 11B8 81 DUP2 11B9 16 AND 11BA 60 PUSH1 0x00 11BC 03 SUB 11BD 61 PUSH2 0x11c5 11C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c5, if 0x00 - (stack[-1] & (0x01 << 0xe0)) label_11C1: // Incoming jump from 0x11C0, if not 0x00 - (stack[-1] & (0x01 << 0xe0)) // Inputs[3] // { // @11C1 stack[-3] // @11C1 stack[-1] // @11C2 stack[-2] // } 11C1 91 SWAP2 11C2 90 SWAP1 11C3 50 POP 11C4 56 *JUMP // Stack delta = -2 // Outputs[1] { @11C1 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_11C5: // Incoming jump from 0x11C0, if 0x00 - (stack[-1] & (0x01 << 0xe0)) 11C5 5B JUMPDEST 11C6 61 PUSH2 0x11d5 11C9 63 PUSH4 0x6f96cda1 11CE 60 PUSH1 0xe1 11D0 1B SHL 11D1 61 PUSH2 0x1092 11D4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11C6 stack[0] = 0x11d5 // @11D0 stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x1092 label_11D5: // Incoming jump from 0x18C6, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1761, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffff // Inputs[3] // { // @11D6 stack[-1] // @11D6 stack[-3] // @11D7 stack[-2] // } 11D5 5B JUMPDEST 11D6 91 SWAP2 11D7 90 SWAP1 11D8 50 POP 11D9 56 *JUMP // Stack delta = -2 // Outputs[1] { @11D6 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_11DA: // Incoming jump from 0x0A30 // Incoming jump from 0x106A // Inputs[1] { @11DD stack[-1] } 11DA 5B JUMPDEST 11DB 60 PUSH1 0x00 11DD 81 DUP2 11DE 61 PUSH2 0xffff 11E1 16 AND 11E2 11 GT 11E3 61 PUSH2 0x1217 11E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1217, if 0xffff & stack[-1] > 0x00 label_11E7: // Incoming jump from 0x11E6, if not 0xffff & stack[-1] > 0x00 // Inputs[1] { @11E9 memory[0x40:0x60] } 11E7 60 PUSH1 0x40 11E9 51 MLOAD 11EA 62 PUSH3 0x461bcd 11EE 60 PUSH1 0xe5 11F0 1B SHL 11F1 81 DUP2 11F2 52 MSTORE 11F3 60 PUSH1 0x20 11F5 60 PUSH1 0x04 11F7 82 DUP3 11F8 01 ADD 11F9 52 MSTORE 11FA 60 PUSH1 0x06 11FC 60 PUSH1 0x24 11FE 82 DUP3 11FF 01 ADD 1200 52 MSTORE 1201 65 PUSH6 0x0858dbdd5b9d 1208 60 PUSH1 0xd2 120A 1B SHL 120B 60 PUSH1 0x44 120D 82 DUP3 120E 01 ADD 120F 52 MSTORE 1210 60 PUSH1 0x64 1212 01 ADD 1213 61 PUSH2 0x0698 1216 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1200 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @120F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x0858dbdd5b9d << 0xd2 // @1212 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_1217: // Incoming jump from 0x11E6, if 0xffff & stack[-1] > 0x00 // Inputs[3] // { // @121A stack[-1] // @1224 storage[0x01] // @1227 storage[0x00] // } 1217 5B JUMPDEST 1218 60 PUSH1 0x00 121A 81 DUP2 121B 61 PUSH2 0xffff 121E 16 AND 121F 61 PUSH2 0x122b 1222 60 PUSH1 0x01 1224 54 SLOAD 1225 60 PUSH1 0x00 1227 54 SLOAD 1228 03 SUB 1229 90 SWAP1 122A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1218 stack[0] = 0x00 // @121E stack[1] = 0xffff & stack[-1] // @1229 stack[2] = storage[0x00] - storage[0x01] // } // Block ends with unconditional jump to 0x122b label_122B: // Incoming jump from 0x122A // Inputs[2] // { // @122F stack[-2] // @1230 stack[-1] // } 122B 5B JUMPDEST 122C 61 PUSH2 0x1235 122F 91 SWAP2 1230 90 SWAP1 1231 61 PUSH2 0x1c7b 1234 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @122F stack[-2] = 0x1235 // @1230 stack[-1] = stack[-2] // @1230 stack[0] = stack[-1] // } // Block ends with call to 0x1c7b, returns to 0x1235 label_1235: // Incoming return from call to 0x1C7B at 0x1234 // Inputs[2] // { // @1236 stack[-1] // @1236 stack[-2] // } 1235 5B JUMPDEST 1236 90 SWAP1 1237 50 POP 1238 61 PUSH2 0x015d 123B 81 DUP2 123C 11 GT 123D 15 ISZERO 123E 61 PUSH2 0x1273 1241 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1236 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1273, if !(stack[-1] > 0x015d) label_1242: // Incoming jump from 0x1241, if not !(stack[-1] > 0x015d) // Inputs[1] { @1244 memory[0x40:0x60] } 1242 60 PUSH1 0x40 1244 51 MLOAD 1245 62 PUSH3 0x461bcd 1249 60 PUSH1 0xe5 124B 1B SHL 124C 81 DUP2 124D 52 MSTORE 124E 60 PUSH1 0x20 1250 60 PUSH1 0x04 1252 82 DUP3 1253 01 ADD 1254 52 MSTORE 1255 60 PUSH1 0x07 1257 60 PUSH1 0x24 1259 82 DUP3 125A 01 ADD 125B 52 MSTORE 125C 66 PUSH7 0x21737570706c79 1264 60 PUSH1 0xc8 1266 1B SHL 1267 60 PUSH1 0x44 1269 82 DUP3 126A 01 ADD 126B 52 MSTORE 126C 60 PUSH1 0x64 126E 01 ADD 126F 61 PUSH2 0x0698 1272 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @124D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1254 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @125B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @126B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x21737570706c79 << 0xc8 // @126E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_1273: // Incoming jump from 0x1241, if !(stack[-1] > 0x015d) // Inputs[3] // { // @1274 stack[-2] // @1279 stack[-3] // @127B msg.value // } 1273 5B JUMPDEST 1274 81 DUP2 1275 61 PUSH2 0xffff 1278 16 AND 1279 83 DUP4 127A 02 MUL 127B 34 CALLVALUE 127C 10 LT 127D 15 ISZERO 127E 61 PUSH2 0x12b2 1281 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12b2, if !(msg.value < stack[-3] * (0xffff & stack[-2])) label_1282: // Incoming jump from 0x1281, if not !(msg.value < stack[-3] * (0xffff & stack[-2])) // Inputs[1] { @1284 memory[0x40:0x60] } 1282 60 PUSH1 0x40 1284 51 MLOAD 1285 62 PUSH3 0x461bcd 1289 60 PUSH1 0xe5 128B 1B SHL 128C 81 DUP2 128D 52 MSTORE 128E 60 PUSH1 0x20 1290 60 PUSH1 0x04 1292 82 DUP3 1293 01 ADD 1294 52 MSTORE 1295 60 PUSH1 0x06 1297 60 PUSH1 0x24 1299 82 DUP3 129A 01 ADD 129B 52 MSTORE 129C 65 PUSH6 0x10b2ba3432b9 12A3 60 PUSH1 0xd1 12A5 1B SHL 12A6 60 PUSH1 0x44 12A8 82 DUP3 12A9 01 ADD 12AA 52 MSTORE 12AB 60 PUSH1 0x64 12AD 01 ADD 12AE 61 PUSH2 0x0698 12B1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @128D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1294 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @129B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @12AA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x10b2ba3432b9 << 0xd1 // @12AD stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0698 label_12B2: // Incoming jump from 0x1281, if !(msg.value < stack[-3] * (0xffff & stack[-2])) // Inputs[2] // { // @12B6 stack[-4] // @12B7 stack[-2] // } 12B2 5B JUMPDEST 12B3 61 PUSH2 0x0dce 12B6 84 DUP5 12B7 83 DUP4 12B8 61 PUSH2 0xffff 12BB 16 AND // Stack delta = +3 // Outputs[3] // { // @12B3 stack[0] = 0x0dce // @12B6 stack[1] = stack[-4] // @12BB stack[2] = 0xffff & stack[-2] // } // Block continues label_12BC: // Incoming jump from 0x0BE2 // Incoming jump from 0x12BB // Inputs[3] // { // @12C0 stack[-2] // @12C1 stack[-1] // @12C4 memory[0x40:0x60] // } 12BC 5B JUMPDEST 12BD 61 PUSH2 0x0818 12C0 82 DUP3 12C1 82 DUP3 12C2 60 PUSH1 0x40 12C4 51 MLOAD 12C5 80 DUP1 12C6 60 PUSH1 0x20 12C8 01 ADD 12C9 60 PUSH1 0x40 12CB 52 MSTORE 12CC 80 DUP1 12CD 60 PUSH1 0x00 12CF 81 DUP2 12D0 52 MSTORE 12D1 50 POP 12D2 61 PUSH2 0x1568 12D5 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @12BD stack[0] = 0x0818 // @12C0 stack[1] = stack[-2] // @12C1 stack[2] = stack[-1] // @12C4 stack[3] = memory[0x40:0x60] // @12CB memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @12D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1568, returns to 0x0818 label_12D6: // Incoming call from 0x0C79, returns to 0x0C7A // Incoming call from 0x0FEC, returns to 0x0B0E // Inputs[5] // { // @12DA storage[0x08] // @12E3 stack[-1] // @12F8 memory[0x40:0x60] // @1324 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1327 stack[-2] // } 12D6 5B JUMPDEST 12D7 60 PUSH1 0x08 12D9 80 DUP1 12DA 54 SLOAD 12DB 60 PUSH1 0x01 12DD 60 PUSH1 0x01 12DF 60 PUSH1 0xa0 12E1 1B SHL 12E2 03 SUB 12E3 83 DUP4 12E4 81 DUP2 12E5 16 AND 12E6 60 PUSH1 0x01 12E8 60 PUSH1 0x01 12EA 60 PUSH1 0xa0 12EC 1B SHL 12ED 03 SUB 12EE 19 NOT 12EF 83 DUP4 12F0 16 AND 12F1 81 DUP2 12F2 17 OR 12F3 90 SWAP1 12F4 93 SWAP4 12F5 55 SSTORE 12F6 60 PUSH1 0x40 12F8 51 MLOAD 12F9 91 SWAP2 12FA 16 AND 12FB 91 SWAP2 12FC 90 SWAP1 12FD 82 DUP3 12FE 90 SWAP1 12FF 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1320 90 SWAP1 1321 60 PUSH1 0x00 1323 90 SWAP1 1324 A3 LOG3 1325 50 POP 1326 50 POP 1327 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @12F5 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1324 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_1328: // Incoming jump from 0x0DB9 // Incoming jump from 0x159B // Inputs[6] // { // @132B memory[0x40:0x60] // @1341 stack[-3] // @134E msg.sender // @1350 stack[-4] // @1352 stack[-2] // @1354 stack[-1] // } 1328 5B JUMPDEST 1329 60 PUSH1 0x40 132B 51 MLOAD 132C 63 PUSH4 0x0a85bd01 1331 60 PUSH1 0xe1 1333 1B SHL 1334 81 DUP2 1335 52 MSTORE 1336 60 PUSH1 0x00 1338 90 SWAP1 1339 60 PUSH1 0x01 133B 60 PUSH1 0x01 133D 60 PUSH1 0xa0 133F 1B SHL 1340 03 SUB 1341 85 DUP6 1342 16 AND 1343 90 SWAP1 1344 63 PUSH4 0x150b7a02 1349 90 SWAP1 134A 61 PUSH2 0x135d 134D 90 SWAP1 134E 33 CALLER 134F 90 SWAP1 1350 89 DUP10 1351 90 SWAP1 1352 88 DUP9 1353 90 SWAP1 1354 88 DUP9 1355 90 SWAP1 1356 60 PUSH1 0x04 1358 01 ADD 1359 61 PUSH2 0x1cf1 135C 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1335 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1338 stack[0] = 0x00 // @1343 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1349 stack[2] = 0x150b7a02 // @134D stack[3] = 0x135d // @134F stack[4] = msg.sender // @1351 stack[5] = stack[-4] // @1353 stack[6] = stack[-2] // @1355 stack[7] = stack[-1] // @1358 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1cf1, returns to 0x135D label_135D: // Incoming return from call to 0x1CF1 at 0x135C // Inputs[6] // { // @1362 memory[0x40:0x60] // @1364 stack[-1] // @1369 stack[-3] // @136A msg.gas // @136B address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @136B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 135D 5B JUMPDEST 135E 60 PUSH1 0x20 1360 60 PUSH1 0x40 1362 51 MLOAD 1363 80 DUP1 1364 83 DUP4 1365 03 SUB 1366 81 DUP2 1367 60 PUSH1 0x00 1369 87 DUP8 136A 5A GAS 136B F1 CALL 136C 92 SWAP3 136D 50 POP 136E 50 POP 136F 50 POP 1370 80 DUP1 1371 15 ISZERO 1372 61 PUSH2 0x1398 1375 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @136B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @136C stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1398, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1376: // Incoming jump from 0x1375, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @137A memory[0x40:0x60] // @137D returndata.length // } 1376 50 POP 1377 60 PUSH1 0x40 1379 80 DUP1 137A 51 MLOAD 137B 60 PUSH1 0x1f 137D 3D RETURNDATASIZE 137E 90 SWAP1 137F 81 DUP2 1380 01 ADD 1381 60 PUSH1 0x1f 1383 19 NOT 1384 16 AND 1385 82 DUP3 1386 01 ADD 1387 90 SWAP1 1388 92 SWAP3 1389 52 MSTORE 138A 61 PUSH2 0x1395 138D 91 SWAP2 138E 81 DUP2 138F 01 ADD 1390 90 SWAP1 1391 61 PUSH2 0x1d2e 1394 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1389 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @138D stack[-1] = 0x1395 // @1390 stack[1] = memory[0x40:0x60] // @1390 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1d2e 1395 5B JUMPDEST 1396 60 PUSH1 0x01 label_1398: // Incoming jump from 0x1375, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @139C stack[-1] } 1398 5B JUMPDEST 1399 61 PUSH2 0x13ed 139C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13ed, if stack[-1] label_139D: // Incoming jump from 0x139C, if not stack[-1] // Inputs[1] { @139D returndata.length } 139D 3D RETURNDATASIZE 139E 80 DUP1 139F 80 DUP1 13A0 15 ISZERO 13A1 61 PUSH2 0x13c6 13A4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @139D stack[0] = returndata.length // @139E stack[1] = returndata.length // } // Block ends with conditional jump to 0x13c6, if !returndata.length label_13A5: // Incoming jump from 0x13A4, if not !returndata.length // Inputs[6] // { // @13A7 memory[0x40:0x60] // @13A8 stack[-2] // @13AF returndata.length // @13B7 returndata.length // @13BA returndata.length // @13C1 returndata[0x00:0x00 + returndata.length] // } 13A5 60 PUSH1 0x40 13A7 51 MLOAD 13A8 91 SWAP2 13A9 50 POP 13AA 60 PUSH1 0x1f 13AC 19 NOT 13AD 60 PUSH1 0x3f 13AF 3D RETURNDATASIZE 13B0 01 ADD 13B1 16 AND 13B2 82 DUP3 13B3 01 ADD 13B4 60 PUSH1 0x40 13B6 52 MSTORE 13B7 3D RETURNDATASIZE 13B8 82 DUP3 13B9 52 MSTORE 13BA 3D RETURNDATASIZE 13BB 60 PUSH1 0x00 13BD 60 PUSH1 0x20 13BF 84 DUP5 13C0 01 ADD 13C1 3E RETURNDATACOPY 13C2 61 PUSH2 0x13cb 13C5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @13A8 stack[-2] = memory[0x40:0x60] // @13B6 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @13B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @13C1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x13cb label_13C6: // Incoming jump from 0x13A4, if !returndata.length // Inputs[2] // { // @13C9 stack[-2] // @13CE memory[0x60:0x80] // } 13C6 5B JUMPDEST 13C7 60 PUSH1 0x60 13C9 91 SWAP2 13CA 50 POP 13CB 5B JUMPDEST 13CC 50 POP 13CD 80 DUP1 13CE 51 MLOAD 13CF 60 PUSH1 0x00 13D1 03 SUB 13D2 61 PUSH2 0x13e5 13D5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @13C9 stack[-2] = 0x60 } // Block ends with conditional jump to 0x13e5, if 0x00 - memory[0x60:0x80] label_13D6: // Incoming jump from 0x13D5, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x13D5, if not 0x00 - memory[0x60:0x80] 13D6 61 PUSH2 0x13e5 13D9 63 PUSH4 0x68d2bf6b 13DE 60 PUSH1 0xe1 13E0 1B SHL 13E1 61 PUSH2 0x1092 13E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13D6 stack[0] = 0x13e5 // @13E0 stack[1] = 0x68d2bf6b << 0xe1 // } // Block ends with unconditional jump to 0x1092 label_13E5: // Incoming jump from 0x13D5, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x13D5, if 0x00 - memory[0x60:0x80] // Inputs[3] // { // @13E6 stack[-1] // @13E7 memory[stack[-1]:stack[-1] + 0x20] // @13EC memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 13E5 5B JUMPDEST 13E6 80 DUP1 13E7 51 MLOAD 13E8 81 DUP2 13E9 60 PUSH1 0x20 13EB 01 ADD 13EC FD *REVERT // Stack delta = +0 // Outputs[1] { @13EC revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_13ED: // Incoming jump from 0x139C, if stack[-1] // Inputs[2] // { // @13F7 stack[-1] // @1401 stack[-2] // } 13ED 5B JUMPDEST 13EE 60 PUSH1 0x01 13F0 60 PUSH1 0x01 13F2 60 PUSH1 0xe0 13F4 1B SHL 13F5 03 SUB 13F6 19 NOT 13F7 16 AND 13F8 63 PUSH4 0x0a85bd01 13FD 60 PUSH1 0xe1 13FF 1B SHL 1400 14 EQ 1401 90 SWAP1 1402 50 POP // Stack delta = -1 // Outputs[1] { @1401 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1403: // Incoming return from call to 0x19AB at 0x1A4B // Incoming jump from 0x1402 // Inputs[3] // { // @1404 stack[-1] // @1404 stack[-6] // @1405 stack[-5] // } 1403 5B JUMPDEST 1404 94 SWAP5 1405 93 SWAP4 1406 50 POP 1407 50 POP 1408 50 POP 1409 50 POP 140A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1404 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_140B: // Incoming jump from 0x0E4A // Inputs[1] { @1411 storage[0x0d] } 140B 5B JUMPDEST 140C 60 PUSH1 0x60 140E 60 PUSH1 0x0d 1410 80 DUP1 1411 54 SLOAD 1412 61 PUSH2 0x074e 1415 90 SWAP1 1416 61 PUSH2 0x1bf6 1419 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @140C stack[0] = 0x60 // @140E stack[1] = 0x0d // @1415 stack[2] = 0x074e // @1415 stack[3] = storage[0x0d] // } // Block ends with call to 0x1bf6, returns to 0x074E 141A 5B JUMPDEST 141B 60 PUSH1 0x60 141D 81 DUP2 141E 60 PUSH1 0x00 1420 03 SUB 1421 61 PUSH2 0x1441 1424 57 *JUMPI 1425 50 POP 1426 50 POP 1427 60 PUSH1 0x40 1429 80 DUP1 142A 51 MLOAD 142B 80 DUP1 142C 82 DUP3 142D 01 ADD 142E 90 SWAP1 142F 91 SWAP2 1430 52 MSTORE 1431 60 PUSH1 0x01 1433 81 DUP2 1434 52 MSTORE 1435 60 PUSH1 0x03 1437 60 PUSH1 0xfc 1439 1B SHL 143A 60 PUSH1 0x20 143C 82 DUP3 143D 01 ADD 143E 52 MSTORE 143F 90 SWAP1 1440 56 *JUMP 1441 5B JUMPDEST 1442 81 DUP2 1443 60 PUSH1 0x00 1445 5B JUMPDEST 1446 81 DUP2 1447 15 ISZERO 1448 61 PUSH2 0x146b 144B 57 *JUMPI 144C 80 DUP1 144D 61 PUSH2 0x1455 1450 81 DUP2 1451 61 PUSH2 0x1ca9 1454 56 *JUMP 1455 5B JUMPDEST 1456 91 SWAP2 1457 50 POP 1458 61 PUSH2 0x1464 145B 90 SWAP1 145C 50 POP 145D 60 PUSH1 0x0a 145F 83 DUP4 1460 61 PUSH2 0x1d61 1463 56 *JUMP 1464 5B JUMPDEST 1465 91 SWAP2 1466 50 POP 1467 61 PUSH2 0x1445 146A 56 *JUMP 146B 5B JUMPDEST 146C 60 PUSH1 0x00 146E 81 DUP2 146F 67 PUSH8 0xffffffffffffffff 1478 81 DUP2 1479 11 GT 147A 15 ISZERO 147B 61 PUSH2 0x1486 147E 57 *JUMPI 147F 61 PUSH2 0x1486 1482 61 PUSH2 0x1964 1485 56 *JUMP 1486 5B JUMPDEST 1487 60 PUSH1 0x40 1489 51 MLOAD 148A 90 SWAP1 148B 80 DUP1 148C 82 DUP3 148D 52 MSTORE 148E 80 DUP1 148F 60 PUSH1 0x1f 1491 01 ADD 1492 60 PUSH1 0x1f 1494 19 NOT 1495 16 AND 1496 60 PUSH1 0x20 1498 01 ADD 1499 82 DUP3 149A 01 ADD 149B 60 PUSH1 0x40 149D 52 MSTORE 149E 80 DUP1 149F 15 ISZERO 14A0 61 PUSH2 0x14b0 14A3 57 *JUMPI 14A4 60 PUSH1 0x20 14A6 82 DUP3 14A7 01 ADD 14A8 81 DUP2 14A9 80 DUP1 14AA 36 CALLDATASIZE 14AB 83 DUP4 14AC 37 CALLDATACOPY 14AD 01 ADD 14AE 90 SWAP1 14AF 50 POP 14B0 5B JUMPDEST 14B1 50 POP 14B2 90 SWAP1 14B3 50 POP 14B4 5B JUMPDEST 14B5 84 DUP5 14B6 15 ISZERO 14B7 61 PUSH2 0x1403 14BA 57 *JUMPI 14BB 61 PUSH2 0x14c5 14BE 60 PUSH1 0x01 14C0 83 DUP4 14C1 61 PUSH2 0x1d75 14C4 56 *JUMP 14C5 5B JUMPDEST 14C6 91 SWAP2 14C7 50 POP 14C8 61 PUSH2 0x14d2 14CB 60 PUSH1 0x0a 14CD 86 DUP7 14CE 61 PUSH2 0x1d8c 14D1 56 *JUMP 14D2 5B JUMPDEST 14D3 61 PUSH2 0x14dd 14D6 90 SWAP1 14D7 60 PUSH1 0x30 14D9 61 PUSH2 0x1c7b 14DC 56 *JUMP 14DD 5B JUMPDEST 14DE 60 PUSH1 0xf8 14E0 1B SHL 14E1 81 DUP2 14E2 83 DUP4 14E3 81 DUP2 14E4 51 MLOAD 14E5 81 DUP2 14E6 10 LT 14E7 61 PUSH2 0x14f2 14EA 57 *JUMPI 14EB 61 PUSH2 0x14f2 14EE 61 PUSH2 0x1c93 14F1 56 *JUMP 14F2 5B JUMPDEST 14F3 60 PUSH1 0x20 14F5 01 ADD 14F6 01 ADD 14F7 90 SWAP1 14F8 60 PUSH1 0x01 14FA 60 PUSH1 0x01 14FC 60 PUSH1 0xf8 14FE 1B SHL 14FF 03 SUB 1500 19 NOT 1501 16 AND 1502 90 SWAP1 1503 81 DUP2 1504 60 PUSH1 0x00 1506 1A BYTE 1507 90 SWAP1 1508 53 MSTORE8 1509 50 POP 150A 61 PUSH2 0x1514 150D 60 PUSH1 0x0a 150F 86 DUP7 1510 61 PUSH2 0x1d61 1513 56 *JUMP 1514 5B JUMPDEST 1515 94 SWAP5 1516 50 POP 1517 61 PUSH2 0x14b4 151A 56 *JUMP label_151B: // Incoming call from 0x0FF9, returns to 0x0FFA // Inputs[3] // { // @151E stack[-1] // @1521 stack[-2] // @1522 memory[stack[-2]:stack[-2] + 0x20] // } 151B 5B JUMPDEST 151C 60 PUSH1 0x00 151E 81 DUP2 151F 81 DUP2 1520 5B JUMPDEST 1521 84 DUP5 1522 51 MLOAD 1523 81 DUP2 1524 10 LT 1525 15 ISZERO 1526 61 PUSH2 0x1560 1529 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @151C stack[0] = 0x00 // @151E stack[1] = stack[-1] // @151F stack[2] = 0x00 // } // Block ends with conditional jump to 0x1560, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_152A: // Incoming jump from 0x1529, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1529, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @152D stack[-2] // @152E stack[-5] // @152F stack[-1] // @1531 memory[stack[-5]:stack[-5] + 0x20] // } 152A 61 PUSH2 0x154c 152D 82 DUP3 152E 86 DUP7 152F 83 DUP4 1530 81 DUP2 1531 51 MLOAD 1532 81 DUP2 1533 10 LT 1534 61 PUSH2 0x153f 1537 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @152A stack[0] = 0x154c // @152D stack[1] = stack[-2] // @152E stack[2] = stack[-5] // @152F stack[3] = stack[-1] // } // Block ends with conditional call to 0x153f, returns to 0x154C, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1538: // Incoming jump from 0x1537, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1538 61 PUSH2 0x153f 153B 61 PUSH2 0x1c93 153E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1538 stack[0] = 0x153f } // Block ends with unconditional jump to 0x1c93 label_153F: // Incoming call from 0x1537, returns to 0x154C, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @1542 stack[-1] // @1546 stack[-2] // @1547 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 153F 5B JUMPDEST 1540 60 PUSH1 0x20 1542 02 MUL 1543 60 PUSH1 0x20 1545 01 ADD 1546 01 ADD 1547 51 MLOAD 1548 61 PUSH2 0x15ca 154B 56 *JUMP // Stack delta = -1 // Outputs[1] { @1547 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x15ca label_154C: // Incoming return from call to 0x153F at 0x1537 // Inputs[3] // { // @154D stack[-1] // @154D stack[-3] // @154F stack[-2] // } 154C 5B JUMPDEST 154D 91 SWAP2 154E 50 POP 154F 80 DUP1 1550 61 PUSH2 0x1558 1553 81 DUP2 1554 61 PUSH2 0x1ca9 1557 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @154D stack[-3] = stack[-1] // @154F stack[-1] = stack[-2] // @1550 stack[0] = 0x1558 // @1553 stack[1] = stack[-2] // } // Block ends with call to 0x1ca9, returns to 0x1558 label_1558: // Incoming return from call to 0x1CA9 at 0x1557 // Inputs[2] // { // @1559 stack[-1] // @1559 stack[-3] // } 1558 5B JUMPDEST 1559 91 SWAP2 155A 50 POP 155B 50 POP 155C 61 PUSH2 0x1520 155F 56 *JUMP // Stack delta = -2 // Outputs[1] { @1559 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1520 label_1560: // Incoming jump from 0x1529, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1529, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1562 stack[-6] // @1562 stack[-2] // @1563 stack[-5] // } 1560 5B JUMPDEST 1561 50 POP 1562 93 SWAP4 1563 92 SWAP3 1564 50 POP 1565 50 POP 1566 50 POP 1567 56 *JUMP // Stack delta = -5 // Outputs[1] { @1562 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1568: // Incoming call from 0x12D5, returns to 0x0818 // Inputs[2] // { // @156C stack[-3] // @156D stack[-2] // } 1568 5B JUMPDEST 1569 61 PUSH2 0x1572 156C 83 DUP4 156D 83 DUP4 156E 61 PUSH2 0x15fc 1571 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1569 stack[0] = 0x1572 // @156C stack[1] = stack[-3] // @156D stack[2] = stack[-2] // } // Block ends with call to 0x15fc, returns to 0x1572 label_1572: // Incoming return from call to 0x15FC at 0x1571 // Inputs[2] // { // @157B stack[-3] // @157D address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1572 5B JUMPDEST 1573 60 PUSH1 0x01 1575 60 PUSH1 0x01 1577 60 PUSH1 0xa0 1579 1B SHL 157A 03 SUB 157B 83 DUP4 157C 16 AND 157D 3B EXTCODESIZE 157E 15 ISZERO 157F 61 PUSH2 0x0b2c 1582 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b2c, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1583: // Incoming jump from 0x1582, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @1585 storage[0x00] // @1586 stack[-2] // @158F stack[-3] // @1597 stack[-1] // } 1583 60 PUSH1 0x00 1585 54 SLOAD 1586 82 DUP3 1587 81 DUP2 1588 03 SUB 1589 5B JUMPDEST 158A 61 PUSH2 0x159c 158D 60 PUSH1 0x00 158F 86 DUP7 1590 83 DUP4 1591 80 DUP1 1592 60 PUSH1 0x01 1594 01 ADD 1595 94 SWAP5 1596 50 POP 1597 86 DUP7 1598 61 PUSH2 0x1328 159B 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1585 stack[0] = storage[0x00] // @158A stack[2] = 0x159c // @158D stack[3] = 0x00 // @158F stack[4] = stack[-3] // @1590 stack[5] = storage[0x00] - stack[-2] // @1595 stack[1] = 0x01 + (storage[0x00] - stack[-2]) // @1597 stack[6] = stack[-1] // } // Block ends with unconditional jump to 0x1328 159C 5B JUMPDEST 159D 61 PUSH2 0x15b0 15A0 57 *JUMPI 15A1 61 PUSH2 0x15b0 15A4 63 PUSH4 0x68d2bf6b 15A9 60 PUSH1 0xe1 15AB 1B SHL 15AC 61 PUSH2 0x1092 15AF 56 *JUMP 15B0 5B JUMPDEST 15B1 81 DUP2 15B2 81 DUP2 15B3 10 LT 15B4 61 PUSH2 0x1589 15B7 57 *JUMPI 15B8 81 DUP2 15B9 60 PUSH1 0x00 15BB 54 SLOAD 15BC 14 EQ 15BD 61 PUSH2 0x06e6 15C0 57 *JUMPI 15C1 61 PUSH2 0x06e6 15C4 60 PUSH1 0x00 15C6 61 PUSH2 0x1092 15C9 56 *JUMP label_15CA: // Incoming jump from 0x154B // Inputs[2] // { // @15CD stack[-1] // @15CE stack[-2] // } 15CA 5B JUMPDEST 15CB 60 PUSH1 0x00 15CD 81 DUP2 15CE 83 DUP4 15CF 10 LT 15D0 61 PUSH2 0x15e6 15D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15CB stack[0] = 0x00 } // Block ends with conditional jump to 0x15e6, if stack[-2] < stack[-1] label_15D4: // Incoming jump from 0x15D3, if not stack[-2] < stack[-1] // Inputs[3] // { // @15D6 stack[-2] // @15DB stack[-3] // @15E1 memory[0x00:0x40] // } 15D4 60 PUSH1 0x00 15D6 82 DUP3 15D7 81 DUP2 15D8 52 MSTORE 15D9 60 PUSH1 0x20 15DB 84 DUP5 15DC 90 SWAP1 15DD 52 MSTORE 15DE 60 PUSH1 0x40 15E0 90 SWAP1 15E1 20 SHA3 15E2 61 PUSH2 0x15f5 15E5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @15D8 memory[0x00:0x20] = stack[-2] // @15DD memory[0x20:0x40] = stack[-3] // @15E1 stack[0] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x15f5 label_15E6: // Incoming jump from 0x15D3, if stack[-2] < stack[-1] // Inputs[3] // { // @15E9 stack[-3] // @15EE stack[-2] // @15F4 memory[0x00:0x40] // } 15E6 5B JUMPDEST 15E7 60 PUSH1 0x00 15E9 83 DUP4 15EA 81 DUP2 15EB 52 MSTORE 15EC 60 PUSH1 0x20 15EE 83 DUP4 15EF 90 SWAP1 15F0 52 MSTORE 15F1 60 PUSH1 0x40 15F3 90 SWAP1 15F4 20 SHA3 // Stack delta = +1 // Outputs[3] // { // @15EB memory[0x00:0x20] = stack[-3] // @15F0 memory[0x20:0x40] = stack[-2] // @15F4 stack[0] = keccak256(memory[0x00:0x40]) // } // Block continues label_15F5: // Incoming return from call to 0x18B4 at 0x1B13 // Incoming return from call to 0x17FD at 0x1D4A // Incoming return from call to 0x17FD at 0x182F // Incoming jump from 0x15E5 // Incoming jump from 0x15F4 // Incoming return from call to 0x185C at 0x189A // Inputs[3] // { // @15F6 stack[-1] // @15F6 stack[-5] // @15F7 stack[-4] // } 15F5 5B JUMPDEST 15F6 93 SWAP4 15F7 92 SWAP3 15F8 50 POP 15F9 50 POP 15FA 50 POP 15FB 56 *JUMP // Stack delta = -4 // Outputs[1] { @15F6 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_15FC: // Incoming call from 0x1571, returns to 0x1572 // Inputs[2] // { // @1600 storage[0x00] // @1602 stack[-1] // } 15FC 5B JUMPDEST 15FD 60 PUSH1 0x00 15FF 80 DUP1 1600 54 SLOAD 1601 90 SWAP1 1602 82 DUP3 1603 90 SWAP1 1604 03 SUB 1605 61 PUSH2 0x1618 1608 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1601 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1618, if 0x00 - stack[-1] label_1609: // Incoming jump from 0x1608, if not 0x00 - stack[-1] 1609 61 PUSH2 0x1618 160C 63 PUSH4 0xb562e8dd 1611 60 PUSH1 0xe0 1613 1B SHL 1614 61 PUSH2 0x1092 1617 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1609 stack[0] = 0x1618 // @1613 stack[1] = 0xb562e8dd << 0xe0 // } // Block ends with unconditional jump to 0x1092 label_1618: // Incoming jump from 0x1608, if 0x00 - stack[-1] // Inputs[7] // { // @161B stack[-1] // @1629 memory[0x00:0x40] // @1632 stack[-3] // @1634 block.timestamp // @163A stack[-2] // @164E memory[0x00:0x40] // @1650 storage[keccak256(memory[0x00:0x40])] // } 1618 5B JUMPDEST 1619 60 PUSH1 0x00 161B 81 DUP2 161C 81 DUP2 161D 52 MSTORE 161E 60 PUSH1 0x04 1620 60 PUSH1 0x20 1622 90 SWAP1 1623 81 DUP2 1624 52 MSTORE 1625 60 PUSH1 0x40 1627 80 DUP1 1628 83 DUP4 1629 20 SHA3 162A 60 PUSH1 0x01 162C 60 PUSH1 0x01 162E 60 PUSH1 0xa0 1630 1B SHL 1631 03 SUB 1632 87 DUP8 1633 16 AND 1634 42 TIMESTAMP 1635 60 PUSH1 0xa0 1637 1B SHL 1638 60 PUSH1 0x01 163A 88 DUP9 163B 14 EQ 163C 60 PUSH1 0xe1 163E 1B SHL 163F 17 OR 1640 81 DUP2 1641 17 OR 1642 90 SWAP1 1643 91 SWAP2 1644 55 SSTORE 1645 80 DUP1 1646 84 DUP5 1647 52 MSTORE 1648 60 PUSH1 0x05 164A 90 SWAP1 164B 92 SWAP3 164C 52 MSTORE 164D 82 DUP3 164E 20 SHA3 164F 80 DUP1 1650 54 SLOAD 1651 68 PUSH9 0x010000000000000001 165B 86 DUP7 165C 02 MUL 165D 01 ADD 165E 90 SWAP1 165F 55 SSTORE 1660 90 SWAP1 1661 81 DUP2 1662 90 SWAP1 1663 03 SUB 1664 61 PUSH2 0x1676 1667 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @161D memory[0x00:0x20] = stack[-1] // @1624 memory[0x20:0x40] = 0x04 // @1644 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | ((stack[-2] == 0x01) << 0xe1) | (block.timestamp << 0xa0) // @1647 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @164C memory[0x20:0x40] = 0x05 // @165F storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1660 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // } // Block ends with conditional jump to 0x1676, if 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) label_1668: // Incoming jump from 0x1667, if not 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) 1668 61 PUSH2 0x1676 166B 62 PUSH3 0x2e0763 166F 60 PUSH1 0xe8 1671 1B SHL 1672 61 PUSH2 0x1092 1675 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1668 stack[0] = 0x1676 // @1671 stack[1] = 0x2e0763 << 0xe8 // } // Block ends with unconditional jump to 0x1092 label_1676: // Incoming jump from 0x1667, if 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @1677 stack[-2] // @1678 stack[-3] // @167D stack[-1] // @16A4 memory[0x00:0x00] // } 1676 5B JUMPDEST 1677 81 DUP2 1678 83 DUP4 1679 01 ADD 167A 82 DUP3 167B 5B JUMPDEST 167C 80 DUP1 167D 83 DUP4 167E 60 PUSH1 0x00 1680 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 16A1 60 PUSH1 0x00 16A3 80 DUP1 16A4 A4 LOG4 16A5 81 DUP2 16A6 81 DUP2 16A7 60 PUSH1 0x01 16A9 01 ADD 16AA 91 SWAP2 16AB 50 POP 16AC 81 DUP2 16AD 03 SUB 16AE 61 PUSH2 0x167b 16B1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1679 stack[0] = stack[-3] + stack[-2] // @16A4 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-1], stack[-2]]); // @16AA stack[1] = 0x01 + stack[-2] // } // Block ends with conditional jump to 0x167b, if (0x01 + stack[-2]) - (stack[-3] + stack[-2]) label_16B2: // Incoming jump from 0x16B1, if not (0x01 + stack[-2]) - (stack[-3] + stack[-2]) // Incoming jump from 0x16B1, if not (0x01 + stack[-1]) - stack[-2] // Inputs[2] // { // @16B5 stack[-2] // @16BA stack[-7] // } 16B2 50 POP 16B3 60 PUSH1 0x00 16B5 55 SSTORE 16B6 50 POP 16B7 50 POP 16B8 50 POP 16B9 50 POP 16BA 56 *JUMP // Stack delta = -7 // Outputs[1] { @16B5 storage[0x00] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_16BB: // Incoming jump from 0x0A6D // Inputs[2] // { // @16BC stack[-3] // @16BE storage[stack[-3]] // } 16BB 5B JUMPDEST 16BC 82 DUP3 16BD 80 DUP1 16BE 54 SLOAD 16BF 61 PUSH2 0x16c7 16C2 90 SWAP1 16C3 61 PUSH2 0x1bf6 16C6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16BC stack[0] = stack[-3] // @16C2 stack[1] = 0x16c7 // @16C2 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1bf6, returns to 0x16C7 label_16C7: // Incoming return from call to 0x1BF6 at 0x16C6 // Inputs[5] // { // @16C8 stack[-1] // @16C8 stack[-2] // @16D0 memory[0x00:0x20] // @16DB stack[-4] // @16DC stack[-3] // } 16C7 5B JUMPDEST 16C8 90 SWAP1 16C9 60 PUSH1 0x00 16CB 52 MSTORE 16CC 60 PUSH1 0x20 16CE 60 PUSH1 0x00 16D0 20 SHA3 16D1 90 SWAP1 16D2 60 PUSH1 0x1f 16D4 01 ADD 16D5 60 PUSH1 0x20 16D7 90 SWAP1 16D8 04 DIV 16D9 81 DUP2 16DA 01 ADD 16DB 92 SWAP3 16DC 82 DUP3 16DD 61 PUSH2 0x16e9 16E0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @16CB memory[0x00:0x20] = stack[-2] // @16D1 stack[-2] = keccak256(memory[0x00:0x20]) // @16DB stack[-1] = stack[-4] // @16DB stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x16e9, if stack[-3] label_16E1: // Incoming jump from 0x16E0, if not stack[-3] // Inputs[1] { @16E3 stack[-5] } 16E1 60 PUSH1 0x00 16E3 85 DUP6 16E4 55 SSTORE 16E5 61 PUSH2 0x172f 16E8 56 *JUMP // Stack delta = +0 // Outputs[1] { @16E4 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x172f label_16E9: // Incoming jump from 0x16E0, if stack[-3] // Inputs[1] { @16EA stack[-3] } 16E9 5B JUMPDEST 16EA 82 DUP3 16EB 60 PUSH1 0x1f 16ED 10 LT 16EE 61 PUSH2 0x1702 16F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1702, if 0x1f < stack[-3] label_16F2: // Incoming jump from 0x16F1, if not 0x1f < stack[-3] // Inputs[4] // { // @16F2 stack[-1] // @16F3 memory[stack[-1]:stack[-1] + 0x20] // @16F8 stack[-3] // @16FC stack[-5] // } 16F2 80 DUP1 16F3 51 MLOAD 16F4 60 PUSH1 0xff 16F6 19 NOT 16F7 16 AND 16F8 83 DUP4 16F9 80 DUP1 16FA 01 ADD 16FB 17 OR 16FC 85 DUP6 16FD 55 SSTORE 16FE 61 PUSH2 0x172f 1701 56 *JUMP // Stack delta = +0 // Outputs[1] { @16FD storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x172f label_1702: // Incoming jump from 0x16F1, if 0x1f < stack[-3] // Inputs[2] // { // @1703 stack[-3] // @1709 stack[-5] // } 1702 5B JUMPDEST 1703 82 DUP3 1704 80 DUP1 1705 01 ADD 1706 60 PUSH1 0x01 1708 01 ADD 1709 85 DUP6 170A 55 SSTORE 170B 82 DUP3 170C 15 ISZERO 170D 61 PUSH2 0x172f 1710 57 *JUMPI // Stack delta = +0 // Outputs[1] { @170A storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x172f, if !stack[-3] label_1711: // Incoming jump from 0x1710, if not !stack[-3] // Inputs[2] // { // @1711 stack[-3] // @1711 stack[-1] // } 1711 91 SWAP2 1712 82 DUP3 1713 01 ADD 1714 5B JUMPDEST 1715 82 DUP3 1716 81 DUP2 1717 11 GT 1718 15 ISZERO 1719 61 PUSH2 0x172f 171C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1711 stack[-3] = stack[-1] // @1713 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x172f, if !(stack[-1] + stack[-3] > stack[-1]) label_171D: // Incoming jump from 0x171C, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x171C, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @171D stack[-3] // @171E memory[stack[-3]:stack[-3] + 0x20] // @171F stack[-2] // @1721 stack[-1] // } 171D 82 DUP3 171E 51 MLOAD 171F 82 DUP3 1720 55 SSTORE 1721 91 SWAP2 1722 60 PUSH1 0x20 1724 01 ADD 1725 91 SWAP2 1726 90 SWAP1 1727 60 PUSH1 0x01 1729 01 ADD 172A 90 SWAP1 172B 61 PUSH2 0x1714 172E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1720 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1725 stack[-3] = 0x20 + stack[-3] // @172A stack[-2] = 0x01 + stack[-2] // @172A stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1714 label_172F: // Incoming jump from 0x171C, if !(stack[-1] > stack[-3]) // Incoming jump from 0x171C, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1710, if !stack[-3] // Incoming jump from 0x16E8 // Incoming jump from 0x1701 // Inputs[2] // { // @1734 stack[-4] // @1735 stack[-3] // } 172F 5B JUMPDEST 1730 50 POP 1731 61 PUSH2 0x173b 1734 92 SWAP3 1735 91 SWAP2 1736 50 POP 1737 61 PUSH2 0x173f 173A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1734 stack[-4] = 0x173b // @1735 stack[-3] = stack[-4] // } // Block ends with call to 0x173f, returns to 0x173B label_173B: // Incoming jump from 0x1748, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1748, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x173F at 0x173A // Inputs[2] // { // @173D stack[-3] // @173D stack[-2] // } 173B 5B JUMPDEST 173C 50 POP 173D 90 SWAP1 173E 56 *JUMP // Stack delta = -2 // Outputs[1] { @173D stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_173F: // Incoming call from 0x173A, returns to 0x173B // Inputs[2] // { // @1741 stack[-1] // @1742 stack[-2] // } 173F 5B JUMPDEST 1740 5B JUMPDEST 1741 80 DUP1 1742 82 DUP3 1743 11 GT 1744 15 ISZERO 1745 61 PUSH2 0x173b 1748 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x173b, if !(stack[-2] > stack[-1]) label_1749: // Incoming jump from 0x1748, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1748, if not !(stack[-2] > stack[-1]) // Inputs[1] { @174B stack[-1] } 1749 60 PUSH1 0x00 174B 81 DUP2 174C 55 SSTORE 174D 60 PUSH1 0x01 174F 01 ADD 1750 61 PUSH2 0x1740 1753 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @174C storage[stack[-1]] = 0x00 // @174F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1740 label_1754: // Incoming call from 0x195A, returns to 0x195B // Incoming call from 0x178D, returns to 0x178E // Inputs[2] // { // @1755 stack[-1] // @1756 msg.data[stack[-1]:stack[-1] + 0x20] // } 1754 5B JUMPDEST 1755 80 DUP1 1756 35 CALLDATALOAD 1757 61 PUSH2 0xffff 175A 81 DUP2 175B 16 AND 175C 81 DUP2 175D 14 EQ 175E 61 PUSH2 0x11d5 1761 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1756 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x11d5, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffff label_1762: // Incoming jump from 0x1761, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffff // Inputs[1] { @1765 memory[0x00:0x00] } 1762 60 PUSH1 0x00 1764 80 DUP1 1765 FD *REVERT // Stack delta = +0 // Outputs[1] { @1765 revert(memory[0x00:0x00]); } // Block terminates label_1766: // Incoming call from 0x020A, returns to 0x020B // Inputs[2] // { // @1771 stack[-1] // @1772 stack[-2] // } 1766 5B JUMPDEST 1767 60 PUSH1 0x00 1769 80 DUP1 176A 60 PUSH1 0x00 176C 80 DUP1 176D 60 PUSH1 0x00 176F 60 PUSH1 0x80 1771 86 DUP7 1772 88 DUP9 1773 03 SUB 1774 12 SLT 1775 15 ISZERO 1776 61 PUSH2 0x177e 1779 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1767 stack[0] = 0x00 // @1769 stack[1] = 0x00 // @176A stack[2] = 0x00 // @176C stack[3] = 0x00 // @176D stack[4] = 0x00 // } // Block ends with conditional jump to 0x177e, if !(stack[-2] - stack[-1] i< 0x80) label_177A: // Incoming jump from 0x1779, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @177D memory[0x00:0x00] } 177A 60 PUSH1 0x00 177C 80 DUP1 177D FD *REVERT // Stack delta = +0 // Outputs[1] { @177D revert(memory[0x00:0x00]); } // Block terminates label_177E: // Incoming jump from 0x1779, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[3] // { // @177F stack[-6] // @1780 msg.data[stack[-6]:stack[-6] + 0x20] // @1781 stack[-5] // } 177E 5B JUMPDEST 177F 85 DUP6 1780 35 CALLDATALOAD 1781 94 SWAP5 1782 50 POP 1783 61 PUSH2 0x178e 1786 60 PUSH1 0x20 1788 87 DUP8 1789 01 ADD 178A 61 PUSH2 0x1754 178D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1781 stack[-5] = msg.data[stack[-6]:stack[-6] + 0x20] // @1783 stack[0] = 0x178e // @1789 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1754, returns to 0x178E label_178E: // Incoming return from call to 0x1754 at 0x178D // Inputs[6] // { // @178F stack[-1] // @178F stack[-5] // @1793 stack[-7] // @1795 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1796 stack[-4] // @179C msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 178E 5B JUMPDEST 178F 93 SWAP4 1790 50 POP 1791 60 PUSH1 0x40 1793 86 DUP7 1794 01 ADD 1795 35 CALLDATALOAD 1796 92 SWAP3 1797 50 POP 1798 60 PUSH1 0x60 179A 86 DUP7 179B 01 ADD 179C 35 CALLDATALOAD 179D 67 PUSH8 0xffffffffffffffff 17A6 80 DUP1 17A7 82 DUP3 17A8 11 GT 17A9 15 ISZERO 17AA 61 PUSH2 0x17b2 17AD 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @178F stack[-5] = stack[-1] // @1796 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @179C stack[-1] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @179D stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x17b2, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_17AE: // Incoming jump from 0x17AD, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @17B1 memory[0x00:0x00] } 17AE 60 PUSH1 0x00 17B0 80 DUP1 17B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @17B1 revert(memory[0x00:0x00]); } // Block terminates label_17B2: // Incoming jump from 0x17AD, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @17B3 stack[-2] // @17B4 stack[-8] // @17B8 stack[-9] // } 17B2 5B JUMPDEST 17B3 81 DUP2 17B4 88 DUP9 17B5 01 ADD 17B6 91 SWAP2 17B7 50 POP 17B8 88 DUP9 17B9 60 PUSH1 0x1f 17BB 83 DUP4 17BC 01 ADD 17BD 12 SLT 17BE 61 PUSH2 0x17c6 17C1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @17B6 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x17c6, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_17C2: // Incoming jump from 0x17C1, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @17C5 memory[0x00:0x00] } 17C2 60 PUSH1 0x00 17C4 80 DUP1 17C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @17C5 revert(memory[0x00:0x00]); } // Block terminates label_17C6: // Incoming jump from 0x17C1, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @17C7 stack[-2] // @17C8 msg.data[stack[-2]:stack[-2] + 0x20] // @17C9 stack[-1] // } 17C6 5B JUMPDEST 17C7 81 DUP2 17C8 35 CALLDATALOAD 17C9 81 DUP2 17CA 81 DUP2 17CB 11 GT 17CC 15 ISZERO 17CD 61 PUSH2 0x17d5 17D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17C8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x17d5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_17D1: // Incoming jump from 0x17D0, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @17D4 memory[0x00:0x00] } 17D1 60 PUSH1 0x00 17D3 80 DUP1 17D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @17D4 revert(memory[0x00:0x00]); } // Block terminates label_17D5: // Incoming jump from 0x17D0, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @17D6 stack[-10] // @17D9 stack[-1] // @17DD stack[-3] // } 17D5 5B JUMPDEST 17D6 89 DUP10 17D7 60 PUSH1 0x20 17D9 82 DUP3 17DA 60 PUSH1 0x05 17DC 1B SHL 17DD 85 DUP6 17DE 01 ADD 17DF 01 ADD 17E0 11 GT 17E1 15 ISZERO 17E2 61 PUSH2 0x17ea 17E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17ea, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) label_17E6: // Incoming jump from 0x17E5, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[1] { @17E9 memory[0x00:0x00] } 17E6 60 PUSH1 0x00 17E8 80 DUP1 17E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @17E9 revert(memory[0x00:0x00]); } // Block terminates label_17EA: // Incoming jump from 0x17E5, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[9] // { // @17EB stack[-8] // @17EB stack[-1] // @17EC stack[-11] // @17ED stack[-7] // @17EE stack[-10] // @17F0 stack[-2] // @17F0 stack[-6] // @17F1 stack[-9] // @17F5 stack[-3] // } 17EA 5B JUMPDEST 17EB 96 SWAP7 17EC 99 SWAP10 17ED 95 SWAP6 17EE 98 SWAP9 17EF 50 POP 17F0 93 SWAP4 17F1 96 SWAP7 17F2 50 POP 17F3 60 PUSH1 0x20 17F5 01 ADD 17F6 94 SWAP5 17F7 93 SWAP4 17F8 92 SWAP3 17F9 50 POP 17FA 50 POP 17FB 50 POP 17FC 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @17EC stack[-11] = stack[-8] // @17EE stack[-10] = stack[-7] // @17F1 stack[-9] = stack[-6] // @17F6 stack[-8] = 0x20 + stack[-3] // @17F7 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_17FD: // Incoming call from 0x182F, returns to 0x15F5 // Incoming call from 0x1D4A, returns to 0x15F5 // Inputs[1] { @1807 stack[-1] } 17FD 5B JUMPDEST 17FE 60 PUSH1 0x01 1800 60 PUSH1 0x01 1802 60 PUSH1 0xe0 1804 1B SHL 1805 03 SUB 1806 19 NOT 1807 81 DUP2 1808 16 AND 1809 81 DUP2 180A 14 EQ 180B 61 PUSH2 0x0b0e 180E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b0e, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_180F: // Incoming jump from 0x180E, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1812 memory[0x00:0x00] } 180F 60 PUSH1 0x00 1811 80 DUP1 1812 FD *REVERT // Stack delta = +0 // Outputs[1] { @1812 revert(memory[0x00:0x00]); } // Block terminates label_1813: // Incoming call from 0x022C, returns to 0x022D // Inputs[2] // { // @1818 stack[-1] // @1819 stack[-2] // } 1813 5B JUMPDEST 1814 60 PUSH1 0x00 1816 60 PUSH1 0x20 1818 82 DUP3 1819 84 DUP5 181A 03 SUB 181B 12 SLT 181C 15 ISZERO 181D 61 PUSH2 0x1825 1820 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1814 stack[0] = 0x00 } // Block ends with conditional jump to 0x1825, if !(stack[-2] - stack[-1] i< 0x20) label_1821: // Incoming jump from 0x1820, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1824 memory[0x00:0x00] } 1821 60 PUSH1 0x00 1823 80 DUP1 1824 FD *REVERT // Stack delta = +0 // Outputs[1] { @1824 revert(memory[0x00:0x00]); } // Block terminates label_1825: // Incoming jump from 0x1820, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1826 stack[-2] // @1827 msg.data[stack[-2]:stack[-2] + 0x20] // } 1825 5B JUMPDEST 1826 81 DUP2 1827 35 CALLDATALOAD 1828 61 PUSH2 0x15f5 182B 81 DUP2 182C 61 PUSH2 0x17fd 182F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1827 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1828 stack[1] = 0x15f5 // @182B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x17fd, returns to 0x15F5 label_1830: // Incoming call from 0x1873, returns to 0x1874 // Inputs[1] { @1834 stack[-3] } 1830 5B JUMPDEST 1831 60 PUSH1 0x00 1833 5B JUMPDEST 1834 83 DUP4 1835 81 DUP2 1836 10 LT 1837 15 ISZERO 1838 61 PUSH2 0x184b 183B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1831 stack[0] = 0x00 } // Block ends with conditional jump to 0x184b, if !(0x00 < stack[-3]) label_183C: // Incoming jump from 0x183B, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x183B, if not !(0x00 < stack[-3]) // Inputs[4] // { // @183C stack[-2] // @183D stack[-1] // @183F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1840 stack[-3] // } 183C 81 DUP2 183D 81 DUP2 183E 01 ADD 183F 51 MLOAD 1840 83 DUP4 1841 82 DUP3 1842 01 ADD 1843 52 MSTORE 1844 60 PUSH1 0x20 1846 01 ADD 1847 61 PUSH2 0x1833 184A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1843 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1846 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1833 label_184B: // Incoming jump from 0x183B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x183B, if !(0x00 < stack[-3]) // Inputs[2] // { // @184C stack[-4] // @184D stack[-1] // } 184B 5B JUMPDEST 184C 83 DUP4 184D 81 DUP2 184E 11 GT 184F 15 ISZERO 1850 61 PUSH2 0x0dce 1853 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dce, if !(stack[-1] > stack[-4]) label_1854: // Incoming jump from 0x1853, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1858 stack[-4] // @1859 stack[-3] // @185B stack[-5] // } 1854 50 POP 1855 50 POP 1856 60 PUSH1 0x00 1858 91 SWAP2 1859 01 ADD 185A 52 MSTORE 185B 56 *JUMP // Stack delta = -5 // Outputs[1] { @185A memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_185C: // Incoming call from 0x189A, returns to 0x15F5 // Incoming call from 0x1D23, returns to 0x1D24 // Inputs[3] // { // @185F stack[-1] // @1860 memory[stack[-1]:stack[-1] + 0x20] // @1862 stack[-2] // } 185C 5B JUMPDEST 185D 60 PUSH1 0x00 185F 81 DUP2 1860 51 MLOAD 1861 80 DUP1 1862 84 DUP5 1863 52 MSTORE 1864 61 PUSH2 0x1874 1867 81 DUP2 1868 60 PUSH1 0x20 186A 86 DUP7 186B 01 ADD 186C 60 PUSH1 0x20 186E 86 DUP7 186F 01 ADD 1870 61 PUSH2 0x1830 1873 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @185D stack[0] = 0x00 // @1860 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1863 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1864 stack[2] = 0x1874 // @1867 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @186B stack[4] = stack[-2] + 0x20 // @186F stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1830, returns to 0x1874 label_1874: // Incoming return from call to 0x1830 at 0x1873 // Inputs[4] // { // @1877 stack[-1] // @187C stack[-4] // @187D stack[-2] // @1883 stack[-5] // } 1874 5B JUMPDEST 1875 60 PUSH1 0x1f 1877 01 ADD 1878 60 PUSH1 0x1f 187A 19 NOT 187B 16 AND 187C 92 SWAP3 187D 90 SWAP1 187E 92 SWAP3 187F 01 ADD 1880 60 PUSH1 0x20 1882 01 ADD 1883 92 SWAP3 1884 91 SWAP2 1885 50 POP 1886 50 POP 1887 56 *JUMP // Stack delta = -4 // Outputs[1] { @1883 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1888: // Incoming jump from 0x0268 // Inputs[2] // { // @188B stack[-1] // @1896 stack[-2] // } 1888 5B JUMPDEST 1889 60 PUSH1 0x20 188B 81 DUP2 188C 52 MSTORE 188D 60 PUSH1 0x00 188F 61 PUSH2 0x15f5 1892 60 PUSH1 0x20 1894 83 DUP4 1895 01 ADD 1896 84 DUP5 1897 61 PUSH2 0x185c 189A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @188C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @188D stack[0] = 0x00 // @188F stack[1] = 0x15f5 // @1895 stack[2] = stack[-1] + 0x20 // @1896 stack[3] = stack[-2] // } // Block ends with call to 0x185c, returns to 0x15F5 label_189B: // Incoming call from 0x051C, returns to 0x051D // Incoming call from 0x0338, returns to 0x0339 // Incoming call from 0x0455, returns to 0x0456 // Incoming call from 0x0283, returns to 0x0284 // Incoming call from 0x03E0, returns to 0x03E1 // Incoming call from 0x0435, returns to 0x0436 // Inputs[2] // { // @18A0 stack[-1] // @18A1 stack[-2] // } 189B 5B JUMPDEST 189C 60 PUSH1 0x00 189E 60 PUSH1 0x20 18A0 82 DUP3 18A1 84 DUP5 18A2 03 SUB 18A3 12 SLT 18A4 15 ISZERO 18A5 61 PUSH2 0x18ad 18A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @189C stack[0] = 0x00 } // Block ends with conditional jump to 0x18ad, if !(stack[-2] - stack[-1] i< 0x20) label_18A9: // Incoming jump from 0x18A8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @18AC memory[0x00:0x00] } 18A9 60 PUSH1 0x00 18AB 80 DUP1 18AC FD *REVERT // Stack delta = +0 // Outputs[1] { @18AC revert(memory[0x00:0x00]); } // Block terminates label_18AD: // Incoming jump from 0x18A8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @18AF msg.data[stack[-2]:stack[-2] + 0x20] // @18AF stack[-2] // @18B0 stack[-4] // @18B1 stack[-3] // } 18AD 5B JUMPDEST 18AE 50 POP 18AF 35 CALLDATALOAD 18B0 91 SWAP2 18B1 90 SWAP1 18B2 50 POP 18B3 56 *JUMP // Stack delta = -3 // Outputs[1] { @18B0 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_18B4: // Incoming call from 0x194C, returns to 0x194D // Incoming call from 0x1B7C, returns to 0x1B7D // Incoming call from 0x1ADD, returns to 0x1ADE // Incoming call from 0x1B6E, returns to 0x1B6F // Incoming call from 0x1BF5, returns to 0x195B // Incoming call from 0x1B13, returns to 0x15F5 // Incoming call from 0x1B2F, returns to 0x1B30 // Incoming call from 0x18E6, returns to 0x18E7 // Incoming call from 0x1920, returns to 0x1921 // Incoming call from 0x1912, returns to 0x1913 // Incoming call from 0x1BE7, returns to 0x1BE8 // Inputs[2] // { // @18B5 stack[-1] // @18B6 msg.data[stack[-1]:stack[-1] + 0x20] // } 18B4 5B JUMPDEST 18B5 80 DUP1 18B6 35 CALLDATALOAD 18B7 60 PUSH1 0x01 18B9 60 PUSH1 0x01 18BB 60 PUSH1 0xa0 18BD 1B SHL 18BE 03 SUB 18BF 81 DUP2 18C0 16 AND 18C1 81 DUP2 18C2 14 EQ 18C3 61 PUSH2 0x11d5 18C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x11d5, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_18C7: // Incoming jump from 0x18C6, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @18CA memory[0x00:0x00] } 18C7 60 PUSH1 0x00 18C9 80 DUP1 18CA FD *REVERT // Stack delta = +0 // Outputs[1] { @18CA revert(memory[0x00:0x00]); } // Block terminates label_18CB: // Incoming call from 0x052F, returns to 0x0530 // Incoming call from 0x02AE, returns to 0x02AF // Inputs[2] // { // @18D1 stack[-1] // @18D2 stack[-2] // } 18CB 5B JUMPDEST 18CC 60 PUSH1 0x00 18CE 80 DUP1 18CF 60 PUSH1 0x40 18D1 83 DUP4 18D2 85 DUP6 18D3 03 SUB 18D4 12 SLT 18D5 15 ISZERO 18D6 61 PUSH2 0x18de 18D9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18CC stack[0] = 0x00 // @18CE stack[1] = 0x00 // } // Block ends with conditional jump to 0x18de, if !(stack[-2] - stack[-1] i< 0x40) label_18DA: // Incoming jump from 0x18D9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @18DD memory[0x00:0x00] } 18DA 60 PUSH1 0x00 18DC 80 DUP1 18DD FD *REVERT // Stack delta = +0 // Outputs[1] { @18DD revert(memory[0x00:0x00]); } // Block terminates label_18DE: // Incoming jump from 0x18D9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @18E2 stack[-3] } 18DE 5B JUMPDEST 18DF 61 PUSH2 0x18e7 18E2 83 DUP4 18E3 61 PUSH2 0x18b4 18E6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @18DF stack[0] = 0x18e7 // @18E2 stack[1] = stack[-3] // } // Block ends with call to 0x18b4, returns to 0x18E7 label_18E7: // Incoming return from call to 0x18B4 at 0x18E6 // Inputs[5] // { // @18E8 stack[-1] // @18E8 stack[-6] // @18EB stack[-4] // @18EF msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @18F0 stack[-5] // } 18E7 5B JUMPDEST 18E8 94 SWAP5 18E9 60 PUSH1 0x20 18EB 93 SWAP4 18EC 90 SWAP1 18ED 93 SWAP4 18EE 01 ADD 18EF 35 CALLDATALOAD 18F0 93 SWAP4 18F1 50 POP 18F2 50 POP 18F3 50 POP 18F4 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @18E8 stack[-6] = stack[-1] // @18F0 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_18F5: // Incoming call from 0x0318, returns to 0x0319 // Incoming call from 0x03A0, returns to 0x03A1 // Inputs[2] // { // @18FD stack[-1] // @18FE stack[-2] // } 18F5 5B JUMPDEST 18F6 60 PUSH1 0x00 18F8 80 DUP1 18F9 60 PUSH1 0x00 18FB 60 PUSH1 0x60 18FD 84 DUP5 18FE 86 DUP7 18FF 03 SUB 1900 12 SLT 1901 15 ISZERO 1902 61 PUSH2 0x190a 1905 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @18F6 stack[0] = 0x00 // @18F8 stack[1] = 0x00 // @18F9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x190a, if !(stack[-2] - stack[-1] i< 0x60) label_1906: // Incoming jump from 0x1905, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1909 memory[0x00:0x00] } 1906 60 PUSH1 0x00 1908 80 DUP1 1909 FD *REVERT // Stack delta = +0 // Outputs[1] { @1909 revert(memory[0x00:0x00]); } // Block terminates label_190A: // Incoming jump from 0x1905, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @190E stack[-4] } 190A 5B JUMPDEST 190B 61 PUSH2 0x1913 190E 84 DUP5 190F 61 PUSH2 0x18b4 1912 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @190B stack[0] = 0x1913 // @190E stack[1] = stack[-4] // } // Block ends with call to 0x18b4, returns to 0x1913 label_1913: // Incoming return from call to 0x18B4 at 0x1912 // Inputs[3] // { // @1914 stack[-4] // @1914 stack[-1] // @191B stack[-5] // } 1913 5B JUMPDEST 1914 92 SWAP3 1915 50 POP 1916 61 PUSH2 0x1921 1919 60 PUSH1 0x20 191B 85 DUP6 191C 01 ADD 191D 61 PUSH2 0x18b4 1920 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1914 stack[-4] = stack[-1] // @1916 stack[-1] = 0x1921 // @191C stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x18b4, returns to 0x1921 label_1921: // Incoming return from call to 0x18B4 at 0x1920 // Inputs[8] // { // @1922 stack[-1] // @1922 stack[-3] // @1926 stack[-5] // @1928 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1929 stack[-2] // @192D stack[-6] // @192F stack[-7] // @192F stack[-4] // } 1921 5B JUMPDEST 1922 91 SWAP2 1923 50 POP 1924 60 PUSH1 0x40 1926 84 DUP5 1927 01 ADD 1928 35 CALLDATALOAD 1929 90 SWAP1 192A 50 POP 192B 92 SWAP3 192C 50 POP 192D 92 SWAP3 192E 50 POP 192F 92 SWAP3 1930 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @192B stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @192D stack[-6] = stack[-1] // @192F stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1931: // Incoming call from 0x0358, returns to 0x0359 // Inputs[2] // { // @1937 stack[-1] // @1938 stack[-2] // } 1931 5B JUMPDEST 1932 60 PUSH1 0x00 1934 80 DUP1 1935 60 PUSH1 0x40 1937 83 DUP4 1938 85 DUP6 1939 03 SUB 193A 12 SLT 193B 15 ISZERO 193C 61 PUSH2 0x1944 193F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1932 stack[0] = 0x00 // @1934 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1944, if !(stack[-2] - stack[-1] i< 0x40) label_1940: // Incoming jump from 0x193F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1943 memory[0x00:0x00] } 1940 60 PUSH1 0x00 1942 80 DUP1 1943 FD *REVERT // Stack delta = +0 // Outputs[1] { @1943 revert(memory[0x00:0x00]); } // Block terminates label_1944: // Incoming jump from 0x193F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1948 stack[-3] } 1944 5B JUMPDEST 1945 61 PUSH2 0x194d 1948 83 DUP4 1949 61 PUSH2 0x18b4 194C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1945 stack[0] = 0x194d // @1948 stack[1] = stack[-3] // } // Block ends with call to 0x18b4, returns to 0x194D label_194D: // Incoming return from call to 0x18B4 at 0x194C // Inputs[3] // { // @194E stack[-1] // @194E stack[-3] // @1955 stack[-4] // } 194D 5B JUMPDEST 194E 91 SWAP2 194F 50 POP 1950 61 PUSH2 0x195b 1953 60 PUSH1 0x20 1955 84 DUP5 1956 01 ADD 1957 61 PUSH2 0x1754 195A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @194E stack[-3] = stack[-1] // @1950 stack[-1] = 0x195b // @1956 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1754, returns to 0x195B label_195B: // Incoming return from call to 0x1754 at 0x195A // Incoming return from call to 0x18B4 at 0x1BF5 // Inputs[6] // { // @195C stack[-1] // @195C stack[-2] // @195E stack[-5] // @1960 stack[-6] // @1960 stack[-3] // @1961 stack[-4] // } 195B 5B JUMPDEST 195C 90 SWAP1 195D 50 POP 195E 92 SWAP3 195F 50 POP 1960 92 SWAP3 1961 90 SWAP1 1962 50 POP 1963 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @195E stack[-5] = stack[-1] // @1960 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1964: // Incoming jump from 0x19A2 // Incoming jump from 0x19C4 // Incoming jump from 0x1A9C // Inputs[1] { @1979 memory[0x00:0x24] } 1964 5B JUMPDEST 1965 63 PUSH4 0x4e487b71 196A 60 PUSH1 0xe0 196C 1B SHL 196D 60 PUSH1 0x00 196F 52 MSTORE 1970 60 PUSH1 0x41 1972 60 PUSH1 0x04 1974 52 MSTORE 1975 60 PUSH1 0x24 1977 60 PUSH1 0x00 1979 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @196F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1974 memory[0x04:0x24] = 0x41 // @1979 revert(memory[0x00:0x24]); // } // Block terminates label_197A: // Incoming call from 0x1AAD, returns to 0x1AAE // Incoming call from 0x19D7, returns to 0x19D8 // Inputs[2] // { // @197D memory[0x40:0x60] // @1980 stack[-1] // } 197A 5B JUMPDEST 197B 60 PUSH1 0x40 197D 51 MLOAD 197E 60 PUSH1 0x1f 1980 82 DUP3 1981 01 ADD 1982 60 PUSH1 0x1f 1984 19 NOT 1985 16 AND 1986 81 DUP2 1987 01 ADD 1988 67 PUSH8 0xffffffffffffffff 1991 81 DUP2 1992 11 GT 1993 82 DUP3 1994 82 DUP3 1995 10 LT 1996 17 OR 1997 15 ISZERO 1998 61 PUSH2 0x19a3 199B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @197D stack[0] = memory[0x40:0x60] // @1987 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x19a3, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_199C: // Incoming jump from 0x199B, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 199C 61 PUSH2 0x19a3 199F 61 PUSH2 0x1964 19A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @199C stack[0] = 0x19a3 } // Block ends with unconditional jump to 0x1964 label_19A3: // Incoming jump from 0x199B, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @19A6 stack[-1] // @19A7 stack[-4] // @19A7 stack[-2] // @19A8 stack[-3] // } 19A3 5B JUMPDEST 19A4 60 PUSH1 0x40 19A6 52 MSTORE 19A7 91 SWAP2 19A8 90 SWAP1 19A9 50 POP 19AA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @19A6 memory[0x40:0x60] = stack[-1] // @19A7 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_19AB: // Incoming call from 0x1A4B, returns to 0x1403 // Incoming call from 0x1BBF, returns to 0x1BC0 // Inputs[1] { @19B7 stack[-2] } 19AB 5B JUMPDEST 19AC 60 PUSH1 0x00 19AE 67 PUSH8 0xffffffffffffffff 19B7 83 DUP4 19B8 11 GT 19B9 15 ISZERO 19BA 61 PUSH2 0x19c5 19BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19AC stack[0] = 0x00 } // Block ends with conditional jump to 0x19c5, if !(stack[-2] > 0xffffffffffffffff) label_19BE: // Incoming jump from 0x19BD, if not !(stack[-2] > 0xffffffffffffffff) 19BE 61 PUSH2 0x19c5 19C1 61 PUSH2 0x1964 19C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @19BE stack[0] = 0x19c5 } // Block ends with unconditional jump to 0x1964 label_19C5: // Incoming jump from 0x19BD, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @19CB stack[-3] } 19C5 5B JUMPDEST 19C6 61 PUSH2 0x19d8 19C9 60 PUSH1 0x1f 19CB 84 DUP5 19CC 01 ADD 19CD 60 PUSH1 0x1f 19CF 19 NOT 19D0 16 AND 19D1 60 PUSH1 0x20 19D3 01 ADD 19D4 61 PUSH2 0x197a 19D7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19C6 stack[0] = 0x19d8 // @19D3 stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x197a, returns to 0x19D8 label_19D8: // Incoming return from call to 0x197A at 0x19D7 // Inputs[5] // { // @19D9 stack[-2] // @19D9 stack[-1] // @19DB stack[-4] // @19DE stack[-5] // @19E0 stack[-3] // } 19D8 5B JUMPDEST 19D9 90 SWAP1 19DA 50 POP 19DB 82 DUP3 19DC 81 DUP2 19DD 52 MSTORE 19DE 83 DUP4 19DF 83 DUP4 19E0 83 DUP4 19E1 01 ADD 19E2 11 GT 19E3 15 ISZERO 19E4 61 PUSH2 0x19ec 19E7 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @19D9 stack[-2] = stack[-1] // @19DD memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x19ec, if !(stack[-3] + stack[-4] > stack[-5]) label_19E8: // Incoming jump from 0x19E7, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @19EB memory[0x00:0x00] } 19E8 60 PUSH1 0x00 19EA 80 DUP1 19EB FD *REVERT // Stack delta = +0 // Outputs[1] { @19EB revert(memory[0x00:0x00]); } // Block terminates label_19EC: // Incoming jump from 0x19E7, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @19ED stack[-3] // @19EE stack[-2] // @19F1 stack[-1] // @19F3 msg.data[stack[-2]:stack[-2] + stack[-3]] // @19FD stack[-5] // @19FE stack[-4] // } 19EC 5B JUMPDEST 19ED 82 DUP3 19EE 82 DUP3 19EF 60 PUSH1 0x20 19F1 83 DUP4 19F2 01 ADD 19F3 37 CALLDATACOPY 19F4 60 PUSH1 0x00 19F6 60 PUSH1 0x20 19F8 84 DUP5 19F9 83 DUP4 19FA 01 ADD 19FB 01 ADD 19FC 52 MSTORE 19FD 93 SWAP4 19FE 92 SWAP3 19FF 50 POP 1A00 50 POP 1A01 50 POP 1A02 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @19F3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @19FC memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @19FD stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_1A03: // Incoming call from 0x0378, returns to 0x0379 // Inputs[2] // { // @1A08 stack[-1] // @1A09 stack[-2] // } 1A03 5B JUMPDEST 1A04 60 PUSH1 0x00 1A06 60 PUSH1 0x20 1A08 82 DUP3 1A09 84 DUP5 1A0A 03 SUB 1A0B 12 SLT 1A0C 15 ISZERO 1A0D 61 PUSH2 0x1a15 1A10 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A04 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a15, if !(stack[-2] - stack[-1] i< 0x20) label_1A11: // Incoming jump from 0x1A10, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A14 memory[0x00:0x00] } 1A11 60 PUSH1 0x00 1A13 80 DUP1 1A14 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A14 revert(memory[0x00:0x00]); } // Block terminates label_1A15: // Incoming jump from 0x1A10, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A16 stack[-2] // @1A17 msg.data[stack[-2]:stack[-2] + 0x20] // } 1A15 5B JUMPDEST 1A16 81 DUP2 1A17 35 CALLDATALOAD 1A18 67 PUSH8 0xffffffffffffffff 1A21 81 DUP2 1A22 11 GT 1A23 15 ISZERO 1A24 61 PUSH2 0x1a2c 1A27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A17 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1a2c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1A28: // Incoming jump from 0x1A27, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1A2B memory[0x00:0x00] } 1A28 60 PUSH1 0x00 1A2A 80 DUP1 1A2B FD *REVERT // Stack delta = +0 // Outputs[1] { @1A2B revert(memory[0x00:0x00]); } // Block terminates label_1A2C: // Incoming jump from 0x1A27, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1A2D stack[-3] // @1A2E stack[-1] // @1A33 stack[-4] // } 1A2C 5B JUMPDEST 1A2D 82 DUP3 1A2E 01 ADD 1A2F 60 PUSH1 0x1f 1A31 81 DUP2 1A32 01 ADD 1A33 84 DUP5 1A34 13 SGT 1A35 61 PUSH2 0x1a3d 1A38 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A2E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1a3d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1A39: // Incoming jump from 0x1A38, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1A3C memory[0x00:0x00] } 1A39 60 PUSH1 0x00 1A3B 80 DUP1 1A3C FD *REVERT // Stack delta = +0 // Outputs[1] { @1A3C revert(memory[0x00:0x00]); } // Block terminates label_1A3D: // Incoming jump from 0x1A38, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1A41 stack[-4] // @1A42 stack[-1] // @1A43 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A3D 5B JUMPDEST 1A3E 61 PUSH2 0x1403 1A41 84 DUP5 1A42 82 DUP3 1A43 35 CALLDATALOAD 1A44 60 PUSH1 0x20 1A46 84 DUP5 1A47 01 ADD 1A48 61 PUSH2 0x19ab 1A4B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A3E stack[0] = 0x1403 // @1A41 stack[1] = stack[-4] // @1A43 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1A47 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x19ab, returns to 0x1403 label_1A4C: // Incoming call from 0x03C0, returns to 0x03C1 // Inputs[2] // { // @1A52 stack[-1] // @1A53 stack[-2] // } 1A4C 5B JUMPDEST 1A4D 60 PUSH1 0x00 1A4F 60 PUSH1 0x20 1A51 80 DUP1 1A52 83 DUP4 1A53 85 DUP6 1A54 03 SUB 1A55 12 SLT 1A56 15 ISZERO 1A57 61 PUSH2 0x1a5f 1A5A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A4D stack[0] = 0x00 // @1A4F stack[1] = 0x20 // } // Block ends with conditional jump to 0x1a5f, if !(stack[-2] - stack[-1] i< 0x20) label_1A5B: // Incoming jump from 0x1A5A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A5E memory[0x00:0x00] } 1A5B 60 PUSH1 0x00 1A5D 80 DUP1 1A5E FD *REVERT // Stack delta = +0 // Outputs[1] { @1A5E revert(memory[0x00:0x00]); } // Block terminates label_1A5F: // Incoming jump from 0x1A5A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A60 stack[-3] // @1A61 msg.data[stack[-3]:stack[-3] + 0x20] // } 1A5F 5B JUMPDEST 1A60 82 DUP3 1A61 35 CALLDATALOAD 1A62 67 PUSH8 0xffffffffffffffff 1A6B 80 DUP1 1A6C 82 DUP3 1A6D 11 GT 1A6E 15 ISZERO 1A6F 61 PUSH2 0x1a77 1A72 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A61 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1A62 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1a77, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1A73: // Incoming jump from 0x1A72, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1A76 memory[0x00:0x00] } 1A73 60 PUSH1 0x00 1A75 80 DUP1 1A76 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A76 revert(memory[0x00:0x00]); } // Block terminates label_1A77: // Incoming jump from 0x1A72, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1A78 stack[-2] // @1A79 stack[-5] // @1A7D stack[-6] // } 1A77 5B JUMPDEST 1A78 81 DUP2 1A79 85 DUP6 1A7A 01 ADD 1A7B 91 SWAP2 1A7C 50 POP 1A7D 85 DUP6 1A7E 60 PUSH1 0x1f 1A80 83 DUP4 1A81 01 ADD 1A82 12 SLT 1A83 61 PUSH2 0x1a8b 1A86 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A7B stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1a8b, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1A87: // Incoming jump from 0x1A86, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1A8A memory[0x00:0x00] } 1A87 60 PUSH1 0x00 1A89 80 DUP1 1A8A FD *REVERT // Stack delta = +0 // Outputs[1] { @1A8A revert(memory[0x00:0x00]); } // Block terminates label_1A8B: // Incoming jump from 0x1A86, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1A8C stack[-2] // @1A8D msg.data[stack[-2]:stack[-2] + 0x20] // @1A8E stack[-1] // } 1A8B 5B JUMPDEST 1A8C 81 DUP2 1A8D 35 CALLDATALOAD 1A8E 81 DUP2 1A8F 81 DUP2 1A90 11 GT 1A91 15 ISZERO 1A92 61 PUSH2 0x1a9d 1A95 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A8D stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1a9d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1A96: // Incoming jump from 0x1A95, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 1A96 61 PUSH2 0x1a9d 1A99 61 PUSH2 0x1964 1A9C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A96 stack[0] = 0x1a9d } // Block ends with unconditional jump to 0x1964 label_1A9D: // Incoming jump from 0x1A95, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1A9E stack[-1] // @1AA2 stack[-2] // @1AA7 stack[-4] // } 1A9D 5B JUMPDEST 1A9E 80 DUP1 1A9F 60 PUSH1 0x05 1AA1 1B SHL 1AA2 91 SWAP2 1AA3 50 POP 1AA4 61 PUSH2 0x1aae 1AA7 84 DUP5 1AA8 83 DUP4 1AA9 01 ADD 1AAA 61 PUSH2 0x197a 1AAD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AA2 stack[-2] = stack[-1] << 0x05 // @1AA4 stack[0] = 0x1aae // @1AA9 stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x197a, returns to 0x1AAE label_1AAE: // Incoming return from call to 0x197A at 0x1AAD // Inputs[6] // { // @1AAF stack[-2] // @1AB0 stack[-1] // @1AB2 stack[-3] // @1AB3 stack[-4] // @1AB5 stack[-5] // @1ABC stack[-8] // } 1AAE 5B JUMPDEST 1AAF 81 DUP2 1AB0 81 DUP2 1AB1 52 MSTORE 1AB2 91 SWAP2 1AB3 83 DUP4 1AB4 01 ADD 1AB5 84 DUP5 1AB6 01 ADD 1AB7 91 SWAP2 1AB8 84 DUP5 1AB9 81 DUP2 1ABA 01 ADD 1ABB 90 SWAP1 1ABC 88 DUP9 1ABD 84 DUP5 1ABE 11 GT 1ABF 15 ISZERO 1AC0 61 PUSH2 0x1ac8 1AC3 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1AB1 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1AB7 stack[-3] = stack[-5] + stack[-4] + stack[-3] // @1ABB stack[-1] = stack[-1] + stack[-5] // @1ABB stack[0] = stack[-1] // } // Block ends with conditional jump to 0x1ac8, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_1AC4: // Incoming jump from 0x1AC3, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @1AC7 memory[0x00:0x00] } 1AC4 60 PUSH1 0x00 1AC6 80 DUP1 1AC7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC7 revert(memory[0x00:0x00]); } // Block terminates label_1AC8: // Incoming jump from 0x1AC3, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @1AC9 stack[-1] // @1AC9 stack[-5] // @1ACA stack[-6] // @1ACE stack[-4] // } 1AC8 5B JUMPDEST 1AC9 93 SWAP4 1ACA 85 DUP6 1ACB 01 ADD 1ACC 93 SWAP4 1ACD 5B JUMPDEST 1ACE 83 DUP4 1ACF 85 DUP6 1AD0 10 LT 1AD1 15 ISZERO 1AD2 61 PUSH2 0x1aed 1AD5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1ACC stack[-5] = stack[-6] + stack[-5] // @1ACC stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x1aed, if !(stack[-6] + stack[-5] < stack[-4]) label_1AD6: // Incoming jump from 0x1AD5, if not !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x1AD5, if not !(stack[-5] < stack[-4]) // Inputs[1] { @1AD9 stack[-5] } 1AD6 61 PUSH2 0x1ade 1AD9 85 DUP6 1ADA 61 PUSH2 0x18b4 1ADD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AD6 stack[0] = 0x1ade // @1AD9 stack[1] = stack[-5] // } // Block ends with call to 0x18b4, returns to 0x1ADE label_1ADE: // Incoming return from call to 0x18B4 at 0x1ADD // Inputs[5] // { // @1ADF stack[-3] // @1AE0 stack[-1] // @1AE1 stack[-2] // @1AE1 stack[-6] // @1AE2 stack[-7] // } 1ADE 5B JUMPDEST 1ADF 82 DUP3 1AE0 52 MSTORE 1AE1 93 SWAP4 1AE2 85 DUP6 1AE3 01 ADD 1AE4 93 SWAP4 1AE5 90 SWAP1 1AE6 85 DUP6 1AE7 01 ADD 1AE8 90 SWAP1 1AE9 61 PUSH2 0x1acd 1AEC 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1AE0 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1AE4 stack[-6] = stack[-7] + stack[-6] // @1AE8 stack[-2] = stack[-2] // @1AE8 stack[-3] = stack[-7] + stack[-3] // } // Block ends with unconditional jump to 0x1acd label_1AED: // Incoming jump from 0x1AD5, if !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x1AD5, if !(stack[-5] < stack[-4]) // Inputs[3] // { // @1AEE stack[-10] // @1AEE stack[-1] // @1AEF stack[-9] // } 1AED 5B JUMPDEST 1AEE 98 SWAP9 1AEF 97 SWAP8 1AF0 50 POP 1AF1 50 POP 1AF2 50 POP 1AF3 50 POP 1AF4 50 POP 1AF5 50 POP 1AF6 50 POP 1AF7 50 POP 1AF8 56 *JUMP // Stack delta = -9 // Outputs[1] { @1AEE stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_1AF9: // Incoming call from 0x0400, returns to 0x0401 // Incoming call from 0x05F0, returns to 0x05F1 // Incoming call from 0x0564, returns to 0x0565 // Inputs[2] // { // @1AFE stack[-1] // @1AFF stack[-2] // } 1AF9 5B JUMPDEST 1AFA 60 PUSH1 0x00 1AFC 60 PUSH1 0x20 1AFE 82 DUP3 1AFF 84 DUP5 1B00 03 SUB 1B01 12 SLT 1B02 15 ISZERO 1B03 61 PUSH2 0x1b0b 1B06 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AFA stack[0] = 0x00 } // Block ends with conditional jump to 0x1b0b, if !(stack[-2] - stack[-1] i< 0x20) label_1B07: // Incoming jump from 0x1B06, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B0A memory[0x00:0x00] } 1B07 60 PUSH1 0x00 1B09 80 DUP1 1B0A FD *REVERT // Stack delta = +0 // Outputs[1] { @1B0A revert(memory[0x00:0x00]); } // Block terminates label_1B0B: // Incoming jump from 0x1B06, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B0F stack[-2] } 1B0B 5B JUMPDEST 1B0C 61 PUSH2 0x15f5 1B0F 82 DUP3 1B10 61 PUSH2 0x18b4 1B13 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B0C stack[0] = 0x15f5 // @1B0F stack[1] = stack[-2] // } // Block ends with call to 0x18b4, returns to 0x15F5 label_1B14: // Incoming call from 0x04BD, returns to 0x04BE // Inputs[2] // { // @1B1A stack[-1] // @1B1B stack[-2] // } 1B14 5B JUMPDEST 1B15 60 PUSH1 0x00 1B17 80 DUP1 1B18 60 PUSH1 0x40 1B1A 83 DUP4 1B1B 85 DUP6 1B1C 03 SUB 1B1D 12 SLT 1B1E 15 ISZERO 1B1F 61 PUSH2 0x1b27 1B22 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B15 stack[0] = 0x00 // @1B17 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b27, if !(stack[-2] - stack[-1] i< 0x40) label_1B23: // Incoming jump from 0x1B22, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B26 memory[0x00:0x00] } 1B23 60 PUSH1 0x00 1B25 80 DUP1 1B26 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B26 revert(memory[0x00:0x00]); } // Block terminates label_1B27: // Incoming jump from 0x1B22, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B2B stack[-3] } 1B27 5B JUMPDEST 1B28 61 PUSH2 0x1b30 1B2B 83 DUP4 1B2C 61 PUSH2 0x18b4 1B2F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B28 stack[0] = 0x1b30 // @1B2B stack[1] = stack[-3] // } // Block ends with call to 0x18b4, returns to 0x1B30 label_1B30: // Incoming return from call to 0x18B4 at 0x1B2F // Inputs[4] // { // @1B31 stack[-1] // @1B31 stack[-3] // @1B35 stack[-4] // @1B37 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1B30 5B JUMPDEST 1B31 91 SWAP2 1B32 50 POP 1B33 60 PUSH1 0x20 1B35 83 DUP4 1B36 01 ADD 1B37 35 CALLDATALOAD 1B38 80 DUP1 1B39 15 ISZERO 1B3A 15 ISZERO 1B3B 81 DUP2 1B3C 14 EQ 1B3D 61 PUSH2 0x1b45 1B40 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B31 stack[-3] = stack[-1] // @1B37 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1b45, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1B41: // Incoming jump from 0x1B40, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @1B44 memory[0x00:0x00] } 1B41 60 PUSH1 0x00 1B43 80 DUP1 1B44 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B44 revert(memory[0x00:0x00]); } // Block terminates label_1B45: // Incoming jump from 0x1B40, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1B46 stack[-1] // @1B47 stack[-2] // @1B4A stack[-5] // @1B4C stack[-6] // @1B4C stack[-3] // @1B4D stack[-4] // } 1B45 5B JUMPDEST 1B46 80 DUP1 1B47 91 SWAP2 1B48 50 POP 1B49 50 POP 1B4A 92 SWAP3 1B4B 50 POP 1B4C 92 SWAP3 1B4D 90 SWAP1 1B4E 50 POP 1B4F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1B4A stack[-5] = stack[-1] // @1B4C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1B50: // Incoming call from 0x04D0, returns to 0x04D1 // Inputs[2] // { // @1B59 stack[-1] // @1B5A stack[-2] // } 1B50 5B JUMPDEST 1B51 60 PUSH1 0x00 1B53 80 DUP1 1B54 60 PUSH1 0x00 1B56 80 DUP1 1B57 60 PUSH1 0x80 1B59 85 DUP6 1B5A 87 DUP8 1B5B 03 SUB 1B5C 12 SLT 1B5D 15 ISZERO 1B5E 61 PUSH2 0x1b66 1B61 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1B51 stack[0] = 0x00 // @1B53 stack[1] = 0x00 // @1B54 stack[2] = 0x00 // @1B56 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1b66, if !(stack[-2] - stack[-1] i< 0x80) label_1B62: // Incoming jump from 0x1B61, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1B65 memory[0x00:0x00] } 1B62 60 PUSH1 0x00 1B64 80 DUP1 1B65 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B65 revert(memory[0x00:0x00]); } // Block terminates label_1B66: // Incoming jump from 0x1B61, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1B6A stack[-5] } 1B66 5B JUMPDEST 1B67 61 PUSH2 0x1b6f 1B6A 85 DUP6 1B6B 61 PUSH2 0x18b4 1B6E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B67 stack[0] = 0x1b6f // @1B6A stack[1] = stack[-5] // } // Block ends with call to 0x18b4, returns to 0x1B6F label_1B6F: // Incoming return from call to 0x18B4 at 0x1B6E // Inputs[3] // { // @1B70 stack[-1] // @1B70 stack[-5] // @1B77 stack[-6] // } 1B6F 5B JUMPDEST 1B70 93 SWAP4 1B71 50 POP 1B72 61 PUSH2 0x1b7d 1B75 60 PUSH1 0x20 1B77 86 DUP7 1B78 01 ADD 1B79 61 PUSH2 0x18b4 1B7C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1B70 stack[-5] = stack[-1] // @1B72 stack[-1] = 0x1b7d // @1B78 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x18b4, returns to 0x1B7D label_1B7D: // Incoming return from call to 0x18B4 at 0x1B7C // Inputs[6] // { // @1B7E stack[-1] // @1B7E stack[-4] // @1B82 stack[-6] // @1B84 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1B85 stack[-3] // @1B8B msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1B7D 5B JUMPDEST 1B7E 92 SWAP3 1B7F 50 POP 1B80 60 PUSH1 0x40 1B82 85 DUP6 1B83 01 ADD 1B84 35 CALLDATALOAD 1B85 91 SWAP2 1B86 50 POP 1B87 60 PUSH1 0x60 1B89 85 DUP6 1B8A 01 ADD 1B8B 35 CALLDATALOAD 1B8C 67 PUSH8 0xffffffffffffffff 1B95 81 DUP2 1B96 11 GT 1B97 15 ISZERO 1B98 61 PUSH2 0x1ba0 1B9B 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1B7E stack[-4] = stack[-1] // @1B85 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1B8B stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1ba0, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1B9C: // Incoming jump from 0x1B9B, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1B9F memory[0x00:0x00] } 1B9C 60 PUSH1 0x00 1B9E 80 DUP1 1B9F FD *REVERT // Stack delta = +0 // Outputs[1] { @1B9F revert(memory[0x00:0x00]); } // Block terminates label_1BA0: // Incoming jump from 0x1B9B, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1BA1 stack[-6] // @1BA2 stack[-1] // @1BA7 stack[-7] // } 1BA0 5B JUMPDEST 1BA1 85 DUP6 1BA2 01 ADD 1BA3 60 PUSH1 0x1f 1BA5 81 DUP2 1BA6 01 ADD 1BA7 87 DUP8 1BA8 13 SGT 1BA9 61 PUSH2 0x1bb1 1BAC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BA2 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1bb1, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1BAD: // Incoming jump from 0x1BAC, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1BB0 memory[0x00:0x00] } 1BAD 60 PUSH1 0x00 1BAF 80 DUP1 1BB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BB0 revert(memory[0x00:0x00]); } // Block terminates label_1BB1: // Incoming jump from 0x1BAC, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1BB5 stack[-7] // @1BB6 stack[-1] // @1BB7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1BB1 5B JUMPDEST 1BB2 61 PUSH2 0x1bc0 1BB5 87 DUP8 1BB6 82 DUP3 1BB7 35 CALLDATALOAD 1BB8 60 PUSH1 0x20 1BBA 84 DUP5 1BBB 01 ADD 1BBC 61 PUSH2 0x19ab 1BBF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BB2 stack[0] = 0x1bc0 // @1BB5 stack[1] = stack[-7] // @1BB7 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1BBB stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x19ab, returns to 0x1BC0 label_1BC0: // Incoming return from call to 0x19AB at 0x1BBF // Inputs[8] // { // @1BC1 stack[-1] // @1BC1 stack[-3] // @1BC4 stack[-6] // @1BC5 stack[-9] // @1BC6 stack[-5] // @1BC7 stack[-8] // @1BC9 stack[-7] // @1BC9 stack[-4] // } 1BC0 5B JUMPDEST 1BC1 91 SWAP2 1BC2 50 POP 1BC3 50 POP 1BC4 92 SWAP3 1BC5 95 SWAP6 1BC6 91 SWAP2 1BC7 94 SWAP5 1BC8 50 POP 1BC9 92 SWAP3 1BCA 50 POP 1BCB 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1BC4 stack[-6] = stack[-1] // @1BC5 stack[-9] = stack[-6] // @1BC7 stack[-8] = stack[-5] // @1BC9 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1BCC: // Incoming call from 0x0591, returns to 0x0592 // Inputs[2] // { // @1BD2 stack[-1] // @1BD3 stack[-2] // } 1BCC 5B JUMPDEST 1BCD 60 PUSH1 0x00 1BCF 80 DUP1 1BD0 60 PUSH1 0x40 1BD2 83 DUP4 1BD3 85 DUP6 1BD4 03 SUB 1BD5 12 SLT 1BD6 15 ISZERO 1BD7 61 PUSH2 0x1bdf 1BDA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BCD stack[0] = 0x00 // @1BCF stack[1] = 0x00 // } // Block ends with conditional jump to 0x1bdf, if !(stack[-2] - stack[-1] i< 0x40) label_1BDB: // Incoming jump from 0x1BDA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BDE memory[0x00:0x00] } 1BDB 60 PUSH1 0x00 1BDD 80 DUP1 1BDE FD *REVERT // Stack delta = +0 // Outputs[1] { @1BDE revert(memory[0x00:0x00]); } // Block terminates label_1BDF: // Incoming jump from 0x1BDA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BE3 stack[-3] } 1BDF 5B JUMPDEST 1BE0 61 PUSH2 0x1be8 1BE3 83 DUP4 1BE4 61 PUSH2 0x18b4 1BE7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BE0 stack[0] = 0x1be8 // @1BE3 stack[1] = stack[-3] // } // Block ends with call to 0x18b4, returns to 0x1BE8 label_1BE8: // Incoming return from call to 0x18B4 at 0x1BE7 // Inputs[3] // { // @1BE9 stack[-3] // @1BE9 stack[-1] // @1BF0 stack[-4] // } 1BE8 5B JUMPDEST 1BE9 91 SWAP2 1BEA 50 POP 1BEB 61 PUSH2 0x195b 1BEE 60 PUSH1 0x20 1BF0 84 DUP5 1BF1 01 ADD 1BF2 61 PUSH2 0x18b4 1BF5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BE9 stack[-3] = stack[-1] // @1BEB stack[-1] = 0x195b // @1BF1 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x18b4, returns to 0x195B label_1BF6: // Incoming call from 0x0ED3, returns to 0x0ED4 // Incoming call from 0x074D, returns to 0x074E // Incoming call from 0x0D26, returns to 0x074E // Incoming call from 0x0EFF, returns to 0x0F00 // Incoming call from 0x16C6, returns to 0x16C7 // Incoming call from 0x0779, returns to 0x077A // Incoming call from 0x1419, returns to 0x074E // Inputs[1] { @1BF9 stack[-1] } 1BF6 5B JUMPDEST 1BF7 60 PUSH1 0x01 1BF9 81 DUP2 1BFA 81 DUP2 1BFB 1C SHR 1BFC 90 SWAP1 1BFD 82 DUP3 1BFE 16 AND 1BFF 80 DUP1 1C00 61 PUSH2 0x1c0a 1C03 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BFC stack[0] = stack[-1] >> 0x01 // @1BFE stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1c0a, if stack[-1] & 0x01 label_1C04: // Incoming jump from 0x1C03, if not stack[-1] & 0x01 // Inputs[2] // { // @1C06 stack[-2] // @1C0F stack[-1] // } 1C04 60 PUSH1 0x7f 1C06 82 DUP3 1C07 16 AND 1C08 91 SWAP2 1C09 50 POP 1C0A 5B JUMPDEST 1C0B 60 PUSH1 0x20 1C0D 82 DUP3 1C0E 10 LT 1C0F 81 DUP2 1C10 03 SUB 1C11 61 PUSH2 0x1c2a 1C14 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C08 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1c2a, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1C15: // Incoming jump from 0x1C14, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1C14, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @1C29 memory[0x00:0x24] } 1C15 63 PUSH4 0x4e487b71 1C1A 60 PUSH1 0xe0 1C1C 1B SHL 1C1D 60 PUSH1 0x00 1C1F 52 MSTORE 1C20 60 PUSH1 0x22 1C22 60 PUSH1 0x04 1C24 52 MSTORE 1C25 60 PUSH1 0x24 1C27 60 PUSH1 0x00 1C29 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C1F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C24 memory[0x04:0x24] = 0x22 // @1C29 revert(memory[0x00:0x24]); // } // Block terminates label_1C2A: // Incoming jump from 0x1C14, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1C14, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @1C2C stack[-4] // @1C2C stack[-2] // @1C2D stack[-3] // } 1C2A 5B JUMPDEST 1C2B 50 POP 1C2C 91 SWAP2 1C2D 90 SWAP1 1C2E 50 POP 1C2F 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C2C stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1C30: // Incoming call from 0x09AA, returns to 0x0698 // Incoming call from 0x0D03, returns to 0x0698 // Incoming call from 0x0CA5, returns to 0x0698 // Incoming call from 0x0C6F, returns to 0x0698 // Incoming call from 0x0F7E, returns to 0x0698 // Incoming call from 0x09D9, returns to 0x0698 // Incoming call from 0x0A5A, returns to 0x0698 // Incoming call from 0x0B5A, returns to 0x0698 // Incoming call from 0x0CD4, returns to 0x0698 // Inputs[2] // { // @1C34 stack[-1] // @1C63 stack[-2] // } 1C30 5B JUMPDEST 1C31 60 PUSH1 0x20 1C33 80 DUP1 1C34 82 DUP3 1C35 52 MSTORE 1C36 81 DUP2 1C37 81 DUP2 1C38 01 ADD 1C39 52 MSTORE 1C3A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1C5B 60 PUSH1 0x40 1C5D 82 DUP3 1C5E 01 ADD 1C5F 52 MSTORE 1C60 60 PUSH1 0x60 1C62 01 ADD 1C63 90 SWAP1 1C64 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1C35 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1C39 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @1C5F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1C63 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1C65: // Incoming jump from 0x1C8D // Incoming jump from 0x1CBA // Inputs[1] { @1C7A memory[0x00:0x24] } 1C65 5B JUMPDEST 1C66 63 PUSH4 0x4e487b71 1C6B 60 PUSH1 0xe0 1C6D 1B SHL 1C6E 60 PUSH1 0x00 1C70 52 MSTORE 1C71 60 PUSH1 0x11 1C73 60 PUSH1 0x04 1C75 52 MSTORE 1C76 60 PUSH1 0x24 1C78 60 PUSH1 0x00 1C7A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C70 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C75 memory[0x04:0x24] = 0x11 // @1C7A revert(memory[0x00:0x24]); // } // Block terminates label_1C7B: // Incoming call from 0x1234, returns to 0x1235 // Incoming call from 0x0B6D, returns to 0x0B6E // Inputs[2] // { // @1C7E stack[-2] // @1C80 stack[-1] // } 1C7B 5B JUMPDEST 1C7C 60 PUSH1 0x00 1C7E 82 DUP3 1C7F 19 NOT 1C80 82 DUP3 1C81 11 GT 1C82 15 ISZERO 1C83 61 PUSH2 0x1c8e 1C86 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C7C stack[0] = 0x00 } // Block ends with conditional jump to 0x1c8e, if !(stack[-1] > ~stack[-2]) label_1C87: // Incoming jump from 0x1C86, if not !(stack[-1] > ~stack[-2]) 1C87 61 PUSH2 0x1c8e 1C8A 61 PUSH2 0x1c65 1C8D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C87 stack[0] = 0x1c8e } // Block ends with unconditional jump to 0x1c65 label_1C8E: // Incoming jump from 0x1C86, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1C90 stack[-3] // @1C90 stack[-2] // @1C91 stack[-4] // } 1C8E 5B JUMPDEST 1C8F 50 POP 1C90 01 ADD 1C91 90 SWAP1 1C92 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C91 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1C93: // Incoming jump from 0x0BD3 // Incoming jump from 0x153E // Inputs[1] { @1CA8 memory[0x00:0x24] } 1C93 5B JUMPDEST 1C94 63 PUSH4 0x4e487b71 1C99 60 PUSH1 0xe0 1C9B 1B SHL 1C9C 60 PUSH1 0x00 1C9E 52 MSTORE 1C9F 60 PUSH1 0x32 1CA1 60 PUSH1 0x04 1CA3 52 MSTORE 1CA4 60 PUSH1 0x24 1CA6 60 PUSH1 0x00 1CA8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C9E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1CA3 memory[0x04:0x24] = 0x32 // @1CA8 revert(memory[0x00:0x24]); // } // Block terminates label_1CA9: // Incoming call from 0x1557, returns to 0x1558 // Inputs[1] { @1CAE stack[-1] } 1CA9 5B JUMPDEST 1CAA 60 PUSH1 0x00 1CAC 60 PUSH1 0x01 1CAE 82 DUP3 1CAF 01 ADD 1CB0 61 PUSH2 0x1cbb 1CB3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CAA stack[0] = 0x00 } // Block ends with conditional jump to 0x1cbb, if stack[-1] + 0x01 label_1CB4: // Incoming jump from 0x1CB3, if not stack[-1] + 0x01 1CB4 61 PUSH2 0x1cbb 1CB7 61 PUSH2 0x1c65 1CBA 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CB4 stack[0] = 0x1cbb } // Block ends with unconditional jump to 0x1c65 label_1CBB: // Incoming jump from 0x1CB3, if stack[-1] + 0x01 // Inputs[2] // { // @1CBF stack[-2] // @1CC0 stack[-3] // } 1CBB 5B JUMPDEST 1CBC 50 POP 1CBD 60 PUSH1 0x01 1CBF 01 ADD 1CC0 90 SWAP1 1CC1 56 *JUMP // Stack delta = -2 // Outputs[1] { @1CC0 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 1CC2 5B JUMPDEST 1CC3 60 PUSH1 0x00 1CC5 83 DUP4 1CC6 51 MLOAD 1CC7 61 PUSH2 0x1cd4 1CCA 81 DUP2 1CCB 84 DUP5 1CCC 60 PUSH1 0x20 1CCE 88 DUP9 1CCF 01 ADD 1CD0 61 PUSH2 0x1830 1CD3 56 *JUMP 1CD4 5B JUMPDEST 1CD5 83 DUP4 1CD6 51 MLOAD 1CD7 90 SWAP1 1CD8 83 DUP4 1CD9 01 ADD 1CDA 90 SWAP1 1CDB 61 PUSH2 0x1ce8 1CDE 81 DUP2 1CDF 83 DUP4 1CE0 60 PUSH1 0x20 1CE2 88 DUP9 1CE3 01 ADD 1CE4 61 PUSH2 0x1830 1CE7 56 *JUMP 1CE8 5B JUMPDEST 1CE9 01 ADD 1CEA 94 SWAP5 1CEB 93 SWAP4 1CEC 50 POP 1CED 50 POP 1CEE 50 POP 1CEF 50 POP 1CF0 56 *JUMP label_1CF1: // Incoming call from 0x135C, returns to 0x135D // Inputs[5] // { // @1CFA stack[-5] // @1CFD stack[-1] // @1CFF stack[-4] // @1D0A stack[-3] // @1D1F stack[-2] // } 1CF1 5B JUMPDEST 1CF2 60 PUSH1 0x01 1CF4 60 PUSH1 0x01 1CF6 60 PUSH1 0xa0 1CF8 1B SHL 1CF9 03 SUB 1CFA 85 DUP6 1CFB 81 DUP2 1CFC 16 AND 1CFD 82 DUP3 1CFE 52 MSTORE 1CFF 84 DUP5 1D00 16 AND 1D01 60 PUSH1 0x20 1D03 82 DUP3 1D04 01 ADD 1D05 52 MSTORE 1D06 60 PUSH1 0x40 1D08 81 DUP2 1D09 01 ADD 1D0A 83 DUP4 1D0B 90 SWAP1 1D0C 52 MSTORE 1D0D 60 PUSH1 0x80 1D0F 60 PUSH1 0x60 1D11 82 DUP3 1D12 01 ADD 1D13 81 DUP2 1D14 90 SWAP1 1D15 52 MSTORE 1D16 60 PUSH1 0x00 1D18 90 SWAP1 1D19 61 PUSH2 0x1d24 1D1C 90 SWAP1 1D1D 83 DUP4 1D1E 01 ADD 1D1F 84 DUP5 1D20 61 PUSH2 0x185c 1D23 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1CFE memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1D05 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1D0C memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1D15 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1D18 stack[0] = 0x00 // @1D1C stack[1] = 0x1d24 // @1D1E stack[2] = stack[-1] + 0x80 // @1D1F stack[3] = stack[-2] // } // Block ends with call to 0x185c, returns to 0x1D24 label_1D24: // Incoming return from call to 0x185C at 0x1D23 // Inputs[3] // { // @1D25 stack[-8] // @1D25 stack[-1] // @1D26 stack[-7] // } 1D24 5B JUMPDEST 1D25 96 SWAP7 1D26 95 SWAP6 1D27 50 POP 1D28 50 POP 1D29 50 POP 1D2A 50 POP 1D2B 50 POP 1D2C 50 POP 1D2D 56 *JUMP // Stack delta = -7 // Outputs[1] { @1D25 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1D2E: // Incoming jump from 0x1394 // Inputs[2] // { // @1D33 stack[-1] // @1D34 stack[-2] // } 1D2E 5B JUMPDEST 1D2F 60 PUSH1 0x00 1D31 60 PUSH1 0x20 1D33 82 DUP3 1D34 84 DUP5 1D35 03 SUB 1D36 12 SLT 1D37 15 ISZERO 1D38 61 PUSH2 0x1d40 1D3B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D2F stack[0] = 0x00 } // Block ends with conditional jump to 0x1d40, if !(stack[-2] - stack[-1] i< 0x20) label_1D3C: // Incoming jump from 0x1D3B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D3F memory[0x00:0x00] } 1D3C 60 PUSH1 0x00 1D3E 80 DUP1 1D3F FD *REVERT // Stack delta = +0 // Outputs[1] { @1D3F revert(memory[0x00:0x00]); } // Block terminates label_1D40: // Incoming jump from 0x1D3B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D41 stack[-2] // @1D42 memory[stack[-2]:stack[-2] + 0x20] // } 1D40 5B JUMPDEST 1D41 81 DUP2 1D42 51 MLOAD 1D43 61 PUSH2 0x15f5 1D46 81 DUP2 1D47 61 PUSH2 0x17fd 1D4A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D42 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1D43 stack[1] = 0x15f5 // @1D46 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x17fd, returns to 0x15F5 1D4B 5B JUMPDEST 1D4C 63 PUSH4 0x4e487b71 1D51 60 PUSH1 0xe0 1D53 1B SHL 1D54 60 PUSH1 0x00 1D56 52 MSTORE 1D57 60 PUSH1 0x12 1D59 60 PUSH1 0x04 1D5B 52 MSTORE 1D5C 60 PUSH1 0x24 1D5E 60 PUSH1 0x00 1D60 FD *REVERT 1D61 5B JUMPDEST 1D62 60 PUSH1 0x00 1D64 82 DUP3 1D65 61 PUSH2 0x1d70 1D68 57 *JUMPI 1D69 61 PUSH2 0x1d70 1D6C 61 PUSH2 0x1d4b 1D6F 56 *JUMP 1D70 5B JUMPDEST 1D71 50 POP 1D72 04 DIV 1D73 90 SWAP1 1D74 56 *JUMP 1D75 5B JUMPDEST 1D76 60 PUSH1 0x00 1D78 82 DUP3 1D79 82 DUP3 1D7A 10 LT 1D7B 15 ISZERO 1D7C 61 PUSH2 0x1d87 1D7F 57 *JUMPI 1D80 61 PUSH2 0x1d87 1D83 61 PUSH2 0x1c65 1D86 56 *JUMP 1D87 5B JUMPDEST 1D88 50 POP 1D89 03 SUB 1D8A 90 SWAP1 1D8B 56 *JUMP 1D8C 5B JUMPDEST 1D8D 60 PUSH1 0x00 1D8F 82 DUP3 1D90 61 PUSH2 0x1d9b 1D93 57 *JUMPI 1D94 61 PUSH2 0x1d9b 1D97 61 PUSH2 0x1d4b 1D9A 56 *JUMP 1D9B 5B JUMPDEST 1D9C 50 POP 1D9D 06 MOD 1D9E 90 SWAP1 1D9F 56 *JUMP 1DA0 FE *ASSERT 1DA1 A2 LOG2 1DA2 64 PUSH5 0x6970667358 1DA8 22 22 1DA9 12 SLT 1DAA 20 SHA3 1DAB 7D PUSH30 0x04e28b3dede9eed5f53d535c964d08bb811a9cf190ae8eb923ea68a389a5 1DCA 08 ADDMOD 1DCB 64 PUSH5 0x736f6c6343 1DD1 00 *STOP 1DD2 08 ADDMOD 1DD3 0E 0E 1DD4 00 *STOP 1DD5 33 CALLER