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 0x0251 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0251, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0139 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0139, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc634d032 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xc634d032 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc634d032 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xefa5860a 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xefa5860a > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xefa5860a > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xefa5860a 003A 14 EQ 003B 61 PUSH2 0x0860 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0860, if 0xefa5860a == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xefa5860a == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf0325549 0045 14 EQ 0046 61 PUSH2 0x088b 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x088b, if 0xf0325549 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf0325549 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf2c4ce1e 0050 14 EQ 0051 61 PUSH2 0x08a2 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a2, if 0xf2c4ce1e == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf2c4ce1e == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x08cb 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08cb, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf47c84c5 0066 14 EQ 0067 61 PUSH2 0x08f4 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08f4, if 0xf47c84c5 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf47c84c5 == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xffe630b5 0071 14 EQ 0072 61 PUSH2 0x091f 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x091f, if 0xffe630b5 == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xffe630b5 == stack[-1] 0076 61 PUSH2 0x0251 0079 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_007A: // Incoming jump from 0x0033, if 0xefa5860a > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xc634d032 0081 14 EQ 0082 61 PUSH2 0x0774 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0774, if 0xc634d032 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc634d032 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc6682862 008C 14 EQ 008D 61 PUSH2 0x0790 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0790, if 0xc6682862 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc6682862 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x07bb 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07bb, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xe985e9c5 00A2 14 EQ 00A3 61 PUSH2 0x07f8 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07f8, if 0xe985e9c5 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xeb8d2444 00AD 14 EQ 00AE 61 PUSH2 0x0835 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0835, if 0xeb8d2444 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xeb8d2444 == stack[-1] 00B2 61 PUSH2 0x0251 00B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_00B6: // Incoming jump from 0x0028, if 0xc634d032 > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x95d89b41 00BD 11 GT 00BE 61 PUSH2 0x00fd 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, 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 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x06b7 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b7, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa22cb465 00D3 14 EQ 00D4 61 PUSH2 0x06e2 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e2, if 0xa22cb465 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa475b5dd 00DE 14 EQ 00DF 61 PUSH2 0x070b 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070b, if 0xa475b5dd == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa475b5dd == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xb7ced53b 00E9 14 EQ 00EA 61 PUSH2 0x0722 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0722, if 0xb7ced53b == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xb7ced53b == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xb88d4fde 00F4 14 EQ 00F5 61 PUSH2 0x074b 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074b, if 0xb88d4fde == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xb88d4fde == stack[-1] 00F9 61 PUSH2 0x0251 00FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_00FD: // Incoming jump from 0x00C1, if 0x95d89b41 > stack[-1] // Inputs[1] { @00FE stack[-1] } 00FD 5B JUMPDEST 00FE 80 DUP1 00FF 63 PUSH4 0x70a08231 0104 14 EQ 0105 61 PUSH2 0x05e2 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e2, if 0x70a08231 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x70a08231 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x715018a6 010F 14 EQ 0110 61 PUSH2 0x061f 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061f, if 0x715018a6 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x715018a6 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x7a8baf52 011A 14 EQ 011B 61 PUSH2 0x0636 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0x7a8baf52 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x7a8baf52 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x7ff9b596 0125 14 EQ 0126 61 PUSH2 0x0661 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0661, if 0x7ff9b596 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x7ff9b596 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x8da5cb5b 0130 14 EQ 0131 61 PUSH2 0x068c 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068c, if 0x8da5cb5b == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x8da5cb5b == stack[-1] 0135 61 PUSH2 0x0251 0138 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_0139: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @013A stack[-1] } 0139 5B JUMPDEST 013A 80 DUP1 013B 63 PUSH4 0x2f745c59 0140 11 GT 0141 61 PUSH2 0x01d2 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d2, if 0x2f745c59 > stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x4f6ccce7 014B 11 GT 014C 61 PUSH2 0x0196 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0196, if 0x4f6ccce7 > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x4f6ccce7 0156 14 EQ 0157 61 PUSH2 0x04cd 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cd, if 0x4f6ccce7 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x51830227 0161 14 EQ 0162 61 PUSH2 0x050a 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050a, if 0x51830227 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x51830227 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x55f804b3 016C 14 EQ 016D 61 PUSH2 0x0535 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0535, if 0x55f804b3 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x6352211e 0177 14 EQ 0178 61 PUSH2 0x055e 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055e, if 0x6352211e == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x6352211e == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x6373a6b1 0182 14 EQ 0183 61 PUSH2 0x059b 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059b, if 0x6373a6b1 == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x6373a6b1 == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x6955327d 018D 14 EQ 018E 61 PUSH2 0x05c6 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c6, if 0x6955327d == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x6955327d == stack[-1] 0192 61 PUSH2 0x0251 0195 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_0196: // Incoming jump from 0x014F, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @0197 stack[-1] } 0196 5B JUMPDEST 0197 80 DUP1 0198 63 PUSH4 0x2f745c59 019D 14 EQ 019E 61 PUSH2 0x0410 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0410, if 0x2f745c59 == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x2f745c59 == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x31690b44 01A8 14 EQ 01A9 61 PUSH2 0x044d 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044d, if 0x31690b44 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x31690b44 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x34918dfd 01B3 14 EQ 01B4 61 PUSH2 0x0476 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0476, if 0x34918dfd == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x34918dfd == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x3ccfd60b 01BE 14 EQ 01BF 61 PUSH2 0x048d 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048d, if 0x3ccfd60b == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x42842e0e 01C9 14 EQ 01CA 61 PUSH2 0x04a4 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a4, if 0x42842e0e == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x42842e0e == stack[-1] 01CE 61 PUSH2 0x0251 01D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_01D2: // Incoming jump from 0x0144, if 0x2f745c59 > stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D2 5B JUMPDEST 01D3 80 DUP1 01D4 63 PUSH4 0x09aa3dcf 01D9 11 GT 01DA 61 PUSH2 0x0219 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, if 0x09aa3dcf > stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x09aa3dcf > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x09aa3dcf 01E4 14 EQ 01E5 61 PUSH2 0x034f 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034f, if 0x09aa3dcf == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x09aa3dcf == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x18160ddd 01EF 14 EQ 01F0 61 PUSH2 0x037a 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037a, if 0x18160ddd == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x18160ddd == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x1f0234d8 01FA 14 EQ 01FB 61 PUSH2 0x03a5 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a5, if 0x1f0234d8 == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x1f0234d8 == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x23b872dd 0205 14 EQ 0206 61 PUSH2 0x03d0 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d0, if 0x23b872dd == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x23b872dd == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x27ac36c4 0210 14 EQ 0211 61 PUSH2 0x03f9 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f9, if 0x27ac36c4 == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x27ac36c4 == stack[-1] 0215 61 PUSH2 0x0251 0218 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0251 label_0219: // Incoming jump from 0x01DD, if 0x09aa3dcf > stack[-1] // Inputs[1] { @021A stack[-1] } 0219 5B JUMPDEST 021A 80 DUP1 021B 63 PUSH4 0x01ffc9a7 0220 14 EQ 0221 61 PUSH2 0x0256 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0256, if 0x01ffc9a7 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x06fdde03 022B 14 EQ 022C 61 PUSH2 0x0293 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if 0x06fdde03 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x081812fc 0236 14 EQ 0237 61 PUSH2 0x02be 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0x081812fc == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x081812fc == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x081c8c44 0241 14 EQ 0242 61 PUSH2 0x02fb 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fb, if 0x081c8c44 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x081c8c44 == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x095ea7b3 024C 14 EQ 024D 61 PUSH2 0x0326 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0326, if 0x095ea7b3 == stack[-1] label_0251: // Incoming jump from 0x00FC // Incoming jump from 0x01D1 // Incoming jump from 0x00B5 // Incoming jump from 0x0218 // Incoming jump from 0x0250, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x0138 // Incoming jump from 0x0079 // Incoming jump from 0x0195 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0255 memory[0x00:0x00] } 0251 5B JUMPDEST 0252 60 PUSH1 0x00 0254 80 DUP1 0255 FD *REVERT // Stack delta = +0 // Outputs[1] { @0255 revert(memory[0x00:0x00]); } // Block terminates label_0256: // Incoming jump from 0x0224, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0257 msg.value } 0256 5B JUMPDEST 0257 34 CALLVALUE 0258 80 DUP1 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0257 stack[0] = msg.value } // Block ends with conditional jump to 0x0262, if !msg.value label_025E: // Incoming jump from 0x025D, if not !msg.value // Inputs[1] { @0261 memory[0x00:0x00] } 025E 60 PUSH1 0x00 0260 80 DUP1 0261 FD *REVERT // Stack delta = +0 // Outputs[1] { @0261 revert(memory[0x00:0x00]); } // Block terminates label_0262: // Incoming jump from 0x025D, if !msg.value // Inputs[1] { @026A msg.data.length } 0262 5B JUMPDEST 0263 50 POP 0264 61 PUSH2 0x027d 0267 60 PUSH1 0x04 0269 80 DUP1 026A 36 CALLDATASIZE 026B 03 SUB 026C 81 DUP2 026D 01 ADD 026E 90 SWAP1 026F 61 PUSH2 0x0278 0272 91 SWAP2 0273 90 SWAP1 0274 61 PUSH2 0x39a3 0277 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0264 stack[-1] = 0x027d // @0272 stack[0] = 0x0278 // @0273 stack[2] = 0x04 // @0273 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x39a3, returns to 0x0278 label_0278: // Incoming return from call to 0x39A3 at 0x0277 0278 5B JUMPDEST 0279 61 PUSH2 0x0948 027C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0948 label_027D: // Incoming return from call to 0x0278 at 0x0277 // Inputs[2] // { // @0280 memory[0x40:0x60] // @0284 stack[-1] // } 027D 5B JUMPDEST 027E 60 PUSH1 0x40 0280 51 MLOAD 0281 61 PUSH2 0x028a 0284 91 SWAP2 0285 90 SWAP1 0286 61 PUSH2 0x45f2 0289 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0284 stack[-1] = 0x028a // @0285 stack[1] = memory[0x40:0x60] // @0285 stack[0] = stack[-1] // } // Block ends with call to 0x45f2, returns to 0x028A label_028A: // Incoming return from call to 0x45F2 at 0x0289 // Inputs[3] // { // @028D memory[0x40:0x60] // @028F stack[-1] // @0292 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 028A 5B JUMPDEST 028B 60 PUSH1 0x40 028D 51 MLOAD 028E 80 DUP1 028F 91 SWAP2 0290 03 SUB 0291 90 SWAP1 0292 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0292 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0293: // Incoming jump from 0x022F, if 0x06fdde03 == stack[-1] // Inputs[1] { @0294 msg.value } 0293 5B JUMPDEST 0294 34 CALLVALUE 0295 80 DUP1 0296 15 ISZERO 0297 61 PUSH2 0x029f 029A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0294 stack[0] = msg.value } // Block ends with conditional jump to 0x029f, if !msg.value label_029B: // Incoming jump from 0x029A, if not !msg.value // Inputs[1] { @029E memory[0x00:0x00] } 029B 60 PUSH1 0x00 029D 80 DUP1 029E FD *REVERT // Stack delta = +0 // Outputs[1] { @029E revert(memory[0x00:0x00]); } // Block terminates label_029F: // Incoming jump from 0x029A, if !msg.value 029F 5B JUMPDEST 02A0 50 POP 02A1 61 PUSH2 0x02a8 02A4 61 PUSH2 0x095a 02A7 56 *JUMP // Stack delta = +0 // Outputs[1] { @02A1 stack[-1] = 0x02a8 } // Block ends with call to 0x095a, returns to 0x02A8 label_02A8: // Incoming return from call to 0x095A at 0x02A7 // Inputs[2] // { // @02AB memory[0x40:0x60] // @02AF stack[-1] // } 02A8 5B JUMPDEST 02A9 60 PUSH1 0x40 02AB 51 MLOAD 02AC 61 PUSH2 0x02b5 02AF 91 SWAP2 02B0 90 SWAP1 02B1 61 PUSH2 0x460d 02B4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02AF stack[-1] = 0x02b5 // @02B0 stack[1] = memory[0x40:0x60] // @02B0 stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x02B5 label_02B5: // Incoming return from call to 0x460D at 0x02B4 // Inputs[3] // { // @02B8 memory[0x40:0x60] // @02BA stack[-1] // @02BD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02B5 5B JUMPDEST 02B6 60 PUSH1 0x40 02B8 51 MLOAD 02B9 80 DUP1 02BA 91 SWAP2 02BB 03 SUB 02BC 90 SWAP1 02BD F3 *RETURN // Stack delta = -1 // Outputs[1] { @02BD return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02BE: // Incoming jump from 0x023A, if 0x081812fc == stack[-1] // Inputs[1] { @02BF msg.value } 02BE 5B JUMPDEST 02BF 34 CALLVALUE 02C0 80 DUP1 02C1 15 ISZERO 02C2 61 PUSH2 0x02ca 02C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BF stack[0] = msg.value } // Block ends with conditional jump to 0x02ca, if !msg.value label_02C6: // Incoming jump from 0x02C5, if not !msg.value // Inputs[1] { @02C9 memory[0x00:0x00] } 02C6 60 PUSH1 0x00 02C8 80 DUP1 02C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C9 revert(memory[0x00:0x00]); } // Block terminates label_02CA: // Incoming jump from 0x02C5, if !msg.value // Inputs[1] { @02D2 msg.data.length } 02CA 5B JUMPDEST 02CB 50 POP 02CC 61 PUSH2 0x02e5 02CF 60 PUSH1 0x04 02D1 80 DUP1 02D2 36 CALLDATASIZE 02D3 03 SUB 02D4 81 DUP2 02D5 01 ADD 02D6 90 SWAP1 02D7 61 PUSH2 0x02e0 02DA 91 SWAP2 02DB 90 SWAP1 02DC 61 PUSH2 0x3a36 02DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02CC stack[-1] = 0x02e5 // @02DA stack[0] = 0x02e0 // @02DB stack[2] = 0x04 // @02DB stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3a36, returns to 0x02E0 label_02E0: // Incoming return from call to 0x3A36 at 0x02DF 02E0 5B JUMPDEST 02E1 61 PUSH2 0x09ec 02E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ec label_02E5: // Incoming return from call to 0x02E0 at 0x02DF // Inputs[2] // { // @02E8 memory[0x40:0x60] // @02EC stack[-1] // } 02E5 5B JUMPDEST 02E6 60 PUSH1 0x40 02E8 51 MLOAD 02E9 61 PUSH2 0x02f2 02EC 91 SWAP2 02ED 90 SWAP1 02EE 61 PUSH2 0x458b 02F1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02EC stack[-1] = 0x02f2 // @02ED stack[1] = memory[0x40:0x60] // @02ED stack[0] = stack[-1] // } // Block ends with call to 0x458b, returns to 0x02F2 label_02F2: // Incoming return from call to 0x458B at 0x02F1 // Inputs[3] // { // @02F5 memory[0x40:0x60] // @02F7 stack[-1] // @02FA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02F2 5B JUMPDEST 02F3 60 PUSH1 0x40 02F5 51 MLOAD 02F6 80 DUP1 02F7 91 SWAP2 02F8 03 SUB 02F9 90 SWAP1 02FA F3 *RETURN // Stack delta = -1 // Outputs[1] { @02FA return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02FB: // Incoming jump from 0x0245, if 0x081c8c44 == stack[-1] // Inputs[1] { @02FC msg.value } 02FB 5B JUMPDEST 02FC 34 CALLVALUE 02FD 80 DUP1 02FE 15 ISZERO 02FF 61 PUSH2 0x0307 0302 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FC stack[0] = msg.value } // Block ends with conditional jump to 0x0307, if !msg.value label_0303: // Incoming jump from 0x0302, if not !msg.value // Inputs[1] { @0306 memory[0x00:0x00] } 0303 60 PUSH1 0x00 0305 80 DUP1 0306 FD *REVERT // Stack delta = +0 // Outputs[1] { @0306 revert(memory[0x00:0x00]); } // Block terminates label_0307: // Incoming jump from 0x0302, if !msg.value 0307 5B JUMPDEST 0308 50 POP 0309 61 PUSH2 0x0310 030C 61 PUSH2 0x0a71 030F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0309 stack[-1] = 0x0310 } // Block ends with call to 0x0a71, returns to 0x0310 label_0310: // Incoming return from call to 0x0A71 at 0x030F // Inputs[2] // { // @0313 memory[0x40:0x60] // @0317 stack[-1] // } 0310 5B JUMPDEST 0311 60 PUSH1 0x40 0313 51 MLOAD 0314 61 PUSH2 0x031d 0317 91 SWAP2 0318 90 SWAP1 0319 61 PUSH2 0x460d 031C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0317 stack[-1] = 0x031d // @0318 stack[1] = memory[0x40:0x60] // @0318 stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x031D label_031D: // Incoming return from call to 0x460D at 0x031C // Inputs[3] // { // @0320 memory[0x40:0x60] // @0322 stack[-1] // @0325 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 031D 5B JUMPDEST 031E 60 PUSH1 0x40 0320 51 MLOAD 0321 80 DUP1 0322 91 SWAP2 0323 03 SUB 0324 90 SWAP1 0325 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0325 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0326: // Incoming jump from 0x0250, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0327 msg.value } 0326 5B JUMPDEST 0327 34 CALLVALUE 0328 80 DUP1 0329 15 ISZERO 032A 61 PUSH2 0x0332 032D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0327 stack[0] = msg.value } // Block ends with conditional jump to 0x0332, if !msg.value label_032E: // Incoming jump from 0x032D, if not !msg.value // Inputs[1] { @0331 memory[0x00:0x00] } 032E 60 PUSH1 0x00 0330 80 DUP1 0331 FD *REVERT // Stack delta = +0 // Outputs[1] { @0331 revert(memory[0x00:0x00]); } // Block terminates label_0332: // Incoming jump from 0x032D, if !msg.value // Inputs[1] { @033A msg.data.length } 0332 5B JUMPDEST 0333 50 POP 0334 61 PUSH2 0x034d 0337 60 PUSH1 0x04 0339 80 DUP1 033A 36 CALLDATASIZE 033B 03 SUB 033C 81 DUP2 033D 01 ADD 033E 90 SWAP1 033F 61 PUSH2 0x0348 0342 91 SWAP2 0343 90 SWAP1 0344 61 PUSH2 0x3967 0347 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0334 stack[-1] = 0x034d // @0342 stack[0] = 0x0348 // @0343 stack[2] = 0x04 // @0343 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3967, returns to 0x0348 label_0348: // Incoming return from call to 0x3967 at 0x0347 0348 5B JUMPDEST 0349 61 PUSH2 0x0aff 034C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aff label_034D: // Incoming return from call to 0x0348 at 0x0347 034D 5B JUMPDEST 034E 00 *STOP // Stack delta = +0 // Outputs[1] { @034E stop(); } // Block terminates label_034F: // Incoming jump from 0x01E8, if 0x09aa3dcf == stack[-1] // Inputs[1] { @0350 msg.value } 034F 5B JUMPDEST 0350 34 CALLVALUE 0351 80 DUP1 0352 15 ISZERO 0353 61 PUSH2 0x035b 0356 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0350 stack[0] = msg.value } // Block ends with conditional jump to 0x035b, if !msg.value label_0357: // Incoming jump from 0x0356, if not !msg.value // Inputs[1] { @035A memory[0x00:0x00] } 0357 60 PUSH1 0x00 0359 80 DUP1 035A FD *REVERT // Stack delta = +0 // Outputs[1] { @035A revert(memory[0x00:0x00]); } // Block terminates label_035B: // Incoming jump from 0x0356, if !msg.value 035B 5B JUMPDEST 035C 50 POP 035D 61 PUSH2 0x0364 0360 61 PUSH2 0x0c17 0363 56 *JUMP // Stack delta = +0 // Outputs[1] { @035D stack[-1] = 0x0364 } // Block ends with call to 0x0c17, returns to 0x0364 label_0364: // Incoming return from call to 0x0C17 at 0x0363 // Inputs[2] // { // @0367 memory[0x40:0x60] // @036B stack[-1] // } 0364 5B JUMPDEST 0365 60 PUSH1 0x40 0367 51 MLOAD 0368 61 PUSH2 0x0371 036B 91 SWAP2 036C 90 SWAP1 036D 61 PUSH2 0x49af 0370 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @036B stack[-1] = 0x0371 // @036C stack[1] = memory[0x40:0x60] // @036C stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0371 label_0371: // Incoming return from call to 0x49AF at 0x0370 // Inputs[3] // { // @0374 memory[0x40:0x60] // @0376 stack[-1] // @0379 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0371 5B JUMPDEST 0372 60 PUSH1 0x40 0374 51 MLOAD 0375 80 DUP1 0376 91 SWAP2 0377 03 SUB 0378 90 SWAP1 0379 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0379 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_037A: // Incoming jump from 0x01F3, if 0x18160ddd == stack[-1] // Inputs[1] { @037B msg.value } 037A 5B JUMPDEST 037B 34 CALLVALUE 037C 80 DUP1 037D 15 ISZERO 037E 61 PUSH2 0x0386 0381 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037B stack[0] = msg.value } // Block ends with conditional jump to 0x0386, if !msg.value label_0382: // Incoming jump from 0x0381, if not !msg.value // Inputs[1] { @0385 memory[0x00:0x00] } 0382 60 PUSH1 0x00 0384 80 DUP1 0385 FD *REVERT // Stack delta = +0 // Outputs[1] { @0385 revert(memory[0x00:0x00]); } // Block terminates label_0386: // Incoming jump from 0x0381, if !msg.value 0386 5B JUMPDEST 0387 50 POP 0388 61 PUSH2 0x038f 038B 61 PUSH2 0x0c1c 038E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0388 stack[-1] = 0x038f } // Block ends with call to 0x0c1c, returns to 0x038F label_038F: // Incoming return from call to 0x0C1C at 0x038E // Inputs[2] // { // @0392 memory[0x40:0x60] // @0396 stack[-1] // } 038F 5B JUMPDEST 0390 60 PUSH1 0x40 0392 51 MLOAD 0393 61 PUSH2 0x039c 0396 91 SWAP2 0397 90 SWAP1 0398 61 PUSH2 0x49af 039B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0396 stack[-1] = 0x039c // @0397 stack[1] = memory[0x40:0x60] // @0397 stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x039C label_039C: // Incoming return from call to 0x49AF at 0x039B // Inputs[3] // { // @039F memory[0x40:0x60] // @03A1 stack[-1] // @03A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 039C 5B JUMPDEST 039D 60 PUSH1 0x40 039F 51 MLOAD 03A0 80 DUP1 03A1 91 SWAP2 03A2 03 SUB 03A3 90 SWAP1 03A4 F3 *RETURN // Stack delta = -1 // Outputs[1] { @03A4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03A5: // Incoming jump from 0x01FE, if 0x1f0234d8 == stack[-1] // Inputs[1] { @03A6 msg.value } 03A5 5B JUMPDEST 03A6 34 CALLVALUE 03A7 80 DUP1 03A8 15 ISZERO 03A9 61 PUSH2 0x03b1 03AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A6 stack[0] = msg.value } // Block ends with conditional jump to 0x03b1, if !msg.value label_03AD: // Incoming jump from 0x03AC, if not !msg.value // Inputs[1] { @03B0 memory[0x00:0x00] } 03AD 60 PUSH1 0x00 03AF 80 DUP1 03B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B0 revert(memory[0x00:0x00]); } // Block terminates label_03B1: // Incoming jump from 0x03AC, if !msg.value 03B1 5B JUMPDEST 03B2 50 POP 03B3 61 PUSH2 0x03ba 03B6 61 PUSH2 0x0c29 03B9 56 *JUMP // Stack delta = +0 // Outputs[1] { @03B3 stack[-1] = 0x03ba } // Block ends with call to 0x0c29, returns to 0x03BA label_03BA: // Incoming return from call to 0x0C29 at 0x03B9 // Inputs[2] // { // @03BD memory[0x40:0x60] // @03C1 stack[-1] // } 03BA 5B JUMPDEST 03BB 60 PUSH1 0x40 03BD 51 MLOAD 03BE 61 PUSH2 0x03c7 03C1 91 SWAP2 03C2 90 SWAP1 03C3 61 PUSH2 0x45f2 03C6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03C1 stack[-1] = 0x03c7 // @03C2 stack[1] = memory[0x40:0x60] // @03C2 stack[0] = stack[-1] // } // Block ends with call to 0x45f2, returns to 0x03C7 label_03C7: // Incoming return from call to 0x45F2 at 0x03C6 // Inputs[3] // { // @03CA memory[0x40:0x60] // @03CC stack[-1] // @03CF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03C7 5B JUMPDEST 03C8 60 PUSH1 0x40 03CA 51 MLOAD 03CB 80 DUP1 03CC 91 SWAP2 03CD 03 SUB 03CE 90 SWAP1 03CF F3 *RETURN // Stack delta = -1 // Outputs[1] { @03CF return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_03D0: // Incoming jump from 0x0209, if 0x23b872dd == stack[-1] // Inputs[1] { @03D1 msg.value } 03D0 5B JUMPDEST 03D1 34 CALLVALUE 03D2 80 DUP1 03D3 15 ISZERO 03D4 61 PUSH2 0x03dc 03D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D1 stack[0] = msg.value } // Block ends with conditional jump to 0x03dc, if !msg.value label_03D8: // Incoming jump from 0x03D7, if not !msg.value // Inputs[1] { @03DB memory[0x00:0x00] } 03D8 60 PUSH1 0x00 03DA 80 DUP1 03DB FD *REVERT // Stack delta = +0 // Outputs[1] { @03DB revert(memory[0x00:0x00]); } // Block terminates label_03DC: // Incoming jump from 0x03D7, if !msg.value // Inputs[1] { @03E4 msg.data.length } 03DC 5B JUMPDEST 03DD 50 POP 03DE 61 PUSH2 0x03f7 03E1 60 PUSH1 0x04 03E3 80 DUP1 03E4 36 CALLDATASIZE 03E5 03 SUB 03E6 81 DUP2 03E7 01 ADD 03E8 90 SWAP1 03E9 61 PUSH2 0x03f2 03EC 91 SWAP2 03ED 90 SWAP1 03EE 61 PUSH2 0x3861 03F1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03DE stack[-1] = 0x03f7 // @03EC stack[0] = 0x03f2 // @03ED stack[2] = 0x04 // @03ED stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3861, returns to 0x03F2 label_03F2: // Incoming return from call to 0x3861 at 0x03F1 03F2 5B JUMPDEST 03F3 61 PUSH2 0x0c3c 03F6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c3c label_03F7: // Incoming return from call to 0x03F2 at 0x03F1 03F7 5B JUMPDEST 03F8 00 *STOP // Stack delta = +0 // Outputs[1] { @03F8 stop(); } // Block terminates label_03F9: // Incoming jump from 0x0214, if 0x27ac36c4 == stack[-1] // Inputs[1] { @03FA msg.value } 03F9 5B JUMPDEST 03FA 34 CALLVALUE 03FB 80 DUP1 03FC 15 ISZERO 03FD 61 PUSH2 0x0405 0400 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FA stack[0] = msg.value } // Block ends with conditional jump to 0x0405, if !msg.value label_0401: // Incoming jump from 0x0400, if not !msg.value // Inputs[1] { @0404 memory[0x00:0x00] } 0401 60 PUSH1 0x00 0403 80 DUP1 0404 FD *REVERT // Stack delta = +0 // Outputs[1] { @0404 revert(memory[0x00:0x00]); } // Block terminates label_0405: // Incoming jump from 0x0400, if !msg.value 0405 5B JUMPDEST 0406 50 POP 0407 61 PUSH2 0x040e 040A 61 PUSH2 0x0c9c 040D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0407 stack[-1] = 0x040e } // Block ends with call to 0x0c9c, returns to 0x040E label_040E: // Incoming return from call to 0x0C9C at 0x040D 040E 5B JUMPDEST 040F 00 *STOP // Stack delta = +0 // Outputs[1] { @040F stop(); } // Block terminates label_0410: // Incoming jump from 0x01A1, if 0x2f745c59 == stack[-1] // Inputs[1] { @0411 msg.value } 0410 5B JUMPDEST 0411 34 CALLVALUE 0412 80 DUP1 0413 15 ISZERO 0414 61 PUSH2 0x041c 0417 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0411 stack[0] = msg.value } // Block ends with conditional jump to 0x041c, if !msg.value label_0418: // Incoming jump from 0x0417, if not !msg.value // Inputs[1] { @041B memory[0x00:0x00] } 0418 60 PUSH1 0x00 041A 80 DUP1 041B FD *REVERT // Stack delta = +0 // Outputs[1] { @041B revert(memory[0x00:0x00]); } // Block terminates label_041C: // Incoming jump from 0x0417, if !msg.value // Inputs[1] { @0424 msg.data.length } 041C 5B JUMPDEST 041D 50 POP 041E 61 PUSH2 0x0437 0421 60 PUSH1 0x04 0423 80 DUP1 0424 36 CALLDATASIZE 0425 03 SUB 0426 81 DUP2 0427 01 ADD 0428 90 SWAP1 0429 61 PUSH2 0x0432 042C 91 SWAP2 042D 90 SWAP1 042E 61 PUSH2 0x3967 0431 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @041E stack[-1] = 0x0437 // @042C stack[0] = 0x0432 // @042D stack[2] = 0x04 // @042D stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3967, returns to 0x0432 label_0432: // Incoming return from call to 0x3967 at 0x0431 0432 5B JUMPDEST 0433 61 PUSH2 0x0d9f 0436 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d9f label_0437: // Incoming return from call to 0x0432 at 0x0431 // Inputs[2] // { // @043A memory[0x40:0x60] // @043E stack[-1] // } 0437 5B JUMPDEST 0438 60 PUSH1 0x40 043A 51 MLOAD 043B 61 PUSH2 0x0444 043E 91 SWAP2 043F 90 SWAP1 0440 61 PUSH2 0x49af 0443 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @043E stack[-1] = 0x0444 // @043F stack[1] = memory[0x40:0x60] // @043F stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0444 label_0444: // Incoming return from call to 0x49AF at 0x0443 // Inputs[3] // { // @0447 memory[0x40:0x60] // @0449 stack[-1] // @044C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0444 5B JUMPDEST 0445 60 PUSH1 0x40 0447 51 MLOAD 0448 80 DUP1 0449 91 SWAP2 044A 03 SUB 044B 90 SWAP1 044C F3 *RETURN // Stack delta = -1 // Outputs[1] { @044C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_044D: // Incoming jump from 0x01AC, if 0x31690b44 == stack[-1] // Inputs[1] { @044E msg.value } 044D 5B JUMPDEST 044E 34 CALLVALUE 044F 80 DUP1 0450 15 ISZERO 0451 61 PUSH2 0x0459 0454 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044E stack[0] = msg.value } // Block ends with conditional jump to 0x0459, if !msg.value label_0455: // Incoming jump from 0x0454, if not !msg.value // Inputs[1] { @0458 memory[0x00:0x00] } 0455 60 PUSH1 0x00 0457 80 DUP1 0458 FD *REVERT // Stack delta = +0 // Outputs[1] { @0458 revert(memory[0x00:0x00]); } // Block terminates label_0459: // Incoming jump from 0x0454, if !msg.value // Inputs[1] { @0461 msg.data.length } 0459 5B JUMPDEST 045A 50 POP 045B 61 PUSH2 0x0474 045E 60 PUSH1 0x04 0460 80 DUP1 0461 36 CALLDATASIZE 0462 03 SUB 0463 81 DUP2 0464 01 ADD 0465 90 SWAP1 0466 61 PUSH2 0x046f 0469 91 SWAP2 046A 90 SWAP1 046B 61 PUSH2 0x37fc 046E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045B stack[-1] = 0x0474 // @0469 stack[0] = 0x046f // @046A stack[2] = 0x04 // @046A stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x37fc, returns to 0x046F label_046F: // Incoming return from call to 0x37FC at 0x046E 046F 5B JUMPDEST 0470 61 PUSH2 0x0e44 0473 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e44 label_0474: // Incoming return from call to 0x046F at 0x046E 0474 5B JUMPDEST 0475 00 *STOP // Stack delta = +0 // Outputs[1] { @0475 stop(); } // Block terminates label_0476: // Incoming jump from 0x01B7, if 0x34918dfd == stack[-1] // Inputs[1] { @0477 msg.value } 0476 5B JUMPDEST 0477 34 CALLVALUE 0478 80 DUP1 0479 15 ISZERO 047A 61 PUSH2 0x0482 047D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0477 stack[0] = msg.value } // Block ends with conditional jump to 0x0482, if !msg.value label_047E: // Incoming jump from 0x047D, if not !msg.value // Inputs[1] { @0481 memory[0x00:0x00] } 047E 60 PUSH1 0x00 0480 80 DUP1 0481 FD *REVERT // Stack delta = +0 // Outputs[1] { @0481 revert(memory[0x00:0x00]); } // Block terminates label_0482: // Incoming jump from 0x047D, if !msg.value 0482 5B JUMPDEST 0483 50 POP 0484 61 PUSH2 0x048b 0487 61 PUSH2 0x0f52 048A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0484 stack[-1] = 0x048b } // Block ends with call to 0x0f52, returns to 0x048B label_048B: // Incoming return from call to 0x0F52 at 0x048A 048B 5B JUMPDEST 048C 00 *STOP // Stack delta = +0 // Outputs[1] { @048C stop(); } // Block terminates label_048D: // Incoming jump from 0x01C2, if 0x3ccfd60b == stack[-1] // Inputs[1] { @048E msg.value } 048D 5B JUMPDEST 048E 34 CALLVALUE 048F 80 DUP1 0490 15 ISZERO 0491 61 PUSH2 0x0499 0494 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048E stack[0] = msg.value } // Block ends with conditional jump to 0x0499, if !msg.value label_0495: // Incoming jump from 0x0494, if not !msg.value // Inputs[1] { @0498 memory[0x00:0x00] } 0495 60 PUSH1 0x00 0497 80 DUP1 0498 FD *REVERT // Stack delta = +0 // Outputs[1] { @0498 revert(memory[0x00:0x00]); } // Block terminates label_0499: // Incoming jump from 0x0494, if !msg.value 0499 5B JUMPDEST 049A 50 POP 049B 61 PUSH2 0x04a2 049E 61 PUSH2 0x0ffa 04A1 56 *JUMP // Stack delta = +0 // Outputs[1] { @049B stack[-1] = 0x04a2 } // Block ends with call to 0x0ffa, returns to 0x04A2 label_04A2: // Incoming return from call to 0x0FFA at 0x04A1 04A2 5B JUMPDEST 04A3 00 *STOP // Stack delta = +0 // Outputs[1] { @04A3 stop(); } // Block terminates label_04A4: // Incoming jump from 0x01CD, if 0x42842e0e == stack[-1] // Inputs[1] { @04A5 msg.value } 04A4 5B JUMPDEST 04A5 34 CALLVALUE 04A6 80 DUP1 04A7 15 ISZERO 04A8 61 PUSH2 0x04b0 04AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A5 stack[0] = msg.value } // Block ends with conditional jump to 0x04b0, if !msg.value label_04AC: // Incoming jump from 0x04AB, if not !msg.value // Inputs[1] { @04AF memory[0x00:0x00] } 04AC 60 PUSH1 0x00 04AE 80 DUP1 04AF FD *REVERT // Stack delta = +0 // Outputs[1] { @04AF revert(memory[0x00:0x00]); } // Block terminates label_04B0: // Incoming jump from 0x04AB, if !msg.value // Inputs[1] { @04B8 msg.data.length } 04B0 5B JUMPDEST 04B1 50 POP 04B2 61 PUSH2 0x04cb 04B5 60 PUSH1 0x04 04B7 80 DUP1 04B8 36 CALLDATASIZE 04B9 03 SUB 04BA 81 DUP2 04BB 01 ADD 04BC 90 SWAP1 04BD 61 PUSH2 0x04c6 04C0 91 SWAP2 04C1 90 SWAP1 04C2 61 PUSH2 0x3861 04C5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B2 stack[-1] = 0x04cb // @04C0 stack[0] = 0x04c6 // @04C1 stack[2] = 0x04 // @04C1 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3861, returns to 0x04C6 label_04C6: // Incoming return from call to 0x3861 at 0x04C5 04C6 5B JUMPDEST 04C7 61 PUSH2 0x10c5 04CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10c5 label_04CB: // Incoming return from call to 0x04C6 at 0x04C5 04CB 5B JUMPDEST 04CC 00 *STOP // Stack delta = +0 // Outputs[1] { @04CC stop(); } // Block terminates label_04CD: // Incoming jump from 0x015A, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04CE msg.value } 04CD 5B JUMPDEST 04CE 34 CALLVALUE 04CF 80 DUP1 04D0 15 ISZERO 04D1 61 PUSH2 0x04d9 04D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CE stack[0] = msg.value } // Block ends with conditional jump to 0x04d9, if !msg.value label_04D5: // Incoming jump from 0x04D4, if not !msg.value // Inputs[1] { @04D8 memory[0x00:0x00] } 04D5 60 PUSH1 0x00 04D7 80 DUP1 04D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D8 revert(memory[0x00:0x00]); } // Block terminates label_04D9: // Incoming jump from 0x04D4, if !msg.value // Inputs[1] { @04E1 msg.data.length } 04D9 5B JUMPDEST 04DA 50 POP 04DB 61 PUSH2 0x04f4 04DE 60 PUSH1 0x04 04E0 80 DUP1 04E1 36 CALLDATASIZE 04E2 03 SUB 04E3 81 DUP2 04E4 01 ADD 04E5 90 SWAP1 04E6 61 PUSH2 0x04ef 04E9 91 SWAP2 04EA 90 SWAP1 04EB 61 PUSH2 0x3a36 04EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DB stack[-1] = 0x04f4 // @04E9 stack[0] = 0x04ef // @04EA stack[2] = 0x04 // @04EA stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3a36, returns to 0x04EF label_04EF: // Incoming return from call to 0x3A36 at 0x04EE 04EF 5B JUMPDEST 04F0 61 PUSH2 0x10e5 04F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10e5 label_04F4: // Incoming return from call to 0x04EF at 0x04EE // Inputs[2] // { // @04F7 memory[0x40:0x60] // @04FB stack[-1] // } 04F4 5B JUMPDEST 04F5 60 PUSH1 0x40 04F7 51 MLOAD 04F8 61 PUSH2 0x0501 04FB 91 SWAP2 04FC 90 SWAP1 04FD 61 PUSH2 0x49af 0500 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04FB stack[-1] = 0x0501 // @04FC stack[1] = memory[0x40:0x60] // @04FC stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0501 label_0501: // Incoming return from call to 0x49AF at 0x0500 // Inputs[3] // { // @0504 memory[0x40:0x60] // @0506 stack[-1] // @0509 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0501 5B JUMPDEST 0502 60 PUSH1 0x40 0504 51 MLOAD 0505 80 DUP1 0506 91 SWAP2 0507 03 SUB 0508 90 SWAP1 0509 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0509 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_050A: // Incoming jump from 0x0165, if 0x51830227 == stack[-1] // Inputs[1] { @050B msg.value } 050A 5B JUMPDEST 050B 34 CALLVALUE 050C 80 DUP1 050D 15 ISZERO 050E 61 PUSH2 0x0516 0511 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050B stack[0] = msg.value } // Block ends with conditional jump to 0x0516, if !msg.value label_0512: // Incoming jump from 0x0511, if not !msg.value // Inputs[1] { @0515 memory[0x00:0x00] } 0512 60 PUSH1 0x00 0514 80 DUP1 0515 FD *REVERT // Stack delta = +0 // Outputs[1] { @0515 revert(memory[0x00:0x00]); } // Block terminates label_0516: // Incoming jump from 0x0511, if !msg.value 0516 5B JUMPDEST 0517 50 POP 0518 61 PUSH2 0x051f 051B 61 PUSH2 0x117c 051E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0518 stack[-1] = 0x051f } // Block ends with call to 0x117c, returns to 0x051F label_051F: // Incoming return from call to 0x117C at 0x051E // Inputs[2] // { // @0522 memory[0x40:0x60] // @0526 stack[-1] // } 051F 5B JUMPDEST 0520 60 PUSH1 0x40 0522 51 MLOAD 0523 61 PUSH2 0x052c 0526 91 SWAP2 0527 90 SWAP1 0528 61 PUSH2 0x45f2 052B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0526 stack[-1] = 0x052c // @0527 stack[1] = memory[0x40:0x60] // @0527 stack[0] = stack[-1] // } // Block ends with call to 0x45f2, returns to 0x052C label_052C: // Incoming return from call to 0x45F2 at 0x052B // Inputs[3] // { // @052F memory[0x40:0x60] // @0531 stack[-1] // @0534 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 052C 5B JUMPDEST 052D 60 PUSH1 0x40 052F 51 MLOAD 0530 80 DUP1 0531 91 SWAP2 0532 03 SUB 0533 90 SWAP1 0534 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0534 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0535: // Incoming jump from 0x0170, if 0x55f804b3 == 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 // Inputs[1] { @0549 msg.data.length } 0541 5B JUMPDEST 0542 50 POP 0543 61 PUSH2 0x055c 0546 60 PUSH1 0x04 0548 80 DUP1 0549 36 CALLDATASIZE 054A 03 SUB 054B 81 DUP2 054C 01 ADD 054D 90 SWAP1 054E 61 PUSH2 0x0557 0551 91 SWAP2 0552 90 SWAP1 0553 61 PUSH2 0x39f5 0556 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0543 stack[-1] = 0x055c // @0551 stack[0] = 0x0557 // @0552 stack[2] = 0x04 // @0552 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x39f5, returns to 0x0557 label_0557: // Incoming return from call to 0x39F5 at 0x0556 0557 5B JUMPDEST 0558 61 PUSH2 0x118f 055B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x118f label_055C: // Incoming return from call to 0x0557 at 0x0556 055C 5B JUMPDEST 055D 00 *STOP // Stack delta = +0 // Outputs[1] { @055D stop(); } // Block terminates label_055E: // Incoming jump from 0x017B, if 0x6352211e == stack[-1] // Inputs[1] { @055F msg.value } 055E 5B JUMPDEST 055F 34 CALLVALUE 0560 80 DUP1 0561 15 ISZERO 0562 61 PUSH2 0x056a 0565 57 *JUMPI // Stack delta = +1 // Outputs[1] { @055F stack[0] = msg.value } // Block ends with conditional jump to 0x056a, if !msg.value label_0566: // Incoming jump from 0x0565, if not !msg.value // Inputs[1] { @0569 memory[0x00:0x00] } 0566 60 PUSH1 0x00 0568 80 DUP1 0569 FD *REVERT // Stack delta = +0 // Outputs[1] { @0569 revert(memory[0x00:0x00]); } // Block terminates label_056A: // Incoming jump from 0x0565, if !msg.value // Inputs[1] { @0572 msg.data.length } 056A 5B JUMPDEST 056B 50 POP 056C 61 PUSH2 0x0585 056F 60 PUSH1 0x04 0571 80 DUP1 0572 36 CALLDATASIZE 0573 03 SUB 0574 81 DUP2 0575 01 ADD 0576 90 SWAP1 0577 61 PUSH2 0x0580 057A 91 SWAP2 057B 90 SWAP1 057C 61 PUSH2 0x3a36 057F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @056C stack[-1] = 0x0585 // @057A stack[0] = 0x0580 // @057B stack[2] = 0x04 // @057B stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3a36, returns to 0x0580 label_0580: // Incoming return from call to 0x3A36 at 0x057F 0580 5B JUMPDEST 0581 61 PUSH2 0x1225 0584 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1225 label_0585: // Incoming return from call to 0x0580 at 0x057F // Inputs[2] // { // @0588 memory[0x40:0x60] // @058C stack[-1] // } 0585 5B JUMPDEST 0586 60 PUSH1 0x40 0588 51 MLOAD 0589 61 PUSH2 0x0592 058C 91 SWAP2 058D 90 SWAP1 058E 61 PUSH2 0x458b 0591 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @058C stack[-1] = 0x0592 // @058D stack[1] = memory[0x40:0x60] // @058D stack[0] = stack[-1] // } // Block ends with call to 0x458b, returns to 0x0592 label_0592: // Incoming return from call to 0x458B at 0x0591 // Inputs[3] // { // @0595 memory[0x40:0x60] // @0597 stack[-1] // @059A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0592 5B JUMPDEST 0593 60 PUSH1 0x40 0595 51 MLOAD 0596 80 DUP1 0597 91 SWAP2 0598 03 SUB 0599 90 SWAP1 059A F3 *RETURN // Stack delta = -1 // Outputs[1] { @059A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_059B: // Incoming jump from 0x0186, if 0x6373a6b1 == stack[-1] // Inputs[1] { @059C msg.value } 059B 5B JUMPDEST 059C 34 CALLVALUE 059D 80 DUP1 059E 15 ISZERO 059F 61 PUSH2 0x05a7 05A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @059C stack[0] = msg.value } // Block ends with conditional jump to 0x05a7, if !msg.value label_05A3: // Incoming jump from 0x05A2, if not !msg.value // Inputs[1] { @05A6 memory[0x00:0x00] } 05A3 60 PUSH1 0x00 05A5 80 DUP1 05A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A6 revert(memory[0x00:0x00]); } // Block terminates label_05A7: // Incoming jump from 0x05A2, if !msg.value 05A7 5B JUMPDEST 05A8 50 POP 05A9 61 PUSH2 0x05b0 05AC 61 PUSH2 0x12d7 05AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A9 stack[-1] = 0x05b0 } // Block ends with call to 0x12d7, returns to 0x05B0 label_05B0: // Incoming return from call to 0x12D7 at 0x05AF // Inputs[2] // { // @05B3 memory[0x40:0x60] // @05B7 stack[-1] // } 05B0 5B JUMPDEST 05B1 60 PUSH1 0x40 05B3 51 MLOAD 05B4 61 PUSH2 0x05bd 05B7 91 SWAP2 05B8 90 SWAP1 05B9 61 PUSH2 0x460d 05BC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05B7 stack[-1] = 0x05bd // @05B8 stack[1] = memory[0x40:0x60] // @05B8 stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x05BD label_05BD: // Incoming return from call to 0x460D at 0x05BC // Inputs[3] // { // @05C0 memory[0x40:0x60] // @05C2 stack[-1] // @05C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05BD 5B JUMPDEST 05BE 60 PUSH1 0x40 05C0 51 MLOAD 05C1 80 DUP1 05C2 91 SWAP2 05C3 03 SUB 05C4 90 SWAP1 05C5 F3 *RETURN // Stack delta = -1 // Outputs[1] { @05C5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_05C6: // Incoming jump from 0x0191, if 0x6955327d == stack[-1] // Inputs[1] { @05CD msg.data.length } 05C6 5B JUMPDEST 05C7 61 PUSH2 0x05e0 05CA 60 PUSH1 0x04 05CC 80 DUP1 05CD 36 CALLDATASIZE 05CE 03 SUB 05CF 81 DUP2 05D0 01 ADD 05D1 90 SWAP1 05D2 61 PUSH2 0x05db 05D5 91 SWAP2 05D6 90 SWAP1 05D7 61 PUSH2 0x3a36 05DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C7 stack[0] = 0x05e0 // @05D5 stack[1] = 0x05db // @05D6 stack[2] = 0x04 + (msg.data.length - 0x04) // @05D6 stack[3] = 0x04 // } // Block ends with call to 0x3a36, returns to 0x05DB label_05DB: // Incoming return from call to 0x3A36 at 0x05DA 05DB 5B JUMPDEST 05DC 61 PUSH2 0x1365 05DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1365 label_05E0: // Incoming return from call to 0x05DB at 0x05DA 05E0 5B JUMPDEST 05E1 00 *STOP // Stack delta = +0 // Outputs[1] { @05E1 stop(); } // Block terminates label_05E2: // Incoming jump from 0x0108, if 0x70a08231 == stack[-1] // Inputs[1] { @05E3 msg.value } 05E2 5B JUMPDEST 05E3 34 CALLVALUE 05E4 80 DUP1 05E5 15 ISZERO 05E6 61 PUSH2 0x05ee 05E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E3 stack[0] = msg.value } // Block ends with conditional jump to 0x05ee, if !msg.value label_05EA: // Incoming jump from 0x05E9, if not !msg.value // Inputs[1] { @05ED memory[0x00:0x00] } 05EA 60 PUSH1 0x00 05EC 80 DUP1 05ED FD *REVERT // Stack delta = +0 // Outputs[1] { @05ED revert(memory[0x00:0x00]); } // Block terminates label_05EE: // Incoming jump from 0x05E9, if !msg.value // Inputs[1] { @05F6 msg.data.length } 05EE 5B JUMPDEST 05EF 50 POP 05F0 61 PUSH2 0x0609 05F3 60 PUSH1 0x04 05F5 80 DUP1 05F6 36 CALLDATASIZE 05F7 03 SUB 05F8 81 DUP2 05F9 01 ADD 05FA 90 SWAP1 05FB 61 PUSH2 0x0604 05FE 91 SWAP2 05FF 90 SWAP1 0600 61 PUSH2 0x37fc 0603 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05F0 stack[-1] = 0x0609 // @05FE stack[0] = 0x0604 // @05FF stack[2] = 0x04 // @05FF stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x37fc, returns to 0x0604 label_0604: // Incoming return from call to 0x37FC at 0x0603 0604 5B JUMPDEST 0605 61 PUSH2 0x165c 0608 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x165c label_0609: // Incoming return from call to 0x0604 at 0x0603 // Inputs[2] // { // @060C memory[0x40:0x60] // @0610 stack[-1] // } 0609 5B JUMPDEST 060A 60 PUSH1 0x40 060C 51 MLOAD 060D 61 PUSH2 0x0616 0610 91 SWAP2 0611 90 SWAP1 0612 61 PUSH2 0x49af 0615 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0610 stack[-1] = 0x0616 // @0611 stack[1] = memory[0x40:0x60] // @0611 stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0616 label_0616: // Incoming return from call to 0x49AF at 0x0615 // Inputs[3] // { // @0619 memory[0x40:0x60] // @061B stack[-1] // @061E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0616 5B JUMPDEST 0617 60 PUSH1 0x40 0619 51 MLOAD 061A 80 DUP1 061B 91 SWAP2 061C 03 SUB 061D 90 SWAP1 061E F3 *RETURN // Stack delta = -1 // Outputs[1] { @061E return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_061F: // Incoming jump from 0x0113, if 0x715018a6 == stack[-1] // Inputs[1] { @0620 msg.value } 061F 5B JUMPDEST 0620 34 CALLVALUE 0621 80 DUP1 0622 15 ISZERO 0623 61 PUSH2 0x062b 0626 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0620 stack[0] = msg.value } // Block ends with conditional jump to 0x062b, if !msg.value label_0627: // Incoming jump from 0x0626, if not !msg.value // Inputs[1] { @062A memory[0x00:0x00] } 0627 60 PUSH1 0x00 0629 80 DUP1 062A FD *REVERT // Stack delta = +0 // Outputs[1] { @062A revert(memory[0x00:0x00]); } // Block terminates label_062B: // Incoming jump from 0x0626, if !msg.value 062B 5B JUMPDEST 062C 50 POP 062D 61 PUSH2 0x0634 0630 61 PUSH2 0x1714 0633 56 *JUMP // Stack delta = +0 // Outputs[1] { @062D stack[-1] = 0x0634 } // Block ends with call to 0x1714, returns to 0x0634 label_0634: // Incoming return from call to 0x1714 at 0x0633 0634 5B JUMPDEST 0635 00 *STOP // Stack delta = +0 // Outputs[1] { @0635 stop(); } // Block terminates label_0636: // Incoming jump from 0x011E, if 0x7a8baf52 == stack[-1] // Inputs[1] { @0637 msg.value } 0636 5B JUMPDEST 0637 34 CALLVALUE 0638 80 DUP1 0639 15 ISZERO 063A 61 PUSH2 0x0642 063D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0637 stack[0] = msg.value } // Block ends with conditional jump to 0x0642, if !msg.value label_063E: // Incoming jump from 0x063D, if not !msg.value // Inputs[1] { @0641 memory[0x00:0x00] } 063E 60 PUSH1 0x00 0640 80 DUP1 0641 FD *REVERT // Stack delta = +0 // Outputs[1] { @0641 revert(memory[0x00:0x00]); } // Block terminates label_0642: // Incoming jump from 0x063D, if !msg.value 0642 5B JUMPDEST 0643 50 POP 0644 61 PUSH2 0x064b 0647 61 PUSH2 0x179c 064A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0644 stack[-1] = 0x064b } // Block ends with call to 0x179c, returns to 0x064B label_064B: // Incoming return from call to 0x179C at 0x064A // Inputs[2] // { // @064E memory[0x40:0x60] // @0652 stack[-1] // } 064B 5B JUMPDEST 064C 60 PUSH1 0x40 064E 51 MLOAD 064F 61 PUSH2 0x0658 0652 91 SWAP2 0653 90 SWAP1 0654 61 PUSH2 0x49af 0657 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0652 stack[-1] = 0x0658 // @0653 stack[1] = memory[0x40:0x60] // @0653 stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0658 label_0658: // Incoming return from call to 0x49AF at 0x0657 // Inputs[3] // { // @065B memory[0x40:0x60] // @065D stack[-1] // @0660 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0658 5B JUMPDEST 0659 60 PUSH1 0x40 065B 51 MLOAD 065C 80 DUP1 065D 91 SWAP2 065E 03 SUB 065F 90 SWAP1 0660 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0660 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0661: // Incoming jump from 0x0129, if 0x7ff9b596 == stack[-1] // Inputs[1] { @0662 msg.value } 0661 5B JUMPDEST 0662 34 CALLVALUE 0663 80 DUP1 0664 15 ISZERO 0665 61 PUSH2 0x066d 0668 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0662 stack[0] = msg.value } // Block ends with conditional jump to 0x066d, if !msg.value label_0669: // Incoming jump from 0x0668, if not !msg.value // Inputs[1] { @066C memory[0x00:0x00] } 0669 60 PUSH1 0x00 066B 80 DUP1 066C FD *REVERT // Stack delta = +0 // Outputs[1] { @066C revert(memory[0x00:0x00]); } // Block terminates label_066D: // Incoming jump from 0x0668, if !msg.value 066D 5B JUMPDEST 066E 50 POP 066F 61 PUSH2 0x0676 0672 61 PUSH2 0x17a2 0675 56 *JUMP // Stack delta = +0 // Outputs[1] { @066F stack[-1] = 0x0676 } // Block ends with call to 0x17a2, returns to 0x0676 label_0676: // Incoming return from call to 0x17A2 at 0x0675 // Inputs[2] // { // @0679 memory[0x40:0x60] // @067D stack[-1] // } 0676 5B JUMPDEST 0677 60 PUSH1 0x40 0679 51 MLOAD 067A 61 PUSH2 0x0683 067D 91 SWAP2 067E 90 SWAP1 067F 61 PUSH2 0x49af 0682 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @067D stack[-1] = 0x0683 // @067E stack[1] = memory[0x40:0x60] // @067E stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0683 label_0683: // Incoming return from call to 0x49AF at 0x0682 // Inputs[3] // { // @0686 memory[0x40:0x60] // @0688 stack[-1] // @068B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0683 5B JUMPDEST 0684 60 PUSH1 0x40 0686 51 MLOAD 0687 80 DUP1 0688 91 SWAP2 0689 03 SUB 068A 90 SWAP1 068B F3 *RETURN // Stack delta = -1 // Outputs[1] { @068B return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_068C: // Incoming jump from 0x0134, if 0x8da5cb5b == stack[-1] // Inputs[1] { @068D msg.value } 068C 5B JUMPDEST 068D 34 CALLVALUE 068E 80 DUP1 068F 15 ISZERO 0690 61 PUSH2 0x0698 0693 57 *JUMPI // Stack delta = +1 // Outputs[1] { @068D stack[0] = msg.value } // Block ends with conditional jump to 0x0698, if !msg.value label_0694: // Incoming jump from 0x0693, if not !msg.value // Inputs[1] { @0697 memory[0x00:0x00] } 0694 60 PUSH1 0x00 0696 80 DUP1 0697 FD *REVERT // Stack delta = +0 // Outputs[1] { @0697 revert(memory[0x00:0x00]); } // Block terminates label_0698: // Incoming jump from 0x0693, if !msg.value 0698 5B JUMPDEST 0699 50 POP 069A 61 PUSH2 0x06a1 069D 61 PUSH2 0x17ae 06A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @069A stack[-1] = 0x06a1 } // Block ends with call to 0x17ae, returns to 0x06A1 label_06A1: // Incoming return from call to 0x17AE at 0x06A0 // Inputs[2] // { // @06A4 memory[0x40:0x60] // @06A8 stack[-1] // } 06A1 5B JUMPDEST 06A2 60 PUSH1 0x40 06A4 51 MLOAD 06A5 61 PUSH2 0x06ae 06A8 91 SWAP2 06A9 90 SWAP1 06AA 61 PUSH2 0x458b 06AD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06A8 stack[-1] = 0x06ae // @06A9 stack[1] = memory[0x40:0x60] // @06A9 stack[0] = stack[-1] // } // Block ends with call to 0x458b, returns to 0x06AE label_06AE: // Incoming return from call to 0x458B at 0x06AD // Inputs[3] // { // @06B1 memory[0x40:0x60] // @06B3 stack[-1] // @06B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 06AE 5B JUMPDEST 06AF 60 PUSH1 0x40 06B1 51 MLOAD 06B2 80 DUP1 06B3 91 SWAP2 06B4 03 SUB 06B5 90 SWAP1 06B6 F3 *RETURN // Stack delta = -1 // Outputs[1] { @06B6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_06B7: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @06B8 msg.value } 06B7 5B JUMPDEST 06B8 34 CALLVALUE 06B9 80 DUP1 06BA 15 ISZERO 06BB 61 PUSH2 0x06c3 06BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B8 stack[0] = msg.value } // Block ends with conditional jump to 0x06c3, if !msg.value label_06BF: // Incoming jump from 0x06BE, if not !msg.value // Inputs[1] { @06C2 memory[0x00:0x00] } 06BF 60 PUSH1 0x00 06C1 80 DUP1 06C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C2 revert(memory[0x00:0x00]); } // Block terminates label_06C3: // Incoming jump from 0x06BE, if !msg.value 06C3 5B JUMPDEST 06C4 50 POP 06C5 61 PUSH2 0x06cc 06C8 61 PUSH2 0x17d8 06CB 56 *JUMP // Stack delta = +0 // Outputs[1] { @06C5 stack[-1] = 0x06cc } // Block ends with call to 0x17d8, returns to 0x06CC label_06CC: // Incoming return from call to 0x17D8 at 0x06CB // Inputs[2] // { // @06CF memory[0x40:0x60] // @06D3 stack[-1] // } 06CC 5B JUMPDEST 06CD 60 PUSH1 0x40 06CF 51 MLOAD 06D0 61 PUSH2 0x06d9 06D3 91 SWAP2 06D4 90 SWAP1 06D5 61 PUSH2 0x460d 06D8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06D3 stack[-1] = 0x06d9 // @06D4 stack[1] = memory[0x40:0x60] // @06D4 stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x06D9 label_06D9: // Incoming return from call to 0x460D at 0x06D8 // Inputs[3] // { // @06DC memory[0x40:0x60] // @06DE stack[-1] // @06E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 06D9 5B JUMPDEST 06DA 60 PUSH1 0x40 06DC 51 MLOAD 06DD 80 DUP1 06DE 91 SWAP2 06DF 03 SUB 06E0 90 SWAP1 06E1 F3 *RETURN // Stack delta = -1 // Outputs[1] { @06E1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_06E2: // Incoming jump from 0x00D7, if 0xa22cb465 == stack[-1] // Inputs[1] { @06E3 msg.value } 06E2 5B JUMPDEST 06E3 34 CALLVALUE 06E4 80 DUP1 06E5 15 ISZERO 06E6 61 PUSH2 0x06ee 06E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E3 stack[0] = msg.value } // Block ends with conditional jump to 0x06ee, if !msg.value label_06EA: // Incoming jump from 0x06E9, if not !msg.value // Inputs[1] { @06ED memory[0x00:0x00] } 06EA 60 PUSH1 0x00 06EC 80 DUP1 06ED FD *REVERT // Stack delta = +0 // Outputs[1] { @06ED revert(memory[0x00:0x00]); } // Block terminates label_06EE: // Incoming jump from 0x06E9, if !msg.value // Inputs[1] { @06F6 msg.data.length } 06EE 5B JUMPDEST 06EF 50 POP 06F0 61 PUSH2 0x0709 06F3 60 PUSH1 0x04 06F5 80 DUP1 06F6 36 CALLDATASIZE 06F7 03 SUB 06F8 81 DUP2 06F9 01 ADD 06FA 90 SWAP1 06FB 61 PUSH2 0x0704 06FE 91 SWAP2 06FF 90 SWAP1 0700 61 PUSH2 0x392b 0703 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06F0 stack[-1] = 0x0709 // @06FE stack[0] = 0x0704 // @06FF stack[2] = 0x04 // @06FF stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x392b, returns to 0x0704 label_0704: // Incoming return from call to 0x392B at 0x0703 0704 5B JUMPDEST 0705 61 PUSH2 0x186a 0708 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x186a label_0709: // Incoming return from call to 0x0704 at 0x0703 0709 5B JUMPDEST 070A 00 *STOP // Stack delta = +0 // Outputs[1] { @070A stop(); } // Block terminates label_070B: // Incoming jump from 0x00E2, if 0xa475b5dd == stack[-1] // Inputs[1] { @070C msg.value } 070B 5B JUMPDEST 070C 34 CALLVALUE 070D 80 DUP1 070E 15 ISZERO 070F 61 PUSH2 0x0717 0712 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070C stack[0] = msg.value } // Block ends with conditional jump to 0x0717, if !msg.value label_0713: // Incoming jump from 0x0712, if not !msg.value // Inputs[1] { @0716 memory[0x00:0x00] } 0713 60 PUSH1 0x00 0715 80 DUP1 0716 FD *REVERT // Stack delta = +0 // Outputs[1] { @0716 revert(memory[0x00:0x00]); } // Block terminates label_0717: // Incoming jump from 0x0712, if !msg.value 0717 5B JUMPDEST 0718 50 POP 0719 61 PUSH2 0x0720 071C 61 PUSH2 0x19eb 071F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0719 stack[-1] = 0x0720 } // Block ends with call to 0x19eb, returns to 0x0720 label_0720: // Incoming return from call to 0x19EB at 0x071F 0720 5B JUMPDEST 0721 00 *STOP // Stack delta = +0 // Outputs[1] { @0721 stop(); } // Block terminates label_0722: // Incoming jump from 0x00ED, if 0xb7ced53b == stack[-1] // Inputs[1] { @0723 msg.value } 0722 5B JUMPDEST 0723 34 CALLVALUE 0724 80 DUP1 0725 15 ISZERO 0726 61 PUSH2 0x072e 0729 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0723 stack[0] = msg.value } // Block ends with conditional jump to 0x072e, if !msg.value label_072A: // Incoming jump from 0x0729, if not !msg.value // Inputs[1] { @072D memory[0x00:0x00] } 072A 60 PUSH1 0x00 072C 80 DUP1 072D FD *REVERT // Stack delta = +0 // Outputs[1] { @072D revert(memory[0x00:0x00]); } // Block terminates label_072E: // Incoming jump from 0x0729, if !msg.value // Inputs[1] { @0736 msg.data.length } 072E 5B JUMPDEST 072F 50 POP 0730 61 PUSH2 0x0749 0733 60 PUSH1 0x04 0735 80 DUP1 0736 36 CALLDATASIZE 0737 03 SUB 0738 81 DUP2 0739 01 ADD 073A 90 SWAP1 073B 61 PUSH2 0x0744 073E 91 SWAP2 073F 90 SWAP1 0740 61 PUSH2 0x37fc 0743 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0730 stack[-1] = 0x0749 // @073E stack[0] = 0x0744 // @073F stack[2] = 0x04 // @073F stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x37fc, returns to 0x0744 label_0744: // Incoming return from call to 0x37FC at 0x0743 0744 5B JUMPDEST 0745 61 PUSH2 0x1a84 0748 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a84 label_0749: // Incoming return from call to 0x0744 at 0x0743 0749 5B JUMPDEST 074A 00 *STOP // Stack delta = +0 // Outputs[1] { @074A stop(); } // Block terminates label_074B: // Incoming jump from 0x00F8, if 0xb88d4fde == stack[-1] // Inputs[1] { @074C msg.value } 074B 5B JUMPDEST 074C 34 CALLVALUE 074D 80 DUP1 074E 15 ISZERO 074F 61 PUSH2 0x0757 0752 57 *JUMPI // Stack delta = +1 // Outputs[1] { @074C stack[0] = msg.value } // Block ends with conditional jump to 0x0757, if !msg.value label_0753: // Incoming jump from 0x0752, if not !msg.value // Inputs[1] { @0756 memory[0x00:0x00] } 0753 60 PUSH1 0x00 0755 80 DUP1 0756 FD *REVERT // Stack delta = +0 // Outputs[1] { @0756 revert(memory[0x00:0x00]); } // Block terminates label_0757: // Incoming jump from 0x0752, if !msg.value // Inputs[1] { @075F msg.data.length } 0757 5B JUMPDEST 0758 50 POP 0759 61 PUSH2 0x0772 075C 60 PUSH1 0x04 075E 80 DUP1 075F 36 CALLDATASIZE 0760 03 SUB 0761 81 DUP2 0762 01 ADD 0763 90 SWAP1 0764 61 PUSH2 0x076d 0767 91 SWAP2 0768 90 SWAP1 0769 61 PUSH2 0x38b0 076C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0759 stack[-1] = 0x0772 // @0767 stack[0] = 0x076d // @0768 stack[2] = 0x04 // @0768 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x38b0, returns to 0x076D label_076D: // Incoming return from call to 0x38B0 at 0x076C 076D 5B JUMPDEST 076E 61 PUSH2 0x1b92 0771 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b92 label_0772: // Incoming return from call to 0x076D at 0x076C // Incoming return from call to 0x076D at 0x076C 0772 5B JUMPDEST 0773 00 *STOP // Stack delta = +0 // Outputs[1] { @0773 stop(); } // Block terminates label_0774: // Incoming jump from 0x0085, if 0xc634d032 == stack[-1] // Inputs[1] { @077B msg.data.length } 0774 5B JUMPDEST 0775 61 PUSH2 0x078e 0778 60 PUSH1 0x04 077A 80 DUP1 077B 36 CALLDATASIZE 077C 03 SUB 077D 81 DUP2 077E 01 ADD 077F 90 SWAP1 0780 61 PUSH2 0x0789 0783 91 SWAP2 0784 90 SWAP1 0785 61 PUSH2 0x3a36 0788 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0775 stack[0] = 0x078e // @0783 stack[1] = 0x0789 // @0784 stack[2] = 0x04 + (msg.data.length - 0x04) // @0784 stack[3] = 0x04 // } // Block ends with call to 0x3a36, returns to 0x0789 label_0789: // Incoming return from call to 0x3A36 at 0x0788 0789 5B JUMPDEST 078A 61 PUSH2 0x1bf4 078D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1bf4 label_078E: // Incoming return from call to 0x0789 at 0x0788 078E 5B JUMPDEST 078F 00 *STOP // Stack delta = +0 // Outputs[1] { @078F stop(); } // Block terminates label_0790: // Incoming jump from 0x0090, if 0xc6682862 == stack[-1] // Inputs[1] { @0791 msg.value } 0790 5B JUMPDEST 0791 34 CALLVALUE 0792 80 DUP1 0793 15 ISZERO 0794 61 PUSH2 0x079c 0797 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0791 stack[0] = msg.value } // Block ends with conditional jump to 0x079c, if !msg.value label_0798: // Incoming jump from 0x0797, if not !msg.value // Inputs[1] { @079B memory[0x00:0x00] } 0798 60 PUSH1 0x00 079A 80 DUP1 079B FD *REVERT // Stack delta = +0 // Outputs[1] { @079B revert(memory[0x00:0x00]); } // Block terminates label_079C: // Incoming jump from 0x0797, if !msg.value 079C 5B JUMPDEST 079D 50 POP 079E 61 PUSH2 0x07a5 07A1 61 PUSH2 0x1e9b 07A4 56 *JUMP // Stack delta = +0 // Outputs[1] { @079E stack[-1] = 0x07a5 } // Block ends with call to 0x1e9b, returns to 0x07A5 label_07A5: // Incoming return from call to 0x1E9B at 0x07A4 // Inputs[2] // { // @07A8 memory[0x40:0x60] // @07AC stack[-1] // } 07A5 5B JUMPDEST 07A6 60 PUSH1 0x40 07A8 51 MLOAD 07A9 61 PUSH2 0x07b2 07AC 91 SWAP2 07AD 90 SWAP1 07AE 61 PUSH2 0x460d 07B1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07AC stack[-1] = 0x07b2 // @07AD stack[1] = memory[0x40:0x60] // @07AD stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x07B2 label_07B2: // Incoming return from call to 0x460D at 0x07B1 // Inputs[3] // { // @07B5 memory[0x40:0x60] // @07B7 stack[-1] // @07BA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 07B2 5B JUMPDEST 07B3 60 PUSH1 0x40 07B5 51 MLOAD 07B6 80 DUP1 07B7 91 SWAP2 07B8 03 SUB 07B9 90 SWAP1 07BA F3 *RETURN // Stack delta = -1 // Outputs[1] { @07BA return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_07BB: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @07BC msg.value } 07BB 5B JUMPDEST 07BC 34 CALLVALUE 07BD 80 DUP1 07BE 15 ISZERO 07BF 61 PUSH2 0x07c7 07C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07BC stack[0] = msg.value } // Block ends with conditional jump to 0x07c7, if !msg.value label_07C3: // Incoming jump from 0x07C2, if not !msg.value // Inputs[1] { @07C6 memory[0x00:0x00] } 07C3 60 PUSH1 0x00 07C5 80 DUP1 07C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C6 revert(memory[0x00:0x00]); } // Block terminates label_07C7: // Incoming jump from 0x07C2, if !msg.value // Inputs[1] { @07CF msg.data.length } 07C7 5B JUMPDEST 07C8 50 POP 07C9 61 PUSH2 0x07e2 07CC 60 PUSH1 0x04 07CE 80 DUP1 07CF 36 CALLDATASIZE 07D0 03 SUB 07D1 81 DUP2 07D2 01 ADD 07D3 90 SWAP1 07D4 61 PUSH2 0x07dd 07D7 91 SWAP2 07D8 90 SWAP1 07D9 61 PUSH2 0x3a36 07DC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07C9 stack[-1] = 0x07e2 // @07D7 stack[0] = 0x07dd // @07D8 stack[2] = 0x04 // @07D8 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3a36, returns to 0x07DD label_07DD: // Incoming return from call to 0x3A36 at 0x07DC 07DD 5B JUMPDEST 07DE 61 PUSH2 0x1f29 07E1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1f29 label_07E2: // Incoming return from call to 0x07DD at 0x07DC // Inputs[2] // { // @07E5 memory[0x40:0x60] // @07E9 stack[-1] // } 07E2 5B JUMPDEST 07E3 60 PUSH1 0x40 07E5 51 MLOAD 07E6 61 PUSH2 0x07ef 07E9 91 SWAP2 07EA 90 SWAP1 07EB 61 PUSH2 0x460d 07EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07E9 stack[-1] = 0x07ef // @07EA stack[1] = memory[0x40:0x60] // @07EA stack[0] = stack[-1] // } // Block ends with call to 0x460d, returns to 0x07EF label_07EF: // Incoming return from call to 0x460D at 0x07EE // Inputs[3] // { // @07F2 memory[0x40:0x60] // @07F4 stack[-1] // @07F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 07EF 5B JUMPDEST 07F0 60 PUSH1 0x40 07F2 51 MLOAD 07F3 80 DUP1 07F4 91 SWAP2 07F5 03 SUB 07F6 90 SWAP1 07F7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @07F7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_07F8: // Incoming jump from 0x00A6, if 0xe985e9c5 == stack[-1] // Inputs[1] { @07F9 msg.value } 07F8 5B JUMPDEST 07F9 34 CALLVALUE 07FA 80 DUP1 07FB 15 ISZERO 07FC 61 PUSH2 0x0804 07FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0804, if !msg.value label_0800: // Incoming jump from 0x07FF, if not !msg.value // Inputs[1] { @0803 memory[0x00:0x00] } 0800 60 PUSH1 0x00 0802 80 DUP1 0803 FD *REVERT // Stack delta = +0 // Outputs[1] { @0803 revert(memory[0x00:0x00]); } // Block terminates label_0804: // Incoming jump from 0x07FF, if !msg.value // Inputs[1] { @080C msg.data.length } 0804 5B JUMPDEST 0805 50 POP 0806 61 PUSH2 0x081f 0809 60 PUSH1 0x04 080B 80 DUP1 080C 36 CALLDATASIZE 080D 03 SUB 080E 81 DUP2 080F 01 ADD 0810 90 SWAP1 0811 61 PUSH2 0x081a 0814 91 SWAP2 0815 90 SWAP1 0816 61 PUSH2 0x3825 0819 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0806 stack[-1] = 0x081f // @0814 stack[0] = 0x081a // @0815 stack[2] = 0x04 // @0815 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x3825, returns to 0x081A label_081A: // Incoming return from call to 0x3825 at 0x0819 081A 5B JUMPDEST 081B 61 PUSH2 0x2082 081E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2082 label_081F: // Incoming return from call to 0x081A at 0x0819 // Inputs[2] // { // @0822 memory[0x40:0x60] // @0826 stack[-1] // } 081F 5B JUMPDEST 0820 60 PUSH1 0x40 0822 51 MLOAD 0823 61 PUSH2 0x082c 0826 91 SWAP2 0827 90 SWAP1 0828 61 PUSH2 0x45f2 082B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0826 stack[-1] = 0x082c // @0827 stack[1] = memory[0x40:0x60] // @0827 stack[0] = stack[-1] // } // Block ends with call to 0x45f2, returns to 0x082C label_082C: // Incoming return from call to 0x45F2 at 0x082B // Inputs[3] // { // @082F memory[0x40:0x60] // @0831 stack[-1] // @0834 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 082C 5B JUMPDEST 082D 60 PUSH1 0x40 082F 51 MLOAD 0830 80 DUP1 0831 91 SWAP2 0832 03 SUB 0833 90 SWAP1 0834 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0834 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0835: // Incoming jump from 0x00B1, if 0xeb8d2444 == stack[-1] // Inputs[1] { @0836 msg.value } 0835 5B JUMPDEST 0836 34 CALLVALUE 0837 80 DUP1 0838 15 ISZERO 0839 61 PUSH2 0x0841 083C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0836 stack[0] = msg.value } // Block ends with conditional jump to 0x0841, if !msg.value label_083D: // Incoming jump from 0x083C, if not !msg.value // Inputs[1] { @0840 memory[0x00:0x00] } 083D 60 PUSH1 0x00 083F 80 DUP1 0840 FD *REVERT // Stack delta = +0 // Outputs[1] { @0840 revert(memory[0x00:0x00]); } // Block terminates label_0841: // Incoming jump from 0x083C, if !msg.value 0841 5B JUMPDEST 0842 50 POP 0843 61 PUSH2 0x084a 0846 61 PUSH2 0x2116 0849 56 *JUMP // Stack delta = +0 // Outputs[1] { @0843 stack[-1] = 0x084a } // Block ends with call to 0x2116, returns to 0x084A label_084A: // Incoming return from call to 0x2116 at 0x0849 // Inputs[2] // { // @084D memory[0x40:0x60] // @0851 stack[-1] // } 084A 5B JUMPDEST 084B 60 PUSH1 0x40 084D 51 MLOAD 084E 61 PUSH2 0x0857 0851 91 SWAP2 0852 90 SWAP1 0853 61 PUSH2 0x45f2 0856 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0851 stack[-1] = 0x0857 // @0852 stack[1] = memory[0x40:0x60] // @0852 stack[0] = stack[-1] // } // Block ends with call to 0x45f2, returns to 0x0857 label_0857: // Incoming return from call to 0x45F2 at 0x0856 // Inputs[3] // { // @085A memory[0x40:0x60] // @085C stack[-1] // @085F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0857 5B JUMPDEST 0858 60 PUSH1 0x40 085A 51 MLOAD 085B 80 DUP1 085C 91 SWAP2 085D 03 SUB 085E 90 SWAP1 085F F3 *RETURN // Stack delta = -1 // Outputs[1] { @085F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0860: // Incoming jump from 0x003E, if 0xefa5860a == stack[-1] // Inputs[1] { @0861 msg.value } 0860 5B JUMPDEST 0861 34 CALLVALUE 0862 80 DUP1 0863 15 ISZERO 0864 61 PUSH2 0x086c 0867 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0861 stack[0] = msg.value } // Block ends with conditional jump to 0x086c, if !msg.value label_0868: // Incoming jump from 0x0867, if not !msg.value // Inputs[1] { @086B memory[0x00:0x00] } 0868 60 PUSH1 0x00 086A 80 DUP1 086B FD *REVERT // Stack delta = +0 // Outputs[1] { @086B revert(memory[0x00:0x00]); } // Block terminates label_086C: // Incoming jump from 0x0867, if !msg.value 086C 5B JUMPDEST 086D 50 POP 086E 61 PUSH2 0x0875 0871 61 PUSH2 0x2129 0874 56 *JUMP // Stack delta = +0 // Outputs[1] { @086E stack[-1] = 0x0875 } // Block ends with call to 0x2129, returns to 0x0875 label_0875: // Incoming return from call to 0x2129 at 0x0874 // Inputs[2] // { // @0878 memory[0x40:0x60] // @087C stack[-1] // } 0875 5B JUMPDEST 0876 60 PUSH1 0x40 0878 51 MLOAD 0879 61 PUSH2 0x0882 087C 91 SWAP2 087D 90 SWAP1 087E 61 PUSH2 0x49af 0881 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @087C stack[-1] = 0x0882 // @087D stack[1] = memory[0x40:0x60] // @087D stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0882 label_0882: // Incoming return from call to 0x49AF at 0x0881 // Inputs[3] // { // @0885 memory[0x40:0x60] // @0887 stack[-1] // @088A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0882 5B JUMPDEST 0883 60 PUSH1 0x40 0885 51 MLOAD 0886 80 DUP1 0887 91 SWAP2 0888 03 SUB 0889 90 SWAP1 088A F3 *RETURN // Stack delta = -1 // Outputs[1] { @088A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_088B: // Incoming jump from 0x0049, if 0xf0325549 == stack[-1] // Inputs[1] { @088C msg.value } 088B 5B JUMPDEST 088C 34 CALLVALUE 088D 80 DUP1 088E 15 ISZERO 088F 61 PUSH2 0x0897 0892 57 *JUMPI // Stack delta = +1 // Outputs[1] { @088C stack[0] = msg.value } // Block ends with conditional jump to 0x0897, if !msg.value label_0893: // Incoming jump from 0x0892, if not !msg.value // Inputs[1] { @0896 memory[0x00:0x00] } 0893 60 PUSH1 0x00 0895 80 DUP1 0896 FD *REVERT // Stack delta = +0 // Outputs[1] { @0896 revert(memory[0x00:0x00]); } // Block terminates label_0897: // Incoming jump from 0x0892, if !msg.value 0897 5B JUMPDEST 0898 50 POP 0899 61 PUSH2 0x08a0 089C 61 PUSH2 0x212e 089F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0899 stack[-1] = 0x08a0 } // Block ends with call to 0x212e, returns to 0x08A0 label_08A0: // Incoming return from call to 0x212E at 0x089F 08A0 5B JUMPDEST 08A1 00 *STOP // Stack delta = +0 // Outputs[1] { @08A1 stop(); } // Block terminates label_08A2: // Incoming jump from 0x0054, if 0xf2c4ce1e == stack[-1] // Inputs[1] { @08A3 msg.value } 08A2 5B JUMPDEST 08A3 34 CALLVALUE 08A4 80 DUP1 08A5 15 ISZERO 08A6 61 PUSH2 0x08ae 08A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08A3 stack[0] = msg.value } // Block ends with conditional jump to 0x08ae, if !msg.value label_08AA: // Incoming jump from 0x08A9, if not !msg.value // Inputs[1] { @08AD memory[0x00:0x00] } 08AA 60 PUSH1 0x00 08AC 80 DUP1 08AD FD *REVERT // Stack delta = +0 // Outputs[1] { @08AD revert(memory[0x00:0x00]); } // Block terminates label_08AE: // Incoming jump from 0x08A9, if !msg.value // Inputs[1] { @08B6 msg.data.length } 08AE 5B JUMPDEST 08AF 50 POP 08B0 61 PUSH2 0x08c9 08B3 60 PUSH1 0x04 08B5 80 DUP1 08B6 36 CALLDATASIZE 08B7 03 SUB 08B8 81 DUP2 08B9 01 ADD 08BA 90 SWAP1 08BB 61 PUSH2 0x08c4 08BE 91 SWAP2 08BF 90 SWAP1 08C0 61 PUSH2 0x39f5 08C3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @08B0 stack[-1] = 0x08c9 // @08BE stack[0] = 0x08c4 // @08BF stack[2] = 0x04 // @08BF stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x39f5, returns to 0x08C4 label_08C4: // Incoming return from call to 0x39F5 at 0x08C3 08C4 5B JUMPDEST 08C5 61 PUSH2 0x21d6 08C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x21d6 label_08C9: // Incoming return from call to 0x08C4 at 0x08C3 08C9 5B JUMPDEST 08CA 00 *STOP // Stack delta = +0 // Outputs[1] { @08CA stop(); } // Block terminates label_08CB: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @08CC msg.value } 08CB 5B JUMPDEST 08CC 34 CALLVALUE 08CD 80 DUP1 08CE 15 ISZERO 08CF 61 PUSH2 0x08d7 08D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08CC stack[0] = msg.value } // Block ends with conditional jump to 0x08d7, if !msg.value label_08D3: // Incoming jump from 0x08D2, if not !msg.value // Inputs[1] { @08D6 memory[0x00:0x00] } 08D3 60 PUSH1 0x00 08D5 80 DUP1 08D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @08D6 revert(memory[0x00:0x00]); } // Block terminates label_08D7: // Incoming jump from 0x08D2, if !msg.value // Inputs[1] { @08DF msg.data.length } 08D7 5B JUMPDEST 08D8 50 POP 08D9 61 PUSH2 0x08f2 08DC 60 PUSH1 0x04 08DE 80 DUP1 08DF 36 CALLDATASIZE 08E0 03 SUB 08E1 81 DUP2 08E2 01 ADD 08E3 90 SWAP1 08E4 61 PUSH2 0x08ed 08E7 91 SWAP2 08E8 90 SWAP1 08E9 61 PUSH2 0x37fc 08EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @08D9 stack[-1] = 0x08f2 // @08E7 stack[0] = 0x08ed // @08E8 stack[2] = 0x04 // @08E8 stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x37fc, returns to 0x08ED label_08ED: // Incoming return from call to 0x37FC at 0x08EC 08ED 5B JUMPDEST 08EE 61 PUSH2 0x226c 08F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x226c label_08F2: // Incoming return from call to 0x08ED at 0x08EC 08F2 5B JUMPDEST 08F3 00 *STOP // Stack delta = +0 // Outputs[1] { @08F3 stop(); } // Block terminates label_08F4: // Incoming jump from 0x006A, if 0xf47c84c5 == stack[-1] // Inputs[1] { @08F5 msg.value } 08F4 5B JUMPDEST 08F5 34 CALLVALUE 08F6 80 DUP1 08F7 15 ISZERO 08F8 61 PUSH2 0x0900 08FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08F5 stack[0] = msg.value } // Block ends with conditional jump to 0x0900, if !msg.value label_08FC: // Incoming jump from 0x08FB, if not !msg.value // Inputs[1] { @08FF memory[0x00:0x00] } 08FC 60 PUSH1 0x00 08FE 80 DUP1 08FF FD *REVERT // Stack delta = +0 // Outputs[1] { @08FF revert(memory[0x00:0x00]); } // Block terminates label_0900: // Incoming jump from 0x08FB, if !msg.value 0900 5B JUMPDEST 0901 50 POP 0902 61 PUSH2 0x0909 0905 61 PUSH2 0x2364 0908 56 *JUMP // Stack delta = +0 // Outputs[1] { @0902 stack[-1] = 0x0909 } // Block ends with call to 0x2364, returns to 0x0909 label_0909: // Incoming return from call to 0x2364 at 0x0908 // Inputs[2] // { // @090C memory[0x40:0x60] // @0910 stack[-1] // } 0909 5B JUMPDEST 090A 60 PUSH1 0x40 090C 51 MLOAD 090D 61 PUSH2 0x0916 0910 91 SWAP2 0911 90 SWAP1 0912 61 PUSH2 0x49af 0915 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0910 stack[-1] = 0x0916 // @0911 stack[1] = memory[0x40:0x60] // @0911 stack[0] = stack[-1] // } // Block ends with call to 0x49af, returns to 0x0916 label_0916: // Incoming return from call to 0x49AF at 0x0915 // Inputs[3] // { // @0919 memory[0x40:0x60] // @091B stack[-1] // @091E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0916 5B JUMPDEST 0917 60 PUSH1 0x40 0919 51 MLOAD 091A 80 DUP1 091B 91 SWAP2 091C 03 SUB 091D 90 SWAP1 091E F3 *RETURN // Stack delta = -1 // Outputs[1] { @091E return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_091F: // Incoming jump from 0x0075, if 0xffe630b5 == stack[-1] // Inputs[1] { @0920 msg.value } 091F 5B JUMPDEST 0920 34 CALLVALUE 0921 80 DUP1 0922 15 ISZERO 0923 61 PUSH2 0x092b 0926 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0920 stack[0] = msg.value } // Block ends with conditional jump to 0x092b, if !msg.value label_0927: // Incoming jump from 0x0926, if not !msg.value // Inputs[1] { @092A memory[0x00:0x00] } 0927 60 PUSH1 0x00 0929 80 DUP1 092A FD *REVERT // Stack delta = +0 // Outputs[1] { @092A revert(memory[0x00:0x00]); } // Block terminates label_092B: // Incoming jump from 0x0926, if !msg.value // Inputs[1] { @0933 msg.data.length } 092B 5B JUMPDEST 092C 50 POP 092D 61 PUSH2 0x0946 0930 60 PUSH1 0x04 0932 80 DUP1 0933 36 CALLDATASIZE 0934 03 SUB 0935 81 DUP2 0936 01 ADD 0937 90 SWAP1 0938 61 PUSH2 0x0941 093B 91 SWAP2 093C 90 SWAP1 093D 61 PUSH2 0x39f5 0940 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @092D stack[-1] = 0x0946 // @093B stack[0] = 0x0941 // @093C stack[2] = 0x04 // @093C stack[1] = 0x04 + (msg.data.length - 0x04) // } // Block ends with call to 0x39f5, returns to 0x0941 label_0941: // Incoming return from call to 0x39F5 at 0x0940 0941 5B JUMPDEST 0942 61 PUSH2 0x236a 0945 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x236a label_0946: // Incoming return from call to 0x0941 at 0x0940 0946 5B JUMPDEST 0947 00 *STOP // Stack delta = +0 // Outputs[1] { @0947 stop(); } // Block terminates label_0948: // Incoming jump from 0x027C // Inputs[1] { @094E stack[-1] } 0948 5B JUMPDEST 0949 60 PUSH1 0x00 094B 61 PUSH2 0x0953 094E 82 DUP3 094F 61 PUSH2 0x2400 0952 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0949 stack[0] = 0x00 // @094B stack[1] = 0x0953 // @094E stack[2] = stack[-1] // } // Block ends with call to 0x2400, returns to 0x0953 label_0953: // Incoming return from call to 0x2400 at 0x0952 // Inputs[4] // { // @0954 stack[-2] // @0954 stack[-1] // @0956 stack[-4] // @0957 stack[-3] // } 0953 5B JUMPDEST 0954 90 SWAP1 0955 50 POP 0956 91 SWAP2 0957 90 SWAP1 0958 50 POP 0959 56 *JUMP // Stack delta = -3 // Outputs[1] { @0956 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_095A: // Incoming call from 0x02A7, returns to 0x02A8 // Inputs[1] { @0960 storage[0x00] } 095A 5B JUMPDEST 095B 60 PUSH1 0x60 095D 60 PUSH1 0x00 095F 80 DUP1 0960 54 SLOAD 0961 61 PUSH2 0x0969 0964 90 SWAP1 0965 61 PUSH2 0x4c7e 0968 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @095B stack[0] = 0x60 // @095D stack[1] = 0x00 // @0964 stack[2] = 0x0969 // @0964 stack[3] = storage[0x00] // } // Block ends with call to 0x4c7e, returns to 0x0969 label_0969: // Incoming return from call to 0x4C7E at 0x0968 // Inputs[4] // { // @096A stack[-1] // @0979 memory[0x40:0x60] // @0981 stack[-2] // @098C storage[stack[-2]] // } 0969 5B JUMPDEST 096A 80 DUP1 096B 60 PUSH1 0x1f 096D 01 ADD 096E 60 PUSH1 0x20 0970 80 DUP1 0971 91 SWAP2 0972 04 DIV 0973 02 MUL 0974 60 PUSH1 0x20 0976 01 ADD 0977 60 PUSH1 0x40 0979 51 MLOAD 097A 90 SWAP1 097B 81 DUP2 097C 01 ADD 097D 60 PUSH1 0x40 097F 52 MSTORE 0980 80 DUP1 0981 92 SWAP3 0982 91 SWAP2 0983 90 SWAP1 0984 81 DUP2 0985 81 DUP2 0986 52 MSTORE 0987 60 PUSH1 0x20 0989 01 ADD 098A 82 DUP3 098B 80 DUP1 098C 54 SLOAD 098D 61 PUSH2 0x0995 0990 90 SWAP1 0991 61 PUSH2 0x4c7e 0994 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @097F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0981 stack[-2] = memory[0x40:0x60] // @0982 stack[-1] = stack[-2] // @0983 stack[0] = stack[-1] // @0986 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0989 stack[1] = 0x20 + memory[0x40:0x60] // @098A stack[2] = stack[-2] // @0990 stack[4] = storage[stack[-2]] // @0990 stack[3] = 0x0995 // } // Block ends with call to 0x4c7e, returns to 0x0995 label_0995: // Incoming return from call to 0x4C7E at 0x0994 // Inputs[1] { @0996 stack[-1] } 0995 5B JUMPDEST 0996 80 DUP1 0997 15 ISZERO 0998 61 PUSH2 0x09e2 099B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09e2, if !stack[-1] label_099C: // Incoming jump from 0x099B, if not !stack[-1] // Inputs[1] { @099C stack[-1] } 099C 80 DUP1 099D 60 PUSH1 0x1f 099F 10 LT 09A0 61 PUSH2 0x09b7 09A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b7, if 0x1f < stack[-1] label_09A4: // Incoming jump from 0x09A3, if not 0x1f < stack[-1] // Inputs[4] // { // @09A8 stack[-2] // @09A9 storage[stack[-2]] // @09AC stack[-3] // @09AE stack[-1] // } 09A4 61 PUSH2 0x0100 09A7 80 DUP1 09A8 83 DUP4 09A9 54 SLOAD 09AA 04 DIV 09AB 02 MUL 09AC 83 DUP4 09AD 52 MSTORE 09AE 91 SWAP2 09AF 60 PUSH1 0x20 09B1 01 ADD 09B2 91 SWAP2 09B3 61 PUSH2 0x09e2 09B6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09AD memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09B2 stack[-1] = stack[-1] // @09B2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x09e2 label_09B7: // Incoming jump from 0x09A3, if 0x1f < stack[-1] // Inputs[5] // { // @09B8 stack[-3] // @09B9 stack[-1] // @09BB stack[-2] // @09C3 memory[0x00:0x20] // @09C7 storage[keccak256(memory[0x00:0x20])] // } 09B7 5B JUMPDEST 09B8 82 DUP3 09B9 01 ADD 09BA 91 SWAP2 09BB 90 SWAP1 09BC 60 PUSH1 0x00 09BE 52 MSTORE 09BF 60 PUSH1 0x20 09C1 60 PUSH1 0x00 09C3 20 SHA3 09C4 90 SWAP1 09C5 5B JUMPDEST 09C6 81 DUP2 09C7 54 SLOAD 09C8 81 DUP2 09C9 52 MSTORE 09CA 90 SWAP1 09CB 60 PUSH1 0x01 09CD 01 ADD 09CE 90 SWAP1 09CF 60 PUSH1 0x20 09D1 01 ADD 09D2 80 DUP1 09D3 83 DUP4 09D4 11 GT 09D5 61 PUSH2 0x09c5 09D8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09BA stack[-3] = stack[-3] + stack[-1] // @09BE memory[0x00:0x20] = stack[-2] // @09C9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09CE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09D1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09c5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09D9: // Incoming jump from 0x09D8, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x09D8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @09D9 stack[-3] // @09DA stack[-1] // } 09D9 82 DUP3 09DA 90 SWAP1 09DB 03 SUB 09DC 60 PUSH1 0x1f 09DE 16 AND 09DF 82 DUP3 09E0 01 ADD 09E1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @09E1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @09E1 stack[-1] = stack[-3] // } // Block continues label_09E2: // Incoming jump from 0x09B6 // Incoming jump from 0x09E1 // Incoming jump from 0x099B, if !stack[-1] // Inputs[3] // { // @09E8 stack[-7] // @09E8 stack[-6] // @09EA stack[-8] // } 09E2 5B JUMPDEST 09E3 50 POP 09E4 50 POP 09E5 50 POP 09E6 50 POP 09E7 50 POP 09E8 90 SWAP1 09E9 50 POP 09EA 90 SWAP1 09EB 56 *JUMP // Stack delta = -7 // Outputs[1] { @09EA stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_09EC: // Incoming jump from 0x02E4 // Incoming call from 0x2652, returns to 0x2653 // Inputs[1] { @09F2 stack[-1] } 09EC 5B JUMPDEST 09ED 60 PUSH1 0x00 09EF 61 PUSH2 0x09f7 09F2 82 DUP3 09F3 61 PUSH2 0x247a 09F6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09ED stack[0] = 0x00 // @09EF stack[1] = 0x09f7 // @09F2 stack[2] = stack[-1] // } // Block ends with call to 0x247a, returns to 0x09F7 label_09F7: // Incoming return from call to 0x247A at 0x09F6 // Inputs[1] { @09FB stack[-1] } 09F7 5B JUMPDEST 09F8 61 PUSH2 0x0a36 09FB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a36, if stack[-1] label_09FC: // Incoming jump from 0x09FB, if not stack[-1] // Inputs[1] { @09FE memory[0x40:0x60] } 09FC 60 PUSH1 0x40 09FE 51 MLOAD 09FF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A20 81 DUP2 0A21 52 MSTORE 0A22 60 PUSH1 0x04 0A24 01 ADD 0A25 61 PUSH2 0x0a2d 0A28 90 SWAP1 0A29 61 PUSH2 0x486f 0A2C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A28 stack[0] = 0x0a2d // @0A28 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x486f, returns to 0x0A2D label_0A2D: // Incoming return from call to 0x486F at 0x0A2C // Inputs[3] // { // @0A30 memory[0x40:0x60] // @0A32 stack[-1] // @0A35 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A2D 5B JUMPDEST 0A2E 60 PUSH1 0x40 0A30 51 MLOAD 0A31 80 DUP1 0A32 91 SWAP2 0A33 03 SUB 0A34 90 SWAP1 0A35 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A35 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A36: // Incoming jump from 0x09FB, if stack[-1] // Inputs[5] // { // @0A3B stack[-2] // @0A49 memory[0x00:0x40] // @0A4D storage[keccak256(memory[0x00:0x40])] // @0A6B stack[-1] // @0A6D stack[-3] // } 0A36 5B JUMPDEST 0A37 60 PUSH1 0x04 0A39 60 PUSH1 0x00 0A3B 83 DUP4 0A3C 81 DUP2 0A3D 52 MSTORE 0A3E 60 PUSH1 0x20 0A40 01 ADD 0A41 90 SWAP1 0A42 81 DUP2 0A43 52 MSTORE 0A44 60 PUSH1 0x20 0A46 01 ADD 0A47 60 PUSH1 0x00 0A49 20 SHA3 0A4A 60 PUSH1 0x00 0A4C 90 SWAP1 0A4D 54 SLOAD 0A4E 90 SWAP1 0A4F 61 PUSH2 0x0100 0A52 0A EXP 0A53 90 SWAP1 0A54 04 DIV 0A55 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A6A 16 AND 0A6B 90 SWAP1 0A6C 50 POP 0A6D 91 SWAP2 0A6E 90 SWAP1 0A6F 50 POP 0A70 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A3D memory[0x00:0x20] = stack[-2] // @0A43 memory[0x20:0x40] = 0x04 // @0A6D stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0A71: // Incoming call from 0x030F, returns to 0x0310 // Inputs[1] { @0A75 storage[0x0e] } 0A71 5B JUMPDEST 0A72 60 PUSH1 0x0e 0A74 80 DUP1 0A75 54 SLOAD 0A76 61 PUSH2 0x0a7e 0A79 90 SWAP1 0A7A 61 PUSH2 0x4c7e 0A7D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A72 stack[0] = 0x0e // @0A79 stack[1] = 0x0a7e // @0A79 stack[2] = storage[0x0e] // } // Block ends with call to 0x4c7e, returns to 0x0A7E label_0A7E: // Incoming return from call to 0x4C7E at 0x0A7D // Inputs[4] // { // @0A7F stack[-1] // @0A8E memory[0x40:0x60] // @0A96 stack[-2] // @0AA1 storage[stack[-2]] // } 0A7E 5B JUMPDEST 0A7F 80 DUP1 0A80 60 PUSH1 0x1f 0A82 01 ADD 0A83 60 PUSH1 0x20 0A85 80 DUP1 0A86 91 SWAP2 0A87 04 DIV 0A88 02 MUL 0A89 60 PUSH1 0x20 0A8B 01 ADD 0A8C 60 PUSH1 0x40 0A8E 51 MLOAD 0A8F 90 SWAP1 0A90 81 DUP2 0A91 01 ADD 0A92 60 PUSH1 0x40 0A94 52 MSTORE 0A95 80 DUP1 0A96 92 SWAP3 0A97 91 SWAP2 0A98 90 SWAP1 0A99 81 DUP2 0A9A 81 DUP2 0A9B 52 MSTORE 0A9C 60 PUSH1 0x20 0A9E 01 ADD 0A9F 82 DUP3 0AA0 80 DUP1 0AA1 54 SLOAD 0AA2 61 PUSH2 0x0aaa 0AA5 90 SWAP1 0AA6 61 PUSH2 0x4c7e 0AA9 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0A94 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0A96 stack[-2] = memory[0x40:0x60] // @0A97 stack[-1] = stack[-2] // @0A98 stack[0] = stack[-1] // @0A9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A9E stack[1] = 0x20 + memory[0x40:0x60] // @0A9F stack[2] = stack[-2] // @0AA5 stack[4] = storage[stack[-2]] // @0AA5 stack[3] = 0x0aaa // } // Block ends with call to 0x4c7e, returns to 0x0AAA label_0AAA: // Incoming return from call to 0x4C7E at 0x0AA9 // Inputs[1] { @0AAB stack[-1] } 0AAA 5B JUMPDEST 0AAB 80 DUP1 0AAC 15 ISZERO 0AAD 61 PUSH2 0x0af7 0AB0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0af7, if !stack[-1] label_0AB1: // Incoming jump from 0x0AB0, if not !stack[-1] // Inputs[1] { @0AB1 stack[-1] } 0AB1 80 DUP1 0AB2 60 PUSH1 0x1f 0AB4 10 LT 0AB5 61 PUSH2 0x0acc 0AB8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0acc, if 0x1f < stack[-1] label_0AB9: // Incoming jump from 0x0AB8, if not 0x1f < stack[-1] // Inputs[4] // { // @0ABD stack[-2] // @0ABE storage[stack[-2]] // @0AC1 stack[-3] // @0AC3 stack[-1] // } 0AB9 61 PUSH2 0x0100 0ABC 80 DUP1 0ABD 83 DUP4 0ABE 54 SLOAD 0ABF 04 DIV 0AC0 02 MUL 0AC1 83 DUP4 0AC2 52 MSTORE 0AC3 91 SWAP2 0AC4 60 PUSH1 0x20 0AC6 01 ADD 0AC7 91 SWAP2 0AC8 61 PUSH2 0x0af7 0ACB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AC2 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0AC7 stack[-1] = stack[-1] // @0AC7 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0af7 label_0ACC: // Incoming jump from 0x0AB8, if 0x1f < stack[-1] // Inputs[5] // { // @0ACD stack[-3] // @0ACE stack[-1] // @0AD0 stack[-2] // @0AD8 memory[0x00:0x20] // @0ADC storage[keccak256(memory[0x00:0x20])] // } 0ACC 5B JUMPDEST 0ACD 82 DUP3 0ACE 01 ADD 0ACF 91 SWAP2 0AD0 90 SWAP1 0AD1 60 PUSH1 0x00 0AD3 52 MSTORE 0AD4 60 PUSH1 0x20 0AD6 60 PUSH1 0x00 0AD8 20 SHA3 0AD9 90 SWAP1 0ADA 5B JUMPDEST 0ADB 81 DUP2 0ADC 54 SLOAD 0ADD 81 DUP2 0ADE 52 MSTORE 0ADF 90 SWAP1 0AE0 60 PUSH1 0x01 0AE2 01 ADD 0AE3 90 SWAP1 0AE4 60 PUSH1 0x20 0AE6 01 ADD 0AE7 80 DUP1 0AE8 83 DUP4 0AE9 11 GT 0AEA 61 PUSH2 0x0ada 0AED 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0ACF stack[-3] = stack[-3] + stack[-1] // @0AD3 memory[0x00:0x20] = stack[-2] // @0ADE memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AE3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0AE6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0ada, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0AEE: // Incoming jump from 0x0AED, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0AED, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0AEE stack[-3] // @0AEF stack[-1] // } 0AEE 82 DUP3 0AEF 90 SWAP1 0AF0 03 SUB 0AF1 60 PUSH1 0x1f 0AF3 16 AND 0AF4 82 DUP3 0AF5 01 ADD 0AF6 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0AF6 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0AF6 stack[-1] = stack[-3] // } // Block continues label_0AF7: // Incoming jump from 0x0AF6 // Incoming jump from 0x0ACB // Incoming jump from 0x0AB0, if !stack[-1] // Inputs[1] { @0AFD stack[-7] } 0AF7 5B JUMPDEST 0AF8 50 POP 0AF9 50 POP 0AFA 50 POP 0AFB 50 POP 0AFC 50 POP 0AFD 81 DUP2 0AFE 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0AFF: // Incoming jump from 0x034C // Inputs[1] { @0B05 stack[-1] } 0AFF 5B JUMPDEST 0B00 60 PUSH1 0x00 0B02 61 PUSH2 0x0b0a 0B05 82 DUP3 0B06 61 PUSH2 0x1225 0B09 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B00 stack[0] = 0x00 // @0B02 stack[1] = 0x0b0a // @0B05 stack[2] = stack[-1] // } // Block ends with call to 0x1225, returns to 0x0B0A label_0B0A: // Incoming return from call to 0x1225 at 0x0B09 // Inputs[3] // { // @0B0B stack[-2] // @0B0B stack[-1] // @0B24 stack[-4] // } 0B0A 5B JUMPDEST 0B0B 90 SWAP1 0B0C 50 POP 0B0D 80 DUP1 0B0E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B23 16 AND 0B24 83 DUP4 0B25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B3A 16 AND 0B3B 14 EQ 0B3C 15 ISZERO 0B3D 61 PUSH2 0x0b7b 0B40 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B0B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0b7b, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0B41: // Incoming jump from 0x0B40, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0B43 memory[0x40:0x60] } 0B41 60 PUSH1 0x40 0B43 51 MLOAD 0B44 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B65 81 DUP2 0B66 52 MSTORE 0B67 60 PUSH1 0x04 0B69 01 ADD 0B6A 61 PUSH2 0x0b72 0B6D 90 SWAP1 0B6E 61 PUSH2 0x490f 0B71 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B6D stack[0] = 0x0b72 // @0B6D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x490f, returns to 0x0B72 label_0B72: // Incoming return from call to 0x490F at 0x0B71 // Inputs[3] // { // @0B75 memory[0x40:0x60] // @0B77 stack[-1] // @0B7A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0B72 5B JUMPDEST 0B73 60 PUSH1 0x40 0B75 51 MLOAD 0B76 80 DUP1 0B77 91 SWAP2 0B78 03 SUB 0B79 90 SWAP1 0B7A FD *REVERT // Stack delta = -1 // Outputs[1] { @0B7A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0B7B: // Incoming jump from 0x0B40, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0B7C stack[-1] } 0B7B 5B JUMPDEST 0B7C 80 DUP1 0B7D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B92 16 AND 0B93 61 PUSH2 0x0b9a 0B96 61 PUSH2 0x24e6 0B99 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B92 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B93 stack[1] = 0x0b9a // } // Block ends with call to 0x24e6, returns to 0x0B9A label_0B9A: // Incoming return from call to 0x24E6 at 0x0B99 // Inputs[2] // { // @0BB0 stack[-1] // @0BB1 stack[-2] // } 0B9A 5B JUMPDEST 0B9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BB0 16 AND 0BB1 14 EQ 0BB2 80 DUP1 0BB3 61 PUSH2 0x0bc9 0BB6 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0BB1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x0bc9, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0BB7: // Incoming jump from 0x0BB6, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0BBB stack[-2] } 0BB7 50 POP 0BB8 61 PUSH2 0x0bc8 0BBB 81 DUP2 0BBC 61 PUSH2 0x0bc3 0BBF 61 PUSH2 0x24e6 0BC2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BB8 stack[-1] = 0x0bc8 // @0BBB stack[0] = stack[-2] // @0BBC stack[1] = 0x0bc3 // } // Block ends with call to 0x24e6, returns to 0x0BC3 label_0BC3: // Incoming return from call to 0x24E6 at 0x0BC2 0BC3 5B JUMPDEST 0BC4 61 PUSH2 0x2082 0BC7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2082 label_0BC8: // Incoming return from call to 0x0BC3 at 0x0BC2 0BC8 5B JUMPDEST // Stack delta = +0 // Block continues label_0BC9: // Incoming jump from 0x0BC8 // Incoming jump from 0x0BB6, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0BCD stack[-1] } 0BC9 5B JUMPDEST 0BCA 61 PUSH2 0x0c08 0BCD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c08, if stack[-1] label_0BCE: // Incoming jump from 0x0BCD, if not stack[-1] // Inputs[1] { @0BD0 memory[0x40:0x60] } 0BCE 60 PUSH1 0x40 0BD0 51 MLOAD 0BD1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BF2 81 DUP2 0BF3 52 MSTORE 0BF4 60 PUSH1 0x04 0BF6 01 ADD 0BF7 61 PUSH2 0x0bff 0BFA 90 SWAP1 0BFB 61 PUSH2 0x47af 0BFE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BFA stack[0] = 0x0bff // @0BFA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x47af, returns to 0x0BFF label_0BFF: // Incoming return from call to 0x47AF at 0x0BFE // Inputs[3] // { // @0C02 memory[0x40:0x60] // @0C04 stack[-1] // @0C07 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0BFF 5B JUMPDEST 0C00 60 PUSH1 0x40 0C02 51 MLOAD 0C03 80 DUP1 0C04 91 SWAP2 0C05 03 SUB 0C06 90 SWAP1 0C07 FD *REVERT // Stack delta = -1 // Outputs[1] { @0C07 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0C08: // Incoming jump from 0x0BCD, if stack[-1] // Inputs[2] // { // @0C0C stack[-3] // @0C0D stack[-2] // } 0C08 5B JUMPDEST 0C09 61 PUSH2 0x0c12 0C0C 83 DUP4 0C0D 83 DUP4 0C0E 61 PUSH2 0x24ee 0C11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C09 stack[0] = 0x0c12 // @0C0C stack[1] = stack[-3] // @0C0D stack[2] = stack[-2] // } // Block ends with call to 0x24ee, returns to 0x0C12 label_0C12: // Incoming return from call to 0x24EE at 0x0C11 // Inputs[1] { @0C16 stack[-4] } 0C12 5B JUMPDEST 0C13 50 POP 0C14 50 POP 0C15 50 POP 0C16 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0C17: // Incoming call from 0x0363, returns to 0x0364 // Inputs[1] { @0C1A stack[-1] } 0C17 5B JUMPDEST 0C18 60 PUSH1 0x08 0C1A 81 DUP2 0C1B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C18 stack[0] = 0x08 } // Block ends with unconditional jump to stack[-1] label_0C1C: // Incoming call from 0x0D21, returns to 0x0D22 // Incoming call from 0x038E, returns to 0x038F // Incoming call from 0x1D20, returns to 0x1D21 // Incoming call from 0x1DE3, returns to 0x1DE4 // Incoming call from 0x14E1, returns to 0x14E2 // Incoming call from 0x15A4, returns to 0x15A5 // Incoming call from 0x1DD6, returns to 0x1DD7 // Incoming call from 0x1597, returns to 0x1598 // Incoming call from 0x10EE, returns to 0x10EF // Inputs[2] // { // @0C22 storage[0x08] // @0C27 stack[-1] // } 0C1C 5B JUMPDEST 0C1D 60 PUSH1 0x00 0C1F 60 PUSH1 0x08 0C21 80 DUP1 0C22 54 SLOAD 0C23 90 SWAP1 0C24 50 POP 0C25 90 SWAP1 0C26 50 POP 0C27 90 SWAP1 0C28 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C27 stack[-1] = storage[0x08] } // Block ends with unconditional jump to stack[-1] label_0C29: // Incoming call from 0x03B9, returns to 0x03BA // Inputs[2] // { // @0C2F storage[0x0d] // @0C3A stack[-1] // } 0C29 5B JUMPDEST 0C2A 60 PUSH1 0x0d 0C2C 60 PUSH1 0x01 0C2E 90 SWAP1 0C2F 54 SLOAD 0C30 90 SWAP1 0C31 61 PUSH2 0x0100 0C34 0A EXP 0C35 90 SWAP1 0C36 04 DIV 0C37 60 PUSH1 0xff 0C39 16 AND 0C3A 81 DUP2 0C3B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C39 stack[0] = 0xff & storage[0x0d] / 0x0100 ** 0x01 } // Block ends with unconditional jump to stack[-1] label_0C3C: // Incoming jump from 0x03F6 0C3C 5B JUMPDEST 0C3D 61 PUSH2 0x0c4d 0C40 61 PUSH2 0x0c47 0C43 61 PUSH2 0x24e6 0C46 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C3D stack[0] = 0x0c4d // @0C40 stack[1] = 0x0c47 // } // Block ends with call to 0x24e6, returns to 0x0C47 label_0C47: // Incoming return from call to 0x24E6 at 0x0C46 // Inputs[1] { @0C48 stack[-3] } 0C47 5B JUMPDEST 0C48 82 DUP3 0C49 61 PUSH2 0x25a7 0C4C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C48 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x25a7 label_0C4D: // Incoming return from call to 0x0C47 at 0x0C46 // Inputs[1] { @0C51 stack[-1] } 0C4D 5B JUMPDEST 0C4E 61 PUSH2 0x0c8c 0C51 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c8c, if stack[-1] label_0C52: // Incoming jump from 0x0C51, if not stack[-1] // Inputs[1] { @0C54 memory[0x40:0x60] } 0C52 60 PUSH1 0x40 0C54 51 MLOAD 0C55 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C76 81 DUP2 0C77 52 MSTORE 0C78 60 PUSH1 0x04 0C7A 01 ADD 0C7B 61 PUSH2 0x0c83 0C7E 90 SWAP1 0C7F 61 PUSH2 0x496f 0C82 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C77 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C7E stack[0] = 0x0c83 // @0C7E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x496f, returns to 0x0C83 label_0C83: // Incoming return from call to 0x496F at 0x0C82 // Inputs[3] // { // @0C86 memory[0x40:0x60] // @0C88 stack[-1] // @0C8B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0C83 5B JUMPDEST 0C84 60 PUSH1 0x40 0C86 51 MLOAD 0C87 80 DUP1 0C88 91 SWAP2 0C89 03 SUB 0C8A 90 SWAP1 0C8B FD *REVERT // Stack delta = -1 // Outputs[1] { @0C8B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0C8C: // Incoming jump from 0x0C51, if stack[-1] // Inputs[3] // { // @0C90 stack[-3] // @0C91 stack[-2] // @0C92 stack[-1] // } 0C8C 5B JUMPDEST 0C8D 61 PUSH2 0x0c97 0C90 83 DUP4 0C91 83 DUP4 0C92 83 DUP4 0C93 61 PUSH2 0x2685 0C96 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C8D stack[0] = 0x0c97 // @0C90 stack[1] = stack[-3] // @0C91 stack[2] = stack[-2] // @0C92 stack[3] = stack[-1] // } // Block ends with call to 0x2685, returns to 0x0C97 label_0C97: // Incoming return from call to 0x2685 at 0x0C96 // Inputs[1] { @0C9B stack[-4] } 0C97 5B JUMPDEST 0C98 50 POP 0C99 50 POP 0C9A 50 POP 0C9B 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0C9C: // Incoming call from 0x040D, returns to 0x040E 0C9C 5B JUMPDEST 0C9D 61 PUSH2 0x0ca4 0CA0 61 PUSH2 0x24e6 0CA3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C9D stack[0] = 0x0ca4 } // Block ends with call to 0x24e6, returns to 0x0CA4 label_0CA4: // Incoming return from call to 0x24E6 at 0x0CA3 // Inputs[1] { @0CBA stack[-1] } 0CA4 5B JUMPDEST 0CA5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CBA 16 AND 0CBB 61 PUSH2 0x0cc2 0CBE 61 PUSH2 0x17ae 0CC1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0CBA stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0CBB stack[0] = 0x0cc2 // } // Block ends with call to 0x17ae, returns to 0x0CC2 label_0CC2: // Incoming return from call to 0x17AE at 0x0CC1 // Inputs[2] // { // @0CD8 stack[-1] // @0CD9 stack[-2] // } 0CC2 5B JUMPDEST 0CC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CD8 16 AND 0CD9 14 EQ 0CDA 61 PUSH2 0x0d18 0CDD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0d18, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0CDE: // Incoming jump from 0x0CDD, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0CE0 memory[0x40:0x60] } 0CDE 60 PUSH1 0x40 0CE0 51 MLOAD 0CE1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D02 81 DUP2 0D03 52 MSTORE 0D04 60 PUSH1 0x04 0D06 01 ADD 0D07 61 PUSH2 0x0d0f 0D0A 90 SWAP1 0D0B 61 PUSH2 0x488f 0D0E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D0A stack[0] = 0x0d0f // @0D0A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x0D0F label_0D0F: // Incoming return from call to 0x488F at 0x0D0E // Inputs[3] // { // @0D12 memory[0x40:0x60] // @0D14 stack[-1] // @0D17 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D0F 5B JUMPDEST 0D10 60 PUSH1 0x40 0D12 51 MLOAD 0D13 80 DUP1 0D14 91 SWAP2 0D15 03 SUB 0D16 90 SWAP1 0D17 FD *REVERT // Stack delta = -1 // Outputs[1] { @0D17 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0D18: // Incoming jump from 0x0CDD, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] 0D18 5B JUMPDEST 0D19 60 PUSH1 0x00 0D1B 61 PUSH2 0x0d22 0D1E 61 PUSH2 0x0c1c 0D21 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D19 stack[0] = 0x00 // @0D1B stack[1] = 0x0d22 // } // Block ends with call to 0x0c1c, returns to 0x0D22 label_0D22: // Incoming return from call to 0x0C1C at 0x0D21 // Inputs[2] // { // @0D23 stack[-1] // @0D23 stack[-2] // } 0D22 5B JUMPDEST 0D23 90 SWAP1 0D24 50 POP 0D25 60 PUSH1 0x64 0D27 81 DUP2 0D28 10 LT 0D29 61 PUSH2 0x0d67 0D2C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D23 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0d67, if stack[-1] < 0x64 label_0D2D: // Incoming jump from 0x0D2C, if not stack[-1] < 0x64 // Inputs[1] { @0D2F memory[0x40:0x60] } 0D2D 60 PUSH1 0x40 0D2F 51 MLOAD 0D30 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D51 81 DUP2 0D52 52 MSTORE 0D53 60 PUSH1 0x04 0D55 01 ADD 0D56 61 PUSH2 0x0d5e 0D59 90 SWAP1 0D5A 61 PUSH2 0x48af 0D5D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D59 stack[0] = 0x0d5e // @0D59 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x48af, returns to 0x0D5E label_0D5E: // Incoming return from call to 0x48AF at 0x0D5D // Inputs[3] // { // @0D61 memory[0x40:0x60] // @0D63 stack[-1] // @0D66 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D5E 5B JUMPDEST 0D5F 60 PUSH1 0x40 0D61 51 MLOAD 0D62 80 DUP1 0D63 91 SWAP2 0D64 03 SUB 0D65 90 SWAP1 0D66 FD *REVERT // Stack delta = -1 // Outputs[1] { @0D66 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0D67: // Incoming jump from 0x0D2C, if stack[-1] < 0x64 0D67 5B JUMPDEST 0D68 60 PUSH1 0x00 0D6A 5B JUMPDEST 0D6B 60 PUSH1 0x64 0D6D 81 DUP2 0D6E 10 LT 0D6F 15 ISZERO 0D70 61 PUSH2 0x0d9b 0D73 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D68 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d9b, if !(0x00 < 0x64) label_0D74: // Incoming jump from 0x0D73, if not !(stack[-1] < 0x64) // Incoming jump from 0x0D73, if not !(0x00 < 0x64) // Inputs[3] // { // @0D77 msg.sender // @0D78 stack[-1] // @0D79 stack[-2] // } 0D74 61 PUSH2 0x0d88 0D77 33 CALLER 0D78 82 DUP3 0D79 84 DUP5 0D7A 61 PUSH2 0x0d83 0D7D 91 SWAP2 0D7E 90 SWAP1 0D7F 61 PUSH2 0x4ab3 0D82 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D74 stack[0] = 0x0d88 // @0D77 stack[1] = msg.sender // @0D7D stack[2] = 0x0d83 // @0D7E stack[3] = stack[-1] // @0D7E stack[4] = stack[-2] // } // Block ends with call to 0x4ab3, returns to 0x0D83 label_0D83: // Incoming return from call to 0x4AB3 at 0x0D82 0D83 5B JUMPDEST 0D84 61 PUSH2 0x28e1 0D87 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x28e1 label_0D88: // Incoming return from call to 0x0D83 at 0x0D82 // Inputs[1] { @0D89 stack[-1] } 0D88 5B JUMPDEST 0D89 80 DUP1 0D8A 80 DUP1 0D8B 61 PUSH2 0x0d93 0D8E 90 SWAP1 0D8F 61 PUSH2 0x4cb0 0D92 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D89 stack[0] = stack[-1] // @0D8E stack[1] = 0x0d93 // @0D8E stack[2] = stack[-1] // } // Block ends with call to 0x4cb0, returns to 0x0D93 label_0D93: // Incoming return from call to 0x4CB0 at 0x0D92 // Inputs[2] // { // @0D94 stack[-3] // @0D94 stack[-1] // } 0D93 5B JUMPDEST 0D94 91 SWAP2 0D95 50 POP 0D96 50 POP 0D97 61 PUSH2 0x0d6a 0D9A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D94 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0d6a label_0D9B: // Incoming jump from 0x0D73, if !(stack[-1] < 0x64) // Incoming jump from 0x0D73, if !(0x00 < 0x64) // Inputs[1] { @0D9E stack[-3] } 0D9B 5B JUMPDEST 0D9C 50 POP 0D9D 50 POP 0D9E 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0D9F: // Incoming jump from 0x0436 // Inputs[1] { @0DA5 stack[-2] } 0D9F 5B JUMPDEST 0DA0 60 PUSH1 0x00 0DA2 61 PUSH2 0x0daa 0DA5 83 DUP4 0DA6 61 PUSH2 0x165c 0DA9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DA0 stack[0] = 0x00 // @0DA2 stack[1] = 0x0daa // @0DA5 stack[2] = stack[-2] // } // Block ends with call to 0x165c, returns to 0x0DAA label_0DAA: // Incoming return from call to 0x165C at 0x0DA9 // Inputs[2] // { // @0DAB stack[-3] // @0DAC stack[-1] // } 0DAA 5B JUMPDEST 0DAB 82 DUP3 0DAC 10 LT 0DAD 61 PUSH2 0x0deb 0DB0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0deb, if stack[-3] < stack[-1] label_0DB1: // Incoming jump from 0x0DB0, if not stack[-3] < stack[-1] // Inputs[1] { @0DB3 memory[0x40:0x60] } 0DB1 60 PUSH1 0x40 0DB3 51 MLOAD 0DB4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0DD5 81 DUP2 0DD6 52 MSTORE 0DD7 60 PUSH1 0x04 0DD9 01 ADD 0DDA 61 PUSH2 0x0de2 0DDD 90 SWAP1 0DDE 61 PUSH2 0x462f 0DE1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0DDD stack[0] = 0x0de2 // @0DDD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x462f, returns to 0x0DE2 label_0DE2: // Incoming return from call to 0x462F at 0x0DE1 // Inputs[3] // { // @0DE5 memory[0x40:0x60] // @0DE7 stack[-1] // @0DEA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0DE2 5B JUMPDEST 0DE3 60 PUSH1 0x40 0DE5 51 MLOAD 0DE6 80 DUP1 0DE7 91 SWAP2 0DE8 03 SUB 0DE9 90 SWAP1 0DEA FD *REVERT // Stack delta = -1 // Outputs[1] { @0DEA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0DEB: // Incoming jump from 0x0DB0, if stack[-3] < stack[-1] // Inputs[7] // { // @0DF0 stack[-3] // @0E2A memory[0x00:0x40] // @0E2D stack[-2] // @0E3B memory[0x00:0x40] // @0E3C storage[keccak256(memory[0x00:0x40])] // @0E3D stack[-1] // @0E3F stack[-4] // } 0DEB 5B JUMPDEST 0DEC 60 PUSH1 0x06 0DEE 60 PUSH1 0x00 0DF0 84 DUP5 0DF1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E06 16 AND 0E07 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E1C 16 AND 0E1D 81 DUP2 0E1E 52 MSTORE 0E1F 60 PUSH1 0x20 0E21 01 ADD 0E22 90 SWAP1 0E23 81 DUP2 0E24 52 MSTORE 0E25 60 PUSH1 0x20 0E27 01 ADD 0E28 60 PUSH1 0x00 0E2A 20 SHA3 0E2B 60 PUSH1 0x00 0E2D 83 DUP4 0E2E 81 DUP2 0E2F 52 MSTORE 0E30 60 PUSH1 0x20 0E32 01 ADD 0E33 90 SWAP1 0E34 81 DUP2 0E35 52 MSTORE 0E36 60 PUSH1 0x20 0E38 01 ADD 0E39 60 PUSH1 0x00 0E3B 20 SHA3 0E3C 54 SLOAD 0E3D 90 SWAP1 0E3E 50 POP 0E3F 92 SWAP3 0E40 91 SWAP2 0E41 50 POP 0E42 50 POP 0E43 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0E1E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E24 memory[0x20:0x40] = 0x06 // @0E2F memory[0x00:0x20] = stack[-2] // @0E35 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E3F stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0E44: // Incoming jump from 0x0473 0E44 5B JUMPDEST 0E45 61 PUSH2 0x0e4c 0E48 61 PUSH2 0x24e6 0E4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E45 stack[0] = 0x0e4c } // Block ends with call to 0x24e6, returns to 0x0E4C label_0E4C: // Incoming return from call to 0x24E6 at 0x0E4B // Inputs[1] { @0E62 stack[-1] } 0E4C 5B JUMPDEST 0E4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E62 16 AND 0E63 61 PUSH2 0x0e6a 0E66 61 PUSH2 0x17ae 0E69 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0E62 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0E63 stack[0] = 0x0e6a // } // Block ends with call to 0x17ae, returns to 0x0E6A label_0E6A: // Incoming return from call to 0x17AE at 0x0E69 // Inputs[2] // { // @0E80 stack[-1] // @0E81 stack[-2] // } 0E6A 5B JUMPDEST 0E6B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E80 16 AND 0E81 14 EQ 0E82 61 PUSH2 0x0ec0 0E85 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ec0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0E86: // Incoming jump from 0x0E85, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0E88 memory[0x40:0x60] } 0E86 60 PUSH1 0x40 0E88 51 MLOAD 0E89 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EAA 81 DUP2 0EAB 52 MSTORE 0EAC 60 PUSH1 0x04 0EAE 01 ADD 0EAF 61 PUSH2 0x0eb7 0EB2 90 SWAP1 0EB3 61 PUSH2 0x488f 0EB6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0EB2 stack[0] = 0x0eb7 // @0EB2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x0EB7 label_0EB7: // Incoming return from call to 0x488F at 0x0EB6 // Inputs[3] // { // @0EBA memory[0x40:0x60] // @0EBC stack[-1] // @0EBF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0EB7 5B JUMPDEST 0EB8 60 PUSH1 0x40 0EBA 51 MLOAD 0EBB 80 DUP1 0EBC 91 SWAP2 0EBD 03 SUB 0EBE 90 SWAP1 0EBF FD *REVERT // Stack delta = -1 // Outputs[1] { @0EBF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0EC0: // Incoming jump from 0x0E85, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[4] // { // @0EC7 stack[-1] // @0F01 memory[0x00:0x40] // @0F09 storage[keccak256(memory[0x00:0x40])] // @0F3D memory[0x40:0x60] // } 0EC0 5B JUMPDEST 0EC1 60 PUSH1 0x01 0EC3 60 PUSH1 0x11 0EC5 60 PUSH1 0x00 0EC7 83 DUP4 0EC8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EDD 16 AND 0EDE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF3 16 AND 0EF4 81 DUP2 0EF5 52 MSTORE 0EF6 60 PUSH1 0x20 0EF8 01 ADD 0EF9 90 SWAP1 0EFA 81 DUP2 0EFB 52 MSTORE 0EFC 60 PUSH1 0x20 0EFE 01 ADD 0EFF 60 PUSH1 0x00 0F01 20 SHA3 0F02 60 PUSH1 0x00 0F04 61 PUSH2 0x0100 0F07 0A EXP 0F08 81 DUP2 0F09 54 SLOAD 0F0A 81 DUP2 0F0B 60 PUSH1 0xff 0F0D 02 MUL 0F0E 19 NOT 0F0F 16 AND 0F10 90 SWAP1 0F11 83 DUP4 0F12 15 ISZERO 0F13 15 ISZERO 0F14 02 MUL 0F15 17 OR 0F16 90 SWAP1 0F17 55 SSTORE 0F18 50 POP 0F19 7F PUSH32 0xc8651250df7c4c306e2bd9eb8d5a8e9a422a3101fb96cfa7f8e0c3a7df3b9b51 0F3A 81 DUP2 0F3B 60 PUSH1 0x40 0F3D 51 MLOAD 0F3E 61 PUSH2 0x0f47 0F41 91 SWAP2 0F42 90 SWAP1 0F43 61 PUSH2 0x458b 0F46 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @0EF5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0EFB memory[0x20:0x40] = 0x11 // @0F17 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0F19 stack[0] = 0xc8651250df7c4c306e2bd9eb8d5a8e9a422a3101fb96cfa7f8e0c3a7df3b9b51 // @0F41 stack[1] = 0x0f47 // @0F42 stack[2] = stack[-1] // @0F42 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x458b, returns to 0x0F47 label_0F47: // Incoming return from call to 0x458B at 0x0F46 // Inputs[5] // { // @0F4A memory[0x40:0x60] // @0F4C stack[-1] // @0F4F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0F4F stack[-2] // @0F51 stack[-4] // } 0F47 5B JUMPDEST 0F48 60 PUSH1 0x40 0F4A 51 MLOAD 0F4B 80 DUP1 0F4C 91 SWAP2 0F4D 03 SUB 0F4E 90 SWAP1 0F4F A1 LOG1 0F50 50 POP 0F51 56 *JUMP // Stack delta = -4 // Outputs[1] { @0F4F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_0F52: // Incoming call from 0x048A, returns to 0x048B 0F52 5B JUMPDEST 0F53 61 PUSH2 0x0f5a 0F56 61 PUSH2 0x24e6 0F59 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F53 stack[0] = 0x0f5a } // Block ends with call to 0x24e6, returns to 0x0F5A label_0F5A: // Incoming return from call to 0x24E6 at 0x0F59 // Inputs[1] { @0F70 stack[-1] } 0F5A 5B JUMPDEST 0F5B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F70 16 AND 0F71 61 PUSH2 0x0f78 0F74 61 PUSH2 0x17ae 0F77 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0F70 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0F71 stack[0] = 0x0f78 // } // Block ends with call to 0x17ae, returns to 0x0F78 label_0F78: // Incoming return from call to 0x17AE at 0x0F77 // Inputs[2] // { // @0F8E stack[-1] // @0F8F stack[-2] // } 0F78 5B JUMPDEST 0F79 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F8E 16 AND 0F8F 14 EQ 0F90 61 PUSH2 0x0fce 0F93 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fce, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0F94: // Incoming jump from 0x0F93, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0F96 memory[0x40:0x60] } 0F94 60 PUSH1 0x40 0F96 51 MLOAD 0F97 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0FB8 81 DUP2 0FB9 52 MSTORE 0FBA 60 PUSH1 0x04 0FBC 01 ADD 0FBD 61 PUSH2 0x0fc5 0FC0 90 SWAP1 0FC1 61 PUSH2 0x488f 0FC4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0FC0 stack[0] = 0x0fc5 // @0FC0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x0FC5 label_0FC5: // Incoming return from call to 0x488F at 0x0FC4 // Inputs[3] // { // @0FC8 memory[0x40:0x60] // @0FCA stack[-1] // @0FCD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0FC5 5B JUMPDEST 0FC6 60 PUSH1 0x40 0FC8 51 MLOAD 0FC9 80 DUP1 0FCA 91 SWAP2 0FCB 03 SUB 0FCC 90 SWAP1 0FCD FD *REVERT // Stack delta = -1 // Outputs[1] { @0FCD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0FCE: // Incoming jump from 0x0F93, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @0FD4 storage[0x0d] // @0FE9 storage[0x0d] // @0FF9 stack[-1] // } 0FCE 5B JUMPDEST 0FCF 60 PUSH1 0x0d 0FD1 60 PUSH1 0x00 0FD3 90 SWAP1 0FD4 54 SLOAD 0FD5 90 SWAP1 0FD6 61 PUSH2 0x0100 0FD9 0A EXP 0FDA 90 SWAP1 0FDB 04 DIV 0FDC 60 PUSH1 0xff 0FDE 16 AND 0FDF 15 ISZERO 0FE0 60 PUSH1 0x0d 0FE2 60 PUSH1 0x00 0FE4 61 PUSH2 0x0100 0FE7 0A EXP 0FE8 81 DUP2 0FE9 54 SLOAD 0FEA 81 DUP2 0FEB 60 PUSH1 0xff 0FED 02 MUL 0FEE 19 NOT 0FEF 16 AND 0FF0 90 SWAP1 0FF1 83 DUP4 0FF2 15 ISZERO 0FF3 15 ISZERO 0FF4 02 MUL 0FF5 17 OR 0FF6 90 SWAP1 0FF7 55 SSTORE 0FF8 50 POP 0FF9 56 *JUMP // Stack delta = -1 // Outputs[1] { @0FF7 storage[0x0d] = !!!(0xff & storage[0x0d] / 0x0100 ** 0x00) * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x0d]) } // Block ends with unconditional jump to stack[-1] label_0FFA: // Incoming call from 0x04A1, returns to 0x04A2 0FFA 5B JUMPDEST 0FFB 61 PUSH2 0x1002 0FFE 61 PUSH2 0x24e6 1001 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FFB stack[0] = 0x1002 } // Block ends with call to 0x24e6, returns to 0x1002 label_1002: // Incoming return from call to 0x24E6 at 0x1001 // Inputs[1] { @1018 stack[-1] } 1002 5B JUMPDEST 1003 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1018 16 AND 1019 61 PUSH2 0x1020 101C 61 PUSH2 0x17ae 101F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1018 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1019 stack[0] = 0x1020 // } // Block ends with call to 0x17ae, returns to 0x1020 label_1020: // Incoming return from call to 0x17AE at 0x101F // Inputs[2] // { // @1036 stack[-1] // @1037 stack[-2] // } 1020 5B JUMPDEST 1021 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1036 16 AND 1037 14 EQ 1038 61 PUSH2 0x1076 103B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1076, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_103C: // Incoming jump from 0x103B, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @103E memory[0x40:0x60] } 103C 60 PUSH1 0x40 103E 51 MLOAD 103F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1060 81 DUP2 1061 52 MSTORE 1062 60 PUSH1 0x04 1064 01 ADD 1065 61 PUSH2 0x106d 1068 90 SWAP1 1069 61 PUSH2 0x488f 106C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1061 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1068 stack[0] = 0x106d // @1068 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x106D label_106D: // Incoming return from call to 0x488F at 0x106C // Inputs[3] // { // @1070 memory[0x40:0x60] // @1072 stack[-1] // @1075 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 106D 5B JUMPDEST 106E 60 PUSH1 0x40 1070 51 MLOAD 1071 80 DUP1 1072 91 SWAP2 1073 03 SUB 1074 90 SWAP1 1075 FD *REVERT // Stack delta = -1 // Outputs[1] { @1075 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1076: // Incoming jump from 0x103B, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[7] // { // @1079 address(this) // @1079 address(this).balance // @107C msg.sender // @109E memory[0x40:0x60] // @10A3 memory[0x40:0x60] // @10AB address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @10AB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1076 5B JUMPDEST 1077 60 PUSH1 0x00 1079 47 SELFBALANCE 107A 90 SWAP1 107B 50 POP 107C 33 CALLER 107D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1092 16 AND 1093 61 PUSH2 0x08fc 1096 82 DUP3 1097 90 SWAP1 1098 81 DUP2 1099 15 ISZERO 109A 02 MUL 109B 90 SWAP1 109C 60 PUSH1 0x40 109E 51 MLOAD 109F 60 PUSH1 0x00 10A1 60 PUSH1 0x40 10A3 51 MLOAD 10A4 80 DUP1 10A5 83 DUP4 10A6 03 SUB 10A7 81 DUP2 10A8 85 DUP6 10A9 88 DUP9 10AA 88 DUP9 10AB F1 CALL 10AC 93 SWAP4 10AD 50 POP 10AE 50 POP 10AF 50 POP 10B0 50 POP 10B1 15 ISZERO 10B2 80 DUP1 10B3 15 ISZERO 10B4 61 PUSH2 0x10c1 10B7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @107A stack[0] = address(this).balance // @10AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @10B1 stack[1] = !address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x10c1, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_10B8: // Incoming jump from 0x10B7, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @10B8 returndata.length // @10BC returndata[0x00:0x00 + returndata.length] // @10BD returndata.length // @10C0 memory[0x00:0x00 + returndata.length] // } 10B8 3D RETURNDATASIZE 10B9 60 PUSH1 0x00 10BB 80 DUP1 10BC 3E RETURNDATACOPY 10BD 3D RETURNDATASIZE 10BE 60 PUSH1 0x00 10C0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10BC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10C0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_10C1: // Incoming jump from 0x10B7, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @10C4 stack[-3] } 10C1 5B JUMPDEST 10C2 50 POP 10C3 50 POP 10C4 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_10C5: // Incoming jump from 0x04CA // Inputs[4] // { // @10C9 stack[-3] // @10CA stack[-2] // @10CB stack[-1] // @10CE memory[0x40:0x60] // } 10C5 5B JUMPDEST 10C6 61 PUSH2 0x10e0 10C9 83 DUP4 10CA 83 DUP4 10CB 83 DUP4 10CC 60 PUSH1 0x40 10CE 51 MLOAD 10CF 80 DUP1 10D0 60 PUSH1 0x20 10D2 01 ADD 10D3 60 PUSH1 0x40 10D5 52 MSTORE 10D6 80 DUP1 10D7 60 PUSH1 0x00 10D9 81 DUP2 10DA 52 MSTORE 10DB 50 POP 10DC 61 PUSH2 0x1b92 10DF 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @10C6 stack[0] = 0x10e0 // @10C9 stack[1] = stack[-3] // @10CA stack[2] = stack[-2] // @10CB stack[3] = stack[-1] // @10CE stack[4] = memory[0x40:0x60] // @10D5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @10DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1b92, returns to 0x10E0 label_10E0: // Incoming return from call to 0x1B92 at 0x10DF // Inputs[1] { @10E4 stack[-4] } 10E0 5B JUMPDEST 10E1 50 POP 10E2 50 POP 10E3 50 POP 10E4 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_10E5: // Incoming jump from 0x04F3 10E5 5B JUMPDEST 10E6 60 PUSH1 0x00 10E8 61 PUSH2 0x10ef 10EB 61 PUSH2 0x0c1c 10EE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10E6 stack[0] = 0x00 // @10E8 stack[1] = 0x10ef // } // Block ends with call to 0x0c1c, returns to 0x10EF label_10EF: // Incoming return from call to 0x0C1C at 0x10EE // Inputs[2] // { // @10F0 stack[-3] // @10F1 stack[-1] // } 10EF 5B JUMPDEST 10F0 82 DUP3 10F1 10 LT 10F2 61 PUSH2 0x1130 10F5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1130, if stack[-3] < stack[-1] label_10F6: // Incoming jump from 0x10F5, if not stack[-3] < stack[-1] // Inputs[1] { @10F8 memory[0x40:0x60] } 10F6 60 PUSH1 0x40 10F8 51 MLOAD 10F9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 111A 81 DUP2 111B 52 MSTORE 111C 60 PUSH1 0x04 111E 01 ADD 111F 61 PUSH2 0x1127 1122 90 SWAP1 1123 61 PUSH2 0x498f 1126 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @111B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1122 stack[0] = 0x1127 // @1122 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x498f, returns to 0x1127 label_1127: // Incoming return from call to 0x498F at 0x1126 // Inputs[3] // { // @112A memory[0x40:0x60] // @112C stack[-1] // @112F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1127 5B JUMPDEST 1128 60 PUSH1 0x40 112A 51 MLOAD 112B 80 DUP1 112C 91 SWAP2 112D 03 SUB 112E 90 SWAP1 112F FD *REVERT // Stack delta = -1 // Outputs[1] { @112F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1130: // Incoming jump from 0x10F5, if stack[-3] < stack[-1] // Inputs[2] // { // @1133 stack[-2] // @1135 storage[0x08] // } 1130 5B JUMPDEST 1131 60 PUSH1 0x08 1133 82 DUP3 1134 81 DUP2 1135 54 SLOAD 1136 81 DUP2 1137 10 LT 1138 61 PUSH2 0x116a 113B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1131 stack[0] = 0x08 // @1133 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x116a, if stack[-2] < storage[0x08] label_113C: // Incoming jump from 0x113B, if not stack[-2] < storage[0x08] // Inputs[1] { @1169 memory[0x00:0x24] } 113C 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 115D 60 PUSH1 0x00 115F 52 MSTORE 1160 60 PUSH1 0x32 1162 60 PUSH1 0x04 1164 52 MSTORE 1165 60 PUSH1 0x24 1167 60 PUSH1 0x00 1169 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @115F memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1164 memory[0x04:0x24] = 0x32 // @1169 revert(memory[0x00:0x24]); // } // Block terminates label_116A: // Incoming jump from 0x113B, if stack[-2] < storage[0x08] // Inputs[7] // { // @116B stack[-2] // @116B stack[-1] // @1173 memory[0x00:0x20] // @1175 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1176 stack[-3] // @1178 stack[-5] // @1179 stack[-4] // } 116A 5B JUMPDEST 116B 90 SWAP1 116C 60 PUSH1 0x00 116E 52 MSTORE 116F 60 PUSH1 0x20 1171 60 PUSH1 0x00 1173 20 SHA3 1174 01 ADD 1175 54 SLOAD 1176 90 SWAP1 1177 50 POP 1178 91 SWAP2 1179 90 SWAP1 117A 50 POP 117B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @116E memory[0x00:0x20] = stack[-2] // @1178 stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_117C: // Incoming call from 0x051E, returns to 0x051F // Inputs[2] // { // @1182 storage[0x0d] // @118D stack[-1] // } 117C 5B JUMPDEST 117D 60 PUSH1 0x0d 117F 60 PUSH1 0x02 1181 90 SWAP1 1182 54 SLOAD 1183 90 SWAP1 1184 61 PUSH2 0x0100 1187 0A EXP 1188 90 SWAP1 1189 04 DIV 118A 60 PUSH1 0xff 118C 16 AND 118D 81 DUP2 118E 56 *JUMP // Stack delta = +1 // Outputs[1] { @118C stack[0] = 0xff & storage[0x0d] / 0x0100 ** 0x02 } // Block ends with unconditional jump to stack[-1] label_118F: // Incoming jump from 0x055B 118F 5B JUMPDEST 1190 61 PUSH2 0x1197 1193 61 PUSH2 0x24e6 1196 56 *JUMP // Stack delta = +1 // Outputs[1] { @1190 stack[0] = 0x1197 } // Block ends with call to 0x24e6, returns to 0x1197 label_1197: // Incoming return from call to 0x24E6 at 0x1196 // Inputs[1] { @11AD stack[-1] } 1197 5B JUMPDEST 1198 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11AD 16 AND 11AE 61 PUSH2 0x11b5 11B1 61 PUSH2 0x17ae 11B4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @11AD stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @11AE stack[0] = 0x11b5 // } // Block ends with call to 0x17ae, returns to 0x11B5 label_11B5: // Incoming return from call to 0x17AE at 0x11B4 // Inputs[2] // { // @11CB stack[-1] // @11CC stack[-2] // } 11B5 5B JUMPDEST 11B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11CB 16 AND 11CC 14 EQ 11CD 61 PUSH2 0x120b 11D0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x120b, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_11D1: // Incoming jump from 0x11D0, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @11D3 memory[0x40:0x60] } 11D1 60 PUSH1 0x40 11D3 51 MLOAD 11D4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 11F5 81 DUP2 11F6 52 MSTORE 11F7 60 PUSH1 0x04 11F9 01 ADD 11FA 61 PUSH2 0x1202 11FD 90 SWAP1 11FE 61 PUSH2 0x488f 1201 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @11FD stack[0] = 0x1202 // @11FD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x1202 label_1202: // Incoming return from call to 0x488F at 0x1201 // Inputs[3] // { // @1205 memory[0x40:0x60] // @1207 stack[-1] // @120A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1202 5B JUMPDEST 1203 60 PUSH1 0x40 1205 51 MLOAD 1206 80 DUP1 1207 91 SWAP2 1208 03 SUB 1209 90 SWAP1 120A FD *REVERT // Stack delta = -1 // Outputs[1] { @120A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_120B: // Incoming jump from 0x11D0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @120C stack[-1] // @1211 memory[stack[-1]:stack[-1] + 0x20] // } 120B 5B JUMPDEST 120C 80 DUP1 120D 60 PUSH1 0x10 120F 90 SWAP1 1210 80 DUP1 1211 51 MLOAD 1212 90 SWAP1 1213 60 PUSH1 0x20 1215 01 ADD 1216 90 SWAP1 1217 61 PUSH2 0x1221 121A 92 SWAP3 121B 91 SWAP2 121C 90 SWAP1 121D 61 PUSH2 0x3620 1220 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @121A stack[0] = 0x1221 // @121B stack[1] = 0x10 // @121C stack[2] = 0x20 + stack[-1] // @121C stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3620, returns to 0x1221 label_1221: // Incoming return from call to 0x3620 at 0x1220 // Inputs[1] { @1224 stack[-3] } 1221 5B JUMPDEST 1222 50 POP 1223 50 POP 1224 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1225: // Incoming call from 0x26A4, returns to 0x26A5 // Incoming jump from 0x0584 // Incoming call from 0x25FB, returns to 0x25FC // Incoming call from 0x0B09, returns to 0x0B0A // Incoming call from 0x2560, returns to 0x2561 // Inputs[3] // { // @122D stack[-1] // @123B memory[0x00:0x40] // @123F storage[keccak256(memory[0x00:0x40])] // } 1225 5B JUMPDEST 1226 60 PUSH1 0x00 1228 80 DUP1 1229 60 PUSH1 0x02 122B 60 PUSH1 0x00 122D 84 DUP5 122E 81 DUP2 122F 52 MSTORE 1230 60 PUSH1 0x20 1232 01 ADD 1233 90 SWAP1 1234 81 DUP2 1235 52 MSTORE 1236 60 PUSH1 0x20 1238 01 ADD 1239 60 PUSH1 0x00 123B 20 SHA3 123C 60 PUSH1 0x00 123E 90 SWAP1 123F 54 SLOAD 1240 90 SWAP1 1241 61 PUSH2 0x0100 1244 0A EXP 1245 90 SWAP1 1246 04 DIV 1247 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125C 16 AND 125D 90 SWAP1 125E 50 POP 125F 60 PUSH1 0x00 1261 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1276 16 AND 1277 81 DUP2 1278 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 128D 16 AND 128E 14 EQ 128F 15 ISZERO 1290 61 PUSH2 0x12ce 1293 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1226 stack[0] = 0x00 // @122F memory[0x00:0x20] = stack[-1] // @1235 memory[0x20:0x40] = 0x02 // @125D stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x12ce, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1294: // Incoming jump from 0x1293, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1296 memory[0x40:0x60] } 1294 60 PUSH1 0x40 1296 51 MLOAD 1297 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12B8 81 DUP2 12B9 52 MSTORE 12BA 60 PUSH1 0x04 12BC 01 ADD 12BD 61 PUSH2 0x12c5 12C0 90 SWAP1 12C1 61 PUSH2 0x47ef 12C4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12C0 stack[0] = 0x12c5 // @12C0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x47ef, returns to 0x12C5 label_12C5: // Incoming return from call to 0x47EF at 0x12C4 // Inputs[3] // { // @12C8 memory[0x40:0x60] // @12CA stack[-1] // @12CD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 12C5 5B JUMPDEST 12C6 60 PUSH1 0x40 12C8 51 MLOAD 12C9 80 DUP1 12CA 91 SWAP2 12CB 03 SUB 12CC 90 SWAP1 12CD FD *REVERT // Stack delta = -1 // Outputs[1] { @12CD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_12CE: // Incoming jump from 0x1293, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @12CF stack[-1] // @12D0 stack[-2] // @12D3 stack[-4] // @12D4 stack[-3] // } 12CE 5B JUMPDEST 12CF 80 DUP1 12D0 91 SWAP2 12D1 50 POP 12D2 50 POP 12D3 91 SWAP2 12D4 90 SWAP1 12D5 50 POP 12D6 56 *JUMP // Stack delta = -3 // Outputs[1] { @12D3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_12D7: // Incoming call from 0x05AF, returns to 0x05B0 // Inputs[1] { @12DB storage[0x0b] } 12D7 5B JUMPDEST 12D8 60 PUSH1 0x0b 12DA 80 DUP1 12DB 54 SLOAD 12DC 61 PUSH2 0x12e4 12DF 90 SWAP1 12E0 61 PUSH2 0x4c7e 12E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12D8 stack[0] = 0x0b // @12DF stack[1] = 0x12e4 // @12DF stack[2] = storage[0x0b] // } // Block ends with call to 0x4c7e, returns to 0x12E4 label_12E4: // Incoming return from call to 0x4C7E at 0x12E3 // Inputs[4] // { // @12E5 stack[-1] // @12F4 memory[0x40:0x60] // @12FC stack[-2] // @1307 storage[stack[-2]] // } 12E4 5B JUMPDEST 12E5 80 DUP1 12E6 60 PUSH1 0x1f 12E8 01 ADD 12E9 60 PUSH1 0x20 12EB 80 DUP1 12EC 91 SWAP2 12ED 04 DIV 12EE 02 MUL 12EF 60 PUSH1 0x20 12F1 01 ADD 12F2 60 PUSH1 0x40 12F4 51 MLOAD 12F5 90 SWAP1 12F6 81 DUP2 12F7 01 ADD 12F8 60 PUSH1 0x40 12FA 52 MSTORE 12FB 80 DUP1 12FC 92 SWAP3 12FD 91 SWAP2 12FE 90 SWAP1 12FF 81 DUP2 1300 81 DUP2 1301 52 MSTORE 1302 60 PUSH1 0x20 1304 01 ADD 1305 82 DUP3 1306 80 DUP1 1307 54 SLOAD 1308 61 PUSH2 0x1310 130B 90 SWAP1 130C 61 PUSH2 0x4c7e 130F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @12FA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @12FC stack[-2] = memory[0x40:0x60] // @12FD stack[-1] = stack[-2] // @12FE stack[0] = stack[-1] // @1301 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1304 stack[1] = 0x20 + memory[0x40:0x60] // @1305 stack[2] = stack[-2] // @130B stack[4] = storage[stack[-2]] // @130B stack[3] = 0x1310 // } // Block ends with call to 0x4c7e, returns to 0x1310 label_1310: // Incoming return from call to 0x4C7E at 0x130F // Inputs[1] { @1311 stack[-1] } 1310 5B JUMPDEST 1311 80 DUP1 1312 15 ISZERO 1313 61 PUSH2 0x135d 1316 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x135d, if !stack[-1] label_1317: // Incoming jump from 0x1316, if not !stack[-1] // Inputs[1] { @1317 stack[-1] } 1317 80 DUP1 1318 60 PUSH1 0x1f 131A 10 LT 131B 61 PUSH2 0x1332 131E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1332, if 0x1f < stack[-1] label_131F: // Incoming jump from 0x131E, if not 0x1f < stack[-1] // Inputs[4] // { // @1323 stack[-2] // @1324 storage[stack[-2]] // @1327 stack[-3] // @1329 stack[-1] // } 131F 61 PUSH2 0x0100 1322 80 DUP1 1323 83 DUP4 1324 54 SLOAD 1325 04 DIV 1326 02 MUL 1327 83 DUP4 1328 52 MSTORE 1329 91 SWAP2 132A 60 PUSH1 0x20 132C 01 ADD 132D 91 SWAP2 132E 61 PUSH2 0x135d 1331 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1328 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @132D stack[-1] = stack[-1] // @132D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x135d label_1332: // Incoming jump from 0x131E, if 0x1f < stack[-1] // Inputs[5] // { // @1333 stack[-3] // @1334 stack[-1] // @1336 stack[-2] // @133E memory[0x00:0x20] // @1342 storage[keccak256(memory[0x00:0x20])] // } 1332 5B JUMPDEST 1333 82 DUP3 1334 01 ADD 1335 91 SWAP2 1336 90 SWAP1 1337 60 PUSH1 0x00 1339 52 MSTORE 133A 60 PUSH1 0x20 133C 60 PUSH1 0x00 133E 20 SHA3 133F 90 SWAP1 1340 5B JUMPDEST 1341 81 DUP2 1342 54 SLOAD 1343 81 DUP2 1344 52 MSTORE 1345 90 SWAP1 1346 60 PUSH1 0x01 1348 01 ADD 1349 90 SWAP1 134A 60 PUSH1 0x20 134C 01 ADD 134D 80 DUP1 134E 83 DUP4 134F 11 GT 1350 61 PUSH2 0x1340 1353 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1335 stack[-3] = stack[-3] + stack[-1] // @1339 memory[0x00:0x20] = stack[-2] // @1344 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1349 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @134C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1340, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1354: // Incoming jump from 0x1353, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1353, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1354 stack[-3] // @1355 stack[-1] // } 1354 82 DUP3 1355 90 SWAP1 1356 03 SUB 1357 60 PUSH1 0x1f 1359 16 AND 135A 82 DUP3 135B 01 ADD 135C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @135C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @135C stack[-1] = stack[-3] // } // Block continues label_135D: // Incoming jump from 0x1316, if !stack[-1] // Incoming jump from 0x1331 // Incoming jump from 0x135C // Inputs[1] { @1363 stack[-7] } 135D 5B JUMPDEST 135E 50 POP 135F 50 POP 1360 50 POP 1361 50 POP 1362 50 POP 1363 81 DUP2 1364 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1365: // Incoming jump from 0x05DF // Inputs[1] { @136B storage[0x0d] } 1365 5B JUMPDEST 1366 60 PUSH1 0x0d 1368 60 PUSH1 0x01 136A 90 SWAP1 136B 54 SLOAD 136C 90 SWAP1 136D 61 PUSH2 0x0100 1370 0A EXP 1371 90 SWAP1 1372 04 DIV 1373 60 PUSH1 0xff 1375 16 AND 1376 61 PUSH2 0x13b4 1379 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13b4, if 0xff & storage[0x0d] / 0x0100 ** 0x01 label_137A: // Incoming jump from 0x1379, if not 0xff & storage[0x0d] / 0x0100 ** 0x01 // Inputs[1] { @137C memory[0x40:0x60] } 137A 60 PUSH1 0x40 137C 51 MLOAD 137D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 139E 81 DUP2 139F 52 MSTORE 13A0 60 PUSH1 0x04 13A2 01 ADD 13A3 61 PUSH2 0x13ab 13A6 90 SWAP1 13A7 61 PUSH2 0x494f 13AA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @139F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @13A6 stack[0] = 0x13ab // @13A6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x494f, returns to 0x13AB label_13AB: // Incoming return from call to 0x494F at 0x13AA // Inputs[3] // { // @13AE memory[0x40:0x60] // @13B0 stack[-1] // @13B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 13AB 5B JUMPDEST 13AC 60 PUSH1 0x40 13AE 51 MLOAD 13AF 80 DUP1 13B0 91 SWAP2 13B1 03 SUB 13B2 90 SWAP1 13B3 FD *REVERT // Stack delta = -1 // Outputs[1] { @13B3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_13B4: // Incoming jump from 0x1379, if 0xff & storage[0x0d] / 0x0100 ** 0x01 // Inputs[1] { @13BA storage[0x0d] } 13B4 5B JUMPDEST 13B5 60 PUSH1 0x0d 13B7 60 PUSH1 0x00 13B9 90 SWAP1 13BA 54 SLOAD 13BB 90 SWAP1 13BC 61 PUSH2 0x0100 13BF 0A EXP 13C0 90 SWAP1 13C1 04 DIV 13C2 60 PUSH1 0xff 13C4 16 AND 13C5 15 ISZERO 13C6 61 PUSH2 0x1404 13C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1404, if !(0xff & storage[0x0d] / 0x0100 ** 0x00) label_13CA: // Incoming jump from 0x13C9, if not !(0xff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @13CC memory[0x40:0x60] } 13CA 60 PUSH1 0x40 13CC 51 MLOAD 13CD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 13EE 81 DUP2 13EF 52 MSTORE 13F0 60 PUSH1 0x04 13F2 01 ADD 13F3 61 PUSH2 0x13fb 13F6 90 SWAP1 13F7 61 PUSH2 0x478f 13FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @13F6 stack[0] = 0x13fb // @13F6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x478f, returns to 0x13FB label_13FB: // Incoming return from call to 0x478F at 0x13FA // Inputs[3] // { // @13FE memory[0x40:0x60] // @1400 stack[-1] // @1403 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 13FB 5B JUMPDEST 13FC 60 PUSH1 0x40 13FE 51 MLOAD 13FF 80 DUP1 1400 91 SWAP2 1401 03 SUB 1402 90 SWAP1 1403 FD *REVERT // Stack delta = -1 // Outputs[1] { @1403 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1404: // Incoming jump from 0x13C9, if !(0xff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1407 stack[-1] } 1404 5B JUMPDEST 1405 60 PUSH1 0x04 1407 81 DUP2 1408 11 GT 1409 15 ISZERO 140A 61 PUSH2 0x1448 140D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1448, if !(stack[-1] > 0x04) label_140E: // Incoming jump from 0x140D, if not !(stack[-1] > 0x04) // Inputs[1] { @1410 memory[0x40:0x60] } 140E 60 PUSH1 0x40 1410 51 MLOAD 1411 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1432 81 DUP2 1433 52 MSTORE 1434 60 PUSH1 0x04 1436 01 ADD 1437 61 PUSH2 0x143f 143A 90 SWAP1 143B 61 PUSH2 0x484f 143E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1433 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @143A stack[0] = 0x143f // @143A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x484f, returns to 0x143F label_143F: // Incoming return from call to 0x484F at 0x143E // Inputs[3] // { // @1442 memory[0x40:0x60] // @1444 stack[-1] // @1447 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 143F 5B JUMPDEST 1440 60 PUSH1 0x40 1442 51 MLOAD 1443 80 DUP1 1444 91 SWAP2 1445 03 SUB 1446 90 SWAP1 1447 FD *REVERT // Stack delta = -1 // Outputs[1] { @1447 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1448: // Incoming jump from 0x140D, if !(stack[-1] > 0x04) // Inputs[4] // { // @144B stack[-1] // @1450 msg.sender // @148A memory[0x00:0x40] // @148B storage[keccak256(memory[0x00:0x40])] // } 1448 5B JUMPDEST 1449 60 PUSH1 0x04 144B 81 DUP2 144C 60 PUSH1 0x12 144E 60 PUSH1 0x00 1450 33 CALLER 1451 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1466 16 AND 1467 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 147C 16 AND 147D 81 DUP2 147E 52 MSTORE 147F 60 PUSH1 0x20 1481 01 ADD 1482 90 SWAP1 1483 81 DUP2 1484 52 MSTORE 1485 60 PUSH1 0x20 1487 01 ADD 1488 60 PUSH1 0x00 148A 20 SHA3 148B 54 SLOAD 148C 61 PUSH2 0x1495 148F 91 SWAP2 1490 90 SWAP1 1491 61 PUSH2 0x4ab3 1494 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1449 stack[0] = 0x04 // @147E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1484 memory[0x20:0x40] = 0x12 // @148F stack[1] = 0x1495 // @1490 stack[2] = stack[-1] // @1490 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x4ab3, returns to 0x1495 label_1495: // Incoming return from call to 0x4AB3 at 0x1494 // Inputs[2] // { // @1496 stack[-1] // @1496 stack[-2] // } 1495 5B JUMPDEST 1496 11 GT 1497 15 ISZERO 1498 61 PUSH2 0x14d6 149B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x14d6, if !(stack[-1] > stack[-2]) label_149C: // Incoming jump from 0x149B, if not !(stack[-1] > stack[-2]) // Inputs[1] { @149E memory[0x40:0x60] } 149C 60 PUSH1 0x40 149E 51 MLOAD 149F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14C0 81 DUP2 14C1 52 MSTORE 14C2 60 PUSH1 0x04 14C4 01 ADD 14C5 61 PUSH2 0x14cd 14C8 90 SWAP1 14C9 61 PUSH2 0x46af 14CC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @14C8 stack[0] = 0x14cd // @14C8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x46af, returns to 0x14CD label_14CD: // Incoming return from call to 0x46AF at 0x14CC // Inputs[3] // { // @14D0 memory[0x40:0x60] // @14D2 stack[-1] // @14D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 14CD 5B JUMPDEST 14CE 60 PUSH1 0x40 14D0 51 MLOAD 14D1 80 DUP1 14D2 91 SWAP2 14D3 03 SUB 14D4 90 SWAP1 14D5 FD *REVERT // Stack delta = -1 // Outputs[1] { @14D5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_14D6: // Incoming jump from 0x149B, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @14D9 storage[0x0c] // @14DA stack[-1] // } 14D6 5B JUMPDEST 14D7 60 PUSH1 0x0c 14D9 54 SLOAD 14DA 81 DUP2 14DB 61 PUSH2 0x14e2 14DE 61 PUSH2 0x0c1c 14E1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14D9 stack[0] = storage[0x0c] // @14DA stack[1] = stack[-1] // @14DB stack[2] = 0x14e2 // } // Block ends with call to 0x0c1c, returns to 0x14E2 label_14E2: // Incoming return from call to 0x0C1C at 0x14E1 // Inputs[2] // { // @14E6 stack[-2] // @14E7 stack[-1] // } 14E2 5B JUMPDEST 14E3 61 PUSH2 0x14ec 14E6 91 SWAP2 14E7 90 SWAP1 14E8 61 PUSH2 0x4ab3 14EB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @14E6 stack[-2] = 0x14ec // @14E7 stack[-1] = stack[-2] // @14E7 stack[0] = stack[-1] // } // Block ends with call to 0x4ab3, returns to 0x14EC label_14EC: // Incoming return from call to 0x4AB3 at 0x14EB // Inputs[2] // { // @14ED stack[-2] // @14ED stack[-1] // } 14EC 5B JUMPDEST 14ED 11 GT 14EE 15 ISZERO 14EF 61 PUSH2 0x152d 14F2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x152d, if !(stack[-1] > stack[-2]) label_14F3: // Incoming jump from 0x14F2, if not !(stack[-1] > stack[-2]) // Inputs[1] { @14F5 memory[0x40:0x60] } 14F3 60 PUSH1 0x40 14F5 51 MLOAD 14F6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1517 81 DUP2 1518 52 MSTORE 1519 60 PUSH1 0x04 151B 01 ADD 151C 61 PUSH2 0x1524 151F 90 SWAP1 1520 61 PUSH2 0x480f 1523 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1518 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @151F stack[0] = 0x1524 // @151F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x480f, returns to 0x1524 label_1524: // Incoming return from call to 0x480F at 0x1523 // Inputs[3] // { // @1527 memory[0x40:0x60] // @1529 stack[-1] // @152C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1524 5B JUMPDEST 1525 60 PUSH1 0x40 1527 51 MLOAD 1528 80 DUP1 1529 91 SWAP2 152A 03 SUB 152B 90 SWAP1 152C FD *REVERT // Stack delta = -1 // Outputs[1] { @152C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_152D: // Incoming jump from 0x14F2, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @152E msg.value // @152F stack[-1] // } 152D 5B JUMPDEST 152E 34 CALLVALUE 152F 81 DUP2 1530 67 PUSH8 0x011c37937e080000 1539 61 PUSH2 0x1542 153C 91 SWAP2 153D 90 SWAP1 153E 61 PUSH2 0x4b3a 1541 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @152E stack[0] = msg.value // @153C stack[1] = 0x1542 // @153D stack[2] = stack[-1] // @153D stack[3] = 0x011c37937e080000 // } // Block ends with call to 0x4b3a, returns to 0x1542 label_1542: // Incoming return from call to 0x4B3A at 0x1541 // Inputs[2] // { // @1543 stack[-2] // @1543 stack[-1] // } 1542 5B JUMPDEST 1543 11 GT 1544 15 ISZERO 1545 61 PUSH2 0x1583 1548 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1583, if !(stack[-1] > stack[-2]) label_1549: // Incoming jump from 0x1548, if not !(stack[-1] > stack[-2]) // Inputs[1] { @154B memory[0x40:0x60] } 1549 60 PUSH1 0x40 154B 51 MLOAD 154C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 156D 81 DUP2 156E 52 MSTORE 156F 60 PUSH1 0x04 1571 01 ADD 1572 61 PUSH2 0x157a 1575 90 SWAP1 1576 61 PUSH2 0x472f 1579 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @156E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1575 stack[0] = 0x157a // @1575 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x472f, returns to 0x157A label_157A: // Incoming return from call to 0x472F at 0x1579 // Inputs[3] // { // @157D memory[0x40:0x60] // @157F stack[-1] // @1582 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 157A 5B JUMPDEST 157B 60 PUSH1 0x40 157D 51 MLOAD 157E 80 DUP1 157F 91 SWAP2 1580 03 SUB 1581 90 SWAP1 1582 FD *REVERT // Stack delta = -1 // Outputs[1] { @1582 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1583: // Incoming jump from 0x1548, if !(stack[-1] > stack[-2]) // Inputs[1] { @1587 stack[-1] } 1583 5B JUMPDEST 1584 60 PUSH1 0x00 1586 5B JUMPDEST 1587 81 DUP2 1588 81 DUP2 1589 10 LT 158A 15 ISZERO 158B 61 PUSH2 0x15ca 158E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1584 stack[0] = 0x00 } // Block ends with conditional jump to 0x15ca, if !(0x00 < stack[-1]) label_158F: // Incoming jump from 0x158E, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x158E, if not !(0x00 < stack[-1]) 158F 60 PUSH1 0x00 1591 61 PUSH2 0x1598 1594 61 PUSH2 0x0c1c 1597 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @158F stack[0] = 0x00 // @1591 stack[1] = 0x1598 // } // Block ends with call to 0x0c1c, returns to 0x1598 label_1598: // Incoming return from call to 0x0C1C at 0x1597 // Inputs[3] // { // @1599 stack[-2] // @1599 stack[-1] // @159D storage[0x0c] // } 1598 5B JUMPDEST 1599 90 SWAP1 159A 50 POP 159B 60 PUSH1 0x0c 159D 54 SLOAD 159E 61 PUSH2 0x15a5 15A1 61 PUSH2 0x0c1c 15A4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1599 stack[-2] = stack[-1] // @159D stack[-1] = storage[0x0c] // @159E stack[0] = 0x15a5 // } // Block ends with call to 0x0c1c, returns to 0x15A5 label_15A5: // Incoming return from call to 0x0C1C at 0x15A4 // Inputs[2] // { // @15A6 stack[-2] // @15A6 stack[-1] // } 15A5 5B JUMPDEST 15A6 10 LT 15A7 15 ISZERO 15A8 61 PUSH2 0x15b6 15AB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x15b6, if !(stack[-1] < stack[-2]) label_15AC: // Incoming jump from 0x15AB, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @15AF msg.sender // @15B0 stack[-1] // } 15AC 61 PUSH2 0x15b5 15AF 33 CALLER 15B0 82 DUP3 15B1 61 PUSH2 0x28e1 15B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15AC stack[0] = 0x15b5 // @15AF stack[1] = msg.sender // @15B0 stack[2] = stack[-1] // } // Block ends with call to 0x28e1, returns to 0x15B5 label_15B5: // Incoming return from call to 0x28E1 at 0x15B4 15B5 5B JUMPDEST // Stack delta = +0 // Block continues label_15B6: // Incoming jump from 0x15AB, if !(stack[-1] < stack[-2]) // Incoming jump from 0x15B5 // Inputs[1] { @15B8 stack[-2] } 15B6 5B JUMPDEST 15B7 50 POP 15B8 80 DUP1 15B9 80 DUP1 15BA 61 PUSH2 0x15c2 15BD 90 SWAP1 15BE 61 PUSH2 0x4cb0 15C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15B8 stack[-1] = stack[-2] // @15BD stack[1] = stack[-2] // @15BD stack[0] = 0x15c2 // } // Block ends with call to 0x4cb0, returns to 0x15C2 label_15C2: // Incoming return from call to 0x4CB0 at 0x15C1 // Inputs[2] // { // @15C3 stack[-1] // @15C3 stack[-3] // } 15C2 5B JUMPDEST 15C3 91 SWAP2 15C4 50 POP 15C5 50 POP 15C6 61 PUSH2 0x1586 15C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @15C3 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1586 label_15CA: // Incoming jump from 0x158E, if !(stack[-1] < stack[-2]) // Incoming jump from 0x158E, if !(0x00 < stack[-1]) // Inputs[4] // { // @15CC stack[-2] // @15D1 msg.sender // @160B memory[0x00:0x40] // @160C storage[keccak256(memory[0x00:0x40])] // } 15CA 5B JUMPDEST 15CB 50 POP 15CC 80 DUP1 15CD 60 PUSH1 0x12 15CF 60 PUSH1 0x00 15D1 33 CALLER 15D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15E7 16 AND 15E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15FD 16 AND 15FE 81 DUP2 15FF 52 MSTORE 1600 60 PUSH1 0x20 1602 01 ADD 1603 90 SWAP1 1604 81 DUP2 1605 52 MSTORE 1606 60 PUSH1 0x20 1608 01 ADD 1609 60 PUSH1 0x00 160B 20 SHA3 160C 54 SLOAD 160D 61 PUSH2 0x1616 1610 91 SWAP2 1611 90 SWAP1 1612 61 PUSH2 0x4ab3 1615 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @15FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1605 memory[0x20:0x40] = 0x12 // @1610 stack[-1] = 0x1616 // @1611 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1611 stack[0] = stack[-2] // } // Block ends with call to 0x4ab3, returns to 0x1616 label_1616: // Incoming return from call to 0x4AB3 at 0x1615 // Inputs[4] // { // @161B msg.sender // @1655 memory[0x00:0x40] // @1656 stack[-1] // @165B stack[-3] // } 1616 5B JUMPDEST 1617 60 PUSH1 0x12 1619 60 PUSH1 0x00 161B 33 CALLER 161C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1631 16 AND 1632 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1647 16 AND 1648 81 DUP2 1649 52 MSTORE 164A 60 PUSH1 0x20 164C 01 ADD 164D 90 SWAP1 164E 81 DUP2 164F 52 MSTORE 1650 60 PUSH1 0x20 1652 01 ADD 1653 60 PUSH1 0x00 1655 20 SHA3 1656 81 DUP2 1657 90 SWAP1 1658 55 SSTORE 1659 50 POP 165A 50 POP 165B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1649 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @164F memory[0x20:0x40] = 0x12 // @1658 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_165C: // Incoming call from 0x32FD, returns to 0x32FE // Incoming call from 0x0DA9, returns to 0x0DAA // Incoming jump from 0x0608 // Incoming call from 0x35AB, returns to 0x35AC // Inputs[1] { @1676 stack[-1] } 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 80 DUP1 1660 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1675 16 AND 1676 82 DUP3 1677 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 168C 16 AND 168D 14 EQ 168E 15 ISZERO 168F 61 PUSH2 0x16cd 1692 57 *JUMPI // Stack delta = +1 // Outputs[1] { @165D stack[0] = 0x00 } // Block ends with conditional jump to 0x16cd, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1693: // Incoming jump from 0x1692, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1695 memory[0x40:0x60] } 1693 60 PUSH1 0x40 1695 51 MLOAD 1696 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16B7 81 DUP2 16B8 52 MSTORE 16B9 60 PUSH1 0x04 16BB 01 ADD 16BC 61 PUSH2 0x16c4 16BF 90 SWAP1 16C0 61 PUSH2 0x47cf 16C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @16BF stack[0] = 0x16c4 // @16BF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x47cf, returns to 0x16C4 label_16C4: // Incoming return from call to 0x47CF at 0x16C3 // Inputs[3] // { // @16C7 memory[0x40:0x60] // @16C9 stack[-1] // @16CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 16C4 5B JUMPDEST 16C5 60 PUSH1 0x40 16C7 51 MLOAD 16C8 80 DUP1 16C9 91 SWAP2 16CA 03 SUB 16CB 90 SWAP1 16CC FD *REVERT // Stack delta = -1 // Outputs[1] { @16CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_16CD: // Incoming jump from 0x1692, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @16D2 stack[-2] // @170C memory[0x00:0x40] // @170D storage[keccak256(memory[0x00:0x40])] // @170E stack[-1] // @1710 stack[-3] // } 16CD 5B JUMPDEST 16CE 60 PUSH1 0x03 16D0 60 PUSH1 0x00 16D2 83 DUP4 16D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16E8 16 AND 16E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16FE 16 AND 16FF 81 DUP2 1700 52 MSTORE 1701 60 PUSH1 0x20 1703 01 ADD 1704 90 SWAP1 1705 81 DUP2 1706 52 MSTORE 1707 60 PUSH1 0x20 1709 01 ADD 170A 60 PUSH1 0x00 170C 20 SHA3 170D 54 SLOAD 170E 90 SWAP1 170F 50 POP 1710 91 SWAP2 1711 90 SWAP1 1712 50 POP 1713 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1700 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1706 memory[0x20:0x40] = 0x03 // @1710 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1714: // Incoming call from 0x0633, returns to 0x0634 1714 5B JUMPDEST 1715 61 PUSH2 0x171c 1718 61 PUSH2 0x24e6 171B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1715 stack[0] = 0x171c } // Block ends with call to 0x24e6, returns to 0x171C label_171C: // Incoming return from call to 0x24E6 at 0x171B // Inputs[1] { @1732 stack[-1] } 171C 5B JUMPDEST 171D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1732 16 AND 1733 61 PUSH2 0x173a 1736 61 PUSH2 0x17ae 1739 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1732 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1733 stack[0] = 0x173a // } // Block ends with call to 0x17ae, returns to 0x173A label_173A: // Incoming return from call to 0x17AE at 0x1739 // Inputs[2] // { // @1750 stack[-1] // @1751 stack[-2] // } 173A 5B JUMPDEST 173B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1750 16 AND 1751 14 EQ 1752 61 PUSH2 0x1790 1755 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1790, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1756: // Incoming jump from 0x1755, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1758 memory[0x40:0x60] } 1756 60 PUSH1 0x40 1758 51 MLOAD 1759 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 177A 81 DUP2 177B 52 MSTORE 177C 60 PUSH1 0x04 177E 01 ADD 177F 61 PUSH2 0x1787 1782 90 SWAP1 1783 61 PUSH2 0x488f 1786 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @177B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1782 stack[0] = 0x1787 // @1782 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x1787 label_1787: // Incoming return from call to 0x488F at 0x1786 // Inputs[3] // { // @178A memory[0x40:0x60] // @178C stack[-1] // @178F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1787 5B JUMPDEST 1788 60 PUSH1 0x40 178A 51 MLOAD 178B 80 DUP1 178C 91 SWAP2 178D 03 SUB 178E 90 SWAP1 178F FD *REVERT // Stack delta = -1 // Outputs[1] { @178F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1790: // Incoming jump from 0x1755, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] 1790 5B JUMPDEST 1791 61 PUSH2 0x179a 1794 60 PUSH1 0x00 1796 61 PUSH2 0x28ff 1799 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1791 stack[0] = 0x179a // @1794 stack[1] = 0x00 // } // Block ends with call to 0x28ff, returns to 0x179A label_179A: // Incoming return from call to 0x28FF at 0x1799 // Inputs[1] { @179B stack[-1] } 179A 5B JUMPDEST 179B 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_179C: // Incoming call from 0x064A, returns to 0x064B // Inputs[1] { @17A0 stack[-1] } 179C 5B JUMPDEST 179D 61 PUSH2 0x22b8 17A0 81 DUP2 17A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @179D stack[0] = 0x22b8 } // Block ends with unconditional jump to stack[-1] label_17A2: // Incoming call from 0x0675, returns to 0x0676 // Inputs[1] { @17AC stack[-1] } 17A2 5B JUMPDEST 17A3 67 PUSH8 0x011c37937e080000 17AC 81 DUP2 17AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @17A3 stack[0] = 0x011c37937e080000 } // Block ends with unconditional jump to stack[-1] label_17AE: // Incoming call from 0x0E69, returns to 0x0E6A // Incoming call from 0x2153, returns to 0x2154 // Incoming call from 0x1A10, returns to 0x1A11 // Incoming call from 0x1739, returns to 0x173A // Incoming call from 0x21FB, returns to 0x21FC // Incoming call from 0x11B4, returns to 0x11B5 // Incoming call from 0x2291, returns to 0x2292 // Incoming call from 0x101F, returns to 0x1020 // Incoming call from 0x0CC1, returns to 0x0CC2 // Incoming call from 0x0F77, returns to 0x0F78 // Incoming call from 0x06A0, returns to 0x06A1 // Incoming call from 0x1AA9, returns to 0x1AAA // Incoming call from 0x238F, returns to 0x2390 // Inputs[2] // { // @17B6 storage[0x0a] // @17D6 stack[-1] // } 17AE 5B JUMPDEST 17AF 60 PUSH1 0x00 17B1 60 PUSH1 0x0a 17B3 60 PUSH1 0x00 17B5 90 SWAP1 17B6 54 SLOAD 17B7 90 SWAP1 17B8 61 PUSH2 0x0100 17BB 0A EXP 17BC 90 SWAP1 17BD 04 DIV 17BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D3 16 AND 17D4 90 SWAP1 17D5 50 POP 17D6 90 SWAP1 17D7 56 *JUMP // Stack delta = +0 // Outputs[1] { @17D6 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_17D8: // Incoming call from 0x06CB, returns to 0x06CC // Inputs[1] { @17DE storage[0x01] } 17D8 5B JUMPDEST 17D9 60 PUSH1 0x60 17DB 60 PUSH1 0x01 17DD 80 DUP1 17DE 54 SLOAD 17DF 61 PUSH2 0x17e7 17E2 90 SWAP1 17E3 61 PUSH2 0x4c7e 17E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @17D9 stack[0] = 0x60 // @17DB stack[1] = 0x01 // @17E2 stack[2] = 0x17e7 // @17E2 stack[3] = storage[0x01] // } // Block ends with call to 0x4c7e, returns to 0x17E7 label_17E7: // Incoming return from call to 0x4C7E at 0x17E6 // Inputs[4] // { // @17E8 stack[-1] // @17F7 memory[0x40:0x60] // @17FF stack[-2] // @180A storage[stack[-2]] // } 17E7 5B JUMPDEST 17E8 80 DUP1 17E9 60 PUSH1 0x1f 17EB 01 ADD 17EC 60 PUSH1 0x20 17EE 80 DUP1 17EF 91 SWAP2 17F0 04 DIV 17F1 02 MUL 17F2 60 PUSH1 0x20 17F4 01 ADD 17F5 60 PUSH1 0x40 17F7 51 MLOAD 17F8 90 SWAP1 17F9 81 DUP2 17FA 01 ADD 17FB 60 PUSH1 0x40 17FD 52 MSTORE 17FE 80 DUP1 17FF 92 SWAP3 1800 91 SWAP2 1801 90 SWAP1 1802 81 DUP2 1803 81 DUP2 1804 52 MSTORE 1805 60 PUSH1 0x20 1807 01 ADD 1808 82 DUP3 1809 80 DUP1 180A 54 SLOAD 180B 61 PUSH2 0x1813 180E 90 SWAP1 180F 61 PUSH2 0x4c7e 1812 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @17FD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @17FF stack[-2] = memory[0x40:0x60] // @1800 stack[-1] = stack[-2] // @1801 stack[0] = stack[-1] // @1804 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1807 stack[1] = 0x20 + memory[0x40:0x60] // @1808 stack[2] = stack[-2] // @180E stack[4] = storage[stack[-2]] // @180E stack[3] = 0x1813 // } // Block ends with call to 0x4c7e, returns to 0x1813 label_1813: // Incoming return from call to 0x4C7E at 0x1812 // Inputs[1] { @1814 stack[-1] } 1813 5B JUMPDEST 1814 80 DUP1 1815 15 ISZERO 1816 61 PUSH2 0x1860 1819 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1860, if !stack[-1] label_181A: // Incoming jump from 0x1819, if not !stack[-1] // Inputs[1] { @181A stack[-1] } 181A 80 DUP1 181B 60 PUSH1 0x1f 181D 10 LT 181E 61 PUSH2 0x1835 1821 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1835, if 0x1f < stack[-1] label_1822: // Incoming jump from 0x1821, if not 0x1f < stack[-1] // Inputs[4] // { // @1826 stack[-2] // @1827 storage[stack[-2]] // @182A stack[-3] // @182C stack[-1] // } 1822 61 PUSH2 0x0100 1825 80 DUP1 1826 83 DUP4 1827 54 SLOAD 1828 04 DIV 1829 02 MUL 182A 83 DUP4 182B 52 MSTORE 182C 91 SWAP2 182D 60 PUSH1 0x20 182F 01 ADD 1830 91 SWAP2 1831 61 PUSH2 0x1860 1834 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @182B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1830 stack[-1] = stack[-1] // @1830 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1860 label_1835: // Incoming jump from 0x1821, if 0x1f < stack[-1] // Inputs[5] // { // @1836 stack[-3] // @1837 stack[-1] // @1839 stack[-2] // @1841 memory[0x00:0x20] // @1845 storage[keccak256(memory[0x00:0x20])] // } 1835 5B JUMPDEST 1836 82 DUP3 1837 01 ADD 1838 91 SWAP2 1839 90 SWAP1 183A 60 PUSH1 0x00 183C 52 MSTORE 183D 60 PUSH1 0x20 183F 60 PUSH1 0x00 1841 20 SHA3 1842 90 SWAP1 1843 5B JUMPDEST 1844 81 DUP2 1845 54 SLOAD 1846 81 DUP2 1847 52 MSTORE 1848 90 SWAP1 1849 60 PUSH1 0x01 184B 01 ADD 184C 90 SWAP1 184D 60 PUSH1 0x20 184F 01 ADD 1850 80 DUP1 1851 83 DUP4 1852 11 GT 1853 61 PUSH2 0x1843 1856 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1838 stack[-3] = stack[-3] + stack[-1] // @183C memory[0x00:0x20] = stack[-2] // @1847 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @184C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @184F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1843, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1857: // Incoming jump from 0x1856, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1856, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1857 stack[-3] // @1858 stack[-1] // } 1857 82 DUP3 1858 90 SWAP1 1859 03 SUB 185A 60 PUSH1 0x1f 185C 16 AND 185D 82 DUP3 185E 01 ADD 185F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @185F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @185F stack[-1] = stack[-3] // } // Block continues label_1860: // Incoming jump from 0x1819, if !stack[-1] // Incoming jump from 0x1834 // Incoming jump from 0x185F // Inputs[3] // { // @1866 stack[-7] // @1866 stack[-6] // @1868 stack[-8] // } 1860 5B JUMPDEST 1861 50 POP 1862 50 POP 1863 50 POP 1864 50 POP 1865 50 POP 1866 90 SWAP1 1867 50 POP 1868 90 SWAP1 1869 56 *JUMP // Stack delta = -7 // Outputs[1] { @1868 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_186A: // Incoming jump from 0x0708 186A 5B JUMPDEST 186B 61 PUSH2 0x1872 186E 61 PUSH2 0x24e6 1871 56 *JUMP // Stack delta = +1 // Outputs[1] { @186B stack[0] = 0x1872 } // Block ends with call to 0x24e6, returns to 0x1872 label_1872: // Incoming return from call to 0x24E6 at 0x1871 // Inputs[2] // { // @1888 stack[-1] // @1889 stack[-3] // } 1872 5B JUMPDEST 1873 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1888 16 AND 1889 82 DUP3 188A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 189F 16 AND 18A0 14 EQ 18A1 15 ISZERO 18A2 61 PUSH2 0x18e0 18A5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18e0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_18A6: // Incoming jump from 0x18A5, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @18A8 memory[0x40:0x60] } 18A6 60 PUSH1 0x40 18A8 51 MLOAD 18A9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 18CA 81 DUP2 18CB 52 MSTORE 18CC 60 PUSH1 0x04 18CE 01 ADD 18CF 61 PUSH2 0x18d7 18D2 90 SWAP1 18D3 61 PUSH2 0x470f 18D6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @18D2 stack[0] = 0x18d7 // @18D2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x470f, returns to 0x18D7 label_18D7: // Incoming return from call to 0x470F at 0x18D6 // Inputs[3] // { // @18DA memory[0x40:0x60] // @18DC stack[-1] // @18DF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 18D7 5B JUMPDEST 18D8 60 PUSH1 0x40 18DA 51 MLOAD 18DB 80 DUP1 18DC 91 SWAP2 18DD 03 SUB 18DE 90 SWAP1 18DF FD *REVERT // Stack delta = -1 // Outputs[1] { @18DF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_18E0: // Incoming jump from 0x18A5, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @18E1 stack[-1] } 18E0 5B JUMPDEST 18E1 80 DUP1 18E2 60 PUSH1 0x05 18E4 60 PUSH1 0x00 18E6 61 PUSH2 0x18ed 18E9 61 PUSH2 0x24e6 18EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18E1 stack[0] = stack[-1] // @18E2 stack[1] = 0x05 // @18E4 stack[2] = 0x00 // @18E6 stack[3] = 0x18ed // } // Block ends with call to 0x24e6, returns to 0x18ED label_18ED: // Incoming return from call to 0x24E6 at 0x18EC // Inputs[8] // { // @1903 stack[-1] // @191A stack[-2] // @191F stack[-3] // @1927 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @192A stack[-6] // @1964 memory[0x00:0x40] // @196C storage[keccak256(memory[0x00:0x40])] // @1974 stack[-4] // } 18ED 5B JUMPDEST 18EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1903 16 AND 1904 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1919 16 AND 191A 81 DUP2 191B 52 MSTORE 191C 60 PUSH1 0x20 191E 01 ADD 191F 90 SWAP1 1920 81 DUP2 1921 52 MSTORE 1922 60 PUSH1 0x20 1924 01 ADD 1925 60 PUSH1 0x00 1927 20 SHA3 1928 60 PUSH1 0x00 192A 84 DUP5 192B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1940 16 AND 1941 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1956 16 AND 1957 81 DUP2 1958 52 MSTORE 1959 60 PUSH1 0x20 195B 01 ADD 195C 90 SWAP1 195D 81 DUP2 195E 52 MSTORE 195F 60 PUSH1 0x20 1961 01 ADD 1962 60 PUSH1 0x00 1964 20 SHA3 1965 60 PUSH1 0x00 1967 61 PUSH2 0x0100 196A 0A EXP 196B 81 DUP2 196C 54 SLOAD 196D 81 DUP2 196E 60 PUSH1 0xff 1970 02 MUL 1971 19 NOT 1972 16 AND 1973 90 SWAP1 1974 83 DUP4 1975 15 ISZERO 1976 15 ISZERO 1977 02 MUL 1978 17 OR 1979 90 SWAP1 197A 55 SSTORE 197B 50 POP 197C 81 DUP2 197D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1992 16 AND 1993 61 PUSH2 0x199a 1996 61 PUSH2 0x24e6 1999 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @191B memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1921 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @1958 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @195E memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @197A storage[keccak256(memory[0x00:0x40])] = !!stack[-4] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1992 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1993 stack[-3] = 0x199a // } // Block ends with call to 0x24e6, returns to 0x199A label_199A: // Incoming return from call to 0x24E6 at 0x1999 // Inputs[3] // { // @19B0 stack[-1] // @19D2 stack[-3] // @19D5 memory[0x40:0x60] // } 199A 5B JUMPDEST 199B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19B0 16 AND 19B1 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 19D2 83 DUP4 19D3 60 PUSH1 0x40 19D5 51 MLOAD 19D6 61 PUSH2 0x19df 19D9 91 SWAP2 19DA 90 SWAP1 19DB 61 PUSH2 0x45f2 19DE 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @19B0 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @19B1 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @19D9 stack[1] = 0x19df // @19DA stack[3] = memory[0x40:0x60] // @19DA stack[2] = stack[-3] // } // Block ends with call to 0x45f2, returns to 0x19DF label_19DF: // Incoming return from call to 0x45F2 at 0x19DE // Inputs[7] // { // @19E2 memory[0x40:0x60] // @19E4 stack[-1] // @19E7 stack[-3] // @19E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @19E7 stack[-4] // @19E7 stack[-2] // @19EA stack[-7] // } 19DF 5B JUMPDEST 19E0 60 PUSH1 0x40 19E2 51 MLOAD 19E3 80 DUP1 19E4 91 SWAP2 19E5 03 SUB 19E6 90 SWAP1 19E7 A3 LOG3 19E8 50 POP 19E9 50 POP 19EA 56 *JUMP // Stack delta = -7 // Outputs[1] { @19E7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_19EB: // Incoming call from 0x071F, returns to 0x0720 19EB 5B JUMPDEST 19EC 61 PUSH2 0x19f3 19EF 61 PUSH2 0x24e6 19F2 56 *JUMP // Stack delta = +1 // Outputs[1] { @19EC stack[0] = 0x19f3 } // Block ends with call to 0x24e6, returns to 0x19F3 label_19F3: // Incoming return from call to 0x24E6 at 0x19F2 // Inputs[1] { @1A09 stack[-1] } 19F3 5B JUMPDEST 19F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A09 16 AND 1A0A 61 PUSH2 0x1a11 1A0D 61 PUSH2 0x17ae 1A10 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1A09 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1A0A stack[0] = 0x1a11 // } // Block ends with call to 0x17ae, returns to 0x1A11 label_1A11: // Incoming return from call to 0x17AE at 0x1A10 // Inputs[2] // { // @1A27 stack[-1] // @1A28 stack[-2] // } 1A11 5B JUMPDEST 1A12 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A27 16 AND 1A28 14 EQ 1A29 61 PUSH2 0x1a67 1A2C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a67, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1A2D: // Incoming jump from 0x1A2C, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1A2F memory[0x40:0x60] } 1A2D 60 PUSH1 0x40 1A2F 51 MLOAD 1A30 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A51 81 DUP2 1A52 52 MSTORE 1A53 60 PUSH1 0x04 1A55 01 ADD 1A56 61 PUSH2 0x1a5e 1A59 90 SWAP1 1A5A 61 PUSH2 0x488f 1A5D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1A52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1A59 stack[0] = 0x1a5e // @1A59 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x1A5E label_1A5E: // Incoming return from call to 0x488F at 0x1A5D // Inputs[3] // { // @1A61 memory[0x40:0x60] // @1A63 stack[-1] // @1A66 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1A5E 5B JUMPDEST 1A5F 60 PUSH1 0x40 1A61 51 MLOAD 1A62 80 DUP1 1A63 91 SWAP2 1A64 03 SUB 1A65 90 SWAP1 1A66 FD *REVERT // Stack delta = -1 // Outputs[1] { @1A66 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1A67: // Incoming jump from 0x1A2C, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @1A73 storage[0x0d] // @1A83 stack[-1] // } 1A67 5B JUMPDEST 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0x0d 1A6C 60 PUSH1 0x02 1A6E 61 PUSH2 0x0100 1A71 0A EXP 1A72 81 DUP2 1A73 54 SLOAD 1A74 81 DUP2 1A75 60 PUSH1 0xff 1A77 02 MUL 1A78 19 NOT 1A79 16 AND 1A7A 90 SWAP1 1A7B 83 DUP4 1A7C 15 ISZERO 1A7D 15 ISZERO 1A7E 02 MUL 1A7F 17 OR 1A80 90 SWAP1 1A81 55 SSTORE 1A82 50 POP 1A83 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A81 storage[0x0d] = !!0x01 * 0x0100 ** 0x02 | (~(0xff * 0x0100 ** 0x02) & storage[0x0d]) } // Block ends with unconditional jump to stack[-1] label_1A84: // Incoming jump from 0x0748 1A84 5B JUMPDEST 1A85 61 PUSH2 0x1a8c 1A88 61 PUSH2 0x24e6 1A8B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A85 stack[0] = 0x1a8c } // Block ends with call to 0x24e6, returns to 0x1A8C label_1A8C: // Incoming return from call to 0x24E6 at 0x1A8B // Inputs[1] { @1AA2 stack[-1] } 1A8C 5B JUMPDEST 1A8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AA2 16 AND 1AA3 61 PUSH2 0x1aaa 1AA6 61 PUSH2 0x17ae 1AA9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1AA2 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1AA3 stack[0] = 0x1aaa // } // Block ends with call to 0x17ae, returns to 0x1AAA label_1AAA: // Incoming return from call to 0x17AE at 0x1AA9 // Inputs[2] // { // @1AC0 stack[-1] // @1AC1 stack[-2] // } 1AAA 5B JUMPDEST 1AAB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AC0 16 AND 1AC1 14 EQ 1AC2 61 PUSH2 0x1b00 1AC5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1b00, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1AC6: // Incoming jump from 0x1AC5, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1AC8 memory[0x40:0x60] } 1AC6 60 PUSH1 0x40 1AC8 51 MLOAD 1AC9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1AEA 81 DUP2 1AEB 52 MSTORE 1AEC 60 PUSH1 0x04 1AEE 01 ADD 1AEF 61 PUSH2 0x1af7 1AF2 90 SWAP1 1AF3 61 PUSH2 0x488f 1AF6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1AF2 stack[0] = 0x1af7 // @1AF2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x1AF7 label_1AF7: // Incoming return from call to 0x488F at 0x1AF6 // Inputs[3] // { // @1AFA memory[0x40:0x60] // @1AFC stack[-1] // @1AFF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1AF7 5B JUMPDEST 1AF8 60 PUSH1 0x40 1AFA 51 MLOAD 1AFB 80 DUP1 1AFC 91 SWAP2 1AFD 03 SUB 1AFE 90 SWAP1 1AFF FD *REVERT // Stack delta = -1 // Outputs[1] { @1AFF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1B00: // Incoming jump from 0x1AC5, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[4] // { // @1B07 stack[-1] // @1B41 memory[0x00:0x40] // @1B49 storage[keccak256(memory[0x00:0x40])] // @1B7D memory[0x40:0x60] // } 1B00 5B JUMPDEST 1B01 60 PUSH1 0x00 1B03 60 PUSH1 0x11 1B05 60 PUSH1 0x00 1B07 83 DUP4 1B08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B1D 16 AND 1B1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B33 16 AND 1B34 81 DUP2 1B35 52 MSTORE 1B36 60 PUSH1 0x20 1B38 01 ADD 1B39 90 SWAP1 1B3A 81 DUP2 1B3B 52 MSTORE 1B3C 60 PUSH1 0x20 1B3E 01 ADD 1B3F 60 PUSH1 0x00 1B41 20 SHA3 1B42 60 PUSH1 0x00 1B44 61 PUSH2 0x0100 1B47 0A EXP 1B48 81 DUP2 1B49 54 SLOAD 1B4A 81 DUP2 1B4B 60 PUSH1 0xff 1B4D 02 MUL 1B4E 19 NOT 1B4F 16 AND 1B50 90 SWAP1 1B51 83 DUP4 1B52 15 ISZERO 1B53 15 ISZERO 1B54 02 MUL 1B55 17 OR 1B56 90 SWAP1 1B57 55 SSTORE 1B58 50 POP 1B59 7F PUSH32 0xf4d05032556b7a946737f39b95e07890ce0335b8d0ea912ac5b9ed95710dbb83 1B7A 81 DUP2 1B7B 60 PUSH1 0x40 1B7D 51 MLOAD 1B7E 61 PUSH2 0x1b87 1B81 91 SWAP2 1B82 90 SWAP1 1B83 61 PUSH2 0x458b 1B86 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1B35 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1B3B memory[0x20:0x40] = 0x11 // @1B57 storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1B59 stack[0] = 0xf4d05032556b7a946737f39b95e07890ce0335b8d0ea912ac5b9ed95710dbb83 // @1B81 stack[1] = 0x1b87 // @1B82 stack[2] = stack[-1] // @1B82 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x458b, returns to 0x1B87 label_1B87: // Incoming return from call to 0x458B at 0x1B86 // Inputs[5] // { // @1B8A memory[0x40:0x60] // @1B8C stack[-1] // @1B8F stack[-2] // @1B8F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1B91 stack[-4] // } 1B87 5B JUMPDEST 1B88 60 PUSH1 0x40 1B8A 51 MLOAD 1B8B 80 DUP1 1B8C 91 SWAP2 1B8D 03 SUB 1B8E 90 SWAP1 1B8F A1 LOG1 1B90 50 POP 1B91 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B8F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_1B92: // Incoming jump from 0x0771 // Incoming call from 0x10DF, returns to 0x10E0 1B92 5B JUMPDEST 1B93 61 PUSH2 0x1ba3 1B96 61 PUSH2 0x1b9d 1B99 61 PUSH2 0x24e6 1B9C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B93 stack[0] = 0x1ba3 // @1B96 stack[1] = 0x1b9d // } // Block ends with call to 0x24e6, returns to 0x1B9D label_1B9D: // Incoming return from call to 0x24E6 at 0x1B9C // Inputs[1] { @1B9E stack[-4] } 1B9D 5B JUMPDEST 1B9E 83 DUP4 1B9F 61 PUSH2 0x25a7 1BA2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B9E stack[0] = stack[-4] } // Block ends with unconditional jump to 0x25a7 label_1BA3: // Incoming return from call to 0x1B9D at 0x1B9C // Inputs[1] { @1BA7 stack[-1] } 1BA3 5B JUMPDEST 1BA4 61 PUSH2 0x1be2 1BA7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1be2, if stack[-1] label_1BA8: // Incoming jump from 0x1BA7, if not stack[-1] // Inputs[1] { @1BAA memory[0x40:0x60] } 1BA8 60 PUSH1 0x40 1BAA 51 MLOAD 1BAB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BCC 81 DUP2 1BCD 52 MSTORE 1BCE 60 PUSH1 0x04 1BD0 01 ADD 1BD1 61 PUSH2 0x1bd9 1BD4 90 SWAP1 1BD5 61 PUSH2 0x496f 1BD8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1BCD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BD4 stack[0] = 0x1bd9 // @1BD4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x496f, returns to 0x1BD9 label_1BD9: // Incoming return from call to 0x496F at 0x1BD8 // Inputs[3] // { // @1BDC memory[0x40:0x60] // @1BDE stack[-1] // @1BE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1BD9 5B JUMPDEST 1BDA 60 PUSH1 0x40 1BDC 51 MLOAD 1BDD 80 DUP1 1BDE 91 SWAP2 1BDF 03 SUB 1BE0 90 SWAP1 1BE1 FD *REVERT // Stack delta = -1 // Outputs[1] { @1BE1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1BE2: // Incoming jump from 0x1BA7, if stack[-1] // Inputs[4] // { // @1BE6 stack[-4] // @1BE7 stack[-3] // @1BE8 stack[-2] // @1BE9 stack[-1] // } 1BE2 5B JUMPDEST 1BE3 61 PUSH2 0x1bee 1BE6 84 DUP5 1BE7 84 DUP5 1BE8 84 DUP5 1BE9 84 DUP5 1BEA 61 PUSH2 0x29c5 1BED 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1BE3 stack[0] = 0x1bee // @1BE6 stack[1] = stack[-4] // @1BE7 stack[2] = stack[-3] // @1BE8 stack[3] = stack[-2] // @1BE9 stack[4] = stack[-1] // } // Block ends with call to 0x29c5, returns to 0x1BEE label_1BEE: // Incoming return from call to 0x29C5 at 0x1BED // Inputs[1] { @1BF3 stack[-5] } 1BEE 5B JUMPDEST 1BEF 50 POP 1BF0 50 POP 1BF1 50 POP 1BF2 50 POP 1BF3 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1BF4: // Incoming jump from 0x078D // Inputs[1] { @1BFA storage[0x0d] } 1BF4 5B JUMPDEST 1BF5 60 PUSH1 0x0d 1BF7 60 PUSH1 0x00 1BF9 90 SWAP1 1BFA 54 SLOAD 1BFB 90 SWAP1 1BFC 61 PUSH2 0x0100 1BFF 0A EXP 1C00 90 SWAP1 1C01 04 DIV 1C02 60 PUSH1 0xff 1C04 16 AND 1C05 61 PUSH2 0x1c43 1C08 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c43, if 0xff & storage[0x0d] / 0x0100 ** 0x00 label_1C09: // Incoming jump from 0x1C08, if not 0xff & storage[0x0d] / 0x0100 ** 0x00 // Inputs[1] { @1C0B memory[0x40:0x60] } 1C09 60 PUSH1 0x40 1C0B 51 MLOAD 1C0C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C2D 81 DUP2 1C2E 52 MSTORE 1C2F 60 PUSH1 0x04 1C31 01 ADD 1C32 61 PUSH2 0x1c3a 1C35 90 SWAP1 1C36 61 PUSH2 0x474f 1C39 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C35 stack[0] = 0x1c3a // @1C35 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x474f, returns to 0x1C3A label_1C3A: // Incoming return from call to 0x474F at 0x1C39 // Inputs[3] // { // @1C3D memory[0x40:0x60] // @1C3F stack[-1] // @1C42 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1C3A 5B JUMPDEST 1C3B 60 PUSH1 0x40 1C3D 51 MLOAD 1C3E 80 DUP1 1C3F 91 SWAP2 1C40 03 SUB 1C41 90 SWAP1 1C42 FD *REVERT // Stack delta = -1 // Outputs[1] { @1C42 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1C43: // Incoming jump from 0x1C08, if 0xff & storage[0x0d] / 0x0100 ** 0x00 // Inputs[1] { @1C46 stack[-1] } 1C43 5B JUMPDEST 1C44 60 PUSH1 0x08 1C46 81 DUP2 1C47 11 GT 1C48 15 ISZERO 1C49 61 PUSH2 0x1c87 1C4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c87, if !(stack[-1] > 0x08) label_1C4D: // Incoming jump from 0x1C4C, if not !(stack[-1] > 0x08) // Inputs[1] { @1C4F memory[0x40:0x60] } 1C4D 60 PUSH1 0x40 1C4F 51 MLOAD 1C50 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C71 81 DUP2 1C72 52 MSTORE 1C73 60 PUSH1 0x04 1C75 01 ADD 1C76 61 PUSH2 0x1c7e 1C79 90 SWAP1 1C7A 61 PUSH2 0x492f 1C7D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C79 stack[0] = 0x1c7e // @1C79 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x492f, returns to 0x1C7E label_1C7E: // Incoming return from call to 0x492F at 0x1C7D // Inputs[3] // { // @1C81 memory[0x40:0x60] // @1C83 stack[-1] // @1C86 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1C7E 5B JUMPDEST 1C7F 60 PUSH1 0x40 1C81 51 MLOAD 1C82 80 DUP1 1C83 91 SWAP2 1C84 03 SUB 1C85 90 SWAP1 1C86 FD *REVERT // Stack delta = -1 // Outputs[1] { @1C86 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1C87: // Incoming jump from 0x1C4C, if !(stack[-1] > 0x08) // Inputs[4] // { // @1C8A stack[-1] // @1C8F msg.sender // @1CC9 memory[0x00:0x40] // @1CCA storage[keccak256(memory[0x00:0x40])] // } 1C87 5B JUMPDEST 1C88 60 PUSH1 0x08 1C8A 81 DUP2 1C8B 60 PUSH1 0x12 1C8D 60 PUSH1 0x00 1C8F 33 CALLER 1C90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA5 16 AND 1CA6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CBB 16 AND 1CBC 81 DUP2 1CBD 52 MSTORE 1CBE 60 PUSH1 0x20 1CC0 01 ADD 1CC1 90 SWAP1 1CC2 81 DUP2 1CC3 52 MSTORE 1CC4 60 PUSH1 0x20 1CC6 01 ADD 1CC7 60 PUSH1 0x00 1CC9 20 SHA3 1CCA 54 SLOAD 1CCB 61 PUSH2 0x1cd4 1CCE 91 SWAP2 1CCF 90 SWAP1 1CD0 61 PUSH2 0x4ab3 1CD3 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1C88 stack[0] = 0x08 // @1CBD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1CC3 memory[0x20:0x40] = 0x12 // @1CCE stack[1] = 0x1cd4 // @1CCF stack[2] = stack[-1] // @1CCF stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x4ab3, returns to 0x1CD4 label_1CD4: // Incoming return from call to 0x4AB3 at 0x1CD3 // Inputs[2] // { // @1CD5 stack[-2] // @1CD5 stack[-1] // } 1CD4 5B JUMPDEST 1CD5 11 GT 1CD6 15 ISZERO 1CD7 61 PUSH2 0x1d15 1CDA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d15, if !(stack[-1] > stack[-2]) label_1CDB: // Incoming jump from 0x1CDA, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1CDD memory[0x40:0x60] } 1CDB 60 PUSH1 0x40 1CDD 51 MLOAD 1CDE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1CFF 81 DUP2 1D00 52 MSTORE 1D01 60 PUSH1 0x04 1D03 01 ADD 1D04 61 PUSH2 0x1d0c 1D07 90 SWAP1 1D08 61 PUSH2 0x46cf 1D0B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1D07 stack[0] = 0x1d0c // @1D07 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x46cf, returns to 0x1D0C label_1D0C: // Incoming return from call to 0x46CF at 0x1D0B // Inputs[3] // { // @1D0F memory[0x40:0x60] // @1D11 stack[-1] // @1D14 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1D0C 5B JUMPDEST 1D0D 60 PUSH1 0x40 1D0F 51 MLOAD 1D10 80 DUP1 1D11 91 SWAP2 1D12 03 SUB 1D13 90 SWAP1 1D14 FD *REVERT // Stack delta = -1 // Outputs[1] { @1D14 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1D15: // Incoming jump from 0x1CDA, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1D18 storage[0x0c] // @1D19 stack[-1] // } 1D15 5B JUMPDEST 1D16 60 PUSH1 0x0c 1D18 54 SLOAD 1D19 81 DUP2 1D1A 61 PUSH2 0x1d21 1D1D 61 PUSH2 0x0c1c 1D20 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D18 stack[0] = storage[0x0c] // @1D19 stack[1] = stack[-1] // @1D1A stack[2] = 0x1d21 // } // Block ends with call to 0x0c1c, returns to 0x1D21 label_1D21: // Incoming return from call to 0x0C1C at 0x1D20 // Inputs[2] // { // @1D25 stack[-2] // @1D26 stack[-1] // } 1D21 5B JUMPDEST 1D22 61 PUSH2 0x1d2b 1D25 91 SWAP2 1D26 90 SWAP1 1D27 61 PUSH2 0x4ab3 1D2A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D25 stack[-2] = 0x1d2b // @1D26 stack[-1] = stack[-2] // @1D26 stack[0] = stack[-1] // } // Block ends with call to 0x4ab3, returns to 0x1D2B label_1D2B: // Incoming return from call to 0x4AB3 at 0x1D2A // Inputs[2] // { // @1D2C stack[-2] // @1D2C stack[-1] // } 1D2B 5B JUMPDEST 1D2C 11 GT 1D2D 15 ISZERO 1D2E 61 PUSH2 0x1d6c 1D31 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d6c, if !(stack[-1] > stack[-2]) label_1D32: // Incoming jump from 0x1D31, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1D34 memory[0x40:0x60] } 1D32 60 PUSH1 0x40 1D34 51 MLOAD 1D35 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1D56 81 DUP2 1D57 52 MSTORE 1D58 60 PUSH1 0x04 1D5A 01 ADD 1D5B 61 PUSH2 0x1d63 1D5E 90 SWAP1 1D5F 61 PUSH2 0x480f 1D62 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1D5E stack[0] = 0x1d63 // @1D5E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x480f, returns to 0x1D63 label_1D63: // Incoming return from call to 0x480F at 0x1D62 // Inputs[3] // { // @1D66 memory[0x40:0x60] // @1D68 stack[-1] // @1D6B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1D63 5B JUMPDEST 1D64 60 PUSH1 0x40 1D66 51 MLOAD 1D67 80 DUP1 1D68 91 SWAP2 1D69 03 SUB 1D6A 90 SWAP1 1D6B FD *REVERT // Stack delta = -1 // Outputs[1] { @1D6B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1D6C: // Incoming jump from 0x1D31, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1D6D msg.value // @1D6E stack[-1] // } 1D6C 5B JUMPDEST 1D6D 34 CALLVALUE 1D6E 81 DUP2 1D6F 67 PUSH8 0x011c37937e080000 1D78 61 PUSH2 0x1d81 1D7B 91 SWAP2 1D7C 90 SWAP1 1D7D 61 PUSH2 0x4b3a 1D80 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D6D stack[0] = msg.value // @1D7B stack[1] = 0x1d81 // @1D7C stack[2] = stack[-1] // @1D7C stack[3] = 0x011c37937e080000 // } // Block ends with call to 0x4b3a, returns to 0x1D81 label_1D81: // Incoming return from call to 0x4B3A at 0x1D80 // Inputs[2] // { // @1D82 stack[-2] // @1D82 stack[-1] // } 1D81 5B JUMPDEST 1D82 11 GT 1D83 15 ISZERO 1D84 61 PUSH2 0x1dc2 1D87 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1dc2, if !(stack[-1] > stack[-2]) label_1D88: // Incoming jump from 0x1D87, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1D8A memory[0x40:0x60] } 1D88 60 PUSH1 0x40 1D8A 51 MLOAD 1D8B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1DAC 81 DUP2 1DAD 52 MSTORE 1DAE 60 PUSH1 0x04 1DB0 01 ADD 1DB1 61 PUSH2 0x1db9 1DB4 90 SWAP1 1DB5 61 PUSH2 0x472f 1DB8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1DB4 stack[0] = 0x1db9 // @1DB4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x472f, returns to 0x1DB9 label_1DB9: // Incoming return from call to 0x472F at 0x1DB8 // Inputs[3] // { // @1DBC memory[0x40:0x60] // @1DBE stack[-1] // @1DC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1DB9 5B JUMPDEST 1DBA 60 PUSH1 0x40 1DBC 51 MLOAD 1DBD 80 DUP1 1DBE 91 SWAP2 1DBF 03 SUB 1DC0 90 SWAP1 1DC1 FD *REVERT // Stack delta = -1 // Outputs[1] { @1DC1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1DC2: // Incoming jump from 0x1D87, if !(stack[-1] > stack[-2]) // Inputs[1] { @1DC6 stack[-1] } 1DC2 5B JUMPDEST 1DC3 60 PUSH1 0x00 1DC5 5B JUMPDEST 1DC6 81 DUP2 1DC7 81 DUP2 1DC8 10 LT 1DC9 15 ISZERO 1DCA 61 PUSH2 0x1e09 1DCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DC3 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e09, if !(0x00 < stack[-1]) label_1DCE: // Incoming jump from 0x1DCD, if not !(0x00 < stack[-1]) // Incoming jump from 0x1DCD, if not !(stack[-1] < stack[-2]) 1DCE 60 PUSH1 0x00 1DD0 61 PUSH2 0x1dd7 1DD3 61 PUSH2 0x0c1c 1DD6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DCE stack[0] = 0x00 // @1DD0 stack[1] = 0x1dd7 // } // Block ends with call to 0x0c1c, returns to 0x1DD7 label_1DD7: // Incoming return from call to 0x0C1C at 0x1DD6 // Inputs[3] // { // @1DD8 stack[-2] // @1DD8 stack[-1] // @1DDC storage[0x0c] // } 1DD7 5B JUMPDEST 1DD8 90 SWAP1 1DD9 50 POP 1DDA 60 PUSH1 0x0c 1DDC 54 SLOAD 1DDD 61 PUSH2 0x1de4 1DE0 61 PUSH2 0x0c1c 1DE3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1DD8 stack[-2] = stack[-1] // @1DDC stack[-1] = storage[0x0c] // @1DDD stack[0] = 0x1de4 // } // Block ends with call to 0x0c1c, returns to 0x1DE4 label_1DE4: // Incoming return from call to 0x0C1C at 0x1DE3 // Inputs[2] // { // @1DE5 stack[-2] // @1DE5 stack[-1] // } 1DE4 5B JUMPDEST 1DE5 10 LT 1DE6 15 ISZERO 1DE7 61 PUSH2 0x1df5 1DEA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1df5, if !(stack[-1] < stack[-2]) label_1DEB: // Incoming jump from 0x1DEA, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @1DEE msg.sender // @1DEF stack[-1] // } 1DEB 61 PUSH2 0x1df4 1DEE 33 CALLER 1DEF 82 DUP3 1DF0 61 PUSH2 0x28e1 1DF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DEB stack[0] = 0x1df4 // @1DEE stack[1] = msg.sender // @1DEF stack[2] = stack[-1] // } // Block ends with call to 0x28e1, returns to 0x1DF4 label_1DF4: // Incoming return from call to 0x28E1 at 0x1DF3 1DF4 5B JUMPDEST // Stack delta = +0 // Block continues label_1DF5: // Incoming jump from 0x1DF4 // Incoming jump from 0x1DEA, if !(stack[-1] < stack[-2]) // Inputs[1] { @1DF7 stack[-2] } 1DF5 5B JUMPDEST 1DF6 50 POP 1DF7 80 DUP1 1DF8 80 DUP1 1DF9 61 PUSH2 0x1e01 1DFC 90 SWAP1 1DFD 61 PUSH2 0x4cb0 1E00 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DF7 stack[-1] = stack[-2] // @1DFC stack[1] = stack[-2] // @1DFC stack[0] = 0x1e01 // } // Block ends with call to 0x4cb0, returns to 0x1E01 label_1E01: // Incoming return from call to 0x4CB0 at 0x1E00 // Inputs[2] // { // @1E02 stack[-1] // @1E02 stack[-3] // } 1E01 5B JUMPDEST 1E02 91 SWAP2 1E03 50 POP 1E04 50 POP 1E05 61 PUSH2 0x1dc5 1E08 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E02 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1dc5 label_1E09: // Incoming jump from 0x1DCD, if !(0x00 < stack[-1]) // Incoming jump from 0x1DCD, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @1E0B stack[-2] // @1E10 msg.sender // @1E4A memory[0x00:0x40] // @1E4B storage[keccak256(memory[0x00:0x40])] // } 1E09 5B JUMPDEST 1E0A 50 POP 1E0B 80 DUP1 1E0C 60 PUSH1 0x12 1E0E 60 PUSH1 0x00 1E10 33 CALLER 1E11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E26 16 AND 1E27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E3C 16 AND 1E3D 81 DUP2 1E3E 52 MSTORE 1E3F 60 PUSH1 0x20 1E41 01 ADD 1E42 90 SWAP1 1E43 81 DUP2 1E44 52 MSTORE 1E45 60 PUSH1 0x20 1E47 01 ADD 1E48 60 PUSH1 0x00 1E4A 20 SHA3 1E4B 54 SLOAD 1E4C 61 PUSH2 0x1e55 1E4F 91 SWAP2 1E50 90 SWAP1 1E51 61 PUSH2 0x4ab3 1E54 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E3E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1E44 memory[0x20:0x40] = 0x12 // @1E4F stack[-1] = 0x1e55 // @1E50 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1E50 stack[0] = stack[-2] // } // Block ends with call to 0x4ab3, returns to 0x1E55 label_1E55: // Incoming return from call to 0x4AB3 at 0x1E54 // Inputs[4] // { // @1E5A msg.sender // @1E94 memory[0x00:0x40] // @1E95 stack[-1] // @1E9A stack[-3] // } 1E55 5B JUMPDEST 1E56 60 PUSH1 0x12 1E58 60 PUSH1 0x00 1E5A 33 CALLER 1E5B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E70 16 AND 1E71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E86 16 AND 1E87 81 DUP2 1E88 52 MSTORE 1E89 60 PUSH1 0x20 1E8B 01 ADD 1E8C 90 SWAP1 1E8D 81 DUP2 1E8E 52 MSTORE 1E8F 60 PUSH1 0x20 1E91 01 ADD 1E92 60 PUSH1 0x00 1E94 20 SHA3 1E95 81 DUP2 1E96 90 SWAP1 1E97 55 SSTORE 1E98 50 POP 1E99 50 POP 1E9A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1E88 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1E8E memory[0x20:0x40] = 0x12 // @1E97 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1E9B: // Incoming call from 0x07A4, returns to 0x07A5 // Inputs[1] { @1E9F storage[0x0f] } 1E9B 5B JUMPDEST 1E9C 60 PUSH1 0x0f 1E9E 80 DUP1 1E9F 54 SLOAD 1EA0 61 PUSH2 0x1ea8 1EA3 90 SWAP1 1EA4 61 PUSH2 0x4c7e 1EA7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E9C stack[0] = 0x0f // @1EA3 stack[1] = 0x1ea8 // @1EA3 stack[2] = storage[0x0f] // } // Block ends with call to 0x4c7e, returns to 0x1EA8 label_1EA8: // Incoming return from call to 0x4C7E at 0x1EA7 // Inputs[4] // { // @1EA9 stack[-1] // @1EB8 memory[0x40:0x60] // @1EC0 stack[-2] // @1ECB storage[stack[-2]] // } 1EA8 5B JUMPDEST 1EA9 80 DUP1 1EAA 60 PUSH1 0x1f 1EAC 01 ADD 1EAD 60 PUSH1 0x20 1EAF 80 DUP1 1EB0 91 SWAP2 1EB1 04 DIV 1EB2 02 MUL 1EB3 60 PUSH1 0x20 1EB5 01 ADD 1EB6 60 PUSH1 0x40 1EB8 51 MLOAD 1EB9 90 SWAP1 1EBA 81 DUP2 1EBB 01 ADD 1EBC 60 PUSH1 0x40 1EBE 52 MSTORE 1EBF 80 DUP1 1EC0 92 SWAP3 1EC1 91 SWAP2 1EC2 90 SWAP1 1EC3 81 DUP2 1EC4 81 DUP2 1EC5 52 MSTORE 1EC6 60 PUSH1 0x20 1EC8 01 ADD 1EC9 82 DUP3 1ECA 80 DUP1 1ECB 54 SLOAD 1ECC 61 PUSH2 0x1ed4 1ECF 90 SWAP1 1ED0 61 PUSH2 0x4c7e 1ED3 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1EBE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1EC0 stack[-2] = memory[0x40:0x60] // @1EC1 stack[-1] = stack[-2] // @1EC2 stack[0] = stack[-1] // @1EC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1EC8 stack[1] = 0x20 + memory[0x40:0x60] // @1EC9 stack[2] = stack[-2] // @1ECF stack[4] = storage[stack[-2]] // @1ECF stack[3] = 0x1ed4 // } // Block ends with call to 0x4c7e, returns to 0x1ED4 label_1ED4: // Incoming return from call to 0x4C7E at 0x1ED3 // Inputs[1] { @1ED5 stack[-1] } 1ED4 5B JUMPDEST 1ED5 80 DUP1 1ED6 15 ISZERO 1ED7 61 PUSH2 0x1f21 1EDA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f21, if !stack[-1] label_1EDB: // Incoming jump from 0x1EDA, if not !stack[-1] // Inputs[1] { @1EDB stack[-1] } 1EDB 80 DUP1 1EDC 60 PUSH1 0x1f 1EDE 10 LT 1EDF 61 PUSH2 0x1ef6 1EE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ef6, if 0x1f < stack[-1] label_1EE3: // Incoming jump from 0x1EE2, if not 0x1f < stack[-1] // Inputs[4] // { // @1EE7 stack[-2] // @1EE8 storage[stack[-2]] // @1EEB stack[-3] // @1EED stack[-1] // } 1EE3 61 PUSH2 0x0100 1EE6 80 DUP1 1EE7 83 DUP4 1EE8 54 SLOAD 1EE9 04 DIV 1EEA 02 MUL 1EEB 83 DUP4 1EEC 52 MSTORE 1EED 91 SWAP2 1EEE 60 PUSH1 0x20 1EF0 01 ADD 1EF1 91 SWAP2 1EF2 61 PUSH2 0x1f21 1EF5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1EEC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1EF1 stack[-1] = stack[-1] // @1EF1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1f21 label_1EF6: // Incoming jump from 0x1EE2, if 0x1f < stack[-1] // Inputs[5] // { // @1EF7 stack[-3] // @1EF8 stack[-1] // @1EFA stack[-2] // @1F02 memory[0x00:0x20] // @1F06 storage[keccak256(memory[0x00:0x20])] // } 1EF6 5B JUMPDEST 1EF7 82 DUP3 1EF8 01 ADD 1EF9 91 SWAP2 1EFA 90 SWAP1 1EFB 60 PUSH1 0x00 1EFD 52 MSTORE 1EFE 60 PUSH1 0x20 1F00 60 PUSH1 0x00 1F02 20 SHA3 1F03 90 SWAP1 1F04 5B JUMPDEST 1F05 81 DUP2 1F06 54 SLOAD 1F07 81 DUP2 1F08 52 MSTORE 1F09 90 SWAP1 1F0A 60 PUSH1 0x01 1F0C 01 ADD 1F0D 90 SWAP1 1F0E 60 PUSH1 0x20 1F10 01 ADD 1F11 80 DUP1 1F12 83 DUP4 1F13 11 GT 1F14 61 PUSH2 0x1f04 1F17 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1EF9 stack[-3] = stack[-3] + stack[-1] // @1EFD memory[0x00:0x20] = stack[-2] // @1F08 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1F0D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1F10 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1f04, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1F18: // Incoming jump from 0x1F17, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1F17, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1F18 stack[-3] // @1F19 stack[-1] // } 1F18 82 DUP3 1F19 90 SWAP1 1F1A 03 SUB 1F1B 60 PUSH1 0x1f 1F1D 16 AND 1F1E 82 DUP3 1F1F 01 ADD 1F20 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1F20 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1F20 stack[-1] = stack[-3] // } // Block continues label_1F21: // Incoming jump from 0x1EF5 // Incoming jump from 0x1F20 // Incoming jump from 0x1EDA, if !stack[-1] // Inputs[1] { @1F27 stack[-7] } 1F21 5B JUMPDEST 1F22 50 POP 1F23 50 POP 1F24 50 POP 1F25 50 POP 1F26 50 POP 1F27 81 DUP2 1F28 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1F29: // Incoming jump from 0x07E1 // Inputs[1] { @1F2F stack[-1] } 1F29 5B JUMPDEST 1F2A 60 PUSH1 0x60 1F2C 61 PUSH2 0x1f34 1F2F 82 DUP3 1F30 61 PUSH2 0x247a 1F33 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F2A stack[0] = 0x60 // @1F2C stack[1] = 0x1f34 // @1F2F stack[2] = stack[-1] // } // Block ends with call to 0x247a, returns to 0x1F34 label_1F34: // Incoming return from call to 0x247A at 0x1F33 // Inputs[1] { @1F38 stack[-1] } 1F34 5B JUMPDEST 1F35 61 PUSH2 0x1f73 1F38 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f73, if stack[-1] label_1F39: // Incoming jump from 0x1F38, if not stack[-1] // Inputs[1] { @1F3B memory[0x40:0x60] } 1F39 60 PUSH1 0x40 1F3B 51 MLOAD 1F3C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F5D 81 DUP2 1F5E 52 MSTORE 1F5F 60 PUSH1 0x04 1F61 01 ADD 1F62 61 PUSH2 0x1f6a 1F65 90 SWAP1 1F66 61 PUSH2 0x48ef 1F69 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1F65 stack[0] = 0x1f6a // @1F65 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x48ef, returns to 0x1F6A label_1F6A: // Incoming return from call to 0x48EF at 0x1F69 // Inputs[3] // { // @1F6D memory[0x40:0x60] // @1F6F stack[-1] // @1F72 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1F6A 5B JUMPDEST 1F6B 60 PUSH1 0x40 1F6D 51 MLOAD 1F6E 80 DUP1 1F6F 91 SWAP2 1F70 03 SUB 1F71 90 SWAP1 1F72 FD *REVERT // Stack delta = -1 // Outputs[1] { @1F72 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1F73: // Incoming jump from 0x1F38, if stack[-1] // Inputs[1] { @1F7D storage[0x0d] } 1F73 5B JUMPDEST 1F74 60 PUSH1 0x00 1F76 15 ISZERO 1F77 15 ISZERO 1F78 60 PUSH1 0x0d 1F7A 60 PUSH1 0x02 1F7C 90 SWAP1 1F7D 54 SLOAD 1F7E 90 SWAP1 1F7F 61 PUSH2 0x0100 1F82 0A EXP 1F83 90 SWAP1 1F84 04 DIV 1F85 60 PUSH1 0xff 1F87 16 AND 1F88 15 ISZERO 1F89 15 ISZERO 1F8A 14 EQ 1F8B 15 ISZERO 1F8C 61 PUSH2 0x2021 1F8F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2021, if !(!!(0xff & storage[0x0d] / 0x0100 ** 0x02) == !!0x00) label_1F90: // Incoming jump from 0x1F8F, if not !(!!(0xff & storage[0x0d] / 0x0100 ** 0x02) == !!0x00) // Inputs[1] { @1F93 storage[0x0e] } 1F90 60 PUSH1 0x0e 1F92 80 DUP1 1F93 54 SLOAD 1F94 61 PUSH2 0x1f9c 1F97 90 SWAP1 1F98 61 PUSH2 0x4c7e 1F9B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F90 stack[0] = 0x0e // @1F97 stack[1] = 0x1f9c // @1F97 stack[2] = storage[0x0e] // } // Block ends with call to 0x4c7e, returns to 0x1F9C label_1F9C: // Incoming return from call to 0x4C7E at 0x1F9B // Inputs[4] // { // @1F9D stack[-1] // @1FAC memory[0x40:0x60] // @1FB4 stack[-2] // @1FBF storage[stack[-2]] // } 1F9C 5B JUMPDEST 1F9D 80 DUP1 1F9E 60 PUSH1 0x1f 1FA0 01 ADD 1FA1 60 PUSH1 0x20 1FA3 80 DUP1 1FA4 91 SWAP2 1FA5 04 DIV 1FA6 02 MUL 1FA7 60 PUSH1 0x20 1FA9 01 ADD 1FAA 60 PUSH1 0x40 1FAC 51 MLOAD 1FAD 90 SWAP1 1FAE 81 DUP2 1FAF 01 ADD 1FB0 60 PUSH1 0x40 1FB2 52 MSTORE 1FB3 80 DUP1 1FB4 92 SWAP3 1FB5 91 SWAP2 1FB6 90 SWAP1 1FB7 81 DUP2 1FB8 81 DUP2 1FB9 52 MSTORE 1FBA 60 PUSH1 0x20 1FBC 01 ADD 1FBD 82 DUP3 1FBE 80 DUP1 1FBF 54 SLOAD 1FC0 61 PUSH2 0x1fc8 1FC3 90 SWAP1 1FC4 61 PUSH2 0x4c7e 1FC7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1FB2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1FB4 stack[-2] = memory[0x40:0x60] // @1FB5 stack[-1] = stack[-2] // @1FB6 stack[0] = stack[-1] // @1FB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1FBC stack[1] = 0x20 + memory[0x40:0x60] // @1FBD stack[2] = stack[-2] // @1FC3 stack[4] = storage[stack[-2]] // @1FC3 stack[3] = 0x1fc8 // } // Block ends with call to 0x4c7e, returns to 0x1FC8 label_1FC8: // Incoming return from call to 0x4C7E at 0x1FC7 // Inputs[1] { @1FC9 stack[-1] } 1FC8 5B JUMPDEST 1FC9 80 DUP1 1FCA 15 ISZERO 1FCB 61 PUSH2 0x2015 1FCE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2015, if !stack[-1] label_1FCF: // Incoming jump from 0x1FCE, if not !stack[-1] // Inputs[1] { @1FCF stack[-1] } 1FCF 80 DUP1 1FD0 60 PUSH1 0x1f 1FD2 10 LT 1FD3 61 PUSH2 0x1fea 1FD6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1fea, if 0x1f < stack[-1] label_1FD7: // Incoming jump from 0x1FD6, if not 0x1f < stack[-1] // Inputs[4] // { // @1FDB stack[-2] // @1FDC storage[stack[-2]] // @1FDF stack[-3] // @1FE1 stack[-1] // } 1FD7 61 PUSH2 0x0100 1FDA 80 DUP1 1FDB 83 DUP4 1FDC 54 SLOAD 1FDD 04 DIV 1FDE 02 MUL 1FDF 83 DUP4 1FE0 52 MSTORE 1FE1 91 SWAP2 1FE2 60 PUSH1 0x20 1FE4 01 ADD 1FE5 91 SWAP2 1FE6 61 PUSH2 0x2015 1FE9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1FE0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1FE5 stack[-1] = stack[-1] // @1FE5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2015 label_1FEA: // Incoming jump from 0x1FD6, if 0x1f < stack[-1] // Inputs[5] // { // @1FEB stack[-3] // @1FEC stack[-1] // @1FEE stack[-2] // @1FF6 memory[0x00:0x20] // @1FFA storage[keccak256(memory[0x00:0x20])] // } 1FEA 5B JUMPDEST 1FEB 82 DUP3 1FEC 01 ADD 1FED 91 SWAP2 1FEE 90 SWAP1 1FEF 60 PUSH1 0x00 1FF1 52 MSTORE 1FF2 60 PUSH1 0x20 1FF4 60 PUSH1 0x00 1FF6 20 SHA3 1FF7 90 SWAP1 1FF8 5B JUMPDEST 1FF9 81 DUP2 1FFA 54 SLOAD 1FFB 81 DUP2 1FFC 52 MSTORE 1FFD 90 SWAP1 1FFE 60 PUSH1 0x01 2000 01 ADD 2001 90 SWAP1 2002 60 PUSH1 0x20 2004 01 ADD 2005 80 DUP1 2006 83 DUP4 2007 11 GT 2008 61 PUSH2 0x1ff8 200B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1FED stack[-3] = stack[-3] + stack[-1] // @1FF1 memory[0x00:0x20] = stack[-2] // @1FFC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2001 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2004 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1ff8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_200C: // Incoming jump from 0x200B, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x200B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @200C stack[-3] // @200D stack[-1] // } 200C 82 DUP3 200D 90 SWAP1 200E 03 SUB 200F 60 PUSH1 0x1f 2011 16 AND 2012 82 DUP3 2013 01 ADD 2014 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2014 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2014 stack[-1] = stack[-3] // } // Block continues label_2015: // Incoming jump from 0x1FE9 // Incoming jump from 0x2014 // Incoming jump from 0x1FCE, if !stack[-1] // Inputs[2] // { // @201B stack[-6] // @201B stack[-7] // } 2015 5B JUMPDEST 2016 50 POP 2017 50 POP 2018 50 POP 2019 50 POP 201A 50 POP 201B 90 SWAP1 201C 50 POP 201D 61 PUSH2 0x207d 2020 56 *JUMP // Stack delta = -6 // Outputs[1] { @201B stack[-7] = stack[-6] } // Block ends with unconditional jump to 0x207d label_2021: // Incoming jump from 0x1F8F, if !(!!(0xff & storage[0x0d] / 0x0100 ** 0x02) == !!0x00) 2021 5B JUMPDEST 2022 60 PUSH1 0x00 2024 61 PUSH2 0x202b 2027 61 PUSH2 0x2a21 202A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2022 stack[0] = 0x00 // @2024 stack[1] = 0x202b // } // Block ends with call to 0x2a21, returns to 0x202B label_202B: // Incoming return from call to 0x2A21 at 0x202A // Inputs[3] // { // @202C stack[-2] // @202C stack[-1] // @2031 memory[stack[-1]:stack[-1] + 0x20] // } 202B 5B JUMPDEST 202C 90 SWAP1 202D 50 POP 202E 60 PUSH1 0x00 2030 81 DUP2 2031 51 MLOAD 2032 11 GT 2033 61 PUSH2 0x204b 2036 57 *JUMPI // Stack delta = -1 // Outputs[1] { @202C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x204b, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 label_2037: // Incoming jump from 0x2036, if not memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[1] { @2039 memory[0x40:0x60] } 2037 60 PUSH1 0x40 2039 51 MLOAD 203A 80 DUP1 203B 60 PUSH1 0x20 203D 01 ADD 203E 60 PUSH1 0x40 2040 52 MSTORE 2041 80 DUP1 2042 60 PUSH1 0x00 2044 81 DUP2 2045 52 MSTORE 2046 50 POP 2047 61 PUSH2 0x2079 204A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2039 stack[0] = memory[0x40:0x60] // @2040 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @2045 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x2079 label_204B: // Incoming jump from 0x2036, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[2] // { // @204C stack[-1] // @2050 stack[-3] // } 204B 5B JUMPDEST 204C 80 DUP1 204D 61 PUSH2 0x2055 2050 84 DUP5 2051 61 PUSH2 0x2ab3 2054 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @204C stack[0] = stack[-1] // @204D stack[1] = 0x2055 // @2050 stack[2] = stack[-3] // } // Block ends with call to 0x2ab3, returns to 0x2055 label_2055: // Incoming return from call to 0x2AB3 at 0x2054 // Inputs[3] // { // @205A memory[0x40:0x60] // @2061 stack[-2] // @2062 stack[-1] // } 2055 5B JUMPDEST 2056 60 PUSH1 0x0f 2058 60 PUSH1 0x40 205A 51 MLOAD 205B 60 PUSH1 0x20 205D 01 ADD 205E 61 PUSH2 0x2069 2061 93 SWAP4 2062 92 SWAP3 2063 91 SWAP2 2064 90 SWAP1 2065 61 PUSH2 0x455a 2068 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2061 stack[-2] = 0x2069 // @2062 stack[-1] = stack[-2] // @2063 stack[0] = stack[-1] // @2064 stack[1] = 0x0f // @2064 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x455a, returns to 0x2069 label_2069: // Incoming return from call to 0x455A at 0x2068 // Inputs[2] // { // @206C memory[0x40:0x60] // @2070 stack[-1] // } 2069 5B JUMPDEST 206A 60 PUSH1 0x40 206C 51 MLOAD 206D 60 PUSH1 0x20 206F 81 DUP2 2070 83 DUP4 2071 03 SUB 2072 03 SUB 2073 81 DUP2 2074 52 MSTORE 2075 90 SWAP1 2076 60 PUSH1 0x40 2078 52 MSTORE // Stack delta = +0 // Outputs[3] // { // @2074 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @2075 stack[-1] = memory[0x40:0x60] // @2078 memory[0x40:0x60] = stack[-1] // } // Block continues label_2079: // Incoming jump from 0x2078 // Incoming jump from 0x204A // Inputs[2] // { // @207A stack[-1] // @207A stack[-3] // } 2079 5B JUMPDEST 207A 91 SWAP2 207B 50 POP 207C 50 POP // Stack delta = -2 // Outputs[1] { @207A stack[-3] = stack[-1] } // Block continues label_207D: // Incoming jump from 0x207C // Incoming jump from 0x2020 // Inputs[3] // { // @207E stack[-3] // @207E stack[-1] // @207F stack[-2] // } 207D 5B JUMPDEST 207E 91 SWAP2 207F 90 SWAP1 2080 50 POP 2081 56 *JUMP // Stack delta = -2 // Outputs[1] { @207E stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2082: // Incoming jump from 0x0BC7 // Incoming jump from 0x081E // Incoming call from 0x267A, returns to 0x267B // Inputs[6] // { // @2089 stack[-2] // @20C3 memory[0x00:0x40] // @20C6 stack[-1] // @2100 memory[0x00:0x40] // @2104 storage[keccak256(memory[0x00:0x40])] // @2111 stack[-3] // } 2082 5B JUMPDEST 2083 60 PUSH1 0x00 2085 60 PUSH1 0x05 2087 60 PUSH1 0x00 2089 84 DUP5 208A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 209F 16 AND 20A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20B5 16 AND 20B6 81 DUP2 20B7 52 MSTORE 20B8 60 PUSH1 0x20 20BA 01 ADD 20BB 90 SWAP1 20BC 81 DUP2 20BD 52 MSTORE 20BE 60 PUSH1 0x20 20C0 01 ADD 20C1 60 PUSH1 0x00 20C3 20 SHA3 20C4 60 PUSH1 0x00 20C6 83 DUP4 20C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20DC 16 AND 20DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20F2 16 AND 20F3 81 DUP2 20F4 52 MSTORE 20F5 60 PUSH1 0x20 20F7 01 ADD 20F8 90 SWAP1 20F9 81 DUP2 20FA 52 MSTORE 20FB 60 PUSH1 0x20 20FD 01 ADD 20FE 60 PUSH1 0x00 2100 20 SHA3 2101 60 PUSH1 0x00 2103 90 SWAP1 2104 54 SLOAD 2105 90 SWAP1 2106 61 PUSH2 0x0100 2109 0A EXP 210A 90 SWAP1 210B 04 DIV 210C 60 PUSH1 0xff 210E 16 AND 210F 90 SWAP1 2110 50 POP 2111 92 SWAP3 2112 91 SWAP2 2113 50 POP 2114 50 POP 2115 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @20B7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @20BD memory[0x20:0x40] = 0x05 // @20F4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @20FA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2111 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_2116: // Incoming call from 0x0849, returns to 0x084A // Inputs[2] // { // @211C storage[0x0d] // @2127 stack[-1] // } 2116 5B JUMPDEST 2117 60 PUSH1 0x0d 2119 60 PUSH1 0x00 211B 90 SWAP1 211C 54 SLOAD 211D 90 SWAP1 211E 61 PUSH2 0x0100 2121 0A EXP 2122 90 SWAP1 2123 04 DIV 2124 60 PUSH1 0xff 2126 16 AND 2127 81 DUP2 2128 56 *JUMP // Stack delta = +1 // Outputs[1] { @2126 stack[0] = 0xff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_2129: // Incoming call from 0x0874, returns to 0x0875 // Inputs[1] { @212C stack[-1] } 2129 5B JUMPDEST 212A 60 PUSH1 0x04 212C 81 DUP2 212D 56 *JUMP // Stack delta = +1 // Outputs[1] { @212A stack[0] = 0x04 } // Block ends with unconditional jump to stack[-1] label_212E: // Incoming call from 0x089F, returns to 0x08A0 212E 5B JUMPDEST 212F 61 PUSH2 0x2136 2132 61 PUSH2 0x24e6 2135 56 *JUMP // Stack delta = +1 // Outputs[1] { @212F stack[0] = 0x2136 } // Block ends with call to 0x24e6, returns to 0x2136 label_2136: // Incoming return from call to 0x24E6 at 0x2135 // Inputs[1] { @214C stack[-1] } 2136 5B JUMPDEST 2137 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 214C 16 AND 214D 61 PUSH2 0x2154 2150 61 PUSH2 0x17ae 2153 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @214C stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @214D stack[0] = 0x2154 // } // Block ends with call to 0x17ae, returns to 0x2154 label_2154: // Incoming return from call to 0x17AE at 0x2153 // Inputs[2] // { // @216A stack[-1] // @216B stack[-2] // } 2154 5B JUMPDEST 2155 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 216A 16 AND 216B 14 EQ 216C 61 PUSH2 0x21aa 216F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x21aa, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_2170: // Incoming jump from 0x216F, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @2172 memory[0x40:0x60] } 2170 60 PUSH1 0x40 2172 51 MLOAD 2173 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2194 81 DUP2 2195 52 MSTORE 2196 60 PUSH1 0x04 2198 01 ADD 2199 61 PUSH2 0x21a1 219C 90 SWAP1 219D 61 PUSH2 0x488f 21A0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2195 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @219C stack[0] = 0x21a1 // @219C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x21A1 label_21A1: // Incoming return from call to 0x488F at 0x21A0 // Inputs[3] // { // @21A4 memory[0x40:0x60] // @21A6 stack[-1] // @21A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 21A1 5B JUMPDEST 21A2 60 PUSH1 0x40 21A4 51 MLOAD 21A5 80 DUP1 21A6 91 SWAP2 21A7 03 SUB 21A8 90 SWAP1 21A9 FD *REVERT // Stack delta = -1 // Outputs[1] { @21A9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_21AA: // Incoming jump from 0x216F, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @21B0 storage[0x0d] // @21C5 storage[0x0d] // @21D5 stack[-1] // } 21AA 5B JUMPDEST 21AB 60 PUSH1 0x0d 21AD 60 PUSH1 0x01 21AF 90 SWAP1 21B0 54 SLOAD 21B1 90 SWAP1 21B2 61 PUSH2 0x0100 21B5 0A EXP 21B6 90 SWAP1 21B7 04 DIV 21B8 60 PUSH1 0xff 21BA 16 AND 21BB 15 ISZERO 21BC 60 PUSH1 0x0d 21BE 60 PUSH1 0x01 21C0 61 PUSH2 0x0100 21C3 0A EXP 21C4 81 DUP2 21C5 54 SLOAD 21C6 81 DUP2 21C7 60 PUSH1 0xff 21C9 02 MUL 21CA 19 NOT 21CB 16 AND 21CC 90 SWAP1 21CD 83 DUP4 21CE 15 ISZERO 21CF 15 ISZERO 21D0 02 MUL 21D1 17 OR 21D2 90 SWAP1 21D3 55 SSTORE 21D4 50 POP 21D5 56 *JUMP // Stack delta = -1 // Outputs[1] { @21D3 storage[0x0d] = !!!(0xff & storage[0x0d] / 0x0100 ** 0x01) * 0x0100 ** 0x01 | (~(0xff * 0x0100 ** 0x01) & storage[0x0d]) } // Block ends with unconditional jump to stack[-1] label_21D6: // Incoming jump from 0x08C8 21D6 5B JUMPDEST 21D7 61 PUSH2 0x21de 21DA 61 PUSH2 0x24e6 21DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @21D7 stack[0] = 0x21de } // Block ends with call to 0x24e6, returns to 0x21DE label_21DE: // Incoming return from call to 0x24E6 at 0x21DD // Inputs[1] { @21F4 stack[-1] } 21DE 5B JUMPDEST 21DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21F4 16 AND 21F5 61 PUSH2 0x21fc 21F8 61 PUSH2 0x17ae 21FB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @21F4 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @21F5 stack[0] = 0x21fc // } // Block ends with call to 0x17ae, returns to 0x21FC label_21FC: // Incoming return from call to 0x17AE at 0x21FB // Inputs[2] // { // @2212 stack[-1] // @2213 stack[-2] // } 21FC 5B JUMPDEST 21FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2212 16 AND 2213 14 EQ 2214 61 PUSH2 0x2252 2217 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2252, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_2218: // Incoming jump from 0x2217, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @221A memory[0x40:0x60] } 2218 60 PUSH1 0x40 221A 51 MLOAD 221B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 223C 81 DUP2 223D 52 MSTORE 223E 60 PUSH1 0x04 2240 01 ADD 2241 61 PUSH2 0x2249 2244 90 SWAP1 2245 61 PUSH2 0x488f 2248 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @223D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2244 stack[0] = 0x2249 // @2244 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x2249 label_2249: // Incoming return from call to 0x488F at 0x2248 // Inputs[3] // { // @224C memory[0x40:0x60] // @224E stack[-1] // @2251 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 2249 5B JUMPDEST 224A 60 PUSH1 0x40 224C 51 MLOAD 224D 80 DUP1 224E 91 SWAP2 224F 03 SUB 2250 90 SWAP1 2251 FD *REVERT // Stack delta = -1 // Outputs[1] { @2251 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_2252: // Incoming jump from 0x2217, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @2253 stack[-1] // @2258 memory[stack[-1]:stack[-1] + 0x20] // } 2252 5B JUMPDEST 2253 80 DUP1 2254 60 PUSH1 0x0e 2256 90 SWAP1 2257 80 DUP1 2258 51 MLOAD 2259 90 SWAP1 225A 60 PUSH1 0x20 225C 01 ADD 225D 90 SWAP1 225E 61 PUSH2 0x2268 2261 92 SWAP3 2262 91 SWAP2 2263 90 SWAP1 2264 61 PUSH2 0x3620 2267 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2261 stack[0] = 0x2268 // @2262 stack[1] = 0x0e // @2263 stack[2] = 0x20 + stack[-1] // @2263 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3620, returns to 0x2268 label_2268: // Incoming return from call to 0x3620 at 0x2267 // Inputs[1] { @226B stack[-3] } 2268 5B JUMPDEST 2269 50 POP 226A 50 POP 226B 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_226C: // Incoming jump from 0x08F1 226C 5B JUMPDEST 226D 61 PUSH2 0x2274 2270 61 PUSH2 0x24e6 2273 56 *JUMP // Stack delta = +1 // Outputs[1] { @226D stack[0] = 0x2274 } // Block ends with call to 0x24e6, returns to 0x2274 label_2274: // Incoming return from call to 0x24E6 at 0x2273 // Inputs[1] { @228A stack[-1] } 2274 5B JUMPDEST 2275 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 228A 16 AND 228B 61 PUSH2 0x2292 228E 61 PUSH2 0x17ae 2291 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @228A stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @228B stack[0] = 0x2292 // } // Block ends with call to 0x17ae, returns to 0x2292 label_2292: // Incoming return from call to 0x17AE at 0x2291 // Inputs[2] // { // @22A8 stack[-1] // @22A9 stack[-2] // } 2292 5B JUMPDEST 2293 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22A8 16 AND 22A9 14 EQ 22AA 61 PUSH2 0x22e8 22AD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x22e8, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_22AE: // Incoming jump from 0x22AD, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @22B0 memory[0x40:0x60] } 22AE 60 PUSH1 0x40 22B0 51 MLOAD 22B1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 22D2 81 DUP2 22D3 52 MSTORE 22D4 60 PUSH1 0x04 22D6 01 ADD 22D7 61 PUSH2 0x22df 22DA 90 SWAP1 22DB 61 PUSH2 0x488f 22DE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @22D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @22DA stack[0] = 0x22df // @22DA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x22DF label_22DF: // Incoming return from call to 0x488F at 0x22DE // Inputs[3] // { // @22E2 memory[0x40:0x60] // @22E4 stack[-1] // @22E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 22DF 5B JUMPDEST 22E0 60 PUSH1 0x40 22E2 51 MLOAD 22E3 80 DUP1 22E4 91 SWAP2 22E5 03 SUB 22E6 90 SWAP1 22E7 FD *REVERT // Stack delta = -1 // Outputs[1] { @22E7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_22E8: // Incoming jump from 0x22AD, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @2301 stack[-1] } 22E8 5B JUMPDEST 22E9 60 PUSH1 0x00 22EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2300 16 AND 2301 81 DUP2 2302 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2317 16 AND 2318 14 EQ 2319 15 ISZERO 231A 61 PUSH2 0x2358 231D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2358, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_231E: // Incoming jump from 0x231D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2320 memory[0x40:0x60] } 231E 60 PUSH1 0x40 2320 51 MLOAD 2321 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2342 81 DUP2 2343 52 MSTORE 2344 60 PUSH1 0x04 2346 01 ADD 2347 61 PUSH2 0x234f 234A 90 SWAP1 234B 61 PUSH2 0x466f 234E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @234A stack[0] = 0x234f // @234A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x466f, returns to 0x234F label_234F: // Incoming return from call to 0x466F at 0x234E // Inputs[3] // { // @2352 memory[0x40:0x60] // @2354 stack[-1] // @2357 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 234F 5B JUMPDEST 2350 60 PUSH1 0x40 2352 51 MLOAD 2353 80 DUP1 2354 91 SWAP2 2355 03 SUB 2356 90 SWAP1 2357 FD *REVERT // Stack delta = -1 // Outputs[1] { @2357 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_2358: // Incoming jump from 0x231D, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @235C stack[-1] } 2358 5B JUMPDEST 2359 61 PUSH2 0x2361 235C 81 DUP2 235D 61 PUSH2 0x28ff 2360 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2359 stack[0] = 0x2361 // @235C stack[1] = stack[-1] // } // Block ends with call to 0x28ff, returns to 0x2361 label_2361: // Incoming return from call to 0x28FF at 0x2360 // Inputs[1] { @2363 stack[-2] } 2361 5B JUMPDEST 2362 50 POP 2363 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2364: // Incoming call from 0x0908, returns to 0x0909 // Inputs[2] // { // @2367 storage[0x0c] // @2368 stack[-1] // } 2364 5B JUMPDEST 2365 60 PUSH1 0x0c 2367 54 SLOAD 2368 81 DUP2 2369 56 *JUMP // Stack delta = +1 // Outputs[1] { @2367 stack[0] = storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_236A: // Incoming jump from 0x0945 236A 5B JUMPDEST 236B 61 PUSH2 0x2372 236E 61 PUSH2 0x24e6 2371 56 *JUMP // Stack delta = +1 // Outputs[1] { @236B stack[0] = 0x2372 } // Block ends with call to 0x24e6, returns to 0x2372 label_2372: // Incoming return from call to 0x24E6 at 0x2371 // Inputs[1] { @2388 stack[-1] } 2372 5B JUMPDEST 2373 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2388 16 AND 2389 61 PUSH2 0x2390 238C 61 PUSH2 0x17ae 238F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2388 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2389 stack[0] = 0x2390 // } // Block ends with call to 0x17ae, returns to 0x2390 label_2390: // Incoming return from call to 0x17AE at 0x238F // Inputs[2] // { // @23A6 stack[-1] // @23A7 stack[-2] // } 2390 5B JUMPDEST 2391 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23A6 16 AND 23A7 14 EQ 23A8 61 PUSH2 0x23e6 23AB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x23e6, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_23AC: // Incoming jump from 0x23AB, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @23AE memory[0x40:0x60] } 23AC 60 PUSH1 0x40 23AE 51 MLOAD 23AF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 23D0 81 DUP2 23D1 52 MSTORE 23D2 60 PUSH1 0x04 23D4 01 ADD 23D5 61 PUSH2 0x23dd 23D8 90 SWAP1 23D9 61 PUSH2 0x488f 23DC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @23D8 stack[0] = 0x23dd // @23D8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x488f, returns to 0x23DD label_23DD: // Incoming return from call to 0x488F at 0x23DC // Inputs[3] // { // @23E0 memory[0x40:0x60] // @23E2 stack[-1] // @23E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 23DD 5B JUMPDEST 23DE 60 PUSH1 0x40 23E0 51 MLOAD 23E1 80 DUP1 23E2 91 SWAP2 23E3 03 SUB 23E4 90 SWAP1 23E5 FD *REVERT // Stack delta = -1 // Outputs[1] { @23E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_23E6: // Incoming jump from 0x23AB, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @23E7 stack[-1] // @23EC memory[stack[-1]:stack[-1] + 0x20] // } 23E6 5B JUMPDEST 23E7 80 DUP1 23E8 60 PUSH1 0x0b 23EA 90 SWAP1 23EB 80 DUP1 23EC 51 MLOAD 23ED 90 SWAP1 23EE 60 PUSH1 0x20 23F0 01 ADD 23F1 90 SWAP1 23F2 61 PUSH2 0x23fc 23F5 92 SWAP3 23F6 91 SWAP2 23F7 90 SWAP1 23F8 61 PUSH2 0x3620 23FB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23F5 stack[0] = 0x23fc // @23F6 stack[1] = 0x0b // @23F7 stack[2] = 0x20 + stack[-1] // @23F7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3620, returns to 0x23FC label_23FC: // Incoming return from call to 0x3620 at 0x23FB // Inputs[1] { @23FF stack[-3] } 23FC 5B JUMPDEST 23FD 50 POP 23FE 50 POP 23FF 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2400: // Incoming call from 0x0952, returns to 0x0953 // Inputs[1] { @2443 stack[-1] } 2400 5B JUMPDEST 2401 60 PUSH1 0x00 2403 7F PUSH32 0x780e9d6300000000000000000000000000000000000000000000000000000000 2424 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2441 19 NOT 2442 16 AND 2443 82 DUP3 2444 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2461 19 NOT 2462 16 AND 2463 14 EQ 2464 80 DUP1 2465 61 PUSH2 0x2473 2468 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2401 stack[0] = 0x00 // @2463 stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x780e9d6300000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x2473, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x780e9d6300000000000000000000000000000000000000000000000000000000 label_2469: // Incoming jump from 0x2468, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x780e9d6300000000000000000000000000000000000000000000000000000000 // Inputs[1] { @246D stack[-3] } 2469 50 POP 246A 61 PUSH2 0x2472 246D 82 DUP3 246E 61 PUSH2 0x2c60 2471 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @246A stack[-1] = 0x2472 // @246D stack[0] = stack[-3] // } // Block ends with call to 0x2c60, returns to 0x2472 label_2472: // Incoming return from call to 0x2C60 at 0x2471 2472 5B JUMPDEST // Stack delta = +0 // Block continues label_2473: // Incoming jump from 0x2472 // Incoming jump from 0x2468, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x780e9d6300000000000000000000000000000000000000000000000000000000 // Inputs[4] // { // @2474 stack[-1] // @2474 stack[-2] // @2476 stack[-4] // @2477 stack[-3] // } 2473 5B JUMPDEST 2474 90 SWAP1 2475 50 POP 2476 91 SWAP2 2477 90 SWAP1 2478 50 POP 2479 56 *JUMP // Stack delta = -3 // Outputs[1] { @2476 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_247A: // Incoming call from 0x313A, returns to 0x313B // Incoming call from 0x1F33, returns to 0x1F34 // Incoming call from 0x09F6, returns to 0x09F7 // Incoming call from 0x25B1, returns to 0x25B2 // Inputs[4] // { // @2498 stack[-1] // @24A6 memory[0x00:0x40] // @24AA storage[keccak256(memory[0x00:0x40])] // @24E2 stack[-2] // } 247A 5B JUMPDEST 247B 60 PUSH1 0x00 247D 80 DUP1 247E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2493 16 AND 2494 60 PUSH1 0x02 2496 60 PUSH1 0x00 2498 84 DUP5 2499 81 DUP2 249A 52 MSTORE 249B 60 PUSH1 0x20 249D 01 ADD 249E 90 SWAP1 249F 81 DUP2 24A0 52 MSTORE 24A1 60 PUSH1 0x20 24A3 01 ADD 24A4 60 PUSH1 0x00 24A6 20 SHA3 24A7 60 PUSH1 0x00 24A9 90 SWAP1 24AA 54 SLOAD 24AB 90 SWAP1 24AC 61 PUSH2 0x0100 24AF 0A EXP 24B0 90 SWAP1 24B1 04 DIV 24B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24C7 16 AND 24C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24DD 16 AND 24DE 14 EQ 24DF 15 ISZERO 24E0 90 SWAP1 24E1 50 POP 24E2 91 SWAP2 24E3 90 SWAP1 24E4 50 POP 24E5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @249A memory[0x00:0x20] = stack[-1] // @24A0 memory[0x20:0x40] = 0x02 // @24E2 stack[-2] = !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // } // Block ends with unconditional jump to stack[-2] label_24E6: // Incoming call from 0x18EC, returns to 0x18ED // Incoming call from 0x0C46, returns to 0x0C47 // Incoming call from 0x0CA3, returns to 0x0CA4 // Incoming call from 0x1999, returns to 0x199A // Incoming call from 0x2273, returns to 0x2274 // Incoming call from 0x1196, returns to 0x1197 // Incoming call from 0x0E4B, returns to 0x0E4C // Incoming call from 0x1871, returns to 0x1872 // Incoming call from 0x19F2, returns to 0x19F3 // Incoming call from 0x2135, returns to 0x2136 // Incoming call from 0x21DD, returns to 0x21DE // Incoming call from 0x1B9C, returns to 0x1B9D // Incoming call from 0x2DF6, returns to 0x2DF7 // Incoming call from 0x1A8B, returns to 0x1A8C // Incoming call from 0x0B99, returns to 0x0B9A // Incoming call from 0x0F59, returns to 0x0F5A // Incoming call from 0x2371, returns to 0x2372 // Incoming call from 0x1001, returns to 0x1002 // Incoming call from 0x0BC2, returns to 0x0BC3 // Incoming call from 0x171B, returns to 0x171C // Inputs[2] // { // @24E9 msg.sender // @24EC stack[-1] // } 24E6 5B JUMPDEST 24E7 60 PUSH1 0x00 24E9 33 CALLER 24EA 90 SWAP1 24EB 50 POP 24EC 90 SWAP1 24ED 56 *JUMP // Stack delta = +0 // Outputs[1] { @24EC stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_24EE: // Incoming call from 0x2780, returns to 0x2781 // Incoming call from 0x0C11, returns to 0x0C12 // Inputs[4] // { // @24EF stack[-2] // @24F4 stack[-1] // @2502 memory[0x00:0x40] // @250A storage[keccak256(memory[0x00:0x40])] // } 24EE 5B JUMPDEST 24EF 81 DUP2 24F0 60 PUSH1 0x04 24F2 60 PUSH1 0x00 24F4 83 DUP4 24F5 81 DUP2 24F6 52 MSTORE 24F7 60 PUSH1 0x20 24F9 01 ADD 24FA 90 SWAP1 24FB 81 DUP2 24FC 52 MSTORE 24FD 60 PUSH1 0x20 24FF 01 ADD 2500 60 PUSH1 0x00 2502 20 SHA3 2503 60 PUSH1 0x00 2505 61 PUSH2 0x0100 2508 0A EXP 2509 81 DUP2 250A 54 SLOAD 250B 81 DUP2 250C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2521 02 MUL 2522 19 NOT 2523 16 AND 2524 90 SWAP1 2525 83 DUP4 2526 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 253B 16 AND 253C 02 MUL 253D 17 OR 253E 90 SWAP1 253F 55 SSTORE 2540 50 POP 2541 80 DUP1 2542 82 DUP3 2543 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2558 16 AND 2559 61 PUSH2 0x2561 255C 83 DUP4 255D 61 PUSH2 0x1225 2560 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @24F6 memory[0x00:0x20] = stack[-1] // @24FC memory[0x20:0x40] = 0x04 // @253F storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2541 stack[0] = stack[-1] // @2558 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2559 stack[2] = 0x2561 // @255C stack[3] = stack[-1] // } // Block ends with call to 0x1225, returns to 0x2561 label_2561: // Incoming return from call to 0x1225 at 0x2560 // Inputs[7] // { // @2577 stack[-1] // @259B memory[0x40:0x60] // @259E memory[0x40:0x60] // @25A3 stack[-3] // @25A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @25A3 stack[-2] // @25A6 stack[-6] // } 2561 5B JUMPDEST 2562 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2577 16 AND 2578 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 2599 60 PUSH1 0x40 259B 51 MLOAD 259C 60 PUSH1 0x40 259E 51 MLOAD 259F 80 DUP1 25A0 91 SWAP2 25A1 03 SUB 25A2 90 SWAP1 25A3 A4 LOG4 25A4 50 POP 25A5 50 POP 25A6 56 *JUMP // Stack delta = -6 // Outputs[1] { @25A3 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_25A7: // Incoming jump from 0x0C4C // Incoming jump from 0x1BA2 // Inputs[1] { @25AD stack[-1] } 25A7 5B JUMPDEST 25A8 60 PUSH1 0x00 25AA 61 PUSH2 0x25b2 25AD 82 DUP3 25AE 61 PUSH2 0x247a 25B1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25A8 stack[0] = 0x00 // @25AA stack[1] = 0x25b2 // @25AD stack[2] = stack[-1] // } // Block ends with call to 0x247a, returns to 0x25B2 label_25B2: // Incoming return from call to 0x247A at 0x25B1 // Inputs[1] { @25B6 stack[-1] } 25B2 5B JUMPDEST 25B3 61 PUSH2 0x25f1 25B6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x25f1, if stack[-1] label_25B7: // Incoming jump from 0x25B6, if not stack[-1] // Inputs[1] { @25B9 memory[0x40:0x60] } 25B7 60 PUSH1 0x40 25B9 51 MLOAD 25BA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 25DB 81 DUP2 25DC 52 MSTORE 25DD 60 PUSH1 0x04 25DF 01 ADD 25E0 61 PUSH2 0x25e8 25E3 90 SWAP1 25E4 61 PUSH2 0x476f 25E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @25DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @25E3 stack[0] = 0x25e8 // @25E3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x476f, returns to 0x25E8 label_25E8: // Incoming return from call to 0x476F at 0x25E7 // Inputs[3] // { // @25EB memory[0x40:0x60] // @25ED stack[-1] // @25F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 25E8 5B JUMPDEST 25E9 60 PUSH1 0x40 25EB 51 MLOAD 25EC 80 DUP1 25ED 91 SWAP2 25EE 03 SUB 25EF 90 SWAP1 25F0 FD *REVERT // Stack delta = -1 // Outputs[1] { @25F0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_25F1: // Incoming jump from 0x25B6, if stack[-1] // Inputs[1] { @25F7 stack[-2] } 25F1 5B JUMPDEST 25F2 60 PUSH1 0x00 25F4 61 PUSH2 0x25fc 25F7 83 DUP4 25F8 61 PUSH2 0x1225 25FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25F2 stack[0] = 0x00 // @25F4 stack[1] = 0x25fc // @25F7 stack[2] = stack[-2] // } // Block ends with call to 0x1225, returns to 0x25FC label_25FC: // Incoming return from call to 0x1225 at 0x25FB // Inputs[3] // { // @25FD stack[-2] // @25FD stack[-1] // @2616 stack[-5] // } 25FC 5B JUMPDEST 25FD 90 SWAP1 25FE 50 POP 25FF 80 DUP1 2600 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2615 16 AND 2616 84 DUP5 2617 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 262C 16 AND 262D 14 EQ 262E 80 DUP1 262F 61 PUSH2 0x266b 2632 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @25FD stack[-2] = stack[-1] // @262D stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x266b, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_2633: // Incoming jump from 0x2632, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @2634 stack[-5] // @264E stack[-4] // } 2633 50 POP 2634 83 DUP4 2635 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 264A 16 AND 264B 61 PUSH2 0x2653 264E 84 DUP5 264F 61 PUSH2 0x09ec 2652 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @264A stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @264B stack[0] = 0x2653 // @264E stack[1] = stack[-4] // } // Block ends with call to 0x09ec, returns to 0x2653 label_2653: // Incoming return from call to 0x09EC at 0x2652 // Inputs[2] // { // @2669 stack[-1] // @266A stack[-2] // } 2653 5B JUMPDEST 2654 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2669 16 AND 266A 14 EQ // Stack delta = -1 // Outputs[1] { @266A stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_266B: // Incoming jump from 0x266A // Incoming jump from 0x2632, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @266C stack[-1] } 266B 5B JUMPDEST 266C 80 DUP1 266D 61 PUSH2 0x267c 2670 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x267c, if stack[-1] label_2671: // Incoming jump from 0x2670, if not stack[-1] // Inputs[2] // { // @2675 stack[-2] // @2676 stack[-5] // } 2671 50 POP 2672 61 PUSH2 0x267b 2675 81 DUP2 2676 85 DUP6 2677 61 PUSH2 0x2082 267A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2672 stack[-1] = 0x267b // @2675 stack[0] = stack[-2] // @2676 stack[1] = stack[-5] // } // Block ends with call to 0x2082, returns to 0x267B label_267B: // Incoming return from call to 0x2082 at 0x267A 267B 5B JUMPDEST // Stack delta = +0 // Block continues label_267C: // Incoming jump from 0x2670, if stack[-1] // Incoming jump from 0x267B // Inputs[4] // { // @267D stack[-3] // @267D stack[-1] // @2680 stack[-6] // @2681 stack[-5] // } 267C 5B JUMPDEST 267D 91 SWAP2 267E 50 POP 267F 50 POP 2680 92 SWAP3 2681 91 SWAP2 2682 50 POP 2683 50 POP 2684 56 *JUMP // Stack delta = -5 // Outputs[1] { @2680 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2685: // Incoming call from 0x0C96, returns to 0x0C97 // Incoming call from 0x29CF, returns to 0x29D0 // Inputs[2] // { // @2686 stack[-3] // @26A0 stack[-1] // } 2685 5B JUMPDEST 2686 82 DUP3 2687 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 269C 16 AND 269D 61 PUSH2 0x26a5 26A0 82 DUP3 26A1 61 PUSH2 0x1225 26A4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @269C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @269D stack[1] = 0x26a5 // @26A0 stack[2] = stack[-1] // } // Block ends with call to 0x1225, returns to 0x26A5 label_26A5: // Incoming return from call to 0x1225 at 0x26A4 // Inputs[2] // { // @26BB stack[-1] // @26BC stack[-2] // } 26A5 5B JUMPDEST 26A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26BB 16 AND 26BC 14 EQ 26BD 61 PUSH2 0x26fb 26C0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x26fb, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_26C1: // Incoming jump from 0x26C0, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @26C3 memory[0x40:0x60] } 26C1 60 PUSH1 0x40 26C3 51 MLOAD 26C4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 26E5 81 DUP2 26E6 52 MSTORE 26E7 60 PUSH1 0x04 26E9 01 ADD 26EA 61 PUSH2 0x26f2 26ED 90 SWAP1 26EE 61 PUSH2 0x48cf 26F1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @26ED stack[0] = 0x26f2 // @26ED stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x48cf, returns to 0x26F2 label_26F2: // Incoming return from call to 0x48CF at 0x26F1 // Inputs[3] // { // @26F5 memory[0x40:0x60] // @26F7 stack[-1] // @26FA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 26F2 5B JUMPDEST 26F3 60 PUSH1 0x40 26F5 51 MLOAD 26F6 80 DUP1 26F7 91 SWAP2 26F8 03 SUB 26F9 90 SWAP1 26FA FD *REVERT // Stack delta = -1 // Outputs[1] { @26FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_26FB: // Incoming jump from 0x26C0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @2714 stack[-2] } 26FB 5B JUMPDEST 26FC 60 PUSH1 0x00 26FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2713 16 AND 2714 82 DUP3 2715 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 272A 16 AND 272B 14 EQ 272C 15 ISZERO 272D 61 PUSH2 0x276b 2730 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x276b, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2731: // Incoming jump from 0x2730, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2733 memory[0x40:0x60] } 2731 60 PUSH1 0x40 2733 51 MLOAD 2734 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2755 81 DUP2 2756 52 MSTORE 2757 60 PUSH1 0x04 2759 01 ADD 275A 61 PUSH2 0x2762 275D 90 SWAP1 275E 61 PUSH2 0x46ef 2761 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2756 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @275D stack[0] = 0x2762 // @275D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x46ef, returns to 0x2762 label_2762: // Incoming return from call to 0x46EF at 0x2761 // Inputs[3] // { // @2765 memory[0x40:0x60] // @2767 stack[-1] // @276A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 2762 5B JUMPDEST 2763 60 PUSH1 0x40 2765 51 MLOAD 2766 80 DUP1 2767 91 SWAP2 2768 03 SUB 2769 90 SWAP1 276A FD *REVERT // Stack delta = -1 // Outputs[1] { @276A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_276B: // Incoming jump from 0x2730, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @276F stack[-3] // @2770 stack[-2] // @2771 stack[-1] // } 276B 5B JUMPDEST 276C 61 PUSH2 0x2776 276F 83 DUP4 2770 83 DUP4 2771 83 DUP4 2772 61 PUSH2 0x2d42 2775 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @276C stack[0] = 0x2776 // @276F stack[1] = stack[-3] // @2770 stack[2] = stack[-2] // @2771 stack[3] = stack[-1] // } // Block ends with call to 0x2d42, returns to 0x2776 label_2776: // Incoming return from call to 0x2D42 at 0x2775 // Inputs[1] { @277C stack[-1] } 2776 5B JUMPDEST 2777 61 PUSH2 0x2781 277A 60 PUSH1 0x00 277C 82 DUP3 277D 61 PUSH2 0x24ee 2780 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2777 stack[0] = 0x2781 // @277A stack[1] = 0x00 // @277C stack[2] = stack[-1] // } // Block ends with call to 0x24ee, returns to 0x2781 label_2781: // Incoming return from call to 0x24EE at 0x2780 // Inputs[3] // { // @2788 stack[-3] // @27C2 memory[0x00:0x40] // @27C7 storage[keccak256(memory[0x00:0x40])] // } 2781 5B JUMPDEST 2782 60 PUSH1 0x01 2784 60 PUSH1 0x03 2786 60 PUSH1 0x00 2788 85 DUP6 2789 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 279E 16 AND 279F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B4 16 AND 27B5 81 DUP2 27B6 52 MSTORE 27B7 60 PUSH1 0x20 27B9 01 ADD 27BA 90 SWAP1 27BB 81 DUP2 27BC 52 MSTORE 27BD 60 PUSH1 0x20 27BF 01 ADD 27C0 60 PUSH1 0x00 27C2 20 SHA3 27C3 60 PUSH1 0x00 27C5 82 DUP3 27C6 82 DUP3 27C7 54 SLOAD 27C8 61 PUSH2 0x27d1 27CB 91 SWAP2 27CC 90 SWAP1 27CD 61 PUSH2 0x4b94 27D0 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @2782 stack[0] = 0x01 // @27B6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @27BC memory[0x20:0x40] = 0x03 // @27C2 stack[1] = keccak256(memory[0x00:0x40]) // @27C3 stack[2] = 0x00 // @27CB stack[3] = 0x27d1 // @27CC stack[4] = 0x01 // @27CC stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x4b94, returns to 0x27D1 label_27D1: // Incoming return from call to 0x4B94 at 0x27D0 // Inputs[6] // { // @27D2 stack[-1] // @27D2 stack[-4] // @27D6 stack[-3] // @27DF stack[-6] // @2819 memory[0x00:0x40] // @281E storage[keccak256(memory[0x00:0x40])] // } 27D1 5B JUMPDEST 27D2 92 SWAP3 27D3 50 POP 27D4 50 POP 27D5 81 DUP2 27D6 90 SWAP1 27D7 55 SSTORE 27D8 50 POP 27D9 60 PUSH1 0x01 27DB 60 PUSH1 0x03 27DD 60 PUSH1 0x00 27DF 84 DUP5 27E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27F5 16 AND 27F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 280B 16 AND 280C 81 DUP2 280D 52 MSTORE 280E 60 PUSH1 0x20 2810 01 ADD 2811 90 SWAP1 2812 81 DUP2 2813 52 MSTORE 2814 60 PUSH1 0x20 2816 01 ADD 2817 60 PUSH1 0x00 2819 20 SHA3 281A 60 PUSH1 0x00 281C 82 DUP3 281D 82 DUP3 281E 54 SLOAD 281F 61 PUSH2 0x2828 2822 91 SWAP2 2823 90 SWAP1 2824 61 PUSH2 0x4ab3 2827 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @27D7 storage[stack[-3]] = stack[-1] // @27D9 stack[-4] = 0x01 // @280D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2813 memory[0x20:0x40] = 0x03 // @2819 stack[-3] = keccak256(memory[0x00:0x40]) // @281A stack[-2] = 0x00 // @2822 stack[-1] = 0x2828 // @2823 stack[0] = 0x01 // @2823 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x4ab3, returns to 0x2828 label_2828: // Incoming return from call to 0x4AB3 at 0x2827 // Inputs[12] // { // @2829 stack[-1] // @2829 stack[-4] // @282D stack[-3] // @2830 stack[-6] // @2835 stack[-5] // @2843 memory[0x00:0x40] // @284B storage[keccak256(memory[0x00:0x40])] // @289A stack[-7] // @28D4 memory[0x40:0x60] // @28D7 memory[0x40:0x60] // @28DC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @28E0 stack[-8] // } 2828 5B JUMPDEST 2829 92 SWAP3 282A 50 POP 282B 50 POP 282C 81 DUP2 282D 90 SWAP1 282E 55 SSTORE 282F 50 POP 2830 81 DUP2 2831 60 PUSH1 0x02 2833 60 PUSH1 0x00 2835 83 DUP4 2836 81 DUP2 2837 52 MSTORE 2838 60 PUSH1 0x20 283A 01 ADD 283B 90 SWAP1 283C 81 DUP2 283D 52 MSTORE 283E 60 PUSH1 0x20 2840 01 ADD 2841 60 PUSH1 0x00 2843 20 SHA3 2844 60 PUSH1 0x00 2846 61 PUSH2 0x0100 2849 0A EXP 284A 81 DUP2 284B 54 SLOAD 284C 81 DUP2 284D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2862 02 MUL 2863 19 NOT 2864 16 AND 2865 90 SWAP1 2866 83 DUP4 2867 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 287C 16 AND 287D 02 MUL 287E 17 OR 287F 90 SWAP1 2880 55 SSTORE 2881 50 POP 2882 80 DUP1 2883 82 DUP3 2884 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2899 16 AND 289A 84 DUP5 289B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28B0 16 AND 28B1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 28D2 60 PUSH1 0x40 28D4 51 MLOAD 28D5 60 PUSH1 0x40 28D7 51 MLOAD 28D8 80 DUP1 28D9 91 SWAP2 28DA 03 SUB 28DB 90 SWAP1 28DC A4 LOG4 28DD 50 POP 28DE 50 POP 28DF 50 POP 28E0 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @282E storage[stack[-3]] = stack[-1] // @2837 memory[0x00:0x20] = stack[-5] // @283D memory[0x20:0x40] = 0x02 // @2880 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @28DC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-5]]); // } // Block ends with unconditional jump to stack[-8] label_28E1: // Incoming jump from 0x0D87 // Incoming call from 0x15B4, returns to 0x15B5 // Incoming call from 0x1DF3, returns to 0x1DF4 // Inputs[3] // { // @28E5 stack[-2] // @28E6 stack[-1] // @28E9 memory[0x40:0x60] // } 28E1 5B JUMPDEST 28E2 61 PUSH2 0x28fb 28E5 82 DUP3 28E6 82 DUP3 28E7 60 PUSH1 0x40 28E9 51 MLOAD 28EA 80 DUP1 28EB 60 PUSH1 0x20 28ED 01 ADD 28EE 60 PUSH1 0x40 28F0 52 MSTORE 28F1 80 DUP1 28F2 60 PUSH1 0x00 28F4 81 DUP2 28F5 52 MSTORE 28F6 50 POP 28F7 61 PUSH2 0x2d52 28FA 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @28E2 stack[0] = 0x28fb // @28E5 stack[1] = stack[-2] // @28E6 stack[2] = stack[-1] // @28E9 stack[3] = memory[0x40:0x60] // @28F0 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @28F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x2d52, returns to 0x28FB label_28FB: // Incoming return from call to 0x2D52 at 0x28FA // Inputs[1] { @28FE stack[-3] } 28FB 5B JUMPDEST 28FC 50 POP 28FD 50 POP 28FE 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_28FF: // Incoming call from 0x1799, returns to 0x179A // Incoming call from 0x2360, returns to 0x2361 // Inputs[7] // { // @2907 storage[0x0a] // @2927 stack[-1] // @2931 storage[0x0a] // @29B9 memory[0x40:0x60] // @29BC memory[0x40:0x60] // @29C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @29C4 stack[-2] // } 28FF 5B JUMPDEST 2900 60 PUSH1 0x00 2902 60 PUSH1 0x0a 2904 60 PUSH1 0x00 2906 90 SWAP1 2907 54 SLOAD 2908 90 SWAP1 2909 61 PUSH2 0x0100 290C 0A EXP 290D 90 SWAP1 290E 04 DIV 290F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2924 16 AND 2925 90 SWAP1 2926 50 POP 2927 81 DUP2 2928 60 PUSH1 0x0a 292A 60 PUSH1 0x00 292C 61 PUSH2 0x0100 292F 0A EXP 2930 81 DUP2 2931 54 SLOAD 2932 81 DUP2 2933 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2948 02 MUL 2949 19 NOT 294A 16 AND 294B 90 SWAP1 294C 83 DUP4 294D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2962 16 AND 2963 02 MUL 2964 17 OR 2965 90 SWAP1 2966 55 SSTORE 2967 50 POP 2968 81 DUP2 2969 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 297E 16 AND 297F 81 DUP2 2980 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2995 16 AND 2996 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 29B7 60 PUSH1 0x40 29B9 51 MLOAD 29BA 60 PUSH1 0x40 29BC 51 MLOAD 29BD 80 DUP1 29BE 91 SWAP2 29BF 03 SUB 29C0 90 SWAP1 29C1 A3 LOG3 29C2 50 POP 29C3 50 POP 29C4 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2966 storage[0x0a] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0a]) // @29C1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_29C5: // Incoming call from 0x1BED, returns to 0x1BEE // Inputs[3] // { // @29C9 stack[-4] // @29CA stack[-3] // @29CB stack[-2] // } 29C5 5B JUMPDEST 29C6 61 PUSH2 0x29d0 29C9 84 DUP5 29CA 84 DUP5 29CB 84 DUP5 29CC 61 PUSH2 0x2685 29CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29C6 stack[0] = 0x29d0 // @29C9 stack[1] = stack[-4] // @29CA stack[2] = stack[-3] // @29CB stack[3] = stack[-2] // } // Block ends with call to 0x2685, returns to 0x29D0 label_29D0: // Incoming return from call to 0x2685 at 0x29CF // Inputs[4] // { // @29D4 stack[-4] // @29D5 stack[-3] // @29D6 stack[-2] // @29D7 stack[-1] // } 29D0 5B JUMPDEST 29D1 61 PUSH2 0x29dc 29D4 84 DUP5 29D5 84 DUP5 29D6 84 DUP5 29D7 84 DUP5 29D8 61 PUSH2 0x2dad 29DB 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @29D1 stack[0] = 0x29dc // @29D4 stack[1] = stack[-4] // @29D5 stack[2] = stack[-3] // @29D6 stack[3] = stack[-2] // @29D7 stack[4] = stack[-1] // } // Block ends with call to 0x2dad, returns to 0x29DC label_29DC: // Incoming return from call to 0x2DAD at 0x29DB // Inputs[1] { @29E0 stack[-1] } 29DC 5B JUMPDEST 29DD 61 PUSH2 0x2a1b 29E0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a1b, if stack[-1] label_29E1: // Incoming jump from 0x29E0, if not stack[-1] // Inputs[1] { @29E3 memory[0x40:0x60] } 29E1 60 PUSH1 0x40 29E3 51 MLOAD 29E4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A05 81 DUP2 2A06 52 MSTORE 2A07 60 PUSH1 0x04 2A09 01 ADD 2A0A 61 PUSH2 0x2a12 2A0D 90 SWAP1 2A0E 61 PUSH2 0x464f 2A11 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2A0D stack[0] = 0x2a12 // @2A0D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x464f, returns to 0x2A12 label_2A12: // Incoming return from call to 0x464F at 0x2A11 // Inputs[3] // { // @2A15 memory[0x40:0x60] // @2A17 stack[-1] // @2A1A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 2A12 5B JUMPDEST 2A13 60 PUSH1 0x40 2A15 51 MLOAD 2A16 80 DUP1 2A17 91 SWAP2 2A18 03 SUB 2A19 90 SWAP1 2A1A FD *REVERT // Stack delta = -1 // Outputs[1] { @2A1A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_2A1B: // Incoming jump from 0x29E0, if stack[-1] // Inputs[1] { @2A20 stack[-5] } 2A1B 5B JUMPDEST 2A1C 50 POP 2A1D 50 POP 2A1E 50 POP 2A1F 50 POP 2A20 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_2A21: // Incoming call from 0x202A, returns to 0x202B // Inputs[1] { @2A27 storage[0x10] } 2A21 5B JUMPDEST 2A22 60 PUSH1 0x60 2A24 60 PUSH1 0x10 2A26 80 DUP1 2A27 54 SLOAD 2A28 61 PUSH2 0x2a30 2A2B 90 SWAP1 2A2C 61 PUSH2 0x4c7e 2A2F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A22 stack[0] = 0x60 // @2A24 stack[1] = 0x10 // @2A2B stack[2] = 0x2a30 // @2A2B stack[3] = storage[0x10] // } // Block ends with call to 0x4c7e, returns to 0x2A30 label_2A30: // Incoming return from call to 0x4C7E at 0x2A2F // Inputs[4] // { // @2A31 stack[-1] // @2A40 memory[0x40:0x60] // @2A48 stack[-2] // @2A53 storage[stack[-2]] // } 2A30 5B JUMPDEST 2A31 80 DUP1 2A32 60 PUSH1 0x1f 2A34 01 ADD 2A35 60 PUSH1 0x20 2A37 80 DUP1 2A38 91 SWAP2 2A39 04 DIV 2A3A 02 MUL 2A3B 60 PUSH1 0x20 2A3D 01 ADD 2A3E 60 PUSH1 0x40 2A40 51 MLOAD 2A41 90 SWAP1 2A42 81 DUP2 2A43 01 ADD 2A44 60 PUSH1 0x40 2A46 52 MSTORE 2A47 80 DUP1 2A48 92 SWAP3 2A49 91 SWAP2 2A4A 90 SWAP1 2A4B 81 DUP2 2A4C 81 DUP2 2A4D 52 MSTORE 2A4E 60 PUSH1 0x20 2A50 01 ADD 2A51 82 DUP3 2A52 80 DUP1 2A53 54 SLOAD 2A54 61 PUSH2 0x2a5c 2A57 90 SWAP1 2A58 61 PUSH2 0x4c7e 2A5B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @2A46 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @2A48 stack[-2] = memory[0x40:0x60] // @2A49 stack[-1] = stack[-2] // @2A4A stack[0] = stack[-1] // @2A4D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2A50 stack[1] = 0x20 + memory[0x40:0x60] // @2A51 stack[2] = stack[-2] // @2A57 stack[4] = storage[stack[-2]] // @2A57 stack[3] = 0x2a5c // } // Block ends with call to 0x4c7e, returns to 0x2A5C label_2A5C: // Incoming return from call to 0x4C7E at 0x2A5B // Inputs[1] { @2A5D stack[-1] } 2A5C 5B JUMPDEST 2A5D 80 DUP1 2A5E 15 ISZERO 2A5F 61 PUSH2 0x2aa9 2A62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2aa9, if !stack[-1] label_2A63: // Incoming jump from 0x2A62, if not !stack[-1] // Inputs[1] { @2A63 stack[-1] } 2A63 80 DUP1 2A64 60 PUSH1 0x1f 2A66 10 LT 2A67 61 PUSH2 0x2a7e 2A6A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a7e, if 0x1f < stack[-1] label_2A6B: // Incoming jump from 0x2A6A, if not 0x1f < stack[-1] // Inputs[4] // { // @2A6F stack[-2] // @2A70 storage[stack[-2]] // @2A73 stack[-3] // @2A75 stack[-1] // } 2A6B 61 PUSH2 0x0100 2A6E 80 DUP1 2A6F 83 DUP4 2A70 54 SLOAD 2A71 04 DIV 2A72 02 MUL 2A73 83 DUP4 2A74 52 MSTORE 2A75 91 SWAP2 2A76 60 PUSH1 0x20 2A78 01 ADD 2A79 91 SWAP2 2A7A 61 PUSH2 0x2aa9 2A7D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2A74 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2A79 stack[-1] = stack[-1] // @2A79 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2aa9 label_2A7E: // Incoming jump from 0x2A6A, if 0x1f < stack[-1] // Inputs[5] // { // @2A7F stack[-3] // @2A80 stack[-1] // @2A82 stack[-2] // @2A8A memory[0x00:0x20] // @2A8E storage[keccak256(memory[0x00:0x20])] // } 2A7E 5B JUMPDEST 2A7F 82 DUP3 2A80 01 ADD 2A81 91 SWAP2 2A82 90 SWAP1 2A83 60 PUSH1 0x00 2A85 52 MSTORE 2A86 60 PUSH1 0x20 2A88 60 PUSH1 0x00 2A8A 20 SHA3 2A8B 90 SWAP1 2A8C 5B JUMPDEST 2A8D 81 DUP2 2A8E 54 SLOAD 2A8F 81 DUP2 2A90 52 MSTORE 2A91 90 SWAP1 2A92 60 PUSH1 0x01 2A94 01 ADD 2A95 90 SWAP1 2A96 60 PUSH1 0x20 2A98 01 ADD 2A99 80 DUP1 2A9A 83 DUP4 2A9B 11 GT 2A9C 61 PUSH2 0x2a8c 2A9F 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2A81 stack[-3] = stack[-3] + stack[-1] // @2A85 memory[0x00:0x20] = stack[-2] // @2A90 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2A95 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2A98 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2a8c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2AA0: // Incoming jump from 0x2A9F, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2A9F, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @2AA0 stack[-3] // @2AA1 stack[-1] // } 2AA0 82 DUP3 2AA1 90 SWAP1 2AA2 03 SUB 2AA3 60 PUSH1 0x1f 2AA5 16 AND 2AA6 82 DUP3 2AA7 01 ADD 2AA8 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2AA8 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2AA8 stack[-1] = stack[-3] // } // Block continues label_2AA9: // Incoming jump from 0x2A62, if !stack[-1] // Incoming jump from 0x2A7D // Incoming jump from 0x2AA8 // Inputs[3] // { // @2AAF stack[-6] // @2AAF stack[-7] // @2AB1 stack[-8] // } 2AA9 5B JUMPDEST 2AAA 50 POP 2AAB 50 POP 2AAC 50 POP 2AAD 50 POP 2AAE 50 POP 2AAF 90 SWAP1 2AB0 50 POP 2AB1 90 SWAP1 2AB2 56 *JUMP // Stack delta = -7 // Outputs[1] { @2AB1 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_2AB3: // Incoming call from 0x2054, returns to 0x2055 // Inputs[1] { @2AB8 stack[-1] } 2AB3 5B JUMPDEST 2AB4 60 PUSH1 0x60 2AB6 60 PUSH1 0x00 2AB8 82 DUP3 2AB9 14 EQ 2ABA 15 ISZERO 2ABB 61 PUSH2 0x2afb 2ABE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AB4 stack[0] = 0x60 } // Block ends with conditional jump to 0x2afb, if !(stack[-1] == 0x00) label_2ABF: // Incoming jump from 0x2ABE, if not !(stack[-1] == 0x00) // Inputs[2] // { // @2AC1 memory[0x40:0x60] // @2AF5 stack[-1] // } 2ABF 60 PUSH1 0x40 2AC1 51 MLOAD 2AC2 80 DUP1 2AC3 60 PUSH1 0x40 2AC5 01 ADD 2AC6 60 PUSH1 0x40 2AC8 52 MSTORE 2AC9 80 DUP1 2ACA 60 PUSH1 0x01 2ACC 81 DUP2 2ACD 52 MSTORE 2ACE 60 PUSH1 0x20 2AD0 01 ADD 2AD1 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 2AF2 81 DUP2 2AF3 52 MSTORE 2AF4 50 POP 2AF5 90 SWAP1 2AF6 50 POP 2AF7 61 PUSH2 0x2c5b 2AFA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2AC8 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2ACD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @2AF3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @2AF5 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2c5b label_2AFB: // Incoming jump from 0x2ABE, if !(stack[-1] == 0x00) // Inputs[1] { @2AFE stack[-2] } 2AFB 5B JUMPDEST 2AFC 60 PUSH1 0x00 2AFE 82 DUP3 2AFF 90 SWAP1 2B00 50 POP 2B01 60 PUSH1 0x00 2B03 5B JUMPDEST 2B04 60 PUSH1 0x00 2B06 82 DUP3 2B07 14 EQ 2B08 61 PUSH2 0x2b2d 2B0B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2AFF stack[0] = stack[-2] // @2B01 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2b2d, if stack[-2] == 0x00 label_2B0C: // Incoming jump from 0x2B0B, if not stack[-2] == 0x00 // Incoming jump from 0x2B0B, if not stack[-2] == 0x00 // Inputs[1] { @2B0C stack[-1] } 2B0C 80 DUP1 2B0D 80 DUP1 2B0E 61 PUSH2 0x2b16 2B11 90 SWAP1 2B12 61 PUSH2 0x4cb0 2B15 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B0C stack[0] = stack[-1] // @2B11 stack[1] = 0x2b16 // @2B11 stack[2] = stack[-1] // } // Block ends with call to 0x4cb0, returns to 0x2B16 label_2B16: // Incoming return from call to 0x4CB0 at 0x2B15 // Inputs[3] // { // @2B17 stack[-1] // @2B17 stack[-3] // @2B1C stack[-4] // } 2B16 5B JUMPDEST 2B17 91 SWAP2 2B18 50 POP 2B19 50 POP 2B1A 60 PUSH1 0x0a 2B1C 82 DUP3 2B1D 61 PUSH2 0x2b26 2B20 91 SWAP2 2B21 90 SWAP1 2B22 61 PUSH2 0x4b09 2B25 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2B17 stack[-3] = stack[-1] // @2B20 stack[-2] = 0x2b26 // @2B21 stack[-1] = 0x0a // @2B21 stack[0] = stack[-4] // } // Block ends with call to 0x4b09, returns to 0x2B26 label_2B26: // Incoming return from call to 0x4B09 at 0x2B25 // Inputs[2] // { // @2B27 stack[-1] // @2B27 stack[-3] // } 2B26 5B JUMPDEST 2B27 91 SWAP2 2B28 50 POP 2B29 61 PUSH2 0x2b03 2B2C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2B27 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x2b03 label_2B2D: // Incoming jump from 0x2B0B, if stack[-2] == 0x00 // Incoming jump from 0x2B0B, if stack[-2] == 0x00 // Inputs[1] { @2B30 stack[-1] } 2B2D 5B JUMPDEST 2B2E 60 PUSH1 0x00 2B30 81 DUP2 2B31 67 PUSH8 0xffffffffffffffff 2B3A 81 DUP2 2B3B 11 GT 2B3C 15 ISZERO 2B3D 61 PUSH2 0x2b6f 2B40 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B2E stack[0] = 0x00 // @2B30 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2b6f, if !(stack[-1] > 0xffffffffffffffff) label_2B41: // Incoming jump from 0x2B40, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @2B6E memory[0x00:0x24] } 2B41 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2B62 60 PUSH1 0x00 2B64 52 MSTORE 2B65 60 PUSH1 0x41 2B67 60 PUSH1 0x04 2B69 52 MSTORE 2B6A 60 PUSH1 0x24 2B6C 60 PUSH1 0x00 2B6E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B64 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2B69 memory[0x04:0x24] = 0x41 // @2B6E revert(memory[0x00:0x24]); // } // Block terminates label_2B6F: // Incoming jump from 0x2B40, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2B72 memory[0x40:0x60] // @2B73 stack[-1] // } 2B6F 5B JUMPDEST 2B70 60 PUSH1 0x40 2B72 51 MLOAD 2B73 90 SWAP1 2B74 80 DUP1 2B75 82 DUP3 2B76 52 MSTORE 2B77 80 DUP1 2B78 60 PUSH1 0x1f 2B7A 01 ADD 2B7B 60 PUSH1 0x1f 2B7D 19 NOT 2B7E 16 AND 2B7F 60 PUSH1 0x20 2B81 01 ADD 2B82 82 DUP3 2B83 01 ADD 2B84 60 PUSH1 0x40 2B86 52 MSTORE 2B87 80 DUP1 2B88 15 ISZERO 2B89 61 PUSH2 0x2ba1 2B8C 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2B73 stack[-1] = memory[0x40:0x60] // @2B73 stack[0] = stack[-1] // @2B76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2B86 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x2ba1, if !stack[-1] label_2B8D: // Incoming jump from 0x2B8C, if not !stack[-1] // Inputs[6] // { // @2B8D stack[-2] // @2B93 stack[-1] // @2B96 msg.data.length // @2B98 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x01] // @2BA3 stack[-3] // @2BA8 stack[-7] // } 2B8D 81 DUP2 2B8E 60 PUSH1 0x20 2B90 01 ADD 2B91 60 PUSH1 0x01 2B93 82 DUP3 2B94 02 MUL 2B95 80 DUP1 2B96 36 CALLDATASIZE 2B97 83 DUP4 2B98 37 CALLDATACOPY 2B99 80 DUP1 2B9A 82 DUP3 2B9B 01 ADD 2B9C 91 SWAP2 2B9D 50 POP 2B9E 50 POP 2B9F 90 SWAP1 2BA0 50 POP 2BA1 5B JUMPDEST 2BA2 50 POP 2BA3 90 SWAP1 2BA4 50 POP 2BA5 5B JUMPDEST 2BA6 60 PUSH1 0x00 2BA8 85 DUP6 2BA9 14 EQ 2BAA 61 PUSH2 0x2c54 2BAD 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2B98 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x01] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x01] // @2BA3 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x2c54, if stack[-7] == 0x00 label_2BAE: // Incoming jump from 0x2BAD, if not stack[-7] == 0x00 // Incoming jump from 0x2BAD, if not stack[-5] == 0x00 // Incoming jump from 0x2BAD, if not stack[-7] == 0x00 // Inputs[1] { @2BB0 stack[-2] } 2BAE 60 PUSH1 0x01 2BB0 82 DUP3 2BB1 61 PUSH2 0x2bba 2BB4 91 SWAP2 2BB5 90 SWAP1 2BB6 61 PUSH2 0x4b94 2BB9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BB4 stack[0] = 0x2bba // @2BB5 stack[1] = 0x01 // @2BB5 stack[2] = stack[-2] // } // Block ends with call to 0x4b94, returns to 0x2BBA label_2BBA: // Incoming return from call to 0x4B94 at 0x2BB9 // Inputs[3] // { // @2BBB stack[-1] // @2BBB stack[-3] // @2BBF stack[-6] // } 2BBA 5B JUMPDEST 2BBB 91 SWAP2 2BBC 50 POP 2BBD 60 PUSH1 0x0a 2BBF 85 DUP6 2BC0 61 PUSH2 0x2bc9 2BC3 91 SWAP2 2BC4 90 SWAP1 2BC5 61 PUSH2 0x4cf9 2BC8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2BBB stack[-3] = stack[-1] // @2BC3 stack[-1] = 0x2bc9 // @2BC4 stack[1] = stack[-6] // @2BC4 stack[0] = 0x0a // } // Block ends with call to 0x4cf9, returns to 0x2BC9 label_2BC9: // Incoming return from call to 0x4CF9 at 0x2BC8 // Inputs[1] { @2BCF stack[-1] } 2BC9 5B JUMPDEST 2BCA 60 PUSH1 0x30 2BCC 61 PUSH2 0x2bd5 2BCF 91 SWAP2 2BD0 90 SWAP1 2BD1 61 PUSH2 0x4ab3 2BD4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2BCF stack[-1] = 0x2bd5 // @2BD0 stack[1] = 0x30 // @2BD0 stack[0] = stack[-1] // } // Block ends with call to 0x4ab3, returns to 0x2BD5 label_2BD5: // Incoming return from call to 0x4AB3 at 0x2BD4 // Inputs[4] // { // @2BD8 stack[-1] // @2BD9 stack[-2] // @2BDA stack[-3] // @2BDC memory[stack[-2]:stack[-2] + 0x20] // } 2BD5 5B JUMPDEST 2BD6 60 PUSH1 0xf8 2BD8 1B SHL 2BD9 81 DUP2 2BDA 83 DUP4 2BDB 81 DUP2 2BDC 51 MLOAD 2BDD 81 DUP2 2BDE 10 LT 2BDF 61 PUSH2 0x2c11 2BE2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2BD8 stack[-1] = stack[-1] << 0xf8 // @2BD9 stack[0] = stack[-2] // @2BDA stack[1] = stack[-3] // } // Block ends with conditional jump to 0x2c11, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_2BE3: // Incoming jump from 0x2BE2, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @2C10 memory[0x00:0x24] } 2BE3 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2C04 60 PUSH1 0x00 2C06 52 MSTORE 2C07 60 PUSH1 0x32 2C09 60 PUSH1 0x04 2C0B 52 MSTORE 2C0C 60 PUSH1 0x24 2C0E 60 PUSH1 0x00 2C10 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2C06 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2C0B memory[0x04:0x24] = 0x32 // @2C10 revert(memory[0x00:0x24]); // } // Block terminates label_2C11: // Incoming jump from 0x2BE2, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @2C14 stack[-1] // @2C15 stack[-2] // @2C16 stack[-3] // @2C43 stack[-8] // } 2C11 5B JUMPDEST 2C12 60 PUSH1 0x20 2C14 01 ADD 2C15 01 ADD 2C16 90 SWAP1 2C17 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2C37 19 NOT 2C38 16 AND 2C39 90 SWAP1 2C3A 81 DUP2 2C3B 60 PUSH1 0x00 2C3D 1A BYTE 2C3E 90 SWAP1 2C3F 53 MSTORE8 2C40 50 POP 2C41 60 PUSH1 0x0a 2C43 85 DUP6 2C44 61 PUSH2 0x2c4d 2C47 91 SWAP2 2C48 90 SWAP1 2C49 61 PUSH2 0x4b09 2C4C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2C3F memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2C47 stack[-3] = 0x2c4d // @2C48 stack[-1] = stack[-8] // @2C48 stack[-2] = 0x0a // } // Block ends with call to 0x4b09, returns to 0x2C4D label_2C4D: // Incoming return from call to 0x4B09 at 0x2C4C // Inputs[2] // { // @2C4E stack[-6] // @2C4E stack[-1] // } 2C4D 5B JUMPDEST 2C4E 94 SWAP5 2C4F 50 POP 2C50 61 PUSH2 0x2ba5 2C53 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C4E stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x2ba5 label_2C54: // Incoming jump from 0x2BAD, if stack[-7] == 0x00 // Incoming jump from 0x2BAD, if stack[-5] == 0x00 // Incoming jump from 0x2BAD, if stack[-7] == 0x00 // Inputs[4] // { // @2C55 stack[-1] // @2C56 stack[-4] // @2C5C stack[-6] // @2C5D stack[-5] // } 2C54 5B JUMPDEST 2C55 80 DUP1 2C56 93 SWAP4 2C57 50 POP 2C58 50 POP 2C59 50 POP 2C5A 50 POP 2C5B 5B JUMPDEST 2C5C 91 SWAP2 2C5D 90 SWAP1 2C5E 50 POP 2C5F 56 *JUMP // Stack delta = -5 // Outputs[1] { @2C5C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2C60: // Incoming call from 0x2471, returns to 0x2472 // Inputs[1] { @2CA3 stack[-1] } 2C60 5B JUMPDEST 2C61 60 PUSH1 0x00 2C63 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 2C84 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2CA1 19 NOT 2CA2 16 AND 2CA3 82 DUP3 2CA4 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2CC1 19 NOT 2CC2 16 AND 2CC3 14 EQ 2CC4 80 DUP1 2CC5 61 PUSH2 0x2d2b 2CC8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C61 stack[0] = 0x00 // @2CC3 stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x2d2b, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 label_2CC9: // Incoming jump from 0x2CC8, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @2D0A stack[-3] } 2CC9 50 POP 2CCA 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 2CEB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2D08 19 NOT 2D09 16 AND 2D0A 82 DUP3 2D0B 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2D28 19 NOT 2D29 16 AND 2D2A 14 EQ 2D2B 5B JUMPDEST 2D2C 80 DUP1 2D2D 61 PUSH2 0x2d3b 2D30 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2D2A stack[-1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x2d3b, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 label_2D31: // Incoming jump from 0x2D30, if not stack[-1] // Incoming jump from 0x2D30, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @2D35 stack[-3] } 2D31 50 POP 2D32 61 PUSH2 0x2d3a 2D35 82 DUP3 2D36 61 PUSH2 0x2f44 2D39 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2D32 stack[-1] = 0x2d3a // @2D35 stack[0] = stack[-3] // } // Block ends with call to 0x2f44, returns to 0x2D3A label_2D3A: // Incoming return from call to 0x2F44 at 0x2D39 2D3A 5B JUMPDEST // Stack delta = +0 // Block continues label_2D3B: // Incoming jump from 0x2D3A // Incoming jump from 0x2D30, if stack[-1] // Incoming jump from 0x2D30, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Inputs[4] // { // @2D3C stack[-1] // @2D3C stack[-2] // @2D3E stack[-4] // @2D3F stack[-3] // } 2D3B 5B JUMPDEST 2D3C 90 SWAP1 2D3D 50 POP 2D3E 91 SWAP2 2D3F 90 SWAP1 2D40 50 POP 2D41 56 *JUMP // Stack delta = -3 // Outputs[1] { @2D3E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2D42: // Incoming call from 0x2775, returns to 0x2776 // Incoming call from 0x3186, returns to 0x3187 // Inputs[3] // { // @2D46 stack[-3] // @2D47 stack[-2] // @2D48 stack[-1] // } 2D42 5B JUMPDEST 2D43 61 PUSH2 0x2d4d 2D46 83 DUP4 2D47 83 DUP4 2D48 83 DUP4 2D49 61 PUSH2 0x2fae 2D4C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2D43 stack[0] = 0x2d4d // @2D46 stack[1] = stack[-3] // @2D47 stack[2] = stack[-2] // @2D48 stack[3] = stack[-1] // } // Block ends with call to 0x2fae, returns to 0x2D4D label_2D4D: // Incoming return from call to 0x2FAE at 0x2D4C // Incoming return from call to 0x2FAE at 0x2D4C // Inputs[1] { @2D51 stack[-4] } 2D4D 5B JUMPDEST 2D4E 50 POP 2D4F 50 POP 2D50 50 POP 2D51 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2D52: // Incoming call from 0x28FA, returns to 0x28FB // Inputs[2] // { // @2D56 stack[-3] // @2D57 stack[-2] // } 2D52 5B JUMPDEST 2D53 61 PUSH2 0x2d5c 2D56 83 DUP4 2D57 83 DUP4 2D58 61 PUSH2 0x30c2 2D5B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D53 stack[0] = 0x2d5c // @2D56 stack[1] = stack[-3] // @2D57 stack[2] = stack[-2] // } // Block ends with call to 0x30c2, returns to 0x2D5C label_2D5C: // Incoming return from call to 0x30C2 at 0x2D5B // Inputs[3] // { // @2D62 stack[-3] // @2D63 stack[-2] // @2D64 stack[-1] // } 2D5C 5B JUMPDEST 2D5D 61 PUSH2 0x2d69 2D60 60 PUSH1 0x00 2D62 84 DUP5 2D63 84 DUP5 2D64 84 DUP5 2D65 61 PUSH2 0x2dad 2D68 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2D5D stack[0] = 0x2d69 // @2D60 stack[1] = 0x00 // @2D62 stack[2] = stack[-3] // @2D63 stack[3] = stack[-2] // @2D64 stack[4] = stack[-1] // } // Block ends with call to 0x2dad, returns to 0x2D69 label_2D69: // Incoming return from call to 0x2DAD at 0x2D68 // Inputs[1] { @2D6D stack[-1] } 2D69 5B JUMPDEST 2D6A 61 PUSH2 0x2da8 2D6D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2da8, if stack[-1] label_2D6E: // Incoming jump from 0x2D6D, if not stack[-1] // Inputs[1] { @2D70 memory[0x40:0x60] } 2D6E 60 PUSH1 0x40 2D70 51 MLOAD 2D71 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2D92 81 DUP2 2D93 52 MSTORE 2D94 60 PUSH1 0x04 2D96 01 ADD 2D97 61 PUSH2 0x2d9f 2D9A 90 SWAP1 2D9B 61 PUSH2 0x464f 2D9E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2D93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2D9A stack[0] = 0x2d9f // @2D9A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x464f, returns to 0x2D9F label_2D9F: // Incoming return from call to 0x464F at 0x2D9E // Inputs[3] // { // @2DA2 memory[0x40:0x60] // @2DA4 stack[-1] // @2DA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 2D9F 5B JUMPDEST 2DA0 60 PUSH1 0x40 2DA2 51 MLOAD 2DA3 80 DUP1 2DA4 91 SWAP2 2DA5 03 SUB 2DA6 90 SWAP1 2DA7 FD *REVERT // Stack delta = -1 // Outputs[1] { @2DA7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_2DA8: // Incoming jump from 0x2D6D, if stack[-1] // Inputs[1] { @2DAC stack[-4] } 2DA8 5B JUMPDEST 2DA9 50 POP 2DAA 50 POP 2DAB 50 POP 2DAC 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2DAD: // Incoming call from 0x29DB, returns to 0x29DC // Incoming call from 0x2D68, returns to 0x2D69 // Inputs[1] { @2DB3 stack[-3] } 2DAD 5B JUMPDEST 2DAE 60 PUSH1 0x00 2DB0 61 PUSH2 0x2dce 2DB3 84 DUP5 2DB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DC9 16 AND 2DCA 61 PUSH2 0x3290 2DCD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DAE stack[0] = 0x00 // @2DB0 stack[1] = 0x2dce // @2DC9 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x3290, returns to 0x2DCE label_2DCE: // Incoming return from call to 0x3290 at 0x2DCD // Inputs[1] { @2DCF stack[-1] } 2DCE 5B JUMPDEST 2DCF 15 ISZERO 2DD0 61 PUSH2 0x2f37 2DD3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2f37, if !stack[-1] label_2DD4: // Incoming jump from 0x2DD3, if not !stack[-1] // Inputs[1] { @2DD4 stack[-4] } 2DD4 83 DUP4 2DD5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DEA 16 AND 2DEB 63 PUSH4 0x150b7a02 2DF0 61 PUSH2 0x2df7 2DF3 61 PUSH2 0x24e6 2DF6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DEA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2DEB stack[1] = 0x150b7a02 // @2DF0 stack[2] = 0x2df7 // } // Block ends with call to 0x24e6, returns to 0x2DF7 label_2DF7: // Incoming return from call to 0x24E6 at 0x2DF6 // Inputs[6] // { // @2DF8 stack[-8] // @2DF9 stack[-6] // @2DFA stack[-5] // @2DFD memory[0x40:0x60] // @2DFE stack[-2] // @2E10 stack[-1] // } 2DF7 5B JUMPDEST 2DF8 87 DUP8 2DF9 86 DUP7 2DFA 86 DUP7 2DFB 60 PUSH1 0x40 2DFD 51 MLOAD 2DFE 85 DUP6 2DFF 63 PUSH4 0xffffffff 2E04 16 AND 2E05 60 PUSH1 0xe0 2E07 1B SHL 2E08 81 DUP2 2E09 52 MSTORE 2E0A 60 PUSH1 0x04 2E0C 01 ADD 2E0D 61 PUSH2 0x2e19 2E10 94 SWAP5 2E11 93 SWAP4 2E12 92 SWAP3 2E13 91 SWAP2 2E14 90 SWAP1 2E15 61 PUSH2 0x45a6 2E18 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2E09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @2E10 stack[-1] = 0x2e19 // @2E11 stack[0] = stack[-1] // @2E12 stack[1] = stack[-8] // @2E13 stack[2] = stack[-6] // @2E14 stack[4] = 0x04 + memory[0x40:0x60] // @2E14 stack[3] = stack[-5] // } // Block ends with call to 0x45a6, returns to 0x2E19 label_2E19: // Incoming return from call to 0x45A6 at 0x2E18 // Inputs[4] // { // @2E1E memory[0x40:0x60] // @2E20 stack[-1] // @2E25 stack[-3] // @2E27 address(stack[-3]).code.length // } 2E19 5B JUMPDEST 2E1A 60 PUSH1 0x20 2E1C 60 PUSH1 0x40 2E1E 51 MLOAD 2E1F 80 DUP1 2E20 83 DUP4 2E21 03 SUB 2E22 81 DUP2 2E23 60 PUSH1 0x00 2E25 87 DUP8 2E26 80 DUP1 2E27 3B EXTCODESIZE 2E28 15 ISZERO 2E29 80 DUP1 2E2A 15 ISZERO 2E2B 61 PUSH2 0x2e33 2E2E 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @2E1A stack[0] = 0x20 // @2E1E stack[1] = memory[0x40:0x60] // @2E21 stack[2] = stack[-1] - memory[0x40:0x60] // @2E22 stack[3] = memory[0x40:0x60] // @2E23 stack[4] = 0x00 // @2E25 stack[5] = stack[-3] // @2E28 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x2e33, if !!address(stack[-3]).code.length label_2E2F: // Incoming jump from 0x2E2E, if not !!address(stack[-3]).code.length // Inputs[1] { @2E32 memory[0x00:0x00] } 2E2F 60 PUSH1 0x00 2E31 80 DUP1 2E32 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E32 revert(memory[0x00:0x00]); } // Block terminates label_2E33: // Incoming jump from 0x2E2E, if !!address(stack[-3]).code.length // Inputs[10] // { // @2E35 msg.gas // @2E36 stack[-2] // @2E36 stack[-7] // @2E36 stack[-4] // @2E36 memory[stack[-4]:stack[-4] + stack[-5]] // @2E36 stack[-6] // @2E36 stack[-5] // @2E36 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2E36 stack[-3] // @2E37 stack[-10] // } 2E33 5B JUMPDEST 2E34 50 POP 2E35 5A GAS 2E36 F1 CALL 2E37 92 SWAP3 2E38 50 POP 2E39 50 POP 2E3A 50 POP 2E3B 80 DUP1 2E3C 15 ISZERO 2E3D 61 PUSH2 0x2e64 2E40 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @2E36 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2E37 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2e64, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2E41: // Incoming jump from 0x2E40, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2E44 memory[0x40:0x60] // @2E45 returndata.length // } 2E41 50 POP 2E42 60 PUSH1 0x40 2E44 51 MLOAD 2E45 3D RETURNDATASIZE 2E46 60 PUSH1 0x1f 2E48 19 NOT 2E49 60 PUSH1 0x1f 2E4B 82 DUP3 2E4C 01 ADD 2E4D 16 AND 2E4E 82 DUP3 2E4F 01 ADD 2E50 80 DUP1 2E51 60 PUSH1 0x40 2E53 52 MSTORE 2E54 50 POP 2E55 81 DUP2 2E56 01 ADD 2E57 90 SWAP1 2E58 61 PUSH2 0x2e61 2E5B 91 SWAP2 2E5C 90 SWAP1 2E5D 61 PUSH2 0x39cc 2E60 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2E53 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2E5B stack[-1] = 0x2e61 // @2E5C stack[1] = memory[0x40:0x60] // @2E5C stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x39cc, returns to 0x2E61 label_2E61: // Incoming return from call to 0x39CC at 0x2E60 2E61 5B JUMPDEST 2E62 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @2E62 stack[0] = 0x01 } // Block continues label_2E64: // Incoming jump from 0x2E40, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Incoming jump from 0x2E62 // Inputs[1] { @2E68 stack[-1] } 2E64 5B JUMPDEST 2E65 61 PUSH2 0x2ee7 2E68 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ee7, if stack[-1] label_2E69: // Incoming jump from 0x2E68, if not stack[-1] // Inputs[1] { @2E69 returndata.length } 2E69 3D RETURNDATASIZE 2E6A 80 DUP1 2E6B 60 PUSH1 0x00 2E6D 81 DUP2 2E6E 14 EQ 2E6F 61 PUSH2 0x2e94 2E72 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2E69 stack[0] = returndata.length // @2E6A stack[1] = returndata.length // } // Block ends with conditional jump to 0x2e94, if returndata.length == 0x00 label_2E73: // Incoming jump from 0x2E72, if not returndata.length == 0x00 // Inputs[6] // { // @2E75 memory[0x40:0x60] // @2E76 stack[-2] // @2E7D returndata.length // @2E85 returndata.length // @2E88 returndata.length // @2E8F returndata[0x00:0x00 + returndata.length] // } 2E73 60 PUSH1 0x40 2E75 51 MLOAD 2E76 91 SWAP2 2E77 50 POP 2E78 60 PUSH1 0x1f 2E7A 19 NOT 2E7B 60 PUSH1 0x3f 2E7D 3D RETURNDATASIZE 2E7E 01 ADD 2E7F 16 AND 2E80 82 DUP3 2E81 01 ADD 2E82 60 PUSH1 0x40 2E84 52 MSTORE 2E85 3D RETURNDATASIZE 2E86 82 DUP3 2E87 52 MSTORE 2E88 3D RETURNDATASIZE 2E89 60 PUSH1 0x00 2E8B 60 PUSH1 0x20 2E8D 84 DUP5 2E8E 01 ADD 2E8F 3E RETURNDATACOPY 2E90 61 PUSH2 0x2e99 2E93 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2E76 stack[-2] = memory[0x40:0x60] // @2E84 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @2E87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @2E8F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x2e99 label_2E94: // Incoming jump from 0x2E72, if returndata.length == 0x00 // Inputs[2] // { // @2E97 stack[-2] // @2E9E memory[0x60:0x80] // } 2E94 5B JUMPDEST 2E95 60 PUSH1 0x60 2E97 91 SWAP2 2E98 50 POP 2E99 5B JUMPDEST 2E9A 50 POP 2E9B 60 PUSH1 0x00 2E9D 81 DUP2 2E9E 51 MLOAD 2E9F 14 EQ 2EA0 15 ISZERO 2EA1 61 PUSH2 0x2edf 2EA4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2E97 stack[-2] = 0x60 } // Block ends with conditional jump to 0x2edf, if !(memory[0x60:0x80] == 0x00) label_2EA5: // Incoming jump from 0x2EA4, if not !(memory[0x60:0x80] == 0x00) // Incoming jump from 0x2EA4, if not !(memory[stack[-2]:stack[-2] + 0x20] == 0x00) // Inputs[1] { @2EA7 memory[0x40:0x60] } 2EA5 60 PUSH1 0x40 2EA7 51 MLOAD 2EA8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2EC9 81 DUP2 2ECA 52 MSTORE 2ECB 60 PUSH1 0x04 2ECD 01 ADD 2ECE 61 PUSH2 0x2ed6 2ED1 90 SWAP1 2ED2 61 PUSH2 0x464f 2ED5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2ECA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2ED1 stack[0] = 0x2ed6 // @2ED1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x464f, returns to 0x2ED6 label_2ED6: // Incoming return from call to 0x464F at 0x2ED5 // Inputs[3] // { // @2ED9 memory[0x40:0x60] // @2EDB stack[-1] // @2EDE memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 2ED6 5B JUMPDEST 2ED7 60 PUSH1 0x40 2ED9 51 MLOAD 2EDA 80 DUP1 2EDB 91 SWAP2 2EDC 03 SUB 2EDD 90 SWAP1 2EDE FD *REVERT // Stack delta = -1 // Outputs[1] { @2EDE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_2EDF: // Incoming jump from 0x2EA4, if !(memory[0x60:0x80] == 0x00) // Incoming jump from 0x2EA4, if !(memory[stack[-2]:stack[-2] + 0x20] == 0x00) // Inputs[3] // { // @2EE0 stack[-1] // @2EE1 memory[stack[-1]:stack[-1] + 0x20] // @2EE6 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 2EDF 5B JUMPDEST 2EE0 80 DUP1 2EE1 51 MLOAD 2EE2 81 DUP2 2EE3 60 PUSH1 0x20 2EE5 01 ADD 2EE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2EE6 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_2EE7: // Incoming jump from 0x2E68, if stack[-1] // Inputs[2] // { // @2F0F stack[-1] // @2F30 stack[-2] // } 2EE7 5B JUMPDEST 2EE8 63 PUSH4 0x150b7a02 2EED 60 PUSH1 0xe0 2EEF 1B SHL 2EF0 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2F0D 19 NOT 2F0E 16 AND 2F0F 81 DUP2 2F10 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2F2D 19 NOT 2F2E 16 AND 2F2F 14 EQ 2F30 91 SWAP2 2F31 50 POP 2F32 50 POP 2F33 61 PUSH2 0x2f3c 2F36 56 *JUMP // Stack delta = -1 // Outputs[1] { @2F30 stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block ends with unconditional jump to 0x2f3c label_2F37: // Incoming jump from 0x2DD3, if !stack[-1] // Inputs[3] // { // @2F3A stack[-1] // @2F3D stack[-6] // @2F3E stack[-5] // } 2F37 5B JUMPDEST 2F38 60 PUSH1 0x01 2F3A 90 SWAP1 2F3B 50 POP 2F3C 5B JUMPDEST 2F3D 94 SWAP5 2F3E 93 SWAP4 2F3F 50 POP 2F40 50 POP 2F41 50 POP 2F42 50 POP 2F43 56 *JUMP // Stack delta = -5 // Outputs[1] { @2F3D stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_2F44: // Incoming call from 0x2D39, returns to 0x2D3A // Inputs[2] // { // @2F87 stack[-1] // @2FAA stack[-2] // } 2F44 5B JUMPDEST 2F45 60 PUSH1 0x00 2F47 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 2F68 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2F85 19 NOT 2F86 16 AND 2F87 82 DUP3 2F88 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2FA5 19 NOT 2FA6 16 AND 2FA7 14 EQ 2FA8 90 SWAP1 2FA9 50 POP 2FAA 91 SWAP2 2FAB 90 SWAP1 2FAC 50 POP 2FAD 56 *JUMP // Stack delta = -1 // Outputs[1] { @2FAA stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_2FAE: // Incoming call from 0x2D4C, returns to 0x2D4D // Inputs[3] // { // @2FB2 stack[-3] // @2FB3 stack[-2] // @2FB4 stack[-1] // } 2FAE 5B JUMPDEST 2FAF 61 PUSH2 0x2fb9 2FB2 83 DUP4 2FB3 83 DUP4 2FB4 83 DUP4 2FB5 61 PUSH2 0x32a3 2FB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2FAF stack[0] = 0x2fb9 // @2FB2 stack[1] = stack[-3] // @2FB3 stack[2] = stack[-2] // @2FB4 stack[3] = stack[-1] // } // Block ends with call to 0x32a3, returns to 0x2FB9 label_2FB9: // Incoming return from call to 0x32A3 at 0x2FB8 // Inputs[1] { @2FD2 stack[-3] } 2FB9 5B JUMPDEST 2FBA 60 PUSH1 0x00 2FBC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2FD1 16 AND 2FD2 83 DUP4 2FD3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2FE8 16 AND 2FE9 14 EQ 2FEA 15 ISZERO 2FEB 61 PUSH2 0x2ffc 2FEE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ffc, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2FEF: // Incoming jump from 0x2FEE, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2FF2 stack[-1] } 2FEF 61 PUSH2 0x2ff7 2FF2 81 DUP2 2FF3 61 PUSH2 0x32a8 2FF6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2FEF stack[0] = 0x2ff7 // @2FF2 stack[1] = stack[-1] // } // Block ends with call to 0x32a8, returns to 0x2FF7 label_2FF7: // Incoming return from call to 0x32A8 at 0x2FF6 2FF7 5B JUMPDEST 2FF8 61 PUSH2 0x303b 2FFB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x303b label_2FFC: // Incoming jump from 0x2FEE, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @2FFD stack[-2] // @3014 stack[-3] // } 2FFC 5B JUMPDEST 2FFD 81 DUP2 2FFE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3013 16 AND 3014 83 DUP4 3015 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 302A 16 AND 302B 14 EQ 302C 61 PUSH2 0x303a 302F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x303a, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] label_3030: // Incoming jump from 0x302F, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Inputs[2] // { // @3033 stack[-3] // @3034 stack[-1] // } 3030 61 PUSH2 0x3039 3033 83 DUP4 3034 82 DUP3 3035 61 PUSH2 0x32f1 3038 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3030 stack[0] = 0x3039 // @3033 stack[1] = stack[-3] // @3034 stack[2] = stack[-1] // } // Block ends with call to 0x32f1, returns to 0x3039 label_3039: // Incoming return from call to 0x32F1 at 0x3038 3039 5B JUMPDEST // Stack delta = +0 // Block continues label_303A: // Incoming jump from 0x302F, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Incoming jump from 0x3039 // Inputs[1] { @3054 stack[-2] } 303A 5B JUMPDEST 303B 5B JUMPDEST 303C 60 PUSH1 0x00 303E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3053 16 AND 3054 82 DUP3 3055 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 306A 16 AND 306B 14 EQ 306C 15 ISZERO 306D 61 PUSH2 0x307e 3070 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x307e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_3071: // Incoming jump from 0x3070, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x3070, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @3074 stack[-1] } 3071 61 PUSH2 0x3079 3074 81 DUP2 3075 61 PUSH2 0x345e 3078 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3071 stack[0] = 0x3079 // @3074 stack[1] = stack[-1] // } // Block ends with call to 0x345e, returns to 0x3079 label_3079: // Incoming return from call to 0x345E at 0x3078 3079 5B JUMPDEST 307A 61 PUSH2 0x30bd 307D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x30bd label_307E: // Incoming jump from 0x3070, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x3070, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @307F stack[-3] // @3096 stack[-2] // } 307E 5B JUMPDEST 307F 82 DUP3 3080 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3095 16 AND 3096 82 DUP3 3097 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30AC 16 AND 30AD 14 EQ 30AE 61 PUSH2 0x30bc 30B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x30bc, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] label_30B2: // Incoming jump from 0x30B1, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // Inputs[2] // { // @30B5 stack[-2] // @30B6 stack[-1] // } 30B2 61 PUSH2 0x30bb 30B5 82 DUP3 30B6 82 DUP3 30B7 61 PUSH2 0x35a1 30BA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @30B2 stack[0] = 0x30bb // @30B5 stack[1] = stack[-2] // @30B6 stack[2] = stack[-1] // } // Block ends with call to 0x35a1, returns to 0x30BB label_30BB: // Incoming return from call to 0x35A1 at 0x30BA 30BB 5B JUMPDEST // Stack delta = +0 // Block continues label_30BC: // Incoming jump from 0x30BB // Incoming jump from 0x30B1, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // Inputs[1] { @30C1 stack[-4] } 30BC 5B JUMPDEST 30BD 5B JUMPDEST 30BE 50 POP 30BF 50 POP 30C0 50 POP 30C1 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_30C2: // Incoming call from 0x2D5B, returns to 0x2D5C // Inputs[1] { @30DB stack[-2] } 30C2 5B JUMPDEST 30C3 60 PUSH1 0x00 30C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30DA 16 AND 30DB 82 DUP3 30DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30F1 16 AND 30F2 14 EQ 30F3 15 ISZERO 30F4 61 PUSH2 0x3132 30F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3132, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_30F8: // Incoming jump from 0x30F7, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @30FA memory[0x40:0x60] } 30F8 60 PUSH1 0x40 30FA 51 MLOAD 30FB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 311C 81 DUP2 311D 52 MSTORE 311E 60 PUSH1 0x04 3120 01 ADD 3121 61 PUSH2 0x3129 3124 90 SWAP1 3125 61 PUSH2 0x482f 3128 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @311D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3124 stack[0] = 0x3129 // @3124 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x482f, returns to 0x3129 label_3129: // Incoming return from call to 0x482F at 0x3128 // Inputs[3] // { // @312C memory[0x40:0x60] // @312E stack[-1] // @3131 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 3129 5B JUMPDEST 312A 60 PUSH1 0x40 312C 51 MLOAD 312D 80 DUP1 312E 91 SWAP2 312F 03 SUB 3130 90 SWAP1 3131 FD *REVERT // Stack delta = -1 // Outputs[1] { @3131 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_3132: // Incoming jump from 0x30F7, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @3136 stack[-1] } 3132 5B JUMPDEST 3133 61 PUSH2 0x313b 3136 81 DUP2 3137 61 PUSH2 0x247a 313A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3133 stack[0] = 0x313b // @3136 stack[1] = stack[-1] // } // Block ends with call to 0x247a, returns to 0x313B label_313B: // Incoming return from call to 0x247A at 0x313A // Inputs[1] { @313C stack[-1] } 313B 5B JUMPDEST 313C 15 ISZERO 313D 61 PUSH2 0x317b 3140 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x317b, if !stack[-1] label_3141: // Incoming jump from 0x3140, if not !stack[-1] // Inputs[1] { @3143 memory[0x40:0x60] } 3141 60 PUSH1 0x40 3143 51 MLOAD 3144 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3165 81 DUP2 3166 52 MSTORE 3167 60 PUSH1 0x04 3169 01 ADD 316A 61 PUSH2 0x3172 316D 90 SWAP1 316E 61 PUSH2 0x468f 3171 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3166 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @316D stack[0] = 0x3172 // @316D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x468f, returns to 0x3172 label_3172: // Incoming return from call to 0x468F at 0x3171 // Inputs[3] // { // @3175 memory[0x40:0x60] // @3177 stack[-1] // @317A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 3172 5B JUMPDEST 3173 60 PUSH1 0x40 3175 51 MLOAD 3176 80 DUP1 3177 91 SWAP2 3178 03 SUB 3179 90 SWAP1 317A FD *REVERT // Stack delta = -1 // Outputs[1] { @317A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_317B: // Incoming jump from 0x3140, if !stack[-1] // Inputs[2] // { // @3181 stack[-2] // @3182 stack[-1] // } 317B 5B JUMPDEST 317C 61 PUSH2 0x3187 317F 60 PUSH1 0x00 3181 83 DUP4 3182 83 DUP4 3183 61 PUSH2 0x2d42 3186 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @317C stack[0] = 0x3187 // @317F stack[1] = 0x00 // @3181 stack[2] = stack[-2] // @3182 stack[3] = stack[-1] // } // Block ends with call to 0x2d42, returns to 0x3187 label_3187: // Incoming return from call to 0x2D42 at 0x3186 // Inputs[3] // { // @318E stack[-2] // @31C8 memory[0x00:0x40] // @31CD storage[keccak256(memory[0x00:0x40])] // } 3187 5B JUMPDEST 3188 60 PUSH1 0x01 318A 60 PUSH1 0x03 318C 60 PUSH1 0x00 318E 84 DUP5 318F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31A4 16 AND 31A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31BA 16 AND 31BB 81 DUP2 31BC 52 MSTORE 31BD 60 PUSH1 0x20 31BF 01 ADD 31C0 90 SWAP1 31C1 81 DUP2 31C2 52 MSTORE 31C3 60 PUSH1 0x20 31C5 01 ADD 31C6 60 PUSH1 0x00 31C8 20 SHA3 31C9 60 PUSH1 0x00 31CB 82 DUP3 31CC 82 DUP3 31CD 54 SLOAD 31CE 61 PUSH2 0x31d7 31D1 91 SWAP2 31D2 90 SWAP1 31D3 61 PUSH2 0x4ab3 31D6 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @3188 stack[0] = 0x01 // @31BC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @31C2 memory[0x20:0x40] = 0x03 // @31C8 stack[1] = keccak256(memory[0x00:0x40]) // @31C9 stack[2] = 0x00 // @31D1 stack[3] = 0x31d7 // @31D2 stack[4] = 0x01 // @31D2 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x4ab3, returns to 0x31D7 label_31D7: // Incoming return from call to 0x4AB3 at 0x31D6 // Inputs[11] // { // @31D8 stack[-4] // @31D8 stack[-1] // @31DC stack[-3] // @31DF stack[-6] // @31E4 stack[-5] // @31F2 memory[0x00:0x40] // @31FA storage[keccak256(memory[0x00:0x40])] // @3284 memory[0x40:0x60] // @3287 memory[0x40:0x60] // @328C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @328F stack[-7] // } 31D7 5B JUMPDEST 31D8 92 SWAP3 31D9 50 POP 31DA 50 POP 31DB 81 DUP2 31DC 90 SWAP1 31DD 55 SSTORE 31DE 50 POP 31DF 81 DUP2 31E0 60 PUSH1 0x02 31E2 60 PUSH1 0x00 31E4 83 DUP4 31E5 81 DUP2 31E6 52 MSTORE 31E7 60 PUSH1 0x20 31E9 01 ADD 31EA 90 SWAP1 31EB 81 DUP2 31EC 52 MSTORE 31ED 60 PUSH1 0x20 31EF 01 ADD 31F0 60 PUSH1 0x00 31F2 20 SHA3 31F3 60 PUSH1 0x00 31F5 61 PUSH2 0x0100 31F8 0A EXP 31F9 81 DUP2 31FA 54 SLOAD 31FB 81 DUP2 31FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3211 02 MUL 3212 19 NOT 3213 16 AND 3214 90 SWAP1 3215 83 DUP4 3216 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 322B 16 AND 322C 02 MUL 322D 17 OR 322E 90 SWAP1 322F 55 SSTORE 3230 50 POP 3231 80 DUP1 3232 82 DUP3 3233 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3248 16 AND 3249 60 PUSH1 0x00 324B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3260 16 AND 3261 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3282 60 PUSH1 0x40 3284 51 MLOAD 3285 60 PUSH1 0x40 3287 51 MLOAD 3288 80 DUP1 3289 91 SWAP2 328A 03 SUB 328B 90 SWAP1 328C A4 LOG4 328D 50 POP 328E 50 POP 328F 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @31DD storage[stack[-3]] = stack[-1] // @31E6 memory[0x00:0x20] = stack[-5] // @31EC memory[0x20:0x40] = 0x02 // @322F storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @328C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_3290: // Incoming call from 0x2DCD, returns to 0x2DCE // Inputs[3] // { // @3294 stack[-1] // @3295 address(stack[-1]).code.length // @329F stack[-2] // } 3290 5B JUMPDEST 3291 60 PUSH1 0x00 3293 80 DUP1 3294 82 DUP3 3295 3B EXTCODESIZE 3296 90 SWAP1 3297 50 POP 3298 60 PUSH1 0x00 329A 81 DUP2 329B 11 GT 329C 91 SWAP2 329D 50 POP 329E 50 POP 329F 91 SWAP2 32A0 90 SWAP1 32A1 50 POP 32A2 56 *JUMP // Stack delta = -1 // Outputs[1] { @329F stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_32A3: // Incoming call from 0x2FB8, returns to 0x2FB9 // Inputs[1] { @32A7 stack[-4] } 32A3 5B JUMPDEST 32A4 50 POP 32A5 50 POP 32A6 50 POP 32A7 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_32A8: // Incoming call from 0x2FF6, returns to 0x2FF7 // Inputs[6] // { // @32AC storage[0x08] // @32B3 stack[-1] // @32C1 memory[0x00:0x40] // @32CE storage[0x08] // @32E3 memory[0x00:0x20] // @32F0 stack[-2] // } 32A8 5B JUMPDEST 32A9 60 PUSH1 0x08 32AB 80 DUP1 32AC 54 SLOAD 32AD 90 SWAP1 32AE 50 POP 32AF 60 PUSH1 0x09 32B1 60 PUSH1 0x00 32B3 83 DUP4 32B4 81 DUP2 32B5 52 MSTORE 32B6 60 PUSH1 0x20 32B8 01 ADD 32B9 90 SWAP1 32BA 81 DUP2 32BB 52 MSTORE 32BC 60 PUSH1 0x20 32BE 01 ADD 32BF 60 PUSH1 0x00 32C1 20 SHA3 32C2 81 DUP2 32C3 90 SWAP1 32C4 55 SSTORE 32C5 50 POP 32C6 60 PUSH1 0x08 32C8 81 DUP2 32C9 90 SWAP1 32CA 80 DUP1 32CB 60 PUSH1 0x01 32CD 81 DUP2 32CE 54 SLOAD 32CF 01 ADD 32D0 80 DUP1 32D1 82 DUP3 32D2 55 SSTORE 32D3 80 DUP1 32D4 91 SWAP2 32D5 50 POP 32D6 50 POP 32D7 60 PUSH1 0x01 32D9 90 SWAP1 32DA 03 SUB 32DB 90 SWAP1 32DC 60 PUSH1 0x00 32DE 52 MSTORE 32DF 60 PUSH1 0x20 32E1 60 PUSH1 0x00 32E3 20 SHA3 32E4 01 ADD 32E5 60 PUSH1 0x00 32E7 90 SWAP1 32E8 91 SWAP2 32E9 90 SWAP1 32EA 91 SWAP2 32EB 90 SWAP1 32EC 91 SWAP2 32ED 50 POP 32EE 55 SSTORE 32EF 50 POP 32F0 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @32B5 memory[0x00:0x20] = stack[-1] // @32BB memory[0x20:0x40] = 0x09 // @32C4 storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @32D2 storage[0x08] = storage[0x08] + 0x01 // @32DE memory[0x00:0x20] = 0x08 // @32EE storage[keccak256(memory[0x00:0x20]) + ((storage[0x08] + 0x01) - 0x01)] = stack[-1] // } // Block ends with unconditional jump to stack[-2] label_32F1: // Incoming call from 0x3038, returns to 0x3039 // Inputs[1] { @32F9 stack[-2] } 32F1 5B JUMPDEST 32F2 60 PUSH1 0x00 32F4 60 PUSH1 0x01 32F6 61 PUSH2 0x32fe 32F9 84 DUP5 32FA 61 PUSH2 0x165c 32FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @32F2 stack[0] = 0x00 // @32F4 stack[1] = 0x01 // @32F6 stack[2] = 0x32fe // @32F9 stack[3] = stack[-2] // } // Block ends with call to 0x165c, returns to 0x32FE label_32FE: // Incoming return from call to 0x165C at 0x32FD // Inputs[2] // { // @3302 stack[-2] // @3303 stack[-1] // } 32FE 5B JUMPDEST 32FF 61 PUSH2 0x3308 3302 91 SWAP2 3303 90 SWAP1 3304 61 PUSH2 0x4b94 3307 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3302 stack[-2] = 0x3308 // @3303 stack[-1] = stack[-2] // @3303 stack[0] = stack[-1] // } // Block ends with call to 0x4b94, returns to 0x3308 label_3308: // Incoming return from call to 0x4B94 at 0x3307 // Inputs[5] // { // @3309 stack[-2] // @3309 stack[-1] // @3311 stack[-3] // @331F memory[0x00:0x40] // @3320 storage[keccak256(memory[0x00:0x40])] // } 3308 5B JUMPDEST 3309 90 SWAP1 330A 50 POP 330B 60 PUSH1 0x00 330D 60 PUSH1 0x07 330F 60 PUSH1 0x00 3311 84 DUP5 3312 81 DUP2 3313 52 MSTORE 3314 60 PUSH1 0x20 3316 01 ADD 3317 90 SWAP1 3318 81 DUP2 3319 52 MSTORE 331A 60 PUSH1 0x20 331C 01 ADD 331D 60 PUSH1 0x00 331F 20 SHA3 3320 54 SLOAD 3321 90 SWAP1 3322 50 POP 3323 81 DUP2 3324 81 DUP2 3325 14 EQ 3326 61 PUSH2 0x33ed 3329 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3309 stack[-2] = stack[-1] // @3313 memory[0x00:0x20] = stack[-3] // @3319 memory[0x20:0x40] = 0x07 // @3321 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x33ed, if storage[keccak256(memory[0x00:0x40])] == stack[-1] label_332A: // Incoming jump from 0x3329, if not storage[keccak256(memory[0x00:0x40])] == stack[-1] // Inputs[14] // { // @3330 stack[-4] // @336A memory[0x00:0x40] // @336D stack[-2] // @337B memory[0x00:0x40] // @337C storage[keccak256(memory[0x00:0x40])] // @33BE memory[0x00:0x40] // @33C1 stack[-1] // @33CF memory[0x00:0x40] // @33E7 memory[0x00:0x40] // @33F2 stack[-3] // @3400 memory[0x00:0x40] // @3443 memory[0x00:0x40] // @3454 memory[0x00:0x40] // @345D stack[-5] // } 332A 60 PUSH1 0x00 332C 60 PUSH1 0x06 332E 60 PUSH1 0x00 3330 86 DUP7 3331 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3346 16 AND 3347 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 335C 16 AND 335D 81 DUP2 335E 52 MSTORE 335F 60 PUSH1 0x20 3361 01 ADD 3362 90 SWAP1 3363 81 DUP2 3364 52 MSTORE 3365 60 PUSH1 0x20 3367 01 ADD 3368 60 PUSH1 0x00 336A 20 SHA3 336B 60 PUSH1 0x00 336D 84 DUP5 336E 81 DUP2 336F 52 MSTORE 3370 60 PUSH1 0x20 3372 01 ADD 3373 90 SWAP1 3374 81 DUP2 3375 52 MSTORE 3376 60 PUSH1 0x20 3378 01 ADD 3379 60 PUSH1 0x00 337B 20 SHA3 337C 54 SLOAD 337D 90 SWAP1 337E 50 POP 337F 80 DUP1 3380 60 PUSH1 0x06 3382 60 PUSH1 0x00 3384 87 DUP8 3385 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 339A 16 AND 339B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33B0 16 AND 33B1 81 DUP2 33B2 52 MSTORE 33B3 60 PUSH1 0x20 33B5 01 ADD 33B6 90 SWAP1 33B7 81 DUP2 33B8 52 MSTORE 33B9 60 PUSH1 0x20 33BB 01 ADD 33BC 60 PUSH1 0x00 33BE 20 SHA3 33BF 60 PUSH1 0x00 33C1 84 DUP5 33C2 81 DUP2 33C3 52 MSTORE 33C4 60 PUSH1 0x20 33C6 01 ADD 33C7 90 SWAP1 33C8 81 DUP2 33C9 52 MSTORE 33CA 60 PUSH1 0x20 33CC 01 ADD 33CD 60 PUSH1 0x00 33CF 20 SHA3 33D0 81 DUP2 33D1 90 SWAP1 33D2 55 SSTORE 33D3 50 POP 33D4 81 DUP2 33D5 60 PUSH1 0x07 33D7 60 PUSH1 0x00 33D9 83 DUP4 33DA 81 DUP2 33DB 52 MSTORE 33DC 60 PUSH1 0x20 33DE 01 ADD 33DF 90 SWAP1 33E0 81 DUP2 33E1 52 MSTORE 33E2 60 PUSH1 0x20 33E4 01 ADD 33E5 60 PUSH1 0x00 33E7 20 SHA3 33E8 81 DUP2 33E9 90 SWAP1 33EA 55 SSTORE 33EB 50 POP 33EC 50 POP 33ED 5B JUMPDEST 33EE 60 PUSH1 0x07 33F0 60 PUSH1 0x00 33F2 84 DUP5 33F3 81 DUP2 33F4 52 MSTORE 33F5 60 PUSH1 0x20 33F7 01 ADD 33F8 90 SWAP1 33F9 81 DUP2 33FA 52 MSTORE 33FB 60 PUSH1 0x20 33FD 01 ADD 33FE 60 PUSH1 0x00 3400 20 SHA3 3401 60 PUSH1 0x00 3403 90 SWAP1 3404 55 SSTORE 3405 60 PUSH1 0x06 3407 60 PUSH1 0x00 3409 85 DUP6 340A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 341F 16 AND 3420 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3435 16 AND 3436 81 DUP2 3437 52 MSTORE 3438 60 PUSH1 0x20 343A 01 ADD 343B 90 SWAP1 343C 81 DUP2 343D 52 MSTORE 343E 60 PUSH1 0x20 3440 01 ADD 3441 60 PUSH1 0x00 3443 20 SHA3 3444 60 PUSH1 0x00 3446 83 DUP4 3447 81 DUP2 3448 52 MSTORE 3449 60 PUSH1 0x20 344B 01 ADD 344C 90 SWAP1 344D 81 DUP2 344E 52 MSTORE 344F 60 PUSH1 0x20 3451 01 ADD 3452 60 PUSH1 0x00 3454 20 SHA3 3455 60 PUSH1 0x00 3457 90 SWAP1 3458 55 SSTORE 3459 50 POP 345A 50 POP 345B 50 POP 345C 50 POP 345D 56 *JUMP // Stack delta = -5 // Outputs[20] // { // @335E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @3364 memory[0x20:0x40] = 0x06 // @336F memory[0x00:0x20] = stack[-2] // @3375 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @33B2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @33B8 memory[0x20:0x40] = 0x06 // @33C3 memory[0x00:0x20] = stack[-1] // @33C9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @33D2 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @33DB memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @33E1 memory[0x20:0x40] = 0x07 // @33EA storage[keccak256(memory[0x00:0x40])] = stack[-1] // @33F4 memory[0x00:0x20] = stack[-3] // @33FA memory[0x20:0x40] = 0x07 // @3404 storage[keccak256(memory[0x00:0x40])] = 0x00 // @3437 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @343D memory[0x20:0x40] = 0x06 // @3448 memory[0x00:0x20] = stack[-2] // @344E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3458 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_345E: // Incoming call from 0x3078, returns to 0x3079 // Inputs[1] { @3466 storage[0x08] } 345E 5B JUMPDEST 345F 60 PUSH1 0x00 3461 60 PUSH1 0x01 3463 60 PUSH1 0x08 3465 80 DUP1 3466 54 SLOAD 3467 90 SWAP1 3468 50 POP 3469 61 PUSH2 0x3472 346C 91 SWAP2 346D 90 SWAP1 346E 61 PUSH2 0x4b94 3471 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @345F stack[0] = 0x00 // @346C stack[1] = 0x3472 // @346D stack[2] = 0x01 // @346D stack[3] = storage[0x08] // } // Block ends with call to 0x4b94, returns to 0x3472 label_3472: // Incoming return from call to 0x4B94 at 0x3471 // Inputs[6] // { // @3473 stack[-1] // @3473 stack[-2] // @347B stack[-3] // @3489 memory[0x00:0x40] // @348A storage[keccak256(memory[0x00:0x40])] // @3493 storage[0x08] // } 3472 5B JUMPDEST 3473 90 SWAP1 3474 50 POP 3475 60 PUSH1 0x00 3477 60 PUSH1 0x09 3479 60 PUSH1 0x00 347B 84 DUP5 347C 81 DUP2 347D 52 MSTORE 347E 60 PUSH1 0x20 3480 01 ADD 3481 90 SWAP1 3482 81 DUP2 3483 52 MSTORE 3484 60 PUSH1 0x20 3486 01 ADD 3487 60 PUSH1 0x00 3489 20 SHA3 348A 54 SLOAD 348B 90 SWAP1 348C 50 POP 348D 60 PUSH1 0x00 348F 60 PUSH1 0x08 3491 83 DUP4 3492 81 DUP2 3493 54 SLOAD 3494 81 DUP2 3495 10 LT 3496 61 PUSH2 0x34c8 3499 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @3473 stack[-2] = stack[-1] // @347D memory[0x00:0x20] = stack[-3] // @3483 memory[0x20:0x40] = 0x09 // @348B stack[-1] = storage[keccak256(memory[0x00:0x40])] // @348D stack[0] = 0x00 // @348F stack[1] = 0x08 // @3491 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x34c8, if stack[-1] < storage[0x08] label_349A: // Incoming jump from 0x3499, if not stack[-1] < storage[0x08] // Inputs[1] { @34C7 memory[0x00:0x24] } 349A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 34BB 60 PUSH1 0x00 34BD 52 MSTORE 34BE 60 PUSH1 0x32 34C0 60 PUSH1 0x04 34C2 52 MSTORE 34C3 60 PUSH1 0x24 34C5 60 PUSH1 0x00 34C7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @34BD memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @34C2 memory[0x04:0x24] = 0x32 // @34C7 revert(memory[0x00:0x24]); // } // Block terminates label_34C8: // Incoming jump from 0x3499, if stack[-1] < storage[0x08] // Inputs[7] // { // @34C9 stack[-1] // @34C9 stack[-2] // @34D1 memory[0x00:0x20] // @34D3 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @34D4 stack[-3] // @34D9 stack[-4] // @34DB storage[0x08] // } 34C8 5B JUMPDEST 34C9 90 SWAP1 34CA 60 PUSH1 0x00 34CC 52 MSTORE 34CD 60 PUSH1 0x20 34CF 60 PUSH1 0x00 34D1 20 SHA3 34D2 01 ADD 34D3 54 SLOAD 34D4 90 SWAP1 34D5 50 POP 34D6 80 DUP1 34D7 60 PUSH1 0x08 34D9 83 DUP4 34DA 81 DUP2 34DB 54 SLOAD 34DC 81 DUP2 34DD 10 LT 34DE 61 PUSH2 0x3510 34E1 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @34CC memory[0x00:0x20] = stack[-2] // @34D4 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @34D6 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @34D7 stack[-1] = 0x08 // @34D9 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x3510, if stack[-4] < storage[0x08] label_34E2: // Incoming jump from 0x34E1, if not stack[-4] < storage[0x08] // Inputs[1] { @350F memory[0x00:0x24] } 34E2 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 3503 60 PUSH1 0x00 3505 52 MSTORE 3506 60 PUSH1 0x32 3508 60 PUSH1 0x04 350A 52 MSTORE 350B 60 PUSH1 0x24 350D 60 PUSH1 0x00 350F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3505 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @350A memory[0x04:0x24] = 0x32 // @350F revert(memory[0x00:0x24]); // } // Block terminates label_3510: // Incoming jump from 0x34E1, if stack[-4] < storage[0x08] // Inputs[10] // { // @3511 stack[-2] // @3511 stack[-1] // @3519 memory[0x00:0x20] // @351B stack[-3] // @351F stack[-5] // @3524 stack[-4] // @3532 memory[0x00:0x40] // @353B stack[-7] // @3549 memory[0x00:0x40] // @3551 storage[0x08] // } 3510 5B JUMPDEST 3511 90 SWAP1 3512 60 PUSH1 0x00 3514 52 MSTORE 3515 60 PUSH1 0x20 3517 60 PUSH1 0x00 3519 20 SHA3 351A 01 ADD 351B 81 DUP2 351C 90 SWAP1 351D 55 SSTORE 351E 50 POP 351F 81 DUP2 3520 60 PUSH1 0x09 3522 60 PUSH1 0x00 3524 83 DUP4 3525 81 DUP2 3526 52 MSTORE 3527 60 PUSH1 0x20 3529 01 ADD 352A 90 SWAP1 352B 81 DUP2 352C 52 MSTORE 352D 60 PUSH1 0x20 352F 01 ADD 3530 60 PUSH1 0x00 3532 20 SHA3 3533 81 DUP2 3534 90 SWAP1 3535 55 SSTORE 3536 50 POP 3537 60 PUSH1 0x09 3539 60 PUSH1 0x00 353B 85 DUP6 353C 81 DUP2 353D 52 MSTORE 353E 60 PUSH1 0x20 3540 01 ADD 3541 90 SWAP1 3542 81 DUP2 3543 52 MSTORE 3544 60 PUSH1 0x20 3546 01 ADD 3547 60 PUSH1 0x00 3549 20 SHA3 354A 60 PUSH1 0x00 354C 90 SWAP1 354D 55 SSTORE 354E 60 PUSH1 0x08 3550 80 DUP1 3551 54 SLOAD 3552 80 DUP1 3553 61 PUSH2 0x3585 3556 57 *JUMPI // Stack delta = -1 // Outputs[10] // { // @3514 memory[0x00:0x20] = stack[-2] // @351D storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @3526 memory[0x00:0x20] = stack[-4] // @352C memory[0x20:0x40] = 0x09 // @3535 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @353D memory[0x00:0x20] = stack[-7] // @3543 memory[0x20:0x40] = 0x09 // @354D storage[keccak256(memory[0x00:0x40])] = 0x00 // @354E stack[-3] = 0x08 // @3551 stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x3585, if storage[0x08] label_3557: // Incoming jump from 0x3556, if not storage[0x08] // Inputs[1] { @3584 memory[0x00:0x24] } 3557 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 3578 60 PUSH1 0x00 357A 52 MSTORE 357B 60 PUSH1 0x31 357D 60 PUSH1 0x04 357F 52 MSTORE 3580 60 PUSH1 0x24 3582 60 PUSH1 0x00 3584 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @357A memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @357F memory[0x04:0x24] = 0x31 // @3584 revert(memory[0x00:0x24]); // } // Block terminates label_3585: // Incoming jump from 0x3556, if storage[0x08] // Inputs[4] // { // @3588 stack[-1] // @358A stack[-2] // @3594 memory[0x00:0x20] // @35A0 stack[-7] // } 3585 5B JUMPDEST 3586 60 PUSH1 0x01 3588 90 SWAP1 3589 03 SUB 358A 81 DUP2 358B 81 DUP2 358C 90 SWAP1 358D 60 PUSH1 0x00 358F 52 MSTORE 3590 60 PUSH1 0x20 3592 60 PUSH1 0x00 3594 20 SHA3 3595 01 ADD 3596 60 PUSH1 0x00 3598 90 SWAP1 3599 55 SSTORE 359A 90 SWAP1 359B 55 SSTORE 359C 50 POP 359D 50 POP 359E 50 POP 359F 50 POP 35A0 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @358F memory[0x00:0x20] = stack[-2] // @3599 storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @359B storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_35A1: // Incoming call from 0x30BA, returns to 0x30BB // Inputs[1] { @35A7 stack[-2] } 35A1 5B JUMPDEST 35A2 60 PUSH1 0x00 35A4 61 PUSH2 0x35ac 35A7 83 DUP4 35A8 61 PUSH2 0x165c 35AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @35A2 stack[0] = 0x00 // @35A4 stack[1] = 0x35ac // @35A7 stack[2] = stack[-2] // } // Block ends with call to 0x165c, returns to 0x35AC label_35AC: // Incoming return from call to 0x165C at 0x35AB // Inputs[8] // { // @35AD stack[-1] // @35AD stack[-2] // @35AF stack[-3] // @35B4 stack[-4] // @35EE memory[0x00:0x40] // @35FF memory[0x00:0x40] // @3617 memory[0x00:0x40] // @361F stack[-5] // } 35AC 5B JUMPDEST 35AD 90 SWAP1 35AE 50 POP 35AF 81 DUP2 35B0 60 PUSH1 0x06 35B2 60 PUSH1 0x00 35B4 85 DUP6 35B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35CA 16 AND 35CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35E0 16 AND 35E1 81 DUP2 35E2 52 MSTORE 35E3 60 PUSH1 0x20 35E5 01 ADD 35E6 90 SWAP1 35E7 81 DUP2 35E8 52 MSTORE 35E9 60 PUSH1 0x20 35EB 01 ADD 35EC 60 PUSH1 0x00 35EE 20 SHA3 35EF 60 PUSH1 0x00 35F1 83 DUP4 35F2 81 DUP2 35F3 52 MSTORE 35F4 60 PUSH1 0x20 35F6 01 ADD 35F7 90 SWAP1 35F8 81 DUP2 35F9 52 MSTORE 35FA 60 PUSH1 0x20 35FC 01 ADD 35FD 60 PUSH1 0x00 35FF 20 SHA3 3600 81 DUP2 3601 90 SWAP1 3602 55 SSTORE 3603 50 POP 3604 80 DUP1 3605 60 PUSH1 0x07 3607 60 PUSH1 0x00 3609 84 DUP5 360A 81 DUP2 360B 52 MSTORE 360C 60 PUSH1 0x20 360E 01 ADD 360F 90 SWAP1 3610 81 DUP2 3611 52 MSTORE 3612 60 PUSH1 0x20 3614 01 ADD 3615 60 PUSH1 0x00 3617 20 SHA3 3618 81 DUP2 3619 90 SWAP1 361A 55 SSTORE 361B 50 POP 361C 50 POP 361D 50 POP 361E 50 POP 361F 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @35E2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @35E8 memory[0x20:0x40] = 0x06 // @35F3 memory[0x00:0x20] = stack[-1] // @35F9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3602 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @360B memory[0x00:0x20] = stack[-3] // @3611 memory[0x20:0x40] = 0x07 // @361A storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_3620: // Incoming call from 0x2267, returns to 0x2268 // Incoming call from 0x1220, returns to 0x1221 // Incoming call from 0x23FB, returns to 0x23FC // Inputs[2] // { // @3621 stack[-3] // @3623 storage[stack[-3]] // } 3620 5B JUMPDEST 3621 82 DUP3 3622 80 DUP1 3623 54 SLOAD 3624 61 PUSH2 0x362c 3627 90 SWAP1 3628 61 PUSH2 0x4c7e 362B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3621 stack[0] = stack[-3] // @3627 stack[1] = 0x362c // @3627 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x4c7e, returns to 0x362C label_362C: // Incoming return from call to 0x4C7E at 0x362B // Inputs[5] // { // @362D stack[-1] // @362D stack[-2] // @3635 memory[0x00:0x20] // @3640 stack[-4] // @3641 stack[-3] // } 362C 5B JUMPDEST 362D 90 SWAP1 362E 60 PUSH1 0x00 3630 52 MSTORE 3631 60 PUSH1 0x20 3633 60 PUSH1 0x00 3635 20 SHA3 3636 90 SWAP1 3637 60 PUSH1 0x1f 3639 01 ADD 363A 60 PUSH1 0x20 363C 90 SWAP1 363D 04 DIV 363E 81 DUP2 363F 01 ADD 3640 92 SWAP3 3641 82 DUP3 3642 61 PUSH2 0x364e 3645 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3630 memory[0x00:0x20] = stack[-2] // @3636 stack[-2] = keccak256(memory[0x00:0x20]) // @3640 stack[-1] = stack[-4] // @3640 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x364e, if stack[-3] label_3646: // Incoming jump from 0x3645, if not stack[-3] // Inputs[1] { @3648 stack[-5] } 3646 60 PUSH1 0x00 3648 85 DUP6 3649 55 SSTORE 364A 61 PUSH2 0x3695 364D 56 *JUMP // Stack delta = +0 // Outputs[1] { @3649 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x3695 label_364E: // Incoming jump from 0x3645, if stack[-3] // Inputs[1] { @364F stack[-3] } 364E 5B JUMPDEST 364F 82 DUP3 3650 60 PUSH1 0x1f 3652 10 LT 3653 61 PUSH2 0x3667 3656 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3667, if 0x1f < stack[-3] label_3657: // Incoming jump from 0x3656, if not 0x1f < stack[-3] // Inputs[4] // { // @3657 stack[-1] // @3658 memory[stack[-1]:stack[-1] + 0x20] // @365D stack[-3] // @3661 stack[-5] // } 3657 80 DUP1 3658 51 MLOAD 3659 60 PUSH1 0xff 365B 19 NOT 365C 16 AND 365D 83 DUP4 365E 80 DUP1 365F 01 ADD 3660 17 OR 3661 85 DUP6 3662 55 SSTORE 3663 61 PUSH2 0x3695 3666 56 *JUMP // Stack delta = +0 // Outputs[1] { @3662 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x3695 label_3667: // Incoming jump from 0x3656, if 0x1f < stack[-3] // Inputs[2] // { // @3668 stack[-3] // @366E stack[-5] // } 3667 5B JUMPDEST 3668 82 DUP3 3669 80 DUP1 366A 01 ADD 366B 60 PUSH1 0x01 366D 01 ADD 366E 85 DUP6 366F 55 SSTORE 3670 82 DUP3 3671 15 ISZERO 3672 61 PUSH2 0x3695 3675 57 *JUMPI // Stack delta = +0 // Outputs[1] { @366F storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x3695, if !stack[-3] label_3676: // Incoming jump from 0x3675, if not !stack[-3] // Inputs[2] // { // @3676 stack[-1] // @3676 stack[-3] // } 3676 91 SWAP2 3677 82 DUP3 3678 01 ADD 3679 5B JUMPDEST 367A 82 DUP3 367B 81 DUP2 367C 11 GT 367D 15 ISZERO 367E 61 PUSH2 0x3694 3681 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3676 stack[-3] = stack[-1] // @3678 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x3694, if !(stack[-1] + stack[-3] > stack[-1]) label_3682: // Incoming jump from 0x3681, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x3681, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @3682 stack[-3] // @3683 memory[stack[-3]:stack[-3] + 0x20] // @3684 stack[-2] // @3686 stack[-1] // } 3682 82 DUP3 3683 51 MLOAD 3684 82 DUP3 3685 55 SSTORE 3686 91 SWAP2 3687 60 PUSH1 0x20 3689 01 ADD 368A 91 SWAP2 368B 90 SWAP1 368C 60 PUSH1 0x01 368E 01 ADD 368F 90 SWAP1 3690 61 PUSH2 0x3679 3693 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3685 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @368A stack[-3] = 0x20 + stack[-3] // @368F stack[-2] = 0x01 + stack[-2] // @368F stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x3679 label_3694: // Incoming jump from 0x3681, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x3681, if !(stack[-1] > stack[-3]) 3694 5B JUMPDEST // Stack delta = +0 // Block continues label_3695: // Incoming jump from 0x364D // Incoming jump from 0x3694 // Incoming jump from 0x3666 // Incoming jump from 0x3675, if !stack[-3] // Inputs[3] // { // @3697 stack[-3] // @3697 stack[-2] // @369C stack[-4] // } 3695 5B JUMPDEST 3696 50 POP 3697 90 SWAP1 3698 50 POP 3699 61 PUSH2 0x36a2 369C 91 SWAP2 369D 90 SWAP1 369E 61 PUSH2 0x36a6 36A1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @369C stack[-4] = 0x36a2 // @369D stack[-2] = stack[-2] // @369D stack[-3] = stack[-4] // } // Block ends with call to 0x36a6, returns to 0x36A2 label_36A2: // Incoming return from call to 0x36A6 at 0x36A1 // Inputs[2] // { // @36A4 stack[-3] // @36A4 stack[-2] // } 36A2 5B JUMPDEST 36A3 50 POP 36A4 90 SWAP1 36A5 56 *JUMP // Stack delta = -2 // Outputs[1] { @36A4 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_36A6: // Incoming call from 0x36A1, returns to 0x36A2 // Inputs[2] // { // @36A8 stack[-1] // @36A9 stack[-2] // } 36A6 5B JUMPDEST 36A7 5B JUMPDEST 36A8 80 DUP1 36A9 82 DUP3 36AA 11 GT 36AB 15 ISZERO 36AC 61 PUSH2 0x36bf 36AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x36bf, if !(stack[-2] > stack[-1]) label_36B0: // Incoming jump from 0x36AF, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x36AF, if not !(stack[-2] > stack[-1]) // Inputs[1] { @36B2 stack[-1] } 36B0 60 PUSH1 0x00 36B2 81 DUP2 36B3 60 PUSH1 0x00 36B5 90 SWAP1 36B6 55 SSTORE 36B7 50 POP 36B8 60 PUSH1 0x01 36BA 01 ADD 36BB 61 PUSH2 0x36a7 36BE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @36B6 storage[stack[-1]] = 0x00 // @36BA stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x36a7 label_36BF: // Incoming jump from 0x36AF, if !(stack[-2] > stack[-1]) // Incoming jump from 0x36AF, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @36C1 stack[-3] // @36C1 stack[-2] // } 36BF 5B JUMPDEST 36C0 50 POP 36C1 90 SWAP1 36C2 56 *JUMP // Stack delta = -2 // Outputs[1] { @36C1 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_36C3: // Incoming call from 0x37B3, returns to 0x37B4 // Inputs[1] { @36CC stack[-2] } 36C3 5B JUMPDEST 36C4 60 PUSH1 0x00 36C6 61 PUSH2 0x36d6 36C9 61 PUSH2 0x36d1 36CC 84 DUP5 36CD 61 PUSH2 0x49fb 36D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @36C4 stack[0] = 0x00 // @36C6 stack[1] = 0x36d6 // @36C9 stack[2] = 0x36d1 // @36CC stack[3] = stack[-2] // } // Block ends with call to 0x49fb, returns to 0x36D1 label_36D1: // Incoming return from call to 0x49FB at 0x36D0 36D1 5B JUMPDEST 36D2 61 PUSH2 0x49ca 36D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x49ca label_36D6: // Incoming return from call to 0x36D1 at 0x36D0 // Inputs[5] // { // @36D7 stack[-1] // @36D7 stack[-2] // @36D9 stack[-4] // @36E0 stack[-5] // @36E2 stack[-3] // } 36D6 5B JUMPDEST 36D7 90 SWAP1 36D8 50 POP 36D9 82 DUP3 36DA 81 DUP2 36DB 52 MSTORE 36DC 60 PUSH1 0x20 36DE 81 DUP2 36DF 01 ADD 36E0 84 DUP5 36E1 84 DUP5 36E2 84 DUP5 36E3 01 ADD 36E4 11 GT 36E5 15 ISZERO 36E6 61 PUSH2 0x36ee 36E9 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @36D7 stack[-2] = stack[-1] // @36DB memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @36DF stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x36ee, if !(stack[-3] + stack[-4] > stack[-5]) label_36EA: // Incoming jump from 0x36E9, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @36ED memory[0x00:0x00] } 36EA 60 PUSH1 0x00 36EC 80 DUP1 36ED FD *REVERT // Stack delta = +0 // Outputs[1] { @36ED revert(memory[0x00:0x00]); } // Block terminates label_36EE: // Incoming jump from 0x36E9, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @36F2 stack[-4] // @36F3 stack[-1] // @36F4 stack[-3] // } 36EE 5B JUMPDEST 36EF 61 PUSH2 0x36f9 36F2 84 DUP5 36F3 82 DUP3 36F4 85 DUP6 36F5 61 PUSH2 0x4c3c 36F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @36EF stack[0] = 0x36f9 // @36F2 stack[1] = stack[-4] // @36F3 stack[2] = stack[-1] // @36F4 stack[3] = stack[-3] // } // Block ends with call to 0x4c3c, returns to 0x36F9 label_36F9: // Incoming return from call to 0x4C3C at 0x36F8 // Inputs[3] // { // @36FB stack[-2] // @36FB stack[-6] // @36FC stack[-5] // } 36F9 5B JUMPDEST 36FA 50 POP 36FB 93 SWAP4 36FC 92 SWAP3 36FD 50 POP 36FE 50 POP 36FF 50 POP 3700 56 *JUMP // Stack delta = -5 // Outputs[1] { @36FB stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_3701: // Incoming call from 0x37DD, returns to 0x37DE // Inputs[1] { @370A stack[-2] } 3701 5B JUMPDEST 3702 60 PUSH1 0x00 3704 61 PUSH2 0x3714 3707 61 PUSH2 0x370f 370A 84 DUP5 370B 61 PUSH2 0x4a2b 370E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3702 stack[0] = 0x00 // @3704 stack[1] = 0x3714 // @3707 stack[2] = 0x370f // @370A stack[3] = stack[-2] // } // Block ends with call to 0x4a2b, returns to 0x370F label_370F: // Incoming return from call to 0x4A2B at 0x370E 370F 5B JUMPDEST 3710 61 PUSH2 0x49ca 3713 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x49ca label_3714: // Incoming return from call to 0x370F at 0x370E // Inputs[5] // { // @3715 stack[-2] // @3715 stack[-1] // @3717 stack[-4] // @371E stack[-5] // @3720 stack[-3] // } 3714 5B JUMPDEST 3715 90 SWAP1 3716 50 POP 3717 82 DUP3 3718 81 DUP2 3719 52 MSTORE 371A 60 PUSH1 0x20 371C 81 DUP2 371D 01 ADD 371E 84 DUP5 371F 84 DUP5 3720 84 DUP5 3721 01 ADD 3722 11 GT 3723 15 ISZERO 3724 61 PUSH2 0x372c 3727 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @3715 stack[-2] = stack[-1] // @3719 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @371D stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x372c, if !(stack[-3] + stack[-4] > stack[-5]) label_3728: // Incoming jump from 0x3727, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @372B memory[0x00:0x00] } 3728 60 PUSH1 0x00 372A 80 DUP1 372B FD *REVERT // Stack delta = +0 // Outputs[1] { @372B revert(memory[0x00:0x00]); } // Block terminates label_372C: // Incoming jump from 0x3727, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @3730 stack[-4] // @3731 stack[-1] // @3732 stack[-3] // } 372C 5B JUMPDEST 372D 61 PUSH2 0x3737 3730 84 DUP5 3731 82 DUP3 3732 85 DUP6 3733 61 PUSH2 0x4c3c 3736 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @372D stack[0] = 0x3737 // @3730 stack[1] = stack[-4] // @3731 stack[2] = stack[-1] // @3732 stack[3] = stack[-3] // } // Block ends with call to 0x4c3c, returns to 0x3737 label_3737: // Incoming return from call to 0x4C3C at 0x3736 // Inputs[3] // { // @3739 stack[-6] // @3739 stack[-2] // @373A stack[-5] // } 3737 5B JUMPDEST 3738 50 POP 3739 93 SWAP4 373A 92 SWAP3 373B 50 POP 373C 50 POP 373D 50 POP 373E 56 *JUMP // Stack delta = -5 // Outputs[1] { @3739 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_373F: // Incoming call from 0x3845, returns to 0x3846 // Incoming call from 0x38D3, returns to 0x38D4 // Incoming call from 0x381B, returns to 0x381C // Incoming call from 0x3883, returns to 0x3884 // Incoming call from 0x38E4, returns to 0x38E5 // Incoming call from 0x3987, returns to 0x3988 // Incoming call from 0x3894, returns to 0x3895 // Incoming call from 0x394B, returns to 0x394C // Incoming call from 0x3856, returns to 0x3857 // Inputs[2] // { // @3742 stack[-1] // @3743 msg.data[stack[-1]:stack[-1] + 0x20] // } 373F 5B JUMPDEST 3740 60 PUSH1 0x00 3742 81 DUP2 3743 35 CALLDATALOAD 3744 90 SWAP1 3745 50 POP 3746 61 PUSH2 0x374e 3749 81 DUP2 374A 61 PUSH2 0x4df7 374D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3744 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @3746 stack[1] = 0x374e // @3749 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4df7, returns to 0x374E label_374E: // Incoming return from call to 0x4DF7 at 0x374D // Inputs[3] // { // @374F stack[-4] // @374F stack[-1] // @3750 stack[-3] // } 374E 5B JUMPDEST 374F 92 SWAP3 3750 91 SWAP2 3751 50 POP 3752 50 POP 3753 56 *JUMP // Stack delta = -3 // Outputs[1] { @374F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3754: // Incoming call from 0x395C, returns to 0x395D // Inputs[2] // { // @3757 stack[-1] // @3758 msg.data[stack[-1]:stack[-1] + 0x20] // } 3754 5B JUMPDEST 3755 60 PUSH1 0x00 3757 81 DUP2 3758 35 CALLDATALOAD 3759 90 SWAP1 375A 50 POP 375B 61 PUSH2 0x3763 375E 81 DUP2 375F 61 PUSH2 0x4e0e 3762 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3759 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @375B stack[1] = 0x3763 // @375E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4e0e, returns to 0x3763 label_3763: // Incoming return from call to 0x4E0E at 0x3762 // Inputs[3] // { // @3764 stack[-1] // @3764 stack[-4] // @3765 stack[-3] // } 3763 5B JUMPDEST 3764 92 SWAP3 3765 91 SWAP2 3766 50 POP 3767 50 POP 3768 56 *JUMP // Stack delta = -3 // Outputs[1] { @3764 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3769: // Incoming call from 0x39C2, returns to 0x39C3 // Inputs[2] // { // @376C stack[-1] // @376D msg.data[stack[-1]:stack[-1] + 0x20] // } 3769 5B JUMPDEST 376A 60 PUSH1 0x00 376C 81 DUP2 376D 35 CALLDATALOAD 376E 90 SWAP1 376F 50 POP 3770 61 PUSH2 0x3778 3773 81 DUP2 3774 61 PUSH2 0x4e25 3777 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @376E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @3770 stack[1] = 0x3778 // @3773 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4e25, returns to 0x3778 label_3778: // Incoming return from call to 0x4E25 at 0x3777 // Inputs[3] // { // @3779 stack[-1] // @3779 stack[-4] // @377A stack[-3] // } 3778 5B JUMPDEST 3779 92 SWAP3 377A 91 SWAP2 377B 50 POP 377C 50 POP 377D 56 *JUMP // Stack delta = -3 // Outputs[1] { @3779 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_377E: // Incoming call from 0x39EB, returns to 0x39EC // Inputs[2] // { // @3781 stack[-1] // @3782 memory[stack[-1]:stack[-1] + 0x20] // } 377E 5B JUMPDEST 377F 60 PUSH1 0x00 3781 81 DUP2 3782 51 MLOAD 3783 90 SWAP1 3784 50 POP 3785 61 PUSH2 0x378d 3788 81 DUP2 3789 61 PUSH2 0x4e25 378C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3783 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @3785 stack[1] = 0x378d // @3788 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4e25, returns to 0x378D label_378D: // Incoming return from call to 0x4E25 at 0x378C // Inputs[3] // { // @378E stack[-1] // @378E stack[-4] // @378F stack[-3] // } 378D 5B JUMPDEST 378E 92 SWAP3 378F 91 SWAP2 3790 50 POP 3791 50 POP 3792 56 *JUMP // Stack delta = -3 // Outputs[1] { @378E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3793: // Incoming call from 0x391E, returns to 0x391F // Inputs[2] // { // @3796 stack[-2] // @3799 stack[-1] // } 3793 5B JUMPDEST 3794 60 PUSH1 0x00 3796 82 DUP3 3797 60 PUSH1 0x1f 3799 83 DUP4 379A 01 ADD 379B 12 SLT 379C 61 PUSH2 0x37a4 379F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3794 stack[0] = 0x00 } // Block ends with conditional jump to 0x37a4, if stack[-1] + 0x1f i< stack[-2] label_37A0: // Incoming jump from 0x379F, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @37A3 memory[0x00:0x00] } 37A0 60 PUSH1 0x00 37A2 80 DUP1 37A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @37A3 revert(memory[0x00:0x00]); } // Block terminates label_37A4: // Incoming jump from 0x379F, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @37A5 stack[-2] // @37A6 msg.data[stack[-2]:stack[-2] + 0x20] // @37AA stack[-3] // } 37A4 5B JUMPDEST 37A5 81 DUP2 37A6 35 CALLDATALOAD 37A7 61 PUSH2 0x37b4 37AA 84 DUP5 37AB 82 DUP3 37AC 60 PUSH1 0x20 37AE 86 DUP7 37AF 01 ADD 37B0 61 PUSH2 0x36c3 37B3 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @37A6 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @37A7 stack[1] = 0x37b4 // @37AA stack[2] = stack[-3] // @37AB stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @37AF stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x36c3, returns to 0x37B4 label_37B4: // Incoming return from call to 0x36C3 at 0x37B3 // Inputs[4] // { // @37B5 stack[-1] // @37B5 stack[-3] // @37B8 stack[-6] // @37B9 stack[-5] // } 37B4 5B JUMPDEST 37B5 91 SWAP2 37B6 50 POP 37B7 50 POP 37B8 92 SWAP3 37B9 91 SWAP2 37BA 50 POP 37BB 50 POP 37BC 56 *JUMP // Stack delta = -5 // Outputs[1] { @37B8 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_37BD: // Incoming call from 0x3A2C, returns to 0x3A2D // Inputs[2] // { // @37C0 stack[-2] // @37C3 stack[-1] // } 37BD 5B JUMPDEST 37BE 60 PUSH1 0x00 37C0 82 DUP3 37C1 60 PUSH1 0x1f 37C3 83 DUP4 37C4 01 ADD 37C5 12 SLT 37C6 61 PUSH2 0x37ce 37C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37BE stack[0] = 0x00 } // Block ends with conditional jump to 0x37ce, if stack[-1] + 0x1f i< stack[-2] label_37CA: // Incoming jump from 0x37C9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @37CD memory[0x00:0x00] } 37CA 60 PUSH1 0x00 37CC 80 DUP1 37CD FD *REVERT // Stack delta = +0 // Outputs[1] { @37CD revert(memory[0x00:0x00]); } // Block terminates label_37CE: // Incoming jump from 0x37C9, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @37CF stack[-2] // @37D0 msg.data[stack[-2]:stack[-2] + 0x20] // @37D4 stack[-3] // } 37CE 5B JUMPDEST 37CF 81 DUP2 37D0 35 CALLDATALOAD 37D1 61 PUSH2 0x37de 37D4 84 DUP5 37D5 82 DUP3 37D6 60 PUSH1 0x20 37D8 86 DUP7 37D9 01 ADD 37DA 61 PUSH2 0x3701 37DD 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @37D0 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @37D1 stack[1] = 0x37de // @37D4 stack[2] = stack[-3] // @37D5 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @37D9 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x3701, returns to 0x37DE label_37DE: // Incoming return from call to 0x3701 at 0x37DD // Inputs[4] // { // @37DF stack[-1] // @37DF stack[-3] // @37E2 stack[-6] // @37E3 stack[-5] // } 37DE 5B JUMPDEST 37DF 91 SWAP2 37E0 50 POP 37E1 50 POP 37E2 92 SWAP3 37E3 91 SWAP2 37E4 50 POP 37E5 50 POP 37E6 56 *JUMP // Stack delta = -5 // Outputs[1] { @37E2 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_37E7: // Incoming call from 0x38A5, returns to 0x38A6 // Incoming call from 0x3A55, returns to 0x3A56 // Incoming call from 0x38F5, returns to 0x38F6 // Incoming call from 0x3998, returns to 0x3999 // Inputs[2] // { // @37EA stack[-1] // @37EB msg.data[stack[-1]:stack[-1] + 0x20] // } 37E7 5B JUMPDEST 37E8 60 PUSH1 0x00 37EA 81 DUP2 37EB 35 CALLDATALOAD 37EC 90 SWAP1 37ED 50 POP 37EE 61 PUSH2 0x37f6 37F1 81 DUP2 37F2 61 PUSH2 0x4e3c 37F5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @37EC stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @37EE stack[1] = 0x37f6 // @37F1 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4e3c, returns to 0x37F6 label_37F6: // Incoming return from call to 0x4E3C at 0x37F5 // Inputs[3] // { // @37F7 stack[-1] // @37F7 stack[-4] // @37F8 stack[-3] // } 37F6 5B JUMPDEST 37F7 92 SWAP3 37F8 91 SWAP2 37F9 50 POP 37FA 50 POP 37FB 56 *JUMP // Stack delta = -3 // Outputs[1] { @37F7 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_37FC: // Incoming call from 0x08EC, returns to 0x08ED // Incoming call from 0x046E, returns to 0x046F // Incoming call from 0x0603, returns to 0x0604 // Incoming call from 0x0743, returns to 0x0744 // Inputs[2] // { // @3801 stack[-1] // @3802 stack[-2] // } 37FC 5B JUMPDEST 37FD 60 PUSH1 0x00 37FF 60 PUSH1 0x20 3801 82 DUP3 3802 84 DUP5 3803 03 SUB 3804 12 SLT 3805 15 ISZERO 3806 61 PUSH2 0x380e 3809 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37FD stack[0] = 0x00 } // Block ends with conditional jump to 0x380e, if !(stack[-2] - stack[-1] i< 0x20) label_380A: // Incoming jump from 0x3809, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @380D memory[0x00:0x00] } 380A 60 PUSH1 0x00 380C 80 DUP1 380D FD *REVERT // Stack delta = +0 // Outputs[1] { @380D revert(memory[0x00:0x00]); } // Block terminates label_380E: // Incoming jump from 0x3809, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3814 stack[-3] // @3816 stack[-2] // } 380E 5B JUMPDEST 380F 60 PUSH1 0x00 3811 61 PUSH2 0x381c 3814 84 DUP5 3815 82 DUP3 3816 85 DUP6 3817 01 ADD 3818 61 PUSH2 0x373f 381B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @380F stack[0] = 0x00 // @3811 stack[1] = 0x381c // @3814 stack[2] = stack[-3] // @3817 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x373f, returns to 0x381C label_381C: // Incoming return from call to 0x373F at 0x381B // Inputs[4] // { // @381D stack[-3] // @381D stack[-1] // @3820 stack[-6] // @3821 stack[-5] // } 381C 5B JUMPDEST 381D 91 SWAP2 381E 50 POP 381F 50 POP 3820 92 SWAP3 3821 91 SWAP2 3822 50 POP 3823 50 POP 3824 56 *JUMP // Stack delta = -5 // Outputs[1] { @3820 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3825: // Incoming call from 0x0819, returns to 0x081A // Inputs[2] // { // @382B stack[-1] // @382C stack[-2] // } 3825 5B JUMPDEST 3826 60 PUSH1 0x00 3828 80 DUP1 3829 60 PUSH1 0x40 382B 83 DUP4 382C 85 DUP6 382D 03 SUB 382E 12 SLT 382F 15 ISZERO 3830 61 PUSH2 0x3838 3833 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3826 stack[0] = 0x00 // @3828 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3838, if !(stack[-2] - stack[-1] i< 0x40) label_3834: // Incoming jump from 0x3833, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3837 memory[0x00:0x00] } 3834 60 PUSH1 0x00 3836 80 DUP1 3837 FD *REVERT // Stack delta = +0 // Outputs[1] { @3837 revert(memory[0x00:0x00]); } // Block terminates label_3838: // Incoming jump from 0x3833, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @383E stack[-4] // @3840 stack[-3] // } 3838 5B JUMPDEST 3839 60 PUSH1 0x00 383B 61 PUSH2 0x3846 383E 85 DUP6 383F 82 DUP3 3840 86 DUP7 3841 01 ADD 3842 61 PUSH2 0x373f 3845 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3839 stack[0] = 0x00 // @383B stack[1] = 0x3846 // @383E stack[2] = stack[-4] // @3841 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x373f, returns to 0x3846 label_3846: // Incoming return from call to 0x373F at 0x3845 // Inputs[4] // { // @3847 stack[-1] // @3847 stack[-4] // @384F stack[-6] // @3851 stack[-5] // } 3846 5B JUMPDEST 3847 92 SWAP3 3848 50 POP 3849 50 POP 384A 60 PUSH1 0x20 384C 61 PUSH2 0x3857 384F 85 DUP6 3850 82 DUP3 3851 86 DUP7 3852 01 ADD 3853 61 PUSH2 0x373f 3856 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3847 stack[-4] = stack[-1] // @384A stack[-2] = 0x20 // @384C stack[-1] = 0x3857 // @384F stack[0] = stack[-6] // @3852 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x373f, returns to 0x3857 label_3857: // Incoming return from call to 0x373F at 0x3856 // Inputs[6] // { // @3858 stack[-1] // @3858 stack[-3] // @385B stack[-6] // @385D stack[-4] // @385D stack[-7] // @385E stack[-5] // } 3857 5B JUMPDEST 3858 91 SWAP2 3859 50 POP 385A 50 POP 385B 92 SWAP3 385C 50 POP 385D 92 SWAP3 385E 90 SWAP1 385F 50 POP 3860 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @385B stack[-6] = stack[-1] // @385D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3861: // Incoming call from 0x04C5, returns to 0x04C6 // Incoming call from 0x03F1, returns to 0x03F2 // Inputs[2] // { // @3869 stack[-1] // @386A stack[-2] // } 3861 5B JUMPDEST 3862 60 PUSH1 0x00 3864 80 DUP1 3865 60 PUSH1 0x00 3867 60 PUSH1 0x60 3869 84 DUP5 386A 86 DUP7 386B 03 SUB 386C 12 SLT 386D 15 ISZERO 386E 61 PUSH2 0x3876 3871 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3862 stack[0] = 0x00 // @3864 stack[1] = 0x00 // @3865 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3876, if !(stack[-2] - stack[-1] i< 0x60) label_3872: // Incoming jump from 0x3871, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3875 memory[0x00:0x00] } 3872 60 PUSH1 0x00 3874 80 DUP1 3875 FD *REVERT // Stack delta = +0 // Outputs[1] { @3875 revert(memory[0x00:0x00]); } // Block terminates label_3876: // Incoming jump from 0x3871, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @387C stack[-5] // @387E stack[-4] // } 3876 5B JUMPDEST 3877 60 PUSH1 0x00 3879 61 PUSH2 0x3884 387C 86 DUP7 387D 82 DUP3 387E 87 DUP8 387F 01 ADD 3880 61 PUSH2 0x373f 3883 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3877 stack[0] = 0x00 // @3879 stack[1] = 0x3884 // @387C stack[2] = stack[-5] // @387F stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x373f, returns to 0x3884 label_3884: // Incoming return from call to 0x373F at 0x3883 // Inputs[4] // { // @3885 stack[-1] // @3885 stack[-5] // @388D stack[-7] // @388F stack[-6] // } 3884 5B JUMPDEST 3885 93 SWAP4 3886 50 POP 3887 50 POP 3888 60 PUSH1 0x20 388A 61 PUSH2 0x3895 388D 86 DUP7 388E 82 DUP3 388F 87 DUP8 3890 01 ADD 3891 61 PUSH2 0x373f 3894 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3885 stack[-5] = stack[-1] // @3888 stack[-2] = 0x20 // @388A stack[-1] = 0x3895 // @388D stack[0] = stack[-7] // @3890 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x373f, returns to 0x3895 label_3895: // Incoming return from call to 0x373F at 0x3894 // Inputs[4] // { // @3896 stack[-4] // @3896 stack[-1] // @389E stack[-7] // @38A0 stack[-6] // } 3895 5B JUMPDEST 3896 92 SWAP3 3897 50 POP 3898 50 POP 3899 60 PUSH1 0x40 389B 61 PUSH2 0x38a6 389E 86 DUP7 389F 82 DUP3 38A0 87 DUP8 38A1 01 ADD 38A2 61 PUSH2 0x37e7 38A5 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3896 stack[-4] = stack[-1] // @3899 stack[-2] = 0x40 // @389B stack[-1] = 0x38a6 // @389E stack[0] = stack[-7] // @38A1 stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x37e7, returns to 0x38A6 label_38A6: // Incoming return from call to 0x37E7 at 0x38A5 // Inputs[7] // { // @38A7 stack[-1] // @38A7 stack[-3] // @38AA stack[-6] // @38AC stack[-4] // @38AC stack[-7] // @38AE stack[-5] // @38AE stack[-8] // } 38A6 5B JUMPDEST 38A7 91 SWAP2 38A8 50 POP 38A9 50 POP 38AA 92 SWAP3 38AB 50 POP 38AC 92 SWAP3 38AD 50 POP 38AE 92 SWAP3 38AF 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @38AA stack[-6] = stack[-1] // @38AC stack[-7] = stack[-4] // @38AE stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_38B0: // Incoming call from 0x076C, returns to 0x076D // Inputs[2] // { // @38B9 stack[-1] // @38BA stack[-2] // } 38B0 5B JUMPDEST 38B1 60 PUSH1 0x00 38B3 80 DUP1 38B4 60 PUSH1 0x00 38B6 80 DUP1 38B7 60 PUSH1 0x80 38B9 85 DUP6 38BA 87 DUP8 38BB 03 SUB 38BC 12 SLT 38BD 15 ISZERO 38BE 61 PUSH2 0x38c6 38C1 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @38B1 stack[0] = 0x00 // @38B3 stack[1] = 0x00 // @38B4 stack[2] = 0x00 // @38B6 stack[3] = 0x00 // } // Block ends with conditional jump to 0x38c6, if !(stack[-2] - stack[-1] i< 0x80) label_38C2: // Incoming jump from 0x38C1, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @38C5 memory[0x00:0x00] } 38C2 60 PUSH1 0x00 38C4 80 DUP1 38C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @38C5 revert(memory[0x00:0x00]); } // Block terminates label_38C6: // Incoming jump from 0x38C1, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @38CC stack[-6] // @38CE stack[-5] // } 38C6 5B JUMPDEST 38C7 60 PUSH1 0x00 38C9 61 PUSH2 0x38d4 38CC 87 DUP8 38CD 82 DUP3 38CE 88 DUP9 38CF 01 ADD 38D0 61 PUSH2 0x373f 38D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @38C7 stack[0] = 0x00 // @38C9 stack[1] = 0x38d4 // @38CC stack[2] = stack[-6] // @38CF stack[3] = stack[-5] + 0x00 // } // Block ends with call to 0x373f, returns to 0x38D4 label_38D4: // Incoming return from call to 0x373F at 0x38D3 // Inputs[4] // { // @38D5 stack[-6] // @38D5 stack[-1] // @38DD stack[-8] // @38DF stack[-7] // } 38D4 5B JUMPDEST 38D5 94 SWAP5 38D6 50 POP 38D7 50 POP 38D8 60 PUSH1 0x20 38DA 61 PUSH2 0x38e5 38DD 87 DUP8 38DE 82 DUP3 38DF 88 DUP9 38E0 01 ADD 38E1 61 PUSH2 0x373f 38E4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @38D5 stack[-6] = stack[-1] // @38D8 stack[-2] = 0x20 // @38DA stack[-1] = 0x38e5 // @38DD stack[0] = stack[-8] // @38E0 stack[1] = stack[-7] + 0x20 // } // Block ends with call to 0x373f, returns to 0x38E5 label_38E5: // Incoming return from call to 0x373F at 0x38E4 // Inputs[4] // { // @38E6 stack[-5] // @38E6 stack[-1] // @38EE stack[-8] // @38F0 stack[-7] // } 38E5 5B JUMPDEST 38E6 93 SWAP4 38E7 50 POP 38E8 50 POP 38E9 60 PUSH1 0x40 38EB 61 PUSH2 0x38f6 38EE 87 DUP8 38EF 82 DUP3 38F0 88 DUP9 38F1 01 ADD 38F2 61 PUSH2 0x37e7 38F5 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @38E6 stack[-5] = stack[-1] // @38E9 stack[-2] = 0x40 // @38EB stack[-1] = 0x38f6 // @38EE stack[0] = stack[-8] // @38F1 stack[1] = stack[-7] + 0x40 // } // Block ends with call to 0x37e7, returns to 0x38F6 label_38F6: // Incoming return from call to 0x37E7 at 0x38F5 // Inputs[4] // { // @38F7 stack[-4] // @38F7 stack[-1] // @38FC stack[-7] // @38FE msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 38F6 5B JUMPDEST 38F7 92 SWAP3 38F8 50 POP 38F9 50 POP 38FA 60 PUSH1 0x60 38FC 85 DUP6 38FD 01 ADD 38FE 35 CALLDATALOAD 38FF 67 PUSH8 0xffffffffffffffff 3908 81 DUP2 3909 11 GT 390A 15 ISZERO 390B 61 PUSH2 0x3913 390E 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @38F7 stack[-4] = stack[-1] // @38FE stack[-2] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x3913, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_390F: // Incoming jump from 0x390E, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @3912 memory[0x00:0x00] } 390F 60 PUSH1 0x00 3911 80 DUP1 3912 FD *REVERT // Stack delta = +0 // Outputs[1] { @3912 revert(memory[0x00:0x00]); } // Block terminates label_3913: // Incoming jump from 0x390E, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3917 stack[-7] // @3918 stack[-1] // @3919 stack[-6] // } 3913 5B JUMPDEST 3914 61 PUSH2 0x391f 3917 87 DUP8 3918 82 DUP3 3919 88 DUP9 391A 01 ADD 391B 61 PUSH2 0x3793 391E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3914 stack[0] = 0x391f // @3917 stack[1] = stack[-7] // @391A stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x3793, returns to 0x391F label_391F: // Incoming return from call to 0x3793 at 0x391E // Inputs[8] // { // @3920 stack[-1] // @3920 stack[-3] // @3923 stack[-6] // @3924 stack[-9] // @3925 stack[-5] // @3926 stack[-8] // @3928 stack[-4] // @3928 stack[-7] // } 391F 5B JUMPDEST 3920 91 SWAP2 3921 50 POP 3922 50 POP 3923 92 SWAP3 3924 95 SWAP6 3925 91 SWAP2 3926 94 SWAP5 3927 50 POP 3928 92 SWAP3 3929 50 POP 392A 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @3923 stack[-6] = stack[-1] // @3924 stack[-9] = stack[-6] // @3926 stack[-8] = stack[-5] // @3928 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_392B: // Incoming call from 0x0703, returns to 0x0704 // Inputs[2] // { // @3931 stack[-1] // @3932 stack[-2] // } 392B 5B JUMPDEST 392C 60 PUSH1 0x00 392E 80 DUP1 392F 60 PUSH1 0x40 3931 83 DUP4 3932 85 DUP6 3933 03 SUB 3934 12 SLT 3935 15 ISZERO 3936 61 PUSH2 0x393e 3939 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @392C stack[0] = 0x00 // @392E stack[1] = 0x00 // } // Block ends with conditional jump to 0x393e, if !(stack[-2] - stack[-1] i< 0x40) label_393A: // Incoming jump from 0x3939, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @393D memory[0x00:0x00] } 393A 60 PUSH1 0x00 393C 80 DUP1 393D FD *REVERT // Stack delta = +0 // Outputs[1] { @393D revert(memory[0x00:0x00]); } // Block terminates label_393E: // Incoming jump from 0x3939, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3944 stack[-4] // @3946 stack[-3] // } 393E 5B JUMPDEST 393F 60 PUSH1 0x00 3941 61 PUSH2 0x394c 3944 85 DUP6 3945 82 DUP3 3946 86 DUP7 3947 01 ADD 3948 61 PUSH2 0x373f 394B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @393F stack[0] = 0x00 // @3941 stack[1] = 0x394c // @3944 stack[2] = stack[-4] // @3947 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x373f, returns to 0x394C label_394C: // Incoming return from call to 0x373F at 0x394B // Inputs[4] // { // @394D stack[-4] // @394D stack[-1] // @3955 stack[-6] // @3957 stack[-5] // } 394C 5B JUMPDEST 394D 92 SWAP3 394E 50 POP 394F 50 POP 3950 60 PUSH1 0x20 3952 61 PUSH2 0x395d 3955 85 DUP6 3956 82 DUP3 3957 86 DUP7 3958 01 ADD 3959 61 PUSH2 0x3754 395C 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @394D stack[-4] = stack[-1] // @3950 stack[-2] = 0x20 // @3952 stack[-1] = 0x395d // @3955 stack[0] = stack[-6] // @3958 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x3754, returns to 0x395D label_395D: // Incoming return from call to 0x3754 at 0x395C // Inputs[6] // { // @395E stack[-3] // @395E stack[-1] // @3961 stack[-6] // @3963 stack[-4] // @3963 stack[-7] // @3964 stack[-5] // } 395D 5B JUMPDEST 395E 91 SWAP2 395F 50 POP 3960 50 POP 3961 92 SWAP3 3962 50 POP 3963 92 SWAP3 3964 90 SWAP1 3965 50 POP 3966 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @3961 stack[-6] = stack[-1] // @3963 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3967: // Incoming call from 0x0347, returns to 0x0348 // Incoming call from 0x0431, returns to 0x0432 // Inputs[2] // { // @396D stack[-1] // @396E stack[-2] // } 3967 5B JUMPDEST 3968 60 PUSH1 0x00 396A 80 DUP1 396B 60 PUSH1 0x40 396D 83 DUP4 396E 85 DUP6 396F 03 SUB 3970 12 SLT 3971 15 ISZERO 3972 61 PUSH2 0x397a 3975 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3968 stack[0] = 0x00 // @396A stack[1] = 0x00 // } // Block ends with conditional jump to 0x397a, if !(stack[-2] - stack[-1] i< 0x40) label_3976: // Incoming jump from 0x3975, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3979 memory[0x00:0x00] } 3976 60 PUSH1 0x00 3978 80 DUP1 3979 FD *REVERT // Stack delta = +0 // Outputs[1] { @3979 revert(memory[0x00:0x00]); } // Block terminates label_397A: // Incoming jump from 0x3975, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3980 stack[-4] // @3982 stack[-3] // } 397A 5B JUMPDEST 397B 60 PUSH1 0x00 397D 61 PUSH2 0x3988 3980 85 DUP6 3981 82 DUP3 3982 86 DUP7 3983 01 ADD 3984 61 PUSH2 0x373f 3987 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @397B stack[0] = 0x00 // @397D stack[1] = 0x3988 // @3980 stack[2] = stack[-4] // @3983 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x373f, returns to 0x3988 label_3988: // Incoming return from call to 0x373F at 0x3987 // Inputs[4] // { // @3989 stack[-1] // @3989 stack[-4] // @3991 stack[-6] // @3993 stack[-5] // } 3988 5B JUMPDEST 3989 92 SWAP3 398A 50 POP 398B 50 POP 398C 60 PUSH1 0x20 398E 61 PUSH2 0x3999 3991 85 DUP6 3992 82 DUP3 3993 86 DUP7 3994 01 ADD 3995 61 PUSH2 0x37e7 3998 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3989 stack[-4] = stack[-1] // @398C stack[-2] = 0x20 // @398E stack[-1] = 0x3999 // @3991 stack[0] = stack[-6] // @3994 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x37e7, returns to 0x3999 label_3999: // Incoming return from call to 0x37E7 at 0x3998 // Inputs[6] // { // @399A stack[-3] // @399A stack[-1] // @399D stack[-6] // @399F stack[-7] // @399F stack[-4] // @39A0 stack[-5] // } 3999 5B JUMPDEST 399A 91 SWAP2 399B 50 POP 399C 50 POP 399D 92 SWAP3 399E 50 POP 399F 92 SWAP3 39A0 90 SWAP1 39A1 50 POP 39A2 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @399D stack[-6] = stack[-1] // @399F stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_39A3: // Incoming call from 0x0277, returns to 0x0278 // Inputs[2] // { // @39A8 stack[-1] // @39A9 stack[-2] // } 39A3 5B JUMPDEST 39A4 60 PUSH1 0x00 39A6 60 PUSH1 0x20 39A8 82 DUP3 39A9 84 DUP5 39AA 03 SUB 39AB 12 SLT 39AC 15 ISZERO 39AD 61 PUSH2 0x39b5 39B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @39A4 stack[0] = 0x00 } // Block ends with conditional jump to 0x39b5, if !(stack[-2] - stack[-1] i< 0x20) label_39B1: // Incoming jump from 0x39B0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @39B4 memory[0x00:0x00] } 39B1 60 PUSH1 0x00 39B3 80 DUP1 39B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @39B4 revert(memory[0x00:0x00]); } // Block terminates label_39B5: // Incoming jump from 0x39B0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @39BB stack[-3] // @39BD stack[-2] // } 39B5 5B JUMPDEST 39B6 60 PUSH1 0x00 39B8 61 PUSH2 0x39c3 39BB 84 DUP5 39BC 82 DUP3 39BD 85 DUP6 39BE 01 ADD 39BF 61 PUSH2 0x3769 39C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @39B6 stack[0] = 0x00 // @39B8 stack[1] = 0x39c3 // @39BB stack[2] = stack[-3] // @39BE stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x3769, returns to 0x39C3 label_39C3: // Incoming return from call to 0x3769 at 0x39C2 // Inputs[4] // { // @39C4 stack[-1] // @39C4 stack[-3] // @39C7 stack[-6] // @39C8 stack[-5] // } 39C3 5B JUMPDEST 39C4 91 SWAP2 39C5 50 POP 39C6 50 POP 39C7 92 SWAP3 39C8 91 SWAP2 39C9 50 POP 39CA 50 POP 39CB 56 *JUMP // Stack delta = -5 // Outputs[1] { @39C7 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_39CC: // Incoming call from 0x2E60, returns to 0x2E61 // Inputs[2] // { // @39D1 stack[-1] // @39D2 stack[-2] // } 39CC 5B JUMPDEST 39CD 60 PUSH1 0x00 39CF 60 PUSH1 0x20 39D1 82 DUP3 39D2 84 DUP5 39D3 03 SUB 39D4 12 SLT 39D5 15 ISZERO 39D6 61 PUSH2 0x39de 39D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @39CD stack[0] = 0x00 } // Block ends with conditional jump to 0x39de, if !(stack[-2] - stack[-1] i< 0x20) label_39DA: // Incoming jump from 0x39D9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @39DD memory[0x00:0x00] } 39DA 60 PUSH1 0x00 39DC 80 DUP1 39DD FD *REVERT // Stack delta = +0 // Outputs[1] { @39DD revert(memory[0x00:0x00]); } // Block terminates label_39DE: // Incoming jump from 0x39D9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @39E4 stack[-3] // @39E6 stack[-2] // } 39DE 5B JUMPDEST 39DF 60 PUSH1 0x00 39E1 61 PUSH2 0x39ec 39E4 84 DUP5 39E5 82 DUP3 39E6 85 DUP6 39E7 01 ADD 39E8 61 PUSH2 0x377e 39EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @39DF stack[0] = 0x00 // @39E1 stack[1] = 0x39ec // @39E4 stack[2] = stack[-3] // @39E7 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x377e, returns to 0x39EC label_39EC: // Incoming return from call to 0x377E at 0x39EB // Inputs[4] // { // @39ED stack[-3] // @39ED stack[-1] // @39F0 stack[-6] // @39F1 stack[-5] // } 39EC 5B JUMPDEST 39ED 91 SWAP2 39EE 50 POP 39EF 50 POP 39F0 92 SWAP3 39F1 91 SWAP2 39F2 50 POP 39F3 50 POP 39F4 56 *JUMP // Stack delta = -5 // Outputs[1] { @39F0 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_39F5: // Incoming call from 0x08C3, returns to 0x08C4 // Incoming call from 0x0940, returns to 0x0941 // Incoming call from 0x0556, returns to 0x0557 // Inputs[2] // { // @39FA stack[-1] // @39FB stack[-2] // } 39F5 5B JUMPDEST 39F6 60 PUSH1 0x00 39F8 60 PUSH1 0x20 39FA 82 DUP3 39FB 84 DUP5 39FC 03 SUB 39FD 12 SLT 39FE 15 ISZERO 39FF 61 PUSH2 0x3a07 3A02 57 *JUMPI // Stack delta = +1 // Outputs[1] { @39F6 stack[0] = 0x00 } // Block ends with conditional jump to 0x3a07, if !(stack[-2] - stack[-1] i< 0x20) label_3A03: // Incoming jump from 0x3A02, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3A06 memory[0x00:0x00] } 3A03 60 PUSH1 0x00 3A05 80 DUP1 3A06 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A06 revert(memory[0x00:0x00]); } // Block terminates label_3A07: // Incoming jump from 0x3A02, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3A0A stack[-2] // @3A0C msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] // } 3A07 5B JUMPDEST 3A08 60 PUSH1 0x00 3A0A 82 DUP3 3A0B 01 ADD 3A0C 35 CALLDATALOAD 3A0D 67 PUSH8 0xffffffffffffffff 3A16 81 DUP2 3A17 11 GT 3A18 15 ISZERO 3A19 61 PUSH2 0x3a21 3A1C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A0C stack[0] = msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] } // Block ends with conditional jump to 0x3a21, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) label_3A1D: // Incoming jump from 0x3A1C, if not !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @3A20 memory[0x00:0x00] } 3A1D 60 PUSH1 0x00 3A1F 80 DUP1 3A20 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A20 revert(memory[0x00:0x00]); } // Block terminates label_3A21: // Incoming jump from 0x3A1C, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3A25 stack[-4] // @3A26 stack[-1] // @3A27 stack[-3] // } 3A21 5B JUMPDEST 3A22 61 PUSH2 0x3a2d 3A25 84 DUP5 3A26 82 DUP3 3A27 85 DUP6 3A28 01 ADD 3A29 61 PUSH2 0x37bd 3A2C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3A22 stack[0] = 0x3a2d // @3A25 stack[1] = stack[-4] // @3A28 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x37bd, returns to 0x3A2D label_3A2D: // Incoming return from call to 0x37BD at 0x3A2C // Inputs[4] // { // @3A2E stack[-3] // @3A2E stack[-1] // @3A31 stack[-6] // @3A32 stack[-5] // } 3A2D 5B JUMPDEST 3A2E 91 SWAP2 3A2F 50 POP 3A30 50 POP 3A31 92 SWAP3 3A32 91 SWAP2 3A33 50 POP 3A34 50 POP 3A35 56 *JUMP // Stack delta = -5 // Outputs[1] { @3A31 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3A36: // Incoming call from 0x02DF, returns to 0x02E0 // Incoming call from 0x04EE, returns to 0x04EF // Incoming call from 0x05DA, returns to 0x05DB // Incoming call from 0x07DC, returns to 0x07DD // Incoming call from 0x057F, returns to 0x0580 // Incoming call from 0x0788, returns to 0x0789 // Inputs[2] // { // @3A3B stack[-1] // @3A3C stack[-2] // } 3A36 5B JUMPDEST 3A37 60 PUSH1 0x00 3A39 60 PUSH1 0x20 3A3B 82 DUP3 3A3C 84 DUP5 3A3D 03 SUB 3A3E 12 SLT 3A3F 15 ISZERO 3A40 61 PUSH2 0x3a48 3A43 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A37 stack[0] = 0x00 } // Block ends with conditional jump to 0x3a48, if !(stack[-2] - stack[-1] i< 0x20) label_3A44: // Incoming jump from 0x3A43, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3A47 memory[0x00:0x00] } 3A44 60 PUSH1 0x00 3A46 80 DUP1 3A47 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A47 revert(memory[0x00:0x00]); } // Block terminates label_3A48: // Incoming jump from 0x3A43, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3A4E stack[-3] // @3A50 stack[-2] // } 3A48 5B JUMPDEST 3A49 60 PUSH1 0x00 3A4B 61 PUSH2 0x3a56 3A4E 84 DUP5 3A4F 82 DUP3 3A50 85 DUP6 3A51 01 ADD 3A52 61 PUSH2 0x37e7 3A55 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3A49 stack[0] = 0x00 // @3A4B stack[1] = 0x3a56 // @3A4E stack[2] = stack[-3] // @3A51 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x37e7, returns to 0x3A56 label_3A56: // Incoming return from call to 0x37E7 at 0x3A55 // Inputs[4] // { // @3A57 stack[-1] // @3A57 stack[-3] // @3A5A stack[-6] // @3A5B stack[-5] // } 3A56 5B JUMPDEST 3A57 91 SWAP2 3A58 50 POP 3A59 50 POP 3A5A 92 SWAP3 3A5B 91 SWAP2 3A5C 50 POP 3A5D 50 POP 3A5E 56 *JUMP // Stack delta = -5 // Outputs[1] { @3A5A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3A5F: // Incoming call from 0x45BA, returns to 0x45BB // Incoming call from 0x45C7, returns to 0x45C8 // Incoming call from 0x459F, returns to 0x45A0 // Inputs[1] { @3A63 stack[-1] } 3A5F 5B JUMPDEST 3A60 61 PUSH2 0x3a68 3A63 81 DUP2 3A64 61 PUSH2 0x4bc8 3A67 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3A60 stack[0] = 0x3a68 // @3A63 stack[1] = stack[-1] // } // Block ends with call to 0x4bc8, returns to 0x3A68 label_3A68: // Incoming return from call to 0x4BC8 at 0x3A67 // Inputs[3] // { // @3A69 stack[-3] // @3A6A stack[-1] // @3A6D stack[-4] // } 3A68 5B JUMPDEST 3A69 82 DUP3 3A6A 52 MSTORE 3A6B 50 POP 3A6C 50 POP 3A6D 56 *JUMP // Stack delta = -4 // Outputs[1] { @3A6A memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3A6E: // Incoming call from 0x4606, returns to 0x4607 // Inputs[1] { @3A72 stack[-1] } 3A6E 5B JUMPDEST 3A6F 61 PUSH2 0x3a77 3A72 81 DUP2 3A73 61 PUSH2 0x4bda 3A76 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3A6F stack[0] = 0x3a77 // @3A72 stack[1] = stack[-1] // } // Block ends with call to 0x4bda, returns to 0x3A77 label_3A77: // Incoming return from call to 0x4BDA at 0x3A76 // Inputs[3] // { // @3A78 stack[-3] // @3A79 stack[-1] // @3A7C stack[-4] // } 3A77 5B JUMPDEST 3A78 82 DUP3 3A79 52 MSTORE 3A7A 50 POP 3A7B 50 POP 3A7C 56 *JUMP // Stack delta = -4 // Outputs[1] { @3A79 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_3A7D: // Incoming call from 0x45E6, returns to 0x45E7 // Inputs[1] { @3A83 stack[-1] } 3A7D 5B JUMPDEST 3A7E 60 PUSH1 0x00 3A80 61 PUSH2 0x3a88 3A83 82 DUP3 3A84 61 PUSH2 0x4a70 3A87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3A7E stack[0] = 0x00 // @3A80 stack[1] = 0x3a88 // @3A83 stack[2] = stack[-1] // } // Block ends with call to 0x4a70, returns to 0x3A88 label_3A88: // Incoming return from call to 0x4A70 at 0x3A87 // Inputs[2] // { // @3A8C stack[-1] // @3A8D stack[-4] // } 3A88 5B JUMPDEST 3A89 61 PUSH2 0x3a92 3A8C 81 DUP2 3A8D 85 DUP6 3A8E 61 PUSH2 0x4a86 3A91 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3A89 stack[0] = 0x3a92 // @3A8C stack[1] = stack[-1] // @3A8D stack[2] = stack[-4] // } // Block ends with call to 0x4a86, returns to 0x3A92 label_3A92: // Incoming return from call to 0x4A86 at 0x3A91 // Inputs[4] // { // @3A93 stack[-1] // @3A93 stack[-5] // @3A98 stack[-2] // @3A9C stack[-4] // } 3A92 5B JUMPDEST 3A93 93 SWAP4 3A94 50 POP 3A95 61 PUSH2 0x3aa2 3A98 81 DUP2 3A99 85 DUP6 3A9A 60 PUSH1 0x20 3A9C 86 DUP7 3A9D 01 ADD 3A9E 61 PUSH2 0x4c4b 3AA1 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @3A93 stack[-5] = stack[-1] // @3A95 stack[-1] = 0x3aa2 // @3A98 stack[0] = stack[-2] // @3A99 stack[1] = stack[-1] // @3A9D stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x4c4b, returns to 0x3AA2 label_3AA2: // Incoming return from call to 0x4C4B at 0x3AA1 // Inputs[1] { @3AA6 stack[-1] } 3AA2 5B JUMPDEST 3AA3 61 PUSH2 0x3aab 3AA6 81 DUP2 3AA7 61 PUSH2 0x4de6 3AAA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3AA3 stack[0] = 0x3aab // @3AA6 stack[1] = stack[-1] // } // Block ends with call to 0x4de6, returns to 0x3AAB label_3AAB: // Incoming return from call to 0x4DE6 at 0x3AAA // Inputs[4] // { // @3AAC stack[-5] // @3AAD stack[-1] // @3AAE stack[-3] // @3AB1 stack[-6] // } 3AAB 5B JUMPDEST 3AAC 84 DUP5 3AAD 01 ADD 3AAE 91 SWAP2 3AAF 50 POP 3AB0 50 POP 3AB1 92 SWAP3 3AB2 91 SWAP2 3AB3 50 POP 3AB4 50 POP 3AB5 56 *JUMP // Stack delta = -5 // Outputs[1] { @3AB1 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_3AB6: // Incoming call from 0x4626, returns to 0x4627 // Inputs[1] { @3ABC stack[-1] } 3AB6 5B JUMPDEST 3AB7 60 PUSH1 0x00 3AB9 61 PUSH2 0x3ac1 3ABC 82 DUP3 3ABD 61 PUSH2 0x4a7b 3AC0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3AB7 stack[0] = 0x00 // @3AB9 stack[1] = 0x3ac1 // @3ABC stack[2] = stack[-1] // } // Block ends with call to 0x4a7b, returns to 0x3AC1 label_3AC1: // Incoming return from call to 0x4A7B at 0x3AC0 // Inputs[2] // { // @3AC5 stack[-1] // @3AC6 stack[-4] // } 3AC1 5B JUMPDEST 3AC2 61 PUSH2 0x3acb 3AC5 81 DUP2 3AC6 85 DUP6 3AC7 61 PUSH2 0x4a97 3ACA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3AC2 stack[0] = 0x3acb // @3AC5 stack[1] = stack[-1] // @3AC6 stack[2] = stack[-4] // } // Block ends with call to 0x4a97, returns to 0x3ACB label_3ACB: // Incoming return from call to 0x4A97 at 0x3ACA // Inputs[4] // { // @3ACC stack[-1] // @3ACC stack[-5] // @3AD1 stack[-2] // @3AD5 stack[-4] // } 3ACB 5B JUMPDEST 3ACC 93 SWAP4 3ACD 50 POP 3ACE 61 PUSH2 0x3adb 3AD1 81 DUP2 3AD2 85 DUP6 3AD3 60 PUSH1 0x20 3AD5 86 DUP7 3AD6 01 ADD 3AD7 61 PUSH2 0x4c4b 3ADA 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @3ACC stack[-5] = stack[-1] // @3ACE stack[-1] = 0x3adb // @3AD1 stack[0] = stack[-2] // @3AD2 stack[1] = stack[-1] // @3AD6 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x4c4b, returns to 0x3ADB label_3ADB: // Incoming return from call to 0x4C4B at 0x3ADA // Inputs[1] { @3ADF stack[-1] } 3ADB 5B JUMPDEST 3ADC 61 PUSH2 0x3ae4 3ADF 81 DUP2 3AE0 61 PUSH2 0x4de6 3AE3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3ADC stack[0] = 0x3ae4 // @3ADF stack[1] = stack[-1] // } // Block ends with call to 0x4de6, returns to 0x3AE4 label_3AE4: // Incoming return from call to 0x4DE6 at 0x3AE3 // Inputs[4] // { // @3AE5 stack[-5] // @3AE6 stack[-1] // @3AE7 stack[-3] // @3AEA stack[-6] // } 3AE4 5B JUMPDEST 3AE5 84 DUP5 3AE6 01 ADD 3AE7 91 SWAP2 3AE8 50 POP 3AE9 50 POP 3AEA 92 SWAP3 3AEB 91 SWAP2 3AEC 50 POP 3AED 50 POP 3AEE 56 *JUMP // Stack delta = -5 // Outputs[1] { @3AEA stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_3AEF: // Incoming call from 0x4571, returns to 0x4572 // Incoming call from 0x4565, returns to 0x4566 // Inputs[1] { @3AF5 stack[-1] } 3AEF 5B JUMPDEST 3AF0 60 PUSH1 0x00 3AF2 61 PUSH2 0x3afa 3AF5 82 DUP3 3AF6 61 PUSH2 0x4a7b 3AF9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3AF0 stack[0] = 0x00 // @3AF2 stack[1] = 0x3afa // @3AF5 stack[2] = stack[-1] // } // Block ends with call to 0x4a7b, returns to 0x3AFA label_3AFA: // Incoming return from call to 0x4A7B at 0x3AF9 // Inputs[2] // { // @3AFE stack[-1] // @3AFF stack[-4] // } 3AFA 5B JUMPDEST 3AFB 61 PUSH2 0x3b04 3AFE 81 DUP2 3AFF 85 DUP6 3B00 61 PUSH2 0x4aa8 3B03 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3AFB stack[0] = 0x3b04 // @3AFE stack[1] = stack[-1] // @3AFF stack[2] = stack[-4] // } // Block ends with call to 0x4aa8, returns to 0x3B04 label_3B04: // Incoming return from call to 0x4AA8 at 0x3B03 // Inputs[4] // { // @3B05 stack[-5] // @3B05 stack[-1] // @3B0A stack[-2] // @3B0E stack[-4] // } 3B04 5B JUMPDEST 3B05 93 SWAP4 3B06 50 POP 3B07 61 PUSH2 0x3b14 3B0A 81 DUP2 3B0B 85 DUP6 3B0C 60 PUSH1 0x20 3B0E 86 DUP7 3B0F 01 ADD 3B10 61 PUSH2 0x4c4b 3B13 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @3B05 stack[-5] = stack[-1] // @3B07 stack[-1] = 0x3b14 // @3B0A stack[0] = stack[-2] // @3B0B stack[1] = stack[-1] // @3B0F stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x4c4b, returns to 0x3B14 label_3B14: // Incoming return from call to 0x4C4B at 0x3B13 // Inputs[4] // { // @3B15 stack[-1] // @3B16 stack[-4] // @3B18 stack[-2] // @3B1B stack[-5] // } 3B14 5B JUMPDEST 3B15 80 DUP1 3B16 84 DUP5 3B17 01 ADD 3B18 91 SWAP2 3B19 50 POP 3B1A 50 POP 3B1B 92 SWAP3 3B1C 91 SWAP2 3B1D 50 POP 3B1E 50 POP 3B1F 56 *JUMP // Stack delta = -4 // Outputs[1] { @3B1B stack[-5] = stack[-4] + stack[-1] } // Block ends with unconditional jump to stack[-5] label_3B20: // Incoming call from 0x457D, returns to 0x457E // Inputs[2] // { // @3B23 stack[-1] // @3B24 storage[stack[-1]] // } 3B20 5B JUMPDEST 3B21 60 PUSH1 0x00 3B23 81 DUP2 3B24 54 SLOAD 3B25 61 PUSH2 0x3b2d 3B28 81 DUP2 3B29 61 PUSH2 0x4c7e 3B2C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3B21 stack[0] = 0x00 // @3B24 stack[1] = storage[stack[-1]] // @3B25 stack[2] = 0x3b2d // @3B28 stack[3] = storage[stack[-1]] // } // Block ends with call to 0x4c7e, returns to 0x3B2D label_3B2D: // Incoming return from call to 0x4C7E at 0x3B2C // Inputs[2] // { // @3B31 stack[-1] // @3B32 stack[-5] // } 3B2D 5B JUMPDEST 3B2E 61 PUSH2 0x3b37 3B31 81 DUP2 3B32 86 DUP7 3B33 61 PUSH2 0x4aa8 3B36 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3B2E stack[0] = 0x3b37 // @3B31 stack[1] = stack[-1] // @3B32 stack[2] = stack[-5] // } // Block ends with call to 0x4aa8, returns to 0x3B37 label_3B37: // Incoming return from call to 0x4AA8 at 0x3B36 // Inputs[3] // { // @3B38 stack[-1] // @3B38 stack[-6] // @3B3C stack[-3] // } 3B37 5B JUMPDEST 3B38 94 SWAP5 3B39 50 POP 3B3A 60 PUSH1 0x01 3B3C 82 DUP3 3B3D 16 AND 3B3E 60 PUSH1 0x00 3B40 81 DUP2 3B41 14 EQ 3B42 61 PUSH2 0x3b52 3B45 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3B38 stack[-6] = stack[-1] // @3B3D stack[-1] = stack[-3] & 0x01 // } // Block ends with conditional jump to 0x3b52, if stack[-3] & 0x01 == 0x00 label_3B46: // Incoming jump from 0x3B45, if not stack[-3] & 0x01 == 0x00 // Inputs[1] { @3B48 stack[-1] } 3B46 60 PUSH1 0x01 3B48 81 DUP2 3B49 14 EQ 3B4A 61 PUSH2 0x3b63 3B4D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3b63, if stack[-1] == 0x01 label_3B4E: // Incoming jump from 0x3B4D, if not stack[-1] == 0x01 3B4E 61 PUSH2 0x3b96 3B51 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x3b96 label_3B52: // Incoming jump from 0x3B45, if stack[-3] & 0x01 == 0x00 // Inputs[4] // { // @3B56 stack[-3] // @3B58 stack[-6] // @3B5A stack[-2] // @3B5D stack[-4] // } 3B52 5B JUMPDEST 3B53 60 PUSH1 0xff 3B55 19 NOT 3B56 83 DUP4 3B57 16 AND 3B58 86 DUP7 3B59 52 MSTORE 3B5A 81 DUP2 3B5B 86 DUP7 3B5C 01 ADD 3B5D 93 SWAP4 3B5E 50 POP 3B5F 61 PUSH2 0x3b96 3B62 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3B59 memory[stack[-6]:stack[-6] + 0x20] = stack[-3] & ~0xff // @3B5D stack[-4] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x3b96 label_3B63: // Incoming jump from 0x3B4D, if stack[-1] == 0x01 // Inputs[1] { @3B67 stack[-5] } 3B63 5B JUMPDEST 3B64 61 PUSH2 0x3b6c 3B67 85 DUP6 3B68 61 PUSH2 0x4a5b 3B6B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3B64 stack[0] = 0x3b6c // @3B67 stack[1] = stack[-5] // } // Block ends with call to 0x4a5b, returns to 0x3B6C label_3B6C: // Incoming return from call to 0x4A5B at 0x3B6B // Inputs[1] { @3B70 stack[-3] } 3B6C 5B JUMPDEST 3B6D 60 PUSH1 0x00 3B6F 5B JUMPDEST 3B70 83 DUP4 3B71 81 DUP2 3B72 10 LT 3B73 15 ISZERO 3B74 61 PUSH2 0x3b8e 3B77 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3B6D stack[0] = 0x00 } // Block ends with conditional jump to 0x3b8e, if !(0x00 < stack[-3]) label_3B78: // Incoming jump from 0x3B77, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x3B77, if not !(0x00 < stack[-3]) // Inputs[4] // { // @3B78 stack[-2] // @3B79 storage[stack[-2]] // @3B7A stack[-1] // @3B7B stack[-8] // } 3B78 81 DUP2 3B79 54 SLOAD 3B7A 81 DUP2 3B7B 89 DUP10 3B7C 01 ADD 3B7D 52 MSTORE 3B7E 60 PUSH1 0x01 3B80 82 DUP3 3B81 01 ADD 3B82 91 SWAP2 3B83 50 POP 3B84 60 PUSH1 0x20 3B86 81 DUP2 3B87 01 ADD 3B88 90 SWAP1 3B89 50 POP 3B8A 61 PUSH2 0x3b6f 3B8D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @3B7D memory[stack[-8] + stack[-1]:stack[-8] + stack[-1] + 0x20] = storage[stack[-2]] // @3B82 stack[-2] = stack[-2] + 0x01 // @3B88 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3b6f label_3B8E: // Incoming jump from 0x3B77, if !(stack[-1] < stack[-4]) // Incoming jump from 0x3B77, if !(0x00 < stack[-3]) // Inputs[3] // { // @3B8F stack[-4] // @3B90 stack[-8] // @3B92 stack[-6] // } 3B8E 5B JUMPDEST 3B8F 83 DUP4 3B90 88 DUP9 3B91 01 ADD 3B92 95 SWAP6 3B93 50 POP 3B94 50 POP 3B95 50 POP // Stack delta = -2 // Outputs[1] { @3B92 stack[-6] = stack[-8] + stack[-4] } // Block continues label_3B96: // Incoming jump from 0x3B62 // Incoming jump from 0x3B95 // Incoming jump from 0x3B51 // Inputs[3] // { // @3B9A stack[-4] // @3B9A stack[-7] // @3B9B stack[-6] // } 3B96 5B JUMPDEST 3B97 50 POP 3B98 50 POP 3B99 50 POP 3B9A 92 SWAP3 3B9B 91 SWAP2 3B9C 50 POP 3B9D 50 POP 3B9E 56 *JUMP // Stack delta = -6 // Outputs[1] { @3B9A stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_3B9F: // Incoming call from 0x4647, returns to 0x4648 // Inputs[1] { @3BA7 stack[-1] } 3B9F 5B JUMPDEST 3BA0 60 PUSH1 0x00 3BA2 61 PUSH2 0x3bac 3BA5 60 PUSH1 0x2b 3BA7 83 DUP4 3BA8 61 PUSH2 0x4a97 3BAB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3BA0 stack[0] = 0x00 // @3BA2 stack[1] = 0x3bac // @3BA5 stack[2] = 0x2b // @3BA7 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3BAC label_3BAC: // Incoming return from call to 0x4A97 at 0x3BAB // Inputs[4] // { // @3BAD stack[-3] // @3BAD stack[-1] // @3BFF stack[-2] // @3C01 stack[-4] // } 3BAC 5B JUMPDEST 3BAD 91 SWAP2 3BAE 50 POP 3BAF 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 3BD0 60 PUSH1 0x00 3BD2 83 DUP4 3BD3 01 ADD 3BD4 52 MSTORE 3BD5 7F PUSH32 0x74206f6620626f756e6473000000000000000000000000000000000000000000 3BF6 60 PUSH1 0x20 3BF8 83 DUP4 3BF9 01 ADD 3BFA 52 MSTORE 3BFB 60 PUSH1 0x40 3BFD 82 DUP3 3BFE 01 ADD 3BFF 90 SWAP1 3C00 50 POP 3C01 91 SWAP2 3C02 90 SWAP1 3C03 50 POP 3C04 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3BD4 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @3BFA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x74206f6620626f756e6473000000000000000000000000000000000000000000 // @3C01 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3C05: // Incoming call from 0x4667, returns to 0x4668 // Inputs[1] { @3C0D stack[-1] } 3C05 5B JUMPDEST 3C06 60 PUSH1 0x00 3C08 61 PUSH2 0x3c12 3C0B 60 PUSH1 0x32 3C0D 83 DUP4 3C0E 61 PUSH2 0x4a97 3C11 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3C06 stack[0] = 0x00 // @3C08 stack[1] = 0x3c12 // @3C0B stack[2] = 0x32 // @3C0D stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3C12 label_3C12: // Incoming return from call to 0x4A97 at 0x3C11 // Inputs[4] // { // @3C13 stack[-1] // @3C13 stack[-3] // @3C65 stack[-2] // @3C67 stack[-4] // } 3C12 5B JUMPDEST 3C13 91 SWAP2 3C14 50 POP 3C15 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 3C36 60 PUSH1 0x00 3C38 83 DUP4 3C39 01 ADD 3C3A 52 MSTORE 3C3B 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 3C5C 60 PUSH1 0x20 3C5E 83 DUP4 3C5F 01 ADD 3C60 52 MSTORE 3C61 60 PUSH1 0x40 3C63 82 DUP3 3C64 01 ADD 3C65 90 SWAP1 3C66 50 POP 3C67 91 SWAP2 3C68 90 SWAP1 3C69 50 POP 3C6A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3C3A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @3C60 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x63656976657220696d706c656d656e7465720000000000000000000000000000 // @3C67 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3C6B: // Incoming call from 0x4687, returns to 0x4688 // Inputs[1] { @3C73 stack[-1] } 3C6B 5B JUMPDEST 3C6C 60 PUSH1 0x00 3C6E 61 PUSH2 0x3c78 3C71 60 PUSH1 0x26 3C73 83 DUP4 3C74 61 PUSH2 0x4a97 3C77 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3C6C stack[0] = 0x00 // @3C6E stack[1] = 0x3c78 // @3C71 stack[2] = 0x26 // @3C73 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3C78 label_3C78: // Incoming return from call to 0x4A97 at 0x3C77 // Inputs[4] // { // @3C79 stack[-3] // @3C79 stack[-1] // @3CCB stack[-2] // @3CCD stack[-4] // } 3C78 5B JUMPDEST 3C79 91 SWAP2 3C7A 50 POP 3C7B 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 3C9C 60 PUSH1 0x00 3C9E 83 DUP4 3C9F 01 ADD 3CA0 52 MSTORE 3CA1 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 3CC2 60 PUSH1 0x20 3CC4 83 DUP4 3CC5 01 ADD 3CC6 52 MSTORE 3CC7 60 PUSH1 0x40 3CC9 82 DUP3 3CCA 01 ADD 3CCB 90 SWAP1 3CCC 50 POP 3CCD 91 SWAP2 3CCE 90 SWAP1 3CCF 50 POP 3CD0 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3CA0 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @3CC6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @3CCD stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3CD1: // Incoming call from 0x46A7, returns to 0x46A8 // Inputs[1] { @3CD9 stack[-1] } 3CD1 5B JUMPDEST 3CD2 60 PUSH1 0x00 3CD4 61 PUSH2 0x3cde 3CD7 60 PUSH1 0x1c 3CD9 83 DUP4 3CDA 61 PUSH2 0x4a97 3CDD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3CD2 stack[0] = 0x00 // @3CD4 stack[1] = 0x3cde // @3CD7 stack[2] = 0x1c // @3CD9 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3CDE label_3CDE: // Incoming return from call to 0x4A97 at 0x3CDD // Inputs[4] // { // @3CDF stack[-1] // @3CDF stack[-3] // @3D0B stack[-2] // @3D0D stack[-4] // } 3CDE 5B JUMPDEST 3CDF 91 SWAP2 3CE0 50 POP 3CE1 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 3D02 60 PUSH1 0x00 3D04 83 DUP4 3D05 01 ADD 3D06 52 MSTORE 3D07 60 PUSH1 0x20 3D09 82 DUP3 3D0A 01 ADD 3D0B 90 SWAP1 3D0C 50 POP 3D0D 91 SWAP2 3D0E 90 SWAP1 3D0F 50 POP 3D10 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3D06 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @3D0D stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_3D11: // Incoming call from 0x46C7, returns to 0x46C8 // Inputs[1] { @3D19 stack[-1] } 3D11 5B JUMPDEST 3D12 60 PUSH1 0x00 3D14 61 PUSH2 0x3d1e 3D17 60 PUSH1 0x28 3D19 83 DUP4 3D1A 61 PUSH2 0x4a97 3D1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3D12 stack[0] = 0x00 // @3D14 stack[1] = 0x3d1e // @3D17 stack[2] = 0x28 // @3D19 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3D1E label_3D1E: // Incoming return from call to 0x4A97 at 0x3D1D // Inputs[4] // { // @3D1F stack[-3] // @3D1F stack[-1] // @3D71 stack[-2] // @3D73 stack[-4] // } 3D1E 5B JUMPDEST 3D1F 91 SWAP2 3D20 50 POP 3D21 7F PUSH32 0x4578636565646564206d61782070726573616c65207075726368617365207065 3D42 60 PUSH1 0x00 3D44 83 DUP4 3D45 01 ADD 3D46 52 MSTORE 3D47 7F PUSH32 0x722077616c6c6574000000000000000000000000000000000000000000000000 3D68 60 PUSH1 0x20 3D6A 83 DUP4 3D6B 01 ADD 3D6C 52 MSTORE 3D6D 60 PUSH1 0x40 3D6F 82 DUP3 3D70 01 ADD 3D71 90 SWAP1 3D72 50 POP 3D73 91 SWAP2 3D74 90 SWAP1 3D75 50 POP 3D76 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3D46 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4578636565646564206d61782070726573616c65207075726368617365207065 // @3D6C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x722077616c6c6574000000000000000000000000000000000000000000000000 // @3D73 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3D77: // Incoming call from 0x46E7, returns to 0x46E8 // Inputs[1] { @3D7F stack[-1] } 3D77 5B JUMPDEST 3D78 60 PUSH1 0x00 3D7A 61 PUSH2 0x3d84 3D7D 60 PUSH1 0x26 3D7F 83 DUP4 3D80 61 PUSH2 0x4a97 3D83 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3D78 stack[0] = 0x00 // @3D7A stack[1] = 0x3d84 // @3D7D stack[2] = 0x26 // @3D7F stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3D84 label_3D84: // Incoming return from call to 0x4A97 at 0x3D83 // Inputs[4] // { // @3D85 stack[-1] // @3D85 stack[-3] // @3DD7 stack[-2] // @3DD9 stack[-4] // } 3D84 5B JUMPDEST 3D85 91 SWAP2 3D86 50 POP 3D87 7F PUSH32 0x4578636565646564206d617820746f6b656e2070757263686173652070657220 3DA8 60 PUSH1 0x00 3DAA 83 DUP4 3DAB 01 ADD 3DAC 52 MSTORE 3DAD 7F PUSH32 0x77616c6c65740000000000000000000000000000000000000000000000000000 3DCE 60 PUSH1 0x20 3DD0 83 DUP4 3DD1 01 ADD 3DD2 52 MSTORE 3DD3 60 PUSH1 0x40 3DD5 82 DUP3 3DD6 01 ADD 3DD7 90 SWAP1 3DD8 50 POP 3DD9 91 SWAP2 3DDA 90 SWAP1 3DDB 50 POP 3DDC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3DAC memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4578636565646564206d617820746f6b656e2070757263686173652070657220 // @3DD2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x77616c6c65740000000000000000000000000000000000000000000000000000 // @3DD9 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3DDD: // Incoming call from 0x4707, returns to 0x4708 // Inputs[1] { @3DE5 stack[-1] } 3DDD 5B JUMPDEST 3DDE 60 PUSH1 0x00 3DE0 61 PUSH2 0x3dea 3DE3 60 PUSH1 0x24 3DE5 83 DUP4 3DE6 61 PUSH2 0x4a97 3DE9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3DDE stack[0] = 0x00 // @3DE0 stack[1] = 0x3dea // @3DE3 stack[2] = 0x24 // @3DE5 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3DEA label_3DEA: // Incoming return from call to 0x4A97 at 0x3DE9 // Inputs[4] // { // @3DEB stack[-3] // @3DEB stack[-1] // @3E3D stack[-2] // @3E3F stack[-4] // } 3DEA 5B JUMPDEST 3DEB 91 SWAP2 3DEC 50 POP 3DED 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 3E0E 60 PUSH1 0x00 3E10 83 DUP4 3E11 01 ADD 3E12 52 MSTORE 3E13 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 3E34 60 PUSH1 0x20 3E36 83 DUP4 3E37 01 ADD 3E38 52 MSTORE 3E39 60 PUSH1 0x40 3E3B 82 DUP3 3E3C 01 ADD 3E3D 90 SWAP1 3E3E 50 POP 3E3F 91 SWAP2 3E40 90 SWAP1 3E41 50 POP 3E42 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3E12 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @3E38 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // @3E3F stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3E43: // Incoming call from 0x4727, returns to 0x4728 // Inputs[1] { @3E4B stack[-1] } 3E43 5B JUMPDEST 3E44 60 PUSH1 0x00 3E46 61 PUSH2 0x3e50 3E49 60 PUSH1 0x19 3E4B 83 DUP4 3E4C 61 PUSH2 0x4a97 3E4F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3E44 stack[0] = 0x00 // @3E46 stack[1] = 0x3e50 // @3E49 stack[2] = 0x19 // @3E4B stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3E50 label_3E50: // Incoming return from call to 0x4A97 at 0x3E4F // Inputs[4] // { // @3E51 stack[-3] // @3E51 stack[-1] // @3E7D stack[-2] // @3E7F stack[-4] // } 3E50 5B JUMPDEST 3E51 91 SWAP2 3E52 50 POP 3E53 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 3E74 60 PUSH1 0x00 3E76 83 DUP4 3E77 01 ADD 3E78 52 MSTORE 3E79 60 PUSH1 0x20 3E7B 82 DUP3 3E7C 01 ADD 3E7D 90 SWAP1 3E7E 50 POP 3E7F 91 SWAP2 3E80 90 SWAP1 3E81 50 POP 3E82 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3E78 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @3E7F stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_3E83: // Incoming call from 0x4747, returns to 0x4748 // Inputs[1] { @3E8B stack[-1] } 3E83 5B JUMPDEST 3E84 60 PUSH1 0x00 3E86 61 PUSH2 0x3e90 3E89 60 PUSH1 0x1f 3E8B 83 DUP4 3E8C 61 PUSH2 0x4a97 3E8F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3E84 stack[0] = 0x00 // @3E86 stack[1] = 0x3e90 // @3E89 stack[2] = 0x1f // @3E8B stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3E90 label_3E90: // Incoming return from call to 0x4A97 at 0x3E8F // Inputs[4] // { // @3E91 stack[-1] // @3E91 stack[-3] // @3EBD stack[-2] // @3EBF stack[-4] // } 3E90 5B JUMPDEST 3E91 91 SWAP2 3E92 50 POP 3E93 7F PUSH32 0x45746865722076616c75652073656e74206973206e6f7420636f727265637400 3EB4 60 PUSH1 0x00 3EB6 83 DUP4 3EB7 01 ADD 3EB8 52 MSTORE 3EB9 60 PUSH1 0x20 3EBB 82 DUP3 3EBC 01 ADD 3EBD 90 SWAP1 3EBE 50 POP 3EBF 91 SWAP2 3EC0 90 SWAP1 3EC1 50 POP 3EC2 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3EB8 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x45746865722076616c75652073656e74206973206e6f7420636f727265637400 // @3EBF stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_3EC3: // Incoming call from 0x4767, returns to 0x4768 // Inputs[1] { @3ECB stack[-1] } 3EC3 5B JUMPDEST 3EC4 60 PUSH1 0x00 3EC6 61 PUSH2 0x3ed0 3EC9 60 PUSH1 0x1b 3ECB 83 DUP4 3ECC 61 PUSH2 0x4a97 3ECF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3EC4 stack[0] = 0x00 // @3EC6 stack[1] = 0x3ed0 // @3EC9 stack[2] = 0x1b // @3ECB stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3ED0 label_3ED0: // Incoming return from call to 0x4A97 at 0x3ECF // Inputs[4] // { // @3ED1 stack[-1] // @3ED1 stack[-3] // @3EFD stack[-2] // @3EFF stack[-4] // } 3ED0 5B JUMPDEST 3ED1 91 SWAP2 3ED2 50 POP 3ED3 7F PUSH32 0x53616c65206d7573742062652061637469766520746f206d696e740000000000 3EF4 60 PUSH1 0x00 3EF6 83 DUP4 3EF7 01 ADD 3EF8 52 MSTORE 3EF9 60 PUSH1 0x20 3EFB 82 DUP3 3EFC 01 ADD 3EFD 90 SWAP1 3EFE 50 POP 3EFF 91 SWAP2 3F00 90 SWAP1 3F01 50 POP 3F02 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3EF8 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x53616c65206d7573742062652061637469766520746f206d696e740000000000 // @3EFF stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_3F03: // Incoming call from 0x4787, returns to 0x4788 // Inputs[1] { @3F0B stack[-1] } 3F03 5B JUMPDEST 3F04 60 PUSH1 0x00 3F06 61 PUSH2 0x3f10 3F09 60 PUSH1 0x2c 3F0B 83 DUP4 3F0C 61 PUSH2 0x4a97 3F0F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3F04 stack[0] = 0x00 // @3F06 stack[1] = 0x3f10 // @3F09 stack[2] = 0x2c // @3F0B stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3F10 label_3F10: // Incoming return from call to 0x4A97 at 0x3F0F // Inputs[4] // { // @3F11 stack[-1] // @3F11 stack[-3] // @3F63 stack[-2] // @3F65 stack[-4] // } 3F10 5B JUMPDEST 3F11 91 SWAP2 3F12 50 POP 3F13 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 3F34 60 PUSH1 0x00 3F36 83 DUP4 3F37 01 ADD 3F38 52 MSTORE 3F39 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 3F5A 60 PUSH1 0x20 3F5C 83 DUP4 3F5D 01 ADD 3F5E 52 MSTORE 3F5F 60 PUSH1 0x40 3F61 82 DUP3 3F62 01 ADD 3F63 90 SWAP1 3F64 50 POP 3F65 91 SWAP2 3F66 90 SWAP1 3F67 50 POP 3F68 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3F38 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @3F5E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @3F65 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3F69: // Incoming call from 0x47A7, returns to 0x47A8 // Inputs[1] { @3F71 stack[-1] } 3F69 5B JUMPDEST 3F6A 60 PUSH1 0x00 3F6C 61 PUSH2 0x3f76 3F6F 60 PUSH1 0x27 3F71 83 DUP4 3F72 61 PUSH2 0x4a97 3F75 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3F6A stack[0] = 0x00 // @3F6C stack[1] = 0x3f76 // @3F6F stack[2] = 0x27 // @3F71 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3F76 label_3F76: // Incoming return from call to 0x4A97 at 0x3F75 // Inputs[4] // { // @3F77 stack[-1] // @3F77 stack[-3] // @3FC9 stack[-2] // @3FCB stack[-4] // } 3F76 5B JUMPDEST 3F77 91 SWAP2 3F78 50 POP 3F79 7F PUSH32 0x436f756c64206e6f74207072652d6d696e742061667465722073616c65206973 3F9A 60 PUSH1 0x00 3F9C 83 DUP4 3F9D 01 ADD 3F9E 52 MSTORE 3F9F 7F PUSH32 0x2061637469766500000000000000000000000000000000000000000000000000 3FC0 60 PUSH1 0x20 3FC2 83 DUP4 3FC3 01 ADD 3FC4 52 MSTORE 3FC5 60 PUSH1 0x40 3FC7 82 DUP3 3FC8 01 ADD 3FC9 90 SWAP1 3FCA 50 POP 3FCB 91 SWAP2 3FCC 90 SWAP1 3FCD 50 POP 3FCE 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3F9E memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x436f756c64206e6f74207072652d6d696e742061667465722073616c65206973 // @3FC4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2061637469766500000000000000000000000000000000000000000000000000 // @3FCB stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_3FCF: // Incoming call from 0x47C7, returns to 0x47C8 // Inputs[1] { @3FD7 stack[-1] } 3FCF 5B JUMPDEST 3FD0 60 PUSH1 0x00 3FD2 61 PUSH2 0x3fdc 3FD5 60 PUSH1 0x38 3FD7 83 DUP4 3FD8 61 PUSH2 0x4a97 3FDB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3FD0 stack[0] = 0x00 // @3FD2 stack[1] = 0x3fdc // @3FD5 stack[2] = 0x38 // @3FD7 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x3FDC label_3FDC: // Incoming return from call to 0x4A97 at 0x3FDB // Inputs[4] // { // @3FDD stack[-3] // @3FDD stack[-1] // @402F stack[-2] // @4031 stack[-4] // } 3FDC 5B JUMPDEST 3FDD 91 SWAP2 3FDE 50 POP 3FDF 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 4000 60 PUSH1 0x00 4002 83 DUP4 4003 01 ADD 4004 52 MSTORE 4005 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 4026 60 PUSH1 0x20 4028 83 DUP4 4029 01 ADD 402A 52 MSTORE 402B 60 PUSH1 0x40 402D 82 DUP3 402E 01 ADD 402F 90 SWAP1 4030 50 POP 4031 91 SWAP2 4032 90 SWAP1 4033 50 POP 4034 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @4004 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @402A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @4031 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_4035: // Incoming call from 0x47E7, returns to 0x47E8 // Inputs[1] { @403D stack[-1] } 4035 5B JUMPDEST 4036 60 PUSH1 0x00 4038 61 PUSH2 0x4042 403B 60 PUSH1 0x2a 403D 83 DUP4 403E 61 PUSH2 0x4a97 4041 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4036 stack[0] = 0x00 // @4038 stack[1] = 0x4042 // @403B stack[2] = 0x2a // @403D stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x4042 label_4042: // Incoming return from call to 0x4A97 at 0x4041 // Inputs[4] // { // @4043 stack[-1] // @4043 stack[-3] // @4095 stack[-2] // @4097 stack[-4] // } 4042 5B JUMPDEST 4043 91 SWAP2 4044 50 POP 4045 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 4066 60 PUSH1 0x00 4068 83 DUP4 4069 01 ADD 406A 52 MSTORE 406B 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 408C 60 PUSH1 0x20 408E 83 DUP4 408F 01 ADD 4090 52 MSTORE 4091 60 PUSH1 0x40 4093 82 DUP3 4094 01 ADD 4095 90 SWAP1 4096 50 POP 4097 91 SWAP2 4098 90 SWAP1 4099 50 POP 409A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @406A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @4090 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // @4097 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_409B: // Incoming call from 0x4807, returns to 0x4808 // Inputs[1] { @40A3 stack[-1] } 409B 5B JUMPDEST 409C 60 PUSH1 0x00 409E 61 PUSH2 0x40a8 40A1 60 PUSH1 0x29 40A3 83 DUP4 40A4 61 PUSH2 0x4a97 40A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @409C stack[0] = 0x00 // @409E stack[1] = 0x40a8 // @40A1 stack[2] = 0x29 // @40A3 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x40A8 label_40A8: // Incoming return from call to 0x4A97 at 0x40A7 // Inputs[4] // { // @40A9 stack[-3] // @40A9 stack[-1] // @40FB stack[-2] // @40FD stack[-4] // } 40A8 5B JUMPDEST 40A9 91 SWAP2 40AA 50 POP 40AB 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 40CC 60 PUSH1 0x00 40CE 83 DUP4 40CF 01 ADD 40D0 52 MSTORE 40D1 7F PUSH32 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 40F2 60 PUSH1 0x20 40F4 83 DUP4 40F5 01 ADD 40F6 52 MSTORE 40F7 60 PUSH1 0x40 40F9 82 DUP3 40FA 01 ADD 40FB 90 SWAP1 40FC 50 POP 40FD 91 SWAP2 40FE 90 SWAP1 40FF 50 POP 4100 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @40D0 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @40F6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 // @40FD stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_4101: // Incoming call from 0x4827, returns to 0x4828 // Inputs[1] { @4109 stack[-1] } 4101 5B JUMPDEST 4102 60 PUSH1 0x00 4104 61 PUSH2 0x410e 4107 60 PUSH1 0x20 4109 83 DUP4 410A 61 PUSH2 0x4a97 410D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4102 stack[0] = 0x00 // @4104 stack[1] = 0x410e // @4107 stack[2] = 0x20 // @4109 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x410E label_410E: // Incoming return from call to 0x4A97 at 0x410D // Inputs[4] // { // @410F stack[-1] // @410F stack[-3] // @413B stack[-2] // @413D stack[-4] // } 410E 5B JUMPDEST 410F 91 SWAP2 4110 50 POP 4111 7F PUSH32 0x507572636861736520776f756c6420657863656564206d617820737570706c79 4132 60 PUSH1 0x00 4134 83 DUP4 4135 01 ADD 4136 52 MSTORE 4137 60 PUSH1 0x20 4139 82 DUP3 413A 01 ADD 413B 90 SWAP1 413C 50 POP 413D 91 SWAP2 413E 90 SWAP1 413F 50 POP 4140 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @4136 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x507572636861736520776f756c6420657863656564206d617820737570706c79 // @413D stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_4141: // Incoming call from 0x4847, returns to 0x4848 // Inputs[1] { @4149 stack[-1] } 4141 5B JUMPDEST 4142 60 PUSH1 0x00 4144 61 PUSH2 0x414e 4147 60 PUSH1 0x20 4149 83 DUP4 414A 61 PUSH2 0x4a97 414D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4142 stack[0] = 0x00 // @4144 stack[1] = 0x414e // @4147 stack[2] = 0x20 // @4149 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x414E label_414E: // Incoming return from call to 0x4A97 at 0x414D // Inputs[4] // { // @414F stack[-3] // @414F stack[-1] // @417B stack[-2] // @417D stack[-4] // } 414E 5B JUMPDEST 414F 91 SWAP2 4150 50 POP 4151 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 4172 60 PUSH1 0x00 4174 83 DUP4 4175 01 ADD 4176 52 MSTORE 4177 60 PUSH1 0x20 4179 82 DUP3 417A 01 ADD 417B 90 SWAP1 417C 50 POP 417D 91 SWAP2 417E 90 SWAP1 417F 50 POP 4180 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @4176 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @417D stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_4181: // Incoming call from 0x4867, returns to 0x4868 // Inputs[1] { @4189 stack[-1] } 4181 5B JUMPDEST 4182 60 PUSH1 0x00 4184 61 PUSH2 0x418e 4187 60 PUSH1 0x1d 4189 83 DUP4 418A 61 PUSH2 0x4a97 418D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4182 stack[0] = 0x00 // @4184 stack[1] = 0x418e // @4187 stack[2] = 0x1d // @4189 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x418E label_418E: // Incoming return from call to 0x4A97 at 0x418D // Inputs[4] // { // @418F stack[-1] // @418F stack[-3] // @41BB stack[-2] // @41BD stack[-4] // } 418E 5B JUMPDEST 418F 91 SWAP2 4190 50 POP 4191 7F PUSH32 0x4578636565646564206d61782070726573616c65207075726368617365000000 41B2 60 PUSH1 0x00 41B4 83 DUP4 41B5 01 ADD 41B6 52 MSTORE 41B7 60 PUSH1 0x20 41B9 82 DUP3 41BA 01 ADD 41BB 90 SWAP1 41BC 50 POP 41BD 91 SWAP2 41BE 90 SWAP1 41BF 50 POP 41C0 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @41B6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4578636565646564206d61782070726573616c65207075726368617365000000 // @41BD stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_41C1: // Incoming call from 0x4887, returns to 0x4888 // Inputs[1] { @41C9 stack[-1] } 41C1 5B JUMPDEST 41C2 60 PUSH1 0x00 41C4 61 PUSH2 0x41ce 41C7 60 PUSH1 0x2c 41C9 83 DUP4 41CA 61 PUSH2 0x4a97 41CD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @41C2 stack[0] = 0x00 // @41C4 stack[1] = 0x41ce // @41C7 stack[2] = 0x2c // @41C9 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x41CE label_41CE: // Incoming return from call to 0x4A97 at 0x41CD // Inputs[4] // { // @41CF stack[-3] // @41CF stack[-1] // @4221 stack[-2] // @4223 stack[-4] // } 41CE 5B JUMPDEST 41CF 91 SWAP2 41D0 50 POP 41D1 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 41F2 60 PUSH1 0x00 41F4 83 DUP4 41F5 01 ADD 41F6 52 MSTORE 41F7 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 4218 60 PUSH1 0x20 421A 83 DUP4 421B 01 ADD 421C 52 MSTORE 421D 60 PUSH1 0x40 421F 82 DUP3 4220 01 ADD 4221 90 SWAP1 4222 50 POP 4223 91 SWAP2 4224 90 SWAP1 4225 50 POP 4226 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @41F6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @421C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @4223 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_4227: // Incoming call from 0x48A7, returns to 0x48A8 // Inputs[1] { @422F stack[-1] } 4227 5B JUMPDEST 4228 60 PUSH1 0x00 422A 61 PUSH2 0x4234 422D 60 PUSH1 0x20 422F 83 DUP4 4230 61 PUSH2 0x4a97 4233 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4228 stack[0] = 0x00 // @422A stack[1] = 0x4234 // @422D stack[2] = 0x20 // @422F stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x4234 label_4234: // Incoming return from call to 0x4A97 at 0x4233 // Inputs[4] // { // @4235 stack[-1] // @4235 stack[-3] // @4261 stack[-2] // @4263 stack[-4] // } 4234 5B JUMPDEST 4235 91 SWAP2 4236 50 POP 4237 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 4258 60 PUSH1 0x00 425A 83 DUP4 425B 01 ADD 425C 52 MSTORE 425D 60 PUSH1 0x20 425F 82 DUP3 4260 01 ADD 4261 90 SWAP1 4262 50 POP 4263 91 SWAP2 4264 90 SWAP1 4265 50 POP 4266 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @425C memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @4263 stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_4267: // Incoming call from 0x48C7, returns to 0x48C8 // Inputs[1] { @426F stack[-1] } 4267 5B JUMPDEST 4268 60 PUSH1 0x00 426A 61 PUSH2 0x4274 426D 60 PUSH1 0x3a 426F 83 DUP4 4270 61 PUSH2 0x4a97 4273 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4268 stack[0] = 0x00 // @426A stack[1] = 0x4274 // @426D stack[2] = 0x3a // @426F stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x4274 label_4274: // Incoming return from call to 0x4A97 at 0x4273 // Inputs[4] // { // @4275 stack[-3] // @4275 stack[-1] // @42C7 stack[-2] // @42C9 stack[-4] // } 4274 5B JUMPDEST 4275 91 SWAP2 4276 50 POP 4277 7F PUSH32 0x4d6f7265207468616e2031303020746f6b656e73206861766520616c72656164 4298 60 PUSH1 0x00 429A 83 DUP4 429B 01 ADD 429C 52 MSTORE 429D 7F PUSH32 0x79206265656e207265736572766564206f72206d696e7465642e000000000000 42BE 60 PUSH1 0x20 42C0 83 DUP4 42C1 01 ADD 42C2 52 MSTORE 42C3 60 PUSH1 0x40 42C5 82 DUP3 42C6 01 ADD 42C7 90 SWAP1 42C8 50 POP 42C9 91 SWAP2 42CA 90 SWAP1 42CB 50 POP 42CC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @429C memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4d6f7265207468616e2031303020746f6b656e73206861766520616c72656164 // @42C2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x79206265656e207265736572766564206f72206d696e7465642e000000000000 // @42C9 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_42CD: // Incoming call from 0x48E7, returns to 0x48E8 // Inputs[1] { @42D5 stack[-1] } 42CD 5B JUMPDEST 42CE 60 PUSH1 0x00 42D0 61 PUSH2 0x42da 42D3 60 PUSH1 0x29 42D5 83 DUP4 42D6 61 PUSH2 0x4a97 42D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @42CE stack[0] = 0x00 // @42D0 stack[1] = 0x42da // @42D3 stack[2] = 0x29 // @42D5 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x42DA label_42DA: // Incoming return from call to 0x4A97 at 0x42D9 // Inputs[4] // { // @42DB stack[-3] // @42DB stack[-1] // @432D stack[-2] // @432F stack[-4] // } 42DA 5B JUMPDEST 42DB 91 SWAP2 42DC 50 POP 42DD 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 42FE 60 PUSH1 0x00 4300 83 DUP4 4301 01 ADD 4302 52 MSTORE 4303 7F PUSH32 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 4324 60 PUSH1 0x20 4326 83 DUP4 4327 01 ADD 4328 52 MSTORE 4329 60 PUSH1 0x40 432B 82 DUP3 432C 01 ADD 432D 90 SWAP1 432E 50 POP 432F 91 SWAP2 4330 90 SWAP1 4331 50 POP 4332 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @4302 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @4328 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 // @432F stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_4333: // Incoming call from 0x4907, returns to 0x4908 // Inputs[1] { @433B stack[-1] } 4333 5B JUMPDEST 4334 60 PUSH1 0x00 4336 61 PUSH2 0x4340 4339 60 PUSH1 0x2f 433B 83 DUP4 433C 61 PUSH2 0x4a97 433F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4334 stack[0] = 0x00 // @4336 stack[1] = 0x4340 // @4339 stack[2] = 0x2f // @433B stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x4340 label_4340: // Incoming return from call to 0x4A97 at 0x433F // Inputs[4] // { // @4341 stack[-3] // @4341 stack[-1] // @4393 stack[-2] // @4395 stack[-4] // } 4340 5B JUMPDEST 4341 91 SWAP2 4342 50 POP 4343 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 4364 60 PUSH1 0x00 4366 83 DUP4 4367 01 ADD 4368 52 MSTORE 4369 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 438A 60 PUSH1 0x20 438C 83 DUP4 438D 01 ADD 438E 52 MSTORE 438F 60 PUSH1 0x40 4391 82 DUP3 4392 01 ADD 4393 90 SWAP1 4394 50 POP 4395 91 SWAP2 4396 90 SWAP1 4397 50 POP 4398 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @4368 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @438E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 // @4395 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_4399: // Incoming call from 0x4927, returns to 0x4928 // Inputs[1] { @43A1 stack[-1] } 4399 5B JUMPDEST 439A 60 PUSH1 0x00 439C 61 PUSH2 0x43a6 439F 60 PUSH1 0x21 43A1 83 DUP4 43A2 61 PUSH2 0x4a97 43A5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @439A stack[0] = 0x00 // @439C stack[1] = 0x43a6 // @439F stack[2] = 0x21 // @43A1 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x43A6 label_43A6: // Incoming return from call to 0x4A97 at 0x43A5 // Inputs[4] // { // @43A7 stack[-1] // @43A7 stack[-3] // @43F9 stack[-2] // @43FB stack[-4] // } 43A6 5B JUMPDEST 43A7 91 SWAP2 43A8 50 POP 43A9 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 43CA 60 PUSH1 0x00 43CC 83 DUP4 43CD 01 ADD 43CE 52 MSTORE 43CF 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 43F0 60 PUSH1 0x20 43F2 83 DUP4 43F3 01 ADD 43F4 52 MSTORE 43F5 60 PUSH1 0x40 43F7 82 DUP3 43F8 01 ADD 43F9 90 SWAP1 43FA 50 POP 43FB 91 SWAP2 43FC 90 SWAP1 43FD 50 POP 43FE 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @43CE memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @43F4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000 // @43FB stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_43FF: // Incoming call from 0x4947, returns to 0x4948 // Inputs[1] { @4407 stack[-1] } 43FF 5B JUMPDEST 4400 60 PUSH1 0x00 4402 61 PUSH2 0x440c 4405 60 PUSH1 0x1b 4407 83 DUP4 4408 61 PUSH2 0x4a97 440B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4400 stack[0] = 0x00 // @4402 stack[1] = 0x440c // @4405 stack[2] = 0x1b // @4407 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x440C label_440C: // Incoming return from call to 0x4A97 at 0x440B // Inputs[4] // { // @440D stack[-1] // @440D stack[-3] // @4439 stack[-2] // @443B stack[-4] // } 440C 5B JUMPDEST 440D 91 SWAP2 440E 50 POP 440F 7F PUSH32 0x4578636565646564206d617820746f6b656e2070757263686173650000000000 4430 60 PUSH1 0x00 4432 83 DUP4 4433 01 ADD 4434 52 MSTORE 4435 60 PUSH1 0x20 4437 82 DUP3 4438 01 ADD 4439 90 SWAP1 443A 50 POP 443B 91 SWAP2 443C 90 SWAP1 443D 50 POP 443E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @4434 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4578636565646564206d617820746f6b656e2070757263686173650000000000 // @443B stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_443F: // Incoming call from 0x4967, returns to 0x4968 // Inputs[1] { @4447 stack[-1] } 443F 5B JUMPDEST 4440 60 PUSH1 0x00 4442 61 PUSH2 0x444c 4445 60 PUSH1 0x1e 4447 83 DUP4 4448 61 PUSH2 0x4a97 444B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4440 stack[0] = 0x00 // @4442 stack[1] = 0x444c // @4445 stack[2] = 0x1e // @4447 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x444C label_444C: // Incoming return from call to 0x4A97 at 0x444B // Inputs[4] // { // @444D stack[-3] // @444D stack[-1] // @4479 stack[-2] // @447B stack[-4] // } 444C 5B JUMPDEST 444D 91 SWAP2 444E 50 POP 444F 7F PUSH32 0x50726553616c65206d7573742062652061637469766520746f206d696e740000 4470 60 PUSH1 0x00 4472 83 DUP4 4473 01 ADD 4474 52 MSTORE 4475 60 PUSH1 0x20 4477 82 DUP3 4478 01 ADD 4479 90 SWAP1 447A 50 POP 447B 91 SWAP2 447C 90 SWAP1 447D 50 POP 447E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @4474 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x50726553616c65206d7573742062652061637469766520746f206d696e740000 // @447B stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_447F: // Incoming call from 0x4987, returns to 0x4988 // Inputs[1] { @4487 stack[-1] } 447F 5B JUMPDEST 4480 60 PUSH1 0x00 4482 61 PUSH2 0x448c 4485 60 PUSH1 0x31 4487 83 DUP4 4488 61 PUSH2 0x4a97 448B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4480 stack[0] = 0x00 // @4482 stack[1] = 0x448c // @4485 stack[2] = 0x31 // @4487 stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x448C label_448C: // Incoming return from call to 0x4A97 at 0x448B // Inputs[4] // { // @448D stack[-1] // @448D stack[-3] // @44DF stack[-2] // @44E1 stack[-4] // } 448C 5B JUMPDEST 448D 91 SWAP2 448E 50 POP 448F 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 44B0 60 PUSH1 0x00 44B2 83 DUP4 44B3 01 ADD 44B4 52 MSTORE 44B5 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 44D6 60 PUSH1 0x20 44D8 83 DUP4 44D9 01 ADD 44DA 52 MSTORE 44DB 60 PUSH1 0x40 44DD 82 DUP3 44DE 01 ADD 44DF 90 SWAP1 44E0 50 POP 44E1 91 SWAP2 44E2 90 SWAP1 44E3 50 POP 44E4 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @44B4 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @44DA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @44E1 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_44E5: // Incoming call from 0x49A7, returns to 0x49A8 // Inputs[1] { @44ED stack[-1] } 44E5 5B JUMPDEST 44E6 60 PUSH1 0x00 44E8 61 PUSH2 0x44f2 44EB 60 PUSH1 0x2c 44ED 83 DUP4 44EE 61 PUSH2 0x4a97 44F1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @44E6 stack[0] = 0x00 // @44E8 stack[1] = 0x44f2 // @44EB stack[2] = 0x2c // @44ED stack[3] = stack[-1] // } // Block ends with call to 0x4a97, returns to 0x44F2 label_44F2: // Incoming return from call to 0x4A97 at 0x44F1 // Inputs[4] // { // @44F3 stack[-3] // @44F3 stack[-1] // @4545 stack[-2] // @4547 stack[-4] // } 44F2 5B JUMPDEST 44F3 91 SWAP2 44F4 50 POP 44F5 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 4516 60 PUSH1 0x00 4518 83 DUP4 4519 01 ADD 451A 52 MSTORE 451B 7F PUSH32 0x7574206f6620626f756e64730000000000000000000000000000000000000000 453C 60 PUSH1 0x20 453E 83 DUP4 453F 01 ADD 4540 52 MSTORE 4541 60 PUSH1 0x40 4543 82 DUP3 4544 01 ADD 4545 90 SWAP1 4546 50 POP 4547 91 SWAP2 4548 90 SWAP1 4549 50 POP 454A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @451A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @4540 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7574206f6620626f756e64730000000000000000000000000000000000000000 // @4547 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_454B: // Incoming call from 0x45D4, returns to 0x45D5 // Incoming call from 0x49C3, returns to 0x49C4 // Inputs[1] { @454F stack[-1] } 454B 5B JUMPDEST 454C 61 PUSH2 0x4554 454F 81 DUP2 4550 61 PUSH2 0x4c32 4553 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @454C stack[0] = 0x4554 // @454F stack[1] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4554 label_4554: // Incoming return from call to 0x4C32 at 0x4553 // Inputs[3] // { // @4555 stack[-3] // @4556 stack[-1] // @4559 stack[-4] // } 4554 5B JUMPDEST 4555 82 DUP3 4556 52 MSTORE 4557 50 POP 4558 50 POP 4559 56 *JUMP // Stack delta = -4 // Outputs[1] { @4556 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_455A: // Incoming call from 0x2068, returns to 0x2069 // Inputs[2] // { // @4560 stack[-1] // @4561 stack[-4] // } 455A 5B JUMPDEST 455B 60 PUSH1 0x00 455D 61 PUSH2 0x4566 4560 82 DUP3 4561 86 DUP7 4562 61 PUSH2 0x3aef 4565 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @455B stack[0] = 0x00 // @455D stack[1] = 0x4566 // @4560 stack[2] = stack[-1] // @4561 stack[3] = stack[-4] // } // Block ends with call to 0x3aef, returns to 0x4566 label_4566: // Incoming return from call to 0x3AEF at 0x4565 // Inputs[3] // { // @4567 stack[-3] // @4567 stack[-1] // @456D stack[-5] // } 4566 5B JUMPDEST 4567 91 SWAP2 4568 50 POP 4569 61 PUSH2 0x4572 456C 82 DUP3 456D 85 DUP6 456E 61 PUSH2 0x3aef 4571 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @4567 stack[-3] = stack[-1] // @4569 stack[-1] = 0x4572 // @456C stack[0] = stack[-1] // @456D stack[1] = stack[-5] // } // Block ends with call to 0x3aef, returns to 0x4572 label_4572: // Incoming return from call to 0x3AEF at 0x4571 // Inputs[3] // { // @4573 stack[-3] // @4573 stack[-1] // @4579 stack[-4] // } 4572 5B JUMPDEST 4573 91 SWAP2 4574 50 POP 4575 61 PUSH2 0x457e 4578 82 DUP3 4579 84 DUP5 457A 61 PUSH2 0x3b20 457D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @4573 stack[-3] = stack[-1] // @4575 stack[-1] = 0x457e // @4578 stack[0] = stack[-1] // @4579 stack[1] = stack[-4] // } // Block ends with call to 0x3b20, returns to 0x457E label_457E: // Incoming return from call to 0x3B20 at 0x457D // Inputs[5] // { // @457F stack[-1] // @457F stack[-3] // @4582 stack[-2] // @4584 stack[-7] // @4585 stack[-6] // } 457E 5B JUMPDEST 457F 91 SWAP2 4580 50 POP 4581 81 DUP2 4582 90 SWAP1 4583 50 POP 4584 94 SWAP5 4585 93 SWAP4 4586 50 POP 4587 50 POP 4588 50 POP 4589 50 POP 458A 56 *JUMP // Stack delta = -6 // Outputs[1] { @4584 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_458B: // Incoming call from 0x0F46, returns to 0x0F47 // Incoming call from 0x1B86, returns to 0x1B87 // Incoming call from 0x0591, returns to 0x0592 // Incoming call from 0x06AD, returns to 0x06AE // Incoming call from 0x02F1, returns to 0x02F2 // Inputs[2] // { // @4590 stack[-1] // @459B stack[-2] // } 458B 5B JUMPDEST 458C 60 PUSH1 0x00 458E 60 PUSH1 0x20 4590 82 DUP3 4591 01 ADD 4592 90 SWAP1 4593 50 POP 4594 61 PUSH2 0x45a0 4597 60 PUSH1 0x00 4599 83 DUP4 459A 01 ADD 459B 84 DUP5 459C 61 PUSH2 0x3a5f 459F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @4592 stack[0] = stack[-1] + 0x20 // @4594 stack[1] = 0x45a0 // @459A stack[2] = stack[-1] + 0x00 // @459B stack[3] = stack[-2] // } // Block ends with call to 0x3a5f, returns to 0x45A0 label_45A0: // Incoming return from call to 0x3A5F at 0x459F // Inputs[3] // { // @45A1 stack[-4] // @45A1 stack[-1] // @45A2 stack[-3] // } 45A0 5B JUMPDEST 45A1 92 SWAP3 45A2 91 SWAP2 45A3 50 POP 45A4 50 POP 45A5 56 *JUMP // Stack delta = -3 // Outputs[1] { @45A1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_45A6: // Incoming call from 0x2E18, returns to 0x2E19 // Inputs[2] // { // @45AB stack[-1] // @45B6 stack[-5] // } 45A6 5B JUMPDEST 45A7 60 PUSH1 0x00 45A9 60 PUSH1 0x80 45AB 82 DUP3 45AC 01 ADD 45AD 90 SWAP1 45AE 50 POP 45AF 61 PUSH2 0x45bb 45B2 60 PUSH1 0x00 45B4 83 DUP4 45B5 01 ADD 45B6 87 DUP8 45B7 61 PUSH2 0x3a5f 45BA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @45AD stack[0] = stack[-1] + 0x80 // @45AF stack[1] = 0x45bb // @45B5 stack[2] = stack[-1] + 0x00 // @45B6 stack[3] = stack[-5] // } // Block ends with call to 0x3a5f, returns to 0x45BB label_45BB: // Incoming return from call to 0x3A5F at 0x45BA // Inputs[2] // { // @45C1 stack[-2] // @45C3 stack[-5] // } 45BB 5B JUMPDEST 45BC 61 PUSH2 0x45c8 45BF 60 PUSH1 0x20 45C1 83 DUP4 45C2 01 ADD 45C3 86 DUP7 45C4 61 PUSH2 0x3a5f 45C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @45BC stack[0] = 0x45c8 // @45C2 stack[1] = stack[-2] + 0x20 // @45C3 stack[2] = stack[-5] // } // Block ends with call to 0x3a5f, returns to 0x45C8 label_45C8: // Incoming return from call to 0x3A5F at 0x45C7 // Inputs[2] // { // @45CE stack[-2] // @45D0 stack[-4] // } 45C8 5B JUMPDEST 45C9 61 PUSH2 0x45d5 45CC 60 PUSH1 0x40 45CE 83 DUP4 45CF 01 ADD 45D0 85 DUP6 45D1 61 PUSH2 0x454b 45D4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @45C9 stack[0] = 0x45d5 // @45CF stack[1] = stack[-2] + 0x40 // @45D0 stack[2] = stack[-4] // } // Block ends with call to 0x454b, returns to 0x45D5 label_45D5: // Incoming return from call to 0x454B at 0x45D4 // Inputs[3] // { // @45D6 stack[-2] // @45D7 stack[-1] // @45E2 stack[-3] // } 45D5 5B JUMPDEST 45D6 81 DUP2 45D7 81 DUP2 45D8 03 SUB 45D9 60 PUSH1 0x60 45DB 83 DUP4 45DC 01 ADD 45DD 52 MSTORE 45DE 61 PUSH2 0x45e7 45E1 81 DUP2 45E2 84 DUP5 45E3 61 PUSH2 0x3a7d 45E6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @45DD memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = stack[-1] - stack[-2] // @45DE stack[0] = 0x45e7 // @45E1 stack[1] = stack[-1] // @45E2 stack[2] = stack[-3] // } // Block ends with call to 0x3a7d, returns to 0x45E7 label_45E7: // Incoming return from call to 0x3A7D at 0x45E6 // Inputs[4] // { // @45E8 stack[-1] // @45E8 stack[-2] // @45EA stack[-8] // @45EB stack[-7] // } 45E7 5B JUMPDEST 45E8 90 SWAP1 45E9 50 POP 45EA 95 SWAP6 45EB 94 SWAP5 45EC 50 POP 45ED 50 POP 45EE 50 POP 45EF 50 POP 45F0 50 POP 45F1 56 *JUMP // Stack delta = -7 // Outputs[1] { @45EA stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_45F2: // Incoming call from 0x052B, returns to 0x052C // Incoming call from 0x03C6, returns to 0x03C7 // Incoming call from 0x19DE, returns to 0x19DF // Incoming call from 0x0856, returns to 0x0857 // Incoming call from 0x0289, returns to 0x028A // Incoming call from 0x082B, returns to 0x082C // Inputs[2] // { // @45F7 stack[-1] // @4602 stack[-2] // } 45F2 5B JUMPDEST 45F3 60 PUSH1 0x00 45F5 60 PUSH1 0x20 45F7 82 DUP3 45F8 01 ADD 45F9 90 SWAP1 45FA 50 POP 45FB 61 PUSH2 0x4607 45FE 60 PUSH1 0x00 4600 83 DUP4 4601 01 ADD 4602 84 DUP5 4603 61 PUSH2 0x3a6e 4606 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @45F9 stack[0] = stack[-1] + 0x20 // @45FB stack[1] = 0x4607 // @4601 stack[2] = stack[-1] + 0x00 // @4602 stack[3] = stack[-2] // } // Block ends with call to 0x3a6e, returns to 0x4607 label_4607: // Incoming return from call to 0x3A6E at 0x4606 // Inputs[3] // { // @4608 stack[-4] // @4608 stack[-1] // @4609 stack[-3] // } 4607 5B JUMPDEST 4608 92 SWAP3 4609 91 SWAP2 460A 50 POP 460B 50 POP 460C 56 *JUMP // Stack delta = -3 // Outputs[1] { @4608 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_460D: // Incoming call from 0x031C, returns to 0x031D // Incoming call from 0x07EE, returns to 0x07EF // Incoming call from 0x05BC, returns to 0x05BD // Incoming call from 0x02B4, returns to 0x02B5 // Incoming call from 0x06D8, returns to 0x06D9 // Incoming call from 0x07B1, returns to 0x07B2 // Inputs[2] // { // @4612 stack[-1] // @4622 stack[-2] // } 460D 5B JUMPDEST 460E 60 PUSH1 0x00 4610 60 PUSH1 0x20 4612 82 DUP3 4613 01 ADD 4614 90 SWAP1 4615 50 POP 4616 81 DUP2 4617 81 DUP2 4618 03 SUB 4619 60 PUSH1 0x00 461B 83 DUP4 461C 01 ADD 461D 52 MSTORE 461E 61 PUSH2 0x4627 4621 81 DUP2 4622 84 DUP5 4623 61 PUSH2 0x3ab6 4626 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @4614 stack[0] = stack[-1] + 0x20 // @461D memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @461E stack[1] = 0x4627 // @4621 stack[2] = stack[-1] + 0x20 // @4622 stack[3] = stack[-2] // } // Block ends with call to 0x3ab6, returns to 0x4627 label_4627: // Incoming return from call to 0x3AB6 at 0x4626 // Inputs[4] // { // @4628 stack[-2] // @4628 stack[-1] // @462A stack[-5] // @462B stack[-4] // } 4627 5B JUMPDEST 4628 90 SWAP1 4629 50 POP 462A 92 SWAP3 462B 91 SWAP2 462C 50 POP 462D 50 POP 462E 56 *JUMP // Stack delta = -4 // Outputs[1] { @462A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_462F: // Incoming call from 0x0DE1, returns to 0x0DE2 // Inputs[1] { @4634 stack[-1] } 462F 5B JUMPDEST 4630 60 PUSH1 0x00 4632 60 PUSH1 0x20 4634 82 DUP3 4635 01 ADD 4636 90 SWAP1 4637 50 POP 4638 81 DUP2 4639 81 DUP2 463A 03 SUB 463B 60 PUSH1 0x00 463D 83 DUP4 463E 01 ADD 463F 52 MSTORE 4640 61 PUSH2 0x4648 4643 81 DUP2 4644 61 PUSH2 0x3b9f 4647 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4636 stack[0] = stack[-1] + 0x20 // @463F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4640 stack[1] = 0x4648 // @4643 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3b9f, returns to 0x4648 label_4648: // Incoming return from call to 0x3B9F at 0x4647 // Inputs[4] // { // @4649 stack[-1] // @4649 stack[-2] // @464B stack[-4] // @464C stack[-3] // } 4648 5B JUMPDEST 4649 90 SWAP1 464A 50 POP 464B 91 SWAP2 464C 90 SWAP1 464D 50 POP 464E 56 *JUMP // Stack delta = -3 // Outputs[1] { @464B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_464F: // Incoming call from 0x2ED5, returns to 0x2ED6 // Incoming call from 0x2D9E, returns to 0x2D9F // Incoming call from 0x2A11, returns to 0x2A12 // Inputs[1] { @4654 stack[-1] } 464F 5B JUMPDEST 4650 60 PUSH1 0x00 4652 60 PUSH1 0x20 4654 82 DUP3 4655 01 ADD 4656 90 SWAP1 4657 50 POP 4658 81 DUP2 4659 81 DUP2 465A 03 SUB 465B 60 PUSH1 0x00 465D 83 DUP4 465E 01 ADD 465F 52 MSTORE 4660 61 PUSH2 0x4668 4663 81 DUP2 4664 61 PUSH2 0x3c05 4667 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4656 stack[0] = stack[-1] + 0x20 // @465F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4660 stack[1] = 0x4668 // @4663 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3c05, returns to 0x4668 label_4668: // Incoming return from call to 0x3C05 at 0x4667 // Inputs[4] // { // @4669 stack[-2] // @4669 stack[-1] // @466B stack[-4] // @466C stack[-3] // } 4668 5B JUMPDEST 4669 90 SWAP1 466A 50 POP 466B 91 SWAP2 466C 90 SWAP1 466D 50 POP 466E 56 *JUMP // Stack delta = -3 // Outputs[1] { @466B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_466F: // Incoming call from 0x234E, returns to 0x234F // Inputs[1] { @4674 stack[-1] } 466F 5B JUMPDEST 4670 60 PUSH1 0x00 4672 60 PUSH1 0x20 4674 82 DUP3 4675 01 ADD 4676 90 SWAP1 4677 50 POP 4678 81 DUP2 4679 81 DUP2 467A 03 SUB 467B 60 PUSH1 0x00 467D 83 DUP4 467E 01 ADD 467F 52 MSTORE 4680 61 PUSH2 0x4688 4683 81 DUP2 4684 61 PUSH2 0x3c6b 4687 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4676 stack[0] = stack[-1] + 0x20 // @467F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4680 stack[1] = 0x4688 // @4683 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3c6b, returns to 0x4688 label_4688: // Incoming return from call to 0x3C6B at 0x4687 // Inputs[4] // { // @4689 stack[-1] // @4689 stack[-2] // @468B stack[-4] // @468C stack[-3] // } 4688 5B JUMPDEST 4689 90 SWAP1 468A 50 POP 468B 91 SWAP2 468C 90 SWAP1 468D 50 POP 468E 56 *JUMP // Stack delta = -3 // Outputs[1] { @468B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_468F: // Incoming call from 0x3171, returns to 0x3172 // Inputs[1] { @4694 stack[-1] } 468F 5B JUMPDEST 4690 60 PUSH1 0x00 4692 60 PUSH1 0x20 4694 82 DUP3 4695 01 ADD 4696 90 SWAP1 4697 50 POP 4698 81 DUP2 4699 81 DUP2 469A 03 SUB 469B 60 PUSH1 0x00 469D 83 DUP4 469E 01 ADD 469F 52 MSTORE 46A0 61 PUSH2 0x46a8 46A3 81 DUP2 46A4 61 PUSH2 0x3cd1 46A7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4696 stack[0] = stack[-1] + 0x20 // @469F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @46A0 stack[1] = 0x46a8 // @46A3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3cd1, returns to 0x46A8 label_46A8: // Incoming return from call to 0x3CD1 at 0x46A7 // Inputs[4] // { // @46A9 stack[-1] // @46A9 stack[-2] // @46AB stack[-4] // @46AC stack[-3] // } 46A8 5B JUMPDEST 46A9 90 SWAP1 46AA 50 POP 46AB 91 SWAP2 46AC 90 SWAP1 46AD 50 POP 46AE 56 *JUMP // Stack delta = -3 // Outputs[1] { @46AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_46AF: // Incoming call from 0x14CC, returns to 0x14CD // Inputs[1] { @46B4 stack[-1] } 46AF 5B JUMPDEST 46B0 60 PUSH1 0x00 46B2 60 PUSH1 0x20 46B4 82 DUP3 46B5 01 ADD 46B6 90 SWAP1 46B7 50 POP 46B8 81 DUP2 46B9 81 DUP2 46BA 03 SUB 46BB 60 PUSH1 0x00 46BD 83 DUP4 46BE 01 ADD 46BF 52 MSTORE 46C0 61 PUSH2 0x46c8 46C3 81 DUP2 46C4 61 PUSH2 0x3d11 46C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @46B6 stack[0] = stack[-1] + 0x20 // @46BF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @46C0 stack[1] = 0x46c8 // @46C3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3d11, returns to 0x46C8 label_46C8: // Incoming return from call to 0x3D11 at 0x46C7 // Inputs[4] // { // @46C9 stack[-1] // @46C9 stack[-2] // @46CB stack[-4] // @46CC stack[-3] // } 46C8 5B JUMPDEST 46C9 90 SWAP1 46CA 50 POP 46CB 91 SWAP2 46CC 90 SWAP1 46CD 50 POP 46CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @46CB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_46CF: // Incoming call from 0x1D0B, returns to 0x1D0C // Inputs[1] { @46D4 stack[-1] } 46CF 5B JUMPDEST 46D0 60 PUSH1 0x00 46D2 60 PUSH1 0x20 46D4 82 DUP3 46D5 01 ADD 46D6 90 SWAP1 46D7 50 POP 46D8 81 DUP2 46D9 81 DUP2 46DA 03 SUB 46DB 60 PUSH1 0x00 46DD 83 DUP4 46DE 01 ADD 46DF 52 MSTORE 46E0 61 PUSH2 0x46e8 46E3 81 DUP2 46E4 61 PUSH2 0x3d77 46E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @46D6 stack[0] = stack[-1] + 0x20 // @46DF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @46E0 stack[1] = 0x46e8 // @46E3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3d77, returns to 0x46E8 label_46E8: // Incoming return from call to 0x3D77 at 0x46E7 // Inputs[4] // { // @46E9 stack[-2] // @46E9 stack[-1] // @46EB stack[-4] // @46EC stack[-3] // } 46E8 5B JUMPDEST 46E9 90 SWAP1 46EA 50 POP 46EB 91 SWAP2 46EC 90 SWAP1 46ED 50 POP 46EE 56 *JUMP // Stack delta = -3 // Outputs[1] { @46EB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_46EF: // Incoming call from 0x2761, returns to 0x2762 // Inputs[1] { @46F4 stack[-1] } 46EF 5B JUMPDEST 46F0 60 PUSH1 0x00 46F2 60 PUSH1 0x20 46F4 82 DUP3 46F5 01 ADD 46F6 90 SWAP1 46F7 50 POP 46F8 81 DUP2 46F9 81 DUP2 46FA 03 SUB 46FB 60 PUSH1 0x00 46FD 83 DUP4 46FE 01 ADD 46FF 52 MSTORE 4700 61 PUSH2 0x4708 4703 81 DUP2 4704 61 PUSH2 0x3ddd 4707 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @46F6 stack[0] = stack[-1] + 0x20 // @46FF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4700 stack[1] = 0x4708 // @4703 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3ddd, returns to 0x4708 label_4708: // Incoming return from call to 0x3DDD at 0x4707 // Inputs[4] // { // @4709 stack[-2] // @4709 stack[-1] // @470B stack[-4] // @470C stack[-3] // } 4708 5B JUMPDEST 4709 90 SWAP1 470A 50 POP 470B 91 SWAP2 470C 90 SWAP1 470D 50 POP 470E 56 *JUMP // Stack delta = -3 // Outputs[1] { @470B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_470F: // Incoming call from 0x18D6, returns to 0x18D7 // Inputs[1] { @4714 stack[-1] } 470F 5B JUMPDEST 4710 60 PUSH1 0x00 4712 60 PUSH1 0x20 4714 82 DUP3 4715 01 ADD 4716 90 SWAP1 4717 50 POP 4718 81 DUP2 4719 81 DUP2 471A 03 SUB 471B 60 PUSH1 0x00 471D 83 DUP4 471E 01 ADD 471F 52 MSTORE 4720 61 PUSH2 0x4728 4723 81 DUP2 4724 61 PUSH2 0x3e43 4727 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4716 stack[0] = stack[-1] + 0x20 // @471F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4720 stack[1] = 0x4728 // @4723 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3e43, returns to 0x4728 label_4728: // Incoming return from call to 0x3E43 at 0x4727 // Inputs[4] // { // @4729 stack[-1] // @4729 stack[-2] // @472B stack[-4] // @472C stack[-3] // } 4728 5B JUMPDEST 4729 90 SWAP1 472A 50 POP 472B 91 SWAP2 472C 90 SWAP1 472D 50 POP 472E 56 *JUMP // Stack delta = -3 // Outputs[1] { @472B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_472F: // Incoming call from 0x1DB8, returns to 0x1DB9 // Incoming call from 0x1579, returns to 0x157A // Inputs[1] { @4734 stack[-1] } 472F 5B JUMPDEST 4730 60 PUSH1 0x00 4732 60 PUSH1 0x20 4734 82 DUP3 4735 01 ADD 4736 90 SWAP1 4737 50 POP 4738 81 DUP2 4739 81 DUP2 473A 03 SUB 473B 60 PUSH1 0x00 473D 83 DUP4 473E 01 ADD 473F 52 MSTORE 4740 61 PUSH2 0x4748 4743 81 DUP2 4744 61 PUSH2 0x3e83 4747 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4736 stack[0] = stack[-1] + 0x20 // @473F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4740 stack[1] = 0x4748 // @4743 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3e83, returns to 0x4748 label_4748: // Incoming return from call to 0x3E83 at 0x4747 // Inputs[4] // { // @4749 stack[-2] // @4749 stack[-1] // @474B stack[-4] // @474C stack[-3] // } 4748 5B JUMPDEST 4749 90 SWAP1 474A 50 POP 474B 91 SWAP2 474C 90 SWAP1 474D 50 POP 474E 56 *JUMP // Stack delta = -3 // Outputs[1] { @474B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_474F: // Incoming call from 0x1C39, returns to 0x1C3A // Inputs[1] { @4754 stack[-1] } 474F 5B JUMPDEST 4750 60 PUSH1 0x00 4752 60 PUSH1 0x20 4754 82 DUP3 4755 01 ADD 4756 90 SWAP1 4757 50 POP 4758 81 DUP2 4759 81 DUP2 475A 03 SUB 475B 60 PUSH1 0x00 475D 83 DUP4 475E 01 ADD 475F 52 MSTORE 4760 61 PUSH2 0x4768 4763 81 DUP2 4764 61 PUSH2 0x3ec3 4767 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4756 stack[0] = stack[-1] + 0x20 // @475F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4760 stack[1] = 0x4768 // @4763 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3ec3, returns to 0x4768 label_4768: // Incoming return from call to 0x3EC3 at 0x4767 // Inputs[4] // { // @4769 stack[-2] // @4769 stack[-1] // @476B stack[-4] // @476C stack[-3] // } 4768 5B JUMPDEST 4769 90 SWAP1 476A 50 POP 476B 91 SWAP2 476C 90 SWAP1 476D 50 POP 476E 56 *JUMP // Stack delta = -3 // Outputs[1] { @476B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_476F: // Incoming call from 0x25E7, returns to 0x25E8 // Inputs[1] { @4774 stack[-1] } 476F 5B JUMPDEST 4770 60 PUSH1 0x00 4772 60 PUSH1 0x20 4774 82 DUP3 4775 01 ADD 4776 90 SWAP1 4777 50 POP 4778 81 DUP2 4779 81 DUP2 477A 03 SUB 477B 60 PUSH1 0x00 477D 83 DUP4 477E 01 ADD 477F 52 MSTORE 4780 61 PUSH2 0x4788 4783 81 DUP2 4784 61 PUSH2 0x3f03 4787 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4776 stack[0] = stack[-1] + 0x20 // @477F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4780 stack[1] = 0x4788 // @4783 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3f03, returns to 0x4788 label_4788: // Incoming return from call to 0x3F03 at 0x4787 // Inputs[4] // { // @4789 stack[-2] // @4789 stack[-1] // @478B stack[-4] // @478C stack[-3] // } 4788 5B JUMPDEST 4789 90 SWAP1 478A 50 POP 478B 91 SWAP2 478C 90 SWAP1 478D 50 POP 478E 56 *JUMP // Stack delta = -3 // Outputs[1] { @478B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_478F: // Incoming call from 0x13FA, returns to 0x13FB // Inputs[1] { @4794 stack[-1] } 478F 5B JUMPDEST 4790 60 PUSH1 0x00 4792 60 PUSH1 0x20 4794 82 DUP3 4795 01 ADD 4796 90 SWAP1 4797 50 POP 4798 81 DUP2 4799 81 DUP2 479A 03 SUB 479B 60 PUSH1 0x00 479D 83 DUP4 479E 01 ADD 479F 52 MSTORE 47A0 61 PUSH2 0x47a8 47A3 81 DUP2 47A4 61 PUSH2 0x3f69 47A7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4796 stack[0] = stack[-1] + 0x20 // @479F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @47A0 stack[1] = 0x47a8 // @47A3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3f69, returns to 0x47A8 label_47A8: // Incoming return from call to 0x3F69 at 0x47A7 // Inputs[4] // { // @47A9 stack[-1] // @47A9 stack[-2] // @47AB stack[-4] // @47AC stack[-3] // } 47A8 5B JUMPDEST 47A9 90 SWAP1 47AA 50 POP 47AB 91 SWAP2 47AC 90 SWAP1 47AD 50 POP 47AE 56 *JUMP // Stack delta = -3 // Outputs[1] { @47AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_47AF: // Incoming call from 0x0BFE, returns to 0x0BFF // Inputs[1] { @47B4 stack[-1] } 47AF 5B JUMPDEST 47B0 60 PUSH1 0x00 47B2 60 PUSH1 0x20 47B4 82 DUP3 47B5 01 ADD 47B6 90 SWAP1 47B7 50 POP 47B8 81 DUP2 47B9 81 DUP2 47BA 03 SUB 47BB 60 PUSH1 0x00 47BD 83 DUP4 47BE 01 ADD 47BF 52 MSTORE 47C0 61 PUSH2 0x47c8 47C3 81 DUP2 47C4 61 PUSH2 0x3fcf 47C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @47B6 stack[0] = stack[-1] + 0x20 // @47BF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @47C0 stack[1] = 0x47c8 // @47C3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x3fcf, returns to 0x47C8 label_47C8: // Incoming return from call to 0x3FCF at 0x47C7 // Inputs[4] // { // @47C9 stack[-2] // @47C9 stack[-1] // @47CB stack[-4] // @47CC stack[-3] // } 47C8 5B JUMPDEST 47C9 90 SWAP1 47CA 50 POP 47CB 91 SWAP2 47CC 90 SWAP1 47CD 50 POP 47CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @47CB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_47CF: // Incoming call from 0x16C3, returns to 0x16C4 // Inputs[1] { @47D4 stack[-1] } 47CF 5B JUMPDEST 47D0 60 PUSH1 0x00 47D2 60 PUSH1 0x20 47D4 82 DUP3 47D5 01 ADD 47D6 90 SWAP1 47D7 50 POP 47D8 81 DUP2 47D9 81 DUP2 47DA 03 SUB 47DB 60 PUSH1 0x00 47DD 83 DUP4 47DE 01 ADD 47DF 52 MSTORE 47E0 61 PUSH2 0x47e8 47E3 81 DUP2 47E4 61 PUSH2 0x4035 47E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @47D6 stack[0] = stack[-1] + 0x20 // @47DF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @47E0 stack[1] = 0x47e8 // @47E3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4035, returns to 0x47E8 label_47E8: // Incoming return from call to 0x4035 at 0x47E7 // Inputs[4] // { // @47E9 stack[-2] // @47E9 stack[-1] // @47EB stack[-4] // @47EC stack[-3] // } 47E8 5B JUMPDEST 47E9 90 SWAP1 47EA 50 POP 47EB 91 SWAP2 47EC 90 SWAP1 47ED 50 POP 47EE 56 *JUMP // Stack delta = -3 // Outputs[1] { @47EB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_47EF: // Incoming call from 0x12C4, returns to 0x12C5 // Inputs[1] { @47F4 stack[-1] } 47EF 5B JUMPDEST 47F0 60 PUSH1 0x00 47F2 60 PUSH1 0x20 47F4 82 DUP3 47F5 01 ADD 47F6 90 SWAP1 47F7 50 POP 47F8 81 DUP2 47F9 81 DUP2 47FA 03 SUB 47FB 60 PUSH1 0x00 47FD 83 DUP4 47FE 01 ADD 47FF 52 MSTORE 4800 61 PUSH2 0x4808 4803 81 DUP2 4804 61 PUSH2 0x409b 4807 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @47F6 stack[0] = stack[-1] + 0x20 // @47FF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4800 stack[1] = 0x4808 // @4803 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x409b, returns to 0x4808 label_4808: // Incoming return from call to 0x409B at 0x4807 // Inputs[4] // { // @4809 stack[-2] // @4809 stack[-1] // @480B stack[-4] // @480C stack[-3] // } 4808 5B JUMPDEST 4809 90 SWAP1 480A 50 POP 480B 91 SWAP2 480C 90 SWAP1 480D 50 POP 480E 56 *JUMP // Stack delta = -3 // Outputs[1] { @480B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_480F: // Incoming call from 0x1D62, returns to 0x1D63 // Incoming call from 0x1523, returns to 0x1524 // Inputs[1] { @4814 stack[-1] } 480F 5B JUMPDEST 4810 60 PUSH1 0x00 4812 60 PUSH1 0x20 4814 82 DUP3 4815 01 ADD 4816 90 SWAP1 4817 50 POP 4818 81 DUP2 4819 81 DUP2 481A 03 SUB 481B 60 PUSH1 0x00 481D 83 DUP4 481E 01 ADD 481F 52 MSTORE 4820 61 PUSH2 0x4828 4823 81 DUP2 4824 61 PUSH2 0x4101 4827 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4816 stack[0] = stack[-1] + 0x20 // @481F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4820 stack[1] = 0x4828 // @4823 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4101, returns to 0x4828 label_4828: // Incoming return from call to 0x4101 at 0x4827 // Inputs[4] // { // @4829 stack[-2] // @4829 stack[-1] // @482B stack[-4] // @482C stack[-3] // } 4828 5B JUMPDEST 4829 90 SWAP1 482A 50 POP 482B 91 SWAP2 482C 90 SWAP1 482D 50 POP 482E 56 *JUMP // Stack delta = -3 // Outputs[1] { @482B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_482F: // Incoming call from 0x3128, returns to 0x3129 // Inputs[1] { @4834 stack[-1] } 482F 5B JUMPDEST 4830 60 PUSH1 0x00 4832 60 PUSH1 0x20 4834 82 DUP3 4835 01 ADD 4836 90 SWAP1 4837 50 POP 4838 81 DUP2 4839 81 DUP2 483A 03 SUB 483B 60 PUSH1 0x00 483D 83 DUP4 483E 01 ADD 483F 52 MSTORE 4840 61 PUSH2 0x4848 4843 81 DUP2 4844 61 PUSH2 0x4141 4847 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4836 stack[0] = stack[-1] + 0x20 // @483F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4840 stack[1] = 0x4848 // @4843 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4141, returns to 0x4848 label_4848: // Incoming return from call to 0x4141 at 0x4847 // Inputs[4] // { // @4849 stack[-1] // @4849 stack[-2] // @484B stack[-4] // @484C stack[-3] // } 4848 5B JUMPDEST 4849 90 SWAP1 484A 50 POP 484B 91 SWAP2 484C 90 SWAP1 484D 50 POP 484E 56 *JUMP // Stack delta = -3 // Outputs[1] { @484B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_484F: // Incoming call from 0x143E, returns to 0x143F // Inputs[1] { @4854 stack[-1] } 484F 5B JUMPDEST 4850 60 PUSH1 0x00 4852 60 PUSH1 0x20 4854 82 DUP3 4855 01 ADD 4856 90 SWAP1 4857 50 POP 4858 81 DUP2 4859 81 DUP2 485A 03 SUB 485B 60 PUSH1 0x00 485D 83 DUP4 485E 01 ADD 485F 52 MSTORE 4860 61 PUSH2 0x4868 4863 81 DUP2 4864 61 PUSH2 0x4181 4867 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4856 stack[0] = stack[-1] + 0x20 // @485F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4860 stack[1] = 0x4868 // @4863 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4181, returns to 0x4868 label_4868: // Incoming return from call to 0x4181 at 0x4867 // Inputs[4] // { // @4869 stack[-1] // @4869 stack[-2] // @486B stack[-4] // @486C stack[-3] // } 4868 5B JUMPDEST 4869 90 SWAP1 486A 50 POP 486B 91 SWAP2 486C 90 SWAP1 486D 50 POP 486E 56 *JUMP // Stack delta = -3 // Outputs[1] { @486B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_486F: // Incoming call from 0x0A2C, returns to 0x0A2D // Inputs[1] { @4874 stack[-1] } 486F 5B JUMPDEST 4870 60 PUSH1 0x00 4872 60 PUSH1 0x20 4874 82 DUP3 4875 01 ADD 4876 90 SWAP1 4877 50 POP 4878 81 DUP2 4879 81 DUP2 487A 03 SUB 487B 60 PUSH1 0x00 487D 83 DUP4 487E 01 ADD 487F 52 MSTORE 4880 61 PUSH2 0x4888 4883 81 DUP2 4884 61 PUSH2 0x41c1 4887 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4876 stack[0] = stack[-1] + 0x20 // @487F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4880 stack[1] = 0x4888 // @4883 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x41c1, returns to 0x4888 label_4888: // Incoming return from call to 0x41C1 at 0x4887 // Inputs[4] // { // @4889 stack[-2] // @4889 stack[-1] // @488B stack[-4] // @488C stack[-3] // } 4888 5B JUMPDEST 4889 90 SWAP1 488A 50 POP 488B 91 SWAP2 488C 90 SWAP1 488D 50 POP 488E 56 *JUMP // Stack delta = -3 // Outputs[1] { @488B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_488F: // Incoming call from 0x21A0, returns to 0x21A1 // Incoming call from 0x0FC4, returns to 0x0FC5 // Incoming call from 0x1786, returns to 0x1787 // Incoming call from 0x22DE, returns to 0x22DF // Incoming call from 0x1201, returns to 0x1202 // Incoming call from 0x2248, returns to 0x2249 // Incoming call from 0x0EB6, returns to 0x0EB7 // Incoming call from 0x1AF6, returns to 0x1AF7 // Incoming call from 0x106C, returns to 0x106D // Incoming call from 0x0D0E, returns to 0x0D0F // Incoming call from 0x23DC, returns to 0x23DD // Incoming call from 0x1A5D, returns to 0x1A5E // Inputs[1] { @4894 stack[-1] } 488F 5B JUMPDEST 4890 60 PUSH1 0x00 4892 60 PUSH1 0x20 4894 82 DUP3 4895 01 ADD 4896 90 SWAP1 4897 50 POP 4898 81 DUP2 4899 81 DUP2 489A 03 SUB 489B 60 PUSH1 0x00 489D 83 DUP4 489E 01 ADD 489F 52 MSTORE 48A0 61 PUSH2 0x48a8 48A3 81 DUP2 48A4 61 PUSH2 0x4227 48A7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4896 stack[0] = stack[-1] + 0x20 // @489F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @48A0 stack[1] = 0x48a8 // @48A3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4227, returns to 0x48A8 label_48A8: // Incoming return from call to 0x4227 at 0x48A7 // Inputs[4] // { // @48A9 stack[-2] // @48A9 stack[-1] // @48AB stack[-4] // @48AC stack[-3] // } 48A8 5B JUMPDEST 48A9 90 SWAP1 48AA 50 POP 48AB 91 SWAP2 48AC 90 SWAP1 48AD 50 POP 48AE 56 *JUMP // Stack delta = -3 // Outputs[1] { @48AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_48AF: // Incoming call from 0x0D5D, returns to 0x0D5E // Inputs[1] { @48B4 stack[-1] } 48AF 5B JUMPDEST 48B0 60 PUSH1 0x00 48B2 60 PUSH1 0x20 48B4 82 DUP3 48B5 01 ADD 48B6 90 SWAP1 48B7 50 POP 48B8 81 DUP2 48B9 81 DUP2 48BA 03 SUB 48BB 60 PUSH1 0x00 48BD 83 DUP4 48BE 01 ADD 48BF 52 MSTORE 48C0 61 PUSH2 0x48c8 48C3 81 DUP2 48C4 61 PUSH2 0x4267 48C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @48B6 stack[0] = stack[-1] + 0x20 // @48BF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @48C0 stack[1] = 0x48c8 // @48C3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4267, returns to 0x48C8 label_48C8: // Incoming return from call to 0x4267 at 0x48C7 // Inputs[4] // { // @48C9 stack[-1] // @48C9 stack[-2] // @48CB stack[-4] // @48CC stack[-3] // } 48C8 5B JUMPDEST 48C9 90 SWAP1 48CA 50 POP 48CB 91 SWAP2 48CC 90 SWAP1 48CD 50 POP 48CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @48CB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_48CF: // Incoming call from 0x26F1, returns to 0x26F2 // Inputs[1] { @48D4 stack[-1] } 48CF 5B JUMPDEST 48D0 60 PUSH1 0x00 48D2 60 PUSH1 0x20 48D4 82 DUP3 48D5 01 ADD 48D6 90 SWAP1 48D7 50 POP 48D8 81 DUP2 48D9 81 DUP2 48DA 03 SUB 48DB 60 PUSH1 0x00 48DD 83 DUP4 48DE 01 ADD 48DF 52 MSTORE 48E0 61 PUSH2 0x48e8 48E3 81 DUP2 48E4 61 PUSH2 0x42cd 48E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @48D6 stack[0] = stack[-1] + 0x20 // @48DF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @48E0 stack[1] = 0x48e8 // @48E3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x42cd, returns to 0x48E8 label_48E8: // Incoming return from call to 0x42CD at 0x48E7 // Inputs[4] // { // @48E9 stack[-2] // @48E9 stack[-1] // @48EB stack[-4] // @48EC stack[-3] // } 48E8 5B JUMPDEST 48E9 90 SWAP1 48EA 50 POP 48EB 91 SWAP2 48EC 90 SWAP1 48ED 50 POP 48EE 56 *JUMP // Stack delta = -3 // Outputs[1] { @48EB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_48EF: // Incoming call from 0x1F69, returns to 0x1F6A // Inputs[1] { @48F4 stack[-1] } 48EF 5B JUMPDEST 48F0 60 PUSH1 0x00 48F2 60 PUSH1 0x20 48F4 82 DUP3 48F5 01 ADD 48F6 90 SWAP1 48F7 50 POP 48F8 81 DUP2 48F9 81 DUP2 48FA 03 SUB 48FB 60 PUSH1 0x00 48FD 83 DUP4 48FE 01 ADD 48FF 52 MSTORE 4900 61 PUSH2 0x4908 4903 81 DUP2 4904 61 PUSH2 0x4333 4907 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @48F6 stack[0] = stack[-1] + 0x20 // @48FF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4900 stack[1] = 0x4908 // @4903 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4333, returns to 0x4908 label_4908: // Incoming return from call to 0x4333 at 0x4907 // Inputs[4] // { // @4909 stack[-2] // @4909 stack[-1] // @490B stack[-4] // @490C stack[-3] // } 4908 5B JUMPDEST 4909 90 SWAP1 490A 50 POP 490B 91 SWAP2 490C 90 SWAP1 490D 50 POP 490E 56 *JUMP // Stack delta = -3 // Outputs[1] { @490B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_490F: // Incoming call from 0x0B71, returns to 0x0B72 // Inputs[1] { @4914 stack[-1] } 490F 5B JUMPDEST 4910 60 PUSH1 0x00 4912 60 PUSH1 0x20 4914 82 DUP3 4915 01 ADD 4916 90 SWAP1 4917 50 POP 4918 81 DUP2 4919 81 DUP2 491A 03 SUB 491B 60 PUSH1 0x00 491D 83 DUP4 491E 01 ADD 491F 52 MSTORE 4920 61 PUSH2 0x4928 4923 81 DUP2 4924 61 PUSH2 0x4399 4927 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4916 stack[0] = stack[-1] + 0x20 // @491F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4920 stack[1] = 0x4928 // @4923 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x4399, returns to 0x4928 label_4928: // Incoming return from call to 0x4399 at 0x4927 // Inputs[4] // { // @4929 stack[-2] // @4929 stack[-1] // @492B stack[-4] // @492C stack[-3] // } 4928 5B JUMPDEST 4929 90 SWAP1 492A 50 POP 492B 91 SWAP2 492C 90 SWAP1 492D 50 POP 492E 56 *JUMP // Stack delta = -3 // Outputs[1] { @492B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_492F: // Incoming call from 0x1C7D, returns to 0x1C7E // Inputs[1] { @4934 stack[-1] } 492F 5B JUMPDEST 4930 60 PUSH1 0x00 4932 60 PUSH1 0x20 4934 82 DUP3 4935 01 ADD 4936 90 SWAP1 4937 50 POP 4938 81 DUP2 4939 81 DUP2 493A 03 SUB 493B 60 PUSH1 0x00 493D 83 DUP4 493E 01 ADD 493F 52 MSTORE 4940 61 PUSH2 0x4948 4943 81 DUP2 4944 61 PUSH2 0x43ff 4947 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4936 stack[0] = stack[-1] + 0x20 // @493F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4940 stack[1] = 0x4948 // @4943 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x43ff, returns to 0x4948 label_4948: // Incoming return from call to 0x43FF at 0x4947 // Inputs[4] // { // @4949 stack[-2] // @4949 stack[-1] // @494B stack[-4] // @494C stack[-3] // } 4948 5B JUMPDEST 4949 90 SWAP1 494A 50 POP 494B 91 SWAP2 494C 90 SWAP1 494D 50 POP 494E 56 *JUMP // Stack delta = -3 // Outputs[1] { @494B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_494F: // Incoming call from 0x13AA, returns to 0x13AB // Inputs[1] { @4954 stack[-1] } 494F 5B JUMPDEST 4950 60 PUSH1 0x00 4952 60 PUSH1 0x20 4954 82 DUP3 4955 01 ADD 4956 90 SWAP1 4957 50 POP 4958 81 DUP2 4959 81 DUP2 495A 03 SUB 495B 60 PUSH1 0x00 495D 83 DUP4 495E 01 ADD 495F 52 MSTORE 4960 61 PUSH2 0x4968 4963 81 DUP2 4964 61 PUSH2 0x443f 4967 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4956 stack[0] = stack[-1] + 0x20 // @495F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4960 stack[1] = 0x4968 // @4963 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x443f, returns to 0x4968 label_4968: // Incoming return from call to 0x443F at 0x4967 // Inputs[4] // { // @4969 stack[-1] // @4969 stack[-2] // @496B stack[-4] // @496C stack[-3] // } 4968 5B JUMPDEST 4969 90 SWAP1 496A 50 POP 496B 91 SWAP2 496C 90 SWAP1 496D 50 POP 496E 56 *JUMP // Stack delta = -3 // Outputs[1] { @496B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_496F: // Incoming call from 0x0C82, returns to 0x0C83 // Incoming call from 0x1BD8, returns to 0x1BD9 // Inputs[1] { @4974 stack[-1] } 496F 5B JUMPDEST 4970 60 PUSH1 0x00 4972 60 PUSH1 0x20 4974 82 DUP3 4975 01 ADD 4976 90 SWAP1 4977 50 POP 4978 81 DUP2 4979 81 DUP2 497A 03 SUB 497B 60 PUSH1 0x00 497D 83 DUP4 497E 01 ADD 497F 52 MSTORE 4980 61 PUSH2 0x4988 4983 81 DUP2 4984 61 PUSH2 0x447f 4987 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4976 stack[0] = stack[-1] + 0x20 // @497F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @4980 stack[1] = 0x4988 // @4983 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x447f, returns to 0x4988 label_4988: // Incoming return from call to 0x447F at 0x4987 // Inputs[4] // { // @4989 stack[-1] // @4989 stack[-2] // @498B stack[-4] // @498C stack[-3] // } 4988 5B JUMPDEST 4989 90 SWAP1 498A 50 POP 498B 91 SWAP2 498C 90 SWAP1 498D 50 POP 498E 56 *JUMP // Stack delta = -3 // Outputs[1] { @498B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_498F: // Incoming call from 0x1126, returns to 0x1127 // Inputs[1] { @4994 stack[-1] } 498F 5B JUMPDEST 4990 60 PUSH1 0x00 4992 60 PUSH1 0x20 4994 82 DUP3 4995 01 ADD 4996 90 SWAP1 4997 50 POP 4998 81 DUP2 4999 81 DUP2 499A 03 SUB 499B 60 PUSH1 0x00 499D 83 DUP4 499E 01 ADD 499F 52 MSTORE 49A0 61 PUSH2 0x49a8 49A3 81 DUP2 49A4 61 PUSH2 0x44e5 49A7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @4996 stack[0] = stack[-1] + 0x20 // @499F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @49A0 stack[1] = 0x49a8 // @49A3 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x44e5, returns to 0x49A8 label_49A8: // Incoming return from call to 0x44E5 at 0x49A7 // Inputs[4] // { // @49A9 stack[-2] // @49A9 stack[-1] // @49AB stack[-4] // @49AC stack[-3] // } 49A8 5B JUMPDEST 49A9 90 SWAP1 49AA 50 POP 49AB 91 SWAP2 49AC 90 SWAP1 49AD 50 POP 49AE 56 *JUMP // Stack delta = -3 // Outputs[1] { @49AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_49AF: // Incoming call from 0x0881, returns to 0x0882 // Incoming call from 0x0370, returns to 0x0371 // Incoming call from 0x0443, returns to 0x0444 // Incoming call from 0x039B, returns to 0x039C // Incoming call from 0x0615, returns to 0x0616 // Incoming call from 0x0657, returns to 0x0658 // Incoming call from 0x0915, returns to 0x0916 // Incoming call from 0x0500, returns to 0x0501 // Incoming call from 0x0682, returns to 0x0683 // Inputs[2] // { // @49B4 stack[-1] // @49BF stack[-2] // } 49AF 5B JUMPDEST 49B0 60 PUSH1 0x00 49B2 60 PUSH1 0x20 49B4 82 DUP3 49B5 01 ADD 49B6 90 SWAP1 49B7 50 POP 49B8 61 PUSH2 0x49c4 49BB 60 PUSH1 0x00 49BD 83 DUP4 49BE 01 ADD 49BF 84 DUP5 49C0 61 PUSH2 0x454b 49C3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @49B6 stack[0] = stack[-1] + 0x20 // @49B8 stack[1] = 0x49c4 // @49BE stack[2] = stack[-1] + 0x00 // @49BF stack[3] = stack[-2] // } // Block ends with call to 0x454b, returns to 0x49C4 label_49C4: // Incoming return from call to 0x454B at 0x49C3 // Inputs[3] // { // @49C5 stack[-1] // @49C5 stack[-4] // @49C6 stack[-3] // } 49C4 5B JUMPDEST 49C5 92 SWAP3 49C6 91 SWAP2 49C7 50 POP 49C8 50 POP 49C9 56 *JUMP // Stack delta = -3 // Outputs[1] { @49C5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_49CA: // Incoming jump from 0x36D5 // Incoming jump from 0x3713 // Inputs[2] // { // @49CF memory[0x40:0x60] // @49D2 stack[-1] // } 49CA 5B JUMPDEST 49CB 60 PUSH1 0x00 49CD 60 PUSH1 0x40 49CF 51 MLOAD 49D0 90 SWAP1 49D1 50 POP 49D2 81 DUP2 49D3 81 DUP2 49D4 01 ADD 49D5 81 DUP2 49D6 81 DUP2 49D7 10 LT 49D8 67 PUSH8 0xffffffffffffffff 49E1 82 DUP3 49E2 11 GT 49E3 17 OR 49E4 15 ISZERO 49E5 61 PUSH2 0x49f1 49E8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @49D0 stack[0] = memory[0x40:0x60] // @49D4 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x49f1, if !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) label_49E9: // Incoming jump from 0x49E8, if not !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) 49E9 61 PUSH2 0x49f0 49EC 61 PUSH2 0x4db7 49EF 56 *JUMP // Stack delta = +1 // Outputs[1] { @49E9 stack[0] = 0x49f0 } // Block ends with unconditional jump to 0x4db7 49F0 5B JUMPDEST label_49F1: // Incoming jump from 0x49E8, if !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) // Inputs[4] // { // @49F2 stack[-1] // @49F7 stack[-2] // @49F7 stack[-4] // @49F8 stack[-3] // } 49F1 5B JUMPDEST 49F2 80 DUP1 49F3 60 PUSH1 0x40 49F5 52 MSTORE 49F6 50 POP 49F7 91 SWAP2 49F8 90 SWAP1 49F9 50 POP 49FA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @49F5 memory[0x40:0x60] = stack[-1] // @49F7 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_49FB: // Incoming call from 0x36D0, returns to 0x36D1 // Inputs[1] { @4A07 stack[-1] } 49FB 5B JUMPDEST 49FC 60 PUSH1 0x00 49FE 67 PUSH8 0xffffffffffffffff 4A07 82 DUP3 4A08 11 GT 4A09 15 ISZERO 4A0A 61 PUSH2 0x4a16 4A0D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @49FC stack[0] = 0x00 } // Block ends with conditional jump to 0x4a16, if !(stack[-1] > 0xffffffffffffffff) label_4A0E: // Incoming jump from 0x4A0D, if not !(stack[-1] > 0xffffffffffffffff) 4A0E 61 PUSH2 0x4a15 4A11 61 PUSH2 0x4db7 4A14 56 *JUMP // Stack delta = +1 // Outputs[1] { @4A0E stack[0] = 0x4a15 } // Block ends with unconditional jump to 0x4db7 4A15 5B JUMPDEST label_4A16: // Incoming jump from 0x4A0D, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @4A1C stack[-2] // @4A1F stack[-1] // @4A27 stack[-3] // } 4A16 5B JUMPDEST 4A17 60 PUSH1 0x1f 4A19 19 NOT 4A1A 60 PUSH1 0x1f 4A1C 83 DUP4 4A1D 01 ADD 4A1E 16 AND 4A1F 90 SWAP1 4A20 50 POP 4A21 60 PUSH1 0x20 4A23 81 DUP2 4A24 01 ADD 4A25 90 SWAP1 4A26 50 POP 4A27 91 SWAP2 4A28 90 SWAP1 4A29 50 POP 4A2A 56 *JUMP // Stack delta = -2 // Outputs[1] { @4A27 stack[-3] = (stack[-2] + 0x1f & ~0x1f) + 0x20 } // Block ends with unconditional jump to stack[-3] label_4A2B: // Incoming call from 0x370E, returns to 0x370F // Inputs[1] { @4A37 stack[-1] } 4A2B 5B JUMPDEST 4A2C 60 PUSH1 0x00 4A2E 67 PUSH8 0xffffffffffffffff 4A37 82 DUP3 4A38 11 GT 4A39 15 ISZERO 4A3A 61 PUSH2 0x4a46 4A3D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4A2C stack[0] = 0x00 } // Block ends with conditional jump to 0x4a46, if !(stack[-1] > 0xffffffffffffffff) label_4A3E: // Incoming jump from 0x4A3D, if not !(stack[-1] > 0xffffffffffffffff) 4A3E 61 PUSH2 0x4a45 4A41 61 PUSH2 0x4db7 4A44 56 *JUMP // Stack delta = +1 // Outputs[1] { @4A3E stack[0] = 0x4a45 } // Block ends with unconditional jump to 0x4db7 4A45 5B JUMPDEST label_4A46: // Incoming jump from 0x4A3D, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @4A4C stack[-2] // @4A4F stack[-1] // @4A57 stack[-3] // } 4A46 5B JUMPDEST 4A47 60 PUSH1 0x1f 4A49 19 NOT 4A4A 60 PUSH1 0x1f 4A4C 83 DUP4 4A4D 01 ADD 4A4E 16 AND 4A4F 90 SWAP1 4A50 50 POP 4A51 60 PUSH1 0x20 4A53 81 DUP2 4A54 01 ADD 4A55 90 SWAP1 4A56 50 POP 4A57 91 SWAP2 4A58 90 SWAP1 4A59 50 POP 4A5A 56 *JUMP // Stack delta = -2 // Outputs[1] { @4A57 stack[-3] = (stack[-2] + 0x1f & ~0x1f) + 0x20 } // Block ends with unconditional jump to stack[-3] label_4A5B: // Incoming call from 0x3B6B, returns to 0x3B6C // Inputs[3] // { // @4A5E stack[-1] // @4A69 memory[0x00:0x20] // @4A6C stack[-2] // } 4A5B 5B JUMPDEST 4A5C 60 PUSH1 0x00 4A5E 81 DUP2 4A5F 90 SWAP1 4A60 50 POP 4A61 81 DUP2 4A62 60 PUSH1 0x00 4A64 52 MSTORE 4A65 60 PUSH1 0x20 4A67 60 PUSH1 0x00 4A69 20 SHA3 4A6A 90 SWAP1 4A6B 50 POP 4A6C 91 SWAP2 4A6D 90 SWAP1 4A6E 50 POP 4A6F 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @4A64 memory[0x00:0x20] = stack[-1] // @4A6C stack[-2] = keccak256(memory[0x00:0x20]) // } // Block ends with unconditional jump to stack[-2] label_4A70: // Incoming call from 0x3A87, returns to 0x3A88 // Inputs[3] // { // @4A73 stack[-1] // @4A74 memory[stack[-1]:stack[-1] + 0x20] // @4A77 stack[-2] // } 4A70 5B JUMPDEST 4A71 60 PUSH1 0x00 4A73 81 DUP2 4A74 51 MLOAD 4A75 90 SWAP1 4A76 50 POP 4A77 91 SWAP2 4A78 90 SWAP1 4A79 50 POP 4A7A 56 *JUMP // Stack delta = -1 // Outputs[1] { @4A77 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_4A7B: // Incoming call from 0x3AC0, returns to 0x3AC1 // Incoming call from 0x3AF9, returns to 0x3AFA // Inputs[3] // { // @4A7E stack[-1] // @4A7F memory[stack[-1]:stack[-1] + 0x20] // @4A82 stack[-2] // } 4A7B 5B JUMPDEST 4A7C 60 PUSH1 0x00 4A7E 81 DUP2 4A7F 51 MLOAD 4A80 90 SWAP1 4A81 50 POP 4A82 91 SWAP2 4A83 90 SWAP1 4A84 50 POP 4A85 56 *JUMP // Stack delta = -1 // Outputs[1] { @4A82 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_4A86: // Incoming call from 0x3A91, returns to 0x3A92 // Inputs[3] // { // @4A89 stack[-2] // @4A8A stack[-1] // @4A92 stack[-3] // } 4A86 5B JUMPDEST 4A87 60 PUSH1 0x00 4A89 82 DUP3 4A8A 82 DUP3 4A8B 52 MSTORE 4A8C 60 PUSH1 0x20 4A8E 82 DUP3 4A8F 01 ADD 4A90 90 SWAP1 4A91 50 POP 4A92 92 SWAP3 4A93 91 SWAP2 4A94 50 POP 4A95 50 POP 4A96 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @4A8B memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @4A92 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_4A97: // Incoming call from 0x44F1, returns to 0x44F2 // Incoming call from 0x40A7, returns to 0x40A8 // Incoming call from 0x440B, returns to 0x440C // Incoming call from 0x41CD, returns to 0x41CE // Incoming call from 0x3E8F, returns to 0x3E90 // Incoming call from 0x3F75, returns to 0x3F76 // Incoming call from 0x3C77, returns to 0x3C78 // Incoming call from 0x3BAB, returns to 0x3BAC // Incoming call from 0x4233, returns to 0x4234 // Incoming call from 0x43A5, returns to 0x43A6 // Incoming call from 0x42D9, returns to 0x42DA // Incoming call from 0x3D1D, returns to 0x3D1E // Incoming call from 0x3ACA, returns to 0x3ACB // Incoming call from 0x3E4F, returns to 0x3E50 // Incoming call from 0x418D, returns to 0x418E // Incoming call from 0x3DE9, returns to 0x3DEA // Incoming call from 0x3F0F, returns to 0x3F10 // Incoming call from 0x410D, returns to 0x410E // Incoming call from 0x4041, returns to 0x4042 // Incoming call from 0x3C11, returns to 0x3C12 // Incoming call from 0x448B, returns to 0x448C // Incoming call from 0x3CDD, returns to 0x3CDE // Incoming call from 0x414D, returns to 0x414E // Incoming call from 0x4273, returns to 0x4274 // Incoming call from 0x3ECF, returns to 0x3ED0 // Incoming call from 0x433F, returns to 0x4340 // Incoming call from 0x3FDB, returns to 0x3FDC // Incoming call from 0x444B, returns to 0x444C // Incoming call from 0x3D83, returns to 0x3D84 // Inputs[3] // { // @4A9A stack[-2] // @4A9B stack[-1] // @4AA3 stack[-3] // } 4A97 5B JUMPDEST 4A98 60 PUSH1 0x00 4A9A 82 DUP3 4A9B 82 DUP3 4A9C 52 MSTORE 4A9D 60 PUSH1 0x20 4A9F 82 DUP3 4AA0 01 ADD 4AA1 90 SWAP1 4AA2 50 POP 4AA3 92 SWAP3 4AA4 91 SWAP2 4AA5 50 POP 4AA6 50 POP 4AA7 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @4A9C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @4AA3 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_4AA8: // Incoming call from 0x3B36, returns to 0x3B37 // Incoming call from 0x3B03, returns to 0x3B04 // Inputs[3] // { // @4AAB stack[-1] // @4AAE stack[-3] // @4AAF stack[-2] // } 4AA8 5B JUMPDEST 4AA9 60 PUSH1 0x00 4AAB 81 DUP2 4AAC 90 SWAP1 4AAD 50 POP 4AAE 92 SWAP3 4AAF 91 SWAP2 4AB0 50 POP 4AB1 50 POP 4AB2 56 *JUMP // Stack delta = -2 // Outputs[1] { @4AAE stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_4AB3: // Incoming call from 0x2BD4, returns to 0x2BD5 // Incoming call from 0x2827, returns to 0x2828 // Incoming call from 0x31D6, returns to 0x31D7 // Incoming call from 0x1E54, returns to 0x1E55 // Incoming call from 0x1615, returns to 0x1616 // Incoming call from 0x1CD3, returns to 0x1CD4 // Incoming call from 0x1D2A, returns to 0x1D2B // Incoming call from 0x1494, returns to 0x1495 // Incoming call from 0x0D82, returns to 0x0D83 // Incoming call from 0x14EB, returns to 0x14EC // Inputs[1] { @4AB9 stack[-1] } 4AB3 5B JUMPDEST 4AB4 60 PUSH1 0x00 4AB6 61 PUSH2 0x4abe 4AB9 82 DUP3 4ABA 61 PUSH2 0x4c32 4ABD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4AB4 stack[0] = 0x00 // @4AB6 stack[1] = 0x4abe // @4AB9 stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4ABE label_4ABE: // Incoming return from call to 0x4C32 at 0x4ABD // Inputs[3] // { // @4ABF stack[-1] // @4ABF stack[-3] // @4AC4 stack[-4] // } 4ABE 5B JUMPDEST 4ABF 91 SWAP2 4AC0 50 POP 4AC1 61 PUSH2 0x4ac9 4AC4 83 DUP4 4AC5 61 PUSH2 0x4c32 4AC8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @4ABF stack[-3] = stack[-1] // @4AC1 stack[-1] = 0x4ac9 // @4AC4 stack[0] = stack[-4] // } // Block ends with call to 0x4c32, returns to 0x4AC9 label_4AC9: // Incoming return from call to 0x4C32 at 0x4AC8 // Inputs[3] // { // @4ACA stack[-1] // @4ACA stack[-4] // @4AEF stack[-3] // } 4AC9 5B JUMPDEST 4ACA 92 SWAP3 4ACB 50 POP 4ACC 82 DUP3 4ACD 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4AEE 03 SUB 4AEF 82 DUP3 4AF0 11 GT 4AF1 15 ISZERO 4AF2 61 PUSH2 0x4afe 4AF5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4ACA stack[-4] = stack[-1] } // Block ends with conditional jump to 0x4afe, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) label_4AF6: // Incoming jump from 0x4AF5, if not !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) 4AF6 61 PUSH2 0x4afd 4AF9 61 PUSH2 0x4d2a 4AFC 56 *JUMP // Stack delta = +1 // Outputs[1] { @4AF6 stack[0] = 0x4afd } // Block ends with unconditional jump to 0x4d2a 4AFD 5B JUMPDEST label_4AFE: // Incoming jump from 0x4AF5, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) // Inputs[4] // { // @4AFF stack[-3] // @4B00 stack[-2] // @4B02 stack[-1] // @4B04 stack[-4] // } 4AFE 5B JUMPDEST 4AFF 82 DUP3 4B00 82 DUP3 4B01 01 ADD 4B02 90 SWAP1 4B03 50 POP 4B04 92 SWAP3 4B05 91 SWAP2 4B06 50 POP 4B07 50 POP 4B08 56 *JUMP // Stack delta = -3 // Outputs[1] { @4B04 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_4B09: // Incoming call from 0x2C4C, returns to 0x2C4D // Incoming call from 0x2B25, returns to 0x2B26 // Inputs[1] { @4B0F stack[-1] } 4B09 5B JUMPDEST 4B0A 60 PUSH1 0x00 4B0C 61 PUSH2 0x4b14 4B0F 82 DUP3 4B10 61 PUSH2 0x4c32 4B13 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4B0A stack[0] = 0x00 // @4B0C stack[1] = 0x4b14 // @4B0F stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4B14 label_4B14: // Incoming return from call to 0x4C32 at 0x4B13 // Inputs[3] // { // @4B15 stack[-1] // @4B15 stack[-3] // @4B1A stack[-4] // } 4B14 5B JUMPDEST 4B15 91 SWAP2 4B16 50 POP 4B17 61 PUSH2 0x4b1f 4B1A 83 DUP4 4B1B 61 PUSH2 0x4c32 4B1E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @4B15 stack[-3] = stack[-1] // @4B17 stack[-1] = 0x4b1f // @4B1A stack[0] = stack[-4] // } // Block ends with call to 0x4c32, returns to 0x4B1F label_4B1F: // Incoming return from call to 0x4C32 at 0x4B1E // Inputs[2] // { // @4B20 stack[-4] // @4B20 stack[-1] // } 4B1F 5B JUMPDEST 4B20 92 SWAP3 4B21 50 POP 4B22 82 DUP3 4B23 61 PUSH2 0x4b2f 4B26 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4B20 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x4b2f, if stack[-1] label_4B27: // Incoming jump from 0x4B26, if not stack[-1] 4B27 61 PUSH2 0x4b2e 4B2A 61 PUSH2 0x4d59 4B2D 56 *JUMP // Stack delta = +1 // Outputs[1] { @4B27 stack[0] = 0x4b2e } // Block ends with unconditional jump to 0x4d59 4B2E 5B JUMPDEST label_4B2F: // Incoming jump from 0x4B26, if stack[-1] // Inputs[4] // { // @4B30 stack[-3] // @4B31 stack[-2] // @4B33 stack[-1] // @4B35 stack[-4] // } 4B2F 5B JUMPDEST 4B30 82 DUP3 4B31 82 DUP3 4B32 04 DIV 4B33 90 SWAP1 4B34 50 POP 4B35 92 SWAP3 4B36 91 SWAP2 4B37 50 POP 4B38 50 POP 4B39 56 *JUMP // Stack delta = -3 // Outputs[1] { @4B35 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_4B3A: // Incoming call from 0x1541, returns to 0x1542 // Incoming call from 0x1D80, returns to 0x1D81 // Inputs[1] { @4B40 stack[-1] } 4B3A 5B JUMPDEST 4B3B 60 PUSH1 0x00 4B3D 61 PUSH2 0x4b45 4B40 82 DUP3 4B41 61 PUSH2 0x4c32 4B44 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4B3B stack[0] = 0x00 // @4B3D stack[1] = 0x4b45 // @4B40 stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4B45 label_4B45: // Incoming return from call to 0x4C32 at 0x4B44 // Inputs[3] // { // @4B46 stack[-3] // @4B46 stack[-1] // @4B4B stack[-4] // } 4B45 5B JUMPDEST 4B46 91 SWAP2 4B47 50 POP 4B48 61 PUSH2 0x4b50 4B4B 83 DUP4 4B4C 61 PUSH2 0x4c32 4B4F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @4B46 stack[-3] = stack[-1] // @4B48 stack[-1] = 0x4b50 // @4B4B stack[0] = stack[-4] // } // Block ends with call to 0x4c32, returns to 0x4B50 label_4B50: // Incoming return from call to 0x4C32 at 0x4B4F // Inputs[3] // { // @4B51 stack[-4] // @4B51 stack[-1] // @4B53 stack[-3] // } 4B50 5B JUMPDEST 4B51 92 SWAP3 4B52 50 POP 4B53 81 DUP2 4B54 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4B75 04 DIV 4B76 83 DUP4 4B77 11 GT 4B78 82 DUP3 4B79 15 ISZERO 4B7A 15 ISZERO 4B7B 16 AND 4B7C 15 ISZERO 4B7D 61 PUSH2 0x4b89 4B80 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4B51 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x4b89, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) label_4B81: // Incoming jump from 0x4B80, if not !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) 4B81 61 PUSH2 0x4b88 4B84 61 PUSH2 0x4d2a 4B87 56 *JUMP // Stack delta = +1 // Outputs[1] { @4B81 stack[0] = 0x4b88 } // Block ends with unconditional jump to 0x4d2a 4B88 5B JUMPDEST label_4B89: // Incoming jump from 0x4B80, if !(!!stack[-3] & (stack[-1] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / stack[-3])) // Inputs[4] // { // @4B8A stack[-3] // @4B8B stack[-2] // @4B8D stack[-1] // @4B8F stack[-4] // } 4B89 5B JUMPDEST 4B8A 82 DUP3 4B8B 82 DUP3 4B8C 02 MUL 4B8D 90 SWAP1 4B8E 50 POP 4B8F 92 SWAP3 4B90 91 SWAP2 4B91 50 POP 4B92 50 POP 4B93 56 *JUMP // Stack delta = -3 // Outputs[1] { @4B8F stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_4B94: // Incoming call from 0x2BB9, returns to 0x2BBA // Incoming call from 0x3471, returns to 0x3472 // Incoming call from 0x27D0, returns to 0x27D1 // Incoming call from 0x3307, returns to 0x3308 // Inputs[1] { @4B9A stack[-1] } 4B94 5B JUMPDEST 4B95 60 PUSH1 0x00 4B97 61 PUSH2 0x4b9f 4B9A 82 DUP3 4B9B 61 PUSH2 0x4c32 4B9E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4B95 stack[0] = 0x00 // @4B97 stack[1] = 0x4b9f // @4B9A stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4B9F label_4B9F: // Incoming return from call to 0x4C32 at 0x4B9E // Inputs[3] // { // @4BA0 stack[-3] // @4BA0 stack[-1] // @4BA5 stack[-4] // } 4B9F 5B JUMPDEST 4BA0 91 SWAP2 4BA1 50 POP 4BA2 61 PUSH2 0x4baa 4BA5 83 DUP4 4BA6 61 PUSH2 0x4c32 4BA9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @4BA0 stack[-3] = stack[-1] // @4BA2 stack[-1] = 0x4baa // @4BA5 stack[0] = stack[-4] // } // Block ends with call to 0x4c32, returns to 0x4BAA label_4BAA: // Incoming return from call to 0x4C32 at 0x4BA9 // Inputs[3] // { // @4BAB stack[-1] // @4BAB stack[-4] // @4BAE stack[-3] // } 4BAA 5B JUMPDEST 4BAB 92 SWAP3 4BAC 50 POP 4BAD 82 DUP3 4BAE 82 DUP3 4BAF 10 LT 4BB0 15 ISZERO 4BB1 61 PUSH2 0x4bbd 4BB4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4BAB stack[-4] = stack[-1] } // Block ends with conditional jump to 0x4bbd, if !(stack[-3] < stack[-1]) label_4BB5: // Incoming jump from 0x4BB4, if not !(stack[-3] < stack[-1]) 4BB5 61 PUSH2 0x4bbc 4BB8 61 PUSH2 0x4d2a 4BBB 56 *JUMP // Stack delta = +1 // Outputs[1] { @4BB5 stack[0] = 0x4bbc } // Block ends with unconditional jump to 0x4d2a 4BBC 5B JUMPDEST label_4BBD: // Incoming jump from 0x4BB4, if !(stack[-3] < stack[-1]) // Inputs[4] // { // @4BBE stack[-3] // @4BBF stack[-2] // @4BC1 stack[-1] // @4BC3 stack[-4] // } 4BBD 5B JUMPDEST 4BBE 82 DUP3 4BBF 82 DUP3 4BC0 03 SUB 4BC1 90 SWAP1 4BC2 50 POP 4BC3 92 SWAP3 4BC4 91 SWAP2 4BC5 50 POP 4BC6 50 POP 4BC7 56 *JUMP // Stack delta = -3 // Outputs[1] { @4BC3 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_4BC8: // Incoming call from 0x4DFF, returns to 0x4E00 // Incoming call from 0x3A67, returns to 0x3A68 // Inputs[1] { @4BCE stack[-1] } 4BC8 5B JUMPDEST 4BC9 60 PUSH1 0x00 4BCB 61 PUSH2 0x4bd3 4BCE 82 DUP3 4BCF 61 PUSH2 0x4c12 4BD2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4BC9 stack[0] = 0x00 // @4BCB stack[1] = 0x4bd3 // @4BCE stack[2] = stack[-1] // } // Block ends with call to 0x4c12, returns to 0x4BD3 label_4BD3: // Incoming return from call to 0x4C12 at 0x4BD2 // Inputs[4] // { // @4BD4 stack[-2] // @4BD4 stack[-1] // @4BD6 stack[-4] // @4BD7 stack[-3] // } 4BD3 5B JUMPDEST 4BD4 90 SWAP1 4BD5 50 POP 4BD6 91 SWAP2 4BD7 90 SWAP1 4BD8 50 POP 4BD9 56 *JUMP // Stack delta = -3 // Outputs[1] { @4BD6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_4BDA: // Incoming call from 0x4E16, returns to 0x4E17 // Incoming call from 0x3A76, returns to 0x3A77 // Inputs[2] // { // @4BDD stack[-1] // @4BE2 stack[-2] // } 4BDA 5B JUMPDEST 4BDB 60 PUSH1 0x00 4BDD 81 DUP2 4BDE 15 ISZERO 4BDF 15 ISZERO 4BE0 90 SWAP1 4BE1 50 POP 4BE2 91 SWAP2 4BE3 90 SWAP1 4BE4 50 POP 4BE5 56 *JUMP // Stack delta = -1 // Outputs[1] { @4BE2 stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_4BE6: // Incoming call from 0x4E2D, returns to 0x4E2E // Inputs[2] // { // @4C0A stack[-1] // @4C0E stack[-2] // } 4BE6 5B JUMPDEST 4BE7 60 PUSH1 0x00 4BE9 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 4C0A 82 DUP3 4C0B 16 AND 4C0C 90 SWAP1 4C0D 50 POP 4C0E 91 SWAP2 4C0F 90 SWAP1 4C10 50 POP 4C11 56 *JUMP // Stack delta = -1 // Outputs[1] { @4C0E stack[-2] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_4C12: // Incoming call from 0x4BD2, returns to 0x4BD3 // Inputs[2] // { // @4C2A stack[-1] // @4C2E stack[-2] // } 4C12 5B JUMPDEST 4C13 60 PUSH1 0x00 4C15 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4C2A 82 DUP3 4C2B 16 AND 4C2C 90 SWAP1 4C2D 50 POP 4C2E 91 SWAP2 4C2F 90 SWAP1 4C30 50 POP 4C31 56 *JUMP // Stack delta = -1 // Outputs[1] { @4C2E stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_4C32: // Incoming call from 0x4553, returns to 0x4554 // Incoming call from 0x4ABD, returns to 0x4ABE // Incoming call from 0x4B1E, returns to 0x4B1F // Incoming call from 0x4D0E, returns to 0x4D0F // Incoming call from 0x4B13, returns to 0x4B14 // Incoming call from 0x4CBA, returns to 0x4CBB // Incoming call from 0x4AC8, returns to 0x4AC9 // Incoming call from 0x4E44, returns to 0x4E45 // Incoming call from 0x4B9E, returns to 0x4B9F // Incoming call from 0x4B4F, returns to 0x4B50 // Incoming call from 0x4BA9, returns to 0x4BAA // Incoming call from 0x4B44, returns to 0x4B45 // Incoming call from 0x4D03, returns to 0x4D04 // Inputs[2] // { // @4C35 stack[-1] // @4C38 stack[-2] // } 4C32 5B JUMPDEST 4C33 60 PUSH1 0x00 4C35 81 DUP2 4C36 90 SWAP1 4C37 50 POP 4C38 91 SWAP2 4C39 90 SWAP1 4C3A 50 POP 4C3B 56 *JUMP // Stack delta = -1 // Outputs[1] { @4C38 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_4C3C: // Incoming call from 0x3736, returns to 0x3737 // Incoming call from 0x36F8, returns to 0x36F9 // Inputs[5] // { // @4C3D stack[-3] // @4C3E stack[-1] // @4C3F stack[-2] // @4C40 msg.data[stack[-1]:stack[-1] + stack[-3]] // @4C4A stack[-4] // } 4C3C 5B JUMPDEST 4C3D 82 DUP3 4C3E 81 DUP2 4C3F 83 DUP4 4C40 37 CALLDATACOPY 4C41 60 PUSH1 0x00 4C43 83 DUP4 4C44 83 DUP4 4C45 01 ADD 4C46 52 MSTORE 4C47 50 POP 4C48 50 POP 4C49 50 POP 4C4A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @4C40 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @4C46 memory[stack[-2] + stack[-3]:stack[-2] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_4C4B: // Incoming call from 0x3AA1, returns to 0x3AA2 // Incoming call from 0x3B13, returns to 0x3B14 // Incoming call from 0x3ADA, returns to 0x3ADB // Inputs[1] { @4C4F stack[-3] } 4C4B 5B JUMPDEST 4C4C 60 PUSH1 0x00 4C4E 5B JUMPDEST 4C4F 83 DUP4 4C50 81 DUP2 4C51 10 LT 4C52 15 ISZERO 4C53 61 PUSH2 0x4c69 4C56 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4C4C stack[0] = 0x00 } // Block ends with conditional jump to 0x4c69, if !(0x00 < stack[-3]) label_4C57: // Incoming jump from 0x4C56, if not !(0x00 < stack[-3]) // Incoming jump from 0x4C56, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @4C57 stack[-1] // @4C58 stack[-2] // @4C5A memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @4C5C stack[-3] // } 4C57 80 DUP1 4C58 82 DUP3 4C59 01 ADD 4C5A 51 MLOAD 4C5B 81 DUP2 4C5C 84 DUP5 4C5D 01 ADD 4C5E 52 MSTORE 4C5F 60 PUSH1 0x20 4C61 81 DUP2 4C62 01 ADD 4C63 90 SWAP1 4C64 50 POP 4C65 61 PUSH2 0x4c4e 4C68 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @4C5E memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @4C63 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x4c4e label_4C69: // Incoming jump from 0x4C56, if !(0x00 < stack[-3]) // Incoming jump from 0x4C56, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @4C6A stack[-4] // @4C6B stack[-1] // } 4C69 5B JUMPDEST 4C6A 83 DUP4 4C6B 81 DUP2 4C6C 11 GT 4C6D 15 ISZERO 4C6E 61 PUSH2 0x4c78 4C71 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4c78, if !(stack[-1] > stack[-4]) label_4C72: // Incoming jump from 0x4C71, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @4C74 stack[-4] // @4C75 stack[-3] // @4C7D stack[-5] // } 4C72 60 PUSH1 0x00 4C74 84 DUP5 4C75 84 DUP5 4C76 01 ADD 4C77 52 MSTORE 4C78 5B JUMPDEST 4C79 50 POP 4C7A 50 POP 4C7B 50 POP 4C7C 50 POP 4C7D 56 *JUMP // Stack delta = -5 // Outputs[1] { @4C77 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_4C7E: // Incoming call from 0x1EA7, returns to 0x1EA8 // Incoming call from 0x12E3, returns to 0x12E4 // Incoming call from 0x1ED3, returns to 0x1ED4 // Incoming call from 0x17E6, returns to 0x17E7 // Incoming call from 0x130F, returns to 0x1310 // Incoming call from 0x2A2F, returns to 0x2A30 // Incoming call from 0x3B2C, returns to 0x3B2D // Incoming call from 0x0AA9, returns to 0x0AAA // Incoming call from 0x1F9B, returns to 0x1F9C // Incoming call from 0x1812, returns to 0x1813 // Incoming call from 0x0A7D, returns to 0x0A7E // Incoming call from 0x2A5B, returns to 0x2A5C // Incoming call from 0x362B, returns to 0x362C // Incoming call from 0x0994, returns to 0x0995 // Incoming call from 0x0968, returns to 0x0969 // Incoming call from 0x1FC7, returns to 0x1FC8 // Inputs[1] { @4C83 stack[-1] } 4C7E 5B JUMPDEST 4C7F 60 PUSH1 0x00 4C81 60 PUSH1 0x02 4C83 82 DUP3 4C84 04 DIV 4C85 90 SWAP1 4C86 50 POP 4C87 60 PUSH1 0x01 4C89 82 DUP3 4C8A 16 AND 4C8B 80 DUP1 4C8C 61 PUSH2 0x4c96 4C8F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4C85 stack[0] = stack[-1] / 0x02 // @4C8A stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x4c96, if stack[-1] & 0x01 label_4C90: // Incoming jump from 0x4C8F, if not stack[-1] & 0x01 // Inputs[2] // { // @4C92 stack[-2] // @4C9B stack[-1] // } 4C90 60 PUSH1 0x7f 4C92 82 DUP3 4C93 16 AND 4C94 91 SWAP2 4C95 50 POP 4C96 5B JUMPDEST 4C97 60 PUSH1 0x20 4C99 82 DUP3 4C9A 10 LT 4C9B 81 DUP2 4C9C 14 EQ 4C9D 15 ISZERO 4C9E 61 PUSH2 0x4caa 4CA1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @4C94 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x4caa, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_4CA2: // Incoming jump from 0x4CA1, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x4CA1, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 4CA2 61 PUSH2 0x4ca9 4CA5 61 PUSH2 0x4d88 4CA8 56 *JUMP // Stack delta = +1 // Outputs[1] { @4CA2 stack[0] = 0x4ca9 } // Block ends with unconditional jump to 0x4d88 4CA9 5B JUMPDEST label_4CAA: // Incoming jump from 0x4CA1, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x4CA1, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @4CAC stack[-2] // @4CAC stack[-4] // @4CAD stack[-3] // } 4CAA 5B JUMPDEST 4CAB 50 POP 4CAC 91 SWAP2 4CAD 90 SWAP1 4CAE 50 POP 4CAF 56 *JUMP // Stack delta = -3 // Outputs[1] { @4CAC stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_4CB0: // Incoming call from 0x1E00, returns to 0x1E01 // Incoming call from 0x0D92, returns to 0x0D93 // Incoming call from 0x2B15, returns to 0x2B16 // Incoming call from 0x15C1, returns to 0x15C2 // Inputs[1] { @4CB6 stack[-1] } 4CB0 5B JUMPDEST 4CB1 60 PUSH1 0x00 4CB3 61 PUSH2 0x4cbb 4CB6 82 DUP3 4CB7 61 PUSH2 0x4c32 4CBA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4CB1 stack[0] = 0x00 // @4CB3 stack[1] = 0x4cbb // @4CB6 stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4CBB label_4CBB: // Incoming return from call to 0x4C32 at 0x4CBA // Inputs[2] // { // @4CBC stack[-3] // @4CBC stack[-1] // } 4CBB 5B JUMPDEST 4CBC 91 SWAP2 4CBD 50 POP 4CBE 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4CDF 82 DUP3 4CE0 14 EQ 4CE1 15 ISZERO 4CE2 61 PUSH2 0x4cee 4CE5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4CBC stack[-3] = stack[-1] } // Block ends with conditional jump to 0x4cee, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_4CE6: // Incoming jump from 0x4CE5, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 4CE6 61 PUSH2 0x4ced 4CE9 61 PUSH2 0x4d2a 4CEC 56 *JUMP // Stack delta = +1 // Outputs[1] { @4CE6 stack[0] = 0x4ced } // Block ends with unconditional jump to 0x4d2a 4CED 5B JUMPDEST label_4CEE: // Incoming jump from 0x4CE5, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @4CF1 stack[-2] // @4CF3 stack[-1] // @4CF5 stack[-3] // } 4CEE 5B JUMPDEST 4CEF 60 PUSH1 0x01 4CF1 82 DUP3 4CF2 01 ADD 4CF3 90 SWAP1 4CF4 50 POP 4CF5 91 SWAP2 4CF6 90 SWAP1 4CF7 50 POP 4CF8 56 *JUMP // Stack delta = -2 // Outputs[1] { @4CF5 stack[-3] = stack[-2] + 0x01 } // Block ends with unconditional jump to stack[-3] label_4CF9: // Incoming call from 0x2BC8, returns to 0x2BC9 // Inputs[1] { @4CFF stack[-1] } 4CF9 5B JUMPDEST 4CFA 60 PUSH1 0x00 4CFC 61 PUSH2 0x4d04 4CFF 82 DUP3 4D00 61 PUSH2 0x4c32 4D03 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4CFA stack[0] = 0x00 // @4CFC stack[1] = 0x4d04 // @4CFF stack[2] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4D04 label_4D04: // Incoming return from call to 0x4C32 at 0x4D03 // Inputs[3] // { // @4D05 stack[-3] // @4D05 stack[-1] // @4D0A stack[-4] // } 4D04 5B JUMPDEST 4D05 91 SWAP2 4D06 50 POP 4D07 61 PUSH2 0x4d0f 4D0A 83 DUP4 4D0B 61 PUSH2 0x4c32 4D0E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @4D05 stack[-3] = stack[-1] // @4D07 stack[-1] = 0x4d0f // @4D0A stack[0] = stack[-4] // } // Block ends with call to 0x4c32, returns to 0x4D0F label_4D0F: // Incoming return from call to 0x4C32 at 0x4D0E // Inputs[2] // { // @4D10 stack[-1] // @4D10 stack[-4] // } 4D0F 5B JUMPDEST 4D10 92 SWAP3 4D11 50 POP 4D12 82 DUP3 4D13 61 PUSH2 0x4d1f 4D16 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4D10 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x4d1f, if stack[-1] label_4D17: // Incoming jump from 0x4D16, if not stack[-1] 4D17 61 PUSH2 0x4d1e 4D1A 61 PUSH2 0x4d59 4D1D 56 *JUMP // Stack delta = +1 // Outputs[1] { @4D17 stack[0] = 0x4d1e } // Block ends with unconditional jump to 0x4d59 4D1E 5B JUMPDEST label_4D1F: // Incoming jump from 0x4D16, if stack[-1] // Inputs[4] // { // @4D20 stack[-3] // @4D21 stack[-2] // @4D23 stack[-1] // @4D25 stack[-4] // } 4D1F 5B JUMPDEST 4D20 82 DUP3 4D21 82 DUP3 4D22 06 MOD 4D23 90 SWAP1 4D24 50 POP 4D25 92 SWAP3 4D26 91 SWAP2 4D27 50 POP 4D28 50 POP 4D29 56 *JUMP // Stack delta = -3 // Outputs[1] { @4D25 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_4D2A: // Incoming jump from 0x4BBB // Incoming jump from 0x4B87 // Incoming jump from 0x4AFC // Incoming jump from 0x4CEC // Inputs[1] { @4D58 memory[0x00:0x24] } 4D2A 5B JUMPDEST 4D2B 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 4D4C 60 PUSH1 0x00 4D4E 52 MSTORE 4D4F 60 PUSH1 0x11 4D51 60 PUSH1 0x04 4D53 52 MSTORE 4D54 60 PUSH1 0x24 4D56 60 PUSH1 0x00 4D58 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @4D4E memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @4D53 memory[0x04:0x24] = 0x11 // @4D58 revert(memory[0x00:0x24]); // } // Block terminates label_4D59: // Incoming jump from 0x4D1D // Incoming jump from 0x4B2D // Inputs[1] { @4D87 memory[0x00:0x24] } 4D59 5B JUMPDEST 4D5A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 4D7B 60 PUSH1 0x00 4D7D 52 MSTORE 4D7E 60 PUSH1 0x12 4D80 60 PUSH1 0x04 4D82 52 MSTORE 4D83 60 PUSH1 0x24 4D85 60 PUSH1 0x00 4D87 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @4D7D memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @4D82 memory[0x04:0x24] = 0x12 // @4D87 revert(memory[0x00:0x24]); // } // Block terminates label_4D88: // Incoming jump from 0x4CA8 // Inputs[1] { @4DB6 memory[0x00:0x24] } 4D88 5B JUMPDEST 4D89 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 4DAA 60 PUSH1 0x00 4DAC 52 MSTORE 4DAD 60 PUSH1 0x22 4DAF 60 PUSH1 0x04 4DB1 52 MSTORE 4DB2 60 PUSH1 0x24 4DB4 60 PUSH1 0x00 4DB6 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @4DAC memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @4DB1 memory[0x04:0x24] = 0x22 // @4DB6 revert(memory[0x00:0x24]); // } // Block terminates label_4DB7: // Incoming jump from 0x4A44 // Incoming jump from 0x4A14 // Incoming jump from 0x49EF // Inputs[1] { @4DE5 memory[0x00:0x24] } 4DB7 5B JUMPDEST 4DB8 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 4DD9 60 PUSH1 0x00 4DDB 52 MSTORE 4DDC 60 PUSH1 0x41 4DDE 60 PUSH1 0x04 4DE0 52 MSTORE 4DE1 60 PUSH1 0x24 4DE3 60 PUSH1 0x00 4DE5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @4DDB memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @4DE0 memory[0x04:0x24] = 0x41 // @4DE5 revert(memory[0x00:0x24]); // } // Block terminates label_4DE6: // Incoming call from 0x3AE3, returns to 0x3AE4 // Incoming call from 0x3AAA, returns to 0x3AAB // Inputs[2] // { // @4DEE stack[-1] // @4DF3 stack[-2] // } 4DE6 5B JUMPDEST 4DE7 60 PUSH1 0x00 4DE9 60 PUSH1 0x1f 4DEB 19 NOT 4DEC 60 PUSH1 0x1f 4DEE 83 DUP4 4DEF 01 ADD 4DF0 16 AND 4DF1 90 SWAP1 4DF2 50 POP 4DF3 91 SWAP2 4DF4 90 SWAP1 4DF5 50 POP 4DF6 56 *JUMP // Stack delta = -1 // Outputs[1] { @4DF3 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_4DF7: // Incoming call from 0x374D, returns to 0x374E // Inputs[1] { @4DFB stack[-1] } 4DF7 5B JUMPDEST 4DF8 61 PUSH2 0x4e00 4DFB 81 DUP2 4DFC 61 PUSH2 0x4bc8 4DFF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4DF8 stack[0] = 0x4e00 // @4DFB stack[1] = stack[-1] // } // Block ends with call to 0x4bc8, returns to 0x4E00 label_4E00: // Incoming return from call to 0x4BC8 at 0x4DFF // Inputs[2] // { // @4E01 stack[-2] // @4E02 stack[-1] // } 4E00 5B JUMPDEST 4E01 81 DUP2 4E02 14 EQ 4E03 61 PUSH2 0x4e0b 4E06 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4e0b, if stack[-2] == stack[-1] label_4E07: // Incoming jump from 0x4E06, if not stack[-2] == stack[-1] // Inputs[1] { @4E0A memory[0x00:0x00] } 4E07 60 PUSH1 0x00 4E09 80 DUP1 4E0A FD *REVERT // Stack delta = +0 // Outputs[1] { @4E0A revert(memory[0x00:0x00]); } // Block terminates label_4E0B: // Incoming jump from 0x4E06, if stack[-2] == stack[-1] // Inputs[1] { @4E0D stack[-2] } 4E0B 5B JUMPDEST 4E0C 50 POP 4E0D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_4E0E: // Incoming call from 0x3762, returns to 0x3763 // Inputs[1] { @4E12 stack[-1] } 4E0E 5B JUMPDEST 4E0F 61 PUSH2 0x4e17 4E12 81 DUP2 4E13 61 PUSH2 0x4bda 4E16 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4E0F stack[0] = 0x4e17 // @4E12 stack[1] = stack[-1] // } // Block ends with call to 0x4bda, returns to 0x4E17 label_4E17: // Incoming return from call to 0x4BDA at 0x4E16 // Inputs[2] // { // @4E18 stack[-2] // @4E19 stack[-1] // } 4E17 5B JUMPDEST 4E18 81 DUP2 4E19 14 EQ 4E1A 61 PUSH2 0x4e22 4E1D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4e22, if stack[-2] == stack[-1] label_4E1E: // Incoming jump from 0x4E1D, if not stack[-2] == stack[-1] // Inputs[1] { @4E21 memory[0x00:0x00] } 4E1E 60 PUSH1 0x00 4E20 80 DUP1 4E21 FD *REVERT // Stack delta = +0 // Outputs[1] { @4E21 revert(memory[0x00:0x00]); } // Block terminates label_4E22: // Incoming jump from 0x4E1D, if stack[-2] == stack[-1] // Inputs[1] { @4E24 stack[-2] } 4E22 5B JUMPDEST 4E23 50 POP 4E24 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_4E25: // Incoming call from 0x3777, returns to 0x3778 // Incoming call from 0x378C, returns to 0x378D // Inputs[1] { @4E29 stack[-1] } 4E25 5B JUMPDEST 4E26 61 PUSH2 0x4e2e 4E29 81 DUP2 4E2A 61 PUSH2 0x4be6 4E2D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4E26 stack[0] = 0x4e2e // @4E29 stack[1] = stack[-1] // } // Block ends with call to 0x4be6, returns to 0x4E2E label_4E2E: // Incoming return from call to 0x4BE6 at 0x4E2D // Inputs[2] // { // @4E2F stack[-2] // @4E30 stack[-1] // } 4E2E 5B JUMPDEST 4E2F 81 DUP2 4E30 14 EQ 4E31 61 PUSH2 0x4e39 4E34 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4e39, if stack[-2] == stack[-1] label_4E35: // Incoming jump from 0x4E34, if not stack[-2] == stack[-1] // Inputs[1] { @4E38 memory[0x00:0x00] } 4E35 60 PUSH1 0x00 4E37 80 DUP1 4E38 FD *REVERT // Stack delta = +0 // Outputs[1] { @4E38 revert(memory[0x00:0x00]); } // Block terminates label_4E39: // Incoming jump from 0x4E34, if stack[-2] == stack[-1] // Inputs[1] { @4E3B stack[-2] } 4E39 5B JUMPDEST 4E3A 50 POP 4E3B 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_4E3C: // Incoming call from 0x37F5, returns to 0x37F6 // Inputs[1] { @4E40 stack[-1] } 4E3C 5B JUMPDEST 4E3D 61 PUSH2 0x4e45 4E40 81 DUP2 4E41 61 PUSH2 0x4c32 4E44 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4E3D stack[0] = 0x4e45 // @4E40 stack[1] = stack[-1] // } // Block ends with call to 0x4c32, returns to 0x4E45 label_4E45: // Incoming return from call to 0x4C32 at 0x4E44 // Inputs[2] // { // @4E46 stack[-2] // @4E47 stack[-1] // } 4E45 5B JUMPDEST 4E46 81 DUP2 4E47 14 EQ 4E48 61 PUSH2 0x4e50 4E4B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4e50, if stack[-2] == stack[-1] label_4E4C: // Incoming jump from 0x4E4B, if not stack[-2] == stack[-1] // Inputs[1] { @4E4F memory[0x00:0x00] } 4E4C 60 PUSH1 0x00 4E4E 80 DUP1 4E4F FD *REVERT // Stack delta = +0 // Outputs[1] { @4E4F revert(memory[0x00:0x00]); } // Block terminates label_4E50: // Incoming jump from 0x4E4B, if stack[-2] == stack[-1] // Inputs[1] { @4E52 stack[-2] } 4E50 5B JUMPDEST 4E51 50 POP 4E52 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 4E53 FE *ASSERT 4E54 A2 LOG2 4E55 64 PUSH5 0x6970667358 4E5B 22 22 4E5C 12 SLT 4E5D 20 SHA3 4E5E 55 SSTORE 4E5F 84 DUP5 4E60 8D DUP14 4E61 AB AB 4E62 A8 A8 4E63 D7 D7 4E64 4E 4E 4E65 1C SHR 4E66 8A DUP11 4E67 2F 2F 4E68 BD BD 4E69 A5 A5 4E6A D7 D7 4E6B C0 C0 4E6C 4A 4A 4E6D DC DC 4E6E 95 SWAP6 4E6F 21 21 4E70 EB EB 4E71 DC DC 4E72 42 TIMESTAMP 4E73 A6 A6 4E74 C4 C4 4E75 F7 F7 4E76 9E SWAP15 4E77 4F 4F 4E78 B7 B7 4E79 BA BA 4E7A 65 PUSH6 0x0ec9c764736f 4E81 6C PUSH13 0x63430008000033