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 0x0184 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0184, 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 0xa8920d2b 0019 11 GT 001A 61 PUSH2 0x00d6 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00d6, if 0xa8920d2b > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0xa8920d2b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xd9c45357 0024 11 GT 0025 61 PUSH2 0x007f 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007f, if 0xd9c45357 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xd9c45357 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xeb5625d9 002F 11 GT 0030 61 PUSH2 0x0059 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xeb5625d9 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xeb5625d9 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xeb5625d9 003A 14 EQ 003B 61 PUSH2 0x0458 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0458, if 0xeb5625d9 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xeb5625d9 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xec77bbdb 0045 14 EQ 0046 61 PUSH2 0x0478 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0478, if 0xec77bbdb == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xec77bbdb == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf1e64c20 0050 14 EQ 0051 61 PUSH2 0x0498 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0498, if 0xf1e64c20 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf1e64c20 == stack[-1] 0055 61 PUSH2 0x01ce 0058 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_0059: // Incoming jump from 0x0033, if 0xeb5625d9 > stack[-1] // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0xd9c45357 0060 14 EQ 0061 61 PUSH2 0x040a 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040a, if 0xd9c45357 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0xd9c45357 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0xe0d12ba5 006B 14 EQ 006C 61 PUSH2 0x0418 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0418, if 0xe0d12ba5 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xe0d12ba5 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xe27703c7 0076 14 EQ 0077 61 PUSH2 0x0438 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0438, if 0xe27703c7 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xe27703c7 == stack[-1] 007B 61 PUSH2 0x01ce 007E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_007F: // Incoming jump from 0x0028, if 0xd9c45357 > stack[-1] // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0xc9f12e9d 0086 11 GT 0087 61 PUSH2 0x00b0 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b0, if 0xc9f12e9d > stack[-1] label_008B: // Incoming jump from 0x008A, if not 0xc9f12e9d > stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0xc9f12e9d 0091 14 EQ 0092 61 PUSH2 0x03aa 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03aa, if 0xc9f12e9d == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xc9f12e9d == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xca19ebd9 009C 14 EQ 009D 61 PUSH2 0x03ca 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0xca19ebd9 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xca19ebd9 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xd1660f99 00A7 14 EQ 00A8 61 PUSH2 0x03ea 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ea, if 0xd1660f99 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xd1660f99 == stack[-1] 00AC 61 PUSH2 0x01ce 00AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_00B0: // Incoming jump from 0x008A, if 0xc9f12e9d > stack[-1] // Inputs[1] { @00B1 stack[-1] } 00B0 5B JUMPDEST 00B1 80 DUP1 00B2 63 PUSH4 0xa8920d2b 00B7 14 EQ 00B8 61 PUSH2 0x034a 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034a, if 0xa8920d2b == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0xa8920d2b == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0xb122f1c5 00C2 14 EQ 00C3 61 PUSH2 0x036a 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036a, if 0xb122f1c5 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xb122f1c5 == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0xb3af37c0 00CD 14 EQ 00CE 61 PUSH2 0x038a 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038a, if 0xb3af37c0 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0xb3af37c0 == stack[-1] 00D2 61 PUSH2 0x01ce 00D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_00D6: // Incoming jump from 0x001D, if 0xa8920d2b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00D7 stack[-1] } 00D6 5B JUMPDEST 00D7 80 DUP1 00D8 63 PUSH4 0x29439004 00DD 11 GT 00DE 61 PUSH2 0x0138 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0138, if 0x29439004 > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x29439004 > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0x70bdb947 00E8 11 GT 00E9 61 PUSH2 0x0112 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0112, if 0x70bdb947 > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x70bdb947 > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x70bdb947 00F3 14 EQ 00F4 61 PUSH2 0x02ea 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ea, if 0x70bdb947 == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x70bdb947 == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x7f8fe7a0 00FE 14 EQ 00FF 61 PUSH2 0x030a 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030a, if 0x7f8fe7a0 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x7f8fe7a0 == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x83f1291f 0109 14 EQ 010A 61 PUSH2 0x032a 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032a, if 0x83f1291f == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x83f1291f == stack[-1] 010E 61 PUSH2 0x01ce 0111 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_0112: // Incoming jump from 0x00EC, if 0x70bdb947 > stack[-1] // Inputs[1] { @0113 stack[-1] } 0112 5B JUMPDEST 0113 80 DUP1 0114 63 PUSH4 0x29439004 0119 14 EQ 011A 61 PUSH2 0x027d 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027d, if 0x29439004 == stack[-1] label_011E: // Incoming jump from 0x011D, if not 0x29439004 == stack[-1] // Inputs[1] { @011E stack[-1] } 011E 80 DUP1 011F 63 PUSH4 0x2e215923 0124 14 EQ 0125 61 PUSH2 0x02aa 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0x2e215923 == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x2e215923 == stack[-1] // Inputs[1] { @0129 stack[-1] } 0129 80 DUP1 012A 63 PUSH4 0x56368850 012F 14 EQ 0130 61 PUSH2 0x02ca 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ca, if 0x56368850 == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x56368850 == stack[-1] 0134 61 PUSH2 0x01ce 0137 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_0138: // Incoming jump from 0x00E1, if 0x29439004 > stack[-1] // Inputs[1] { @0139 stack[-1] } 0138 5B JUMPDEST 0139 80 DUP1 013A 63 PUSH4 0x0c7e1209 013F 11 GT 0140 61 PUSH2 0x0169 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0169, if 0x0c7e1209 > stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x0c7e1209 > stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x0c7e1209 014A 14 EQ 014B 61 PUSH2 0x0206 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0206, if 0x0c7e1209 == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x0c7e1209 == stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x1d97832e 0155 14 EQ 0156 61 PUSH2 0x0226 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0226, if 0x1d97832e == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x1d97832e == stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x293c72ed 0160 14 EQ 0161 61 PUSH2 0x025d 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025d, if 0x293c72ed == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x293c72ed == stack[-1] 0165 61 PUSH2 0x01ce 0168 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_0169: // Incoming jump from 0x0143, if 0x0c7e1209 > stack[-1] // Inputs[1] { @016A stack[-1] } 0169 5B JUMPDEST 016A 80 DUP1 016B 63 PUSH4 0x05971224 0170 14 EQ 0171 61 PUSH2 0x01d3 0174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d3, if 0x05971224 == stack[-1] label_0175: // Incoming jump from 0x0174, if not 0x05971224 == stack[-1] // Inputs[1] { @0175 stack[-1] } 0175 80 DUP1 0176 63 PUSH4 0x08d4b9e1 017B 14 EQ 017C 61 PUSH2 0x01e6 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e6, if 0x08d4b9e1 == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x08d4b9e1 == stack[-1] 0180 61 PUSH2 0x01ce 0183 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01ce label_0184: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0185 msg.data.length } 0184 5B JUMPDEST 0185 36 CALLDATASIZE 0186 61 PUSH2 0x01ce 0189 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ce, if msg.data.length label_018A: // Incoming jump from 0x0189, if not msg.data.length // Inputs[2] // { // @018A msg.sender // @018B tx.origin // } 018A 33 CALLER 018B 32 ORIGIN 018C 14 EQ 018D 15 ISZERO 018E 61 PUSH2 0x01cc 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if !(tx.origin == msg.sender) label_0192: // Incoming jump from 0x0191, if not !(tx.origin == msg.sender) // Inputs[1] { @0194 memory[0x40:0x60] } 0192 60 PUSH1 0x40 0194 51 MLOAD 0195 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 01B6 81 DUP2 01B7 52 MSTORE 01B8 60 PUSH1 0x04 01BA 01 ADD 01BB 61 PUSH2 0x01c3 01BE 90 SWAP1 01BF 61 PUSH2 0x3f70 01C2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @01BE stack[0] = 0x01c3 // @01BE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3f70, returns to 0x01C3 label_01C3: // Incoming return from call to 0x3E7A at 0x0E60 // Incoming return from call to 0x422A at 0x24FA // Incoming return from call to 0x3F02 at 0x085A // Incoming return from call to 0x41BC at 0x1FB6 // Incoming return from call to 0x3FDE at 0x1C40 // Incoming return from call to 0x3FA7 at 0x1C8D // Incoming return from call to 0x404C at 0x23FF // Incoming return from call to 0x3F70 at 0x01C2 // Incoming return from call to 0x3ECB at 0x26D3 // Incoming return from call to 0x4083 at 0x0BB7 // Incoming return from call to 0x40BA at 0x1C05 // Incoming return from call to 0x4185 at 0x0F87 // Incoming return from call to 0x3F39 at 0x2842 // Incoming return from call to 0x3E7A at 0x0A23 // Incoming return from call to 0x3F02 at 0x19EE // Incoming return from call to 0x4117 at 0x0BF7 // Incoming return from call to 0x4015 at 0x28F0 // Inputs[3] // { // @01C6 memory[0x40:0x60] // @01C8 stack[-1] // @01CB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01C3 5B JUMPDEST 01C4 60 PUSH1 0x40 01C6 51 MLOAD 01C7 80 DUP1 01C8 91 SWAP2 01C9 03 SUB 01CA 90 SWAP1 01CB FD *REVERT // Stack delta = -1 // Outputs[1] { @01CB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_01CC: // Incoming return from call to 0x0365 at 0x0364 // Incoming return from call to 0x02E5 at 0x02E4 // Incoming jump from 0x0191, if !(tx.origin == msg.sender) // Incoming return from call to 0x01E1 at 0x01E0 // Incoming return from call to 0x02C5 at 0x02C4 // Incoming return from call to 0x03C5 at 0x03C4 // Incoming return from call to 0x0453 at 0x0452 // Incoming return from call to 0x0365 at 0x0417 // Incoming return from call to 0x0221 at 0x0220 // Incoming return from call to 0x0278 at 0x0277 // Incoming return from call to 0x0405 at 0x0404 01CC 5B JUMPDEST 01CD 00 *STOP // Stack delta = +0 // Outputs[1] { @01CD stop(); } // Block terminates label_01CE: // Incoming jump from 0x0168 // Incoming jump from 0x0111 // Incoming jump from 0x0058 // Incoming jump from 0x00D5 // Incoming jump from 0x007E // Incoming jump from 0x00AF // Incoming jump from 0x0189, if msg.data.length // Incoming jump from 0x0137 // Incoming jump from 0x0183 // Inputs[1] { @01D2 memory[0x00:0x00] } 01CE 5B JUMPDEST 01CF 60 PUSH1 0x00 01D1 80 DUP1 01D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D2 revert(memory[0x00:0x00]); } // Block terminates label_01D3: // Incoming jump from 0x0174, if 0x05971224 == stack[-1] // Inputs[1] { @01DA msg.data.length } 01D3 5B JUMPDEST 01D4 61 PUSH2 0x01cc 01D7 61 PUSH2 0x01e1 01DA 36 CALLDATASIZE 01DB 60 PUSH1 0x04 01DD 61 PUSH2 0x3600 01E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D4 stack[0] = 0x01cc // @01D7 stack[1] = 0x01e1 // @01DA stack[2] = msg.data.length // @01DB stack[3] = 0x04 // } // Block ends with call to 0x3600, returns to 0x01E1 label_01E1: // Incoming return from call to 0x3600 at 0x01E0 01E1 5B JUMPDEST 01E2 61 PUSH2 0x04b8 01E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04b8 label_01E6: // Incoming jump from 0x017F, if 0x08d4b9e1 == stack[-1] // Inputs[1] { @01E7 msg.value } 01E6 5B JUMPDEST 01E7 34 CALLVALUE 01E8 80 DUP1 01E9 15 ISZERO 01EA 61 PUSH2 0x01f2 01ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01E7 stack[0] = msg.value } // Block ends with conditional jump to 0x01f2, if !msg.value label_01EE: // Incoming jump from 0x01ED, if not !msg.value // Inputs[1] { @01F1 memory[0x00:0x00] } 01EE 60 PUSH1 0x00 01F0 80 DUP1 01F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F1 revert(memory[0x00:0x00]); } // Block terminates label_01F2: // Incoming jump from 0x01ED, if !msg.value // Inputs[1] { @01FA msg.data.length } 01F2 5B JUMPDEST 01F3 50 POP 01F4 61 PUSH2 0x01cc 01F7 61 PUSH2 0x0201 01FA 36 CALLDATASIZE 01FB 60 PUSH1 0x04 01FD 61 PUSH2 0x3964 0200 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01F4 stack[-1] = 0x01cc // @01F7 stack[0] = 0x0201 // @01FA stack[1] = msg.data.length // @01FB stack[2] = 0x04 // } // Block ends with call to 0x3964, returns to 0x0201 label_0201: // Incoming return from call to 0x3964 at 0x0200 0201 5B JUMPDEST 0202 61 PUSH2 0x077f 0205 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x077f label_0206: // Incoming jump from 0x014E, if 0x0c7e1209 == stack[-1] // Inputs[1] { @0207 msg.value } 0206 5B JUMPDEST 0207 34 CALLVALUE 0208 80 DUP1 0209 15 ISZERO 020A 61 PUSH2 0x0212 020D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0207 stack[0] = msg.value } // Block ends with conditional jump to 0x0212, if !msg.value label_020E: // Incoming jump from 0x020D, if not !msg.value // Inputs[1] { @0211 memory[0x00:0x00] } 020E 60 PUSH1 0x00 0210 80 DUP1 0211 FD *REVERT // Stack delta = +0 // Outputs[1] { @0211 revert(memory[0x00:0x00]); } // Block terminates label_0212: // Incoming jump from 0x020D, if !msg.value // Inputs[1] { @021A msg.data.length } 0212 5B JUMPDEST 0213 50 POP 0214 61 PUSH2 0x01cc 0217 61 PUSH2 0x0221 021A 36 CALLDATASIZE 021B 60 PUSH1 0x04 021D 61 PUSH2 0x3738 0220 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0214 stack[-1] = 0x01cc // @0217 stack[0] = 0x0221 // @021A stack[1] = msg.data.length // @021B stack[2] = 0x04 // } // Block ends with call to 0x3738, returns to 0x0221 label_0221: // Incoming return from call to 0x3738 at 0x0220 // Incoming return from call to 0x4378 at 0x2538 0221 5B JUMPDEST 0222 61 PUSH2 0x081d 0225 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x081d label_0226: // Incoming jump from 0x0159, if 0x1d97832e == stack[-1] // Inputs[1] { @0227 msg.value } 0226 5B JUMPDEST 0227 34 CALLVALUE 0228 80 DUP1 0229 15 ISZERO 022A 61 PUSH2 0x0232 022D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0227 stack[0] = msg.value } // Block ends with conditional jump to 0x0232, if !msg.value label_022E: // Incoming jump from 0x022D, if not !msg.value // Inputs[1] { @0231 memory[0x00:0x00] } 022E 60 PUSH1 0x00 0230 80 DUP1 0231 FD *REVERT // Stack delta = +0 // Outputs[1] { @0231 revert(memory[0x00:0x00]); } // Block terminates label_0232: // Incoming jump from 0x022D, if !msg.value // Inputs[1] { @023A msg.data.length } 0232 5B JUMPDEST 0233 50 POP 0234 61 PUSH2 0x0246 0237 61 PUSH2 0x0241 023A 36 CALLDATASIZE 023B 60 PUSH1 0x04 023D 61 PUSH2 0x3a0e 0240 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0234 stack[-1] = 0x0246 // @0237 stack[0] = 0x0241 // @023A stack[1] = msg.data.length // @023B stack[2] = 0x04 // } // Block ends with call to 0x3a0e, returns to 0x0241 label_0241: // Incoming return from call to 0x3A0E at 0x0240 0241 5B JUMPDEST 0242 61 PUSH2 0x0a63 0245 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a63 label_0246: // Incoming return from call to 0x0241 at 0x0240 // Inputs[3] // { // @0249 memory[0x40:0x60] // @024D stack[-2] // @024E stack[-1] // } 0246 5B JUMPDEST 0247 60 PUSH1 0x40 0249 51 MLOAD 024A 61 PUSH2 0x0254 024D 92 SWAP3 024E 91 SWAP2 024F 90 SWAP1 0250 61 PUSH2 0x3ce9 0253 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @024D stack[-2] = 0x0254 // @024E stack[-1] = stack[-2] // @024F stack[1] = memory[0x40:0x60] // @024F stack[0] = stack[-1] // } // Block ends with call to 0x3ce9, returns to 0x0254 label_0254: // Incoming return from call to 0x3CE9 at 0x0253 // Incoming return from call to 0x3CBF at 0x02A9 // Inputs[3] // { // @0257 memory[0x40:0x60] // @0259 stack[-1] // @025C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0254 5B JUMPDEST 0255 60 PUSH1 0x40 0257 51 MLOAD 0258 80 DUP1 0259 91 SWAP2 025A 03 SUB 025B 90 SWAP1 025C F3 *RETURN // Stack delta = -1 // Outputs[1] { @025C return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_025D: // Incoming jump from 0x0164, if 0x293c72ed == stack[-1] // Inputs[1] { @025E msg.value } 025D 5B JUMPDEST 025E 34 CALLVALUE 025F 80 DUP1 0260 15 ISZERO 0261 61 PUSH2 0x0269 0264 57 *JUMPI // Stack delta = +1 // Outputs[1] { @025E stack[0] = msg.value } // Block ends with conditional jump to 0x0269, if !msg.value label_0265: // Incoming jump from 0x0264, if not !msg.value // Inputs[1] { @0268 memory[0x00:0x00] } 0265 60 PUSH1 0x00 0267 80 DUP1 0268 FD *REVERT // Stack delta = +0 // Outputs[1] { @0268 revert(memory[0x00:0x00]); } // Block terminates label_0269: // Incoming jump from 0x0264, if !msg.value // Inputs[1] { @0271 msg.data.length } 0269 5B JUMPDEST 026A 50 POP 026B 61 PUSH2 0x01cc 026E 61 PUSH2 0x0278 0271 36 CALLDATASIZE 0272 60 PUSH1 0x04 0274 61 PUSH2 0x3458 0277 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @026B stack[-1] = 0x01cc // @026E stack[0] = 0x0278 // @0271 stack[1] = msg.data.length // @0272 stack[2] = 0x04 // } // Block ends with call to 0x3458, returns to 0x0278 label_0278: // Incoming return from call to 0x3458 at 0x0277 0278 5B JUMPDEST 0279 61 PUSH2 0x0ab4 027C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab4 label_027D: // Incoming jump from 0x011D, if 0x29439004 == stack[-1] // Inputs[1] { @027E msg.value } 027D 5B JUMPDEST 027E 34 CALLVALUE 027F 80 DUP1 0280 15 ISZERO 0281 61 PUSH2 0x0289 0284 57 *JUMPI // Stack delta = +1 // Outputs[1] { @027E stack[0] = msg.value } // Block ends with conditional jump to 0x0289, if !msg.value label_0285: // Incoming jump from 0x0284, if not !msg.value // Inputs[1] { @0288 memory[0x00:0x00] } 0285 60 PUSH1 0x00 0287 80 DUP1 0288 FD *REVERT // Stack delta = +0 // Outputs[1] { @0288 revert(memory[0x00:0x00]); } // Block terminates label_0289: // Incoming jump from 0x0284, if !msg.value // Inputs[1] { @0291 msg.data.length } 0289 5B JUMPDEST 028A 50 POP 028B 61 PUSH2 0x029d 028E 61 PUSH2 0x0298 0291 36 CALLDATASIZE 0292 60 PUSH1 0x04 0294 61 PUSH2 0x39ca 0297 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @028B stack[-1] = 0x029d // @028E stack[0] = 0x0298 // @0291 stack[1] = msg.data.length // @0292 stack[2] = 0x04 // } // Block ends with call to 0x39ca, returns to 0x0298 label_0298: // Incoming return from call to 0x39CA at 0x0297 0298 5B JUMPDEST 0299 61 PUSH2 0x0ae8 029C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ae8 label_029D: // Incoming return from call to 0x0298 at 0x0297 // Incoming return from call to 0x0305 at 0x0304 // Inputs[2] // { // @02A0 memory[0x40:0x60] // @02A4 stack[-1] // } 029D 5B JUMPDEST 029E 60 PUSH1 0x40 02A0 51 MLOAD 02A1 61 PUSH2 0x0254 02A4 91 SWAP2 02A5 90 SWAP1 02A6 61 PUSH2 0x3cbf 02A9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02A4 stack[-1] = 0x0254 // @02A5 stack[1] = memory[0x40:0x60] // @02A5 stack[0] = stack[-1] // } // Block ends with call to 0x3cbf, returns to 0x0254 label_02AA: // Incoming jump from 0x0128, if 0x2e215923 == stack[-1] // Inputs[1] { @02AB msg.value } 02AA 5B JUMPDEST 02AB 34 CALLVALUE 02AC 80 DUP1 02AD 15 ISZERO 02AE 61 PUSH2 0x02b6 02B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02AB stack[0] = msg.value } // Block ends with conditional jump to 0x02b6, if !msg.value label_02B2: // Incoming jump from 0x02B1, if not !msg.value // Inputs[1] { @02B5 memory[0x00:0x00] } 02B2 60 PUSH1 0x00 02B4 80 DUP1 02B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B5 revert(memory[0x00:0x00]); } // Block terminates label_02B6: // Incoming jump from 0x02B1, if !msg.value // Inputs[1] { @02BE msg.data.length } 02B6 5B JUMPDEST 02B7 50 POP 02B8 61 PUSH2 0x01cc 02BB 61 PUSH2 0x02c5 02BE 36 CALLDATASIZE 02BF 60 PUSH1 0x04 02C1 61 PUSH2 0x334a 02C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B8 stack[-1] = 0x01cc // @02BB stack[0] = 0x02c5 // @02BE stack[1] = msg.data.length // @02BF stack[2] = 0x04 // } // Block ends with call to 0x334a, returns to 0x02C5 label_02C5: // Incoming return from call to 0x334A at 0x02C4 02C5 5B JUMPDEST 02C6 61 PUSH2 0x0b22 02C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b22 label_02CA: // Incoming jump from 0x0133, if 0x56368850 == stack[-1] // Inputs[1] { @02CB msg.value } 02CA 5B JUMPDEST 02CB 34 CALLVALUE 02CC 80 DUP1 02CD 15 ISZERO 02CE 61 PUSH2 0x02d6 02D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CB stack[0] = msg.value } // Block ends with conditional jump to 0x02d6, if !msg.value label_02D2: // Incoming jump from 0x02D1, if not !msg.value // Inputs[1] { @02D5 memory[0x00:0x00] } 02D2 60 PUSH1 0x00 02D4 80 DUP1 02D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D5 revert(memory[0x00:0x00]); } // Block terminates label_02D6: // Incoming jump from 0x02D1, if !msg.value // Inputs[1] { @02DE msg.data.length } 02D6 5B JUMPDEST 02D7 50 POP 02D8 61 PUSH2 0x01cc 02DB 61 PUSH2 0x02e5 02DE 36 CALLDATASIZE 02DF 60 PUSH1 0x04 02E1 61 PUSH2 0x33b8 02E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D8 stack[-1] = 0x01cc // @02DB stack[0] = 0x02e5 // @02DE stack[1] = msg.data.length // @02DF stack[2] = 0x04 // } // Block ends with call to 0x33b8, returns to 0x02E5 label_02E5: // Incoming return from call to 0x33B8 at 0x02E4 02E5 5B JUMPDEST 02E6 61 PUSH2 0x0bc1 02E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bc1 label_02EA: // Incoming jump from 0x00F7, if 0x70bdb947 == stack[-1] // Inputs[1] { @02EB msg.value } 02EA 5B JUMPDEST 02EB 34 CALLVALUE 02EC 80 DUP1 02ED 15 ISZERO 02EE 61 PUSH2 0x02f6 02F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02EB stack[0] = msg.value } // Block ends with conditional jump to 0x02f6, if !msg.value label_02F2: // Incoming jump from 0x02F1, if not !msg.value // Inputs[1] { @02F5 memory[0x00:0x00] } 02F2 60 PUSH1 0x00 02F4 80 DUP1 02F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F5 revert(memory[0x00:0x00]); } // Block terminates label_02F6: // Incoming jump from 0x02F1, if !msg.value // Inputs[1] { @02FE msg.data.length } 02F6 5B JUMPDEST 02F7 50 POP 02F8 61 PUSH2 0x029d 02FB 61 PUSH2 0x0305 02FE 36 CALLDATASIZE 02FF 60 PUSH1 0x04 0301 61 PUSH2 0x32df 0304 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F8 stack[-1] = 0x029d // @02FB stack[0] = 0x0305 // @02FE stack[1] = msg.data.length // @02FF stack[2] = 0x04 // } // Block ends with call to 0x32df, returns to 0x0305 label_0305: // Incoming return from call to 0x32DF at 0x0304 0305 5B JUMPDEST 0306 61 PUSH2 0x0d3b 0309 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d3b label_030A: // Incoming jump from 0x0102, if 0x7f8fe7a0 == stack[-1] // Inputs[1] { @030B msg.value } 030A 5B JUMPDEST 030B 34 CALLVALUE 030C 80 DUP1 030D 15 ISZERO 030E 61 PUSH2 0x0316 0311 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030B stack[0] = msg.value } // Block ends with conditional jump to 0x0316, if !msg.value label_0312: // Incoming jump from 0x0311, if not !msg.value // Inputs[1] { @0315 memory[0x00:0x00] } 0312 60 PUSH1 0x00 0314 80 DUP1 0315 FD *REVERT // Stack delta = +0 // Outputs[1] { @0315 revert(memory[0x00:0x00]); } // Block terminates label_0316: // Incoming jump from 0x0311, if !msg.value // Inputs[1] { @031E msg.data.length } 0316 5B JUMPDEST 0317 50 POP 0318 61 PUSH2 0x01cc 031B 61 PUSH2 0x0325 031E 36 CALLDATASIZE 031F 60 PUSH1 0x04 0321 61 PUSH2 0x37a3 0324 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0318 stack[-1] = 0x01cc // @031B stack[0] = 0x0325 // @031E stack[1] = msg.data.length // @031F stack[2] = 0x04 // } // Block ends with call to 0x37a3, returns to 0x0325 label_0325: // Incoming return from call to 0x37A3 at 0x0324 0325 5B JUMPDEST 0326 61 PUSH2 0x0d7a 0329 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d7a label_032A: // Incoming jump from 0x010D, if 0x83f1291f == stack[-1] // Inputs[1] { @032B msg.value } 032A 5B JUMPDEST 032B 34 CALLVALUE 032C 80 DUP1 032D 15 ISZERO 032E 61 PUSH2 0x0336 0331 57 *JUMPI // Stack delta = +1 // Outputs[1] { @032B stack[0] = msg.value } // Block ends with conditional jump to 0x0336, if !msg.value label_0332: // Incoming jump from 0x0331, if not !msg.value // Inputs[1] { @0335 memory[0x00:0x00] } 0332 60 PUSH1 0x00 0334 80 DUP1 0335 FD *REVERT // Stack delta = +0 // Outputs[1] { @0335 revert(memory[0x00:0x00]); } // Block terminates label_0336: // Incoming jump from 0x0331, if !msg.value // Inputs[1] { @033E msg.data.length } 0336 5B JUMPDEST 0337 50 POP 0338 61 PUSH2 0x01cc 033B 61 PUSH2 0x0345 033E 36 CALLDATASIZE 033F 60 PUSH1 0x04 0341 61 PUSH2 0x3530 0344 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0338 stack[-1] = 0x01cc // @033B stack[0] = 0x0345 // @033E stack[1] = msg.data.length // @033F stack[2] = 0x04 // } // Block ends with unconditional jump to 0x3530 0345 5B JUMPDEST 0346 61 PUSH2 0x0e84 0349 56 *JUMP label_034A: // Incoming jump from 0x00BB, if 0xa8920d2b == stack[-1] // Inputs[1] { @034B msg.value } 034A 5B JUMPDEST 034B 34 CALLVALUE 034C 80 DUP1 034D 15 ISZERO 034E 61 PUSH2 0x0356 0351 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034B stack[0] = msg.value } // Block ends with conditional jump to 0x0356, if !msg.value label_0352: // Incoming jump from 0x0351, if not !msg.value // Inputs[1] { @0355 memory[0x00:0x00] } 0352 60 PUSH1 0x00 0354 80 DUP1 0355 FD *REVERT // Stack delta = +0 // Outputs[1] { @0355 revert(memory[0x00:0x00]); } // Block terminates label_0356: // Incoming jump from 0x0351, if !msg.value // Inputs[1] { @035E msg.data.length } 0356 5B JUMPDEST 0357 50 POP 0358 61 PUSH2 0x01cc 035B 61 PUSH2 0x0365 035E 36 CALLDATASIZE 035F 60 PUSH1 0x04 0361 61 PUSH2 0x330a 0364 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0358 stack[-1] = 0x01cc // @035B stack[0] = 0x0365 // @035E stack[1] = msg.data.length // @035F stack[2] = 0x04 // } // Block ends with call to 0x330a, returns to 0x0365 label_0365: // Incoming return from call to 0x330A at 0x0364 // Incoming return from call to 0x330A at 0x0417 0365 5B JUMPDEST 0366 61 PUSH2 0x0f44 0369 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f44 label_036A: // Incoming jump from 0x00C6, if 0xb122f1c5 == stack[-1] // Inputs[1] { @036B msg.value } 036A 5B JUMPDEST 036B 34 CALLVALUE 036C 80 DUP1 036D 15 ISZERO 036E 61 PUSH2 0x0376 0371 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036B stack[0] = msg.value } // Block ends with conditional jump to 0x0376, if !msg.value label_0372: // Incoming jump from 0x0371, if not !msg.value // Inputs[1] { @0375 memory[0x00:0x00] } 0372 60 PUSH1 0x00 0374 80 DUP1 0375 FD *REVERT // Stack delta = +0 // Outputs[1] { @0375 revert(memory[0x00:0x00]); } // Block terminates label_0376: // Incoming jump from 0x0371, if !msg.value // Inputs[1] { @037E msg.data.length } 0376 5B JUMPDEST 0377 50 POP 0378 61 PUSH2 0x01cc 037B 61 PUSH2 0x0385 037E 36 CALLDATASIZE 037F 60 PUSH1 0x04 0381 61 PUSH2 0x348b 0384 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0378 stack[-1] = 0x01cc // @037B stack[0] = 0x0385 // @037E stack[1] = msg.data.length // @037F stack[2] = 0x04 // } // Block ends with call to 0x348b, returns to 0x0385 label_0385: // Incoming return from call to 0x348B at 0x0384 0385 5B JUMPDEST 0386 61 PUSH2 0x0f4e 0389 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f4e label_038A: // Incoming jump from 0x00D1, if 0xb3af37c0 == stack[-1] // Inputs[1] { @038B msg.value } 038A 5B JUMPDEST 038B 34 CALLVALUE 038C 80 DUP1 038D 15 ISZERO 038E 61 PUSH2 0x0396 0391 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038B stack[0] = msg.value } // Block ends with conditional jump to 0x0396, if !msg.value label_0392: // Incoming jump from 0x0391, if not !msg.value // Inputs[1] { @0395 memory[0x00:0x00] } 0392 60 PUSH1 0x00 0394 80 DUP1 0395 FD *REVERT // Stack delta = +0 // Outputs[1] { @0395 revert(memory[0x00:0x00]); } // Block terminates label_0396: // Incoming jump from 0x0391, if !msg.value // Inputs[1] { @039E msg.data.length } 0396 5B JUMPDEST 0397 50 POP 0398 61 PUSH2 0x01cc 039B 61 PUSH2 0x03a5 039E 36 CALLDATASIZE 039F 60 PUSH1 0x04 03A1 61 PUSH2 0x3829 03A4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0398 stack[-1] = 0x01cc // @039B stack[0] = 0x03a5 // @039E stack[1] = msg.data.length // @039F stack[2] = 0x04 // } // Block ends with call to 0x3829, returns to 0x03A5 label_03A5: // Incoming return from call to 0x3829 at 0x03A4 03A5 5B JUMPDEST 03A6 61 PUSH2 0x108b 03A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x108b label_03AA: // Incoming jump from 0x0095, if 0xc9f12e9d == stack[-1] // Inputs[1] { @03AB msg.value } 03AA 5B JUMPDEST 03AB 34 CALLVALUE 03AC 80 DUP1 03AD 15 ISZERO 03AE 61 PUSH2 0x03b6 03B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AB stack[0] = msg.value } // Block ends with conditional jump to 0x03b6, if !msg.value label_03B2: // Incoming jump from 0x03B1, if not !msg.value // Inputs[1] { @03B5 memory[0x00:0x00] } 03B2 60 PUSH1 0x00 03B4 80 DUP1 03B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B5 revert(memory[0x00:0x00]); } // Block terminates label_03B6: // Incoming jump from 0x03B1, if !msg.value // Inputs[1] { @03BE msg.data.length } 03B6 5B JUMPDEST 03B7 50 POP 03B8 61 PUSH2 0x01cc 03BB 61 PUSH2 0x03c5 03BE 36 CALLDATASIZE 03BF 60 PUSH1 0x04 03C1 61 PUSH2 0x3684 03C4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03B8 stack[-1] = 0x01cc // @03BB stack[0] = 0x03c5 // @03BE stack[1] = msg.data.length // @03BF stack[2] = 0x04 // } // Block ends with call to 0x3684, returns to 0x03C5 label_03C5: // Incoming return from call to 0x3684 at 0x03C4 03C5 5B JUMPDEST 03C6 61 PUSH2 0x10d8 03C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10d8 label_03CA: // Incoming jump from 0x00A0, if 0xca19ebd9 == stack[-1] // Inputs[1] { @03CB msg.value } 03CA 5B JUMPDEST 03CB 34 CALLVALUE 03CC 80 DUP1 03CD 15 ISZERO 03CE 61 PUSH2 0x03d6 03D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CB stack[0] = msg.value } // Block ends with conditional jump to 0x03d6, if !msg.value label_03D2: // Incoming jump from 0x03D1, if not !msg.value // Inputs[1] { @03D5 memory[0x00:0x00] } 03D2 60 PUSH1 0x00 03D4 80 DUP1 03D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D5 revert(memory[0x00:0x00]); } // Block terminates label_03D6: // Incoming jump from 0x03D1, if !msg.value // Inputs[1] { @03DE msg.data.length } 03D6 5B JUMPDEST 03D7 50 POP 03D8 61 PUSH2 0x029d 03DB 61 PUSH2 0x03e5 03DE 36 CALLDATASIZE 03DF 60 PUSH1 0x04 03E1 61 PUSH2 0x32df 03E4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D8 stack[-1] = 0x029d // @03DB stack[0] = 0x03e5 // @03DE stack[1] = msg.data.length // @03DF stack[2] = 0x04 // } // Block ends with call to 0x32df, returns to 0x03E5 label_03E5: // Incoming return from call to 0x32DF at 0x03E4 03E5 5B JUMPDEST 03E6 61 PUSH2 0x117e 03E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x117e label_03EA: // Incoming jump from 0x00AB, if 0xd1660f99 == stack[-1] // Inputs[1] { @03EB msg.value } 03EA 5B JUMPDEST 03EB 34 CALLVALUE 03EC 80 DUP1 03ED 15 ISZERO 03EE 61 PUSH2 0x03f6 03F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03EB stack[0] = msg.value } // Block ends with conditional jump to 0x03f6, if !msg.value label_03F2: // Incoming jump from 0x03F1, if not !msg.value // Inputs[1] { @03F5 memory[0x00:0x00] } 03F2 60 PUSH1 0x00 03F4 80 DUP1 03F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F5 revert(memory[0x00:0x00]); } // Block terminates label_03F6: // Incoming jump from 0x03F1, if !msg.value // Inputs[1] { @03FE msg.data.length } 03F6 5B JUMPDEST 03F7 50 POP 03F8 61 PUSH2 0x01cc 03FB 61 PUSH2 0x0405 03FE 36 CALLDATASIZE 03FF 60 PUSH1 0x04 0401 61 PUSH2 0x35c0 0404 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F8 stack[-1] = 0x01cc // @03FB stack[0] = 0x0405 // @03FE stack[1] = msg.data.length // @03FF stack[2] = 0x04 // } // Block ends with call to 0x35c0, returns to 0x0405 label_0405: // Incoming return from call to 0x35C0 at 0x0404 0405 5B JUMPDEST 0406 61 PUSH2 0x16e2 0409 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16e2 label_040A: // Incoming jump from 0x0064, if 0xd9c45357 == stack[-1] // Inputs[1] { @0411 msg.data.length } 040A 5B JUMPDEST 040B 61 PUSH2 0x01cc 040E 61 PUSH2 0x0365 0411 36 CALLDATASIZE 0412 60 PUSH1 0x04 0414 61 PUSH2 0x330a 0417 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @040B stack[0] = 0x01cc // @040E stack[1] = 0x0365 // @0411 stack[2] = msg.data.length // @0412 stack[3] = 0x04 // } // Block ends with call to 0x330a, returns to 0x0365 label_0418: // Incoming jump from 0x006F, if 0xe0d12ba5 == stack[-1] // Inputs[1] { @0419 msg.value } 0418 5B JUMPDEST 0419 34 CALLVALUE 041A 80 DUP1 041B 15 ISZERO 041C 61 PUSH2 0x0424 041F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0419 stack[0] = msg.value } // Block ends with conditional jump to 0x0424, if !msg.value label_0420: // Incoming jump from 0x041F, if not !msg.value // Inputs[1] { @0423 memory[0x00:0x00] } 0420 60 PUSH1 0x00 0422 80 DUP1 0423 FD *REVERT // Stack delta = +0 // Outputs[1] { @0423 revert(memory[0x00:0x00]); } // Block terminates label_0424: // Incoming jump from 0x041F, if !msg.value // Inputs[1] { @042C msg.data.length } 0424 5B JUMPDEST 0425 50 POP 0426 61 PUSH2 0x01cc 0429 61 PUSH2 0x0433 042C 36 CALLDATASIZE 042D 60 PUSH1 0x04 042F 61 PUSH2 0x36de 0432 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0426 stack[-1] = 0x01cc // @0429 stack[0] = 0x0433 // @042C stack[1] = msg.data.length // @042D stack[2] = 0x04 // } // Block ends with call to 0x36de, returns to 0x0433 label_0433: // Incoming return from call to 0x36DE at 0x0432 0433 5B JUMPDEST 0434 61 PUSH2 0x1708 0437 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1708 label_0438: // Incoming jump from 0x007A, if 0xe27703c7 == stack[-1] // Inputs[1] { @0439 msg.value } 0438 5B JUMPDEST 0439 34 CALLVALUE 043A 80 DUP1 043B 15 ISZERO 043C 61 PUSH2 0x0444 043F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0439 stack[0] = msg.value } // Block ends with conditional jump to 0x0444, if !msg.value label_0440: // Incoming jump from 0x043F, if not !msg.value // Inputs[1] { @0443 memory[0x00:0x00] } 0440 60 PUSH1 0x00 0442 80 DUP1 0443 FD *REVERT // Stack delta = +0 // Outputs[1] { @0443 revert(memory[0x00:0x00]); } // Block terminates label_0444: // Incoming jump from 0x043F, if !msg.value // Inputs[1] { @044C msg.data.length } 0444 5B JUMPDEST 0445 50 POP 0446 61 PUSH2 0x01cc 0449 61 PUSH2 0x0453 044C 36 CALLDATASIZE 044D 60 PUSH1 0x04 044F 61 PUSH2 0x3684 0452 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0446 stack[-1] = 0x01cc // @0449 stack[0] = 0x0453 // @044C stack[1] = msg.data.length // @044D stack[2] = 0x04 // } // Block ends with call to 0x3684, returns to 0x0453 label_0453: // Incoming return from call to 0x3684 at 0x0452 0453 5B JUMPDEST 0454 61 PUSH2 0x18dc 0457 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18dc label_0458: // Incoming jump from 0x003E, if 0xeb5625d9 == stack[-1] // Inputs[1] { @0459 msg.value } 0458 5B JUMPDEST 0459 34 CALLVALUE 045A 80 DUP1 045B 15 ISZERO 045C 61 PUSH2 0x0464 045F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0459 stack[0] = msg.value } // Block ends with conditional jump to 0x0464, if !msg.value label_0460: // Incoming jump from 0x045F, if not !msg.value // Inputs[1] { @0463 memory[0x00:0x00] } 0460 60 PUSH1 0x00 0462 80 DUP1 0463 FD *REVERT // Stack delta = +0 // Outputs[1] { @0463 revert(memory[0x00:0x00]); } // Block terminates label_0464: // Incoming jump from 0x045F, if !msg.value // Inputs[1] { @046C msg.data.length } 0464 5B JUMPDEST 0465 50 POP 0466 61 PUSH2 0x01cc 0469 61 PUSH2 0x0473 046C 36 CALLDATASIZE 046D 60 PUSH1 0x04 046F 61 PUSH2 0x35c0 0472 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0466 stack[-1] = 0x01cc // @0469 stack[0] = 0x0473 // @046C stack[1] = msg.data.length // @046D stack[2] = 0x04 // } // Block ends with call to 0x35c0, returns to 0x0473 label_0473: // Incoming return from call to 0x35C0 at 0x0472 0473 5B JUMPDEST 0474 61 PUSH2 0x1947 0477 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1947 label_0478: // Incoming jump from 0x0049, if 0xec77bbdb == stack[-1] // Inputs[1] { @0479 msg.value } 0478 5B JUMPDEST 0479 34 CALLVALUE 047A 80 DUP1 047B 15 ISZERO 047C 61 PUSH2 0x0484 047F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0479 stack[0] = msg.value } // Block ends with conditional jump to 0x0484, if !msg.value label_0480: // Incoming jump from 0x047F, if not !msg.value // Inputs[1] { @0483 memory[0x00:0x00] } 0480 60 PUSH1 0x00 0482 80 DUP1 0483 FD *REVERT // Stack delta = +0 // Outputs[1] { @0483 revert(memory[0x00:0x00]); } // Block terminates label_0484: // Incoming jump from 0x047F, if !msg.value // Inputs[1] { @048C msg.data.length } 0484 5B JUMPDEST 0485 50 POP 0486 61 PUSH2 0x029d 0489 61 PUSH2 0x0493 048C 36 CALLDATASIZE 048D 60 PUSH1 0x04 048F 61 PUSH2 0x3650 0492 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0486 stack[-1] = 0x029d // @0489 stack[0] = 0x0493 // @048C stack[1] = msg.data.length // @048D stack[2] = 0x04 // } // Block ends with call to 0x3650, returns to 0x0493 label_0493: // Incoming return from call to 0x3650 at 0x0492 0493 5B JUMPDEST 0494 61 PUSH2 0x1968 0497 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1968 label_0498: // Incoming jump from 0x0054, if 0xf1e64c20 == stack[-1] // Inputs[1] { @0499 msg.value } 0498 5B JUMPDEST 0499 34 CALLVALUE 049A 80 DUP1 049B 15 ISZERO 049C 61 PUSH2 0x04a4 049F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0499 stack[0] = msg.value } // Block ends with conditional jump to 0x04a4, if !msg.value label_04A0: // Incoming jump from 0x049F, if not !msg.value // Inputs[1] { @04A3 memory[0x00:0x00] } 04A0 60 PUSH1 0x00 04A2 80 DUP1 04A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A3 revert(memory[0x00:0x00]); } // Block terminates label_04A4: // Incoming jump from 0x049F, if !msg.value // Inputs[1] { @04AC msg.data.length } 04A4 5B JUMPDEST 04A5 50 POP 04A6 61 PUSH2 0x01cc 04A9 61 PUSH2 0x04b3 04AC 36 CALLDATASIZE 04AD 60 PUSH1 0x04 04AF 61 PUSH2 0x3770 04B2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04A6 stack[-1] = 0x01cc // @04A9 stack[0] = 0x04b3 // @04AC stack[1] = msg.data.length // @04AD stack[2] = 0x04 // } // Block ends with call to 0x3770, returns to 0x04B3 label_04B3: // Incoming return from call to 0x3770 at 0x04B2 04B3 5B JUMPDEST 04B4 61 PUSH2 0x19b1 04B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x19b1 label_04B8: // Incoming jump from 0x01E5 // Inputs[1] { @04D0 stack[-4] } 04B8 5B JUMPDEST 04B9 60 PUSH1 0x00 04BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04D0 85 DUP6 04D1 16 AND 04D2 61 PUSH2 0x04dc 04D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B9 stack[0] = 0x00 } // Block ends with conditional jump to 0x04dc, if stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff label_04D6: // Incoming jump from 0x04D5, if not stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff 04D6 60 PUSH1 0x00 04D8 61 PUSH2 0x0506 04DB 56 *JUMP // Stack delta = +1 // Outputs[1] { @04D6 stack[0] = 0x00 } // Block ends with unconditional jump to 0x0506 label_04DC: // Incoming jump from 0x04D5, if stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[2] // { // @04F1 stack[-3] // @04F6 stack[-4] // } 04DC 5B JUMPDEST 04DD 61 PUSH2 0x0506 04E0 6F PUSH16 0xffffffffffffffffffffffffffffffff 04F1 84 DUP5 04F2 16 AND 04F3 61 PUSH2 0x0500 04F6 86 DUP7 04F7 60 PUSH1 0x80 04F9 87 DUP8 04FA 90 SWAP1 04FB 1C SHR 04FC 61 PUSH2 0x1bb2 04FF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @04DD stack[0] = 0x0506 // @04F2 stack[1] = stack[-3] & 0xffffffffffffffffffffffffffffffff // @04F3 stack[2] = 0x0500 // @04F6 stack[3] = stack[-4] // @04FB stack[4] = stack[-3] >> 0x80 // } // Block ends with call to 0x1bb2, returns to 0x0500 label_0500: // Incoming return from call to 0x0B13 at 0x19AA // Incoming return from call to 0x0B13 at 0x10CA // Incoming return from call to 0x1BB2 at 0x04FF // Incoming return from call to 0x0B13 at 0x0B12 // Incoming return from call to 0x1BB2 at 0x285A // Inputs[2] // { // @0501 stack[-2] // @0501 stack[-1] // } 0500 5B JUMPDEST 0501 90 SWAP1 0502 61 PUSH2 0x1c06 0505 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0501 stack[-1] = stack[-2] // @0501 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x1c06 label_0506: // Incoming jump from 0x04DB // Incoming return from call to 0x0500 at 0x04FF // Inputs[3] // { // @0507 stack[-2] // @0507 stack[-1] // @050E stack[-5] // } 0506 5B JUMPDEST 0507 90 SWAP1 0508 50 POP 0509 60 PUSH1 0x00 050B 61 PUSH2 0x0514 050E 85 DUP6 050F 83 DUP4 0510 61 PUSH2 0x1c52 0513 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0507 stack[-2] = stack[-1] // @0509 stack[-1] = 0x00 // @050B stack[0] = 0x0514 // @050E stack[1] = stack[-5] // @050F stack[2] = stack[-1] // } // Block ends with call to 0x1c52, returns to 0x0514 label_0514: // Incoming return from call to 0x1C52 at 0x0513 // Inputs[4] // { // @0515 stack[-1] // @0515 stack[-2] // @0517 stack[-4] // @0518 stack[-3] // } 0514 5B JUMPDEST 0515 90 SWAP1 0516 50 POP 0517 82 DUP3 0518 82 DUP3 0519 11 GT 051A 15 ISZERO 051B 80 DUP1 051C 15 ISZERO 051D 61 PUSH2 0x0526 0520 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0515 stack[-2] = stack[-1] // @051A stack[-1] = !(stack[-3] > stack[-4]) // } // Block ends with conditional jump to 0x0526, if !!(stack[-3] > stack[-4]) label_0521: // Incoming jump from 0x0520, if not !!(stack[-3] > stack[-4]) // Inputs[2] // { // @0522 stack[-4] // @0523 stack[-2] // } 0521 50 POP 0522 82 DUP3 0523 81 DUP2 0524 11 GT 0525 15 ISZERO 0526 5B JUMPDEST 0527 15 ISZERO 0528 61 PUSH2 0x0532 052B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0532, if !!(stack[-2] > stack[-4]) label_052C: // Incoming jump from 0x052B, if not !stack[-1] // Incoming jump from 0x052B, if not !!(stack[-2] > stack[-4]) 052C 50 POP 052D 50 POP 052E 61 PUSH2 0x0778 0531 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0778 label_0532: // Incoming jump from 0x052B, if !stack[-1] // Incoming jump from 0x052B, if !!(stack[-2] > stack[-4]) 0532 5B JUMPDEST 0533 61 PUSH2 0x053a 0536 61 PUSH2 0x3016 0539 56 *JUMP // Stack delta = +1 // Outputs[1] { @0533 stack[0] = 0x053a } // Block ends with call to 0x3016, returns to 0x053A label_053A: // Incoming return from call to 0x3016 at 0x0539 // Inputs[4] // { // @053D memory[0x40:0x60] // @0563 stack[-8] // @0585 stack[-2] // @0588 memory[0x40:0x60] // } 053A 5B JUMPDEST 053B 60 PUSH1 0x40 053D 51 MLOAD 053E 80 DUP1 053F 60 PUSH1 0x80 0541 01 ADD 0542 60 PUSH1 0x40 0544 52 MSTORE 0545 80 DUP1 0546 60 PUSH1 0x00 0548 81 DUP2 0549 52 MSTORE 054A 60 PUSH1 0x20 054C 01 ADD 054D 60 PUSH1 0x00 054F 81 DUP2 0550 52 MSTORE 0551 60 PUSH1 0x20 0553 01 ADD 0554 60 PUSH1 0x00 0556 81 DUP2 0557 52 MSTORE 0558 60 PUSH1 0x20 055A 01 ADD 055B 63 PUSH4 0xd1660f99 0560 60 PUSH1 0xe0 0562 1B SHL 0563 8A DUP11 0564 7F PUSH32 0x000000000000000000000000dd9f24efc84d93deef3c8745c837ab63e80abd27 0585 86 DUP7 0586 60 PUSH1 0x40 0588 51 MLOAD 0589 60 PUSH1 0x24 058B 01 ADD 058C 61 PUSH2 0x0597 058F 93 SWAP4 0590 92 SWAP3 0591 91 SWAP2 0592 90 SWAP1 0593 61 PUSH2 0x3e49 0596 56 *JUMP // Stack delta = +8 // Outputs[12] // { // @053D stack[0] = memory[0x40:0x60] // @0544 memory[0x40:0x60] = 0x80 + memory[0x40:0x60] // @0549 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0550 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @0557 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @055A stack[1] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0562 stack[2] = 0xd1660f99 << 0xe0 // @058F stack[3] = 0x0597 // @0590 stack[4] = stack[-8] // @0591 stack[5] = 0x000000000000000000000000dd9f24efc84d93deef3c8745c837ab63e80abd27 // @0592 stack[6] = stack[-2] // @0592 stack[7] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x3e49, returns to 0x0597 label_0597: // Incoming return from call to 0x3E49 at 0x0596 // Inputs[7] // { // @059B memory[0x40:0x60] // @05BE stack[-1] // @05CB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @060C stack[-2] // @0615 stack[-3] // @0617 stack[-5] // @0617 stack[-4] // } 0597 5B JUMPDEST 0598 60 PUSH1 0x40 059A 80 DUP1 059B 51 MLOAD 059C 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 05BD 81 DUP2 05BE 84 DUP5 05BF 03 SUB 05C0 01 ADD 05C1 81 DUP2 05C2 52 MSTORE 05C3 91 SWAP2 05C4 90 SWAP1 05C5 52 MSTORE 05C6 60 PUSH1 0x20 05C8 81 DUP2 05C9 01 ADD 05CA 80 DUP1 05CB 51 MLOAD 05CC 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 05E9 16 AND 05EA 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 060B 90 SWAP1 060C 93 SWAP4 060D 16 AND 060E 92 SWAP3 060F 90 SWAP1 0610 92 SWAP3 0611 17 OR 0612 90 SWAP1 0613 91 SWAP2 0614 52 MSTORE 0615 90 SWAP1 0616 52 MSTORE 0617 90 SWAP1 0618 50 POP 0619 61 PUSH2 0x0620 061C 61 PUSH2 0x3016 061F 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @05C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @05C5 memory[0x40:0x60] = stack[-1] // @0614 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @0616 memory[stack[-3]:stack[-3] + 0x20] = memory[0x40:0x60] // @0617 stack[-5] = stack[-4] // @0619 stack[-4] = 0x0620 // } // Block ends with call to 0x3016, returns to 0x0620 label_0620: // Incoming return from call to 0x3016 at 0x061F // Inputs[5] // { // @0623 memory[0x40:0x60] // @0649 stack[-9] // @064A stack[-8] // @064B stack[-4] // @064E memory[0x40:0x60] // } 0620 5B JUMPDEST 0621 60 PUSH1 0x40 0623 51 MLOAD 0624 80 DUP1 0625 60 PUSH1 0x80 0627 01 ADD 0628 60 PUSH1 0x40 062A 52 MSTORE 062B 80 DUP1 062C 60 PUSH1 0x00 062E 81 DUP2 062F 52 MSTORE 0630 60 PUSH1 0x20 0632 01 ADD 0633 60 PUSH1 0x00 0635 81 DUP2 0636 52 MSTORE 0637 60 PUSH1 0x20 0639 01 ADD 063A 60 PUSH1 0x00 063C 81 DUP2 063D 52 MSTORE 063E 60 PUSH1 0x20 0640 01 ADD 0641 63 PUSH4 0xd1660f99 0646 60 PUSH1 0xe0 0648 1B SHL 0649 8B DUP12 064A 8B DUP12 064B 88 DUP9 064C 60 PUSH1 0x40 064E 51 MLOAD 064F 60 PUSH1 0x24 0651 01 ADD 0652 61 PUSH2 0x065d 0655 93 SWAP4 0656 92 SWAP3 0657 91 SWAP2 0658 90 SWAP1 0659 61 PUSH2 0x3e49 065C 56 *JUMP // Stack delta = +8 // Outputs[12] // { // @0623 stack[0] = memory[0x40:0x60] // @062A memory[0x40:0x60] = 0x80 + memory[0x40:0x60] // @062F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0636 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @063D memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @0640 stack[1] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0648 stack[2] = 0xd1660f99 << 0xe0 // @0655 stack[3] = 0x065d // @0656 stack[4] = stack[-9] // @0657 stack[5] = stack[-8] // @0658 stack[6] = stack[-4] // @0658 stack[7] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x3e49, returns to 0x065D label_065D: // Incoming return from call to 0x3E49 at 0x065C // Inputs[9] // { // @0661 memory[0x40:0x60] // @0684 stack[-1] // @0691 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @06D2 stack[-2] // @06DB stack[-3] // @06DD stack[-5] // @06DD stack[-4] // @06DF stack[-9] // @06E0 stack[-8] // } 065D 5B JUMPDEST 065E 60 PUSH1 0x40 0660 80 DUP1 0661 51 MLOAD 0662 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 0683 81 DUP2 0684 84 DUP5 0685 03 SUB 0686 01 ADD 0687 81 DUP2 0688 52 MSTORE 0689 91 SWAP2 068A 90 SWAP1 068B 52 MSTORE 068C 60 PUSH1 0x20 068E 81 DUP2 068F 01 ADD 0690 80 DUP1 0691 51 MLOAD 0692 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 06AF 16 AND 06B0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 06D1 90 SWAP1 06D2 93 SWAP4 06D3 16 AND 06D4 92 SWAP3 06D5 90 SWAP1 06D6 92 SWAP3 06D7 17 OR 06D8 90 SWAP1 06D9 91 SWAP2 06DA 52 MSTORE 06DB 90 SWAP1 06DC 52 MSTORE 06DD 90 SWAP1 06DE 50 POP 06DF 84 DUP5 06E0 84 DUP5 06E1 11 GT 06E2 61 PUSH2 0x06f3 06E5 57 *JUMPI // Stack delta = -4 // Outputs[5] // { // @0688 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @068B memory[0x40:0x60] = stack[-1] // @06DA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @06DC memory[stack[-3]:stack[-3] + 0x20] = memory[0x40:0x60] // @06DD stack[-5] = stack[-4] // } // Block ends with conditional jump to 0x06f3, if stack[-8] > stack[-9] label_06E6: // Incoming jump from 0x06E5, if not stack[-8] > stack[-9] // Inputs[1] { @06E9 stack[-2] } 06E6 61 PUSH2 0x06ee 06E9 82 DUP3 06EA 61 PUSH2 0x19b1 06ED 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06E6 stack[0] = 0x06ee // @06E9 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x19b1 06EE 5B JUMPDEST 06EF 61 PUSH2 0x0773 06F2 56 *JUMP label_06F3: // Incoming jump from 0x06E5, if stack[-8] > stack[-9] // Inputs[2] // { // @06F4 stack[-5] // @06F5 stack[-3] // } 06F3 5B JUMPDEST 06F4 84 DUP5 06F5 83 DUP4 06F6 11 GT 06F7 61 PUSH2 0x0703 06FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0703, if stack[-3] > stack[-5] label_06FB: // Incoming jump from 0x06FA, if not stack[-3] > stack[-5] // Inputs[1] { @06FE stack[-1] } 06FB 61 PUSH2 0x06ee 06FE 81 DUP2 06FF 61 PUSH2 0x19b1 0702 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FB stack[0] = 0x06ee // @06FE stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x19b1 label_0703: // Incoming jump from 0x06FA, if stack[-3] > stack[-5] // Inputs[1] { @0707 memory[0x40:0x60] } 0703 5B JUMPDEST 0704 60 PUSH1 0x40 0706 80 DUP1 0707 51 MLOAD 0708 60 PUSH1 0x02 070A 80 DUP1 070B 82 DUP3 070C 52 MSTORE 070D 60 PUSH1 0x60 070F 82 DUP3 0710 81 DUP2 0711 01 ADD 0712 90 SWAP1 0713 93 SWAP4 0714 52 MSTORE 0715 81 DUP2 0716 60 PUSH1 0x20 0718 01 ADD 0719 5B JUMPDEST 071A 61 PUSH2 0x0721 071D 61 PUSH2 0x3016 0720 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0707 stack[1] = memory[0x40:0x60] // @0708 stack[2] = 0x02 // @070C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @0713 stack[0] = 0x60 // @0714 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0718 stack[3] = 0x20 + memory[0x40:0x60] // @071A stack[4] = 0x0721 // } // Block ends with call to 0x3016, returns to 0x0721 label_0721: // Incoming return from call to 0x3016 at 0x0720 // Incoming return from call to 0x3016 at 0x0720 // Inputs[3] // { // @0722 stack[-2] // @0723 stack[-1] // @0727 stack[-3] // } 0721 5B JUMPDEST 0722 81 DUP2 0723 52 MSTORE 0724 60 PUSH1 0x20 0726 01 ADD 0727 90 SWAP1 0728 60 PUSH1 0x01 072A 90 SWAP1 072B 03 SUB 072C 90 SWAP1 072D 81 DUP2 072E 61 PUSH2 0x0719 0731 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0723 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @072C stack[-2] = 0x20 + stack[-2] // @072C stack[-3] = stack[-3] - 0x01 // } // Block ends with conditional jump to 0x0719, if stack[-3] - 0x01 label_0732: // Incoming jump from 0x0731, if not stack[-3] - 0x01 // Inputs[6] // { // @0732 stack[-2] // @0732 stack[-1] // @0735 stack[-3] // @0735 stack[-4] // @0737 stack[-6] // @073C memory[stack[-3]:stack[-3] + 0x20] // } 0732 90 SWAP1 0733 50 POP 0734 50 POP 0735 90 SWAP1 0736 50 POP 0737 82 DUP3 0738 81 DUP2 0739 60 PUSH1 0x00 073B 81 DUP2 073C 51 MLOAD 073D 81 DUP2 073E 10 LT 073F 61 PUSH2 0x0744 0742 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0735 stack[-4] = stack[-3] // @0737 stack[-3] = stack[-6] // @0738 stack[-2] = stack[-3] // @0739 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0744, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0743: // Incoming jump from 0x0742, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0743 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0743 assert(); } // Block terminates label_0744: // Incoming jump from 0x0742, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0747 stack[-1] // @074B stack[-2] // @074C stack[-3] // @0750 stack[-5] // @0751 stack[-4] // @0755 memory[stack[-4]:stack[-4] + 0x20] // } 0744 5B JUMPDEST 0745 60 PUSH1 0x20 0747 02 MUL 0748 60 PUSH1 0x20 074A 01 ADD 074B 01 ADD 074C 81 DUP2 074D 90 SWAP1 074E 52 MSTORE 074F 50 POP 0750 81 DUP2 0751 81 DUP2 0752 60 PUSH1 0x01 0754 81 DUP2 0755 51 MLOAD 0756 81 DUP2 0757 10 LT 0758 61 PUSH2 0x075d 075B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @074E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @0750 stack[-3] = stack[-5] // @0751 stack[-2] = stack[-4] // @0752 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x075d, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_075C: // Incoming jump from 0x075B, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 075C FE *ASSERT // Stack delta = +0 // Outputs[1] { @075C assert(); } // Block terminates label_075D: // Incoming jump from 0x075B, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @0760 stack[-1] // @0764 stack[-2] // @0765 stack[-3] // @076C stack[-4] // } 075D 5B JUMPDEST 075E 60 PUSH1 0x20 0760 02 MUL 0761 60 PUSH1 0x20 0763 01 ADD 0764 01 ADD 0765 81 DUP2 0766 90 SWAP1 0767 52 MSTORE 0768 50 POP 0769 61 PUSH2 0x0771 076C 81 DUP2 076D 61 PUSH2 0x0ab4 0770 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0767 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @0769 stack[-3] = 0x0771 // @076C stack[-2] = stack[-4] // } // Block ends with call to 0x0ab4, returns to 0x0771 label_0771: // Incoming jump from 0x1060, if !(stack[-1] < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x1060, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming return from call to 0x0AB4 at 0x0770 0771 5B JUMPDEST 0772 50 POP 0773 5B JUMPDEST 0774 50 POP 0775 50 POP 0776 50 POP 0777 50 POP // Stack delta = -5 // Block continues label_0778: // Incoming jump from 0x0531 // Incoming return from call to 0x23A4 at 0x10D7 // Incoming jump from 0x0777 // Incoming jump from 0x0777 // Inputs[1] { @077E stack[-6] } 0778 5B JUMPDEST 0779 50 POP 077A 50 POP 077B 50 POP 077C 50 POP 077D 50 POP 077E 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_077F: // Incoming jump from 0x0205 // Inputs[3] // { // @0783 memory[0x40:0x60] // @07C9 stack[-4] // @07D6 stack[-5] // } 077F 5B JUMPDEST 0780 60 PUSH1 0x40 0782 80 DUP1 0783 51 MLOAD 0784 60 PUSH1 0x00 0786 81 DUP2 0787 52 MSTORE 0788 60 PUSH1 0x20 078A 81 DUP2 078B 01 ADD 078C 91 SWAP2 078D 82 DUP3 078E 90 SWAP1 078F 52 MSTORE 0790 7F PUSH32 0x5915d80600000000000000000000000000000000000000000000000000000000 07B1 90 SWAP1 07B2 91 SWAP2 07B3 52 MSTORE 07B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C9 85 DUP6 07CA 16 AND 07CB 90 SWAP1 07CC 63 PUSH4 0x5915d806 07D1 90 SWAP1 07D2 61 PUSH2 0x07e0 07D5 90 SWAP1 07D6 88 DUP9 07D7 90 SWAP1 07D8 60 PUSH1 0x24 07DA 81 DUP2 07DB 01 ADD 07DC 61 PUSH2 0x4261 07DF 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @0787 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @078F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @07B3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x5915d80600000000000000000000000000000000000000000000000000000000 // @07CB stack[0] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @07D1 stack[1] = 0x5915d806 // @07D5 stack[2] = 0x07e0 // @07D7 stack[3] = stack[-5] // @07D7 stack[4] = memory[0x40:0x60] // @07DB stack[5] = memory[0x40:0x60] + 0x24 // } // Block ends with call to 0x4261, returns to 0x07E0 label_07E0: // Incoming return from call to 0x4261 at 0x07DF // Inputs[4] // { // @07E5 memory[0x40:0x60] // @07E7 stack[-1] // @07EC stack[-3] // @07EE address(stack[-3]).code.length // } 07E0 5B JUMPDEST 07E1 60 PUSH1 0x00 07E3 60 PUSH1 0x40 07E5 51 MLOAD 07E6 80 DUP1 07E7 83 DUP4 07E8 03 SUB 07E9 81 DUP2 07EA 60 PUSH1 0x00 07EC 87 DUP8 07ED 80 DUP1 07EE 3B EXTCODESIZE 07EF 15 ISZERO 07F0 80 DUP1 07F1 15 ISZERO 07F2 61 PUSH2 0x07fa 07F5 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @07E1 stack[0] = 0x00 // @07E5 stack[1] = memory[0x40:0x60] // @07E8 stack[2] = stack[-1] - memory[0x40:0x60] // @07E9 stack[3] = memory[0x40:0x60] // @07EA stack[4] = 0x00 // @07EC stack[5] = stack[-3] // @07EF stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x07fa, if !!address(stack[-3]).code.length label_07F6: // Incoming jump from 0x07F5, if not !!address(stack[-3]).code.length // Inputs[1] { @07F9 memory[0x00:0x00] } 07F6 60 PUSH1 0x00 07F8 80 DUP1 07F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07F9 revert(memory[0x00:0x00]); } // Block terminates label_07FA: // Incoming jump from 0x07F5, if !!address(stack[-3]).code.length // Inputs[9] // { // @07FC msg.gas // @07FD stack[-5] // @07FD stack[-3] // @07FD memory[stack[-4]:stack[-4] + stack[-5]] // @07FD stack[-2] // @07FD address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @07FD stack[-4] // @07FD stack[-7] // @07FD stack[-6] // } 07FA 5B JUMPDEST 07FB 50 POP 07FC 5A GAS 07FD F1 CALL 07FE 15 ISZERO 07FF 80 DUP1 0800 15 ISZERO 0801 61 PUSH2 0x080e 0804 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @07FD memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @07FE stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x080e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0805: // Incoming jump from 0x0804, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0805 returndata.length // @0809 returndata[0x00:0x00 + returndata.length] // @080A returndata.length // @080D memory[0x00:0x00 + returndata.length] // } 0805 3D RETURNDATASIZE 0806 60 PUSH1 0x00 0808 80 DUP1 0809 3E RETURNDATACOPY 080A 3D RETURNDATASIZE 080B 60 PUSH1 0x00 080D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0809 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @080D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_080E: // Incoming jump from 0x0804, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @0816 stack[-7] // @0817 stack[-6] // @0818 stack[-5] // } 080E 5B JUMPDEST 080F 50 POP 0810 50 POP 0811 50 POP 0812 50 POP 0813 61 PUSH2 0x0778 0816 83 DUP4 0817 83 DUP4 0818 83 DUP4 0819 61 PUSH2 0x1c94 081C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0813 stack[-4] = 0x0778 // @0816 stack[-3] = stack[-7] // @0817 stack[-2] = stack[-6] // @0818 stack[-1] = stack[-5] // } // Block ends with unconditional jump to 0x1c94 label_081D: // Incoming jump from 0x0225 // Inputs[4] // { // @081E stack[-1] // @0822 msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @0823 address(this) // @0823 address(this).balance // } 081D 5B JUMPDEST 081E 80 DUP1 081F 60 PUSH1 0x40 0821 01 ADD 0822 35 CALLDATALOAD 0823 47 SELFBALANCE 0824 10 LT 0825 15 ISZERO 0826 61 PUSH2 0x085b 0829 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085b, if !(address(this).balance < msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) label_082A: // Incoming jump from 0x0829, if not !(address(this).balance < msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) // Inputs[1] { @082C memory[0x40:0x60] } 082A 60 PUSH1 0x40 082C 51 MLOAD 082D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 084E 81 DUP2 084F 52 MSTORE 0850 60 PUSH1 0x04 0852 01 ADD 0853 61 PUSH2 0x01c3 0856 90 SWAP1 0857 61 PUSH2 0x3f02 085A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @084F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0856 stack[0] = 0x01c3 // @0856 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3f02, returns to 0x01C3 label_085B: // Incoming jump from 0x0829, if !(address(this).balance < msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) // Inputs[2] // { // @0861 stack[-1] // @0862 msg.data[stack[-1]:stack[-1] + 0x20] // } 085B 5B JUMPDEST 085C 60 PUSH1 0x00 085E 60 PUSH1 0x60 0860 81 DUP2 0861 83 DUP4 0862 35 CALLDATALOAD 0863 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0878 16 AND 0879 15 ISZERO 087A 61 PUSH2 0x0884 087D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @085C stack[0] = 0x00 // @085E stack[1] = 0x60 // @0860 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0884, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-1]:stack[-1] + 0x20]) label_087E: // Incoming jump from 0x087D, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @087E stack[-4] // @087F msg.data[stack[-4]:stack[-4] + 0x20] // } 087E 83 DUP4 087F 35 CALLDATALOAD 0880 61 PUSH2 0x0886 0883 56 *JUMP // Stack delta = +1 // Outputs[1] { @087F stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] } // Block ends with unconditional jump to 0x0886 label_0884: // Incoming jump from 0x087D, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0885 address(this) // @0887 stack[-1] // @088B stack[-4] // @088D msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 0884 5B JUMPDEST 0885 30 ADDRESS 0886 5B JUMPDEST 0887 90 SWAP1 0888 50 POP 0889 60 PUSH1 0x20 088B 84 DUP5 088C 01 ADD 088D 35 CALLDATALOAD 088E 61 PUSH2 0x0915 0891 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0887 stack[-1] = address(this) } // Block ends with conditional jump to 0x0915, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_0892: // Incoming jump from 0x0891, if not msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // Incoming jump from 0x0891, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[3] // { // @08A7 stack[-1] // @08AB stack[-4] // @08AD msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } 0892 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A7 81 DUP2 08A8 16 AND 08A9 60 PUSH1 0x40 08AB 85 DUP6 08AC 01 ADD 08AD 35 CALLDATALOAD 08AE 61 PUSH2 0x08ba 08B1 60 PUSH1 0x60 08B3 87 DUP8 08B4 01 ADD 08B5 87 DUP8 08B6 61 PUSH2 0x4315 08B9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @08A8 stack[0] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @08AD stack[1] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @08AE stack[2] = 0x08ba // @08B4 stack[3] = stack[-4] + 0x60 // @08B5 stack[4] = stack[-4] // } // Block ends with call to 0x4315, returns to 0x08BA label_08BA: // Incoming return from call to 0x4315 at 0x08B9 // Inputs[3] // { // @08BD memory[0x40:0x60] // @08C1 stack[-2] // @08C2 stack[-1] // } 08BA 5B JUMPDEST 08BB 60 PUSH1 0x40 08BD 51 MLOAD 08BE 61 PUSH2 0x08c8 08C1 92 SWAP3 08C2 91 SWAP2 08C3 90 SWAP1 08C4 61 PUSH2 0x3b43 08C7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @08C1 stack[-2] = 0x08c8 // @08C2 stack[-1] = stack[-2] // @08C3 stack[1] = memory[0x40:0x60] // @08C3 stack[0] = stack[-1] // } // Block ends with call to 0x3b43, returns to 0x08C8 label_08C8: // Incoming return from call to 0x3B43 at 0x08C7 // Inputs[8] // { // @08CD memory[0x40:0x60] // @08CF stack[-1] // @08D2 stack[-2] // @08D3 stack[-3] // @08D4 msg.gas // @08D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @08D5 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08DA returndata.length // } 08C8 5B JUMPDEST 08C9 60 PUSH1 0x00 08CB 60 PUSH1 0x40 08CD 51 MLOAD 08CE 80 DUP1 08CF 83 DUP4 08D0 03 SUB 08D1 81 DUP2 08D2 85 DUP6 08D3 87 DUP8 08D4 5A GAS 08D5 F1 CALL 08D6 92 SWAP3 08D7 50 POP 08D8 50 POP 08D9 50 POP 08DA 3D RETURNDATASIZE 08DB 80 DUP1 08DC 60 PUSH1 0x00 08DE 81 DUP2 08DF 14 EQ 08E0 61 PUSH2 0x0905 08E3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @08D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08D6 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08DA stack[-2] = returndata.length // @08DB stack[-1] = returndata.length // } // Block ends with conditional jump to 0x0905, if returndata.length == 0x00 label_08E4: // Incoming jump from 0x08E3, if not returndata.length == 0x00 // Inputs[6] // { // @08E6 memory[0x40:0x60] // @08E7 stack[-2] // @08EE returndata.length // @08F6 returndata.length // @08F9 returndata.length // @0900 returndata[0x00:0x00 + returndata.length] // } 08E4 60 PUSH1 0x40 08E6 51 MLOAD 08E7 91 SWAP2 08E8 50 POP 08E9 60 PUSH1 0x1f 08EB 19 NOT 08EC 60 PUSH1 0x3f 08EE 3D RETURNDATASIZE 08EF 01 ADD 08F0 16 AND 08F1 82 DUP3 08F2 01 ADD 08F3 60 PUSH1 0x40 08F5 52 MSTORE 08F6 3D RETURNDATASIZE 08F7 82 DUP3 08F8 52 MSTORE 08F9 3D RETURNDATASIZE 08FA 60 PUSH1 0x00 08FC 60 PUSH1 0x20 08FE 84 DUP5 08FF 01 ADD 0900 3E RETURNDATACOPY 0901 61 PUSH2 0x090a 0904 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @08E7 stack[-2] = memory[0x40:0x60] // @08F5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @08F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0900 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x090a label_0905: // Incoming jump from 0x08E3, if returndata.length == 0x00 // Inputs[4] // { // @0908 stack[-2] // @090C stack[-3] // @090D stack[-6] // @090F stack[-5] // } 0905 5B JUMPDEST 0906 60 PUSH1 0x60 0908 91 SWAP2 0909 50 POP 090A 5B JUMPDEST 090B 50 POP 090C 90 SWAP1 090D 93 SWAP4 090E 50 POP 090F 91 SWAP2 0910 50 POP 0911 61 PUSH2 0x099b 0914 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @090D stack[-6] = stack[-3] // @090F stack[-5] = 0x60 // } // Block ends with unconditional jump to 0x099b label_0915: // Incoming jump from 0x0891, if msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // Incoming jump from 0x0891, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[4] // { // @092B stack[-1] // @092F stack[-4] // @0931 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @0936 msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } 0915 5B JUMPDEST 0916 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 092B 81 DUP2 092C 16 AND 092D 60 PUSH1 0x20 092F 85 DUP6 0930 01 ADD 0931 35 CALLDATALOAD 0932 60 PUSH1 0x40 0934 86 DUP7 0935 01 ADD 0936 35 CALLDATALOAD 0937 61 PUSH2 0x0943 093A 60 PUSH1 0x60 093C 88 DUP9 093D 01 ADD 093E 88 DUP9 093F 61 PUSH2 0x4315 0942 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @092C stack[0] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0931 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @0936 stack[2] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @0937 stack[3] = 0x0943 // @093D stack[4] = stack[-4] + 0x60 // @093E stack[5] = stack[-4] // } // Block ends with call to 0x4315, returns to 0x0943 label_0943: // Incoming return from call to 0x4315 at 0x0942 // Inputs[3] // { // @0946 memory[0x40:0x60] // @094A stack[-2] // @094B stack[-1] // } 0943 5B JUMPDEST 0944 60 PUSH1 0x40 0946 51 MLOAD 0947 61 PUSH2 0x0951 094A 92 SWAP3 094B 91 SWAP2 094C 90 SWAP1 094D 61 PUSH2 0x3b43 0950 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @094A stack[-2] = 0x0951 // @094B stack[-1] = stack[-2] // @094C stack[1] = memory[0x40:0x60] // @094C stack[0] = stack[-1] // } // Block ends with call to 0x3b43, returns to 0x0951 label_0951: // Incoming return from call to 0x3B43 at 0x0950 // Inputs[8] // { // @0956 memory[0x40:0x60] // @0958 stack[-1] // @095B stack[-2] // @095C stack[-4] // @095D stack[-3] // @095E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @095E address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0964 returndata.length // } 0951 5B JUMPDEST 0952 60 PUSH1 0x00 0954 60 PUSH1 0x40 0956 51 MLOAD 0957 80 DUP1 0958 83 DUP4 0959 03 SUB 095A 81 DUP2 095B 85 DUP6 095C 88 DUP9 095D 88 DUP9 095E F1 CALL 095F 93 SWAP4 0960 50 POP 0961 50 POP 0962 50 POP 0963 50 POP 0964 3D RETURNDATASIZE 0965 80 DUP1 0966 60 PUSH1 0x00 0968 81 DUP2 0969 14 EQ 096A 61 PUSH2 0x098f 096D 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @095E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @095F stack[-4] = address(stack[-4]).call.gas(stack[-3]).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0964 stack[-3] = returndata.length // @0965 stack[-2] = returndata.length // } // Block ends with conditional jump to 0x098f, if returndata.length == 0x00 label_096E: // Incoming jump from 0x096D, if not returndata.length == 0x00 // Inputs[6] // { // @0970 memory[0x40:0x60] // @0971 stack[-2] // @0978 returndata.length // @0980 returndata.length // @0983 returndata.length // @098A returndata[0x00:0x00 + returndata.length] // } 096E 60 PUSH1 0x40 0970 51 MLOAD 0971 91 SWAP2 0972 50 POP 0973 60 PUSH1 0x1f 0975 19 NOT 0976 60 PUSH1 0x3f 0978 3D RETURNDATASIZE 0979 01 ADD 097A 16 AND 097B 82 DUP3 097C 01 ADD 097D 60 PUSH1 0x40 097F 52 MSTORE 0980 3D RETURNDATASIZE 0981 82 DUP3 0982 52 MSTORE 0983 3D RETURNDATASIZE 0984 60 PUSH1 0x00 0986 60 PUSH1 0x20 0988 84 DUP5 0989 01 ADD 098A 3E RETURNDATACOPY 098B 61 PUSH2 0x0994 098E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0971 stack[-2] = memory[0x40:0x60] // @097F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0982 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @098A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0994 label_098F: // Incoming jump from 0x096D, if returndata.length == 0x00 // Inputs[4] // { // @0992 stack[-2] // @0996 stack[-3] // @0997 stack[-6] // @0999 stack[-5] // } 098F 5B JUMPDEST 0990 60 PUSH1 0x60 0992 91 SWAP2 0993 50 POP 0994 5B JUMPDEST 0995 50 POP 0996 90 SWAP1 0997 93 SWAP4 0998 50 POP 0999 91 SWAP2 099A 50 POP 099B 5B JUMPDEST 099C 82 DUP3 099D 61 PUSH2 0x0a5d 09A0 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0997 stack[-6] = stack[-3] // @0999 stack[-5] = 0x60 // } // Block ends with conditional jump to 0x0a5d, if stack[-3] label_09A1: // Incoming jump from 0x09A0, if not stack[-3] // Incoming jump from 0x09A0, if not stack[-3] // Inputs[2] // { // @09A6 stack[-2] // @09A9 memory[0x40:0x60] // } 09A1 60 PUSH1 0x60 09A3 61 PUSH2 0x09e1 09A6 83 DUP4 09A7 60 PUSH1 0x40 09A9 51 MLOAD 09AA 80 DUP1 09AB 60 PUSH1 0x40 09AD 01 ADD 09AE 60 PUSH1 0x40 09B0 52 MSTORE 09B1 80 DUP1 09B2 60 PUSH1 0x16 09B4 81 DUP2 09B5 52 MSTORE 09B6 60 PUSH1 0x20 09B8 01 ADD 09B9 7F PUSH32 0x45787465726e616c2063616c6c206661696c65643a2000000000000000000000 09DA 81 DUP2 09DB 52 MSTORE 09DC 50 POP 09DD 61 PUSH2 0x1de7 09E0 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @09A1 stack[0] = 0x60 // @09A3 stack[1] = 0x09e1 // @09A6 stack[2] = stack[-2] // @09A9 stack[3] = memory[0x40:0x60] // @09B0 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @09B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x16 // @09DB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x45787465726e616c2063616c6c206661696c65643a2000000000000000000000 // } // Block ends with call to 0x1de7, returns to 0x09E1 label_09E1: // Incoming return from call to 0x1DE7 at 0x09E0 // Incoming return from call to 0x1DE7 at 0x09E0 // Inputs[4] // { // @09E2 stack[-2] // @09E2 stack[-1] // @09E6 stack[-6] // @09E7 msg.data[stack[-6]:stack[-6] + 0x20] // } 09E1 5B JUMPDEST 09E2 90 SWAP1 09E3 50 POP 09E4 60 PUSH1 0x01 09E6 85 DUP6 09E7 35 CALLDATALOAD 09E8 60 PUSH1 0xff 09EA 1C SHR 09EB 14 EQ 09EC 15 ISZERO 09ED 61 PUSH2 0x0a24 09F0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @09E2 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0a24, if !(msg.data[stack[-6]:stack[-6] + 0x20] >> 0xff == 0x01) label_09F1: // Incoming jump from 0x09F0, if not !(msg.data[stack[-6]:stack[-6] + 0x20] >> 0xff == 0x01) // Inputs[2] // { // @09F1 stack[-1] // @09F4 memory[0x40:0x60] // } 09F1 80 DUP1 09F2 60 PUSH1 0x40 09F4 51 MLOAD 09F5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A16 81 DUP2 0A17 52 MSTORE 0A18 60 PUSH1 0x04 0A1A 01 ADD 0A1B 61 PUSH2 0x01c3 0A1E 91 SWAP2 0A1F 90 SWAP1 0A20 61 PUSH2 0x3e7a 0A23 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0A17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A1E stack[0] = 0x01c3 // @0A1F stack[1] = stack[-1] // @0A1F stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3e7a, returns to 0x01C3 label_0A24: // Incoming jump from 0x09F0, if !(msg.data[stack[-6]:stack[-6] + 0x20] >> 0xff == 0x01) // Inputs[2] // { // @0A46 stack[-1] // @0A49 memory[0x40:0x60] // } 0A24 5B JUMPDEST 0A25 7F PUSH32 0x08c379a0afcc32b1a39302f7cb8073359698411ab5fd6e3edb2c02c0b5fba8aa 0A46 81 DUP2 0A47 60 PUSH1 0x40 0A49 51 MLOAD 0A4A 61 PUSH2 0x0a53 0A4D 91 SWAP2 0A4E 90 SWAP1 0A4F 61 PUSH2 0x3e7a 0A52 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A25 stack[0] = 0x08c379a0afcc32b1a39302f7cb8073359698411ab5fd6e3edb2c02c0b5fba8aa // @0A4D stack[1] = 0x0a53 // @0A4E stack[2] = stack[-1] // @0A4E stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x3e7a, returns to 0x0A53 label_0A53: // Incoming return from call to 0x3E7A at 0x0A52 // Inputs[4] // { // @0A56 memory[0x40:0x60] // @0A58 stack[-1] // @0A5B stack[-2] // @0A5B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A53 5B JUMPDEST 0A54 60 PUSH1 0x40 0A56 51 MLOAD 0A57 80 DUP1 0A58 91 SWAP2 0A59 03 SUB 0A5A 90 SWAP1 0A5B A1 LOG1 0A5C 50 POP // Stack delta = -3 // Outputs[1] { @0A5B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block continues label_0A5D: // Incoming jump from 0x43F5, if !(stack[-1] > stack[-4]) // Incoming jump from 0x09A0, if stack[-3] // Incoming jump from 0x0A5C // Incoming jump from 0x09A0, if stack[-3] // Inputs[1] { @0A62 stack[-5] } 0A5D 5B JUMPDEST 0A5E 50 POP 0A5F 50 POP 0A60 50 POP 0A61 50 POP 0A62 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0A63: // Incoming jump from 0x0245 // Inputs[3] // { // @0A81 stack[-1] // @0A83 stack[-3] // @0A8F msg.gas // } 0A63 5B JUMPDEST 0A64 60 PUSH1 0x00 0A66 80 DUP1 0A67 6D PUSH14 0x4946c0e9f43f4dee607b0ef1fa1c 0A76 61 PUSH2 0x0aa8 0A79 61 PUSH2 0xa37c 0A7C 61 PUSH2 0xb717 0A7F 60 PUSH1 0x05 0A81 87 DUP8 0A82 02 MUL 0A83 89 DUP10 0A84 01 ADD 0A85 01 ADD 0A86 04 DIV 0A87 61 PUSH2 0x17d4 0A8A 61 PUSH2 0x7530 0A8D 60 PUSH1 0x3f 0A8F 5A GAS 0A90 60 PUSH1 0x40 0A92 02 MUL 0A93 81 DUP2 0A94 61 PUSH2 0x0a99 0A97 57 *JUMPI // Stack delta = +9 // Outputs[9] // { // @0A64 stack[0] = 0x00 // @0A66 stack[1] = 0x00 // @0A67 stack[2] = 0x4946c0e9f43f4dee607b0ef1fa1c // @0A76 stack[3] = 0x0aa8 // @0A86 stack[4] = (stack[-3] + stack[-1] * 0x05 + 0xb717) / 0xa37c // @0A87 stack[5] = 0x17d4 // @0A8A stack[6] = 0x7530 // @0A8D stack[7] = 0x3f // @0A92 stack[8] = 0x40 * msg.gas // } // Block ends with conditional call to 0x0a99, returns to 0x0AA8, if 0x3f label_0A98: // Incoming jump from 0x0A97, if not 0x3f 0A98 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0A98 assert(); } // Block terminates label_0A99: // Incoming call from 0x0A97, returns to 0x0AA8, if 0x3f // Inputs[4] // { // @0A9A stack[-2] // @0A9A stack[-1] // @0A9B stack[-3] // @0A9C stack[-4] // } 0A99 5B JUMPDEST 0A9A 04 DIV 0A9B 03 SUB 0A9C 81 DUP2 0A9D 61 PUSH2 0x0aa2 0AA0 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0A9B stack[-3] = stack[-1] / stack[-2] - stack[-3] } // Block ends with conditional jump to 0x0aa2, if stack[-4] label_0AA1: // Incoming jump from 0x0AA0, if not stack[-4] 0AA1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0AA1 assert(); } // Block terminates label_0AA2: // Incoming jump from 0x0AA0, if stack[-4] // Inputs[2] // { // @0AA3 stack[-2] // @0AA3 stack[-1] // } 0AA2 5B JUMPDEST 0AA3 04 DIV 0AA4 61 PUSH2 0x21b9 0AA7 56 *JUMP // Stack delta = -1 // Outputs[1] { @0AA3 stack[-2] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x21b9 label_0AA8: // Incoming return from call to 0x0A99 at 0x0A97 // Inputs[7] // { // @0AA9 stack[-1] // @0AA9 stack[-3] // @0AAB stack[-4] // @0AAB stack[-2] // @0AAD stack[-7] // @0AAF stack[-8] // @0AB0 stack[-6] // } 0AA8 5B JUMPDEST 0AA9 91 SWAP2 0AAA 50 POP 0AAB 91 SWAP2 0AAC 50 POP 0AAD 93 SWAP4 0AAE 50 POP 0AAF 93 SWAP4 0AB0 91 SWAP2 0AB1 50 POP 0AB2 50 POP 0AB3 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0AAD stack[-7] = stack[-1] // @0AAF stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-8] label_0AB4: // Incoming call from 0x0770, returns to 0x0771 // Incoming jump from 0x027C // Inputs[2] // { // @0AB8 stack[-1] // @0AB9 memory[stack[-1]:stack[-1] + 0x20] // } 0AB4 5B JUMPDEST 0AB5 60 PUSH1 0x00 0AB7 5B JUMPDEST 0AB8 81 DUP2 0AB9 51 MLOAD 0ABA 81 DUP2 0ABB 10 LT 0ABC 15 ISZERO 0ABD 61 PUSH2 0x0ae4 0AC0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AB5 stack[0] = 0x00 } // Block ends with conditional jump to 0x0ae4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0AC1: // Incoming jump from 0x0AC0, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0AC4 stack[-2] // @0AC5 stack[-1] // @0AC7 memory[stack[-2]:stack[-2] + 0x20] // } 0AC1 61 PUSH2 0x0adc 0AC4 82 DUP3 0AC5 82 DUP3 0AC6 81 DUP2 0AC7 51 MLOAD 0AC8 81 DUP2 0AC9 10 LT 0ACA 61 PUSH2 0x0acf 0ACD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0AC1 stack[0] = 0x0adc // @0AC4 stack[1] = stack[-2] // @0AC5 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0acf, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0ACE: // Incoming jump from 0x0ACD, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0ACE FE *ASSERT // Stack delta = +0 // Outputs[1] { @0ACE assert(); } // Block terminates label_0ACF: // Incoming jump from 0x0ACD, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0AD2 stack[-1] // @0AD6 stack[-2] // @0AD7 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0ACF 5B JUMPDEST 0AD0 60 PUSH1 0x20 0AD2 02 MUL 0AD3 60 PUSH1 0x20 0AD5 01 ADD 0AD6 01 ADD 0AD7 51 MLOAD 0AD8 61 PUSH2 0x19b1 0ADB 56 *JUMP // Stack delta = -1 // Outputs[1] { @0AD7 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x19b1 0ADC 5B JUMPDEST 0ADD 60 PUSH1 0x01 0ADF 01 ADD 0AE0 61 PUSH2 0x0ab7 0AE3 56 *JUMP label_0AE4: // Incoming return from call to 0x250D at 0x0F4D // Incoming jump from 0x0AC0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @0AE7 stack[-3] } 0AE4 5B JUMPDEST 0AE5 50 POP 0AE6 50 POP 0AE7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0AE8: // Incoming jump from 0x029C // Inputs[4] // { // @0AFF stack[-1] // @0B0C msg.sender // @0B0D address(msg.sender).balance // @0B0E stack[-2] // } 0AE8 5B JUMPDEST 0AE9 60 PUSH1 0x00 0AEB 61 PUSH2 0x0b19 0AEE 6F PUSH16 0xffffffffffffffffffffffffffffffff 0AFF 83 DUP4 0B00 16 AND 0B01 61 PUSH2 0x0500 0B04 60 PUSH1 0x80 0B06 85 DUP6 0B07 90 SWAP1 0B08 1C SHR 0B09 61 PUSH2 0x0b13 0B0C 33 CALLER 0B0D 31 BALANCE 0B0E 88 DUP9 0B0F 61 PUSH2 0x1c52 0B12 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @0AE9 stack[0] = 0x00 // @0AEB stack[1] = 0x0b19 // @0B00 stack[2] = stack[-1] & 0xffffffffffffffffffffffffffffffff // @0B01 stack[3] = 0x0500 // @0B08 stack[4] = stack[-1] >> 0x80 // @0B09 stack[5] = 0x0b13 // @0B0D stack[6] = address(msg.sender).balance // @0B0E stack[7] = stack[-2] // } // Block ends with call to 0x1c52, returns to 0x0B13 label_0B13: // Incoming return from call to 0x21CF at 0x19AA // Incoming return from call to 0x1C52 at 0x0B12 // Incoming return from call to 0x21CF at 0x10CA // Inputs[2] // { // @0B14 stack[-2] // @0B14 stack[-1] // } 0B13 5B JUMPDEST 0B14 90 SWAP1 0B15 61 PUSH2 0x1bb2 0B18 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B14 stack[-1] = stack[-2] // @0B14 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x1bb2 label_0B19: // Incoming return from call to 0x0500 at 0x285A // Incoming jump from 0x1BD4, if stack[-1] / stack[-2] == stack[-3] // Incoming jump from 0x2811, if !(stack[-1] + stack[-2] < stack[-2]) // Incoming return from call to 0x0500 at 0x0B12 // Incoming jump from 0x376C, if !(stack[-4] - (stack[-3] + stack[-1]) i< 0x80) // Incoming jump from 0x3A56, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] & 0xff // Incoming jump from 0x21C7 // Inputs[4] // { // @0B1A stack[-2] // @0B1A stack[-1] // @0B1D stack[-5] // @0B1E stack[-4] // } 0B19 5B JUMPDEST 0B1A 90 SWAP1 0B1B 50 POP 0B1C 5B JUMPDEST 0B1D 92 SWAP3 0B1E 91 SWAP2 0B1F 50 POP 0B20 50 POP 0B21 56 *JUMP // Stack delta = -4 // Outputs[1] { @0B1D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0B22: // Incoming jump from 0x02C9 // Inputs[2] // { // @0B3D stack[-3] // @0B3F stack[-2] // } 0B22 5B JUMPDEST 0B23 60 PUSH1 0x00 0B25 61 PUSH2 0x0b44 0B28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B3D 85 DUP6 0B3E 16 AND 0B3F 84 DUP5 0B40 61 PUSH2 0x21cf 0B43 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B23 stack[0] = 0x00 // @0B25 stack[1] = 0x0b44 // @0B3E stack[2] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0B3F stack[3] = stack[-2] // } // Block ends with call to 0x21cf, returns to 0x0B44 label_0B44: // Incoming return from call to 0x21CF at 0x0B43 // Inputs[4] // { // @0B45 stack[-2] // @0B45 stack[-1] // @0B4A stack[-7] // @0B4B stack[-6] // } 0B44 5B JUMPDEST 0B45 90 SWAP1 0B46 50 POP 0B47 61 PUSH2 0x0b50 0B4A 86 DUP7 0B4B 86 DUP7 0B4C 61 PUSH2 0x0f44 0B4F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0B45 stack[-2] = stack[-1] // @0B47 stack[-1] = 0x0b50 // @0B4A stack[0] = stack[-7] // @0B4B stack[1] = stack[-6] // } // Block ends with call to 0x0f44, returns to 0x0B50 label_0B50: // Incoming return from call to 0x0F44 at 0x0B4F // Inputs[3] // { // @0B56 stack[-1] // @0B6F stack[-4] // @0B71 stack[-3] // } 0B50 5B JUMPDEST 0B51 60 PUSH1 0x00 0B53 61 PUSH2 0x0b7c 0B56 82 DUP3 0B57 61 PUSH2 0x0b76 0B5A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B6F 88 DUP9 0B70 16 AND 0B71 87 DUP8 0B72 61 PUSH2 0x21cf 0B75 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0B51 stack[0] = 0x00 // @0B53 stack[1] = 0x0b7c // @0B56 stack[2] = stack[-1] // @0B57 stack[3] = 0x0b76 // @0B70 stack[4] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @0B71 stack[5] = stack[-3] // } // Block ends with call to 0x21cf, returns to 0x0B76 label_0B76: // Incoming return from call to 0x21CF at 0x0B75 // Inputs[2] // { // @0B77 stack[-1] // @0B77 stack[-2] // } 0B76 5B JUMPDEST 0B77 90 SWAP1 0B78 61 PUSH2 0x1c52 0B7B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B77 stack[-1] = stack[-2] // @0B77 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x1c52 label_0B7C: // Incoming return from call to 0x0B76 at 0x0B75 // Inputs[3] // { // @0B7D stack[-1] // @0B7D stack[-2] // @0B7F stack[-4] // } 0B7C 5B JUMPDEST 0B7D 90 SWAP1 0B7E 50 POP 0B7F 82 DUP3 0B80 81 DUP2 0B81 10 LT 0B82 15 ISZERO 0B83 61 PUSH2 0x0bb8 0B86 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B7D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0bb8, if !(stack[-1] < stack[-4]) label_0B87: // Incoming jump from 0x0B86, if not !(stack[-1] < stack[-4]) // Inputs[1] { @0B89 memory[0x40:0x60] } 0B87 60 PUSH1 0x40 0B89 51 MLOAD 0B8A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BAB 81 DUP2 0BAC 52 MSTORE 0BAD 60 PUSH1 0x04 0BAF 01 ADD 0BB0 61 PUSH2 0x01c3 0BB3 90 SWAP1 0BB4 61 PUSH2 0x4083 0BB7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BB3 stack[0] = 0x01c3 // @0BB3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4083, returns to 0x01C3 label_0BB8: // Incoming jump from 0x0B86, if !(stack[-1] < stack[-4]) // Inputs[1] { @0BC0 stack[-8] } 0BB8 5B JUMPDEST 0BB9 50 POP 0BBA 50 POP 0BBB 50 POP 0BBC 50 POP 0BBD 50 POP 0BBE 50 POP 0BBF 50 POP 0BC0 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0BC1: // Incoming jump from 0x02E9 // Inputs[1] { @0BC2 stack[-7] } 0BC1 5B JUMPDEST 0BC2 86 DUP7 0BC3 61 PUSH2 0x0bf8 0BC6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf8, if stack[-7] label_0BC7: // Incoming jump from 0x0BC6, if not stack[-7] // Inputs[1] { @0BC9 memory[0x40:0x60] } 0BC7 60 PUSH1 0x40 0BC9 51 MLOAD 0BCA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BEB 81 DUP2 0BEC 52 MSTORE 0BED 60 PUSH1 0x04 0BEF 01 ADD 0BF0 61 PUSH2 0x01c3 0BF3 90 SWAP1 0BF4 61 PUSH2 0x4117 0BF7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BF3 stack[0] = 0x01c3 // @0BF3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4117, returns to 0x01C3 label_0BF8: // Incoming jump from 0x0BC6, if stack[-7] // Inputs[7] // { // @0BFB memory[0x40:0x60] // @0C1F address(this) // @0C2B stack[-8] // @0C2D stack[-7] // @0C2F stack[-4] // @0C31 stack[-2] // @0C33 stack[-1] // } 0BF8 5B JUMPDEST 0BF9 60 PUSH1 0x40 0BFB 51 MLOAD 0BFC 7F PUSH32 0x2e21592300000000000000000000000000000000000000000000000000000000 0C1D 81 DUP2 0C1E 52 MSTORE 0C1F 30 ADDRESS 0C20 90 SWAP1 0C21 63 PUSH4 0x2e215923 0C26 90 SWAP1 0C27 61 PUSH2 0x0c3c 0C2A 90 SWAP1 0C2B 8B DUP12 0C2C 90 SWAP1 0C2D 8B DUP12 0C2E 90 SWAP1 0C2F 89 DUP10 0C30 90 SWAP1 0C31 88 DUP9 0C32 90 SWAP1 0C33 88 DUP9 0C34 90 SWAP1 0C35 60 PUSH1 0x04 0C37 01 ADD 0C38 61 PUSH2 0x3d38 0C3B 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @0C1E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e21592300000000000000000000000000000000000000000000000000000000 // @0C20 stack[0] = address(this) // @0C26 stack[1] = 0x2e215923 // @0C2A stack[2] = 0x0c3c // @0C2C stack[3] = stack[-8] // @0C2E stack[4] = stack[-7] // @0C30 stack[5] = stack[-4] // @0C32 stack[6] = stack[-2] // @0C34 stack[7] = stack[-1] // @0C37 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3d38, returns to 0x0C3C label_0C3C: // Incoming return from call to 0x3D38 at 0x0C3B // Inputs[4] // { // @0C41 memory[0x40:0x60] // @0C43 stack[-1] // @0C48 stack[-3] // @0C4A address(stack[-3]).code.length // } 0C3C 5B JUMPDEST 0C3D 60 PUSH1 0x00 0C3F 60 PUSH1 0x40 0C41 51 MLOAD 0C42 80 DUP1 0C43 83 DUP4 0C44 03 SUB 0C45 81 DUP2 0C46 60 PUSH1 0x00 0C48 87 DUP8 0C49 80 DUP1 0C4A 3B EXTCODESIZE 0C4B 15 ISZERO 0C4C 80 DUP1 0C4D 15 ISZERO 0C4E 61 PUSH2 0x0c56 0C51 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0C3D stack[0] = 0x00 // @0C41 stack[1] = memory[0x40:0x60] // @0C44 stack[2] = stack[-1] - memory[0x40:0x60] // @0C45 stack[3] = memory[0x40:0x60] // @0C46 stack[4] = 0x00 // @0C48 stack[5] = stack[-3] // @0C4B stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0c56, if !!address(stack[-3]).code.length label_0C52: // Incoming jump from 0x0C51, if not !!address(stack[-3]).code.length // Inputs[1] { @0C55 memory[0x00:0x00] } 0C52 60 PUSH1 0x00 0C54 80 DUP1 0C55 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C55 revert(memory[0x00:0x00]); } // Block terminates label_0C56: // Incoming jump from 0x0C51, if !!address(stack[-3]).code.length // Inputs[10] // { // @0C58 msg.gas // @0C59 stack[-6] // @0C59 stack[-7] // @0C59 stack[-3] // @0C59 memory[stack[-4]:stack[-4] + stack[-5]] // @0C59 stack[-5] // @0C59 stack[-2] // @0C59 stack[-4] // @0C59 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C5A stack[-10] // } 0C56 5B JUMPDEST 0C57 50 POP 0C58 5A GAS 0C59 F1 CALL 0C5A 92 SWAP3 0C5B 50 POP 0C5C 50 POP 0C5D 50 POP 0C5E 80 DUP1 0C5F 15 ISZERO 0C60 61 PUSH2 0x0c67 0C63 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @0C59 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C5A 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 0x0c67, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0C64: // Incoming jump from 0x0C63, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 0C64 50 POP 0C65 60 PUSH1 0x01 0C67 5B JUMPDEST 0C68 61 PUSH2 0x0d31 0C6B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d31, if 0x01 label_0C6C: // Incoming jump from 0x0C6B, if not stack[-1] // Incoming jump from 0x0C6B, if not 0x01 // Inputs[1] { @0C6C returndata.length } 0C6C 3D RETURNDATASIZE 0C6D 80 DUP1 0C6E 80 DUP1 0C6F 15 ISZERO 0C70 61 PUSH2 0x0c95 0C73 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C6C stack[0] = returndata.length // @0C6D stack[1] = returndata.length // } // Block ends with conditional jump to 0x0c95, if !returndata.length label_0C74: // Incoming jump from 0x0C73, if not !returndata.length // Inputs[6] // { // @0C76 memory[0x40:0x60] // @0C77 stack[-2] // @0C7E returndata.length // @0C86 returndata.length // @0C89 returndata.length // @0C90 returndata[0x00:0x00 + returndata.length] // } 0C74 60 PUSH1 0x40 0C76 51 MLOAD 0C77 91 SWAP2 0C78 50 POP 0C79 60 PUSH1 0x1f 0C7B 19 NOT 0C7C 60 PUSH1 0x3f 0C7E 3D RETURNDATASIZE 0C7F 01 ADD 0C80 16 AND 0C81 82 DUP3 0C82 01 ADD 0C83 60 PUSH1 0x40 0C85 52 MSTORE 0C86 3D RETURNDATASIZE 0C87 82 DUP3 0C88 52 MSTORE 0C89 3D RETURNDATASIZE 0C8A 60 PUSH1 0x00 0C8C 60 PUSH1 0x20 0C8E 84 DUP5 0C8F 01 ADD 0C90 3E RETURNDATACOPY 0C91 61 PUSH2 0x0c9a 0C94 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0C77 stack[-2] = memory[0x40:0x60] // @0C85 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0C88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0C90 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0c9a label_0C95: // Incoming jump from 0x0C73, if !returndata.length // Inputs[2] // { // @0C98 stack[-2] // @0CC3 memory[0x40:0x60] // } 0C95 5B JUMPDEST 0C96 60 PUSH1 0x60 0C98 91 SWAP2 0C99 50 POP 0C9A 5B JUMPDEST 0C9B 50 POP 0C9C 7F PUSH32 0x08c379a0afcc32b1a39302f7cb8073359698411ab5fd6e3edb2c02c0b5fba8aa 0CBD 61 PUSH2 0x0cfb 0CC0 82 DUP3 0CC1 60 PUSH1 0x40 0CC3 51 MLOAD 0CC4 80 DUP1 0CC5 60 PUSH1 0x40 0CC7 01 ADD 0CC8 60 PUSH1 0x40 0CCA 52 MSTORE 0CCB 80 DUP1 0CCC 60 PUSH1 0x16 0CCE 81 DUP2 0CCF 52 MSTORE 0CD0 60 PUSH1 0x20 0CD2 01 ADD 0CD3 7F PUSH32 0x5772617070656420726f757465206661696c65643a2000000000000000000000 0CF4 81 DUP2 0CF5 52 MSTORE 0CF6 50 POP 0CF7 61 PUSH2 0x1de7 0CFA 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @0C98 stack[-2] = 0x60 // @0C9C stack[-1] = 0x08c379a0afcc32b1a39302f7cb8073359698411ab5fd6e3edb2c02c0b5fba8aa // @0CBD stack[0] = 0x0cfb // @0CC0 stack[1] = 0x60 // @0CC3 stack[2] = memory[0x40:0x60] // @0CCA memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0CCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x16 // @0CF5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x5772617070656420726f757465206661696c65643a2000000000000000000000 // } // Block ends with call to 0x1de7, returns to 0x0CFB label_0CFB: // Incoming return from call to 0x1DE7 at 0x0CFA // Incoming return from call to 0x1DE7 at 0x0CFA // Inputs[2] // { // @0CFE memory[0x40:0x60] // @0D02 stack[-1] // } 0CFB 5B JUMPDEST 0CFC 60 PUSH1 0x40 0CFE 51 MLOAD 0CFF 61 PUSH2 0x0d08 0D02 91 SWAP2 0D03 90 SWAP1 0D04 61 PUSH2 0x3e7a 0D07 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D02 stack[-1] = 0x0d08 // @0D03 stack[1] = memory[0x40:0x60] // @0D03 stack[0] = stack[-1] // } // Block ends with call to 0x3e7a, returns to 0x0D08 label_0D08: // Incoming return from call to 0x3E7A at 0x0D07 // Inputs[7] // { // @0D0B memory[0x40:0x60] // @0D0D stack[-1] // @0D10 stack[-2] // @0D10 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0D29 stack[-8] // @0D2B stack[-6] // @0D2C stack[-9] // } 0D08 5B JUMPDEST 0D09 60 PUSH1 0x40 0D0B 51 MLOAD 0D0C 80 DUP1 0D0D 91 SWAP2 0D0E 03 SUB 0D0F 90 SWAP1 0D10 A1 LOG1 0D11 61 PUSH2 0x0773 0D14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D29 87 DUP8 0D2A 16 AND 0D2B 85 DUP6 0D2C 89 DUP10 0D2D 61 PUSH2 0x22a6 0D30 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0D10 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); // @0D11 stack[-2] = 0x0773 // @0D2A stack[-1] = stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff // @0D2B stack[0] = stack[-6] // @0D2C stack[1] = stack[-9] // } // Block ends with call to 0x22a6, returns to 0x0773 label_0D31: // Incoming jump from 0x0C6B, if 0x01 // Incoming return from call to 0x23A4 at 0x0E83 // Incoming jump from 0x0C6B, if stack[-1] // Inputs[1] { @0D3A stack[-9] } 0D31 5B JUMPDEST 0D32 50 POP 0D33 50 POP 0D34 50 POP 0D35 50 POP 0D36 50 POP 0D37 50 POP 0D38 50 POP 0D39 50 POP 0D3A 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_0D3B: // Incoming jump from 0x0309 // Inputs[2] // { // @0D57 stack[-2] // @0D59 msg.sender // } 0D3B 5B JUMPDEST 0D3C 60 PUSH1 0x00 0D3E 80 DUP1 0D3F 61 PUSH2 0x0d5e 0D42 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D57 85 DUP6 0D58 16 AND 0D59 33 CALLER 0D5A 61 PUSH2 0x21cf 0D5D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D3C stack[0] = 0x00 // @0D3E stack[1] = 0x00 // @0D3F stack[2] = 0x0d5e // @0D58 stack[3] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0D59 stack[4] = msg.sender // } // Block ends with call to 0x21cf, returns to 0x0D5E label_0D5E: // Incoming return from call to 0x21CF at 0x0D5D // Inputs[3] // { // @0D5F stack[-2] // @0D5F stack[-1] // @0D61 stack[-4] // } 0D5E 5B JUMPDEST 0D5F 90 SWAP1 0D60 50 POP 0D61 82 DUP3 0D62 81 DUP2 0D63 11 GT 0D64 61 PUSH2 0x0d6e 0D67 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D5F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0d6e, if stack[-1] > stack[-4] label_0D68: // Incoming jump from 0x0D67, if not stack[-1] > stack[-4] 0D68 60 PUSH1 0x00 0D6A 61 PUSH2 0x0d72 0D6D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D68 stack[0] = 0x00 } // Block ends with unconditional jump to 0x0d72 label_0D6E: // Incoming jump from 0x0D67, if stack[-1] > stack[-4] // Inputs[2] // { // @0D6F stack[-3] // @0D70 stack[-1] // } 0D6E 5B JUMPDEST 0D6F 82 DUP3 0D70 81 DUP2 0D71 03 SUB // Stack delta = +1 // Outputs[1] { @0D71 stack[0] = stack[-1] - stack[-3] } // Block continues label_0D72: // Incoming return from call to 0x3206 at 0x37A2 // Incoming jump from 0x0D71 // Incoming return from call to 0x314F at 0x348A // Incoming return from call to 0x19AB at 0x19AA // Incoming jump from 0x0D6D // Inputs[3] // { // @0D73 stack[-1] // @0D73 stack[-6] // @0D74 stack[-5] // } 0D72 5B JUMPDEST 0D73 94 SWAP5 0D74 93 SWAP4 0D75 50 POP 0D76 50 POP 0D77 50 POP 0D78 50 POP 0D79 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D73 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0D7A: // Incoming jump from 0x0329 // Inputs[4] // { // @0D7F stack[-3] // @0D96 stack[-2] // @0D97 stack[-1] // @0D9A memory[0x40:0x60] // } 0D7A 5B JUMPDEST 0D7B 60 PUSH1 0x00 0D7D 60 PUSH1 0x60 0D7F 84 DUP5 0D80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D95 16 AND 0D96 84 DUP5 0D97 84 DUP5 0D98 60 PUSH1 0x40 0D9A 51 MLOAD 0D9B 61 PUSH2 0x0da5 0D9E 92 SWAP3 0D9F 91 SWAP2 0DA0 90 SWAP1 0DA1 61 PUSH2 0x3b43 0DA4 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0D7B stack[0] = 0x00 // @0D7D stack[1] = 0x60 // @0D95 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0D9E stack[3] = 0x0da5 // @0D9F stack[4] = stack[-2] // @0DA0 stack[5] = stack[-1] // @0DA0 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x3b43, returns to 0x0DA5 label_0DA5: // Incoming return from call to 0x3B43 at 0x0DA4 // Inputs[7] // { // @0DAA memory[0x40:0x60] // @0DAC stack[-1] // @0DAF stack[-2] // @0DB0 msg.gas // @0DB1 address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0DB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0DB5 returndata.length // } 0DA5 5B JUMPDEST 0DA6 60 PUSH1 0x00 0DA8 60 PUSH1 0x40 0DAA 51 MLOAD 0DAB 80 DUP1 0DAC 83 DUP4 0DAD 03 SUB 0DAE 81 DUP2 0DAF 85 DUP6 0DB0 5A GAS 0DB1 FA STATICCALL 0DB2 91 SWAP2 0DB3 50 POP 0DB4 50 POP 0DB5 3D RETURNDATASIZE 0DB6 80 DUP1 0DB7 60 PUSH1 0x00 0DB9 81 DUP2 0DBA 14 EQ 0DBB 61 PUSH2 0x0de0 0DBE 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0DB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0DB2 stack[-2] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0DB5 stack[-1] = returndata.length // @0DB6 stack[0] = returndata.length // } // Block ends with conditional jump to 0x0de0, if returndata.length == 0x00 label_0DBF: // Incoming jump from 0x0DBE, if not returndata.length == 0x00 // Inputs[6] // { // @0DC1 memory[0x40:0x60] // @0DC2 stack[-2] // @0DC9 returndata.length // @0DD1 returndata.length // @0DD4 returndata.length // @0DDB returndata[0x00:0x00 + returndata.length] // } 0DBF 60 PUSH1 0x40 0DC1 51 MLOAD 0DC2 91 SWAP2 0DC3 50 POP 0DC4 60 PUSH1 0x1f 0DC6 19 NOT 0DC7 60 PUSH1 0x3f 0DC9 3D RETURNDATASIZE 0DCA 01 ADD 0DCB 16 AND 0DCC 82 DUP3 0DCD 01 ADD 0DCE 60 PUSH1 0x40 0DD0 52 MSTORE 0DD1 3D RETURNDATASIZE 0DD2 82 DUP3 0DD3 52 MSTORE 0DD4 3D RETURNDATASIZE 0DD5 60 PUSH1 0x00 0DD7 60 PUSH1 0x20 0DD9 84 DUP5 0DDA 01 ADD 0DDB 3E RETURNDATACOPY 0DDC 61 PUSH2 0x0de5 0DDF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0DC2 stack[-2] = memory[0x40:0x60] // @0DD0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0DD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0DDB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0de5 label_0DE0: // Incoming jump from 0x0DBE, if returndata.length == 0x00 // Inputs[4] // { // @0DE3 stack[-2] // @0DE7 stack[-4] // @0DE9 stack[-3] // @0DE9 stack[-5] // } 0DE0 5B JUMPDEST 0DE1 60 PUSH1 0x60 0DE3 91 SWAP2 0DE4 50 POP 0DE5 5B JUMPDEST 0DE6 50 POP 0DE7 91 SWAP2 0DE8 50 POP 0DE9 91 SWAP2 0DEA 50 POP 0DEB 81 DUP2 0DEC 61 PUSH2 0x0e61 0DEF 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0DE7 stack[-4] = 0x60 // @0DE9 stack[-5] = stack[-3] // } // Block ends with conditional jump to 0x0e61, if stack[-3] label_0DF0: // Incoming jump from 0x0DEF, if not stack[-3] // Incoming jump from 0x0DEF, if not stack[-3] // Inputs[2] // { // @0DF3 stack[-1] // @0DF6 memory[0x40:0x60] // } 0DF0 61 PUSH2 0x0e2e 0DF3 81 DUP2 0DF4 60 PUSH1 0x40 0DF6 51 MLOAD 0DF7 80 DUP1 0DF8 60 PUSH1 0x40 0DFA 01 ADD 0DFB 60 PUSH1 0x40 0DFD 52 MSTORE 0DFE 80 DUP1 0DFF 60 PUSH1 0x13 0E01 81 DUP2 0E02 52 MSTORE 0E03 60 PUSH1 0x20 0E05 01 ADD 0E06 7F PUSH32 0x50617463682063616c6c206661696c65643a2000000000000000000000000000 0E27 81 DUP2 0E28 52 MSTORE 0E29 50 POP 0E2A 61 PUSH2 0x1de7 0E2D 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0DF0 stack[0] = 0x0e2e // @0DF3 stack[1] = stack[-1] // @0DF6 stack[2] = memory[0x40:0x60] // @0DFD memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0E02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x13 // @0E28 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x50617463682063616c6c206661696c65643a2000000000000000000000000000 // } // Block ends with call to 0x1de7, returns to 0x0E2E label_0E2E: // Incoming return from call to 0x1DE7 at 0x0E2D // Incoming return from call to 0x1DE7 at 0x103B // Inputs[2] // { // @0E31 memory[0x40:0x60] // @0E5B stack[-1] // } 0E2E 5B JUMPDEST 0E2F 60 PUSH1 0x40 0E31 51 MLOAD 0E32 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E53 81 DUP2 0E54 52 MSTORE 0E55 60 PUSH1 0x04 0E57 01 ADD 0E58 61 PUSH2 0x01c3 0E5B 91 SWAP2 0E5C 90 SWAP1 0E5D 61 PUSH2 0x3e7a 0E60 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0E54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E5B stack[-1] = 0x01c3 // @0E5C stack[1] = 0x04 + memory[0x40:0x60] // @0E5C stack[0] = stack[-1] // } // Block ends with call to 0x3e7a, returns to 0x01C3 label_0E61: // Incoming jump from 0x0DEF, if stack[-3] // Incoming jump from 0x0DEF, if stack[-3] // Inputs[2] // { // @0E64 stack[-1] // @0E6A memory[stack[-1]:stack[-1] + 0x20] // } 0E61 5B JUMPDEST 0E62 60 PUSH1 0x00 0E64 81 DUP2 0E65 80 DUP1 0E66 60 PUSH1 0x20 0E68 01 ADD 0E69 90 SWAP1 0E6A 51 MLOAD 0E6B 81 DUP2 0E6C 01 ADD 0E6D 90 SWAP1 0E6E 61 PUSH2 0x0e77 0E71 91 SWAP2 0E72 90 SWAP1 0E73 61 PUSH2 0x38dc 0E76 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E62 stack[0] = 0x00 // @0E71 stack[1] = 0x0e77 // @0E72 stack[2] = 0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20] // @0E72 stack[3] = 0x20 + stack[-1] // } // Block ends with call to 0x38dc, returns to 0x0E77 label_0E77: // Incoming return from call to 0x38DC at 0x0E76 // Inputs[4] // { // @0E78 stack[-1] // @0E78 stack[-2] // @0E7D stack[-9] // @0E7E stack[-8] // } 0E77 5B JUMPDEST 0E78 90 SWAP1 0E79 50 POP 0E7A 61 PUSH2 0x0d31 0E7D 88 DUP9 0E7E 88 DUP9 0E7F 83 DUP4 0E80 61 PUSH2 0x23a4 0E83 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0E78 stack[-2] = stack[-1] // @0E7A stack[-1] = 0x0d31 // @0E7D stack[0] = stack[-9] // @0E7E stack[1] = stack[-8] // @0E7F stack[2] = stack[-1] // } // Block ends with call to 0x23a4, returns to 0x0D31 0E84 5B JUMPDEST 0E85 84 DUP5 0E86 51 MLOAD 0E87 83 DUP4 0E88 14 EQ 0E89 61 PUSH2 0x0ebe 0E8C 57 *JUMPI 0E8D 60 PUSH1 0x40 0E8F 51 MLOAD 0E90 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EB1 81 DUP2 0EB2 52 MSTORE 0EB3 60 PUSH1 0x04 0EB5 01 ADD 0EB6 61 PUSH2 0x01c3 0EB9 90 SWAP1 0EBA 61 PUSH2 0x4185 0EBD 56 *JUMP 0EBE 5B JUMPDEST 0EBF 60 PUSH1 0x00 0EC1 61 PUSH2 0x0efe 0EC4 6F PUSH16 0xffffffffffffffffffffffffffffffff 0ED5 83 DUP4 0ED6 16 AND 0ED7 61 PUSH2 0x0500 0EDA 60 PUSH1 0x80 0EDC 85 DUP6 0EDD 90 SWAP1 0EDE 1C SHR 0EDF 61 PUSH2 0x0b13 0EE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF7 88 DUP9 0EF8 16 AND 0EF9 33 CALLER 0EFA 61 PUSH2 0x21cf 0EFD 56 *JUMP 0EFE 5B JUMPDEST 0EFF 90 SWAP1 0F00 50 POP 0F01 60 PUSH1 0x00 0F03 5B JUMPDEST 0F04 86 DUP7 0F05 51 MLOAD 0F06 81 DUP2 0F07 10 LT 0F08 15 ISZERO 0F09 61 PUSH2 0x0bb8 0F0C 57 *JUMPI 0F0D 61 PUSH2 0x0f3c 0F10 87 DUP8 0F11 82 DUP3 0F12 81 DUP2 0F13 51 MLOAD 0F14 81 DUP2 0F15 10 LT 0F16 61 PUSH2 0x0f1b 0F19 57 *JUMPI 0F1A FE *ASSERT 0F1B 5B JUMPDEST 0F1C 60 PUSH1 0x20 0F1E 02 MUL 0F1F 60 PUSH1 0x20 0F21 01 ADD 0F22 01 ADD 0F23 51 MLOAD 0F24 87 DUP8 0F25 87 DUP8 0F26 84 DUP5 0F27 81 DUP2 0F28 81 DUP2 0F29 10 LT 0F2A 61 PUSH2 0x0f2f 0F2D 57 *JUMPI 0F2E FE *ASSERT label_0F2F: // Incoming jump from 0x1081, if stack[-4] < stack[-11] // Inputs[5] // { // @0F30 stack[-1] // @0F30 stack[-2] // @0F35 stack[-3] // @0F36 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0F37 stack[-7] // } 0F2F 5B JUMPDEST 0F30 90 SWAP1 0F31 50 POP 0F32 60 PUSH1 0x20 0F34 02 MUL 0F35 01 ADD 0F36 35 CALLDATALOAD 0F37 84 DUP5 0F38 61 PUSH2 0x23a4 0F3B 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0F36 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0F37 stack[-2] = stack[-7] // } // Block ends with unconditional jump to 0x23a4 0F3C 5B JUMPDEST 0F3D 60 PUSH1 0x01 0F3F 01 ADD 0F40 61 PUSH2 0x0f03 0F43 56 *JUMP label_0F44: // Incoming call from 0x0B4F, returns to 0x0B50 // Incoming jump from 0x0369 // Inputs[2] // { // @0F48 stack[-2] // @0F49 stack[-1] // } 0F44 5B JUMPDEST 0F45 61 PUSH2 0x0ae4 0F48 82 DUP3 0F49 82 DUP3 0F4A 61 PUSH2 0x250d 0F4D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F45 stack[0] = 0x0ae4 // @0F48 stack[1] = stack[-2] // @0F49 stack[2] = stack[-1] // } // Block ends with call to 0x250d, returns to 0x0AE4 label_0F4E: // Incoming jump from 0x0389 // Inputs[3] // { // @0F4F stack[-6] // @0F50 memory[stack[-6]:stack[-6] + 0x20] // @0F51 stack[-4] // } 0F4E 5B JUMPDEST 0F4F 85 DUP6 0F50 51 MLOAD 0F51 84 DUP5 0F52 14 EQ 0F53 61 PUSH2 0x0f88 0F56 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f88, if stack[-4] == memory[stack[-6]:stack[-6] + 0x20] label_0F57: // Incoming jump from 0x0F56, if not stack[-4] == memory[stack[-6]:stack[-6] + 0x20] // Inputs[1] { @0F59 memory[0x40:0x60] } 0F57 60 PUSH1 0x40 0F59 51 MLOAD 0F5A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F7B 81 DUP2 0F7C 52 MSTORE 0F7D 60 PUSH1 0x04 0F7F 01 ADD 0F80 61 PUSH2 0x01c3 0F83 90 SWAP1 0F84 61 PUSH2 0x4185 0F87 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F7C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F83 stack[0] = 0x01c3 // @0F83 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4185, returns to 0x01C3 label_0F88: // Incoming jump from 0x0F56, if stack[-4] == memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @0F8D stack[-3] // @0FA4 stack[-2] // @0FA5 stack[-1] // @0FA8 memory[0x40:0x60] // } 0F88 5B JUMPDEST 0F89 60 PUSH1 0x00 0F8B 60 PUSH1 0x60 0F8D 84 DUP5 0F8E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FA3 16 AND 0FA4 84 DUP5 0FA5 84 DUP5 0FA6 60 PUSH1 0x40 0FA8 51 MLOAD 0FA9 61 PUSH2 0x0fb3 0FAC 92 SWAP3 0FAD 91 SWAP2 0FAE 90 SWAP1 0FAF 61 PUSH2 0x3b43 0FB2 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0F89 stack[0] = 0x00 // @0F8B stack[1] = 0x60 // @0FA3 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0FAC stack[3] = 0x0fb3 // @0FAD stack[4] = stack[-2] // @0FAE stack[5] = stack[-1] // @0FAE stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x3b43, returns to 0x0FB3 label_0FB3: // Incoming return from call to 0x3B43 at 0x0FB2 // Inputs[7] // { // @0FB8 memory[0x40:0x60] // @0FBA stack[-1] // @0FBD stack[-2] // @0FBE msg.gas // @0FBF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0FBF address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0FC3 returndata.length // } 0FB3 5B JUMPDEST 0FB4 60 PUSH1 0x00 0FB6 60 PUSH1 0x40 0FB8 51 MLOAD 0FB9 80 DUP1 0FBA 83 DUP4 0FBB 03 SUB 0FBC 81 DUP2 0FBD 85 DUP6 0FBE 5A GAS 0FBF FA STATICCALL 0FC0 91 SWAP2 0FC1 50 POP 0FC2 50 POP 0FC3 3D RETURNDATASIZE 0FC4 80 DUP1 0FC5 60 PUSH1 0x00 0FC7 81 DUP2 0FC8 14 EQ 0FC9 61 PUSH2 0x0fee 0FCC 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0FBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0FC0 stack[-2] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0FC3 stack[-1] = returndata.length // @0FC4 stack[0] = returndata.length // } // Block ends with conditional jump to 0x0fee, if returndata.length == 0x00 label_0FCD: // Incoming jump from 0x0FCC, if not returndata.length == 0x00 // Inputs[6] // { // @0FCF memory[0x40:0x60] // @0FD0 stack[-2] // @0FD7 returndata.length // @0FDF returndata.length // @0FE2 returndata.length // @0FE9 returndata[0x00:0x00 + returndata.length] // } 0FCD 60 PUSH1 0x40 0FCF 51 MLOAD 0FD0 91 SWAP2 0FD1 50 POP 0FD2 60 PUSH1 0x1f 0FD4 19 NOT 0FD5 60 PUSH1 0x3f 0FD7 3D RETURNDATASIZE 0FD8 01 ADD 0FD9 16 AND 0FDA 82 DUP3 0FDB 01 ADD 0FDC 60 PUSH1 0x40 0FDE 52 MSTORE 0FDF 3D RETURNDATASIZE 0FE0 82 DUP3 0FE1 52 MSTORE 0FE2 3D RETURNDATASIZE 0FE3 60 PUSH1 0x00 0FE5 60 PUSH1 0x20 0FE7 84 DUP5 0FE8 01 ADD 0FE9 3E RETURNDATACOPY 0FEA 61 PUSH2 0x0ff3 0FED 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0FD0 stack[-2] = memory[0x40:0x60] // @0FDE memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0FE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0FE9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0ff3 label_0FEE: // Incoming jump from 0x0FCC, if returndata.length == 0x00 // Inputs[4] // { // @0FF1 stack[-2] // @0FF5 stack[-4] // @0FF7 stack[-3] // @0FF7 stack[-5] // } 0FEE 5B JUMPDEST 0FEF 60 PUSH1 0x60 0FF1 91 SWAP2 0FF2 50 POP 0FF3 5B JUMPDEST 0FF4 50 POP 0FF5 91 SWAP2 0FF6 50 POP 0FF7 91 SWAP2 0FF8 50 POP 0FF9 81 DUP2 0FFA 61 PUSH2 0x103c 0FFD 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0FF5 stack[-4] = 0x60 // @0FF7 stack[-5] = stack[-3] // } // Block ends with conditional jump to 0x103c, if stack[-3] label_0FFE: // Incoming jump from 0x0FFD, if not stack[-3] // Incoming jump from 0x0FFD, if not stack[-3] // Inputs[2] // { // @1001 stack[-1] // @1004 memory[0x40:0x60] // } 0FFE 61 PUSH2 0x0e2e 1001 81 DUP2 1002 60 PUSH1 0x40 1004 51 MLOAD 1005 80 DUP1 1006 60 PUSH1 0x40 1008 01 ADD 1009 60 PUSH1 0x40 100B 52 MSTORE 100C 80 DUP1 100D 60 PUSH1 0x13 100F 81 DUP2 1010 52 MSTORE 1011 60 PUSH1 0x20 1013 01 ADD 1014 7F PUSH32 0x50617463682063616c6c206661696c65643a2000000000000000000000000000 1035 81 DUP2 1036 52 MSTORE 1037 50 POP 1038 61 PUSH2 0x1de7 103B 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0FFE stack[0] = 0x0e2e // @1001 stack[1] = stack[-1] // @1004 stack[2] = memory[0x40:0x60] // @100B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1010 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x13 // @1036 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x50617463682063616c6c206661696c65643a2000000000000000000000000000 // } // Block ends with call to 0x1de7, returns to 0x0E2E label_103C: // Incoming jump from 0x0FFD, if stack[-3] // Incoming jump from 0x0FFD, if stack[-3] // Inputs[2] // { // @103F stack[-1] // @1045 memory[stack[-1]:stack[-1] + 0x20] // } 103C 5B JUMPDEST 103D 60 PUSH1 0x00 103F 81 DUP2 1040 80 DUP1 1041 60 PUSH1 0x20 1043 01 ADD 1044 90 SWAP1 1045 51 MLOAD 1046 81 DUP2 1047 01 ADD 1048 90 SWAP1 1049 61 PUSH2 0x1052 104C 91 SWAP2 104D 90 SWAP1 104E 61 PUSH2 0x38dc 1051 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @103D stack[0] = 0x00 // @104C stack[1] = 0x1052 // @104D stack[2] = 0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20] // @104D stack[3] = 0x20 + stack[-1] // } // Block ends with call to 0x38dc, returns to 0x1052 label_1052: // Incoming return from call to 0x38DC at 0x1051 // Inputs[4] // { // @1053 stack[-1] // @1053 stack[-2] // @1058 stack[-10] // @1059 memory[stack[-10]:stack[-10] + 0x20] // } 1052 5B JUMPDEST 1053 90 SWAP1 1054 50 POP 1055 60 PUSH1 0x00 1057 5B JUMPDEST 1058 89 DUP10 1059 51 MLOAD 105A 81 DUP2 105B 10 LT 105C 15 ISZERO 105D 61 PUSH2 0x0771 1060 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1053 stack[-2] = stack[-1] // @1055 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0771, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) label_1061: // Incoming jump from 0x1060, if not !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x1060, if not !(stack[-1] < memory[stack[-10]:stack[-10] + 0x20]) // Inputs[3] // { // @1064 stack[-10] // @1065 stack[-1] // @1067 memory[stack[-10]:stack[-10] + 0x20] // } 1061 61 PUSH2 0x1083 1064 8A DUP11 1065 82 DUP3 1066 81 DUP2 1067 51 MLOAD 1068 81 DUP2 1069 10 LT 106A 61 PUSH2 0x106f 106D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1061 stack[0] = 0x1083 // @1064 stack[1] = stack[-10] // @1065 stack[2] = stack[-1] // } // Block ends with conditional call to 0x106f, returns to 0x1083, if stack[-1] < memory[stack[-10]:stack[-10] + 0x20] label_106E: // Incoming jump from 0x106D, if not stack[-1] < memory[stack[-10]:stack[-10] + 0x20] 106E FE *ASSERT // Stack delta = +0 // Outputs[1] { @106E assert(); } // Block terminates label_106F: // Incoming call from 0x106D, returns to 0x1083, if stack[-1] < memory[stack[-10]:stack[-10] + 0x20] // Inputs[6] // { // @1072 stack[-1] // @1076 stack[-2] // @1077 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1078 stack[-12] // @1079 stack[-11] // @107A stack[-4] // } 106F 5B JUMPDEST 1070 60 PUSH1 0x20 1072 02 MUL 1073 60 PUSH1 0x20 1075 01 ADD 1076 01 ADD 1077 51 MLOAD 1078 8A DUP11 1079 8A DUP11 107A 84 DUP5 107B 81 DUP2 107C 81 DUP2 107D 10 LT 107E 61 PUSH2 0x0f2f 1081 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1077 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1078 stack[-1] = stack[-12] // @1079 stack[0] = stack[-11] // @107A stack[1] = stack[-4] // } // Block ends with conditional jump to 0x0f2f, if stack[-4] < stack[-11] label_1082: // Incoming jump from 0x1081, if not stack[-4] < stack[-11] 1082 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1082 assert(); } // Block terminates label_1083: // Incoming return from call to 0x106F at 0x106D // Inputs[1] { @1086 stack[-1] } 1083 5B JUMPDEST 1084 60 PUSH1 0x01 1086 01 ADD 1087 61 PUSH2 0x1057 108A 56 *JUMP // Stack delta = +0 // Outputs[1] { @1086 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x1057 label_108B: // Incoming jump from 0x03A9 // Inputs[3] // { // @10A2 stack[-1] // @10C4 stack[-2] // @10C6 msg.sender // } 108B 5B JUMPDEST 108C 60 PUSH1 0x00 108E 61 PUSH2 0x10cb 1091 6F PUSH16 0xffffffffffffffffffffffffffffffff 10A2 83 DUP4 10A3 16 AND 10A4 61 PUSH2 0x0500 10A7 60 PUSH1 0x80 10A9 85 DUP6 10AA 90 SWAP1 10AB 1C SHR 10AC 61 PUSH2 0x0b13 10AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C4 88 DUP9 10C5 16 AND 10C6 33 CALLER 10C7 61 PUSH2 0x21cf 10CA 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @108C stack[0] = 0x00 // @108E stack[1] = 0x10cb // @10A3 stack[2] = stack[-1] & 0xffffffffffffffffffffffffffffffff // @10A4 stack[3] = 0x0500 // @10AB stack[4] = stack[-1] >> 0x80 // @10AC stack[5] = 0x0b13 // @10C5 stack[6] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @10C6 stack[7] = msg.sender // } // Block ends with call to 0x21cf, returns to 0x0B13 label_10CB: // Incoming return from call to 0x0500 at 0x10CA // Inputs[4] // { // @10CC stack[-1] // @10CC stack[-2] // @10D1 stack[-6] // @10D2 stack[-5] // } 10CB 5B JUMPDEST 10CC 90 SWAP1 10CD 50 POP 10CE 61 PUSH2 0x0778 10D1 85 DUP6 10D2 85 DUP6 10D3 83 DUP4 10D4 61 PUSH2 0x23a4 10D7 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @10CC stack[-2] = stack[-1] // @10CE stack[-1] = 0x0778 // @10D1 stack[0] = stack[-6] // @10D2 stack[1] = stack[-5] // @10D3 stack[2] = stack[-1] // } // Block ends with call to 0x23a4, returns to 0x0778 label_10D8: // Incoming jump from 0x03C9 // Inputs[5] // { // @10DF stack[-5] // @10E0 stack[-4] // @10E1 stack[-3] // @10E2 stack[-2] // @10E3 stack[-1] // } 10D8 5B JUMPDEST 10D9 60 PUSH1 0x00 10DB 80 DUP1 10DC 61 PUSH2 0x10e8 10DF 87 DUP8 10E0 87 DUP8 10E1 87 DUP8 10E2 87 DUP8 10E3 87 DUP8 10E4 61 PUSH2 0x2541 10E7 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @10D9 stack[0] = 0x00 // @10DB stack[1] = 0x00 // @10DC stack[2] = 0x10e8 // @10DF stack[3] = stack[-5] // @10E0 stack[4] = stack[-4] // @10E1 stack[5] = stack[-3] // @10E2 stack[6] = stack[-2] // @10E3 stack[7] = stack[-1] // } // Block ends with call to 0x2541, returns to 0x10E8 label_10E8: // Incoming return from call to 0x2541 at 0x10E7 // Inputs[7] // { // @10EB memory[0x40:0x60] // @110F stack[-2] // @1110 stack[-4] // @1112 stack[-3] // @1112 stack[-1] // @1129 stack[-9] // @113A stack[-6] // } 10E8 5B JUMPDEST 10E9 60 PUSH1 0x40 10EB 51 MLOAD 10EC 7F PUSH32 0x022c0d9f00000000000000000000000000000000000000000000000000000000 110D 81 DUP2 110E 52 MSTORE 110F 91 SWAP2 1110 93 SWAP4 1111 50 POP 1112 91 SWAP2 1113 50 POP 1114 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1129 88 DUP9 112A 16 AND 112B 90 SWAP1 112C 63 PUSH4 0x022c0d9f 1131 90 SWAP1 1132 61 PUSH2 0x1143 1135 90 SWAP1 1136 85 DUP6 1137 90 SWAP1 1138 85 DUP6 1139 90 SWAP1 113A 89 DUP10 113B 90 SWAP1 113C 60 PUSH1 0x04 113E 01 ADD 113F 61 PUSH2 0x42da 1142 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @110E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x022c0d9f00000000000000000000000000000000000000000000000000000000 // @1110 stack[-4] = stack[-2] // @1112 stack[-3] = stack[-1] // @112B stack[-2] = stack[-9] & 0xffffffffffffffffffffffffffffffffffffffff // @1131 stack[-1] = 0x022c0d9f // @1135 stack[0] = 0x1143 // @1137 stack[1] = stack[-2] // @1139 stack[2] = stack[-1] // @113B stack[3] = stack[-6] // @113E stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42da, returns to 0x1143 label_1143: // Incoming return from call to 0x42AE at 0x1946 // Incoming return from call to 0x42DA at 0x1142 // Inputs[4] // { // @1148 memory[0x40:0x60] // @114A stack[-1] // @114F stack[-3] // @1151 address(stack[-3]).code.length // } 1143 5B JUMPDEST 1144 60 PUSH1 0x00 1146 60 PUSH1 0x40 1148 51 MLOAD 1149 80 DUP1 114A 83 DUP4 114B 03 SUB 114C 81 DUP2 114D 60 PUSH1 0x00 114F 87 DUP8 1150 80 DUP1 1151 3B EXTCODESIZE 1152 15 ISZERO 1153 80 DUP1 1154 15 ISZERO 1155 61 PUSH2 0x115d 1158 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1144 stack[0] = 0x00 // @1148 stack[1] = memory[0x40:0x60] // @114B stack[2] = stack[-1] - memory[0x40:0x60] // @114C stack[3] = memory[0x40:0x60] // @114D stack[4] = 0x00 // @114F stack[5] = stack[-3] // @1152 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x115d, if !!address(stack[-3]).code.length label_1159: // Incoming jump from 0x1158, if not !!address(stack[-3]).code.length // Inputs[1] { @115C memory[0x00:0x00] } 1159 60 PUSH1 0x00 115B 80 DUP1 115C FD *REVERT // Stack delta = +0 // Outputs[1] { @115C revert(memory[0x00:0x00]); } // Block terminates label_115D: // Incoming jump from 0x1158, if !!address(stack[-3]).code.length // Inputs[9] // { // @115F msg.gas // @1160 memory[stack[-4]:stack[-4] + stack[-5]] // @1160 stack[-5] // @1160 stack[-3] // @1160 stack[-2] // @1160 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1160 stack[-4] // @1160 stack[-7] // @1160 stack[-6] // } 115D 5B JUMPDEST 115E 50 POP 115F 5A GAS 1160 F1 CALL 1161 15 ISZERO 1162 80 DUP1 1163 15 ISZERO 1164 61 PUSH2 0x1171 1167 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1160 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1161 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1171, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1168: // Incoming jump from 0x1167, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1168 returndata.length // @116C returndata[0x00:0x00 + returndata.length] // @116D returndata.length // @1170 memory[0x00:0x00 + returndata.length] // } 1168 3D RETURNDATASIZE 1169 60 PUSH1 0x00 116B 80 DUP1 116C 3E RETURNDATACOPY 116D 3D RETURNDATASIZE 116E 60 PUSH1 0x00 1170 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @116C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1170 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1171: // Incoming jump from 0x1167, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @117D stack[-12] } 1171 5B JUMPDEST 1172 50 POP 1173 50 POP 1174 50 POP 1175 50 POP 1176 50 POP 1177 50 POP 1178 50 POP 1179 50 POP 117A 50 POP 117B 50 POP 117C 50 POP 117D 56 *JUMP // Stack delta = -12 // Block ends with unconditional jump to stack[-12] label_117E: // Incoming jump from 0x03E9 117E 5B JUMPDEST 117F 60 PUSH1 0x00 1181 61 PUSH2 0x1188 1184 61 PUSH2 0x303e 1187 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @117F stack[0] = 0x00 // @1181 stack[1] = 0x1188 // } // Block ends with call to 0x303e, returns to 0x1188 label_1188: // Incoming return from call to 0x303E at 0x1187 // Inputs[4] // { // @1189 stack[-4] // @11A7 memory[0x40:0x60] // @11BA memory[0x40:0x60] // @11C1 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } 1188 5B JUMPDEST 1189 83 DUP4 118A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 119F 16 AND 11A0 63 PUSH4 0xffa64225 11A5 60 PUSH1 0x40 11A7 51 MLOAD 11A8 81 DUP2 11A9 63 PUSH4 0xffffffff 11AE 16 AND 11AF 60 PUSH1 0xe0 11B1 1B SHL 11B2 81 DUP2 11B3 52 MSTORE 11B4 60 PUSH1 0x04 11B6 01 ADD 11B7 60 PUSH1 0x40 11B9 80 DUP1 11BA 51 MLOAD 11BB 80 DUP1 11BC 83 DUP4 11BD 03 SUB 11BE 81 DUP2 11BF 86 DUP7 11C0 80 DUP1 11C1 3B EXTCODESIZE 11C2 15 ISZERO 11C3 80 DUP1 11C4 15 ISZERO 11C5 61 PUSH2 0x11cd 11C8 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @119F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @11A0 stack[1] = 0xffa64225 // @11B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xffa64225) << 0xe0 // @11B6 stack[2] = 0x04 + memory[0x40:0x60] // @11B7 stack[3] = 0x40 // @11BA stack[4] = memory[0x40:0x60] // @11BD stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @11BE stack[6] = memory[0x40:0x60] // @11BF stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @11C2 stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } // Block ends with conditional jump to 0x11cd, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length label_11C9: // Incoming jump from 0x11C8, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[1] { @11CC memory[0x00:0x00] } 11C9 60 PUSH1 0x00 11CB 80 DUP1 11CC FD *REVERT // Stack delta = +0 // Outputs[1] { @11CC revert(memory[0x00:0x00]); } // Block terminates label_11CD: // Incoming jump from 0x11C8, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[8] // { // @11CF msg.gas // @11D0 stack[-3] // @11D0 stack[-6] // @11D0 stack[-4] // @11D0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @11D0 stack[-5] // @11D0 memory[stack[-3]:stack[-3] + stack[-4]] // @11D0 stack[-2] // } 11CD 5B JUMPDEST 11CE 50 POP 11CF 5A GAS 11D0 FA STATICCALL 11D1 15 ISZERO 11D2 80 DUP1 11D3 15 ISZERO 11D4 61 PUSH2 0x11e1 11D7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @11D0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @11D1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x11e1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_11D8: // Incoming jump from 0x11D7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @11D8 returndata.length // @11DC returndata[0x00:0x00 + returndata.length] // @11DD returndata.length // @11E0 memory[0x00:0x00 + returndata.length] // } 11D8 3D RETURNDATASIZE 11D9 60 PUSH1 0x00 11DB 80 DUP1 11DC 3E RETURNDATACOPY 11DD 3D RETURNDATASIZE 11DE 60 PUSH1 0x00 11E0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11DC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @11E0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_11E1: // Incoming jump from 0x11D7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @11E8 memory[0x40:0x60] // @11E9 returndata.length // } 11E1 5B JUMPDEST 11E2 50 POP 11E3 50 POP 11E4 50 POP 11E5 50 POP 11E6 60 PUSH1 0x40 11E8 51 MLOAD 11E9 3D RETURNDATASIZE 11EA 60 PUSH1 0x1f 11EC 19 NOT 11ED 60 PUSH1 0x1f 11EF 82 DUP3 11F0 01 ADD 11F1 16 AND 11F2 82 DUP3 11F3 01 ADD 11F4 80 DUP1 11F5 60 PUSH1 0x40 11F7 52 MSTORE 11F8 50 POP 11F9 81 DUP2 11FA 01 ADD 11FB 90 SWAP1 11FC 61 PUSH2 0x1205 11FF 91 SWAP2 1200 90 SWAP1 1201 61 PUSH2 0x39eb 1204 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @11F7 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @11FF stack[-4] = 0x1205 // @1200 stack[-2] = memory[0x40:0x60] // @1200 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x39eb, returns to 0x1205 label_1205: // Incoming return from call to 0x39EB at 0x1204 // Inputs[7] // { // @1208 stack[-3] // @120A stack[-1] // @120F stack[-2] // @1213 memory[0x40:0x60] // @1238 memory[0x40:0x60] // @124E stack[-6] // @1269 address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1205 5B JUMPDEST 1206 60 PUSH1 0xa0 1208 83 DUP4 1209 01 ADD 120A 52 MSTORE 120B 60 PUSH1 0x80 120D 82 DUP3 120E 01 ADD 120F 52 MSTORE 1210 60 PUSH1 0x40 1212 80 DUP1 1213 51 MLOAD 1214 7F PUSH32 0x17be952e00000000000000000000000000000000000000000000000000000000 1235 81 DUP2 1236 52 MSTORE 1237 90 SWAP1 1238 51 MLOAD 1239 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 124E 86 DUP7 124F 16 AND 1250 91 SWAP2 1251 63 PUSH4 0x17be952e 1256 91 SWAP2 1257 60 PUSH1 0x04 1259 80 DUP1 125A 83 DUP4 125B 01 ADD 125C 92 SWAP3 125D 60 PUSH1 0x20 125F 92 SWAP3 1260 91 SWAP2 1261 90 SWAP1 1262 82 DUP3 1263 90 SWAP1 1264 03 SUB 1265 01 ADD 1266 81 DUP2 1267 86 DUP7 1268 80 DUP1 1269 3B EXTCODESIZE 126A 15 ISZERO 126B 80 DUP1 126C 15 ISZERO 126D 61 PUSH2 0x1275 1270 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @120A memory[stack[-3] + 0xa0:stack[-3] + 0xa0 + 0x20] = stack[-1] // @120F memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] = stack[-2] // @1236 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x17be952e00000000000000000000000000000000000000000000000000000000 // @1250 stack[-2] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1256 stack[-1] = 0x17be952e // @125C stack[0] = memory[0x40:0x60] + 0x04 // @125F stack[1] = 0x20 // @1260 stack[2] = memory[0x40:0x60] // @1265 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @1266 stack[4] = memory[0x40:0x60] // @1267 stack[5] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @126A stack[6] = !address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x1275, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1271: // Incoming jump from 0x1270, if not !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1274 memory[0x00:0x00] } 1271 60 PUSH1 0x00 1273 80 DUP1 1274 FD *REVERT // Stack delta = +0 // Outputs[1] { @1274 revert(memory[0x00:0x00]); } // Block terminates label_1275: // Incoming jump from 0x1270, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1277 msg.gas // @1278 stack[-2] // @1278 stack[-6] // @1278 memory[stack[-3]:stack[-3] + stack[-4]] // @1278 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1278 stack[-5] // @1278 stack[-3] // @1278 stack[-4] // } 1275 5B JUMPDEST 1276 50 POP 1277 5A GAS 1278 FA STATICCALL 1279 15 ISZERO 127A 80 DUP1 127B 15 ISZERO 127C 61 PUSH2 0x1289 127F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1278 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1279 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1289, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1280: // Incoming jump from 0x127F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1280 returndata.length // @1284 returndata[0x00:0x00 + returndata.length] // @1285 returndata.length // @1288 memory[0x00:0x00 + returndata.length] // } 1280 3D RETURNDATASIZE 1281 60 PUSH1 0x00 1283 80 DUP1 1284 3E RETURNDATACOPY 1285 3D RETURNDATASIZE 1286 60 PUSH1 0x00 1288 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1284 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1288 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1289: // Incoming jump from 0x127F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1290 memory[0x40:0x60] // @1291 returndata.length // } 1289 5B JUMPDEST 128A 50 POP 128B 50 POP 128C 50 POP 128D 50 POP 128E 60 PUSH1 0x40 1290 51 MLOAD 1291 3D RETURNDATASIZE 1292 60 PUSH1 0x1f 1294 19 NOT 1295 60 PUSH1 0x1f 1297 82 DUP3 1298 01 ADD 1299 16 AND 129A 82 DUP3 129B 01 ADD 129C 80 DUP1 129D 60 PUSH1 0x40 129F 52 MSTORE 12A0 50 POP 12A1 81 DUP2 12A2 01 ADD 12A3 90 SWAP1 12A4 61 PUSH2 0x12ad 12A7 91 SWAP2 12A8 90 SWAP1 12A9 61 PUSH2 0x3a39 12AC 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @129F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @12A7 stack[-4] = 0x12ad // @12A8 stack[-2] = memory[0x40:0x60] // @12A8 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x3a39, returns to 0x12AD label_12AD: // Incoming return from call to 0x3A39 at 0x12AC // Inputs[1] { @12B0 stack[-1] } 12AD 5B JUMPDEST 12AE 60 PUSH1 0xff 12B0 16 AND 12B1 60 PUSH1 0x02 12B3 81 DUP2 12B4 11 GT 12B5 15 ISZERO 12B6 61 PUSH2 0x12bb 12B9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @12B0 stack[-1] = 0xff & stack[-1] } // Block ends with conditional jump to 0x12bb, if !(0xff & stack[-1] > 0x02) label_12BA: // Incoming jump from 0x12B9, if not !(0xff & stack[-1] > 0x02) 12BA FE *ASSERT // Stack delta = +0 // Outputs[1] { @12BA assert(); } // Block terminates label_12BB: // Incoming jump from 0x12B9, if !(0xff & stack[-1] > 0x02) // Inputs[2] // { // @12BC stack[-2] // @12C0 stack[-1] // } 12BB 5B JUMPDEST 12BC 81 DUP2 12BD 60 PUSH1 0xc0 12BF 01 ADD 12C0 90 SWAP1 12C1 60 PUSH1 0x02 12C3 81 DUP2 12C4 11 GT 12C5 15 ISZERO 12C6 61 PUSH2 0x12cb 12C9 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @12C0 stack[0] = stack[-1] // @12C0 stack[-1] = 0xc0 + stack[-2] // } // Block ends with conditional jump to 0x12cb, if !(stack[-1] > 0x02) label_12CA: // Incoming jump from 0x12C9, if not !(stack[-1] > 0x02) 12CA FE *ASSERT // Stack delta = +0 // Outputs[1] { @12CA assert(); } // Block terminates label_12CB: // Incoming jump from 0x12C9, if !(stack[-1] > 0x02) // Inputs[2] // { // @12CC stack[-1] // @12CC stack[-2] // } 12CB 5B JUMPDEST 12CC 90 SWAP1 12CD 81 DUP2 12CE 60 PUSH1 0x02 12D0 81 DUP2 12D1 11 GT 12D2 15 ISZERO 12D3 61 PUSH2 0x12d8 12D6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12CC stack[-2] = stack[-1] // @12CC stack[-1] = stack[-2] // @12CD stack[0] = stack[-1] // } // Block ends with conditional jump to 0x12d8, if !(stack[-1] > 0x02) label_12D7: // Incoming jump from 0x12D6, if not !(stack[-1] > 0x02) 12D7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12D7 assert(); } // Block terminates label_12D8: // Incoming jump from 0x12D6, if !(stack[-1] > 0x02) // Inputs[6] // { // @12D9 stack[-2] // @12DA stack[-1] // @12DD stack[-7] // @12FB memory[0x40:0x60] // @130F memory[0x40:0x60] // @1316 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } 12D8 5B JUMPDEST 12D9 81 DUP2 12DA 52 MSTORE 12DB 50 POP 12DC 50 POP 12DD 83 DUP4 12DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12F3 16 AND 12F4 63 PUSH4 0x796da7af 12F9 60 PUSH1 0x40 12FB 51 MLOAD 12FC 81 DUP2 12FD 63 PUSH4 0xffffffff 1302 16 AND 1303 60 PUSH1 0xe0 1305 1B SHL 1306 81 DUP2 1307 52 MSTORE 1308 60 PUSH1 0x04 130A 01 ADD 130B 60 PUSH1 0x20 130D 60 PUSH1 0x40 130F 51 MLOAD 1310 80 DUP1 1311 83 DUP4 1312 03 SUB 1313 81 DUP2 1314 86 DUP7 1315 80 DUP1 1316 3B EXTCODESIZE 1317 15 ISZERO 1318 80 DUP1 1319 15 ISZERO 131A 61 PUSH2 0x1322 131D 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @12DA memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @12F3 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @12F4 stack[-2] = 0x796da7af // @1307 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x796da7af) << 0xe0 // @130A stack[-1] = 0x04 + memory[0x40:0x60] // @130B stack[0] = 0x20 // @130F stack[1] = memory[0x40:0x60] // @1312 stack[2] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1313 stack[3] = memory[0x40:0x60] // @1314 stack[4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1317 stack[5] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } // Block ends with conditional jump to 0x1322, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length label_131E: // Incoming jump from 0x131D, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Inputs[1] { @1321 memory[0x00:0x00] } 131E 60 PUSH1 0x00 1320 80 DUP1 1321 FD *REVERT // Stack delta = +0 // Outputs[1] { @1321 revert(memory[0x00:0x00]); } // Block terminates label_1322: // Incoming jump from 0x131D, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Inputs[8] // { // @1324 msg.gas // @1325 stack[-3] // @1325 stack[-5] // @1325 stack[-2] // @1325 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1325 stack[-6] // @1325 memory[stack[-3]:stack[-3] + stack[-4]] // @1325 stack[-4] // } 1322 5B JUMPDEST 1323 50 POP 1324 5A GAS 1325 FA STATICCALL 1326 15 ISZERO 1327 80 DUP1 1328 15 ISZERO 1329 61 PUSH2 0x1336 132C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1325 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1326 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1336, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_132D: // Incoming jump from 0x132C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @132D returndata.length // @1331 returndata[0x00:0x00 + returndata.length] // @1332 returndata.length // @1335 memory[0x00:0x00 + returndata.length] // } 132D 3D RETURNDATASIZE 132E 60 PUSH1 0x00 1330 80 DUP1 1331 3E RETURNDATACOPY 1332 3D RETURNDATASIZE 1333 60 PUSH1 0x00 1335 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1331 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1335 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1336: // Incoming jump from 0x132C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @133D memory[0x40:0x60] // @133E returndata.length // } 1336 5B JUMPDEST 1337 50 POP 1338 50 POP 1339 50 POP 133A 50 POP 133B 60 PUSH1 0x40 133D 51 MLOAD 133E 3D RETURNDATASIZE 133F 60 PUSH1 0x1f 1341 19 NOT 1342 60 PUSH1 0x1f 1344 82 DUP3 1345 01 ADD 1346 16 AND 1347 82 DUP3 1348 01 ADD 1349 80 DUP1 134A 60 PUSH1 0x40 134C 52 MSTORE 134D 50 POP 134E 81 DUP2 134F 01 ADD 1350 90 SWAP1 1351 61 PUSH2 0x135a 1354 91 SWAP2 1355 90 SWAP1 1356 61 PUSH2 0x38dc 1359 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @134C memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1354 stack[-4] = 0x135a // @1355 stack[-2] = memory[0x40:0x60] // @1355 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x135A label_135A: // Incoming return from call to 0x38DC at 0x1359 // Inputs[6] // { // @135B stack[-2] // @135F stack[-1] // @1364 stack[-5] // @1382 memory[0x40:0x60] // @1396 memory[0x40:0x60] // @139D address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } 135A 5B JUMPDEST 135B 81 DUP2 135C 60 PUSH1 0x00 135E 01 ADD 135F 81 DUP2 1360 81 DUP2 1361 52 MSTORE 1362 50 POP 1363 50 POP 1364 83 DUP4 1365 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 137A 16 AND 137B 63 PUSH4 0x7c9b8e89 1380 60 PUSH1 0x40 1382 51 MLOAD 1383 81 DUP2 1384 63 PUSH4 0xffffffff 1389 16 AND 138A 60 PUSH1 0xe0 138C 1B SHL 138D 81 DUP2 138E 52 MSTORE 138F 60 PUSH1 0x04 1391 01 ADD 1392 60 PUSH1 0x20 1394 60 PUSH1 0x40 1396 51 MLOAD 1397 80 DUP1 1398 83 DUP4 1399 03 SUB 139A 81 DUP2 139B 86 DUP7 139C 80 DUP1 139D 3B EXTCODESIZE 139E 15 ISZERO 139F 80 DUP1 13A0 15 ISZERO 13A1 61 PUSH2 0x13a9 13A4 57 *JUMPI // Stack delta = +8 // Outputs[11] // { // @1361 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] = stack[-1] // @137A stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @137B stack[0] = 0x7c9b8e89 // @138E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x7c9b8e89) << 0xe0 // @1391 stack[1] = 0x04 + memory[0x40:0x60] // @1392 stack[2] = 0x20 // @1396 stack[3] = memory[0x40:0x60] // @1399 stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @139A stack[5] = memory[0x40:0x60] // @139B stack[6] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @139E stack[7] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } // Block ends with conditional jump to 0x13a9, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length label_13A5: // Incoming jump from 0x13A4, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[1] { @13A8 memory[0x00:0x00] } 13A5 60 PUSH1 0x00 13A7 80 DUP1 13A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @13A8 revert(memory[0x00:0x00]); } // Block terminates label_13A9: // Incoming jump from 0x13A4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[8] // { // @13AB msg.gas // @13AC stack[-2] // @13AC address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @13AC memory[stack[-3]:stack[-3] + stack[-4]] // @13AC stack[-6] // @13AC stack[-5] // @13AC stack[-3] // @13AC stack[-4] // } 13A9 5B JUMPDEST 13AA 50 POP 13AB 5A GAS 13AC FA STATICCALL 13AD 15 ISZERO 13AE 80 DUP1 13AF 15 ISZERO 13B0 61 PUSH2 0x13bd 13B3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @13AC memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @13AD stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x13bd, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_13B4: // Incoming jump from 0x13B3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @13B4 returndata.length // @13B8 returndata[0x00:0x00 + returndata.length] // @13B9 returndata.length // @13BC memory[0x00:0x00 + returndata.length] // } 13B4 3D RETURNDATASIZE 13B5 60 PUSH1 0x00 13B7 80 DUP1 13B8 3E RETURNDATACOPY 13B9 3D RETURNDATASIZE 13BA 60 PUSH1 0x00 13BC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @13B8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @13BC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_13BD: // Incoming jump from 0x13B3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @13C4 memory[0x40:0x60] // @13C5 returndata.length // } 13BD 5B JUMPDEST 13BE 50 POP 13BF 50 POP 13C0 50 POP 13C1 50 POP 13C2 60 PUSH1 0x40 13C4 51 MLOAD 13C5 3D RETURNDATASIZE 13C6 60 PUSH1 0x1f 13C8 19 NOT 13C9 60 PUSH1 0x1f 13CB 82 DUP3 13CC 01 ADD 13CD 16 AND 13CE 82 DUP3 13CF 01 ADD 13D0 80 DUP1 13D1 60 PUSH1 0x40 13D3 52 MSTORE 13D4 50 POP 13D5 81 DUP2 13D6 01 ADD 13D7 90 SWAP1 13D8 61 PUSH2 0x13e1 13DB 91 SWAP2 13DC 90 SWAP1 13DD 61 PUSH2 0x38dc 13E0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @13D3 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @13DB stack[-4] = 0x13e1 // @13DC stack[-2] = memory[0x40:0x60] // @13DC stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x13E1 label_13E1: // Incoming return from call to 0x38DC at 0x13E0 // Inputs[6] // { // @13E2 stack[-2] // @13E6 stack[-1] // @13EB stack[-5] // @1409 memory[0x40:0x60] // @141D memory[0x40:0x60] // @1424 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } 13E1 5B JUMPDEST 13E2 81 DUP2 13E3 60 PUSH1 0x60 13E5 01 ADD 13E6 81 DUP2 13E7 81 DUP2 13E8 52 MSTORE 13E9 50 POP 13EA 50 POP 13EB 83 DUP4 13EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1401 16 AND 1402 63 PUSH4 0xeab5d20e 1407 60 PUSH1 0x40 1409 51 MLOAD 140A 81 DUP2 140B 63 PUSH4 0xffffffff 1410 16 AND 1411 60 PUSH1 0xe0 1413 1B SHL 1414 81 DUP2 1415 52 MSTORE 1416 60 PUSH1 0x04 1418 01 ADD 1419 60 PUSH1 0x20 141B 60 PUSH1 0x40 141D 51 MLOAD 141E 80 DUP1 141F 83 DUP4 1420 03 SUB 1421 81 DUP2 1422 86 DUP7 1423 80 DUP1 1424 3B EXTCODESIZE 1425 15 ISZERO 1426 80 DUP1 1427 15 ISZERO 1428 61 PUSH2 0x1430 142B 57 *JUMPI // Stack delta = +8 // Outputs[11] // { // @13E8 memory[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] = stack[-1] // @1401 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1402 stack[0] = 0xeab5d20e // @1415 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xeab5d20e) << 0xe0 // @1418 stack[1] = 0x04 + memory[0x40:0x60] // @1419 stack[2] = 0x20 // @141D stack[3] = memory[0x40:0x60] // @1420 stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1421 stack[5] = memory[0x40:0x60] // @1422 stack[6] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1425 stack[7] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } // Block ends with conditional jump to 0x1430, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length label_142C: // Incoming jump from 0x142B, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[1] { @142F memory[0x00:0x00] } 142C 60 PUSH1 0x00 142E 80 DUP1 142F FD *REVERT // Stack delta = +0 // Outputs[1] { @142F revert(memory[0x00:0x00]); } // Block terminates label_1430: // Incoming jump from 0x142B, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[8] // { // @1432 msg.gas // @1433 stack[-6] // @1433 memory[stack[-3]:stack[-3] + stack[-4]] // @1433 stack[-4] // @1433 stack[-2] // @1433 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1433 stack[-5] // @1433 stack[-3] // } 1430 5B JUMPDEST 1431 50 POP 1432 5A GAS 1433 FA STATICCALL 1434 15 ISZERO 1435 80 DUP1 1436 15 ISZERO 1437 61 PUSH2 0x1444 143A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1433 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1434 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1444, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_143B: // Incoming jump from 0x143A, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @143B returndata.length // @143F returndata[0x00:0x00 + returndata.length] // @1440 returndata.length // @1443 memory[0x00:0x00 + returndata.length] // } 143B 3D RETURNDATASIZE 143C 60 PUSH1 0x00 143E 80 DUP1 143F 3E RETURNDATACOPY 1440 3D RETURNDATASIZE 1441 60 PUSH1 0x00 1443 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @143F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1443 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1444: // Incoming jump from 0x143A, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @144B memory[0x40:0x60] // @144C returndata.length // } 1444 5B JUMPDEST 1445 50 POP 1446 50 POP 1447 50 POP 1448 50 POP 1449 60 PUSH1 0x40 144B 51 MLOAD 144C 3D RETURNDATASIZE 144D 60 PUSH1 0x1f 144F 19 NOT 1450 60 PUSH1 0x1f 1452 82 DUP3 1453 01 ADD 1454 16 AND 1455 82 DUP3 1456 01 ADD 1457 80 DUP1 1458 60 PUSH1 0x40 145A 52 MSTORE 145B 50 POP 145C 81 DUP2 145D 01 ADD 145E 90 SWAP1 145F 61 PUSH2 0x1468 1462 91 SWAP2 1463 90 SWAP1 1464 61 PUSH2 0x38dc 1467 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @145A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1462 stack[-4] = 0x1468 // @1463 stack[-2] = memory[0x40:0x60] // @1463 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x1468 label_1468: // Incoming return from call to 0x38DC at 0x1467 // Inputs[6] // { // @1469 stack[-2] // @146D stack[-1] // @1472 stack[-5] // @1490 memory[0x40:0x60] // @14A4 memory[0x40:0x60] // @14AB address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } 1468 5B JUMPDEST 1469 81 DUP2 146A 60 PUSH1 0x40 146C 01 ADD 146D 81 DUP2 146E 81 DUP2 146F 52 MSTORE 1470 50 POP 1471 50 POP 1472 83 DUP4 1473 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1488 16 AND 1489 63 PUSH4 0xec2fd46d 148E 60 PUSH1 0x40 1490 51 MLOAD 1491 81 DUP2 1492 63 PUSH4 0xffffffff 1497 16 AND 1498 60 PUSH1 0xe0 149A 1B SHL 149B 81 DUP2 149C 52 MSTORE 149D 60 PUSH1 0x04 149F 01 ADD 14A0 60 PUSH1 0x20 14A2 60 PUSH1 0x40 14A4 51 MLOAD 14A5 80 DUP1 14A6 83 DUP4 14A7 03 SUB 14A8 81 DUP2 14A9 86 DUP7 14AA 80 DUP1 14AB 3B EXTCODESIZE 14AC 15 ISZERO 14AD 80 DUP1 14AE 15 ISZERO 14AF 61 PUSH2 0x14b7 14B2 57 *JUMPI // Stack delta = +8 // Outputs[11] // { // @146F memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] = stack[-1] // @1488 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1489 stack[0] = 0xec2fd46d // @149C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xec2fd46d) << 0xe0 // @149F stack[1] = 0x04 + memory[0x40:0x60] // @14A0 stack[2] = 0x20 // @14A4 stack[3] = memory[0x40:0x60] // @14A7 stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @14A8 stack[5] = memory[0x40:0x60] // @14A9 stack[6] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @14AC stack[7] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } // Block ends with conditional jump to 0x14b7, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length label_14B3: // Incoming jump from 0x14B2, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[1] { @14B6 memory[0x00:0x00] } 14B3 60 PUSH1 0x00 14B5 80 DUP1 14B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @14B6 revert(memory[0x00:0x00]); } // Block terminates label_14B7: // Incoming jump from 0x14B2, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[8] // { // @14B9 msg.gas // @14BA stack[-6] // @14BA memory[stack[-3]:stack[-3] + stack[-4]] // @14BA stack[-4] // @14BA stack[-5] // @14BA address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14BA stack[-2] // @14BA stack[-3] // } 14B7 5B JUMPDEST 14B8 50 POP 14B9 5A GAS 14BA FA STATICCALL 14BB 15 ISZERO 14BC 80 DUP1 14BD 15 ISZERO 14BE 61 PUSH2 0x14cb 14C1 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14BA memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14BB stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x14cb, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_14C2: // Incoming jump from 0x14C1, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @14C2 returndata.length // @14C6 returndata[0x00:0x00 + returndata.length] // @14C7 returndata.length // @14CA memory[0x00:0x00 + returndata.length] // } 14C2 3D RETURNDATASIZE 14C3 60 PUSH1 0x00 14C5 80 DUP1 14C6 3E RETURNDATACOPY 14C7 3D RETURNDATASIZE 14C8 60 PUSH1 0x00 14CA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14C6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @14CA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_14CB: // Incoming jump from 0x14C1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @14D2 memory[0x40:0x60] // @14D3 returndata.length // } 14CB 5B JUMPDEST 14CC 50 POP 14CD 50 POP 14CE 50 POP 14CF 50 POP 14D0 60 PUSH1 0x40 14D2 51 MLOAD 14D3 3D RETURNDATASIZE 14D4 60 PUSH1 0x1f 14D6 19 NOT 14D7 60 PUSH1 0x1f 14D9 82 DUP3 14DA 01 ADD 14DB 16 AND 14DC 82 DUP3 14DD 01 ADD 14DE 80 DUP1 14DF 60 PUSH1 0x40 14E1 52 MSTORE 14E2 50 POP 14E3 81 DUP2 14E4 01 ADD 14E5 90 SWAP1 14E6 61 PUSH2 0x14ef 14E9 91 SWAP2 14EA 90 SWAP1 14EB 61 PUSH2 0x38dc 14EE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @14E1 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @14E9 stack[-4] = 0x14ef // @14EA stack[-2] = memory[0x40:0x60] // @14EA stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x14EF label_14EF: // Incoming return from call to 0x38DC at 0x14EE // Inputs[3] // { // @14F2 stack[-2] // @14F4 stack[-1] // @14FC memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } 14EF 5B JUMPDEST 14F0 60 PUSH1 0x20 14F2 82 DUP3 14F3 01 ADD 14F4 52 MSTORE 14F5 60 PUSH1 0x00 14F7 80 DUP1 14F8 82 DUP3 14F9 60 PUSH1 0xc0 14FB 01 ADD 14FC 51 MLOAD 14FD 60 PUSH1 0x02 14FF 81 DUP2 1500 11 GT 1501 15 ISZERO 1502 61 PUSH2 0x1507 1505 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @14F4 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @14F5 stack[-1] = 0x00 // @14F7 stack[0] = 0x00 // @14FC stack[1] = memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1507, if !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) label_1506: // Incoming jump from 0x1505, if not !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) 1506 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1506 assert(); } // Block terminates label_1507: // Incoming jump from 0x1505, if !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) // Inputs[2] // { // @1508 stack[-1] // @1508 stack[-2] // } 1507 5B JUMPDEST 1508 14 EQ 1509 15 ISZERO 150A 61 PUSH2 0x151e 150D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x151e, if !(stack[-1] == stack[-2]) label_150E: // Incoming jump from 0x150D, if not !(stack[-1] == stack[-2]) // Inputs[2] // { // @1511 stack[-4] // @1512 stack[-2] // } 150E 61 PUSH2 0x1517 1511 84 DUP5 1512 83 DUP4 1513 61 PUSH2 0x271d 1516 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @150E stack[0] = 0x1517 // @1511 stack[1] = stack[-4] // @1512 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x271d 1517 5B JUMPDEST 1518 90 SWAP1 1519 50 POP 151A 61 PUSH2 0x15b9 151D 56 *JUMP label_151E: // Incoming jump from 0x150D, if !(stack[-1] == stack[-2]) // Inputs[2] // { // @1521 stack[-2] // @1525 memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } 151E 5B JUMPDEST 151F 60 PUSH1 0x01 1521 82 DUP3 1522 60 PUSH1 0xc0 1524 01 ADD 1525 51 MLOAD 1526 60 PUSH1 0x02 1528 81 DUP2 1529 11 GT 152A 15 ISZERO 152B 61 PUSH2 0x1530 152E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @151F stack[0] = 0x01 // @1525 stack[1] = memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1530, if !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) label_152F: // Incoming jump from 0x152E, if not !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) 152F FE *ASSERT // Stack delta = +0 // Outputs[1] { @152F assert(); } // Block terminates label_1530: // Incoming jump from 0x152E, if !(memory[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] > 0x02) // Inputs[2] // { // @1531 stack[-2] // @1531 stack[-1] // } 1530 5B JUMPDEST 1531 14 EQ 1532 15 ISZERO 1533 61 PUSH2 0x1540 1536 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1540, if !(stack[-1] == stack[-2]) label_1537: // Incoming jump from 0x1536, if not !(stack[-1] == stack[-2]) // Inputs[2] // { // @153A stack[-4] // @153B stack[-2] // } 1537 61 PUSH2 0x1517 153A 84 DUP5 153B 83 DUP4 153C 61 PUSH2 0x276f 153F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1537 stack[0] = 0x1517 // @153A stack[1] = stack[-4] // @153B stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x276f label_1540: // Incoming jump from 0x1536, if !(stack[-1] == stack[-2]) // Inputs[3] // { // @1546 stack[-2] // @154A memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // @154F memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 1540 5B JUMPDEST 1541 60 PUSH1 0x00 1543 61 PUSH2 0x155d 1546 83 DUP4 1547 60 PUSH1 0x80 1549 01 ADD 154A 51 MLOAD 154B 84 DUP5 154C 60 PUSH1 0x40 154E 01 ADD 154F 51 MLOAD 1550 61 PUSH2 0x1c52 1553 90 SWAP1 1554 91 SWAP2 1555 90 SWAP1 1556 63 PUSH4 0xffffffff 155B 16 AND 155C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1541 stack[0] = 0x00 // @1543 stack[1] = 0x155d // @1554 stack[2] = memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @1555 stack[3] = memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // } // Block ends with call to 0xffffffff & 0x1c52, returns to 0x155D label_155D: // Incoming return from call to 0x1C52 at 0x155C // Inputs[5] // { // @155E stack[-1] // @155E stack[-2] // @1565 stack[-4] // @1569 memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @156E memory[0xa0 + stack[-4]:0xa0 + stack[-4] + 0x20] // } 155D 5B JUMPDEST 155E 90 SWAP1 155F 50 POP 1560 60 PUSH1 0x00 1562 61 PUSH2 0x157c 1565 84 DUP5 1566 60 PUSH1 0x60 1568 01 ADD 1569 51 MLOAD 156A 85 DUP6 156B 60 PUSH1 0xa0 156D 01 ADD 156E 51 MLOAD 156F 61 PUSH2 0x1c52 1572 90 SWAP1 1573 91 SWAP2 1574 90 SWAP1 1575 63 PUSH4 0xffffffff 157A 16 AND 157B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @155E stack[-2] = stack[-1] // @1560 stack[-1] = 0x00 // @1562 stack[0] = 0x157c // @1573 stack[1] = memory[0xa0 + stack[-4]:0xa0 + stack[-4] + 0x20] // @1574 stack[2] = memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // } // Block ends with call to 0xffffffff & 0x1c52, returns to 0x157C label_157C: // Incoming return from call to 0x1C52 at 0x157B // Inputs[3] // { // @157D stack[-2] // @157D stack[-1] // @1580 stack[-7] // } 157C 5B JUMPDEST 157D 90 SWAP1 157E 50 POP 157F 80 DUP1 1580 86 DUP7 1581 11 GT 1582 61 PUSH2 0x1596 1585 57 *JUMPI // Stack delta = -1 // Outputs[1] { @157D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1596, if stack[-7] > stack[-1] label_1586: // Incoming jump from 0x1585, if not stack[-7] > stack[-1] // Inputs[2] // { // @1589 stack[-6] // @158A stack[-4] // } 1586 61 PUSH2 0x158f 1589 86 DUP7 158A 85 DUP6 158B 61 PUSH2 0x27b5 158E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1586 stack[0] = 0x158f // @1589 stack[1] = stack[-6] // @158A stack[2] = stack[-4] // } // Block ends with unconditional jump to 0x27b5 158F 5B JUMPDEST 1590 92 SWAP3 1591 50 POP 1592 61 PUSH2 0x15b6 1595 56 *JUMP label_1596: // Incoming jump from 0x1585, if stack[-7] > stack[-1] // Inputs[2] // { // @15A0 stack[-6] // @15A1 stack[-1] // } 1596 5B JUMPDEST 1597 61 PUSH2 0x15b3 159A 61 PUSH2 0x15ac 159D 61 PUSH2 0x15a6 15A0 88 DUP9 15A1 84 DUP5 15A2 61 PUSH2 0x1c52 15A5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1597 stack[0] = 0x15b3 // @159A stack[1] = 0x15ac // @159D stack[2] = 0x15a6 // @15A0 stack[3] = stack[-6] // @15A1 stack[4] = stack[-1] // } // Block ends with call to 0x1c52, returns to 0x15A6 label_15A6: // Incoming return from call to 0x1C52 at 0x15A5 // Inputs[1] { @15A7 stack[-7] } 15A6 5B JUMPDEST 15A7 86 DUP7 15A8 61 PUSH2 0x271d 15AB 56 *JUMP // Stack delta = +1 // Outputs[1] { @15A7 stack[0] = stack[-7] } // Block ends with unconditional jump to 0x271d 15AC 5B JUMPDEST 15AD 83 DUP4 15AE 90 SWAP1 15AF 61 PUSH2 0x2804 15B2 56 *JUMP 15B3 5B JUMPDEST 15B4 92 SWAP3 15B5 50 POP 15B6 5B JUMPDEST 15B7 50 POP 15B8 50 POP 15B9 5B JUMPDEST 15BA 61 PUSH2 0x16d9 15BD 81 DUP2 15BE 61 PUSH2 0x16d4 15C1 87 DUP8 15C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15D7 16 AND 15D8 63 PUSH4 0xab44a7a3 15DD 60 PUSH1 0x40 15DF 51 MLOAD 15E0 81 DUP2 15E1 63 PUSH4 0xffffffff 15E6 16 AND 15E7 60 PUSH1 0xe0 15E9 1B SHL 15EA 81 DUP2 15EB 52 MSTORE 15EC 60 PUSH1 0x04 15EE 01 ADD 15EF 60 PUSH1 0x20 15F1 60 PUSH1 0x40 15F3 51 MLOAD 15F4 80 DUP1 15F5 83 DUP4 15F6 03 SUB 15F7 81 DUP2 15F8 86 DUP7 15F9 80 DUP1 15FA 3B EXTCODESIZE 15FB 15 ISZERO 15FC 80 DUP1 15FD 15 ISZERO 15FE 61 PUSH2 0x1606 1601 57 *JUMPI 1602 60 PUSH1 0x00 1604 80 DUP1 1605 FD *REVERT 1606 5B JUMPDEST 1607 50 POP 1608 5A GAS 1609 FA STATICCALL 160A 15 ISZERO 160B 80 DUP1 160C 15 ISZERO 160D 61 PUSH2 0x161a 1610 57 *JUMPI 1611 3D RETURNDATASIZE 1612 60 PUSH1 0x00 1614 80 DUP1 1615 3E RETURNDATACOPY 1616 3D RETURNDATASIZE 1617 60 PUSH1 0x00 1619 FD *REVERT 161A 5B JUMPDEST 161B 50 POP 161C 50 POP 161D 50 POP 161E 50 POP 161F 60 PUSH1 0x40 1621 51 MLOAD 1622 3D RETURNDATASIZE 1623 60 PUSH1 0x1f 1625 19 NOT 1626 60 PUSH1 0x1f 1628 82 DUP3 1629 01 ADD 162A 16 AND 162B 82 DUP3 162C 01 ADD 162D 80 DUP1 162E 60 PUSH1 0x40 1630 52 MSTORE 1631 50 POP 1632 81 DUP2 1633 01 ADD 1634 90 SWAP1 1635 61 PUSH2 0x163e 1638 91 SWAP2 1639 90 SWAP1 163A 61 PUSH2 0x38dc 163D 56 *JUMP 163E 5B JUMPDEST 163F 61 PUSH2 0x16ce 1642 89 DUP10 1643 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1658 16 AND 1659 63 PUSH4 0xc0ffa178 165E 60 PUSH1 0x40 1660 51 MLOAD 1661 81 DUP2 1662 63 PUSH4 0xffffffff 1667 16 AND 1668 60 PUSH1 0xe0 166A 1B SHL 166B 81 DUP2 166C 52 MSTORE 166D 60 PUSH1 0x04 166F 01 ADD 1670 60 PUSH1 0x20 1672 60 PUSH1 0x40 1674 51 MLOAD 1675 80 DUP1 1676 83 DUP4 1677 03 SUB 1678 81 DUP2 1679 86 DUP7 167A 80 DUP1 167B 3B EXTCODESIZE 167C 15 ISZERO 167D 80 DUP1 167E 15 ISZERO 167F 61 PUSH2 0x1687 1682 57 *JUMPI 1683 60 PUSH1 0x00 1685 80 DUP1 1686 FD *REVERT 1687 5B JUMPDEST 1688 50 POP 1689 5A GAS 168A FA STATICCALL 168B 15 ISZERO 168C 80 DUP1 168D 15 ISZERO 168E 61 PUSH2 0x169b 1691 57 *JUMPI 1692 3D RETURNDATASIZE 1693 60 PUSH1 0x00 1695 80 DUP1 1696 3E RETURNDATACOPY 1697 3D RETURNDATASIZE 1698 60 PUSH1 0x00 169A FD *REVERT 169B 5B JUMPDEST 169C 50 POP 169D 50 POP 169E 50 POP 169F 50 POP 16A0 60 PUSH1 0x40 16A2 51 MLOAD 16A3 3D RETURNDATASIZE 16A4 60 PUSH1 0x1f 16A6 19 NOT 16A7 60 PUSH1 0x1f 16A9 82 DUP3 16AA 01 ADD 16AB 16 AND 16AC 82 DUP3 16AD 01 ADD 16AE 80 DUP1 16AF 60 PUSH1 0x40 16B1 52 MSTORE 16B2 50 POP 16B3 81 DUP2 16B4 01 ADD 16B5 90 SWAP1 16B6 61 PUSH2 0x16bf 16B9 91 SWAP2 16BA 90 SWAP1 16BB 61 PUSH2 0x38dc 16BE 56 *JUMP 16BF 5B JUMPDEST 16C0 67 PUSH8 0x0de0b6b3a7640000 16C9 90 SWAP1 16CA 61 PUSH2 0x2804 16CD 56 *JUMP label_16CE: // Incoming return from call to 0x1BB2 at 0x2686 // Inputs[2] // { // @16CF stack[-2] // @16CF stack[-1] // } 16CE 5B JUMPDEST 16CF 90 SWAP1 16D0 61 PUSH2 0x2804 16D3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @16CF stack[-1] = stack[-2] // @16CF stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x2804 16D4 5B JUMPDEST 16D5 61 PUSH2 0x2843 16D8 56 *JUMP 16D9 5B JUMPDEST 16DA 95 SWAP6 16DB 94 SWAP5 16DC 50 POP 16DD 50 POP 16DE 50 POP 16DF 50 POP 16E0 50 POP 16E1 56 *JUMP label_16E2: // Incoming jump from 0x0409 // Inputs[3] // { // @16FB stack[-3] // @16FD stack[-2] // @16FE stack[-1] // } 16E2 5B JUMPDEST 16E3 61 PUSH2 0x1703 16E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16FB 84 DUP5 16FC 16 AND 16FD 83 DUP4 16FE 83 DUP4 16FF 61 PUSH2 0x22a6 1702 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16E3 stack[0] = 0x1703 // @16FC stack[1] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @16FD stack[2] = stack[-2] // @16FE stack[3] = stack[-1] // } // Block ends with call to 0x22a6, returns to 0x1703 label_1703: // Incoming jump from 0x2518, if !(0x00 < stack[-1]) // Incoming jump from 0x2302 // Incoming jump from 0x2431 // Incoming jump from 0x2518, if !(stack[-1] < stack[-2]) // Incoming jump from 0x22AC, if !stack[-1] // Incoming return from call to 0x22A6 at 0x1702 // Inputs[1] { @1707 stack[-4] } 1703 5B JUMPDEST 1704 50 POP 1705 50 POP 1706 50 POP 1707 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1708: // Incoming jump from 0x0437 // Inputs[3] // { // @170B memory[0x40:0x60] // @1744 stack[-4] // @1751 address(this) // } 1708 5B JUMPDEST 1709 60 PUSH1 0x40 170B 51 MLOAD 170C 7F PUSH32 0x89afcb4400000000000000000000000000000000000000000000000000000000 172D 81 DUP2 172E 52 MSTORE 172F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1744 85 DUP6 1745 16 AND 1746 90 SWAP1 1747 63 PUSH4 0x89afcb44 174C 90 SWAP1 174D 61 PUSH2 0x175a 1750 90 SWAP1 1751 30 ADDRESS 1752 90 SWAP1 1753 60 PUSH1 0x04 1755 01 ADD 1756 61 PUSH2 0x3cc8 1759 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @172E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x89afcb4400000000000000000000000000000000000000000000000000000000 // @1746 stack[0] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @174C stack[1] = 0x89afcb44 // @1750 stack[2] = 0x175a // @1752 stack[3] = address(this) // @1755 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3cc8, returns to 0x175A label_175A: // Incoming return from call to 0x3CC8 at 0x1759 // Inputs[4] // { // @175E memory[0x40:0x60] // @1760 stack[-1] // @1765 stack[-3] // @1767 address(stack[-3]).code.length // } 175A 5B JUMPDEST 175B 60 PUSH1 0x40 175D 80 DUP1 175E 51 MLOAD 175F 80 DUP1 1760 83 DUP4 1761 03 SUB 1762 81 DUP2 1763 60 PUSH1 0x00 1765 87 DUP8 1766 80 DUP1 1767 3B EXTCODESIZE 1768 15 ISZERO 1769 80 DUP1 176A 15 ISZERO 176B 61 PUSH2 0x1773 176E 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @175B stack[0] = 0x40 // @175E stack[1] = memory[0x40:0x60] // @1761 stack[2] = stack[-1] - memory[0x40:0x60] // @1762 stack[3] = memory[0x40:0x60] // @1763 stack[4] = 0x00 // @1765 stack[5] = stack[-3] // @1768 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1773, if !!address(stack[-3]).code.length label_176F: // Incoming jump from 0x176E, if not !!address(stack[-3]).code.length // Inputs[1] { @1772 memory[0x00:0x00] } 176F 60 PUSH1 0x00 1771 80 DUP1 1772 FD *REVERT // Stack delta = +0 // Outputs[1] { @1772 revert(memory[0x00:0x00]); } // Block terminates label_1773: // Incoming jump from 0x176E, if !!address(stack[-3]).code.length // Inputs[9] // { // @1775 msg.gas // @1776 stack[-7] // @1776 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1776 stack[-5] // @1776 stack[-2] // @1776 stack[-3] // @1776 stack[-6] // @1776 memory[stack[-4]:stack[-4] + stack[-5]] // @1776 stack[-4] // } 1773 5B JUMPDEST 1774 50 POP 1775 5A GAS 1776 F1 CALL 1777 15 ISZERO 1778 80 DUP1 1779 15 ISZERO 177A 61 PUSH2 0x1787 177D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1776 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1777 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1787, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_177E: // Incoming jump from 0x177D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @177E returndata.length // @1782 returndata[0x00:0x00 + returndata.length] // @1783 returndata.length // @1786 memory[0x00:0x00 + returndata.length] // } 177E 3D RETURNDATASIZE 177F 60 PUSH1 0x00 1781 80 DUP1 1782 3E RETURNDATACOPY 1783 3D RETURNDATASIZE 1784 60 PUSH1 0x00 1786 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1782 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1786 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1787: // Incoming jump from 0x177D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @178E memory[0x40:0x60] // @178F returndata.length // } 1787 5B JUMPDEST 1788 50 POP 1789 50 POP 178A 50 POP 178B 50 POP 178C 60 PUSH1 0x40 178E 51 MLOAD 178F 3D RETURNDATASIZE 1790 60 PUSH1 0x1f 1792 19 NOT 1793 60 PUSH1 0x1f 1795 82 DUP3 1796 01 ADD 1797 16 AND 1798 82 DUP3 1799 01 ADD 179A 80 DUP1 179B 60 PUSH1 0x40 179D 52 MSTORE 179E 50 POP 179F 81 DUP2 17A0 01 ADD 17A1 90 SWAP1 17A2 61 PUSH2 0x17ab 17A5 91 SWAP2 17A6 90 SWAP1 17A7 61 PUSH2 0x39eb 17AA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @179D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @17A5 stack[-4] = 0x17ab // @17A6 stack[-2] = memory[0x40:0x60] // @17A6 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x39eb, returns to 0x17AB label_17AB: // Incoming return from call to 0x39EB at 0x17AA // Inputs[3] // { // @17B0 stack[-2] // @17B2 stack[-4] // @17BA memory[0x20 * 0x00 + stack[-4]:0x20 * 0x00 + stack[-4] + 0x20] // } 17AB 5B JUMPDEST 17AC 50 POP 17AD 61 PUSH2 0x17d5 17B0 90 SWAP1 17B1 50 POP 17B2 82 DUP3 17B3 60 PUSH1 0x00 17B5 5B JUMPDEST 17B6 60 PUSH1 0x20 17B8 02 MUL 17B9 01 ADD 17BA 51 MLOAD 17BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D0 16 AND 17D1 61 PUSH2 0x285b 17D4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17B0 stack[-2] = 0x17d5 // @17D0 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 * 0x00 + stack[-4]:0x20 * 0x00 + stack[-4] + 0x20] // } // Block ends with call to 0x285b, returns to 0x17D5 label_17D5: // Incoming return from call to 0x285B at 0x17D4 // Inputs[1] { @17D6 stack[-1] } 17D5 5B JUMPDEST 17D6 15 ISZERO 17D7 61 PUSH2 0x18d1 17DA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18d1, if !stack[-1] label_17DB: // Incoming jump from 0x17DA, if not !stack[-1] // Inputs[2] // { // @17DD memory[0x40:0x60] // @1829 address(this) // } 17DB 60 PUSH1 0x40 17DD 51 MLOAD 17DE 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 17FF 81 DUP2 1800 52 MSTORE 1801 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1816 90 SWAP1 1817 63 PUSH4 0x2e1a7d4d 181C 90 SWAP1 181D 82 DUP3 181E 90 SWAP1 181F 63 PUSH4 0x70a08231 1824 90 SWAP1 1825 61 PUSH2 0x1832 1828 90 SWAP1 1829 30 ADDRESS 182A 90 SWAP1 182B 60 PUSH1 0x04 182D 01 ADD 182E 61 PUSH2 0x3cc8 1831 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1800 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1816 stack[0] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @181C stack[1] = 0x2e1a7d4d // @181E stack[2] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1824 stack[3] = 0x70a08231 // @1828 stack[4] = 0x1832 // @182A stack[5] = address(this) // @182D stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3cc8, returns to 0x1832 label_1832: // Incoming return from call to 0x3CC8 at 0x1831 // Inputs[4] // { // @1837 memory[0x40:0x60] // @1839 stack[-1] // @183C stack[-3] // @183E address(stack[-3]).code.length // } 1832 5B JUMPDEST 1833 60 PUSH1 0x20 1835 60 PUSH1 0x40 1837 51 MLOAD 1838 80 DUP1 1839 83 DUP4 183A 03 SUB 183B 81 DUP2 183C 86 DUP7 183D 80 DUP1 183E 3B EXTCODESIZE 183F 15 ISZERO 1840 80 DUP1 1841 15 ISZERO 1842 61 PUSH2 0x184a 1845 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1833 stack[0] = 0x20 // @1837 stack[1] = memory[0x40:0x60] // @183A stack[2] = stack[-1] - memory[0x40:0x60] // @183B stack[3] = memory[0x40:0x60] // @183C stack[4] = stack[-3] // @183F stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x184a, if !!address(stack[-3]).code.length label_1846: // Incoming jump from 0x1845, if not !!address(stack[-3]).code.length // Inputs[1] { @1849 memory[0x00:0x00] } 1846 60 PUSH1 0x00 1848 80 DUP1 1849 FD *REVERT // Stack delta = +0 // Outputs[1] { @1849 revert(memory[0x00:0x00]); } // Block terminates label_184A: // Incoming jump from 0x1845, if !!address(stack[-3]).code.length // Inputs[8] // { // @184C msg.gas // @184D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @184D stack[-6] // @184D memory[stack[-3]:stack[-3] + stack[-4]] // @184D stack[-5] // @184D stack[-2] // @184D stack[-3] // @184D stack[-4] // } 184A 5B JUMPDEST 184B 50 POP 184C 5A GAS 184D FA STATICCALL 184E 15 ISZERO 184F 80 DUP1 1850 15 ISZERO 1851 61 PUSH2 0x185e 1854 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @184D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @184E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x185e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1855: // Incoming jump from 0x1854, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1855 returndata.length // @1859 returndata[0x00:0x00 + returndata.length] // @185A returndata.length // @185D memory[0x00:0x00 + returndata.length] // } 1855 3D RETURNDATASIZE 1856 60 PUSH1 0x00 1858 80 DUP1 1859 3E RETURNDATACOPY 185A 3D RETURNDATASIZE 185B 60 PUSH1 0x00 185D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1859 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @185D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_185E: // Incoming jump from 0x1854, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1865 memory[0x40:0x60] // @1866 returndata.length // } 185E 5B JUMPDEST 185F 50 POP 1860 50 POP 1861 50 POP 1862 50 POP 1863 60 PUSH1 0x40 1865 51 MLOAD 1866 3D RETURNDATASIZE 1867 60 PUSH1 0x1f 1869 19 NOT 186A 60 PUSH1 0x1f 186C 82 DUP3 186D 01 ADD 186E 16 AND 186F 82 DUP3 1870 01 ADD 1871 80 DUP1 1872 60 PUSH1 0x40 1874 52 MSTORE 1875 50 POP 1876 81 DUP2 1877 01 ADD 1878 90 SWAP1 1879 61 PUSH2 0x1882 187C 91 SWAP2 187D 90 SWAP1 187E 61 PUSH2 0x38dc 1881 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1874 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @187C stack[-4] = 0x1882 // @187D stack[-2] = memory[0x40:0x60] // @187D stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x1882 label_1882: // Incoming return from call to 0x38DC at 0x1881 // Inputs[3] // { // @1885 memory[0x40:0x60] // @1886 stack[-2] // @1898 stack[-1] // } 1882 5B JUMPDEST 1883 60 PUSH1 0x40 1885 51 MLOAD 1886 82 DUP3 1887 63 PUSH4 0xffffffff 188C 16 AND 188D 60 PUSH1 0xe0 188F 1B SHL 1890 81 DUP2 1891 52 MSTORE 1892 60 PUSH1 0x04 1894 01 ADD 1895 61 PUSH2 0x189e 1898 91 SWAP2 1899 90 SWAP1 189A 61 PUSH2 0x3cbf 189D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1891 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @1898 stack[-1] = 0x189e // @1899 stack[1] = 0x04 + memory[0x40:0x60] // @1899 stack[0] = stack[-1] // } // Block ends with call to 0x3cbf, returns to 0x189E label_189E: // Incoming return from call to 0x3CBF at 0x189D // Inputs[4] // { // @18A3 memory[0x40:0x60] // @18A5 stack[-1] // @18AA stack[-3] // @18AC address(stack[-3]).code.length // } 189E 5B JUMPDEST 189F 60 PUSH1 0x00 18A1 60 PUSH1 0x40 18A3 51 MLOAD 18A4 80 DUP1 18A5 83 DUP4 18A6 03 SUB 18A7 81 DUP2 18A8 60 PUSH1 0x00 18AA 87 DUP8 18AB 80 DUP1 18AC 3B EXTCODESIZE 18AD 15 ISZERO 18AE 80 DUP1 18AF 15 ISZERO 18B0 61 PUSH2 0x18b8 18B3 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @189F stack[0] = 0x00 // @18A3 stack[1] = memory[0x40:0x60] // @18A6 stack[2] = stack[-1] - memory[0x40:0x60] // @18A7 stack[3] = memory[0x40:0x60] // @18A8 stack[4] = 0x00 // @18AA stack[5] = stack[-3] // @18AD stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x18b8, if !!address(stack[-3]).code.length label_18B4: // Incoming jump from 0x18B3, if not !!address(stack[-3]).code.length // Inputs[1] { @18B7 memory[0x00:0x00] } 18B4 60 PUSH1 0x00 18B6 80 DUP1 18B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @18B7 revert(memory[0x00:0x00]); } // Block terminates label_18B8: // Incoming jump from 0x18B3, if !!address(stack[-3]).code.length // Inputs[9] // { // @18BA msg.gas // @18BB address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @18BB stack[-7] // @18BB stack[-4] // @18BB stack[-2] // @18BB stack[-3] // @18BB stack[-6] // @18BB stack[-5] // @18BB memory[stack[-4]:stack[-4] + stack[-5]] // } 18B8 5B JUMPDEST 18B9 50 POP 18BA 5A GAS 18BB F1 CALL 18BC 15 ISZERO 18BD 80 DUP1 18BE 15 ISZERO 18BF 61 PUSH2 0x18cc 18C2 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @18BB memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @18BC stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x18cc, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_18C3: // Incoming jump from 0x18C2, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @18C3 returndata.length // @18C7 returndata[0x00:0x00 + returndata.length] // @18C8 returndata.length // @18CB memory[0x00:0x00 + returndata.length] // } 18C3 3D RETURNDATASIZE 18C4 60 PUSH1 0x00 18C6 80 DUP1 18C7 3E RETURNDATACOPY 18C8 3D RETURNDATASIZE 18C9 60 PUSH1 0x00 18CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18C7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @18CB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_18CC: // Incoming jump from 0x18C2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 18CC 5B JUMPDEST 18CD 50 POP 18CE 50 POP 18CF 50 POP 18D0 50 POP // Stack delta = -4 // Block continues label_18D1: // Incoming jump from 0x17DA, if !stack[-1] // Incoming jump from 0x18D0 // Inputs[3] // { // @18D5 stack[-3] // @18D6 stack[-2] // @18D7 stack[-1] // } 18D1 5B JUMPDEST 18D2 61 PUSH2 0x0a5d 18D5 83 DUP4 18D6 83 DUP4 18D7 83 DUP4 18D8 61 PUSH2 0x1c94 18DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18D2 stack[0] = 0x0a5d // @18D5 stack[1] = stack[-3] // @18D6 stack[2] = stack[-2] // @18D7 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1c94 label_18DC: // Incoming jump from 0x0457 // Inputs[5] // { // @18E3 stack[-5] // @18E4 stack[-4] // @18E5 stack[-3] // @18E6 stack[-2] // @18E7 stack[-1] // } 18DC 5B JUMPDEST 18DD 60 PUSH1 0x00 18DF 80 DUP1 18E0 61 PUSH2 0x18ec 18E3 87 DUP8 18E4 87 DUP8 18E5 87 DUP8 18E6 87 DUP8 18E7 87 DUP8 18E8 61 PUSH2 0x2541 18EB 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @18DD stack[0] = 0x00 // @18DF stack[1] = 0x00 // @18E0 stack[2] = 0x18ec // @18E3 stack[3] = stack[-5] // @18E4 stack[4] = stack[-4] // @18E5 stack[5] = stack[-3] // @18E6 stack[6] = stack[-2] // @18E7 stack[7] = stack[-1] // } // Block ends with call to 0x2541, returns to 0x18EC label_18EC: // Incoming return from call to 0x2541 at 0x18EB // Inputs[7] // { // @18EF memory[0x40:0x60] // @1913 stack[-2] // @1914 stack[-4] // @1916 stack[-1] // @1916 stack[-3] // @192D stack[-9] // @193E stack[-6] // } 18EC 5B JUMPDEST 18ED 60 PUSH1 0x40 18EF 51 MLOAD 18F0 7F PUSH32 0x6d9a640a00000000000000000000000000000000000000000000000000000000 1911 81 DUP2 1912 52 MSTORE 1913 91 SWAP2 1914 93 SWAP4 1915 50 POP 1916 91 SWAP2 1917 50 POP 1918 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 192D 88 DUP9 192E 16 AND 192F 90 SWAP1 1930 63 PUSH4 0x6d9a640a 1935 90 SWAP1 1936 61 PUSH2 0x1143 1939 90 SWAP1 193A 85 DUP6 193B 90 SWAP1 193C 85 DUP6 193D 90 SWAP1 193E 89 DUP10 193F 90 SWAP1 1940 60 PUSH1 0x04 1942 01 ADD 1943 61 PUSH2 0x42ae 1946 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @1912 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6d9a640a00000000000000000000000000000000000000000000000000000000 // @1914 stack[-4] = stack[-2] // @1916 stack[-3] = stack[-1] // @192F stack[-2] = stack[-9] & 0xffffffffffffffffffffffffffffffffffffffff // @1935 stack[-1] = 0x6d9a640a // @1939 stack[0] = 0x1143 // @193B stack[1] = stack[-2] // @193D stack[2] = stack[-1] // @193F stack[3] = stack[-6] // @1942 stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x42ae, returns to 0x1143 label_1947: // Incoming jump from 0x0477 // Inputs[3] // { // @1960 stack[-3] // @1962 stack[-2] // @1963 stack[-1] // } 1947 5B JUMPDEST 1948 61 PUSH2 0x1703 194B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1960 84 DUP5 1961 16 AND 1962 83 DUP4 1963 83 DUP4 1964 61 PUSH2 0x28b1 1967 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1948 stack[0] = 0x1703 // @1961 stack[1] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1962 stack[2] = stack[-2] // @1963 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x28b1 label_1968: // Incoming jump from 0x0497 // Inputs[3] // { // @1982 stack[-2] // @19A4 stack[-3] // @19A6 msg.sender // } 1968 5B JUMPDEST 1969 60 PUSH1 0x00 196B 61 PUSH2 0x0d72 196E 61 PUSH2 0x19ab 1971 6F PUSH16 0xffffffffffffffffffffffffffffffff 1982 85 DUP6 1983 16 AND 1984 61 PUSH2 0x0500 1987 60 PUSH1 0x80 1989 87 DUP8 198A 90 SWAP1 198B 1C SHR 198C 61 PUSH2 0x0b13 198F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A4 8A DUP11 19A5 16 AND 19A6 33 CALLER 19A7 61 PUSH2 0x21cf 19AA 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @1969 stack[0] = 0x00 // @196B stack[1] = 0x0d72 // @196E stack[2] = 0x19ab // @1983 stack[3] = stack[-2] & 0xffffffffffffffffffffffffffffffff // @1984 stack[4] = 0x0500 // @198B stack[5] = stack[-2] >> 0x80 // @198C stack[6] = 0x0b13 // @19A5 stack[7] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @19A6 stack[8] = msg.sender // } // Block ends with call to 0x21cf, returns to 0x0B13 label_19AB: // Incoming return from call to 0x0500 at 0x19AA // Inputs[1] { @19AC stack[-4] } 19AB 5B JUMPDEST 19AC 83 DUP4 19AD 61 PUSH2 0x21b9 19B0 56 *JUMP // Stack delta = +1 // Outputs[1] { @19AC stack[0] = stack[-4] } // Block ends with unconditional jump to 0x21b9 label_19B1: // Incoming jump from 0x06ED // Incoming jump from 0x250C // Incoming jump from 0x0702 // Incoming jump from 0x0ADB // Incoming jump from 0x04B7 // Inputs[4] // { // @19B2 stack[-1] // @19B6 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @19B7 address(this).balance // @19B7 address(this) // } 19B1 5B JUMPDEST 19B2 80 DUP1 19B3 60 PUSH1 0x40 19B5 01 ADD 19B6 51 MLOAD 19B7 47 SELFBALANCE 19B8 10 LT 19B9 15 ISZERO 19BA 61 PUSH2 0x19ef 19BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19ef, if !(address(this).balance < memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) label_19BE: // Incoming jump from 0x19BD, if not !(address(this).balance < memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) // Inputs[1] { @19C0 memory[0x40:0x60] } 19BE 60 PUSH1 0x40 19C0 51 MLOAD 19C1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 19E2 81 DUP2 19E3 52 MSTORE 19E4 60 PUSH1 0x04 19E6 01 ADD 19E7 61 PUSH2 0x01c3 19EA 90 SWAP1 19EB 61 PUSH2 0x3f02 19EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @19EA stack[0] = 0x01c3 // @19EA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3f02, returns to 0x01C3 label_19EF: // Incoming jump from 0x19BD, if !(address(this).balance < memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20]) // Inputs[2] // { // @19F0 stack[-1] // @19F1 memory[stack[-1]:stack[-1] + 0x20] // } 19EF 5B JUMPDEST 19F0 80 DUP1 19F1 51 MLOAD 19F2 60 PUSH1 0x00 19F4 90 SWAP1 19F5 60 PUSH1 0x60 19F7 90 SWAP1 19F8 82 DUP3 19F9 90 SWAP1 19FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A0F 16 AND 1A10 15 ISZERO 1A11 61 PUSH2 0x1a1b 1A14 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @19F4 stack[0] = 0x00 // @19F7 stack[1] = 0x60 // @19F9 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1a1b, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-1]:stack[-1] + 0x20]) label_1A15: // Incoming jump from 0x1A14, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @1A15 stack[-4] // @1A16 memory[stack[-4]:stack[-4] + 0x20] // } 1A15 83 DUP4 1A16 51 MLOAD 1A17 61 PUSH2 0x1a1d 1A1A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A16 stack[0] = memory[stack[-4]:stack[-4] + 0x20] } // Block ends with unconditional jump to 0x1a1d label_1A1B: // Incoming jump from 0x1A14, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1A1C address(this) // @1A1E stack[-1] // @1A20 stack[-4] // @1A24 memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } 1A1B 5B JUMPDEST 1A1C 30 ADDRESS 1A1D 5B JUMPDEST 1A1E 90 SWAP1 1A1F 50 POP 1A20 83 DUP4 1A21 60 PUSH1 0x20 1A23 01 ADD 1A24 51 MLOAD 1A25 60 PUSH1 0x00 1A27 14 EQ 1A28 15 ISZERO 1A29 61 PUSH2 0x1aa7 1A2C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A1E stack[-1] = address(this) } // Block ends with conditional jump to 0x1aa7, if !(0x00 == memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20]) label_1A2D: // Incoming jump from 0x1A2C, if not !(0x00 == memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20]) // Incoming jump from 0x1A2C, if not !(0x00 == memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20]) // Inputs[5] // { // @1A2D stack[-1] // @1A44 stack[-4] // @1A48 memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @1A4D memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @1A50 memory[0x40:0x60] // } 1A2D 80 DUP1 1A2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A43 16 AND 1A44 84 DUP5 1A45 60 PUSH1 0x40 1A47 01 ADD 1A48 51 MLOAD 1A49 85 DUP6 1A4A 60 PUSH1 0x60 1A4C 01 ADD 1A4D 51 MLOAD 1A4E 60 PUSH1 0x40 1A50 51 MLOAD 1A51 61 PUSH2 0x1a5a 1A54 91 SWAP2 1A55 90 SWAP1 1A56 61 PUSH2 0x3b53 1A59 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1A43 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1A48 stack[1] = memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @1A54 stack[2] = 0x1a5a // @1A55 stack[3] = memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @1A55 stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x3b53 1A5A 5B JUMPDEST 1A5B 60 PUSH1 0x00 1A5D 60 PUSH1 0x40 1A5F 51 MLOAD 1A60 80 DUP1 1A61 83 DUP4 1A62 03 SUB 1A63 81 DUP2 1A64 85 DUP6 1A65 87 DUP8 1A66 5A GAS 1A67 F1 CALL 1A68 92 SWAP3 1A69 50 POP 1A6A 50 POP 1A6B 50 POP 1A6C 3D RETURNDATASIZE 1A6D 80 DUP1 1A6E 60 PUSH1 0x00 1A70 81 DUP2 1A71 14 EQ 1A72 61 PUSH2 0x1a97 1A75 57 *JUMPI 1A76 60 PUSH1 0x40 1A78 51 MLOAD 1A79 91 SWAP2 1A7A 50 POP 1A7B 60 PUSH1 0x1f 1A7D 19 NOT 1A7E 60 PUSH1 0x3f 1A80 3D RETURNDATASIZE 1A81 01 ADD 1A82 16 AND 1A83 82 DUP3 1A84 01 ADD 1A85 60 PUSH1 0x40 1A87 52 MSTORE 1A88 3D RETURNDATASIZE 1A89 82 DUP3 1A8A 52 MSTORE 1A8B 3D RETURNDATASIZE 1A8C 60 PUSH1 0x00 1A8E 60 PUSH1 0x20 1A90 84 DUP5 1A91 01 ADD 1A92 3E RETURNDATACOPY 1A93 61 PUSH2 0x1a9c 1A96 56 *JUMP 1A97 5B JUMPDEST 1A98 60 PUSH1 0x60 1A9A 91 SWAP2 1A9B 50 POP 1A9C 5B JUMPDEST 1A9D 50 POP 1A9E 90 SWAP1 1A9F 93 SWAP4 1AA0 50 POP 1AA1 91 SWAP2 1AA2 50 POP 1AA3 61 PUSH2 0x1b25 1AA6 56 *JUMP label_1AA7: // Incoming jump from 0x1A2C, if !(0x00 == memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20]) // Incoming jump from 0x1A2C, if !(0x00 == memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20]) // Inputs[6] // { // @1AA8 stack[-1] // @1ABF stack[-4] // @1AC3 memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @1AC8 memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1ACE memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @1AD1 memory[0x40:0x60] // } 1AA7 5B JUMPDEST 1AA8 80 DUP1 1AA9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ABE 16 AND 1ABF 84 DUP5 1AC0 60 PUSH1 0x40 1AC2 01 ADD 1AC3 51 MLOAD 1AC4 85 DUP6 1AC5 60 PUSH1 0x20 1AC7 01 ADD 1AC8 51 MLOAD 1AC9 90 SWAP1 1ACA 86 DUP7 1ACB 60 PUSH1 0x60 1ACD 01 ADD 1ACE 51 MLOAD 1ACF 60 PUSH1 0x40 1AD1 51 MLOAD 1AD2 61 PUSH2 0x1adb 1AD5 91 SWAP2 1AD6 90 SWAP1 1AD7 61 PUSH2 0x3b53 1ADA 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1ABE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1AC9 stack[1] = memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1AC9 stack[2] = memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @1AD5 stack[3] = 0x1adb // @1AD6 stack[4] = memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @1AD6 stack[5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x3b53 1ADB 5B JUMPDEST 1ADC 60 PUSH1 0x00 1ADE 60 PUSH1 0x40 1AE0 51 MLOAD 1AE1 80 DUP1 1AE2 83 DUP4 1AE3 03 SUB 1AE4 81 DUP2 1AE5 85 DUP6 1AE6 88 DUP9 1AE7 88 DUP9 1AE8 F1 CALL 1AE9 93 SWAP4 1AEA 50 POP 1AEB 50 POP 1AEC 50 POP 1AED 50 POP 1AEE 3D RETURNDATASIZE 1AEF 80 DUP1 1AF0 60 PUSH1 0x00 1AF2 81 DUP2 1AF3 14 EQ 1AF4 61 PUSH2 0x1b19 1AF7 57 *JUMPI 1AF8 60 PUSH1 0x40 1AFA 51 MLOAD 1AFB 91 SWAP2 1AFC 50 POP 1AFD 60 PUSH1 0x1f 1AFF 19 NOT 1B00 60 PUSH1 0x3f 1B02 3D RETURNDATASIZE 1B03 01 ADD 1B04 16 AND 1B05 82 DUP3 1B06 01 ADD 1B07 60 PUSH1 0x40 1B09 52 MSTORE 1B0A 3D RETURNDATASIZE 1B0B 82 DUP3 1B0C 52 MSTORE 1B0D 3D RETURNDATASIZE 1B0E 60 PUSH1 0x00 1B10 60 PUSH1 0x20 1B12 84 DUP5 1B13 01 ADD 1B14 3E RETURNDATACOPY 1B15 61 PUSH2 0x1b1e 1B18 56 *JUMP 1B19 5B JUMPDEST 1B1A 60 PUSH1 0x60 1B1C 91 SWAP2 1B1D 50 POP 1B1E 5B JUMPDEST 1B1F 50 POP 1B20 90 SWAP1 1B21 93 SWAP4 1B22 50 POP 1B23 91 SWAP2 1B24 50 POP 1B25 5B JUMPDEST 1B26 82 DUP3 1B27 61 PUSH2 0x0a5d 1B2A 57 *JUMPI 1B2B 60 PUSH1 0x60 1B2D 61 PUSH2 0x1b6b 1B30 83 DUP4 1B31 60 PUSH1 0x40 1B33 51 MLOAD 1B34 80 DUP1 1B35 60 PUSH1 0x40 1B37 01 ADD 1B38 60 PUSH1 0x40 1B3A 52 MSTORE 1B3B 80 DUP1 1B3C 60 PUSH1 0x16 1B3E 81 DUP2 1B3F 52 MSTORE 1B40 60 PUSH1 0x20 1B42 01 ADD 1B43 7F PUSH32 0x45787465726e616c2063616c6c206661696c65643a2000000000000000000000 1B64 81 DUP2 1B65 52 MSTORE 1B66 50 POP 1B67 61 PUSH2 0x1de7 1B6A 56 *JUMP 1B6B 5B JUMPDEST 1B6C 90 SWAP1 1B6D 50 POP 1B6E 60 PUSH1 0xff 1B70 85 DUP6 1B71 60 PUSH1 0x00 1B73 01 ADD 1B74 51 MLOAD 1B75 90 SWAP1 1B76 1C SHR 1B77 60 PUSH1 0x01 1B79 14 EQ 1B7A 15 ISZERO 1B7B 61 PUSH2 0x0a24 1B7E 57 *JUMPI 1B7F 80 DUP1 1B80 60 PUSH1 0x40 1B82 51 MLOAD 1B83 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BA4 81 DUP2 1BA5 52 MSTORE 1BA6 60 PUSH1 0x04 1BA8 01 ADD 1BA9 61 PUSH2 0x01c3 1BAC 91 SWAP2 1BAD 90 SWAP1 1BAE 61 PUSH2 0x3e7a 1BB1 56 *JUMP label_1BB2: // Incoming call from 0x285A, returns to 0x0500 // Incoming call from 0x2686, returns to 0x16CE // Incoming call from 0x04FF, returns to 0x0500 // Incoming call from 0x2672, returns to 0x2673 // Incoming jump from 0x0B18 // Incoming call from 0x2664, returns to 0x2665 // Inputs[1] { @1BB5 stack[-2] } 1BB2 5B JUMPDEST 1BB3 60 PUSH1 0x00 1BB5 82 DUP3 1BB6 61 PUSH2 0x1bc1 1BB9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BB3 stack[0] = 0x00 } // Block ends with conditional jump to 0x1bc1, if stack[-2] label_1BBA: // Incoming jump from 0x1BB9, if not stack[-2] 1BBA 50 POP 1BBB 60 PUSH1 0x00 1BBD 61 PUSH2 0x0b1c 1BC0 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BBB stack[-1] = 0x00 } // Block ends with unconditional jump to 0x0b1c label_1BC1: // Incoming jump from 0x1BB9, if stack[-2] // Inputs[2] // { // @1BC2 stack[-3] // @1BC3 stack[-2] // } 1BC1 5B JUMPDEST 1BC2 82 DUP3 1BC3 82 DUP3 1BC4 02 MUL 1BC5 82 DUP3 1BC6 84 DUP5 1BC7 82 DUP3 1BC8 81 DUP2 1BC9 61 PUSH2 0x1bce 1BCC 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1BC4 stack[0] = stack[-2] * stack[-3] // @1BC5 stack[1] = stack[-2] // @1BC6 stack[2] = stack[-3] // @1BC7 stack[3] = stack[-2] * stack[-3] // } // Block ends with conditional jump to 0x1bce, if stack[-3] label_1BCD: // Incoming jump from 0x1BCC, if not stack[-3] 1BCD FE *ASSERT // Stack delta = +0 // Outputs[1] { @1BCD assert(); } // Block terminates label_1BCE: // Incoming jump from 0x1BCC, if stack[-3] // Inputs[3] // { // @1BCF stack[-2] // @1BCF stack[-1] // @1BD0 stack[-3] // } 1BCE 5B JUMPDEST 1BCF 04 DIV 1BD0 14 EQ 1BD1 61 PUSH2 0x0b19 1BD4 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0b19, if stack[-1] / stack[-2] == stack[-3] label_1BD5: // Incoming jump from 0x1BD4, if not stack[-1] / stack[-2] == stack[-3] // Inputs[1] { @1BD7 memory[0x40:0x60] } 1BD5 60 PUSH1 0x40 1BD7 51 MLOAD 1BD8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BF9 81 DUP2 1BFA 52 MSTORE 1BFB 60 PUSH1 0x04 1BFD 01 ADD 1BFE 61 PUSH2 0x01c3 1C01 90 SWAP1 1C02 61 PUSH2 0x40ba 1C05 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1BFA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C01 stack[0] = 0x01c3 // @1C01 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x40ba, returns to 0x01C3 label_1C06: // Incoming call from 0x2694, returns to 0x2695 // Incoming jump from 0x0505 // Inputs[1] { @1C0A stack[-1] } 1C06 5B JUMPDEST 1C07 60 PUSH1 0x00 1C09 80 DUP1 1C0A 82 DUP3 1C0B 11 GT 1C0C 61 PUSH2 0x1c41 1C0F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C07 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c41, if stack[-1] > 0x00 label_1C10: // Incoming jump from 0x1C0F, if not stack[-1] > 0x00 // Inputs[1] { @1C12 memory[0x40:0x60] } 1C10 60 PUSH1 0x40 1C12 51 MLOAD 1C13 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C34 81 DUP2 1C35 52 MSTORE 1C36 60 PUSH1 0x04 1C38 01 ADD 1C39 61 PUSH2 0x01c3 1C3C 90 SWAP1 1C3D 61 PUSH2 0x3fde 1C40 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C35 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C3C stack[0] = 0x01c3 // @1C3C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3fde, returns to 0x01C3 label_1C41: // Incoming jump from 0x1C0F, if stack[-1] > 0x00 // Inputs[2] // { // @1C42 stack[-2] // @1C43 stack[-3] // } 1C41 5B JUMPDEST 1C42 81 DUP2 1C43 83 DUP4 1C44 81 DUP2 1C45 61 PUSH2 0x1c4a 1C48 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C42 stack[0] = stack[-2] // @1C43 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1c4a, if stack[-2] label_1C49: // Incoming jump from 0x1C48, if not stack[-2] 1C49 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C49 assert(); } // Block terminates label_1C4A: // Incoming jump from 0x1C48, if stack[-2] // Inputs[4] // { // @1C4B stack[-2] // @1C4B stack[-1] // @1C4C stack[-6] // @1C4D stack[-5] // } 1C4A 5B JUMPDEST 1C4B 04 DIV 1C4C 93 SWAP4 1C4D 92 SWAP3 1C4E 50 POP 1C4F 50 POP 1C50 50 POP 1C51 56 *JUMP // Stack delta = -5 // Outputs[1] { @1C4C stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-6] label_1C52: // Incoming call from 0x15A5, returns to 0x15A6 // Incoming jump from 0x0B7B // Incoming call from 0x157B, returns to 0x157C // Incoming call from 0x264E, returns to 0x264F // Incoming call from 0x155C, returns to 0x155D // Incoming call from 0x0513, returns to 0x0514 // Incoming call from 0x264E, returns to 0x264F // Incoming call from 0x0B12, returns to 0x0B13 // Inputs[2] // { // @1C55 stack[-2] // @1C56 stack[-1] // } 1C52 5B JUMPDEST 1C53 60 PUSH1 0x00 1C55 82 DUP3 1C56 82 DUP3 1C57 11 GT 1C58 15 ISZERO 1C59 61 PUSH2 0x1c8e 1C5C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C53 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c8e, if !(stack[-1] > stack[-2]) label_1C5D: // Incoming jump from 0x1C5C, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1C5F memory[0x40:0x60] } 1C5D 60 PUSH1 0x40 1C5F 51 MLOAD 1C60 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C81 81 DUP2 1C82 52 MSTORE 1C83 60 PUSH1 0x04 1C85 01 ADD 1C86 61 PUSH2 0x01c3 1C89 90 SWAP1 1C8A 61 PUSH2 0x3fa7 1C8D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C89 stack[0] = 0x01c3 // @1C89 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3fa7, returns to 0x01C3 label_1C8E: // Incoming jump from 0x1C5C, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @1C90 stack[-3] // @1C90 stack[-2] // @1C92 stack[-4] // } 1C8E 5B JUMPDEST 1C8F 50 POP 1C90 90 SWAP1 1C91 03 SUB 1C92 90 SWAP1 1C93 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C92 stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_1C94: // Incoming jump from 0x18DB // Incoming jump from 0x081C 1C94 5B JUMPDEST 1C95 60 PUSH1 0x00 1C97 61 PUSH2 0x1c9e 1C9A 61 PUSH2 0x3085 1C9D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C95 stack[0] = 0x00 // @1C97 stack[1] = 0x1c9e // } // Block ends with call to 0x3085, returns to 0x1C9E label_1C9E: // Incoming return from call to 0x3085 at 0x1C9D 1C9E 5B JUMPDEST 1C9F 61 PUSH2 0x1ca6 1CA2 61 PUSH2 0x3085 1CA5 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C9F stack[0] = 0x1ca6 } // Block ends with call to 0x3085, returns to 0x1CA6 label_1CA6: // Incoming return from call to 0x3085 at 0x1CA5 // Inputs[3] // { // @1CAA address(this) // @1CAB stack[-5] // @1CB3 memory[0x20 * 0x00 + stack[-5]:0x20 * 0x00 + stack[-5] + 0x20] // } 1CA6 5B JUMPDEST 1CA7 61 PUSH2 0x1ccf 1CAA 30 ADDRESS 1CAB 86 DUP7 1CAC 60 PUSH1 0x00 1CAE 5B JUMPDEST 1CAF 60 PUSH1 0x20 1CB1 02 MUL 1CB2 01 ADD 1CB3 51 MLOAD 1CB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CC9 16 AND 1CCA 90 SWAP1 1CCB 61 PUSH2 0x21cf 1CCE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CA7 stack[0] = 0x1ccf // @1CCA stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 * 0x00 + stack[-5]:0x20 * 0x00 + stack[-5] + 0x20] // @1CCA stack[2] = address(this) // } // Block ends with call to 0x21cf, returns to 0x1CCF label_1CCF: // Incoming return from call to 0x21CF at 0x1CCE // Inputs[4] // { // @1CD0 stack[-2] // @1CD1 stack[-1] // @1CD5 address(this) // @1CD6 stack[-6] // } 1CCF 5B JUMPDEST 1CD0 81 DUP2 1CD1 52 MSTORE 1CD2 61 PUSH2 0x1cdd 1CD5 30 ADDRESS 1CD6 86 DUP7 1CD7 60 PUSH1 0x01 1CD9 61 PUSH2 0x1cae 1CDC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1CD1 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1CD2 stack[-1] = 0x1cdd // @1CD5 stack[0] = address(this) // @1CD6 stack[1] = stack[-6] // @1CD7 stack[2] = 0x01 // } // Block ends with call to 0x1cae, returns to 0x1CDD label_1CDD: // Incoming return from call to 0x1CAE at 0x1CDC // Inputs[3] // { // @1CE0 stack[-2] // @1CE2 stack[-1] // @1CE6 stack[-6] // } 1CDD 5B JUMPDEST 1CDE 60 PUSH1 0x20 1CE0 82 DUP3 1CE1 01 ADD 1CE2 52 MSTORE 1CE3 61 PUSH2 0x1ced 1CE6 85 DUP6 1CE7 60 PUSH1 0x00 1CE9 61 PUSH2 0x17b5 1CEC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1CE2 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @1CE3 stack[-1] = 0x1ced // @1CE6 stack[0] = stack[-6] // @1CE7 stack[1] = 0x00 // } // Block ends with call to 0x17b5, returns to 0x1CED label_1CED: // Incoming return from call to 0x17B5 at 0x1CEC // Inputs[1] { @1CEE stack[-1] } 1CED 5B JUMPDEST 1CEE 15 ISZERO 1CEF 61 PUSH2 0x1cfb 1CF2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1cfb, if !stack[-1] label_1CF3: // Incoming jump from 0x1CF2, if not !stack[-1] // Inputs[3] // { // @1CF3 stack[-1] // @1CF4 memory[stack[-1]:stack[-1] + 0x20] // @1CF5 stack[-3] // } 1CF3 80 DUP1 1CF4 51 MLOAD 1CF5 92 SWAP3 1CF6 50 POP 1CF7 61 PUSH2 0x1d29 1CFA 56 *JUMP // Stack delta = +0 // Outputs[1] { @1CF5 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to 0x1d29 label_1CFB: // Incoming jump from 0x1CF2, if !stack[-1] // Inputs[5] // { // @1CFC stack[-1] // @1CFD memory[stack[-1]:stack[-1] + 0x20] // @1D02 stack[-6] // @1D04 stack[-5] // @1D0C memory[0x20 * 0x00 + stack[-5]:0x20 * 0x00 + stack[-5] + 0x20] // } 1CFB 5B JUMPDEST 1CFC 80 DUP1 1CFD 51 MLOAD 1CFE 61 PUSH2 0x1d29 1D01 90 SWAP1 1D02 87 DUP8 1D03 90 SWAP1 1D04 87 DUP8 1D05 60 PUSH1 0x00 1D07 5B JUMPDEST 1D08 60 PUSH1 0x20 1D0A 02 MUL 1D0B 01 ADD 1D0C 51 MLOAD 1D0D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D22 16 AND 1D23 91 SWAP2 1D24 90 SWAP1 1D25 61 PUSH2 0x28b1 1D28 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D01 stack[0] = 0x1d29 // @1D23 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 * 0x00 + stack[-5]:0x20 * 0x00 + stack[-5] + 0x20] // @1D24 stack[2] = stack[-6] // @1D24 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x28b1 label_1D29: // Incoming jump from 0x1CFA // Inputs[4] // { // @1D2D stack[-6] // @1D2E stack[-1] // @1D35 memory[0x20 * 0x01 + stack[-1]:0x20 * 0x01 + stack[-1] + 0x20] // @1D36 stack[-5] // } 1D29 5B JUMPDEST 1D2A 61 PUSH2 0x1d3d 1D2D 86 DUP7 1D2E 82 DUP3 1D2F 60 PUSH1 0x01 1D31 60 PUSH1 0x20 1D33 02 MUL 1D34 01 ADD 1D35 51 MLOAD 1D36 87 DUP8 1D37 60 PUSH1 0x01 1D39 61 PUSH2 0x1d07 1D3C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D2A stack[0] = 0x1d3d // @1D2D stack[1] = stack[-6] // @1D35 stack[2] = memory[0x20 * 0x01 + stack[-1]:0x20 * 0x01 + stack[-1] + 0x20] // @1D36 stack[3] = stack[-5] // @1D37 stack[4] = 0x01 // } // Block ends with unconditional jump to 0x1d07 1D3D 5B JUMPDEST 1D3E 60 PUSH1 0x40 1D40 51 MLOAD 1D41 7F PUSH32 0x9ea5ce0a00000000000000000000000000000000000000000000000000000000 1D62 81 DUP2 1D63 52 MSTORE 1D64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D79 87 DUP8 1D7A 16 AND 1D7B 90 SWAP1 1D7C 63 PUSH4 0x9ea5ce0a 1D81 90 SWAP1 1D82 85 DUP6 1D83 90 SWAP1 1D84 61 PUSH2 0x1d95 1D87 90 SWAP1 1D88 85 DUP6 1D89 90 SWAP1 1D8A 87 DUP8 1D8B 90 SWAP1 1D8C 8A DUP11 1D8D 90 SWAP1 1D8E 60 PUSH1 0x04 1D90 01 ADD 1D91 61 PUSH2 0x3e0a 1D94 56 *JUMP 1D95 5B JUMPDEST 1D96 60 PUSH1 0x60 1D98 60 PUSH1 0x40 1D9A 51 MLOAD 1D9B 80 DUP1 1D9C 83 DUP4 1D9D 03 SUB 1D9E 81 DUP2 1D9F 85 DUP6 1DA0 88 DUP9 1DA1 80 DUP1 1DA2 3B EXTCODESIZE 1DA3 15 ISZERO 1DA4 80 DUP1 1DA5 15 ISZERO 1DA6 61 PUSH2 0x1dae 1DA9 57 *JUMPI 1DAA 60 PUSH1 0x00 1DAC 80 DUP1 1DAD FD *REVERT 1DAE 5B JUMPDEST 1DAF 50 POP 1DB0 5A GAS 1DB1 F1 CALL 1DB2 15 ISZERO 1DB3 80 DUP1 1DB4 15 ISZERO 1DB5 61 PUSH2 0x1dc2 1DB8 57 *JUMPI 1DB9 3D RETURNDATASIZE 1DBA 60 PUSH1 0x00 1DBC 80 DUP1 1DBD 3E RETURNDATACOPY 1DBE 3D RETURNDATASIZE 1DBF 60 PUSH1 0x00 1DC1 FD *REVERT 1DC2 5B JUMPDEST 1DC3 50 POP 1DC4 50 POP 1DC5 50 POP 1DC6 50 POP 1DC7 50 POP 1DC8 60 PUSH1 0x40 1DCA 51 MLOAD 1DCB 3D RETURNDATASIZE 1DCC 60 PUSH1 0x1f 1DCE 19 NOT 1DCF 60 PUSH1 0x1f 1DD1 82 DUP3 1DD2 01 ADD 1DD3 16 AND 1DD4 82 DUP3 1DD5 01 ADD 1DD6 80 DUP1 1DD7 60 PUSH1 0x40 1DD9 52 MSTORE 1DDA 50 POP 1DDB 81 DUP2 1DDC 01 ADD 1DDD 90 SWAP1 1DDE 61 PUSH2 0x0d31 1DE1 91 SWAP2 1DE2 90 SWAP1 1DE3 61 PUSH2 0x38f4 1DE6 56 *JUMP label_1DE7: // Incoming call from 0x0CFA, returns to 0x0CFB // Incoming call from 0x09E0, returns to 0x09E1 // Incoming call from 0x103B, returns to 0x0E2E // Incoming call from 0x0CFA, returns to 0x0CFB // Incoming call from 0x0E2D, returns to 0x0E2E // Inputs[2] // { // @1DEC stack[-2] // @1DED memory[stack[-2]:stack[-2] + 0x20] // } 1DE7 5B JUMPDEST 1DE8 60 PUSH1 0x60 1DEA 60 PUSH1 0x44 1DEC 83 DUP4 1DED 51 MLOAD 1DEE 10 LT 1DEF 15 ISZERO 1DF0 80 DUP1 1DF1 15 ISZERO 1DF2 61 PUSH2 0x1e4e 1DF5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DE8 stack[0] = 0x60 // @1DEF stack[1] = !(memory[stack[-2]:stack[-2] + 0x20] < 0x44) // } // Block ends with conditional jump to 0x1e4e, if !!(memory[stack[-2]:stack[-2] + 0x20] < 0x44) label_1DF6: // Incoming jump from 0x1DF5, if not !!(memory[stack[-2]:stack[-2] + 0x20] < 0x44) // Inputs[2] // { // @1DF7 stack[-4] // @1DFB memory[stack[-4]:stack[-4] + 0x20] // } 1DF6 50 POP 1DF7 82 DUP3 1DF8 60 PUSH1 0x00 1DFA 81 DUP2 1DFB 51 MLOAD 1DFC 81 DUP2 1DFD 10 LT 1DFE 61 PUSH2 0x1e03 1E01 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1DF7 stack[-1] = stack[-4] // @1DF8 stack[0] = 0x00 // } // Block ends with conditional jump to 0x1e03, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1E02: // Incoming jump from 0x1E01, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 1E02 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1E02 assert(); } // Block terminates label_1E03: // Incoming jump from 0x1E01, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1E06 stack[-2] // @1E07 stack[-1] // @1E09 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1E03 5B JUMPDEST 1E04 60 PUSH1 0x20 1E06 91 SWAP2 1E07 01 ADD 1E08 01 ADD 1E09 51 MLOAD 1E0A 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 1E2B 16 AND 1E2C 7F PUSH32 0x0800000000000000000000000000000000000000000000000000000000000000 1E4D 14 EQ // Stack delta = -1 // Outputs[1] { @1E4D stack[-2] = 0x0800000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_1E4E: // Incoming jump from 0x1DF5, if !!(memory[stack[-2]:stack[-2] + 0x20] < 0x44) // Incoming jump from 0x1E4D // Inputs[1] { @1E4F stack[-1] } 1E4E 5B JUMPDEST 1E4F 80 DUP1 1E50 15 ISZERO 1E51 61 PUSH2 0x1ead 1E54 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ead, if !stack[-1] label_1E55: // Incoming jump from 0x1E54, if not !stack[-1] // Inputs[2] // { // @1E56 stack[-4] // @1E5A memory[stack[-4]:stack[-4] + 0x20] // } 1E55 50 POP 1E56 82 DUP3 1E57 60 PUSH1 0x01 1E59 81 DUP2 1E5A 51 MLOAD 1E5B 81 DUP2 1E5C 10 LT 1E5D 61 PUSH2 0x1e62 1E60 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1E56 stack[-1] = stack[-4] // @1E57 stack[0] = 0x01 // } // Block ends with conditional jump to 0x1e62, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_1E61: // Incoming jump from 0x1E60, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 1E61 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1E61 assert(); } // Block terminates label_1E62: // Incoming jump from 0x1E60, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1E65 stack[-2] // @1E66 stack[-1] // @1E68 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1E62 5B JUMPDEST 1E63 60 PUSH1 0x20 1E65 91 SWAP2 1E66 01 ADD 1E67 01 ADD 1E68 51 MLOAD 1E69 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 1E8A 16 AND 1E8B 7F PUSH32 0xc300000000000000000000000000000000000000000000000000000000000000 1EAC 14 EQ // Stack delta = -1 // Outputs[1] { @1EAC stack[-2] = 0xc300000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_1EAD: // Incoming jump from 0x1EAC // Incoming jump from 0x1E54, if !stack[-1] // Inputs[1] { @1EAE stack[-1] } 1EAD 5B JUMPDEST 1EAE 80 DUP1 1EAF 15 ISZERO 1EB0 61 PUSH2 0x1f0c 1EB3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f0c, if !stack[-1] label_1EB4: // Incoming jump from 0x1EB3, if not !stack[-1] // Inputs[2] // { // @1EB5 stack[-4] // @1EB9 memory[stack[-4]:stack[-4] + 0x20] // } 1EB4 50 POP 1EB5 82 DUP3 1EB6 60 PUSH1 0x02 1EB8 81 DUP2 1EB9 51 MLOAD 1EBA 81 DUP2 1EBB 10 LT 1EBC 61 PUSH2 0x1ec1 1EBF 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1EB5 stack[-1] = stack[-4] // @1EB6 stack[0] = 0x02 // } // Block ends with conditional jump to 0x1ec1, if 0x02 < memory[stack[-4]:stack[-4] + 0x20] label_1EC0: // Incoming jump from 0x1EBF, if not 0x02 < memory[stack[-4]:stack[-4] + 0x20] 1EC0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1EC0 assert(); } // Block terminates label_1EC1: // Incoming jump from 0x1EBF, if 0x02 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1EC4 stack[-2] // @1EC5 stack[-1] // @1EC7 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1EC1 5B JUMPDEST 1EC2 60 PUSH1 0x20 1EC4 91 SWAP2 1EC5 01 ADD 1EC6 01 ADD 1EC7 51 MLOAD 1EC8 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 1EE9 16 AND 1EEA 7F PUSH32 0x7900000000000000000000000000000000000000000000000000000000000000 1F0B 14 EQ // Stack delta = -1 // Outputs[1] { @1F0B stack[-2] = 0x7900000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_1F0C: // Incoming jump from 0x1F0B // Incoming jump from 0x1EB3, if !stack[-1] // Inputs[1] { @1F0D stack[-1] } 1F0C 5B JUMPDEST 1F0D 80 DUP1 1F0E 15 ISZERO 1F0F 61 PUSH2 0x1f6b 1F12 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f6b, if !stack[-1] label_1F13: // Incoming jump from 0x1F12, if not !stack[-1] // Inputs[2] // { // @1F14 stack[-4] // @1F18 memory[stack[-4]:stack[-4] + 0x20] // } 1F13 50 POP 1F14 82 DUP3 1F15 60 PUSH1 0x03 1F17 81 DUP2 1F18 51 MLOAD 1F19 81 DUP2 1F1A 10 LT 1F1B 61 PUSH2 0x1f20 1F1E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1F14 stack[-1] = stack[-4] // @1F15 stack[0] = 0x03 // } // Block ends with conditional jump to 0x1f20, if 0x03 < memory[stack[-4]:stack[-4] + 0x20] label_1F1F: // Incoming jump from 0x1F1E, if not 0x03 < memory[stack[-4]:stack[-4] + 0x20] 1F1F FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F1F assert(); } // Block terminates label_1F20: // Incoming jump from 0x1F1E, if 0x03 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1F23 stack[-2] // @1F24 stack[-1] // @1F26 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1F20 5B JUMPDEST 1F21 60 PUSH1 0x20 1F23 91 SWAP2 1F24 01 ADD 1F25 01 ADD 1F26 51 MLOAD 1F27 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 1F48 16 AND 1F49 7F PUSH32 0xa000000000000000000000000000000000000000000000000000000000000000 1F6A 14 EQ // Stack delta = -1 // Outputs[1] { @1F6A stack[-2] = 0xa000000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_1F6B: // Incoming jump from 0x1F12, if !stack[-1] // Incoming jump from 0x1F6A // Inputs[1] { @1F6C stack[-1] } 1F6B 5B JUMPDEST 1F6C 15 ISZERO 1F6D 61 PUSH2 0x1fe1 1F70 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1fe1, if !stack[-1] label_1F71: // Incoming jump from 0x1F70, if not !stack[-1] // Inputs[3] // { // @1F75 stack[-3] // @1F7A memory[stack[-3] + 0x44:stack[-3] + 0x44 + 0x20] // @1F7F memory[stack[-3]:stack[-3] + 0x20] // } 1F71 60 PUSH1 0x60 1F73 60 PUSH1 0x44 1F75 84 DUP5 1F76 01 ADD 1F77 90 SWAP1 1F78 50 POP 1F79 80 DUP1 1F7A 51 MLOAD 1F7B 60 PUSH1 0x44 1F7D 01 ADD 1F7E 84 DUP5 1F7F 51 MLOAD 1F80 10 LT 1F81 15 ISZERO 1F82 61 PUSH2 0x1fb7 1F85 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F77 stack[0] = stack[-3] + 0x44 } // Block ends with conditional jump to 0x1fb7, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x44 + memory[stack[-3] + 0x44:stack[-3] + 0x44 + 0x20]) label_1F86: // Incoming jump from 0x1F85, if not !(memory[stack[-3]:stack[-3] + 0x20] < 0x44 + memory[stack[-3] + 0x44:stack[-3] + 0x44 + 0x20]) // Inputs[1] { @1F88 memory[0x40:0x60] } 1F86 60 PUSH1 0x40 1F88 51 MLOAD 1F89 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1FAA 81 DUP2 1FAB 52 MSTORE 1FAC 60 PUSH1 0x04 1FAE 01 ADD 1FAF 61 PUSH2 0x01c3 1FB2 90 SWAP1 1FB3 61 PUSH2 0x41bc 1FB6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1FB2 stack[0] = 0x01c3 // @1FB2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x41bc, returns to 0x01C3 label_1FB7: // Incoming jump from 0x1F85, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x44 + memory[stack[-3] + 0x44:stack[-3] + 0x44 + 0x20]) // Inputs[3] // { // @1FB8 stack[-3] // @1FB9 stack[-1] // @1FBC memory[0x40:0x60] // } 1FB7 5B JUMPDEST 1FB8 82 DUP3 1FB9 81 DUP2 1FBA 60 PUSH1 0x40 1FBC 51 MLOAD 1FBD 60 PUSH1 0x20 1FBF 01 ADD 1FC0 61 PUSH2 0x1fca 1FC3 92 SWAP3 1FC4 91 SWAP2 1FC5 90 SWAP1 1FC6 61 PUSH2 0x3c73 1FC9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FC3 stack[0] = 0x1fca // @1FC4 stack[1] = stack[-3] // @1FC5 stack[2] = stack[-1] // @1FC5 stack[3] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3c73, returns to 0x1FCA label_1FCA: // Incoming return from call to 0x3C73 at 0x1FC9 // Inputs[3] // { // @1FCD memory[0x40:0x60] // @1FD1 stack[-1] // @1FDA stack[-3] // } 1FCA 5B JUMPDEST 1FCB 60 PUSH1 0x40 1FCD 51 MLOAD 1FCE 60 PUSH1 0x20 1FD0 81 DUP2 1FD1 83 DUP4 1FD2 03 SUB 1FD3 03 SUB 1FD4 81 DUP2 1FD5 52 MSTORE 1FD6 90 SWAP1 1FD7 60 PUSH1 0x40 1FD9 52 MSTORE 1FDA 91 SWAP2 1FDB 50 POP 1FDC 50 POP 1FDD 61 PUSH2 0x0b1c 1FE0 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1FD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1FD9 memory[0x40:0x60] = stack[-1] // @1FDA stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0b1c label_1FE1: // Incoming jump from 0x1F70, if !stack[-1] // Inputs[2] // { // @1FE2 stack[-3] // @1FE3 memory[stack[-3]:stack[-3] + 0x20] // } 1FE1 5B JUMPDEST 1FE2 82 DUP3 1FE3 51 MLOAD 1FE4 60 PUSH1 0x24 1FE6 14 EQ 1FE7 80 DUP1 1FE8 15 ISZERO 1FE9 61 PUSH2 0x2045 1FEC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FE6 stack[0] = 0x24 == memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2045, if !(0x24 == memory[stack[-3]:stack[-3] + 0x20]) label_1FED: // Incoming jump from 0x1FEC, if not !(0x24 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[2] // { // @1FEE stack[-4] // @1FF2 memory[stack[-4]:stack[-4] + 0x20] // } 1FED 50 POP 1FEE 82 DUP3 1FEF 60 PUSH1 0x00 1FF1 81 DUP2 1FF2 51 MLOAD 1FF3 81 DUP2 1FF4 10 LT 1FF5 61 PUSH2 0x1ffa 1FF8 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1FEE stack[-1] = stack[-4] // @1FEF stack[0] = 0x00 // } // Block ends with conditional jump to 0x1ffa, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1FF9: // Incoming jump from 0x1FF8, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 1FF9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1FF9 assert(); } // Block terminates label_1FFA: // Incoming jump from 0x1FF8, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1FFD stack[-2] // @1FFE stack[-1] // @2000 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1FFA 5B JUMPDEST 1FFB 60 PUSH1 0x20 1FFD 91 SWAP2 1FFE 01 ADD 1FFF 01 ADD 2000 51 MLOAD 2001 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 2022 16 AND 2023 7F PUSH32 0x4e00000000000000000000000000000000000000000000000000000000000000 2044 14 EQ // Stack delta = -1 // Outputs[1] { @2044 stack[-2] = 0x4e00000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_2045: // Incoming jump from 0x2044 // Incoming jump from 0x1FEC, if !(0x24 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @2046 stack[-1] } 2045 5B JUMPDEST 2046 80 DUP1 2047 15 ISZERO 2048 61 PUSH2 0x20a4 204B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20a4, if !stack[-1] label_204C: // Incoming jump from 0x204B, if not !stack[-1] // Inputs[2] // { // @204D stack[-4] // @2051 memory[stack[-4]:stack[-4] + 0x20] // } 204C 50 POP 204D 82 DUP3 204E 60 PUSH1 0x01 2050 81 DUP2 2051 51 MLOAD 2052 81 DUP2 2053 10 LT 2054 61 PUSH2 0x2059 2057 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @204D stack[-1] = stack[-4] // @204E stack[0] = 0x01 // } // Block ends with conditional jump to 0x2059, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_2058: // Incoming jump from 0x2057, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 2058 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2058 assert(); } // Block terminates label_2059: // Incoming jump from 0x2057, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @205C stack[-2] // @205D stack[-1] // @205F memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 2059 5B JUMPDEST 205A 60 PUSH1 0x20 205C 91 SWAP2 205D 01 ADD 205E 01 ADD 205F 51 MLOAD 2060 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 2081 16 AND 2082 7F PUSH32 0x4800000000000000000000000000000000000000000000000000000000000000 20A3 14 EQ // Stack delta = -1 // Outputs[1] { @20A3 stack[-2] = 0x4800000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_20A4: // Incoming jump from 0x204B, if !stack[-1] // Incoming jump from 0x20A3 // Inputs[1] { @20A5 stack[-1] } 20A4 5B JUMPDEST 20A5 80 DUP1 20A6 15 ISZERO 20A7 61 PUSH2 0x2103 20AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2103, if !stack[-1] label_20AB: // Incoming jump from 0x20AA, if not !stack[-1] // Inputs[2] // { // @20AC stack[-4] // @20B0 memory[stack[-4]:stack[-4] + 0x20] // } 20AB 50 POP 20AC 82 DUP3 20AD 60 PUSH1 0x02 20AF 81 DUP2 20B0 51 MLOAD 20B1 81 DUP2 20B2 10 LT 20B3 61 PUSH2 0x20b8 20B6 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @20AC stack[-1] = stack[-4] // @20AD stack[0] = 0x02 // } // Block ends with conditional jump to 0x20b8, if 0x02 < memory[stack[-4]:stack[-4] + 0x20] label_20B7: // Incoming jump from 0x20B6, if not 0x02 < memory[stack[-4]:stack[-4] + 0x20] 20B7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @20B7 assert(); } // Block terminates label_20B8: // Incoming jump from 0x20B6, if 0x02 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @20BB stack[-2] // @20BC stack[-1] // @20BE memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 20B8 5B JUMPDEST 20B9 60 PUSH1 0x20 20BB 91 SWAP2 20BC 01 ADD 20BD 01 ADD 20BE 51 MLOAD 20BF 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 20E0 16 AND 20E1 7F PUSH32 0x7b00000000000000000000000000000000000000000000000000000000000000 2102 14 EQ // Stack delta = -1 // Outputs[1] { @2102 stack[-2] = 0x7b00000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_2103: // Incoming jump from 0x20AA, if !stack[-1] // Incoming jump from 0x2102 // Inputs[1] { @2104 stack[-1] } 2103 5B JUMPDEST 2104 80 DUP1 2105 15 ISZERO 2106 61 PUSH2 0x2162 2109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2162, if !stack[-1] label_210A: // Incoming jump from 0x2109, if not !stack[-1] // Inputs[2] // { // @210B stack[-4] // @210F memory[stack[-4]:stack[-4] + 0x20] // } 210A 50 POP 210B 82 DUP3 210C 60 PUSH1 0x03 210E 81 DUP2 210F 51 MLOAD 2110 81 DUP2 2111 10 LT 2112 61 PUSH2 0x2117 2115 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @210B stack[-1] = stack[-4] // @210C stack[0] = 0x03 // } // Block ends with conditional jump to 0x2117, if 0x03 < memory[stack[-4]:stack[-4] + 0x20] label_2116: // Incoming jump from 0x2115, if not 0x03 < memory[stack[-4]:stack[-4] + 0x20] 2116 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2116 assert(); } // Block terminates label_2117: // Incoming jump from 0x2115, if 0x03 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @211A stack[-2] // @211B stack[-1] // @211D memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 2117 5B JUMPDEST 2118 60 PUSH1 0x20 211A 91 SWAP2 211B 01 ADD 211C 01 ADD 211D 51 MLOAD 211E 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 213F 16 AND 2140 7F PUSH32 0x7100000000000000000000000000000000000000000000000000000000000000 2161 14 EQ // Stack delta = -1 // Outputs[1] { @2161 stack[-2] = 0x7100000000000000000000000000000000000000000000000000000000000000 == 0xff00000000000000000000000000000000000000000000000000000000000000 & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] } // Block continues label_2162: // Incoming jump from 0x2161 // Incoming jump from 0x2109, if !stack[-1] // Inputs[1] { @2163 stack[-1] } 2162 5B JUMPDEST 2163 15 ISZERO 2164 61 PUSH2 0x2187 2167 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2187, if !stack[-1] label_2168: // Incoming jump from 0x2167, if not !stack[-1] // Inputs[3] // { // @216A stack[-3] // @216C memory[stack[-3] + 0x24:stack[-3] + 0x24 + 0x20] // @216D stack[-2] // } 2168 60 PUSH1 0x24 216A 83 DUP4 216B 01 ADD 216C 51 MLOAD 216D 82 DUP3 216E 61 PUSH2 0x2176 2171 82 DUP3 2172 61 PUSH2 0x2a65 2175 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @216C stack[0] = memory[stack[-3] + 0x24:stack[-3] + 0x24 + 0x20] // @216D stack[1] = stack[-2] // @216E stack[2] = 0x2176 // @2171 stack[3] = memory[stack[-3] + 0x24:stack[-3] + 0x24 + 0x20] // } // Block ends with unconditional jump to 0x2a65 2176 5B JUMPDEST 2177 60 PUSH1 0x40 2179 51 MLOAD 217A 60 PUSH1 0x20 217C 01 ADD 217D 61 PUSH2 0x1fca 2180 92 SWAP3 2181 91 SWAP2 2182 90 SWAP1 2183 61 PUSH2 0x3b6f 2186 56 *JUMP label_2187: // Incoming jump from 0x2167, if !stack[-1] // Inputs[2] // { // @2188 stack[-2] // @218C stack[-3] // } 2187 5B JUMPDEST 2188 81 DUP2 2189 61 PUSH2 0x2191 218C 84 DUP5 218D 61 PUSH2 0x2a8b 2190 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2188 stack[0] = stack[-2] // @2189 stack[1] = 0x2191 // @218C stack[2] = stack[-3] // } // Block ends with call to 0x2a8b, returns to 0x2191 label_2191: // Incoming return from call to 0x2A8B at 0x2190 // Inputs[3] // { // @2194 memory[0x40:0x60] // @219B stack[-2] // @219C stack[-1] // } 2191 5B JUMPDEST 2192 60 PUSH1 0x40 2194 51 MLOAD 2195 60 PUSH1 0x20 2197 01 ADD 2198 61 PUSH2 0x21a2 219B 92 SWAP3 219C 91 SWAP2 219D 90 SWAP1 219E 61 PUSH2 0x3bf1 21A1 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @219B stack[-2] = 0x21a2 // @219C stack[-1] = stack[-2] // @219D stack[1] = 0x20 + memory[0x40:0x60] // @219D stack[0] = stack[-1] // } // Block ends with call to 0x3bf1, returns to 0x21A2 label_21A2: // Incoming return from call to 0x3BF1 at 0x21A1 // Inputs[5] // { // @21A5 memory[0x40:0x60] // @21A9 stack[-1] // @21B2 stack[-2] // @21B4 stack[-5] // @21B5 stack[-4] // } 21A2 5B JUMPDEST 21A3 60 PUSH1 0x40 21A5 51 MLOAD 21A6 60 PUSH1 0x20 21A8 81 DUP2 21A9 83 DUP4 21AA 03 SUB 21AB 03 SUB 21AC 81 DUP2 21AD 52 MSTORE 21AE 90 SWAP1 21AF 60 PUSH1 0x40 21B1 52 MSTORE 21B2 90 SWAP1 21B3 50 POP 21B4 92 SWAP3 21B5 91 SWAP2 21B6 50 POP 21B7 50 POP 21B8 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @21AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @21B1 memory[0x40:0x60] = stack[-1] // @21B4 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-5] label_21B9: // Incoming jump from 0x19B0 // Incoming jump from 0x0AA7 // Inputs[2] // { // @21BC stack[-1] // @21BD stack[-2] // } 21B9 5B JUMPDEST 21BA 60 PUSH1 0x00 21BC 81 DUP2 21BD 83 DUP4 21BE 10 LT 21BF 61 PUSH2 0x21c8 21C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21BA stack[0] = 0x00 } // Block ends with conditional jump to 0x21c8, if stack[-2] < stack[-1] label_21C3: // Incoming jump from 0x21C2, if not stack[-2] < stack[-1] // Inputs[1] { @21C3 stack[-2] } 21C3 81 DUP2 21C4 61 PUSH2 0x0b19 21C7 56 *JUMP // Stack delta = +1 // Outputs[1] { @21C3 stack[0] = stack[-2] } // Block ends with unconditional jump to 0x0b19 label_21C8: // Incoming jump from 0x21C2, if stack[-2] < stack[-1] // Inputs[3] // { // @21CA stack[-2] // @21CA stack[-3] // @21CB stack[-4] // } 21C8 5B JUMPDEST 21C9 50 POP 21CA 90 SWAP1 21CB 91 SWAP2 21CC 90 SWAP1 21CD 50 POP 21CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @21CB stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] label_21CF: // Incoming call from 0x19AA, returns to 0x0B13 // Incoming call from 0x1CCE, returns to 0x1CCF // Incoming call from 0x0D5D, returns to 0x0D5E // Incoming jump from 0x1CCE // Incoming call from 0x0B43, returns to 0x0B44 // Incoming call from 0x2564, returns to 0x2565 // Incoming call from 0x0B75, returns to 0x0B76 // Incoming call from 0x10CA, returns to 0x0B13 // Inputs[1] { @21D5 stack[-2] } 21CF 5B JUMPDEST 21D0 60 PUSH1 0x00 21D2 61 PUSH2 0x21da 21D5 83 DUP4 21D6 61 PUSH2 0x285b 21D9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21D0 stack[0] = 0x00 // @21D2 stack[1] = 0x21da // @21D5 stack[2] = stack[-2] // } // Block ends with call to 0x285b, returns to 0x21DA label_21DA: // Incoming return from call to 0x285B at 0x21D9 // Inputs[1] { @21DB stack[-1] } 21DA 5B JUMPDEST 21DB 15 ISZERO 21DC 61 PUSH2 0x21fd 21DF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x21fd, if !stack[-1] label_21E0: // Incoming jump from 0x21DF, if not !stack[-1] // Inputs[2] // { // @21F6 stack[-2] // @21F8 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).balance // } 21E0 50 POP 21E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21F6 81 DUP2 21F7 16 AND 21F8 31 BALANCE 21F9 61 PUSH2 0x0b1c 21FC 56 *JUMP // Stack delta = +0 // Outputs[1] { @21F8 stack[-1] = address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).balance } // Block ends with unconditional jump to 0x0b1c label_21FD: // Incoming jump from 0x21DF, if !stack[-1] // Inputs[3] // { // @2200 memory[0x40:0x60] // @2239 stack[-3] // @2246 stack[-2] // } 21FD 5B JUMPDEST 21FE 60 PUSH1 0x40 2200 51 MLOAD 2201 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 2222 81 DUP2 2223 52 MSTORE 2224 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2239 84 DUP5 223A 16 AND 223B 90 SWAP1 223C 63 PUSH4 0x70a08231 2241 90 SWAP1 2242 61 PUSH2 0x224f 2245 90 SWAP1 2246 85 DUP6 2247 90 SWAP1 2248 60 PUSH1 0x04 224A 01 ADD 224B 61 PUSH2 0x3cc8 224E 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2223 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @223B stack[0] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @2241 stack[1] = 0x70a08231 // @2245 stack[2] = 0x224f // @2247 stack[3] = stack[-2] // @224A stack[4] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3cc8, returns to 0x224F label_224F: // Incoming return from call to 0x3CC8 at 0x224E // Inputs[4] // { // @2254 memory[0x40:0x60] // @2256 stack[-1] // @2259 stack[-3] // @225B address(stack[-3]).code.length // } 224F 5B JUMPDEST 2250 60 PUSH1 0x20 2252 60 PUSH1 0x40 2254 51 MLOAD 2255 80 DUP1 2256 83 DUP4 2257 03 SUB 2258 81 DUP2 2259 86 DUP7 225A 80 DUP1 225B 3B EXTCODESIZE 225C 15 ISZERO 225D 80 DUP1 225E 15 ISZERO 225F 61 PUSH2 0x2267 2262 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2250 stack[0] = 0x20 // @2254 stack[1] = memory[0x40:0x60] // @2257 stack[2] = stack[-1] - memory[0x40:0x60] // @2258 stack[3] = memory[0x40:0x60] // @2259 stack[4] = stack[-3] // @225C stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x2267, if !!address(stack[-3]).code.length label_2263: // Incoming jump from 0x2262, if not !!address(stack[-3]).code.length // Inputs[1] { @2266 memory[0x00:0x00] } 2263 60 PUSH1 0x00 2265 80 DUP1 2266 FD *REVERT // Stack delta = +0 // Outputs[1] { @2266 revert(memory[0x00:0x00]); } // Block terminates label_2267: // Incoming jump from 0x2262, if !!address(stack[-3]).code.length // Inputs[8] // { // @2269 msg.gas // @226A stack[-2] // @226A stack[-5] // @226A memory[stack[-3]:stack[-3] + stack[-4]] // @226A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @226A stack[-6] // @226A stack[-3] // @226A stack[-4] // } 2267 5B JUMPDEST 2268 50 POP 2269 5A GAS 226A FA STATICCALL 226B 15 ISZERO 226C 80 DUP1 226D 15 ISZERO 226E 61 PUSH2 0x227b 2271 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @226A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @226B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x227b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2272: // Incoming jump from 0x2271, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2272 returndata.length // @2276 returndata[0x00:0x00 + returndata.length] // @2277 returndata.length // @227A memory[0x00:0x00 + returndata.length] // } 2272 3D RETURNDATASIZE 2273 60 PUSH1 0x00 2275 80 DUP1 2276 3E RETURNDATACOPY 2277 3D RETURNDATASIZE 2278 60 PUSH1 0x00 227A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2276 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @227A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_227B: // Incoming jump from 0x2271, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2282 memory[0x40:0x60] // @2283 returndata.length // } 227B 5B JUMPDEST 227C 50 POP 227D 50 POP 227E 50 POP 227F 50 POP 2280 60 PUSH1 0x40 2282 51 MLOAD 2283 3D RETURNDATASIZE 2284 60 PUSH1 0x1f 2286 19 NOT 2287 60 PUSH1 0x1f 2289 82 DUP3 228A 01 ADD 228B 16 AND 228C 82 DUP3 228D 01 ADD 228E 80 DUP1 228F 60 PUSH1 0x40 2291 52 MSTORE 2292 50 POP 2293 81 DUP2 2294 01 ADD 2295 90 SWAP1 2296 61 PUSH2 0x229f 2299 91 SWAP2 229A 90 SWAP1 229B 61 PUSH2 0x38dc 229E 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2291 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2299 stack[-4] = 0x229f // @229A stack[-2] = memory[0x40:0x60] // @229A stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x38dc, returns to 0x229F label_229F: // Incoming return from call to 0x38DC at 0x229E // Inputs[2] // { // @22A0 stack[-1] // @22A0 stack[-2] // } 229F 5B JUMPDEST 22A0 90 SWAP1 22A1 50 POP 22A2 61 PUSH2 0x0b1c 22A5 56 *JUMP // Stack delta = -1 // Outputs[1] { @22A0 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0b1c label_22A6: // Incoming call from 0x0D30, returns to 0x0773 // Incoming call from 0x1702, returns to 0x1703 // Inputs[1] { @22A7 stack[-1] } 22A6 5B JUMPDEST 22A7 80 DUP1 22A8 15 ISZERO 22A9 61 PUSH2 0x1703 22AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1703, if !stack[-1] label_22AD: // Incoming jump from 0x22AC, if not !stack[-1] // Inputs[1] { @22B0 stack[-3] } 22AD 61 PUSH2 0x22b5 22B0 83 DUP4 22B1 61 PUSH2 0x285b 22B4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22AD stack[0] = 0x22b5 // @22B0 stack[1] = stack[-3] // } // Block ends with call to 0x285b, returns to 0x22B5 label_22B5: // Incoming return from call to 0x285B at 0x22B4 // Inputs[1] { @22B6 stack[-1] } 22B5 5B JUMPDEST 22B6 15 ISZERO 22B7 61 PUSH2 0x2303 22BA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2303, if !stack[-1] label_22BB: // Incoming jump from 0x22BA, if not !stack[-1] // Inputs[5] // { // @22BD memory[0x40:0x60] // @22D3 stack[-2] // @22D6 stack[-1] // @22E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @22E7 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 22BB 60 PUSH1 0x40 22BD 51 MLOAD 22BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22D3 83 DUP4 22D4 16 AND 22D5 90 SWAP1 22D6 82 DUP3 22D7 15 ISZERO 22D8 61 PUSH2 0x08fc 22DB 02 MUL 22DC 90 SWAP1 22DD 83 DUP4 22DE 90 SWAP1 22DF 60 PUSH1 0x00 22E1 81 DUP2 22E2 81 DUP2 22E3 81 DUP2 22E4 85 DUP6 22E5 88 DUP9 22E6 88 DUP9 22E7 F1 CALL 22E8 93 SWAP4 22E9 50 POP 22EA 50 POP 22EB 50 POP 22EC 50 POP 22ED 15 ISZERO 22EE 80 DUP1 22EF 15 ISZERO 22F0 61 PUSH2 0x22fd 22F3 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @22E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @22ED stack[0] = !address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x22fd, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_22F4: // Incoming jump from 0x22F3, if not !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @22F4 returndata.length // @22F8 returndata[0x00:0x00 + returndata.length] // @22F9 returndata.length // @22FC memory[0x00:0x00 + returndata.length] // } 22F4 3D RETURNDATASIZE 22F5 60 PUSH1 0x00 22F7 80 DUP1 22F8 3E RETURNDATACOPY 22F9 3D RETURNDATASIZE 22FA 60 PUSH1 0x00 22FC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @22F8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @22FC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_22FD: // Incoming jump from 0x22F3, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) 22FD 5B JUMPDEST 22FE 50 POP 22FF 61 PUSH2 0x1703 2302 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1703 label_2303: // Incoming jump from 0x22BA, if !stack[-1] // Inputs[4] // { // @2307 stack[-3] // @2310 stack[-2] // @2311 stack[-1] // @2314 memory[0x40:0x60] // } 2303 5B JUMPDEST 2304 61 PUSH2 0x1703 2307 83 DUP4 2308 63 PUSH4 0xa9059cbb 230D 60 PUSH1 0xe0 230F 1B SHL 2310 84 DUP5 2311 84 DUP5 2312 60 PUSH1 0x40 2314 51 MLOAD 2315 60 PUSH1 0x24 2317 01 ADD 2318 61 PUSH2 0x2322 231B 92 SWAP3 231C 91 SWAP2 231D 90 SWAP1 231E 61 PUSH2 0x3ce9 2321 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2304 stack[0] = 0x1703 // @2307 stack[1] = stack[-3] // @230F stack[2] = 0xa9059cbb << 0xe0 // @231B stack[3] = 0x2322 // @231C stack[4] = stack[-2] // @231D stack[5] = stack[-1] // @231D stack[6] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x3ce9, returns to 0x2322 label_2322: // Incoming return from call to 0x3CE9 at 0x2321 // Inputs[4] // { // @2326 memory[0x40:0x60] // @2349 stack[-1] // @2356 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2397 stack[-2] // } 2322 5B JUMPDEST 2323 60 PUSH1 0x40 2325 80 DUP1 2326 51 MLOAD 2327 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 2348 81 DUP2 2349 84 DUP5 234A 03 SUB 234B 01 ADD 234C 81 DUP2 234D 52 MSTORE 234E 91 SWAP2 234F 90 SWAP1 2350 52 MSTORE 2351 60 PUSH1 0x20 2353 81 DUP2 2354 01 ADD 2355 80 DUP1 2356 51 MLOAD 2357 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2374 16 AND 2375 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 2396 90 SWAP1 2397 93 SWAP4 2398 16 AND 2399 92 SWAP3 239A 90 SWAP1 239B 92 SWAP3 239C 17 OR 239D 90 SWAP1 239E 91 SWAP2 239F 52 MSTORE 23A0 61 PUSH2 0x2cc6 23A3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @234D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @2350 memory[0x40:0x60] = stack[-1] // @239E stack[-2] = memory[0x40:0x60] // @239F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // } // Block ends with unconditional jump to 0x2cc6 label_23A4: // Incoming call from 0x10D7, returns to 0x0778 // Incoming jump from 0x0F3B // Incoming call from 0x0E83, returns to 0x0D31 // Inputs[1] { @23C6 stack[-2] } 23A4 5B JUMPDEST 23A5 7F PUSH32 0xc000000000000000000000000000000000000000000000000000000000000000 23C6 82 DUP3 23C7 81 DUP2 23C8 16 AND 23C9 14 EQ 23CA 15 ISZERO 23CB 61 PUSH2 0x2400 23CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2400, if !(0xc000000000000000000000000000000000000000000000000000000000000000 & stack[-2] == 0xc000000000000000000000000000000000000000000000000000000000000000) label_23CF: // Incoming jump from 0x23CE, if not !(0xc000000000000000000000000000000000000000000000000000000000000000 & stack[-2] == 0xc000000000000000000000000000000000000000000000000000000000000000) // Inputs[1] { @23D1 memory[0x40:0x60] } 23CF 60 PUSH1 0x40 23D1 51 MLOAD 23D2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 23F3 81 DUP2 23F4 52 MSTORE 23F5 60 PUSH1 0x04 23F7 01 ADD 23F8 61 PUSH2 0x01c3 23FB 90 SWAP1 23FC 61 PUSH2 0x404c 23FF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @23FB stack[0] = 0x01c3 // @23FB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x404c, returns to 0x01C3 label_2400: // Incoming jump from 0x23CE, if !(0xc000000000000000000000000000000000000000000000000000000000000000 & stack[-2] == 0xc000000000000000000000000000000000000000000000000000000000000000) // Inputs[1] { @2422 stack[-2] } 2400 5B JUMPDEST 2401 7F PUSH32 0x2000000000000000000000000000000000000000000000000000000000000000 2422 82 DUP3 2423 16 AND 2424 15 ISZERO 2425 61 PUSH2 0x2432 2428 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2432, if !(stack[-2] & 0x2000000000000000000000000000000000000000000000000000000000000000) label_2429: // Incoming jump from 0x2428, if not !(stack[-2] & 0x2000000000000000000000000000000000000000000000000000000000000000) // Inputs[1] { @2429 stack[-1] } 2429 80 DUP1 242A 61 PUSH2 0x2432 242D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2432, if stack[-1] label_242E: // Incoming jump from 0x242D, if not stack[-1] 242E 61 PUSH2 0x1703 2431 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1703 label_2432: // Incoming jump from 0x2428, if !(stack[-2] & 0x2000000000000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x242D, if stack[-1] // Inputs[1] { @2454 stack[-2] } 2432 5B JUMPDEST 2433 7F PUSH32 0x8000000000000000000000000000000000000000000000000000000000000000 2454 82 DUP3 2455 16 AND 2456 61 PUSH2 0x246e 2459 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x246e, if stack[-2] & 0x8000000000000000000000000000000000000000000000000000000000000000 label_245A: // Incoming jump from 0x2459, if not stack[-2] & 0x8000000000000000000000000000000000000000000000000000000000000000 // Inputs[3] // { // @245C stack[-3] // @245E memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2463 stack[-1] // } 245A 60 PUSH1 0x40 245C 83 DUP4 245D 01 ADD 245E 51 MLOAD 245F 61 PUSH2 0x2468 2462 90 SWAP1 2463 82 DUP3 2464 61 PUSH2 0x2804 2467 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2462 stack[0] = 0x2468 // @2462 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2463 stack[2] = stack[-1] // } // Block ends with call to 0x2804, returns to 0x2468 label_2468: // Incoming return from call to 0x2804 at 0x2467 // Inputs[2] // { // @246B stack[-4] // @246D stack[-1] // } 2468 5B JUMPDEST 2469 60 PUSH1 0x40 246B 84 DUP5 246C 01 ADD 246D 52 MSTORE // Stack delta = -1 // Outputs[1] { @246D memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] = stack[-1] } // Block continues label_246E: // Incoming jump from 0x2459, if stack[-2] & 0x8000000000000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x246D // Inputs[1] { @2490 stack[-2] } 246E 5B JUMPDEST 246F 7F PUSH32 0x4000000000000000000000000000000000000000000000000000000000000000 2490 82 DUP3 2491 16 AND 2492 61 PUSH2 0x2504 2495 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2504, if stack[-2] & 0x4000000000000000000000000000000000000000000000000000000000000000 label_2496: // Incoming jump from 0x2495, if not stack[-2] & 0x4000000000000000000000000000000000000000000000000000000000000000 // Inputs[4] // { // @2498 stack[-3] // @249A memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @249B memory[memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20]:memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] + 0x20] // @24BD stack[-2] // } 2496 60 PUSH1 0x60 2498 83 DUP4 2499 01 ADD 249A 51 MLOAD 249B 51 MLOAD 249C 7F PUSH32 0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 24BD 83 DUP4 24BE 16 AND 24BF 90 SWAP1 24C0 60 PUSH1 0x20 24C2 82 DUP3 24C3 01 ADD 24C4 11 GT 24C5 15 ISZERO 24C6 61 PUSH2 0x24fb 24C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24BF stack[0] = stack[-2] & 0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff } // Block ends with conditional jump to 0x24fb, if !((stack[-2] & 0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 0x20 > memory[memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20]:memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] + 0x20]) label_24CA: // Incoming jump from 0x24C9, if not !((stack[-2] & 0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 0x20 > memory[memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20]:memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] + 0x20]) // Inputs[1] { @24CC memory[0x40:0x60] } 24CA 60 PUSH1 0x40 24CC 51 MLOAD 24CD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 24EE 81 DUP2 24EF 52 MSTORE 24F0 60 PUSH1 0x04 24F2 01 ADD 24F3 61 PUSH2 0x01c3 24F6 90 SWAP1 24F7 61 PUSH2 0x422a 24FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @24EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @24F6 stack[0] = 0x01c3 // @24F6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x422a, returns to 0x01C3 label_24FB: // Incoming jump from 0x24C9, if !((stack[-2] & 0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 0x20 > memory[memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20]:memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] + 0x20]) // Inputs[3] // { // @24FC stack[-4] // @24FD stack[-1] // @2501 stack[-2] // } 24FB 5B JUMPDEST 24FC 83 DUP4 24FD 01 ADD 24FE 60 PUSH1 0xa0 2500 01 ADD 2501 81 DUP2 2502 90 SWAP1 2503 52 MSTORE // Stack delta = -1 // Outputs[1] { @2503 memory[0xa0 + stack[-4] + stack[-1]:0xa0 + stack[-4] + stack[-1] + 0x20] = stack[-2] } // Block continues label_2504: // Incoming jump from 0x2495, if stack[-2] & 0x4000000000000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x2503 // Inputs[1] { @2508 stack[-3] } 2504 5B JUMPDEST 2505 61 PUSH2 0x1703 2508 83 DUP4 2509 61 PUSH2 0x19b1 250C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2505 stack[0] = 0x1703 // @2508 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x19b1 label_250D: // Incoming call from 0x0F4D, returns to 0x0AE4 // Inputs[1] { @2511 stack[-1] } 250D 5B JUMPDEST 250E 60 PUSH1 0x00 2510 5B JUMPDEST 2511 81 DUP2 2512 81 DUP2 2513 10 LT 2514 15 ISZERO 2515 61 PUSH2 0x1703 2518 57 *JUMPI // Stack delta = +1 // Outputs[1] { @250E stack[0] = 0x00 } // Block ends with conditional jump to 0x1703, if !(0x00 < stack[-1]) label_2519: // Incoming jump from 0x2518, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2518, if not !(0x00 < stack[-1]) // Inputs[3] // { // @251C stack[-3] // @251D stack[-2] // @251E stack[-1] // } 2519 61 PUSH2 0x2539 251C 83 DUP4 251D 83 DUP4 251E 83 DUP4 251F 81 DUP2 2520 81 DUP2 2521 10 LT 2522 61 PUSH2 0x2527 2525 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2519 stack[0] = 0x2539 // @251C stack[1] = stack[-3] // @251D stack[2] = stack[-2] // @251E stack[3] = stack[-1] // } // Block ends with conditional call to 0x2527, returns to 0x2539, if stack[-1] < stack[-2] label_2526: // Incoming jump from 0x2525, if not stack[-1] < stack[-2] 2526 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2526 assert(); } // Block terminates label_2527: // Incoming call from 0x2525, returns to 0x2539, if stack[-1] < stack[-2] // Inputs[3] // { // @2528 stack[-2] // @2528 stack[-1] // @252D stack[-3] // } 2527 5B JUMPDEST 2528 90 SWAP1 2529 50 POP 252A 60 PUSH1 0x20 252C 02 MUL 252D 81 DUP2 252E 01 ADD 252F 90 SWAP1 2530 61 PUSH2 0x0221 2533 91 SWAP2 2534 90 SWAP1 2535 61 PUSH2 0x4378 2538 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2533 stack[-3] = 0x0221 // @2534 stack[-1] = stack[-3] // @2534 stack[-2] = stack[-3] + 0x20 * stack[-1] // } // Block ends with call to 0x4378, returns to 0x0221 label_2539: // Incoming return from call to 0x2527 at 0x2525 // Inputs[1] { @253C stack[-1] } 2539 5B JUMPDEST 253A 60 PUSH1 0x01 253C 01 ADD 253D 61 PUSH2 0x2510 2540 56 *JUMP // Stack delta = +0 // Outputs[1] { @253C stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x2510 label_2541: // Incoming call from 0x18EB, returns to 0x18EC // Incoming call from 0x10E7, returns to 0x10E8 // Inputs[2] // { // @255E stack[-4] // @2560 stack[-5] // } 2541 5B JUMPDEST 2542 60 PUSH1 0x00 2544 80 DUP1 2545 80 DUP1 2546 61 PUSH2 0x2565 2549 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 255E 88 DUP9 255F 16 AND 2560 89 DUP10 2561 61 PUSH2 0x21cf 2564 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2542 stack[0] = 0x00 // @2544 stack[1] = 0x00 // @2545 stack[2] = 0x00 // @2546 stack[3] = 0x2565 // @255F stack[4] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @2560 stack[5] = stack[-5] // } // Block ends with call to 0x21cf, returns to 0x2565 label_2565: // Incoming return from call to 0x21CF at 0x2564 // Inputs[6] // { // @2566 stack[-2] // @2566 stack[-1] // @256B stack[-9] // @2589 memory[0x40:0x60] // @259D memory[0x40:0x60] // @25A4 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // } 2565 5B JUMPDEST 2566 90 SWAP1 2567 50 POP 2568 60 PUSH1 0x00 256A 80 DUP1 256B 89 DUP10 256C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2581 16 AND 2582 63 PUSH4 0x0902f1ac 2587 60 PUSH1 0x40 2589 51 MLOAD 258A 81 DUP2 258B 63 PUSH4 0xffffffff 2590 16 AND 2591 60 PUSH1 0xe0 2593 1B SHL 2594 81 DUP2 2595 52 MSTORE 2596 60 PUSH1 0x04 2598 01 ADD 2599 60 PUSH1 0x60 259B 60 PUSH1 0x40 259D 51 MLOAD 259E 80 DUP1 259F 83 DUP4 25A0 03 SUB 25A1 81 DUP2 25A2 86 DUP7 25A3 80 DUP1 25A4 3B EXTCODESIZE 25A5 15 ISZERO 25A6 80 DUP1 25A7 15 ISZERO 25A8 61 PUSH2 0x25b0 25AB 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @2566 stack[-2] = stack[-1] // @2568 stack[-1] = 0x00 // @256A stack[0] = 0x00 // @2581 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @2582 stack[2] = 0x0902f1ac // @2595 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @2598 stack[3] = 0x04 + memory[0x40:0x60] // @2599 stack[4] = 0x60 // @259D stack[5] = memory[0x40:0x60] // @25A0 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @25A1 stack[7] = memory[0x40:0x60] // @25A2 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @25A5 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // } // Block ends with conditional jump to 0x25b0, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length label_25AC: // Incoming jump from 0x25AB, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // Inputs[1] { @25AF memory[0x00:0x00] } 25AC 60 PUSH1 0x00 25AE 80 DUP1 25AF FD *REVERT // Stack delta = +0 // Outputs[1] { @25AF revert(memory[0x00:0x00]); } // Block terminates label_25B0: // Incoming jump from 0x25AB, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // Inputs[8] // { // @25B2 msg.gas // @25B3 stack[-5] // @25B3 stack[-4] // @25B3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25B3 memory[stack[-3]:stack[-3] + stack[-4]] // @25B3 stack[-6] // @25B3 stack[-3] // @25B3 stack[-2] // } 25B0 5B JUMPDEST 25B1 50 POP 25B2 5A GAS 25B3 FA STATICCALL 25B4 15 ISZERO 25B5 80 DUP1 25B6 15 ISZERO 25B7 61 PUSH2 0x25c4 25BA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @25B3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25B4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x25c4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_25BB: // Incoming jump from 0x25BA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @25BB returndata.length // @25BF returndata[0x00:0x00 + returndata.length] // @25C0 returndata.length // @25C3 memory[0x00:0x00 + returndata.length] // } 25BB 3D RETURNDATASIZE 25BC 60 PUSH1 0x00 25BE 80 DUP1 25BF 3E RETURNDATACOPY 25C0 3D RETURNDATASIZE 25C1 60 PUSH1 0x00 25C3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @25BF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @25C3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_25C4: // Incoming jump from 0x25BA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @25CB memory[0x40:0x60] // @25CC returndata.length // } 25C4 5B JUMPDEST 25C5 50 POP 25C6 50 POP 25C7 50 POP 25C8 50 POP 25C9 60 PUSH1 0x40 25CB 51 MLOAD 25CC 3D RETURNDATASIZE 25CD 60 PUSH1 0x1f 25CF 19 NOT 25D0 60 PUSH1 0x1f 25D2 82 DUP3 25D3 01 ADD 25D4 16 AND 25D5 82 DUP3 25D6 01 ADD 25D7 80 DUP1 25D8 60 PUSH1 0x40 25DA 52 MSTORE 25DB 50 POP 25DC 81 DUP2 25DD 01 ADD 25DE 90 SWAP1 25DF 61 PUSH2 0x25e8 25E2 91 SWAP2 25E3 90 SWAP1 25E4 61 PUSH2 0x3888 25E7 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @25DA memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @25E2 stack[-4] = 0x25e8 // @25E3 stack[-2] = memory[0x40:0x60] // @25E3 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x3888, returns to 0x25E8 label_25E8: // Incoming return from call to 0x3888 at 0x25E7 // Inputs[6] // { // @25F9 stack[-2] // @25FA stack[-4] // @260B stack[-3] // @260C stack[-5] // @260E stack[-11] // @2625 stack[-12] // } 25E8 5B JUMPDEST 25E9 50 POP 25EA 6D PUSH14 0xffffffffffffffffffffffffffff 25F9 16 AND 25FA 91 SWAP2 25FB 50 POP 25FC 6D PUSH14 0xffffffffffffffffffffffffffff 260B 16 AND 260C 91 SWAP2 260D 50 POP 260E 87 DUP8 260F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2624 16 AND 2625 89 DUP10 2626 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 263B 16 AND 263C 11 GT 263D 15 ISZERO 263E 61 PUSH2 0x2643 2641 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @25FA stack[-4] = 0xffffffffffffffffffffffffffff & stack[-2] // @260C stack[-5] = 0xffffffffffffffffffffffffffff & stack[-3] // } // Block ends with conditional jump to 0x2643, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-12] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) label_2642: // Incoming jump from 0x2641, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-12] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) // Inputs[3] // { // @2642 stack[-1] // @2642 stack[-2] // @2649 stack[-3] // } 2642 90 SWAP1 2643 5B JUMPDEST 2644 60 PUSH1 0x00 2646 61 PUSH2 0x264f 2649 84 DUP5 264A 84 DUP5 264B 61 PUSH2 0x1c52 264E 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2642 stack[-1] = stack[-2] // @2642 stack[-2] = stack[-1] // @2644 stack[0] = 0x00 // @2646 stack[1] = 0x264f // @2649 stack[2] = stack[-3] // @264A stack[3] = stack[-1] // } // Block ends with call to 0x1c52, returns to 0x264F label_264F: // Incoming return from call to 0x1C52 at 0x264E // Incoming return from call to 0x1C52 at 0x264E // Inputs[3] // { // @2650 stack[-2] // @2650 stack[-1] // @265A stack[-9] // } 264F 5B JUMPDEST 2650 90 SWAP1 2651 50 POP 2652 60 PUSH1 0x00 2654 61 PUSH2 0x2665 2657 82 DUP3 2658 60 PUSH1 0xa0 265A 8B DUP12 265B 90 SWAP1 265C 1C SHR 265D 61 PUSH2 0x03e8 2660 03 SUB 2661 61 PUSH2 0x1bb2 2664 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2650 stack[-2] = stack[-1] // @2652 stack[-1] = 0x00 // @2654 stack[0] = 0x2665 // @2657 stack[1] = stack[-1] // @2660 stack[2] = 0x03e8 - (stack[-9] >> 0xa0) // } // Block ends with call to 0x1bb2, returns to 0x2665 label_2665: // Incoming return from call to 0x1BB2 at 0x2664 // Inputs[3] // { // @2666 stack[-1] // @2666 stack[-2] // @266E stack[-4] // } 2665 5B JUMPDEST 2666 90 SWAP1 2667 50 POP 2668 60 PUSH1 0x00 266A 61 PUSH2 0x2673 266D 82 DUP3 266E 85 DUP6 266F 61 PUSH2 0x1bb2 2672 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2666 stack[-2] = stack[-1] // @2668 stack[-1] = 0x00 // @266A stack[0] = 0x2673 // @266D stack[1] = stack[-1] // @266E stack[2] = stack[-4] // } // Block ends with call to 0x1bb2, returns to 0x2673 label_2673: // Incoming return from call to 0x1BB2 at 0x2672 // Inputs[4] // { // @2674 stack[-1] // @2674 stack[-2] // @267B stack[-3] // @267F stack[-6] // } 2673 5B JUMPDEST 2674 90 SWAP1 2675 50 POP 2676 60 PUSH1 0x00 2678 61 PUSH2 0x2687 267B 83 DUP4 267C 61 PUSH2 0x16ce 267F 88 DUP9 2680 61 PUSH2 0x03e8 2683 61 PUSH2 0x1bb2 2686 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2674 stack[-2] = stack[-1] // @2676 stack[-1] = 0x00 // @2678 stack[0] = 0x2687 // @267B stack[1] = stack[-3] // @267C stack[2] = 0x16ce // @267F stack[3] = stack[-6] // @2680 stack[4] = 0x03e8 // } // Block ends with call to 0x1bb2, returns to 0x16CE label_2687: // Incoming return from call to 0x16CE at 0x2686 // Inputs[3] // { // @2688 stack[-2] // @2688 stack[-1] // @268F stack[-3] // } 2687 5B JUMPDEST 2688 90 SWAP1 2689 50 POP 268A 60 PUSH1 0x00 268C 61 PUSH2 0x2695 268F 83 DUP4 2690 83 DUP4 2691 61 PUSH2 0x1c06 2694 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2688 stack[-2] = stack[-1] // @268A stack[-1] = 0x00 // @268C stack[0] = 0x2695 // @268F stack[1] = stack[-3] // @2690 stack[2] = stack[-1] // } // Block ends with call to 0x1c06, returns to 0x2695 label_2695: // Incoming return from call to 0x1C06 at 0x2694 // Inputs[5] // { // @2696 stack[-2] // @2696 stack[-1] // @2697 stack[-11] // @2699 stack[-10] // @269B stack[-12] // } 2695 5B JUMPDEST 2696 90 SWAP1 2697 99 SWAP10 2698 50 POP 2699 97 SWAP8 269A 50 POP 269B 89 DUP10 269C 88 DUP9 269D 10 LT 269E 15 ISZERO 269F 61 PUSH2 0x26d4 26A2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2697 stack[-11] = stack[-2] // @2699 stack[-10] = stack[-1] // } // Block ends with conditional jump to 0x26d4, if !(stack[-1] < stack[-12]) label_26A3: // Incoming jump from 0x26A2, if not !(stack[-1] < stack[-12]) // Inputs[1] { @26A5 memory[0x40:0x60] } 26A3 60 PUSH1 0x40 26A5 51 MLOAD 26A6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 26C7 81 DUP2 26C8 52 MSTORE 26C9 60 PUSH1 0x04 26CB 01 ADD 26CC 61 PUSH2 0x01c3 26CF 90 SWAP1 26D0 61 PUSH2 0x3ecb 26D3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @26CF stack[0] = 0x01c3 // @26CF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3ecb, returns to 0x01C3 label_26D4: // Incoming jump from 0x26A2, if !(stack[-1] < stack[-12]) // Inputs[2] // { // @26D5 stack[-12] // @26EC stack[-13] // } 26D4 5B JUMPDEST 26D5 8B DUP12 26D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26EB 16 AND 26EC 8D DUP14 26ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2702 16 AND 2703 11 GT 2704 15 ISZERO 2705 61 PUSH2 0x270c 2708 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x270c, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-13] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-12]) label_2709: // Incoming jump from 0x2708, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-13] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-12]) // Inputs[6] // { // @2709 stack[-8] // @2709 stack[-1] // @270A stack[-9] // @2714 stack[-14] // @2716 stack[-15] // @2717 stack[-13] // } 2709 96 SWAP7 270A 97 SWAP8 270B 96 SWAP7 270C 5B JUMPDEST 270D 50 POP 270E 50 POP 270F 50 POP 2710 50 POP 2711 50 POP 2712 50 POP 2713 50 POP 2714 95 SWAP6 2715 50 POP 2716 95 SWAP6 2717 93 SWAP4 2718 50 POP 2719 50 POP 271A 50 POP 271B 50 POP 271C 56 *JUMP // Stack delta = -13 // Outputs[2] // { // @2714 stack[-14] = stack[-9] // @2716 stack[-15] = stack[-8] // } // Block ends with unconditional jump to stack[-15] label_271D: // Incoming jump from 0x1516 // Incoming jump from 0x15AB // Inputs[2] // { // @272D stack[-1] // @2731 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 271D 5B JUMPDEST 271E 60 PUSH1 0x00 2720 80 DUP1 2721 61 PUSH2 0x2736 2724 67 PUSH8 0x0de0b6b3a7640000 272D 84 DUP5 272E 60 PUSH1 0x00 2730 01 ADD 2731 51 MLOAD 2732 61 PUSH2 0x2843 2735 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @271E stack[0] = 0x00 // @2720 stack[1] = 0x00 // @2721 stack[2] = 0x2736 // @2724 stack[3] = 0x0de0b6b3a7640000 // @2731 stack[4] = memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2843 2736 5B JUMPDEST 2737 90 SWAP1 2738 50 POP 2739 60 PUSH1 0x00 273B 61 PUSH2 0x275d 273E 84 DUP5 273F 60 PUSH1 0x80 2741 01 ADD 2742 51 MLOAD 2743 85 DUP6 2744 60 PUSH1 0x80 2746 01 ADD 2747 51 MLOAD 2748 61 PUSH2 0x2751 274B 85 DUP6 274C 89 DUP10 274D 61 PUSH2 0x2dbe 2750 56 *JUMP 2751 5B JUMPDEST 2752 60 PUSH1 0x00 2754 88 DUP9 2755 60 PUSH1 0x20 2757 01 ADD 2758 51 MLOAD 2759 61 PUSH2 0x2dda 275C 56 *JUMP 275D 5B JUMPDEST 275E 60 PUSH1 0x80 2760 85 DUP6 2761 01 ADD 2762 51 MLOAD 2763 90 SWAP1 2764 91 SWAP2 2765 50 POP 2766 61 PUSH2 0x16d9 2769 90 SWAP1 276A 82 DUP3 276B 61 PUSH2 0x1c52 276E 56 *JUMP label_276F: // Incoming jump from 0x153F // Inputs[2] // { // @277F stack[-1] // @2783 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 276F 5B JUMPDEST 2770 60 PUSH1 0x00 2772 80 DUP1 2773 61 PUSH2 0x2788 2776 67 PUSH8 0x0de0b6b3a7640000 277F 84 DUP5 2780 60 PUSH1 0x00 2782 01 ADD 2783 51 MLOAD 2784 61 PUSH2 0x2843 2787 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2770 stack[0] = 0x00 // @2772 stack[1] = 0x00 // @2773 stack[2] = 0x2788 // @2776 stack[3] = 0x0de0b6b3a7640000 // @2783 stack[4] = memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2843 2788 5B JUMPDEST 2789 90 SWAP1 278A 50 POP 278B 60 PUSH1 0x00 278D 61 PUSH2 0x27a3 2790 84 DUP5 2791 60 PUSH1 0x80 2793 01 ADD 2794 51 MLOAD 2795 85 DUP6 2796 60 PUSH1 0x40 2798 01 ADD 2799 51 MLOAD 279A 61 PUSH2 0x2751 279D 85 DUP6 279E 89 DUP10 279F 61 PUSH2 0x2dbe 27A2 56 *JUMP 27A3 5B JUMPDEST 27A4 60 PUSH1 0x40 27A6 85 DUP6 27A7 01 ADD 27A8 51 MLOAD 27A9 90 SWAP1 27AA 91 SWAP2 27AB 50 POP 27AC 61 PUSH2 0x16d9 27AF 90 SWAP1 27B0 82 DUP3 27B1 61 PUSH2 0x1c52 27B4 56 *JUMP label_27B5: // Incoming jump from 0x158E // Inputs[3] // { // @27BC stack[-2] // @27BD stack[-1] // @27C1 memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // } 27B5 5B JUMPDEST 27B6 60 PUSH1 0x00 27B8 80 DUP1 27B9 61 PUSH2 0x27cf 27BC 84 DUP5 27BD 84 DUP5 27BE 60 PUSH1 0x60 27C0 01 ADD 27C1 51 MLOAD 27C2 61 PUSH2 0x2804 27C5 90 SWAP1 27C6 91 SWAP2 27C7 90 SWAP1 27C8 63 PUSH4 0xffffffff 27CD 16 AND 27CE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @27B6 stack[0] = 0x00 // @27B8 stack[1] = 0x00 // @27B9 stack[2] = 0x27cf // @27C6 stack[3] = memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @27C7 stack[4] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2804, returns to 0x27CF label_27CF: // Incoming return from call to 0x2804 at 0x27CE // Inputs[4] // { // @27D0 stack[-1] // @27D0 stack[-2] // @27E0 stack[-4] // @27E4 memory[0x00 + stack[-4]:0x00 + stack[-4] + 0x20] // } 27CF 5B JUMPDEST 27D0 90 SWAP1 27D1 50 POP 27D2 60 PUSH1 0x00 27D4 61 PUSH2 0x27e9 27D7 67 PUSH8 0x0de0b6b3a7640000 27E0 85 DUP6 27E1 60 PUSH1 0x00 27E3 01 ADD 27E4 51 MLOAD 27E5 61 PUSH2 0x2843 27E8 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @27D0 stack[-2] = stack[-1] // @27D2 stack[-1] = 0x00 // @27D4 stack[0] = 0x27e9 // @27D7 stack[1] = 0x0de0b6b3a7640000 // @27E4 stack[2] = memory[0x00 + stack[-4]:0x00 + stack[-4] + 0x20] // } // Block ends with unconditional jump to 0x2843 27E9 5B JUMPDEST 27EA 90 SWAP1 27EB 50 POP 27EC 61 PUSH2 0x16d9 27EF 84 DUP5 27F0 60 PUSH1 0xa0 27F2 01 ADD 27F3 51 MLOAD 27F4 83 DUP4 27F5 86 DUP7 27F6 60 PUSH1 0x60 27F8 01 ADD 27F9 51 MLOAD 27FA 84 DUP5 27FB 88 DUP9 27FC 60 PUSH1 0x20 27FE 01 ADD 27FF 51 MLOAD 2800 61 PUSH2 0x2f14 2803 56 *JUMP label_2804: // Incoming call from 0x2467, returns to 0x2468 // Incoming call from 0x27CE, returns to 0x27CF // Incoming jump from 0x16D3 // Inputs[2] // { // @2807 stack[-2] // @2808 stack[-1] // } 2804 5B JUMPDEST 2805 60 PUSH1 0x00 2807 82 DUP3 2808 82 DUP3 2809 01 ADD 280A 83 DUP4 280B 81 DUP2 280C 10 LT 280D 15 ISZERO 280E 61 PUSH2 0x0b19 2811 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2805 stack[0] = 0x00 // @2809 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x0b19, if !(stack[-1] + stack[-2] < stack[-2]) label_2812: // Incoming jump from 0x2811, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[1] { @2814 memory[0x40:0x60] } 2812 60 PUSH1 0x40 2814 51 MLOAD 2815 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2836 81 DUP2 2837 52 MSTORE 2838 60 PUSH1 0x04 283A 01 ADD 283B 61 PUSH2 0x01c3 283E 90 SWAP1 283F 61 PUSH2 0x3f39 2842 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2837 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @283E stack[0] = 0x01c3 // @283E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3f39, returns to 0x01C3 label_2843: // Incoming jump from 0x2735 // Incoming jump from 0x27E8 // Incoming jump from 0x2787 // Inputs[2] // { // @2849 stack[-1] // @284D stack[-2] // } 2843 5B JUMPDEST 2844 60 PUSH1 0x00 2846 61 PUSH2 0x0b19 2849 82 DUP3 284A 61 PUSH2 0x0500 284D 85 DUP6 284E 67 PUSH8 0x0de0b6b3a7640000 2857 61 PUSH2 0x1bb2 285A 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2844 stack[0] = 0x00 // @2846 stack[1] = 0x0b19 // @2849 stack[2] = stack[-1] // @284A stack[3] = 0x0500 // @284D stack[4] = stack[-2] // @284E stack[5] = 0x0de0b6b3a7640000 // } // Block ends with call to 0x1bb2, returns to 0x0500 label_285B: // Incoming call from 0x22B4, returns to 0x22B5 // Incoming call from 0x28B9, returns to 0x28BA // Incoming jump from 0x17D4 // Incoming call from 0x21D9, returns to 0x21DA // Incoming call from 0x17D4, returns to 0x17D5 // Inputs[1] { @2873 stack[-1] } 285B 5B JUMPDEST 285C 60 PUSH1 0x00 285E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2873 82 DUP3 2874 16 AND 2875 15 ISZERO 2876 80 DUP1 2877 61 PUSH2 0x28a9 287A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @285C stack[0] = 0x00 // @2875 stack[1] = !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // } // Block ends with conditional jump to 0x28a9, if !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) label_287B: // Incoming jump from 0x287A, if not !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @2891 stack[-3] // @28AA stack[-2] // @28AD stack[-4] // } 287B 50 POP 287C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2891 82 DUP3 2892 16 AND 2893 73 PUSH20 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee 28A8 14 EQ 28A9 5B JUMPDEST 28AA 90 SWAP1 28AB 50 POP 28AC 5B JUMPDEST 28AD 91 SWAP2 28AE 90 SWAP1 28AF 50 POP 28B0 56 *JUMP // Stack delta = -3 // Outputs[1] { @28AD stack[-4] = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-4] label_28B1: // Incoming jump from 0x1967 // Incoming jump from 0x1D28 // Incoming jump from 0x1D28 // Inputs[1] { @28B5 stack[-3] } 28B1 5B JUMPDEST 28B2 61 PUSH2 0x28ba 28B5 83 DUP4 28B6 61 PUSH2 0x285b 28B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28B2 stack[0] = 0x28ba // @28B5 stack[1] = stack[-3] // } // Block ends with call to 0x285b, returns to 0x28BA label_28BA: // Incoming return from call to 0x285B at 0x28B9 // Inputs[1] { @28BB stack[-1] } 28BA 5B JUMPDEST 28BB 15 ISZERO 28BC 61 PUSH2 0x28f1 28BF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x28f1, if !stack[-1] label_28C0: // Incoming jump from 0x28BF, if not !stack[-1] // Inputs[1] { @28C2 memory[0x40:0x60] } 28C0 60 PUSH1 0x40 28C2 51 MLOAD 28C3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 28E4 81 DUP2 28E5 52 MSTORE 28E6 60 PUSH1 0x04 28E8 01 ADD 28E9 61 PUSH2 0x01c3 28EC 90 SWAP1 28ED 61 PUSH2 0x4015 28F0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @28E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @28EC stack[0] = 0x01c3 // @28EC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x4015, returns to 0x01C3 label_28F1: // Incoming jump from 0x28BF, if !stack[-1] // Inputs[4] // { // @28F6 stack[-3] // @2915 stack[-2] // @2916 stack[-1] // @2919 memory[0x40:0x60] // } 28F1 5B JUMPDEST 28F2 60 PUSH1 0x00 28F4 60 PUSH1 0x60 28F6 84 DUP5 28F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 290C 16 AND 290D 63 PUSH4 0x095ea7b3 2912 60 PUSH1 0xe0 2914 1B SHL 2915 85 DUP6 2916 85 DUP6 2917 60 PUSH1 0x40 2919 51 MLOAD 291A 60 PUSH1 0x24 291C 01 ADD 291D 61 PUSH2 0x2927 2920 92 SWAP3 2921 91 SWAP2 2922 90 SWAP1 2923 61 PUSH2 0x3ce9 2926 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @28F2 stack[0] = 0x00 // @28F4 stack[1] = 0x60 // @290C stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2914 stack[3] = 0x095ea7b3 << 0xe0 // @2920 stack[4] = 0x2927 // @2921 stack[5] = stack[-2] // @2922 stack[6] = stack[-1] // @2922 stack[7] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x3ce9, returns to 0x2927 label_2927: // Incoming return from call to 0x3CE9 at 0x2926 // Inputs[5] // { // @292B memory[0x40:0x60] // @294E stack[-1] // @295B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @299C stack[-2] // @29A6 memory[0x40:0x60] // } 2927 5B JUMPDEST 2928 60 PUSH1 0x40 292A 80 DUP1 292B 51 MLOAD 292C 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 294D 81 DUP2 294E 84 DUP5 294F 03 SUB 2950 01 ADD 2951 81 DUP2 2952 52 MSTORE 2953 91 SWAP2 2954 81 DUP2 2955 52 MSTORE 2956 60 PUSH1 0x20 2958 82 DUP3 2959 01 ADD 295A 80 DUP1 295B 51 MLOAD 295C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2979 16 AND 297A 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 299B 90 SWAP1 299C 94 SWAP5 299D 16 AND 299E 93 SWAP4 299F 90 SWAP1 29A0 93 SWAP4 29A1 17 OR 29A2 90 SWAP1 29A3 92 SWAP3 29A4 52 MSTORE 29A5 90 SWAP1 29A6 51 MLOAD 29A7 61 PUSH2 0x29b0 29AA 91 SWAP2 29AB 90 SWAP1 29AC 61 PUSH2 0x3b53 29AF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2952 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @2955 memory[0x40:0x60] = stack[-1] // @29A4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] & 0xffffffff00000000000000000000000000000000000000000000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @29AA stack[-2] = 0x29b0 // @29AB stack[0] = memory[0x40:0x60] // @29AB stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x3b53 29B0 5B JUMPDEST 29B1 60 PUSH1 0x00 29B3 60 PUSH1 0x40 29B5 51 MLOAD 29B6 80 DUP1 29B7 83 DUP4 29B8 03 SUB 29B9 81 DUP2 29BA 60 PUSH1 0x00 29BC 86 DUP7 29BD 5A GAS 29BE F1 CALL 29BF 91 SWAP2 29C0 50 POP 29C1 50 POP 29C2 3D RETURNDATASIZE 29C3 80 DUP1 29C4 60 PUSH1 0x00 29C6 81 DUP2 29C7 14 EQ 29C8 61 PUSH2 0x29ed 29CB 57 *JUMPI 29CC 60 PUSH1 0x40 29CE 51 MLOAD 29CF 91 SWAP2 29D0 50 POP 29D1 60 PUSH1 0x1f 29D3 19 NOT 29D4 60 PUSH1 0x3f 29D6 3D RETURNDATASIZE 29D7 01 ADD 29D8 16 AND 29D9 82 DUP3 29DA 01 ADD 29DB 60 PUSH1 0x40 29DD 52 MSTORE 29DE 3D RETURNDATASIZE 29DF 82 DUP3 29E0 52 MSTORE 29E1 3D RETURNDATASIZE 29E2 60 PUSH1 0x00 29E4 60 PUSH1 0x20 29E6 84 DUP5 29E7 01 ADD 29E8 3E RETURNDATACOPY 29E9 61 PUSH2 0x29f2 29EC 56 *JUMP 29ED 5B JUMPDEST 29EE 60 PUSH1 0x60 29F0 91 SWAP2 29F1 50 POP 29F2 5B JUMPDEST 29F3 50 POP 29F4 91 SWAP2 29F5 50 POP 29F6 91 SWAP2 29F7 50 POP 29F8 81 DUP2 29F9 15 ISZERO 29FA 80 DUP1 29FB 61 PUSH2 0x2a21 29FE 57 *JUMPI 29FF 50 POP 2A00 60 PUSH1 0x00 2A02 81 DUP2 2A03 51 MLOAD 2A04 11 GT 2A05 80 DUP1 2A06 15 ISZERO 2A07 61 PUSH2 0x2a21 2A0A 57 *JUMPI 2A0B 50 POP 2A0C 80 DUP1 2A0D 80 DUP1 2A0E 60 PUSH1 0x20 2A10 01 ADD 2A11 90 SWAP1 2A12 51 MLOAD 2A13 81 DUP2 2A14 01 ADD 2A15 90 SWAP1 2A16 61 PUSH2 0x2a1f 2A19 91 SWAP2 2A1A 90 SWAP1 2A1B 61 PUSH2 0x35a0 2A1E 56 *JUMP 2A1F 5B JUMPDEST 2A20 15 ISZERO 2A21 5B JUMPDEST 2A22 15 ISZERO 2A23 61 PUSH2 0x0778 2A26 57 *JUMPI 2A27 61 PUSH2 0x2a46 2A2A 85 DUP6 2A2B 63 PUSH4 0x095ea7b3 2A30 60 PUSH1 0xe0 2A32 1B SHL 2A33 86 DUP7 2A34 60 PUSH1 0x00 2A36 60 PUSH1 0x40 2A38 51 MLOAD 2A39 60 PUSH1 0x24 2A3B 01 ADD 2A3C 61 PUSH2 0x2322 2A3F 92 SWAP3 2A40 91 SWAP2 2A41 90 SWAP1 2A42 61 PUSH2 0x3d0f 2A45 56 *JUMP 2A46 5B JUMPDEST 2A47 61 PUSH2 0x0778 2A4A 85 DUP6 2A4B 63 PUSH4 0x095ea7b3 2A50 60 PUSH1 0xe0 2A52 1B SHL 2A53 86 DUP7 2A54 86 DUP7 2A55 60 PUSH1 0x40 2A57 51 MLOAD 2A58 60 PUSH1 0x24 2A5A 01 ADD 2A5B 61 PUSH2 0x2322 2A5E 92 SWAP3 2A5F 91 SWAP2 2A60 90 SWAP1 2A61 61 PUSH2 0x3ce9 2A64 56 *JUMP label_2A65: // Incoming jump from 0x2175 // Inputs[2] // { // @2A6B stack[-1] // @2A6E memory[0x40:0x60] // } 2A65 5B JUMPDEST 2A66 60 PUSH1 0x60 2A68 61 PUSH2 0x28a9 2A6B 82 DUP3 2A6C 60 PUSH1 0x40 2A6E 51 MLOAD 2A6F 60 PUSH1 0x20 2A71 01 ADD 2A72 61 PUSH2 0x2a7b 2A75 91 SWAP2 2A76 90 SWAP1 2A77 61 PUSH2 0x3cbf 2A7A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2A66 stack[0] = 0x60 // @2A68 stack[1] = 0x28a9 // @2A75 stack[2] = 0x2a7b // @2A76 stack[3] = stack[-1] // @2A76 stack[4] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3cbf, returns to 0x2A7B label_2A7B: // Incoming return from call to 0x3CBF at 0x2A7A // Inputs[2] // { // @2A7E memory[0x40:0x60] // @2A82 stack[-1] // } 2A7B 5B JUMPDEST 2A7C 60 PUSH1 0x40 2A7E 51 MLOAD 2A7F 60 PUSH1 0x20 2A81 81 DUP2 2A82 83 DUP4 2A83 03 SUB 2A84 03 SUB 2A85 81 DUP2 2A86 52 MSTORE 2A87 90 SWAP1 2A88 60 PUSH1 0x40 2A8A 52 MSTORE // Stack delta = +0 // Outputs[3] // { // @2A86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @2A87 stack[-1] = memory[0x40:0x60] // @2A8A memory[0x40:0x60] = stack[-1] // } // Block continues label_2A8B: // Incoming call from 0x2190, returns to 0x2191 // Incoming jump from 0x2A8A // Inputs[2] // { // @2A8C stack[-1] // @2A8D memory[stack[-1]:stack[-1] + 0x20] // } 2A8B 5B JUMPDEST 2A8C 80 DUP1 2A8D 51 MLOAD 2A8E 60 PUSH1 0x60 2A90 90 SWAP1 2A91 7F PUSH32 0x3031323334353637383961626364656600000000000000000000000000000000 2AB2 90 SWAP1 2AB3 82 DUP3 2AB4 90 SWAP1 2AB5 60 PUSH1 0x02 2AB7 90 SWAP1 2AB8 81 DUP2 2AB9 02 MUL 2ABA 01 ADD 2ABB 67 PUSH8 0xffffffffffffffff 2AC4 81 DUP2 2AC5 11 GT 2AC6 80 DUP1 2AC7 15 ISZERO 2AC8 61 PUSH2 0x2ad0 2ACB 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2A90 stack[0] = 0x60 // @2AB2 stack[1] = 0x3031323334353637383961626364656600000000000000000000000000000000 // @2AB4 stack[2] = 0x60 // @2ABA stack[3] = 0x02 * memory[stack[-1]:stack[-1] + 0x20] + 0x02 // @2AC5 stack[4] = 0x02 * memory[stack[-1]:stack[-1] + 0x20] + 0x02 > 0xffffffffffffffff // } // Block ends with conditional jump to 0x2ad0, if !(0x02 * memory[stack[-1]:stack[-1] + 0x20] + 0x02 > 0xffffffffffffffff) label_2ACC: // Incoming jump from 0x2ACB, if not !(0x02 * memory[stack[-1]:stack[-1] + 0x20] + 0x02 > 0xffffffffffffffff) // Inputs[1] { @2ACF memory[0x00:0x00] } 2ACC 60 PUSH1 0x00 2ACE 80 DUP1 2ACF FD *REVERT // Stack delta = +0 // Outputs[1] { @2ACF revert(memory[0x00:0x00]); } // Block terminates label_2AD0: // Incoming jump from 0x2ACB, if !(0x02 * memory[stack[-1]:stack[-1] + 0x20] + 0x02 > 0xffffffffffffffff) // Inputs[2] // { // @2AD4 memory[0x40:0x60] // @2AD5 stack[-2] // } 2AD0 5B JUMPDEST 2AD1 50 POP 2AD2 60 PUSH1 0x40 2AD4 51 MLOAD 2AD5 90 SWAP1 2AD6 80 DUP1 2AD7 82 DUP3 2AD8 52 MSTORE 2AD9 80 DUP1 2ADA 60 PUSH1 0x1f 2ADC 01 ADD 2ADD 60 PUSH1 0x1f 2ADF 19 NOT 2AE0 16 AND 2AE1 60 PUSH1 0x20 2AE3 01 ADD 2AE4 82 DUP3 2AE5 01 ADD 2AE6 60 PUSH1 0x40 2AE8 52 MSTORE 2AE9 80 DUP1 2AEA 15 ISZERO 2AEB 61 PUSH2 0x2afb 2AEE 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2AD5 stack[-2] = memory[0x40:0x60] // @2AD5 stack[-1] = stack[-2] // @2AD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2AE8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-2]) // } // Block ends with conditional jump to 0x2afb, if !stack[-2] label_2AEF: // Incoming jump from 0x2AEE, if not !stack[-2] // Inputs[6] // { // @2AF1 stack[-2] // @2AF3 stack[-1] // @2AF5 msg.data.length // @2AF7 msg.data[msg.data.length:msg.data.length + stack[-1]] // @2AFD stack[-3] // @2B24 memory[stack[-2]:stack[-2] + 0x20] // } 2AEF 60 PUSH1 0x20 2AF1 82 DUP3 2AF2 01 ADD 2AF3 81 DUP2 2AF4 80 DUP1 2AF5 36 CALLDATASIZE 2AF6 83 DUP4 2AF7 37 CALLDATACOPY 2AF8 01 ADD 2AF9 90 SWAP1 2AFA 50 POP 2AFB 5B JUMPDEST 2AFC 50 POP 2AFD 90 SWAP1 2AFE 50 POP 2AFF 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 2B20 81 DUP2 2B21 60 PUSH1 0x00 2B23 81 DUP2 2B24 51 MLOAD 2B25 81 DUP2 2B26 10 LT 2B27 61 PUSH2 0x2b2c 2B2A 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2AF7 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @2AFD stack[-3] = stack[-2] // @2AFF stack[-2] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @2B20 stack[-1] = stack[-2] // @2B21 stack[0] = 0x00 // } // Block ends with conditional jump to 0x2b2c, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_2B2B: // Incoming jump from 0x2B2A, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2B2A, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 2B2B FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B2B assert(); } // Block terminates label_2B2C: // Incoming jump from 0x2B2A, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2B2A, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @2B2F stack[-1] // @2B30 stack[-2] // @2B31 stack[-3] // @2B7D stack[-4] // @2B81 memory[stack[-4]:stack[-4] + 0x20] // } 2B2C 5B JUMPDEST 2B2D 60 PUSH1 0x20 2B2F 01 ADD 2B30 01 ADD 2B31 90 SWAP1 2B32 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2B52 19 NOT 2B53 16 AND 2B54 90 SWAP1 2B55 81 DUP2 2B56 60 PUSH1 0x00 2B58 1A BYTE 2B59 90 SWAP1 2B5A 53 MSTORE8 2B5B 50 POP 2B5C 7F PUSH32 0x7800000000000000000000000000000000000000000000000000000000000000 2B7D 81 DUP2 2B7E 60 PUSH1 0x01 2B80 81 DUP2 2B81 51 MLOAD 2B82 81 DUP2 2B83 10 LT 2B84 61 PUSH2 0x2b89 2B87 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2B5A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2B5C stack[-3] = 0x7800000000000000000000000000000000000000000000000000000000000000 // @2B7D stack[-2] = stack[-4] // @2B7E stack[-1] = 0x01 // } // Block ends with conditional jump to 0x2b89, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_2B88: // Incoming jump from 0x2B87, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 2B88 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B88 assert(); } // Block terminates label_2B89: // Incoming jump from 0x2B87, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @2B8C stack[-1] // @2B8D stack[-2] // @2B8E stack[-3] // @2BBC stack[-7] // @2BBD memory[stack[-7]:stack[-7] + 0x20] // } 2B89 5B JUMPDEST 2B8A 60 PUSH1 0x20 2B8C 01 ADD 2B8D 01 ADD 2B8E 90 SWAP1 2B8F 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2BAF 19 NOT 2BB0 16 AND 2BB1 90 SWAP1 2BB2 81 DUP2 2BB3 60 PUSH1 0x00 2BB5 1A BYTE 2BB6 90 SWAP1 2BB7 53 MSTORE8 2BB8 50 POP 2BB9 60 PUSH1 0x00 2BBB 5B JUMPDEST 2BBC 84 DUP5 2BBD 51 MLOAD 2BBE 81 DUP2 2BBF 10 LT 2BC0 15 ISZERO 2BC1 61 PUSH2 0x2cbe 2BC4 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2BB7 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2BB9 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x2cbe, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) label_2BC5: // Incoming jump from 0x2BC4, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x2BC4, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @2BC5 stack[-3] // @2BC8 stack[-5] // @2BC9 stack[-1] // @2BCB memory[stack[-5]:stack[-5] + 0x20] // } 2BC5 82 DUP3 2BC6 60 PUSH1 0x04 2BC8 86 DUP7 2BC9 83 DUP4 2BCA 81 DUP2 2BCB 51 MLOAD 2BCC 81 DUP2 2BCD 10 LT 2BCE 61 PUSH2 0x2bd3 2BD1 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2BC5 stack[0] = stack[-3] // @2BC6 stack[1] = 0x04 // @2BC8 stack[2] = stack[-5] // @2BC9 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x2bd3, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2BD2: // Incoming jump from 0x2BD1, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 2BD2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BD2 assert(); } // Block terminates label_2BD3: // Incoming jump from 0x2BD1, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @2BD4 stack[-2] // @2BD4 stack[-1] // @2BD8 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @2BFB stack[-3] // } 2BD3 5B JUMPDEST 2BD4 01 ADD 2BD5 60 PUSH1 0x20 2BD7 01 ADD 2BD8 51 MLOAD 2BD9 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 2BFA 16 AND 2BFB 90 SWAP1 2BFC 1C SHR 2BFD 60 PUSH1 0xf8 2BFF 1C SHR 2C00 60 PUSH1 0x10 2C02 81 DUP2 2C03 10 LT 2C04 61 PUSH2 0x2c09 2C07 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2BFF stack[-3] = ((0xff00000000000000000000000000000000000000000000000000000000000000 & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20]) >> stack[-3]) >> 0xf8 } // Block ends with conditional jump to 0x2c09, if ((0xff00000000000000000000000000000000000000000000000000000000000000 & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20]) >> stack[-3]) >> 0xf8 < 0x10 label_2C08: // Incoming jump from 0x2C07, if not ((0xff00000000000000000000000000000000000000000000000000000000000000 & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20]) >> stack[-3]) >> 0xf8 < 0x10 2C08 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C08 assert(); } // Block terminates label_2C09: // Incoming jump from 0x2C07, if ((0xff00000000000000000000000000000000000000000000000000000000000000 & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20]) >> stack[-3]) >> 0xf8 < 0x10 // Inputs[5] // { // @2C0A stack[-2] // @2C0A stack[-1] // @2C0E stack[-4] // @2C0F stack[-3] // @2C17 memory[stack[-4]:stack[-4] + 0x20] // } 2C09 5B JUMPDEST 2C0A 1A BYTE 2C0B 60 PUSH1 0xf8 2C0D 1B SHL 2C0E 82 DUP3 2C0F 82 DUP3 2C10 60 PUSH1 0x02 2C12 02 MUL 2C13 60 PUSH1 0x02 2C15 01 ADD 2C16 81 DUP2 2C17 51 MLOAD 2C18 81 DUP2 2C19 10 LT 2C1A 61 PUSH2 0x2c1f 2C1D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2C0D stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @2C0E stack[-1] = stack[-4] // @2C15 stack[0] = 0x02 + 0x02 * stack[-3] // } // Block ends with conditional jump to 0x2c1f, if 0x02 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2C1E: // Incoming jump from 0x2C1D, if not 0x02 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 2C1E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C1E assert(); } // Block terminates label_2C1F: // Incoming jump from 0x2C1D, if 0x02 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @2C22 stack[-1] // @2C23 stack[-2] // @2C24 stack[-3] // @2C4F stack[-6] // @2C50 stack[-8] // @2C51 stack[-4] // @2C53 memory[stack[-8]:stack[-8] + 0x20] // } 2C1F 5B JUMPDEST 2C20 60 PUSH1 0x20 2C22 01 ADD 2C23 01 ADD 2C24 90 SWAP1 2C25 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2C45 19 NOT 2C46 16 AND 2C47 90 SWAP1 2C48 81 DUP2 2C49 60 PUSH1 0x00 2C4B 1A BYTE 2C4C 90 SWAP1 2C4D 53 MSTORE8 2C4E 50 POP 2C4F 82 DUP3 2C50 85 DUP6 2C51 82 DUP3 2C52 81 DUP2 2C53 51 MLOAD 2C54 81 DUP2 2C55 10 LT 2C56 61 PUSH2 0x2c5b 2C59 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2C4D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2C4F stack[-3] = stack[-6] // @2C50 stack[-2] = stack[-8] // @2C51 stack[-1] = stack[-4] // } // Block ends with conditional jump to 0x2c5b, if stack[-4] < memory[stack[-8]:stack[-8] + 0x20] label_2C5A: // Incoming jump from 0x2C59, if not stack[-4] < memory[stack[-8]:stack[-8] + 0x20] 2C5A FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C5A assert(); } // Block terminates label_2C5B: // Incoming jump from 0x2C59, if stack[-4] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[3] // { // @2C5E stack[-2] // @2C5F stack[-1] // @2C61 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 2C5B 5B JUMPDEST 2C5C 60 PUSH1 0x20 2C5E 91 SWAP2 2C5F 01 ADD 2C60 01 ADD 2C61 51 MLOAD 2C62 60 PUSH1 0xf8 2C64 1C SHR 2C65 60 PUSH1 0x0f 2C67 16 AND 2C68 60 PUSH1 0x10 2C6A 81 DUP2 2C6B 10 LT 2C6C 61 PUSH2 0x2c71 2C6F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2C67 stack[-2] = 0x0f & (memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] >> 0xf8) } // Block ends with conditional jump to 0x2c71, if 0x0f & (memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] >> 0xf8) < 0x10 label_2C70: // Incoming jump from 0x2C6F, if not 0x0f & (memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] >> 0xf8) < 0x10 2C70 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C70 assert(); } // Block terminates label_2C71: // Incoming jump from 0x2C6F, if 0x0f & (memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] >> 0xf8) < 0x10 // Inputs[5] // { // @2C72 stack[-2] // @2C72 stack[-1] // @2C76 stack[-4] // @2C77 stack[-3] // @2C7F memory[stack[-4]:stack[-4] + 0x20] // } 2C71 5B JUMPDEST 2C72 1A BYTE 2C73 60 PUSH1 0xf8 2C75 1B SHL 2C76 82 DUP3 2C77 82 DUP3 2C78 60 PUSH1 0x02 2C7A 02 MUL 2C7B 60 PUSH1 0x03 2C7D 01 ADD 2C7E 81 DUP2 2C7F 51 MLOAD 2C80 81 DUP2 2C81 10 LT 2C82 61 PUSH2 0x2c87 2C85 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2C75 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @2C76 stack[-1] = stack[-4] // @2C7D stack[0] = 0x03 + 0x02 * stack[-3] // } // Block ends with conditional jump to 0x2c87, if 0x03 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2C86: // Incoming jump from 0x2C85, if not 0x03 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 2C86 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C86 assert(); } // Block terminates label_2C87: // Incoming jump from 0x2C85, if 0x03 + 0x02 * stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @2C8A stack[-1] // @2C8B stack[-2] // @2C8C stack[-3] // @2CB9 stack[-4] // } 2C87 5B JUMPDEST 2C88 60 PUSH1 0x20 2C8A 01 ADD 2C8B 01 ADD 2C8C 90 SWAP1 2C8D 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2CAD 19 NOT 2CAE 16 AND 2CAF 90 SWAP1 2CB0 81 DUP2 2CB1 60 PUSH1 0x00 2CB3 1A BYTE 2CB4 90 SWAP1 2CB5 53 MSTORE8 2CB6 50 POP 2CB7 60 PUSH1 0x01 2CB9 01 ADD 2CBA 61 PUSH2 0x2bbb 2CBD 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2CB5 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2CB9 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x2bbb label_2CBE: // Incoming jump from 0x2BC4, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x2BC4, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @2CC0 stack[-6] // @2CC0 stack[-2] // @2CC1 stack[-5] // } 2CBE 5B JUMPDEST 2CBF 50 POP 2CC0 93 SWAP4 2CC1 92 SWAP3 2CC2 50 POP 2CC3 50 POP 2CC4 50 POP 2CC5 56 *JUMP // Stack delta = -5 // Outputs[1] { @2CC0 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_2CC6: // Incoming jump from 0x23A3 // Inputs[3] // { // @2CCB stack[-2] // @2CE2 stack[-1] // @2CE5 memory[0x40:0x60] // } 2CC6 5B JUMPDEST 2CC7 60 PUSH1 0x00 2CC9 60 PUSH1 0x60 2CCB 83 DUP4 2CCC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CE1 16 AND 2CE2 83 DUP4 2CE3 60 PUSH1 0x40 2CE5 51 MLOAD 2CE6 61 PUSH2 0x2cef 2CE9 91 SWAP2 2CEA 90 SWAP1 2CEB 61 PUSH2 0x3b53 2CEE 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2CC7 stack[0] = 0x00 // @2CC9 stack[1] = 0x60 // @2CE1 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2CE9 stack[3] = 0x2cef // @2CEA stack[4] = stack[-1] // @2CEA stack[5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x3b53 2CEF 5B JUMPDEST 2CF0 60 PUSH1 0x00 2CF2 60 PUSH1 0x40 2CF4 51 MLOAD 2CF5 80 DUP1 2CF6 83 DUP4 2CF7 03 SUB 2CF8 81 DUP2 2CF9 60 PUSH1 0x00 2CFB 86 DUP7 2CFC 5A GAS 2CFD F1 CALL 2CFE 91 SWAP2 2CFF 50 POP 2D00 50 POP 2D01 3D RETURNDATASIZE 2D02 80 DUP1 2D03 60 PUSH1 0x00 2D05 81 DUP2 2D06 14 EQ 2D07 61 PUSH2 0x2d2c 2D0A 57 *JUMPI 2D0B 60 PUSH1 0x40 2D0D 51 MLOAD 2D0E 91 SWAP2 2D0F 50 POP 2D10 60 PUSH1 0x1f 2D12 19 NOT 2D13 60 PUSH1 0x3f 2D15 3D RETURNDATASIZE 2D16 01 ADD 2D17 16 AND 2D18 82 DUP3 2D19 01 ADD 2D1A 60 PUSH1 0x40 2D1C 52 MSTORE 2D1D 3D RETURNDATASIZE 2D1E 82 DUP3 2D1F 52 MSTORE 2D20 3D RETURNDATASIZE 2D21 60 PUSH1 0x00 2D23 60 PUSH1 0x20 2D25 84 DUP5 2D26 01 ADD 2D27 3E RETURNDATACOPY 2D28 61 PUSH2 0x2d31 2D2B 56 *JUMP 2D2C 5B JUMPDEST 2D2D 60 PUSH1 0x60 2D2F 91 SWAP2 2D30 50 POP 2D31 5B JUMPDEST 2D32 50 POP 2D33 91 SWAP2 2D34 50 POP 2D35 91 SWAP2 2D36 50 POP 2D37 81 DUP2 2D38 61 PUSH2 0x2d6d 2D3B 57 *JUMPI 2D3C 60 PUSH1 0x40 2D3E 51 MLOAD 2D3F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2D60 81 DUP2 2D61 52 MSTORE 2D62 60 PUSH1 0x04 2D64 01 ADD 2D65 61 PUSH2 0x01c3 2D68 90 SWAP1 2D69 61 PUSH2 0x41f3 2D6C 56 *JUMP 2D6D 5B JUMPDEST 2D6E 80 DUP1 2D6F 51 MLOAD 2D70 15 ISZERO 2D71 61 PUSH2 0x0a5d 2D74 57 *JUMPI 2D75 80 DUP1 2D76 80 DUP1 2D77 60 PUSH1 0x20 2D79 01 ADD 2D7A 90 SWAP1 2D7B 51 MLOAD 2D7C 81 DUP2 2D7D 01 ADD 2D7E 90 SWAP1 2D7F 61 PUSH2 0x2d88 2D82 91 SWAP2 2D83 90 SWAP1 2D84 61 PUSH2 0x35a0 2D87 56 *JUMP 2D88 5B JUMPDEST 2D89 61 PUSH2 0x0a5d 2D8C 57 *JUMPI 2D8D 60 PUSH1 0x40 2D8F 51 MLOAD 2D90 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DB1 81 DUP2 2DB2 52 MSTORE 2DB3 60 PUSH1 0x04 2DB5 01 ADD 2DB6 61 PUSH2 0x01c3 2DB9 90 SWAP1 2DBA 61 PUSH2 0x414e 2DBD 56 *JUMP 2DBE 5B JUMPDEST 2DBF 60 PUSH1 0x00 2DC1 67 PUSH8 0x0de0b6b3a7640000 2DCA 61 PUSH2 0x2dd3 2DCD 84 DUP5 2DCE 84 DUP5 2DCF 61 PUSH2 0x1bb2 2DD2 56 *JUMP 2DD3 5B JUMPDEST 2DD4 81 DUP2 2DD5 61 PUSH2 0x1c4a 2DD8 57 *JUMPI 2DD9 FE *ASSERT 2DDA 5B JUMPDEST 2DDB 60 PUSH1 0x00 2DDD 80 DUP1 2DDE 61 PUSH2 0x2def 2DE1 86 DUP7 2DE2 61 PUSH2 0x0500 2DE5 89 DUP10 2DE6 61 PUSH2 0x0b13 2DE9 87 DUP8 2DEA 8C DUP13 2DEB 61 PUSH2 0x2dbe 2DEE 56 *JUMP 2DEF 5B JUMPDEST 2DF0 90 SWAP1 2DF1 50 POP 2DF2 60 PUSH1 0x00 2DF4 61 PUSH2 0x2e0e 2DF7 61 PUSH2 0x2e08 2DFA 67 PUSH8 0x0de0b6b3a7640000 2E03 86 DUP7 2E04 61 PUSH2 0x1c52 2E07 56 *JUMP 2E08 5B JUMPDEST 2E09 88 DUP9 2E0A 61 PUSH2 0x2dbe 2E0D 56 *JUMP 2E0E 5B JUMPDEST 2E0F 90 SWAP1 2E10 50 POP 2E11 60 PUSH1 0x01 2E13 85 DUP6 2E14 15 ISZERO 2E15 61 PUSH2 0x2e29 2E18 57 *JUMPI 2E19 61 PUSH2 0x2e22 2E1C 82 DUP3 2E1D 88 DUP9 2E1E 61 PUSH2 0x2804 2E21 56 *JUMP 2E22 5B JUMPDEST 2E23 91 SWAP2 2E24 50 POP 2E25 61 PUSH2 0x2e36 2E28 56 *JUMP 2E29 5B JUMPDEST 2E2A 61 PUSH2 0x2e33 2E2D 83 DUP4 2E2E 88 DUP9 2E2F 61 PUSH2 0x2804 2E32 56 *JUMP 2E33 5B JUMPDEST 2E34 92 SWAP3 2E35 50 POP 2E36 5B JUMPDEST 2E37 82 DUP3 2E38 82 DUP3 2E39 10 LT 2E3A 61 PUSH2 0x2e52 2E3D 57 *JUMPI 2E3E 61 PUSH2 0x2e47 2E41 82 DUP3 2E42 84 DUP5 2E43 61 PUSH2 0x1c52 2E46 56 *JUMP 2E47 5B JUMPDEST 2E48 91 SWAP2 2E49 50 POP 2E4A 60 PUSH1 0x01 2E4C 90 SWAP1 2E4D 50 POP 2E4E 61 PUSH2 0x2e63 2E51 56 *JUMP 2E52 5B JUMPDEST 2E53 61 PUSH2 0x2e5c 2E56 83 DUP4 2E57 83 DUP4 2E58 61 PUSH2 0x1c52 2E5B 56 *JUMP 2E5C 5B JUMPDEST 2E5D 91 SWAP2 2E5E 50 POP 2E5F 60 PUSH1 0x00 2E61 90 SWAP1 2E62 50 POP 2E63 5B JUMPDEST 2E64 60 PUSH1 0x00 2E66 61 PUSH2 0x2e92 2E69 61 PUSH2 0x2e7f 2E6C 60 PUSH1 0x04 2E6E 61 PUSH2 0x0b13 2E71 67 PUSH8 0x0de0b6b3a7640000 2E7A 8A DUP11 2E7B 61 PUSH2 0x1c52 2E7E 56 *JUMP 2E7F 5B JUMPDEST 2E80 61 PUSH2 0x2e8d 2E83 8C DUP13 2E84 61 PUSH2 0x0b13 2E87 8A DUP11 2E88 8F DUP16 2E89 61 PUSH2 0x2dbe 2E8C 56 *JUMP 2E8D 5B JUMPDEST 2E8E 61 PUSH2 0x2dbe 2E91 56 *JUMP 2E92 5B JUMPDEST 2E93 90 SWAP1 2E94 50 POP 2E95 61 PUSH2 0x2eaa 2E98 61 PUSH2 0x2ea5 2E9B 82 DUP3 2E9C 61 PUSH2 0x16ce 2E9F 86 DUP7 2EA0 80 DUP1 2EA1 61 PUSH2 0x1bb2 2EA4 56 *JUMP 2EA5 5B JUMPDEST 2EA6 61 PUSH2 0x2f77 2EA9 56 *JUMP 2EAA 5B JUMPDEST 2EAB 90 SWAP1 2EAC 50 POP 2EAD 60 PUSH1 0x00 2EAF 61 PUSH2 0x2ec5 2EB2 60 PUSH1 0x02 2EB4 61 PUSH2 0x0b13 2EB7 67 PUSH8 0x0de0b6b3a7640000 2EC0 8A DUP11 2EC1 61 PUSH2 0x1c52 2EC4 56 *JUMP 2EC5 5B JUMPDEST 2EC6 90 SWAP1 2EC7 50 POP 2EC8 60 PUSH1 0x00 2ECA 83 DUP4 2ECB 15 ISZERO 2ECC 61 PUSH2 0x2ee0 2ECF 57 *JUMPI 2ED0 61 PUSH2 0x2ed9 2ED3 85 DUP6 2ED4 84 DUP5 2ED5 61 PUSH2 0x2804 2ED8 56 *JUMP 2ED9 5B JUMPDEST 2EDA 90 SWAP1 2EDB 50 POP 2EDC 61 PUSH2 0x2eed 2EDF 56 *JUMP 2EE0 5B JUMPDEST 2EE1 61 PUSH2 0x2eea 2EE4 83 DUP4 2EE5 86 DUP7 2EE6 61 PUSH2 0x1c52 2EE9 56 *JUMP 2EEA 5B JUMPDEST 2EEB 90 SWAP1 2EEC 50 POP 2EED 5B JUMPDEST 2EEE 88 DUP9 2EEF 15 ISZERO 2EF0 61 PUSH2 0x2f0a 2EF3 57 *JUMPI 2EF4 61 PUSH2 0x2efd 2EF7 81 DUP2 2EF8 83 DUP4 2EF9 61 PUSH2 0x2843 2EFC 56 *JUMP 2EFD 5B JUMPDEST 2EFE 96 SWAP7 2EFF 50 POP 2F00 50 POP 2F01 50 POP 2F02 50 POP 2F03 50 POP 2F04 50 POP 2F05 50 POP 2F06 61 PUSH2 0x16d9 2F09 56 *JUMP 2F0A 5B JUMPDEST 2F0B 61 PUSH2 0x2efd 2F0E 81 DUP2 2F0F 83 DUP4 2F10 61 PUSH2 0x2fd1 2F13 56 *JUMP 2F14 5B JUMPDEST 2F15 60 PUSH1 0x00 2F17 80 DUP1 2F18 61 PUSH2 0x2f25 2F1B 84 DUP5 2F1C 61 PUSH2 0x2e8d 2F1F 88 DUP9 2F20 88 DUP9 2F21 61 PUSH2 0x1c52 2F24 56 *JUMP 2F25 5B JUMPDEST 2F26 90 SWAP1 2F27 50 POP 2F28 60 PUSH1 0x00 2F2A 61 PUSH2 0x2f40 2F2D 61 PUSH2 0x2f3a 2F30 88 DUP9 2F31 61 PUSH2 0x0500 2F34 8B DUP12 2F35 80 DUP1 2F36 61 PUSH2 0x1bb2 2F39 56 *JUMP 2F3A 5B JUMPDEST 2F3B 87 DUP8 2F3C 61 PUSH2 0x2fd1 2F3F 56 *JUMP 2F40 5B JUMPDEST 2F41 90 SWAP1 2F42 50 POP 2F43 60 PUSH1 0x00 2F45 61 PUSH2 0x2f4e 2F48 85 DUP6 2F49 83 DUP4 2F4A 61 PUSH2 0x2dbe 2F4D 56 *JUMP 2F4E 5B JUMPDEST 2F4F 90 SWAP1 2F50 50 POP 2F51 61 PUSH2 0x2f6a 2F54 83 DUP4 2F55 61 PUSH2 0x2e8d 2F58 83 DUP4 2F59 61 PUSH2 0x16ce 2F5C 67 PUSH8 0x0de0b6b3a7640000 2F65 8A DUP11 2F66 61 PUSH2 0x1c52 2F69 56 *JUMP 2F6A 5B JUMPDEST 2F6B 99 SWAP10 2F6C 98 SWAP9 2F6D 50 POP 2F6E 50 POP 2F6F 50 POP 2F70 50 POP 2F71 50 POP 2F72 50 POP 2F73 50 POP 2F74 50 POP 2F75 50 POP 2F76 56 *JUMP 2F77 5B JUMPDEST 2F78 60 PUSH1 0x00 2F7A 60 PUSH1 0x03 2F7C 82 DUP3 2F7D 11 GT 2F7E 15 ISZERO 2F7F 61 PUSH2 0x2fbb 2F82 57 *JUMPI 2F83 81 DUP2 2F84 60 PUSH1 0x01 2F86 60 PUSH1 0x02 2F88 82 DUP3 2F89 04 DIV 2F8A 01 ADD 2F8B 5B JUMPDEST 2F8C 81 DUP2 2F8D 81 DUP2 2F8E 10 LT 2F8F 15 ISZERO 2F90 61 PUSH2 0x2fb3 2F93 57 *JUMPI 2F94 80 DUP1 2F95 91 SWAP2 2F96 50 POP 2F97 60 PUSH1 0x02 2F99 81 DUP2 2F9A 82 DUP3 2F9B 86 DUP7 2F9C 81 DUP2 2F9D 61 PUSH2 0x2fa2 2FA0 57 *JUMPI 2FA1 FE *ASSERT 2FA2 5B JUMPDEST 2FA3 04 DIV 2FA4 01 ADD 2FA5 81 DUP2 2FA6 61 PUSH2 0x2fab 2FA9 57 *JUMPI 2FAA FE *ASSERT 2FAB 5B JUMPDEST 2FAC 04 DIV 2FAD 90 SWAP1 2FAE 50 POP 2FAF 61 PUSH2 0x2f8b 2FB2 56 *JUMP 2FB3 5B JUMPDEST 2FB4 50 POP 2FB5 90 SWAP1 2FB6 50 POP 2FB7 61 PUSH2 0x28ac 2FBA 56 *JUMP 2FBB 5B JUMPDEST 2FBC 81 DUP2 2FBD 15 ISZERO 2FBE 61 PUSH2 0x2fc9 2FC1 57 *JUMPI 2FC2 50 POP 2FC3 60 PUSH1 0x01 2FC5 61 PUSH2 0x28ac 2FC8 56 *JUMP 2FC9 5B JUMPDEST 2FCA 50 POP 2FCB 60 PUSH1 0x00 2FCD 61 PUSH2 0x28ac 2FD0 56 *JUMP 2FD1 5B JUMPDEST 2FD2 60 PUSH1 0x00 2FD4 61 PUSH2 0x0b19 2FD7 61 PUSH2 0x2fe8 2FDA 84 DUP5 2FDB 67 PUSH8 0x0de0b6b3a7640000 2FE4 61 PUSH2 0x1bb2 2FE7 56 *JUMP 2FE8 5B JUMPDEST 2FE9 83 DUP4 2FEA 60 PUSH1 0x00 2FEC 80 DUP1 2FED 61 PUSH2 0x2ff6 2FF0 84 DUP5 2FF1 84 DUP5 2FF2 61 PUSH2 0x1c06 2FF5 56 *JUMP 2FF6 5B JUMPDEST 2FF7 90 SWAP1 2FF8 50 POP 2FF9 82 DUP3 2FFA 81 DUP2 2FFB 02 MUL 2FFC 84 DUP5 2FFD 03 SUB 2FFE 80 DUP1 2FFF 15 ISZERO 3000 61 PUSH2 0x300e 3003 57 *JUMPI 3004 50 POP 3005 60 PUSH1 0x01 3007 01 ADD 3008 90 SWAP1 3009 50 POP 300A 61 PUSH2 0x0b1c 300D 56 *JUMP 300E 5B JUMPDEST 300F 50 POP 3010 90 SWAP1 3011 50 POP 3012 61 PUSH2 0x0b1c 3015 56 *JUMP label_3016: // Incoming call from 0x0720, returns to 0x0721 // Incoming call from 0x0539, returns to 0x053A // Incoming call from 0x061F, returns to 0x0620 // Incoming call from 0x0720, returns to 0x0721 // Inputs[2] // { // @3019 memory[0x40:0x60] // @303C stack[-1] // } 3016 5B JUMPDEST 3017 60 PUSH1 0x40 3019 51 MLOAD 301A 80 DUP1 301B 60 PUSH1 0x80 301D 01 ADD 301E 60 PUSH1 0x40 3020 52 MSTORE 3021 80 DUP1 3022 60 PUSH1 0x00 3024 81 DUP2 3025 52 MSTORE 3026 60 PUSH1 0x20 3028 01 ADD 3029 60 PUSH1 0x00 302B 81 DUP2 302C 52 MSTORE 302D 60 PUSH1 0x20 302F 01 ADD 3030 60 PUSH1 0x00 3032 81 DUP2 3033 52 MSTORE 3034 60 PUSH1 0x20 3036 01 ADD 3037 60 PUSH1 0x60 3039 81 DUP2 303A 52 MSTORE 303B 50 POP 303C 90 SWAP1 303D 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @3020 memory[0x40:0x60] = 0x80 + memory[0x40:0x60] // @3025 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @302C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @3033 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @303A memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x60 // @303C stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_303E: // Incoming call from 0x1187, returns to 0x1188 // Inputs[1] { @3041 memory[0x40:0x60] } 303E 5B JUMPDEST 303F 60 PUSH1 0x40 3041 51 MLOAD 3042 80 DUP1 3043 60 PUSH1 0xe0 3045 01 ADD 3046 60 PUSH1 0x40 3048 52 MSTORE 3049 80 DUP1 304A 60 PUSH1 0x00 304C 81 DUP2 304D 52 MSTORE 304E 60 PUSH1 0x20 3050 01 ADD 3051 60 PUSH1 0x00 3053 81 DUP2 3054 52 MSTORE 3055 60 PUSH1 0x20 3057 01 ADD 3058 60 PUSH1 0x00 305A 81 DUP2 305B 52 MSTORE 305C 60 PUSH1 0x20 305E 01 ADD 305F 60 PUSH1 0x00 3061 81 DUP2 3062 52 MSTORE 3063 60 PUSH1 0x20 3065 01 ADD 3066 60 PUSH1 0x00 3068 81 DUP2 3069 52 MSTORE 306A 60 PUSH1 0x20 306C 01 ADD 306D 60 PUSH1 0x00 306F 81 DUP2 3070 52 MSTORE 3071 60 PUSH1 0x20 3073 01 ADD 3074 60 PUSH1 0x00 3076 60 PUSH1 0x02 3078 81 DUP2 3079 11 GT 307A 15 ISZERO 307B 61 PUSH2 0x3080 307E 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @3041 stack[0] = memory[0x40:0x60] // @3048 memory[0x40:0x60] = 0xe0 + memory[0x40:0x60] // @304D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @3054 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @305B memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @3062 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @3069 memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @3070 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @3073 stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3074 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3080, if !(0x00 > 0x02) label_307F: // Incoming jump from 0x307E, if not !(0x00 > 0x02) 307F FE *ASSERT // Stack delta = +0 // Outputs[1] { @307F assert(); } // Block terminates label_3080: // Incoming jump from 0x307E, if !(0x00 > 0x02) // Inputs[4] // { // @3081 stack[-1] // @3081 stack[-2] // @3083 stack[-4] // @3083 stack[-3] // } 3080 5B JUMPDEST 3081 90 SWAP1 3082 52 MSTORE 3083 90 SWAP1 3084 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3082 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @3083 stack[-4] = stack[-3] // } // Block ends with unconditional jump to stack[-4] label_3085: // Incoming call from 0x1C9D, returns to 0x1C9E // Incoming call from 0x1CA5, returns to 0x1CA6 // Inputs[4] // { // @3088 memory[0x40:0x60] // @3099 msg.data.length // @309B msg.data[msg.data.length:msg.data.length + 0x02 * 0x20] // @309E stack[-1] // } 3085 5B JUMPDEST 3086 60 PUSH1 0x40 3088 51 MLOAD 3089 80 DUP1 308A 60 PUSH1 0x40 308C 01 ADD 308D 60 PUSH1 0x40 308F 52 MSTORE 3090 80 DUP1 3091 60 PUSH1 0x02 3093 90 SWAP1 3094 60 PUSH1 0x20 3096 82 DUP3 3097 02 MUL 3098 80 DUP1 3099 36 CALLDATASIZE 309A 83 DUP4 309B 37 CALLDATACOPY 309C 50 POP 309D 91 SWAP2 309E 92 SWAP3 309F 91 SWAP2 30A0 50 POP 30A1 50 POP 30A2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @308F memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @309B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x02 * 0x20] = msg.data[msg.data.length:msg.data.length + 0x02 * 0x20] // @309E stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_30A3: // Incoming call from 0x371C, returns to 0x371D // Incoming call from 0x39AB, returns to 0x39AC // Inputs[2] // { // @30A6 stack[-2] // @30A9 stack[-1] // } 30A3 5B JUMPDEST 30A4 60 PUSH1 0x00 30A6 82 DUP3 30A7 60 PUSH1 0x1f 30A9 83 DUP4 30AA 01 ADD 30AB 12 SLT 30AC 61 PUSH2 0x30b3 30AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30A4 stack[0] = 0x00 } // Block ends with conditional jump to 0x30b3, if stack[-1] + 0x1f i< stack[-2] label_30B0: // Incoming jump from 0x30AF, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @30B0 stack[-1] // @30B2 memory[stack[-1]:stack[-1] + stack[-1]] // } 30B0 80 DUP1 30B1 81 DUP2 30B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @30B2 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_30B3: // Incoming jump from 0x30AF, if stack[-1] + 0x1f i< stack[-2] 30B3 5B JUMPDEST 30B4 61 PUSH2 0x30bd 30B7 60 PUSH1 0x40 30B9 61 PUSH2 0x43ab 30BC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @30B4 stack[0] = 0x30bd // @30B7 stack[1] = 0x40 // } // Block ends with call to 0x43ab, returns to 0x30BD label_30BD: // Incoming return from call to 0x43AB at 0x30BC // Inputs[4] // { // @30BE stack[-2] // @30BE stack[-1] // @30C1 stack[-3] // @30C2 stack[-4] // } 30BD 5B JUMPDEST 30BE 90 SWAP1 30BF 50 POP 30C0 80 DUP1 30C1 82 DUP3 30C2 84 DUP5 30C3 60 PUSH1 0x40 30C5 85 DUP6 30C6 01 ADD 30C7 11 GT 30C8 15 ISZERO 30C9 61 PUSH2 0x30d1 30CC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @30BE stack[-2] = stack[-1] // @30C0 stack[-1] = stack[-1] // @30C1 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x30d1, if !(stack[-3] + 0x40 > stack[-4]) label_30CD: // Incoming jump from 0x30CC, if not !(stack[-3] + 0x40 > stack[-4]) // Inputs[1] { @30D0 memory[0x00:0x00] } 30CD 60 PUSH1 0x00 30CF 80 DUP1 30D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @30D0 revert(memory[0x00:0x00]); } // Block terminates label_30D1: // Incoming jump from 0x30CC, if !(stack[-3] + 0x40 > stack[-4]) 30D1 5B JUMPDEST 30D2 60 PUSH1 0x00 30D4 5B JUMPDEST 30D5 60 PUSH1 0x02 30D7 81 DUP2 30D8 10 LT 30D9 15 ISZERO 30DA 61 PUSH2 0x30fd 30DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30D2 stack[0] = 0x00 } // Block ends with conditional jump to 0x30fd, if !(0x00 < 0x02) label_30DE: // Incoming jump from 0x30DD, if not !(0x00 < 0x02) // Incoming jump from 0x30DD, if not !(stack[-1] < 0x02) // Inputs[2] // { // @30DE stack[-2] // @30DF msg.data[stack[-2]:stack[-2] + 0x20] // } 30DE 81 DUP2 30DF 35 CALLDATALOAD 30E0 61 PUSH2 0x30e8 30E3 81 DUP2 30E4 61 PUSH2 0x43fe 30E7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @30DF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @30E0 stack[1] = 0x30e8 // @30E3 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x30E8 label_30E8: // Incoming return from call to 0x43FE at 0x30E7 // Inputs[4] // { // @30E9 stack[-4] // @30EA stack[-1] // @30F1 stack[-3] // @30F2 stack[-2] // } 30E8 5B JUMPDEST 30E9 83 DUP4 30EA 52 MSTORE 30EB 60 PUSH1 0x20 30ED 92 SWAP3 30EE 83 DUP4 30EF 01 ADD 30F0 92 SWAP3 30F1 91 SWAP2 30F2 90 SWAP1 30F3 91 SWAP2 30F4 01 ADD 30F5 90 SWAP1 30F6 60 PUSH1 0x01 30F8 01 ADD 30F9 61 PUSH2 0x30d4 30FC 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @30EA memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @30F0 stack[-4] = 0x20 + stack[-4] // @30F5 stack[-3] = 0x20 + stack[-3] // @30F8 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x30d4 label_30FD: // Incoming jump from 0x30DD, if !(0x00 < 0x02) // Incoming jump from 0x30DD, if !(stack[-1] < 0x02) // Inputs[3] // { // @3101 stack[-4] // @3101 stack[-7] // @3102 stack[-6] // } 30FD 5B JUMPDEST 30FE 50 POP 30FF 50 POP 3100 50 POP 3101 92 SWAP3 3102 91 SWAP2 3103 50 POP 3104 50 POP 3105 56 *JUMP // Stack delta = -6 // Outputs[1] { @3101 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_3106: // Incoming call from 0x33F4, returns to 0x33F5 // Incoming call from 0x333D, returns to 0x333E // Incoming call from 0x34E6, returns to 0x34E7 // Incoming call from 0x3382, returns to 0x3383 // Incoming call from 0x358B, returns to 0x358C // Inputs[2] // { // @310A stack[-2] // @310D stack[-1] // } 3106 5B JUMPDEST 3107 60 PUSH1 0x00 3109 80 DUP1 310A 83 DUP4 310B 60 PUSH1 0x1f 310D 84 DUP5 310E 01 ADD 310F 12 SLT 3110 61 PUSH2 0x3117 3113 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3107 stack[0] = 0x00 // @3109 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3117, if stack[-1] + 0x1f i< stack[-2] label_3114: // Incoming jump from 0x3113, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @3114 stack[-1] // @3116 memory[stack[-1]:stack[-1] + stack[-1]] // } 3114 80 DUP1 3115 81 DUP2 3116 FD *REVERT // Stack delta = +0 // Outputs[1] { @3116 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3117: // Incoming jump from 0x3113, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @3119 stack[-3] // @311A msg.data[stack[-3]:stack[-3] + 0x20] // } 3117 5B JUMPDEST 3118 50 POP 3119 81 DUP2 311A 35 CALLDATALOAD 311B 67 PUSH8 0xffffffffffffffff 3124 81 DUP2 3125 11 GT 3126 15 ISZERO 3127 61 PUSH2 0x312e 312A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @311A stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x312e, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_312B: // Incoming jump from 0x312A, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @312B stack[-2] // @312D memory[stack[-2]:stack[-2] + stack[-2]] // } 312B 81 DUP2 312C 82 DUP3 312D FD *REVERT // Stack delta = +0 // Outputs[1] { @312D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_312E: // Incoming jump from 0x312A, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @3131 stack[-3] // @3133 stack[-2] // @3135 stack[-4] // @3139 stack[-1] // } 312E 5B JUMPDEST 312F 60 PUSH1 0x20 3131 83 DUP4 3132 01 ADD 3133 91 SWAP2 3134 50 POP 3135 83 DUP4 3136 60 PUSH1 0x20 3138 80 DUP1 3139 83 DUP4 313A 02 MUL 313B 85 DUP6 313C 01 ADD 313D 01 ADD 313E 11 GT 313F 15 ISZERO 3140 61 PUSH2 0x3148 3143 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3133 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x3148, if !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-4]) label_3144: // Incoming jump from 0x3143, if not !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-4]) // Inputs[1] { @3147 memory[0x00:0x00] } 3144 60 PUSH1 0x00 3146 80 DUP1 3147 FD *REVERT // Stack delta = +0 // Outputs[1] { @3147 revert(memory[0x00:0x00]); } // Block terminates label_3148: // Incoming jump from 0x4373, if !(0x20 + stack[-1] i> msg.data.length - stack[-2]) // Incoming jump from 0x3143, if !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-4]) // Incoming jump from 0x3201, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[5] // { // @3149 stack[-4] // @3149 stack[-1] // @314B stack[-2] // @314B stack[-5] // @314C stack[-3] // } 3148 5B JUMPDEST 3149 92 SWAP3 314A 50 POP 314B 92 SWAP3 314C 90 SWAP1 314D 50 POP 314E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3149 stack[-4] = stack[-1] // @314B stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_314F: // Incoming call from 0x34C5, returns to 0x34C6 // Incoming call from 0x348A, returns to 0x0D72 // Incoming call from 0x3569, returns to 0x356A // Inputs[2] // { // @3152 stack[-2] // @3155 stack[-1] // } 314F 5B JUMPDEST 3150 60 PUSH1 0x00 3152 82 DUP3 3153 60 PUSH1 0x1f 3155 83 DUP4 3156 01 ADD 3157 12 SLT 3158 61 PUSH2 0x315f 315B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3150 stack[0] = 0x00 } // Block ends with conditional jump to 0x315f, if stack[-1] + 0x1f i< stack[-2] label_315C: // Incoming jump from 0x315B, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @315C stack[-1] // @315E memory[stack[-1]:stack[-1] + stack[-1]] // } 315C 80 DUP1 315D 81 DUP2 315E FD *REVERT // Stack delta = +0 // Outputs[1] { @315E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_315F: // Incoming jump from 0x315B, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @3160 stack[-2] // @3161 msg.data[stack[-2]:stack[-2] + 0x20] // } 315F 5B JUMPDEST 3160 81 DUP2 3161 35 CALLDATALOAD 3162 67 PUSH8 0xffffffffffffffff 316B 81 DUP2 316C 11 GT 316D 15 ISZERO 316E 61 PUSH2 0x3175 3171 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3161 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3175, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3172: // Incoming jump from 0x3171, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3172 stack[-2] // @3174 memory[stack[-2]:stack[-2] + stack[-2]] // } 3172 81 DUP2 3173 82 DUP3 3174 FD *REVERT // Stack delta = +0 // Outputs[1] { @3174 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3175: // Incoming jump from 0x3171, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @317D stack[-1] } 3175 5B JUMPDEST 3176 60 PUSH1 0x20 3178 61 PUSH2 0x3184 317B 81 DUP2 317C 82 DUP3 317D 84 DUP5 317E 02 MUL 317F 01 ADD 3180 61 PUSH2 0x43ab 3183 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3176 stack[0] = 0x20 // @3178 stack[1] = 0x3184 // @317F stack[2] = stack[-1] * 0x20 + 0x20 // } // Block ends with call to 0x43ab, returns to 0x3184 label_3184: // Incoming return from call to 0x43AB at 0x3183 // Inputs[5] // { // @3185 stack[-3] // @3186 stack[-1] // @3188 stack[-4] // @318A stack[-2] // @318D stack[-5] // } 3184 5B JUMPDEST 3185 82 DUP3 3186 81 DUP2 3187 52 MSTORE 3188 92 SWAP3 3189 50 POP 318A 80 DUP1 318B 83 DUP4 318C 01 ADD 318D 84 DUP5 318E 82 DUP3 318F 01 ADD 3190 60 PUSH1 0x00 3192 5B JUMPDEST 3193 84 DUP5 3194 81 DUP2 3195 10 LT 3196 15 ISZERO 3197 61 PUSH2 0x31bb 319A 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @3187 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @3188 stack[-4] = stack[-1] // @318C stack[-1] = stack[-1] + stack[-2] // @318F stack[0] = stack[-2] + stack[-5] // @3190 stack[1] = 0x00 // } // Block ends with conditional jump to 0x31bb, if !(0x00 < stack[-3]) label_319B: // Incoming jump from 0x319A, if not !(stack[-1] < stack[-5]) // Incoming jump from 0x319A, if not !(0x00 < stack[-3]) // Inputs[5] // { // @319E stack[-8] // @319F stack[-4] // @31A0 stack[-2] // @31A1 msg.data[stack[-2]:stack[-2] + 0x20] // @31A2 stack[-7] // } 319B 61 PUSH2 0x31a9 319E 88 DUP9 319F 85 DUP6 31A0 84 DUP5 31A1 35 CALLDATALOAD 31A2 8A DUP11 31A3 01 ADD 31A4 01 ADD 31A5 61 PUSH2 0x3206 31A8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @319B stack[0] = 0x31a9 // @319E stack[1] = stack[-8] // @31A4 stack[2] = stack[-7] + msg.data[stack[-2]:stack[-2] + 0x20] + stack[-4] // } // Block ends with call to 0x3206, returns to 0x31A9 label_31A9: // Incoming return from call to 0x3206 at 0x31A8 // Inputs[5] // { // @31AA stack[-4] // @31AB stack[-1] // @31AC stack[-2] // @31AD stack[-5] // @31B0 stack[-3] // } 31A9 5B JUMPDEST 31AA 83 DUP4 31AB 52 MSTORE 31AC 91 SWAP2 31AD 83 DUP4 31AE 01 ADD 31AF 91 SWAP2 31B0 90 SWAP1 31B1 83 DUP4 31B2 01 ADD 31B3 90 SWAP1 31B4 60 PUSH1 0x01 31B6 01 ADD 31B7 61 PUSH2 0x3192 31BA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @31AB memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @31AF stack[-4] = stack[-5] + stack[-4] // @31B3 stack[-3] = stack[-5] + stack[-3] // @31B6 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x3192 label_31BB: // Incoming jump from 0x319A, if !(stack[-1] < stack[-5]) // Incoming jump from 0x319A, if !(0x00 < stack[-3]) // Inputs[3] // { // @31C1 stack[-6] // @31C1 stack[-9] // @31C2 stack[-8] // } 31BB 5B JUMPDEST 31BC 50 POP 31BD 50 POP 31BE 50 POP 31BF 50 POP 31C0 50 POP 31C1 92 SWAP3 31C2 91 SWAP2 31C3 50 POP 31C4 50 POP 31C5 56 *JUMP // Stack delta = -8 // Outputs[1] { @31C1 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_31C6: // Incoming call from 0x351D, returns to 0x351E // Incoming call from 0x3817, returns to 0x3818 // Inputs[2] // { // @31CA stack[-2] // @31CD stack[-1] // } 31C6 5B JUMPDEST 31C7 60 PUSH1 0x00 31C9 80 DUP1 31CA 83 DUP4 31CB 60 PUSH1 0x1f 31CD 84 DUP5 31CE 01 ADD 31CF 12 SLT 31D0 61 PUSH2 0x31d7 31D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @31C7 stack[0] = 0x00 // @31C9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x31d7, if stack[-1] + 0x1f i< stack[-2] label_31D4: // Incoming jump from 0x31D3, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @31D4 stack[-2] // @31D6 memory[stack[-2]:stack[-2] + stack[-2]] // } 31D4 81 DUP2 31D5 82 DUP3 31D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @31D6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_31D7: // Incoming jump from 0x31D3, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @31D9 stack[-3] // @31DA msg.data[stack[-3]:stack[-3] + 0x20] // } 31D7 5B JUMPDEST 31D8 50 POP 31D9 81 DUP2 31DA 35 CALLDATALOAD 31DB 67 PUSH8 0xffffffffffffffff 31E4 81 DUP2 31E5 11 GT 31E6 15 ISZERO 31E7 61 PUSH2 0x31ee 31EA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @31DA stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x31ee, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_31EB: // Incoming jump from 0x31EA, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @31EB stack[-2] // @31ED memory[stack[-2]:stack[-2] + stack[-2]] // } 31EB 81 DUP2 31EC 82 DUP3 31ED FD *REVERT // Stack delta = +0 // Outputs[1] { @31ED revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_31EE: // Incoming jump from 0x31EA, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @31F1 stack[-3] // @31F3 stack[-2] // @31F5 stack[-4] // @31F8 stack[-1] // } 31EE 5B JUMPDEST 31EF 60 PUSH1 0x20 31F1 83 DUP4 31F2 01 ADD 31F3 91 SWAP2 31F4 50 POP 31F5 83 DUP4 31F6 60 PUSH1 0x20 31F8 82 DUP3 31F9 85 DUP6 31FA 01 ADD 31FB 01 ADD 31FC 11 GT 31FD 15 ISZERO 31FE 61 PUSH2 0x3148 3201 57 *JUMPI // Stack delta = +0 // Outputs[1] { @31F3 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x3148, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_3202: // Incoming jump from 0x3201, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @3205 memory[0x00:0x00] } 3202 60 PUSH1 0x00 3204 80 DUP1 3205 FD *REVERT // Stack delta = +0 // Outputs[1] { @3205 revert(memory[0x00:0x00]); } // Block terminates label_3206: // Incoming call from 0x37A2, returns to 0x0D72 // Incoming call from 0x31A8, returns to 0x31A9 // Incoming call from 0x37DC, returns to 0x37DD // Incoming call from 0x385F, returns to 0x3860 // Inputs[2] // { // @320B stack[-1] // @320C stack[-2] // } 3206 5B JUMPDEST 3207 60 PUSH1 0x00 3209 60 PUSH1 0x80 320B 82 DUP3 320C 84 DUP5 320D 03 SUB 320E 12 SLT 320F 15 ISZERO 3210 61 PUSH2 0x3217 3213 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3207 stack[0] = 0x00 } // Block ends with conditional jump to 0x3217, if !(stack[-2] - stack[-1] i< 0x80) label_3214: // Incoming jump from 0x3213, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3214 stack[-1] // @3216 memory[stack[-1]:stack[-1] + stack[-1]] // } 3214 80 DUP1 3215 81 DUP2 3216 FD *REVERT // Stack delta = +0 // Outputs[1] { @3216 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3217: // Incoming jump from 0x3213, if !(stack[-2] - stack[-1] i< 0x80) 3217 5B JUMPDEST 3218 61 PUSH2 0x3221 321B 60 PUSH1 0x80 321D 61 PUSH2 0x43ab 3220 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3218 stack[0] = 0x3221 // @321B stack[1] = 0x80 // } // Block ends with call to 0x43ab, returns to 0x3221 label_3221: // Incoming return from call to 0x43AB at 0x3220 // Inputs[7] // { // @3222 stack[-1] // @3222 stack[-2] // @3224 stack[-3] // @3225 msg.data[stack[-3]:stack[-3] + 0x20] // @322D msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3236 msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @3240 msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // } 3221 5B JUMPDEST 3222 90 SWAP1 3223 50 POP 3224 81 DUP2 3225 35 CALLDATALOAD 3226 81 DUP2 3227 52 MSTORE 3228 60 PUSH1 0x20 322A 80 DUP1 322B 83 DUP4 322C 01 ADD 322D 35 CALLDATALOAD 322E 81 DUP2 322F 83 DUP4 3230 01 ADD 3231 52 MSTORE 3232 60 PUSH1 0x40 3234 83 DUP4 3235 01 ADD 3236 35 CALLDATALOAD 3237 60 PUSH1 0x40 3239 83 DUP4 323A 01 ADD 323B 52 MSTORE 323C 60 PUSH1 0x60 323E 83 DUP4 323F 01 ADD 3240 35 CALLDATALOAD 3241 67 PUSH8 0xffffffffffffffff 324A 80 DUP1 324B 82 DUP3 324C 11 GT 324D 15 ISZERO 324E 61 PUSH2 0x3256 3251 57 *JUMPI // Stack delta = +2 // Outputs[7] // { // @3222 stack[-2] = stack[-1] // @3227 memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-3]:stack[-3] + 0x20] // @3228 stack[-1] = 0x20 // @3231 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @323B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @3240 stack[0] = msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @3241 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x3256, if !(msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] > 0xffffffffffffffff) label_3252: // Incoming jump from 0x3251, if not !(msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @3255 memory[0x00:0x00] } 3252 60 PUSH1 0x00 3254 80 DUP1 3255 FD *REVERT // Stack delta = +0 // Outputs[1] { @3255 revert(memory[0x00:0x00]); } // Block terminates label_3256: // Incoming jump from 0x3251, if !(msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3257 stack[-2] // @3258 stack[-5] // @325C stack[-6] // } 3256 5B JUMPDEST 3257 81 DUP2 3258 85 DUP6 3259 01 ADD 325A 91 SWAP2 325B 50 POP 325C 85 DUP6 325D 60 PUSH1 0x1f 325F 83 DUP4 3260 01 ADD 3261 12 SLT 3262 61 PUSH2 0x326a 3265 57 *JUMPI // Stack delta = +0 // Outputs[1] { @325A stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x326a, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_3266: // Incoming jump from 0x3265, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @3269 memory[0x00:0x00] } 3266 60 PUSH1 0x00 3268 80 DUP1 3269 FD *REVERT // Stack delta = +0 // Outputs[1] { @3269 revert(memory[0x00:0x00]); } // Block terminates label_326A: // Incoming jump from 0x3265, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @326B stack[-2] // @326C msg.data[stack[-2]:stack[-2] + 0x20] // @326D stack[-1] // } 326A 5B JUMPDEST 326B 81 DUP2 326C 35 CALLDATALOAD 326D 81 DUP2 326E 81 DUP2 326F 11 GT 3270 15 ISZERO 3271 61 PUSH2 0x3279 3274 57 *JUMPI // Stack delta = +1 // Outputs[1] { @326C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3279, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_3275: // Incoming jump from 0x3274, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @3278 memory[0x00:0x00] } 3275 60 PUSH1 0x00 3277 80 DUP1 3278 FD *REVERT // Stack delta = +0 // Outputs[1] { @3278 revert(memory[0x00:0x00]); } // Block terminates label_3279: // Incoming jump from 0x3274, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @327D stack[-4] // @32A1 stack[-1] // } 3279 5B JUMPDEST 327A 61 PUSH2 0x32a9 327D 84 DUP5 327E 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 329F 60 PUSH1 0x1f 32A1 84 DUP5 32A2 01 ADD 32A3 16 AND 32A4 01 ADD 32A5 61 PUSH2 0x43ab 32A8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @327A stack[0] = 0x32a9 // @32A4 stack[1] = (stack[-1] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + stack[-4] // } // Block ends with call to 0x43ab, returns to 0x32A9 label_32A9: // Incoming return from call to 0x43AB at 0x32A8 // Inputs[6] // { // @32AA stack[-3] // @32AA stack[-1] // @32AC stack[-2] // @32AF stack[-8] // @32B0 stack[-5] // @32B2 stack[-4] // } 32A9 5B JUMPDEST 32AA 91 SWAP2 32AB 50 POP 32AC 80 DUP1 32AD 82 DUP3 32AE 52 MSTORE 32AF 86 DUP7 32B0 84 DUP5 32B1 82 DUP3 32B2 85 DUP6 32B3 01 ADD 32B4 01 ADD 32B5 11 GT 32B6 15 ISZERO 32B7 61 PUSH2 0x32bf 32BA 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @32AA stack[-3] = stack[-1] // @32AE memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // } // Block ends with conditional jump to 0x32bf, if !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) label_32BB: // Incoming jump from 0x32BA, if not !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) // Inputs[1] { @32BE memory[0x00:0x00] } 32BB 60 PUSH1 0x00 32BD 80 DUP1 32BE FD *REVERT // Stack delta = +0 // Outputs[1] { @32BE revert(memory[0x00:0x00]); } // Block terminates label_32BF: // Incoming jump from 0x32BA, if !(stack[-4] + stack[-2] + stack[-5] > stack[-8]) // Inputs[8] // { // @32C0 stack[-1] // @32C1 stack[-4] // @32C2 stack[-3] // @32C5 stack[-2] // @32C7 msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @32D4 stack[-5] // @32DA stack[-8] // @32DB stack[-7] // } 32BF 5B JUMPDEST 32C0 80 DUP1 32C1 84 DUP5 32C2 84 DUP5 32C3 01 ADD 32C4 85 DUP6 32C5 84 DUP5 32C6 01 ADD 32C7 37 CALLDATACOPY 32C8 60 PUSH1 0x00 32CA 84 DUP5 32CB 82 DUP3 32CC 84 DUP5 32CD 01 ADD 32CE 01 ADD 32CF 52 MSTORE 32D0 50 POP 32D1 80 DUP1 32D2 60 PUSH1 0x60 32D4 85 DUP6 32D5 01 ADD 32D6 52 MSTORE 32D7 50 POP 32D8 50 POP 32D9 50 POP 32DA 92 SWAP3 32DB 91 SWAP2 32DC 50 POP 32DD 50 POP 32DE 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @32C7 memory[stack[-2] + stack[-4]:stack[-2] + stack[-4] + stack[-1]] = msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @32CF memory[stack[-2] + stack[-1] + stack[-4]:stack[-2] + stack[-1] + stack[-4] + 0x20] = 0x00 // @32D6 memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] = stack[-2] // @32DA stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_32DF: // Incoming call from 0x0304, returns to 0x0305 // Incoming call from 0x03E4, returns to 0x03E5 // Inputs[2] // { // @32E5 stack[-1] // @32E6 stack[-2] // } 32DF 5B JUMPDEST 32E0 60 PUSH1 0x00 32E2 80 DUP1 32E3 60 PUSH1 0x40 32E5 83 DUP4 32E6 85 DUP6 32E7 03 SUB 32E8 12 SLT 32E9 15 ISZERO 32EA 61 PUSH2 0x32f1 32ED 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @32E0 stack[0] = 0x00 // @32E2 stack[1] = 0x00 // } // Block ends with conditional jump to 0x32f1, if !(stack[-2] - stack[-1] i< 0x40) label_32EE: // Incoming jump from 0x32ED, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @32EE stack[-2] // @32F0 memory[stack[-2]:stack[-2] + stack[-2]] // } 32EE 81 DUP2 32EF 82 DUP3 32F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @32F0 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_32F1: // Incoming jump from 0x32ED, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @32F2 stack[-3] // @32F3 msg.data[stack[-3]:stack[-3] + 0x20] // } 32F1 5B JUMPDEST 32F2 82 DUP3 32F3 35 CALLDATALOAD 32F4 61 PUSH2 0x32fc 32F7 81 DUP2 32F8 61 PUSH2 0x43fe 32FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @32F3 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @32F4 stack[1] = 0x32fc // @32F7 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x32FC label_32FC: // Incoming return from call to 0x43FE at 0x32FB // Inputs[5] // { // @32FD stack[-6] // @32FD stack[-1] // @3300 stack[-4] // @3304 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3305 stack[-5] // } 32FC 5B JUMPDEST 32FD 94 SWAP5 32FE 60 PUSH1 0x20 3300 93 SWAP4 3301 90 SWAP1 3302 93 SWAP4 3303 01 ADD 3304 35 CALLDATALOAD 3305 93 SWAP4 3306 50 POP 3307 50 POP 3308 50 POP 3309 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @32FD stack[-6] = stack[-1] // @3305 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_330A: // Incoming call from 0x0364, returns to 0x0365 // Incoming call from 0x0417, returns to 0x0365 // Inputs[2] // { // @3310 stack[-1] // @3311 stack[-2] // } 330A 5B JUMPDEST 330B 60 PUSH1 0x00 330D 80 DUP1 330E 60 PUSH1 0x20 3310 83 DUP4 3311 85 DUP6 3312 03 SUB 3313 12 SLT 3314 15 ISZERO 3315 61 PUSH2 0x331c 3318 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @330B stack[0] = 0x00 // @330D stack[1] = 0x00 // } // Block ends with conditional jump to 0x331c, if !(stack[-2] - stack[-1] i< 0x20) label_3319: // Incoming jump from 0x3318, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3319 stack[-2] // @331B memory[stack[-2]:stack[-2] + stack[-2]] // } 3319 81 DUP2 331A 82 DUP3 331B FD *REVERT // Stack delta = +0 // Outputs[1] { @331B revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_331C: // Incoming jump from 0x3318, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @331D stack[-3] // @331E msg.data[stack[-3]:stack[-3] + 0x20] // } 331C 5B JUMPDEST 331D 82 DUP3 331E 35 CALLDATALOAD 331F 67 PUSH8 0xffffffffffffffff 3328 81 DUP2 3329 11 GT 332A 15 ISZERO 332B 61 PUSH2 0x3332 332E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @331E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x3332, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_332F: // Incoming jump from 0x332E, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @332F stack[-3] // @3331 memory[stack[-3]:stack[-3] + stack[-3]] // } 332F 82 DUP3 3330 83 DUP4 3331 FD *REVERT // Stack delta = +0 // Outputs[1] { @3331 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3332: // Incoming jump from 0x332E, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3336 stack[-5] // @3337 stack[-1] // @3338 stack[-4] // } 3332 5B JUMPDEST 3333 61 PUSH2 0x333e 3336 85 DUP6 3337 82 DUP3 3338 86 DUP7 3339 01 ADD 333A 61 PUSH2 0x3106 333D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3333 stack[0] = 0x333e // @3336 stack[1] = stack[-5] // @3339 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x3106, returns to 0x333E label_333E: // Incoming return from call to 0x3106 at 0x333D // Inputs[5] // { // @333F stack[-1] // @333F stack[-2] // @3340 stack[-8] // @3342 stack[-7] // @3344 stack[-6] // } 333E 5B JUMPDEST 333F 90 SWAP1 3340 96 SWAP7 3341 90 SWAP1 3342 95 SWAP6 3343 50 POP 3344 93 SWAP4 3345 50 POP 3346 50 POP 3347 50 POP 3348 50 POP 3349 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @3340 stack[-8] = stack[-2] // @3342 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_334A: // Incoming call from 0x02C4, returns to 0x02C5 // Inputs[2] // { // @3355 stack[-1] // @3356 stack[-2] // } 334A 5B JUMPDEST 334B 60 PUSH1 0x00 334D 80 DUP1 334E 60 PUSH1 0x00 3350 80 DUP1 3351 60 PUSH1 0x00 3353 60 PUSH1 0x80 3355 86 DUP7 3356 88 DUP9 3357 03 SUB 3358 12 SLT 3359 15 ISZERO 335A 61 PUSH2 0x3361 335D 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @334B stack[0] = 0x00 // @334D stack[1] = 0x00 // @334E stack[2] = 0x00 // @3350 stack[3] = 0x00 // @3351 stack[4] = 0x00 // } // Block ends with conditional jump to 0x3361, if !(stack[-2] - stack[-1] i< 0x80) label_335E: // Incoming jump from 0x335D, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @335E stack[-1] // @3360 memory[stack[-1]:stack[-1] + stack[-1]] // } 335E 80 DUP1 335F 81 DUP2 3360 FD *REVERT // Stack delta = +0 // Outputs[1] { @3360 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3361: // Incoming jump from 0x335D, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3362 stack[-6] // @3363 msg.data[stack[-6]:stack[-6] + 0x20] // } 3361 5B JUMPDEST 3362 85 DUP6 3363 35 CALLDATALOAD 3364 67 PUSH8 0xffffffffffffffff 336D 81 DUP2 336E 11 GT 336F 15 ISZERO 3370 61 PUSH2 0x3377 3373 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3363 stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] } // Block ends with conditional jump to 0x3377, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) label_3374: // Incoming jump from 0x3373, if not !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3374 stack[-2] // @3376 memory[stack[-2]:stack[-2] + stack[-2]] // } 3374 81 DUP2 3375 82 DUP3 3376 FD *REVERT // Stack delta = +0 // Outputs[1] { @3376 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3377: // Incoming jump from 0x3373, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @337B stack[-8] // @337C stack[-1] // @337D stack[-7] // } 3377 5B JUMPDEST 3378 61 PUSH2 0x3383 337B 88 DUP9 337C 82 DUP3 337D 89 DUP10 337E 01 ADD 337F 61 PUSH2 0x3106 3382 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3378 stack[0] = 0x3383 // @337B stack[1] = stack[-8] // @337E stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x3106, returns to 0x3383 label_3383: // Incoming return from call to 0x3106 at 0x3382 // Inputs[6] // { // @3384 stack[-1] // @3384 stack[-2] // @3385 stack[-8] // @3387 stack[-7] // @338C stack[-9] // @338E msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } 3383 5B JUMPDEST 3384 90 SWAP1 3385 96 SWAP7 3386 50 POP 3387 94 SWAP5 3388 50 POP 3389 50 POP 338A 60 PUSH1 0x20 338C 86 DUP7 338D 01 ADD 338E 35 CALLDATALOAD 338F 61 PUSH2 0x3397 3392 81 DUP2 3393 61 PUSH2 0x43fe 3396 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @3385 stack[-8] = stack[-2] // @3387 stack[-7] = stack[-1] // @338E stack[-3] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @338F stack[-2] = 0x3397 // @3392 stack[-1] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3397 label_3397: // Incoming return from call to 0x43FE at 0x3396 // Inputs[4] // { // @3398 stack[-1] // @3398 stack[-4] // @339C stack[-7] // @339E msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 3397 5B JUMPDEST 3398 92 SWAP3 3399 50 POP 339A 60 PUSH1 0x40 339C 86 DUP7 339D 01 ADD 339E 35 CALLDATALOAD 339F 61 PUSH2 0x33a7 33A2 81 DUP2 33A3 61 PUSH2 0x43fe 33A6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3398 stack[-4] = stack[-1] // @339E stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @339F stack[0] = 0x33a7 // @33A2 stack[1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x33A7 label_33A7: // Incoming return from call to 0x43FE at 0x33A6 // Incoming return from call to 0x43FE at 0x359F // Inputs[9] // { // @33A8 stack[-6] // @33A8 stack[-1] // @33A9 stack[-9] // @33AA stack[-5] // @33AB stack[-8] // @33AD stack[-2] // @33AD stack[-4] // @33AE stack[-7] // @33B2 msg.data[0x60 + stack[-7]:0x60 + stack[-7] + 0x20] // } 33A7 5B JUMPDEST 33A8 94 SWAP5 33A9 97 SWAP8 33AA 93 SWAP4 33AB 96 SWAP7 33AC 50 POP 33AD 91 SWAP2 33AE 94 SWAP5 33AF 60 PUSH1 0x60 33B1 01 ADD 33B2 35 CALLDATALOAD 33B3 92 SWAP3 33B4 91 SWAP2 33B5 50 POP 33B6 50 POP 33B7 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @33A8 stack[-6] = stack[-1] // @33A9 stack[-9] = stack[-6] // @33AB stack[-8] = stack[-5] // @33AE stack[-7] = stack[-4] // @33B3 stack[-5] = msg.data[0x60 + stack[-7]:0x60 + stack[-7] + 0x20] // } // Block ends with unconditional jump to stack[-9] label_33B8: // Incoming call from 0x02E4, returns to 0x02E5 // Inputs[2] // { // @33C7 stack[-1] // @33C8 stack[-2] // } 33B8 5B JUMPDEST 33B9 60 PUSH1 0x00 33BB 80 DUP1 33BC 60 PUSH1 0x00 33BE 80 DUP1 33BF 60 PUSH1 0x00 33C1 80 DUP1 33C2 60 PUSH1 0x00 33C4 80 DUP1 33C5 60 PUSH1 0xe0 33C7 89 DUP10 33C8 8B DUP12 33C9 03 SUB 33CA 12 SLT 33CB 15 ISZERO 33CC 61 PUSH2 0x33d3 33CF 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @33B9 stack[0] = 0x00 // @33BB stack[1] = 0x00 // @33BC stack[2] = 0x00 // @33BE stack[3] = 0x00 // @33BF stack[4] = 0x00 // @33C1 stack[5] = 0x00 // @33C2 stack[6] = 0x00 // @33C4 stack[7] = 0x00 // } // Block ends with conditional jump to 0x33d3, if !(stack[-2] - stack[-1] i< 0xe0) label_33D0: // Incoming jump from 0x33CF, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @33D0 stack[-6] // @33D2 memory[stack[-6]:stack[-6] + stack[-6]] // } 33D0 85 DUP6 33D1 86 DUP7 33D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @33D2 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_33D3: // Incoming jump from 0x33CF, if !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @33D4 stack[-9] // @33D5 msg.data[stack[-9]:stack[-9] + 0x20] // } 33D3 5B JUMPDEST 33D4 88 DUP9 33D5 35 CALLDATALOAD 33D6 67 PUSH8 0xffffffffffffffff 33DF 81 DUP2 33E0 11 GT 33E1 15 ISZERO 33E2 61 PUSH2 0x33e9 33E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @33D5 stack[0] = msg.data[stack[-9]:stack[-9] + 0x20] } // Block ends with conditional jump to 0x33e9, if !(msg.data[stack[-9]:stack[-9] + 0x20] > 0xffffffffffffffff) label_33E6: // Incoming jump from 0x33E5, if not !(msg.data[stack[-9]:stack[-9] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @33E6 stack[-7] // @33E8 memory[stack[-7]:stack[-7] + stack[-7]] // } 33E6 86 DUP7 33E7 87 DUP8 33E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @33E8 revert(memory[stack[-7]:stack[-7] + stack[-7]]); } // Block terminates label_33E9: // Incoming jump from 0x33E5, if !(msg.data[stack[-9]:stack[-9] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @33ED stack[-11] // @33EE stack[-1] // @33EF stack[-10] // } 33E9 5B JUMPDEST 33EA 61 PUSH2 0x33f5 33ED 8B DUP12 33EE 82 DUP3 33EF 8C DUP13 33F0 01 ADD 33F1 61 PUSH2 0x3106 33F4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @33EA stack[0] = 0x33f5 // @33ED stack[1] = stack[-11] // @33F0 stack[2] = stack[-10] + stack[-1] // } // Block ends with call to 0x3106, returns to 0x33F5 label_33F5: // Incoming return from call to 0x3106 at 0x33F4 // Inputs[8] // { // @33F6 stack[-2] // @33F6 stack[-1] // @33F7 stack[-11] // @33F9 stack[-10] // @33FE stack[-12] // @3400 msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] // @3401 stack[-9] // @3407 msg.data[stack[-12] + 0x40:stack[-12] + 0x40 + 0x20] // } 33F5 5B JUMPDEST 33F6 90 SWAP1 33F7 99 SWAP10 33F8 50 POP 33F9 97 SWAP8 33FA 50 POP 33FB 50 POP 33FC 60 PUSH1 0x20 33FE 89 DUP10 33FF 01 ADD 3400 35 CALLDATALOAD 3401 95 SWAP6 3402 50 POP 3403 60 PUSH1 0x40 3405 89 DUP10 3406 01 ADD 3407 35 CALLDATALOAD 3408 61 PUSH2 0x3410 340B 81 DUP2 340C 61 PUSH2 0x43fe 340F 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @33F7 stack[-11] = stack[-2] // @33F9 stack[-10] = stack[-1] // @3401 stack[-9] = msg.data[stack[-12] + 0x20:stack[-12] + 0x20 + 0x20] // @3407 stack[-3] = msg.data[stack[-12] + 0x40:stack[-12] + 0x40 + 0x20] // @3408 stack[-2] = 0x3410 // @340B stack[-1] = msg.data[stack[-12] + 0x40:stack[-12] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3410 label_3410: // Incoming return from call to 0x43FE at 0x340F // Inputs[4] // { // @3411 stack[-1] // @3411 stack[-6] // @3415 stack[-10] // @3417 msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // } 3410 5B JUMPDEST 3411 94 SWAP5 3412 50 POP 3413 60 PUSH1 0x60 3415 89 DUP10 3416 01 ADD 3417 35 CALLDATALOAD 3418 61 PUSH2 0x3420 341B 81 DUP2 341C 61 PUSH2 0x43fe 341F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3411 stack[-6] = stack[-1] // @3417 stack[-1] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @3418 stack[0] = 0x3420 // @341B stack[1] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3420 label_3420: // Incoming return from call to 0x43FE at 0x341F // Inputs[4] // { // @3421 stack[-5] // @3421 stack[-1] // @3425 stack[-10] // @3427 msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // } 3420 5B JUMPDEST 3421 93 SWAP4 3422 50 POP 3423 60 PUSH1 0x80 3425 89 DUP10 3426 01 ADD 3427 35 CALLDATALOAD 3428 61 PUSH2 0x3430 342B 81 DUP2 342C 61 PUSH2 0x43fe 342F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3421 stack[-5] = stack[-1] // @3427 stack[-1] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @3428 stack[0] = 0x3430 // @342B stack[1] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3430 label_3430: // Incoming return from call to 0x43FE at 0x342F // Inputs[4] // { // @3431 stack[-4] // @3431 stack[-1] // @3435 stack[-10] // @3437 msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // } 3430 5B JUMPDEST 3431 92 SWAP3 3432 50 POP 3433 60 PUSH1 0xa0 3435 89 DUP10 3436 01 ADD 3437 35 CALLDATALOAD 3438 61 PUSH2 0x3440 343B 81 DUP2 343C 61 PUSH2 0x43fe 343F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3431 stack[-4] = stack[-1] // @3437 stack[-1] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @3438 stack[0] = 0x3440 // @343B stack[1] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3440 label_3440: // Incoming return from call to 0x43FE at 0x343F // Inputs[13] // { // @3441 stack[-1] // @3442 stack[-3] // @3447 stack[-10] // @3449 msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @344A stack[-2] // @344C stack[-5] // @344D stack[-8] // @344E stack[-11] // @3450 stack[-6] // @3451 stack[-9] // @3452 stack[-12] // @3453 stack[-4] // @3454 stack[-7] // } 3440 5B JUMPDEST 3441 80 DUP1 3442 92 SWAP3 3443 50 POP 3444 50 POP 3445 60 PUSH1 0xc0 3447 89 DUP10 3448 01 ADD 3449 35 CALLDATALOAD 344A 90 SWAP1 344B 50 POP 344C 92 SWAP3 344D 95 SWAP6 344E 98 SWAP9 344F 50 POP 3450 92 SWAP3 3451 95 SWAP6 3452 98 SWAP9 3453 90 SWAP1 3454 93 SWAP4 3455 96 SWAP7 3456 50 POP 3457 56 *JUMP // Stack delta = -4 // Outputs[8] // { // @344C stack[-5] = msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @344D stack[-8] = stack[-5] // @344E stack[-11] = stack[-8] // @3450 stack[-6] = stack[-1] // @3451 stack[-9] = stack[-6] // @3452 stack[-12] = stack[-9] // @3454 stack[-7] = stack[-4] // @3455 stack[-10] = stack[-7] // } // Block ends with unconditional jump to stack[-12] label_3458: // Incoming call from 0x0277, returns to 0x0278 // Inputs[2] // { // @345D stack[-1] // @345E stack[-2] // } 3458 5B JUMPDEST 3459 60 PUSH1 0x00 345B 60 PUSH1 0x20 345D 82 DUP3 345E 84 DUP5 345F 03 SUB 3460 12 SLT 3461 15 ISZERO 3462 61 PUSH2 0x3469 3465 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3459 stack[0] = 0x00 } // Block ends with conditional jump to 0x3469, if !(stack[-2] - stack[-1] i< 0x20) label_3466: // Incoming jump from 0x3465, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3466 stack[-1] // @3468 memory[stack[-1]:stack[-1] + stack[-1]] // } 3466 80 DUP1 3467 81 DUP2 3468 FD *REVERT // Stack delta = +0 // Outputs[1] { @3468 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3469: // Incoming jump from 0x3465, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @346A stack[-2] // @346B msg.data[stack[-2]:stack[-2] + 0x20] // } 3469 5B JUMPDEST 346A 81 DUP2 346B 35 CALLDATALOAD 346C 67 PUSH8 0xffffffffffffffff 3475 81 DUP2 3476 11 GT 3477 15 ISZERO 3478 61 PUSH2 0x347f 347B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @346B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x347f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_347C: // Incoming jump from 0x347B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @347C stack[-2] // @347E memory[stack[-2]:stack[-2] + stack[-2]] // } 347C 81 DUP2 347D 82 DUP3 347E FD *REVERT // Stack delta = +0 // Outputs[1] { @347E revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_347F: // Incoming jump from 0x347B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3483 stack[-4] // @3484 stack[-1] // @3485 stack[-3] // } 347F 5B JUMPDEST 3480 61 PUSH2 0x0d72 3483 84 DUP5 3484 82 DUP3 3485 85 DUP6 3486 01 ADD 3487 61 PUSH2 0x314f 348A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3480 stack[0] = 0x0d72 // @3483 stack[1] = stack[-4] // @3486 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x314f, returns to 0x0D72 label_348B: // Incoming call from 0x0384, returns to 0x0385 // Inputs[2] // { // @3497 stack[-1] // @3498 stack[-2] // } 348B 5B JUMPDEST 348C 60 PUSH1 0x00 348E 80 DUP1 348F 60 PUSH1 0x00 3491 80 DUP1 3492 60 PUSH1 0x00 3494 80 DUP1 3495 60 PUSH1 0x80 3497 87 DUP8 3498 89 DUP10 3499 03 SUB 349A 12 SLT 349B 15 ISZERO 349C 61 PUSH2 0x34a3 349F 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @348C stack[0] = 0x00 // @348E stack[1] = 0x00 // @348F stack[2] = 0x00 // @3491 stack[3] = 0x00 // @3492 stack[4] = 0x00 // @3494 stack[5] = 0x00 // } // Block ends with conditional jump to 0x34a3, if !(stack[-2] - stack[-1] i< 0x80) label_34A0: // Incoming jump from 0x349F, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @34A0 stack[-4] // @34A2 memory[stack[-4]:stack[-4] + stack[-4]] // } 34A0 83 DUP4 34A1 84 DUP5 34A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @34A2 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_34A3: // Incoming jump from 0x349F, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @34A4 stack[-7] // @34A5 msg.data[stack[-7]:stack[-7] + 0x20] // } 34A3 5B JUMPDEST 34A4 86 DUP7 34A5 35 CALLDATALOAD 34A6 67 PUSH8 0xffffffffffffffff 34AF 80 DUP1 34B0 82 DUP3 34B1 11 GT 34B2 15 ISZERO 34B3 61 PUSH2 0x34ba 34B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34A5 stack[0] = msg.data[stack[-7]:stack[-7] + 0x20] // @34A6 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x34ba, if !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) label_34B7: // Incoming jump from 0x34B6, if not !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @34B7 stack[-6] // @34B9 memory[stack[-6]:stack[-6] + stack[-6]] // } 34B7 85 DUP6 34B8 86 DUP7 34B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @34B9 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_34BA: // Incoming jump from 0x34B6, if !(msg.data[stack[-7]:stack[-7] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @34BE stack[-10] // @34BF stack[-2] // @34C0 stack[-9] // } 34BA 5B JUMPDEST 34BB 61 PUSH2 0x34c6 34BE 8A DUP11 34BF 83 DUP4 34C0 8B DUP12 34C1 01 ADD 34C2 61 PUSH2 0x314f 34C5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34BB stack[0] = 0x34c6 // @34BE stack[1] = stack[-10] // @34C1 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x314f, returns to 0x34C6 label_34C6: // Incoming return from call to 0x314F at 0x34C5 // Inputs[6] // { // @34C7 stack[-9] // @34C7 stack[-1] // @34CB stack[-10] // @34CD msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // @34CE stack[-3] // @34D0 stack[-2] // } 34C6 5B JUMPDEST 34C7 97 SWAP8 34C8 50 POP 34C9 60 PUSH1 0x20 34CB 89 DUP10 34CC 01 ADD 34CD 35 CALLDATALOAD 34CE 91 SWAP2 34CF 50 POP 34D0 80 DUP1 34D1 82 DUP3 34D2 11 GT 34D3 15 ISZERO 34D4 61 PUSH2 0x34db 34D7 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @34C7 stack[-9] = stack[-1] // @34CE stack[-3] = msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x34db, if !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) label_34D8: // Incoming jump from 0x34D7, if not !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) // Inputs[2] // { // @34D8 stack[-6] // @34DA memory[stack[-6]:stack[-6] + stack[-6]] // } 34D8 85 DUP6 34D9 86 DUP7 34DA FD *REVERT // Stack delta = +0 // Outputs[1] { @34DA revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_34DB: // Incoming jump from 0x34D7, if !(msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @34DF stack[-10] // @34E0 stack[-2] // @34E1 stack[-9] // } 34DB 5B JUMPDEST 34DC 61 PUSH2 0x34e7 34DF 8A DUP11 34E0 83 DUP4 34E1 8B DUP12 34E2 01 ADD 34E3 61 PUSH2 0x3106 34E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34DC stack[0] = 0x34e7 // @34DF stack[1] = stack[-10] // @34E2 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x3106, returns to 0x34E7 label_34E7: // Incoming return from call to 0x3106 at 0x34E6 // Inputs[7] // { // @34E8 stack[-1] // @34E8 stack[-2] // @34E9 stack[-9] // @34EB stack[-8] // @34EF stack[-11] // @34F1 msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // @34F2 stack[-4] // } 34E7 5B JUMPDEST 34E8 90 SWAP1 34E9 97 SWAP8 34EA 50 POP 34EB 95 SWAP6 34EC 50 POP 34ED 60 PUSH1 0x40 34EF 89 DUP10 34F0 01 ADD 34F1 35 CALLDATALOAD 34F2 91 SWAP2 34F3 50 POP 34F4 61 PUSH2 0x34fc 34F7 82 DUP3 34F8 61 PUSH2 0x43fe 34FB 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @34E9 stack[-9] = stack[-2] // @34EB stack[-8] = stack[-1] // @34F2 stack[-4] = msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // @34F4 stack[-2] = 0x34fc // @34F7 stack[-1] = msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x34FC label_34FC: // Incoming return from call to 0x43FE at 0x34FB // Inputs[5] // { // @34FD stack[-1] // @34FD stack[-2] // @34FE stack[-5] // @3502 stack[-9] // @3504 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } 34FC 5B JUMPDEST 34FD 90 SWAP1 34FE 93 SWAP4 34FF 50 POP 3500 60 PUSH1 0x60 3502 88 DUP9 3503 01 ADD 3504 35 CALLDATALOAD 3505 90 SWAP1 3506 80 DUP1 3507 82 DUP3 3508 11 GT 3509 15 ISZERO 350A 61 PUSH2 0x3511 350D 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @34FE stack[-5] = stack[-2] // @3505 stack[-2] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @3505 stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x3511, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-1]) label_350E: // Incoming jump from 0x350D, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-1]) // Inputs[2] // { // @350E stack[-4] // @3510 memory[stack[-4]:stack[-4] + stack[-4]] // } 350E 83 DUP4 350F 84 DUP5 3510 FD *REVERT // Stack delta = +0 // Outputs[1] { @3510 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_3511: // Incoming jump from 0x350D, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-1]) // Inputs[3] // { // @3516 stack[-10] // @3517 stack[-2] // @3518 stack[-9] // } 3511 5B JUMPDEST 3512 50 POP 3513 61 PUSH2 0x351e 3516 89 DUP10 3517 82 DUP3 3518 8A DUP11 3519 01 ADD 351A 61 PUSH2 0x31c6 351D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3513 stack[-1] = 0x351e // @3516 stack[0] = stack[-10] // @3519 stack[1] = stack[-9] + stack[-2] // } // Block ends with call to 0x31c6, returns to 0x351E label_351E: // Incoming return from call to 0x31C6 at 0x351D // Inputs[10] // { // @351F stack[-1] // @351F stack[-9] // @3520 stack[-12] // @3521 stack[-8] // @3522 stack[-11] // @3524 stack[-7] // @3524 stack[-2] // @3525 stack[-10] // @3527 stack[-3] // @3527 stack[-6] // } 351E 5B JUMPDEST 351F 97 SWAP8 3520 9A SWAP11 3521 96 SWAP7 3522 99 SWAP10 3523 50 POP 3524 94 SWAP5 3525 97 SWAP8 3526 50 POP 3527 92 SWAP3 3528 95 SWAP6 3529 93 SWAP4 352A 94 SWAP5 352B 92 SWAP3 352C 50 POP 352D 50 POP 352E 50 POP 352F 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @3520 stack[-12] = stack[-9] // @3522 stack[-11] = stack[-8] // @3525 stack[-10] = stack[-7] // @3528 stack[-9] = stack[-6] // @3529 stack[-7] = stack[-1] // @352A stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-12] label_3530: // Incoming jump from 0x0344 // Inputs[2] // { // @353B stack[-1] // @353C stack[-2] // } 3530 5B JUMPDEST 3531 60 PUSH1 0x00 3533 80 DUP1 3534 60 PUSH1 0x00 3536 80 DUP1 3537 60 PUSH1 0x00 3539 60 PUSH1 0x80 353B 86 DUP7 353C 88 DUP9 353D 03 SUB 353E 12 SLT 353F 15 ISZERO 3540 61 PUSH2 0x3547 3543 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3531 stack[0] = 0x00 // @3533 stack[1] = 0x00 // @3534 stack[2] = 0x00 // @3536 stack[3] = 0x00 // @3537 stack[4] = 0x00 // } // Block ends with conditional jump to 0x3547, if !(stack[-2] - stack[-1] i< 0x80) label_3544: // Incoming jump from 0x3543, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3544 stack[-3] // @3546 memory[stack[-3]:stack[-3] + stack[-3]] // } 3544 82 DUP3 3545 83 DUP4 3546 FD *REVERT // Stack delta = +0 // Outputs[1] { @3546 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3547: // Incoming jump from 0x3543, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3548 stack[-6] // @3549 msg.data[stack[-6]:stack[-6] + 0x20] // } 3547 5B JUMPDEST 3548 85 DUP6 3549 35 CALLDATALOAD 354A 67 PUSH8 0xffffffffffffffff 3553 80 DUP1 3554 82 DUP3 3555 11 GT 3556 15 ISZERO 3557 61 PUSH2 0x355e 355A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3549 stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @354A stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x355e, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) label_355B: // Incoming jump from 0x355A, if not !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @355B stack[-5] // @355D memory[stack[-5]:stack[-5] + stack[-5]] // } 355B 84 DUP5 355C 85 DUP6 355D FD *REVERT // Stack delta = +0 // Outputs[1] { @355D revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_355E: // Incoming jump from 0x355A, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3562 stack[-9] // @3563 stack[-2] // @3564 stack[-8] // } 355E 5B JUMPDEST 355F 61 PUSH2 0x356a 3562 89 DUP10 3563 83 DUP4 3564 8A DUP11 3565 01 ADD 3566 61 PUSH2 0x314f 3569 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @355F stack[0] = 0x356a // @3562 stack[1] = stack[-9] // @3565 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x314f, returns to 0x356A label_356A: // Incoming return from call to 0x314F at 0x3569 // Inputs[6] // { // @356B stack[-8] // @356B stack[-1] // @356F stack[-9] // @3571 msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @3572 stack[-3] // @3574 stack[-2] // } 356A 5B JUMPDEST 356B 96 SWAP7 356C 50 POP 356D 60 PUSH1 0x20 356F 88 DUP9 3570 01 ADD 3571 35 CALLDATALOAD 3572 91 SWAP2 3573 50 POP 3574 80 DUP1 3575 82 DUP3 3576 11 GT 3577 15 ISZERO 3578 61 PUSH2 0x357f 357B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @356B stack[-8] = stack[-1] // @3572 stack[-3] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x357f, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-2]) label_357C: // Incoming jump from 0x357B, if not !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-2]) // Inputs[2] // { // @357C stack[-5] // @357E memory[stack[-5]:stack[-5] + stack[-5]] // } 357C 84 DUP5 357D 85 DUP6 357E FD *REVERT // Stack delta = +0 // Outputs[1] { @357E revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_357F: // Incoming jump from 0x357B, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @3584 stack[-9] // @3585 stack[-2] // @3586 stack[-8] // } 357F 5B JUMPDEST 3580 50 POP 3581 61 PUSH2 0x358c 3584 88 DUP9 3585 82 DUP3 3586 89 DUP10 3587 01 ADD 3588 61 PUSH2 0x3106 358B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3581 stack[-1] = 0x358c // @3584 stack[0] = stack[-9] // @3587 stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x3106, returns to 0x358C label_358C: // Incoming return from call to 0x3106 at 0x358B // Inputs[6] // { // @358D stack[-2] // @358D stack[-1] // @358E stack[-7] // @3590 stack[-6] // @3595 stack[-9] // @3597 msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // } 358C 5B JUMPDEST 358D 90 SWAP1 358E 95 SWAP6 358F 50 POP 3590 93 SWAP4 3591 50 POP 3592 50 POP 3593 60 PUSH1 0x40 3595 86 DUP7 3596 01 ADD 3597 35 CALLDATALOAD 3598 61 PUSH2 0x33a7 359B 81 DUP2 359C 61 PUSH2 0x43fe 359F 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @358E stack[-7] = stack[-2] // @3590 stack[-6] = stack[-1] // @3597 stack[-3] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @3598 stack[-2] = 0x33a7 // @359B stack[-1] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x33A7 35A0 5B JUMPDEST 35A1 60 PUSH1 0x00 35A3 60 PUSH1 0x20 35A5 82 DUP3 35A6 84 DUP5 35A7 03 SUB 35A8 12 SLT 35A9 15 ISZERO 35AA 61 PUSH2 0x35b1 35AD 57 *JUMPI 35AE 80 DUP1 35AF 81 DUP2 35B0 FD *REVERT 35B1 5B JUMPDEST 35B2 81 DUP2 35B3 51 MLOAD 35B4 80 DUP1 35B5 15 ISZERO 35B6 15 ISZERO 35B7 81 DUP2 35B8 14 EQ 35B9 61 PUSH2 0x0b19 35BC 57 *JUMPI 35BD 81 DUP2 35BE 82 DUP3 35BF FD *REVERT label_35C0: // Incoming call from 0x0404, returns to 0x0405 // Incoming call from 0x0472, returns to 0x0473 // Inputs[2] // { // @35C8 stack[-1] // @35C9 stack[-2] // } 35C0 5B JUMPDEST 35C1 60 PUSH1 0x00 35C3 80 DUP1 35C4 60 PUSH1 0x00 35C6 60 PUSH1 0x60 35C8 84 DUP5 35C9 86 DUP7 35CA 03 SUB 35CB 12 SLT 35CC 15 ISZERO 35CD 61 PUSH2 0x35d4 35D0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @35C1 stack[0] = 0x00 // @35C3 stack[1] = 0x00 // @35C4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x35d4, if !(stack[-2] - stack[-1] i< 0x60) label_35D1: // Incoming jump from 0x35D0, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @35D1 stack[-1] // @35D3 memory[stack[-1]:stack[-1] + stack[-1]] // } 35D1 80 DUP1 35D2 81 DUP2 35D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @35D3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_35D4: // Incoming jump from 0x35D0, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @35D5 stack[-4] // @35D6 msg.data[stack[-4]:stack[-4] + 0x20] // } 35D4 5B JUMPDEST 35D5 83 DUP4 35D6 35 CALLDATALOAD 35D7 61 PUSH2 0x35df 35DA 81 DUP2 35DB 61 PUSH2 0x43fe 35DE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @35D6 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @35D7 stack[1] = 0x35df // @35DA stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x35DF label_35DF: // Incoming return from call to 0x43FE at 0x35DE // Inputs[4] // { // @35E0 stack[-1] // @35E0 stack[-4] // @35E4 stack[-5] // @35E6 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 35DF 5B JUMPDEST 35E0 92 SWAP3 35E1 50 POP 35E2 60 PUSH1 0x20 35E4 84 DUP5 35E5 01 ADD 35E6 35 CALLDATALOAD 35E7 61 PUSH2 0x35ef 35EA 81 DUP2 35EB 61 PUSH2 0x43fe 35EE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @35E0 stack[-4] = stack[-1] // @35E6 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @35E7 stack[0] = 0x35ef // @35EA stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x35EF label_35EF: // Incoming return from call to 0x43FE at 0x35EE // Inputs[6] // { // @35F0 stack[-1] // @35F0 stack[-4] // @35F1 stack[-7] // @35F3 stack[-6] // @35F9 stack[-5] // @35FD msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 35EF 5B JUMPDEST 35F0 92 SWAP3 35F1 95 SWAP6 35F2 92 SWAP3 35F3 94 SWAP5 35F4 50 POP 35F5 50 POP 35F6 50 POP 35F7 60 PUSH1 0x40 35F9 91 SWAP2 35FA 90 SWAP1 35FB 91 SWAP2 35FC 01 ADD 35FD 35 CALLDATALOAD 35FE 90 SWAP1 35FF 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @35F1 stack[-7] = stack[-4] // @35F3 stack[-6] = stack[-1] // @35FE stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_3600: // Incoming call from 0x01E0, returns to 0x01E1 // Inputs[2] // { // @360B stack[-1] // @360C stack[-2] // } 3600 5B JUMPDEST 3601 60 PUSH1 0x00 3603 80 DUP1 3604 60 PUSH1 0x00 3606 80 DUP1 3607 60 PUSH1 0x00 3609 60 PUSH1 0xa0 360B 86 DUP7 360C 88 DUP9 360D 03 SUB 360E 12 SLT 360F 15 ISZERO 3610 61 PUSH2 0x3617 3613 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3601 stack[0] = 0x00 // @3603 stack[1] = 0x00 // @3604 stack[2] = 0x00 // @3606 stack[3] = 0x00 // @3607 stack[4] = 0x00 // } // Block ends with conditional jump to 0x3617, if !(stack[-2] - stack[-1] i< 0xa0) label_3614: // Incoming jump from 0x3613, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @3614 stack[-3] // @3616 memory[stack[-3]:stack[-3] + stack[-3]] // } 3614 82 DUP3 3615 83 DUP4 3616 FD *REVERT // Stack delta = +0 // Outputs[1] { @3616 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3617: // Incoming jump from 0x3613, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @3618 stack[-6] // @3619 msg.data[stack[-6]:stack[-6] + 0x20] // } 3617 5B JUMPDEST 3618 85 DUP6 3619 35 CALLDATALOAD 361A 61 PUSH2 0x3622 361D 81 DUP2 361E 61 PUSH2 0x43fe 3621 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3619 stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @361A stack[1] = 0x3622 // @361D stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3622 label_3622: // Incoming return from call to 0x43FE at 0x3621 // Inputs[4] // { // @3623 stack[-6] // @3623 stack[-1] // @3627 stack[-7] // @3629 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 3622 5B JUMPDEST 3623 94 SWAP5 3624 50 POP 3625 60 PUSH1 0x20 3627 86 DUP7 3628 01 ADD 3629 35 CALLDATALOAD 362A 61 PUSH2 0x3632 362D 81 DUP2 362E 61 PUSH2 0x43fe 3631 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3623 stack[-6] = stack[-1] // @3629 stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @362A stack[0] = 0x3632 // @362D stack[1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3632 label_3632: // Incoming return from call to 0x43FE at 0x3631 // Inputs[9] // { // @3633 stack[-6] // @3633 stack[-1] // @3634 stack[-9] // @3636 stack[-8] // @363D stack[-7] // @363F msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3645 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @364C msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // @364D stack[-5] // } 3632 5B JUMPDEST 3633 94 SWAP5 3634 97 SWAP8 3635 94 SWAP5 3636 96 SWAP7 3637 50 POP 3638 50 POP 3639 50 POP 363A 50 POP 363B 60 PUSH1 0x40 363D 83 DUP4 363E 01 ADD 363F 35 CALLDATALOAD 3640 92 SWAP3 3641 60 PUSH1 0x60 3643 81 DUP2 3644 01 ADD 3645 35 CALLDATALOAD 3646 92 SWAP3 3647 60 PUSH1 0x80 3649 90 SWAP1 364A 91 SWAP2 364B 01 ADD 364C 35 CALLDATALOAD 364D 91 SWAP2 364E 50 POP 364F 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @3634 stack[-9] = stack[-6] // @3636 stack[-8] = stack[-1] // @3640 stack[-7] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3646 stack[-6] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @364D stack[-5] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with unconditional jump to stack[-9] label_3650: // Incoming call from 0x0492, returns to 0x0493 // Inputs[2] // { // @3658 stack[-1] // @3659 stack[-2] // } 3650 5B JUMPDEST 3651 60 PUSH1 0x00 3653 80 DUP1 3654 60 PUSH1 0x00 3656 60 PUSH1 0x60 3658 84 DUP5 3659 86 DUP7 365A 03 SUB 365B 12 SLT 365C 15 ISZERO 365D 61 PUSH2 0x3664 3660 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3651 stack[0] = 0x00 // @3653 stack[1] = 0x00 // @3654 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3664, if !(stack[-2] - stack[-1] i< 0x60) label_3661: // Incoming jump from 0x3660, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3661 stack[-1] // @3663 memory[stack[-1]:stack[-1] + stack[-1]] // } 3661 80 DUP1 3662 81 DUP2 3663 FD *REVERT // Stack delta = +0 // Outputs[1] { @3663 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3664: // Incoming jump from 0x3660, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3665 stack[-4] // @3666 msg.data[stack[-4]:stack[-4] + 0x20] // } 3664 5B JUMPDEST 3665 83 DUP4 3666 35 CALLDATALOAD 3667 61 PUSH2 0x366f 366A 81 DUP2 366B 61 PUSH2 0x43fe 366E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3666 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @3667 stack[1] = 0x366f // @366A stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x366F label_366F: // Incoming return from call to 0x43FE at 0x366E // Inputs[7] // { // @3670 stack[-7] // @3670 stack[-1] // @3673 stack[-5] // @3675 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3676 stack[-6] // @367D msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @367F stack[-4] // } 366F 5B JUMPDEST 3670 95 SWAP6 3671 60 PUSH1 0x20 3673 85 DUP6 3674 01 ADD 3675 35 CALLDATALOAD 3676 95 SWAP6 3677 50 POP 3678 60 PUSH1 0x40 367A 90 SWAP1 367B 94 SWAP5 367C 01 ADD 367D 35 CALLDATALOAD 367E 93 SWAP4 367F 92 SWAP3 3680 50 POP 3681 50 POP 3682 50 POP 3683 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3670 stack[-7] = stack[-1] // @3676 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @367E stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_3684: // Incoming call from 0x03C4, returns to 0x03C5 // Incoming call from 0x0452, returns to 0x0453 // Inputs[2] // { // @368F stack[-1] // @3690 stack[-2] // } 3684 5B JUMPDEST 3685 60 PUSH1 0x00 3687 80 DUP1 3688 60 PUSH1 0x00 368A 80 DUP1 368B 60 PUSH1 0x00 368D 60 PUSH1 0xa0 368F 86 DUP7 3690 88 DUP9 3691 03 SUB 3692 12 SLT 3693 15 ISZERO 3694 61 PUSH2 0x369b 3697 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3685 stack[0] = 0x00 // @3687 stack[1] = 0x00 // @3688 stack[2] = 0x00 // @368A stack[3] = 0x00 // @368B stack[4] = 0x00 // } // Block ends with conditional jump to 0x369b, if !(stack[-2] - stack[-1] i< 0xa0) label_3698: // Incoming jump from 0x3697, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @3698 stack[-3] // @369A memory[stack[-3]:stack[-3] + stack[-3]] // } 3698 82 DUP3 3699 83 DUP4 369A FD *REVERT // Stack delta = +0 // Outputs[1] { @369A revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_369B: // Incoming jump from 0x3697, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @369C stack[-6] // @369D msg.data[stack[-6]:stack[-6] + 0x20] // } 369B 5B JUMPDEST 369C 85 DUP6 369D 35 CALLDATALOAD 369E 61 PUSH2 0x36a6 36A1 81 DUP2 36A2 61 PUSH2 0x43fe 36A5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @369D stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @369E stack[1] = 0x36a6 // @36A1 stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x36A6 label_36A6: // Incoming return from call to 0x43FE at 0x36A5 // Inputs[4] // { // @36A7 stack[-6] // @36A7 stack[-1] // @36AB stack[-7] // @36AD msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 36A6 5B JUMPDEST 36A7 94 SWAP5 36A8 50 POP 36A9 60 PUSH1 0x20 36AB 86 DUP7 36AC 01 ADD 36AD 35 CALLDATALOAD 36AE 61 PUSH2 0x36b6 36B1 81 DUP2 36B2 61 PUSH2 0x43fe 36B5 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @36A7 stack[-6] = stack[-1] // @36AD stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @36AE stack[0] = 0x36b6 // @36B1 stack[1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x36B6 label_36B6: // Incoming return from call to 0x43FE at 0x36B5 // Inputs[4] // { // @36B7 stack[-5] // @36B7 stack[-1] // @36BB stack[-7] // @36BD msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 36B6 5B JUMPDEST 36B7 93 SWAP4 36B8 50 POP 36B9 60 PUSH1 0x40 36BB 86 DUP7 36BC 01 ADD 36BD 35 CALLDATALOAD 36BE 61 PUSH2 0x36c6 36C1 81 DUP2 36C2 61 PUSH2 0x43fe 36C5 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @36B7 stack[-5] = stack[-1] // @36BD stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @36BE stack[0] = 0x36c6 // @36C1 stack[1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x36C6 label_36C6: // Incoming return from call to 0x43FE at 0x36C5 // Inputs[10] // { // @36C7 stack[-6] // @36C7 stack[-1] // @36C8 stack[-9] // @36C9 stack[-5] // @36CA stack[-8] // @36CC stack[-2] // @36CD stack[-7] // @36D2 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @36D8 msg.data[0x80 + stack[-7]:0x80 + stack[-7] + 0x20] // @36DA stack[-4] // } 36C6 5B JUMPDEST 36C7 94 SWAP5 36C8 97 SWAP8 36C9 93 SWAP4 36CA 96 SWAP7 36CB 50 POP 36CC 93 SWAP4 36CD 94 SWAP5 36CE 60 PUSH1 0x60 36D0 81 DUP2 36D1 01 ADD 36D2 35 CALLDATALOAD 36D3 94 SWAP5 36D4 50 POP 36D5 60 PUSH1 0x80 36D7 01 ADD 36D8 35 CALLDATALOAD 36D9 92 SWAP3 36DA 91 SWAP2 36DB 50 POP 36DC 50 POP 36DD 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @36C8 stack[-9] = stack[-6] // @36CA stack[-8] = stack[-5] // @36CD stack[-7] = stack[-1] // @36D3 stack[-6] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @36D9 stack[-5] = msg.data[0x80 + stack[-7]:0x80 + stack[-7] + 0x20] // } // Block ends with unconditional jump to stack[-9] label_36DE: // Incoming call from 0x0432, returns to 0x0433 // Inputs[2] // { // @36E7 stack[-1] // @36E8 stack[-2] // } 36DE 5B JUMPDEST 36DF 60 PUSH1 0x00 36E1 80 DUP1 36E2 60 PUSH1 0x00 36E4 80 DUP1 36E5 60 PUSH1 0xa0 36E7 85 DUP6 36E8 87 DUP8 36E9 03 SUB 36EA 12 SLT 36EB 15 ISZERO 36EC 61 PUSH2 0x36f3 36EF 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @36DF stack[0] = 0x00 // @36E1 stack[1] = 0x00 // @36E2 stack[2] = 0x00 // @36E4 stack[3] = 0x00 // } // Block ends with conditional jump to 0x36f3, if !(stack[-2] - stack[-1] i< 0xa0) label_36F0: // Incoming jump from 0x36EF, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @36F0 stack[-2] // @36F2 memory[stack[-2]:stack[-2] + stack[-2]] // } 36F0 81 DUP2 36F1 82 DUP3 36F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @36F2 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_36F3: // Incoming jump from 0x36EF, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @36F4 stack[-5] // @36F5 msg.data[stack[-5]:stack[-5] + 0x20] // } 36F3 5B JUMPDEST 36F4 84 DUP5 36F5 35 CALLDATALOAD 36F6 61 PUSH2 0x36fe 36F9 81 DUP2 36FA 61 PUSH2 0x43fe 36FD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @36F5 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @36F6 stack[1] = 0x36fe // @36F9 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x43fe, returns to 0x36FE label_36FE: // Incoming return from call to 0x43FE at 0x36FD // Inputs[4] // { // @36FF stack[-5] // @36FF stack[-1] // @3703 stack[-6] // @3705 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 36FE 5B JUMPDEST 36FF 93 SWAP4 3700 50 POP 3701 60 PUSH1 0x20 3703 85 DUP6 3704 01 ADD 3705 35 CALLDATALOAD 3706 61 PUSH2 0x370e 3709 81 DUP2 370A 61 PUSH2 0x43fe 370D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @36FF stack[-5] = stack[-1] // @3705 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @3706 stack[0] = 0x370e // @3709 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x370E label_370E: // Incoming return from call to 0x43FE at 0x370D // Inputs[4] // { // @370F stack[-1] // @370F stack[-4] // @3714 stack[-7] // @3717 stack[-6] // } 370E 5B JUMPDEST 370F 92 SWAP3 3710 50 POP 3711 61 PUSH2 0x371d 3714 86 DUP7 3715 60 PUSH1 0x40 3717 87 DUP8 3718 01 ADD 3719 61 PUSH2 0x30a3 371C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @370F stack[-4] = stack[-1] // @3711 stack[-1] = 0x371d // @3714 stack[0] = stack[-7] // @3718 stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x30a3, returns to 0x371D label_371D: // Incoming return from call to 0x30A3 at 0x371C // Inputs[4] // { // @371E stack[-1] // @371E stack[-3] // @3722 stack[-6] // @3724 msg.data[stack[-6] + 0x80:stack[-6] + 0x80 + 0x20] // } 371D 5B JUMPDEST 371E 91 SWAP2 371F 50 POP 3720 60 PUSH1 0x80 3722 85 DUP6 3723 01 ADD 3724 35 CALLDATALOAD 3725 61 PUSH2 0x372d 3728 81 DUP2 3729 61 PUSH2 0x43fe 372C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @371E stack[-3] = stack[-1] // @3724 stack[-1] = msg.data[stack[-6] + 0x80:stack[-6] + 0x80 + 0x20] // @3725 stack[0] = 0x372d // @3728 stack[1] = msg.data[stack[-6] + 0x80:stack[-6] + 0x80 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x372D label_372D: // Incoming return from call to 0x43FE at 0x372C // Inputs[8] // { // @372E stack[-1] // @372E stack[-5] // @372F stack[-8] // @3730 stack[-4] // @3731 stack[-7] // @3733 stack[-3] // @3733 stack[-2] // @3734 stack[-6] // } 372D 5B JUMPDEST 372E 93 SWAP4 372F 96 SWAP7 3730 92 SWAP3 3731 95 SWAP6 3732 50 POP 3733 90 SWAP1 3734 93 SWAP4 3735 50 POP 3736 50 POP 3737 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @372E stack[-5] = stack[-1] // @372F stack[-8] = stack[-5] // @3731 stack[-7] = stack[-4] // @3734 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_3738: // Incoming call from 0x0220, returns to 0x0221 // Inputs[2] // { // @373D stack[-1] // @373E stack[-2] // } 3738 5B JUMPDEST 3739 60 PUSH1 0x00 373B 60 PUSH1 0x20 373D 82 DUP3 373E 84 DUP5 373F 03 SUB 3740 12 SLT 3741 15 ISZERO 3742 61 PUSH2 0x3749 3745 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3739 stack[0] = 0x00 } // Block ends with conditional jump to 0x3749, if !(stack[-2] - stack[-1] i< 0x20) label_3746: // Incoming jump from 0x3745, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3746 stack[-1] // @3748 memory[stack[-1]:stack[-1] + stack[-1]] // } 3746 80 DUP1 3747 81 DUP2 3748 FD *REVERT // Stack delta = +0 // Outputs[1] { @3748 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3749: // Incoming jump from 0x3745, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @374A stack[-2] // @374B msg.data[stack[-2]:stack[-2] + 0x20] // } 3749 5B JUMPDEST 374A 81 DUP2 374B 35 CALLDATALOAD 374C 67 PUSH8 0xffffffffffffffff 3755 81 DUP2 3756 11 GT 3757 15 ISZERO 3758 61 PUSH2 0x375f 375B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @374B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x375f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_375C: // Incoming jump from 0x375B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @375C stack[-2] // @375E memory[stack[-2]:stack[-2] + stack[-2]] // } 375C 81 DUP2 375D 82 DUP3 375E FD *REVERT // Stack delta = +0 // Outputs[1] { @375E revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_375F: // Incoming jump from 0x375B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3760 stack[-3] // @3761 stack[-1] // @3765 stack[-4] // } 375F 5B JUMPDEST 3760 82 DUP3 3761 01 ADD 3762 60 PUSH1 0x80 3764 81 DUP2 3765 85 DUP6 3766 03 SUB 3767 12 SLT 3768 15 ISZERO 3769 61 PUSH2 0x0b19 376C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3761 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0b19, if !(stack[-4] - (stack[-3] + stack[-1]) i< 0x80) label_376D: // Incoming jump from 0x376C, if not !(stack[-4] - (stack[-3] + stack[-1]) i< 0x80) // Inputs[2] // { // @376D stack[-2] // @376F memory[stack[-2]:stack[-2] + stack[-2]] // } 376D 81 DUP2 376E 82 DUP3 376F FD *REVERT // Stack delta = +0 // Outputs[1] { @376F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3770: // Incoming call from 0x04B2, returns to 0x04B3 // Inputs[2] // { // @3775 stack[-1] // @3776 stack[-2] // } 3770 5B JUMPDEST 3771 60 PUSH1 0x00 3773 60 PUSH1 0x20 3775 82 DUP3 3776 84 DUP5 3777 03 SUB 3778 12 SLT 3779 15 ISZERO 377A 61 PUSH2 0x3781 377D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3771 stack[0] = 0x00 } // Block ends with conditional jump to 0x3781, if !(stack[-2] - stack[-1] i< 0x20) label_377E: // Incoming jump from 0x377D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @377E stack[-1] // @3780 memory[stack[-1]:stack[-1] + stack[-1]] // } 377E 80 DUP1 377F 81 DUP2 3780 FD *REVERT // Stack delta = +0 // Outputs[1] { @3780 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3781: // Incoming jump from 0x377D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3782 stack[-2] // @3783 msg.data[stack[-2]:stack[-2] + 0x20] // } 3781 5B JUMPDEST 3782 81 DUP2 3783 35 CALLDATALOAD 3784 67 PUSH8 0xffffffffffffffff 378D 81 DUP2 378E 11 GT 378F 15 ISZERO 3790 61 PUSH2 0x3797 3793 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3783 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3797, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3794: // Incoming jump from 0x3793, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3794 stack[-2] // @3796 memory[stack[-2]:stack[-2] + stack[-2]] // } 3794 81 DUP2 3795 82 DUP3 3796 FD *REVERT // Stack delta = +0 // Outputs[1] { @3796 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3797: // Incoming jump from 0x3793, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @379B stack[-4] // @379C stack[-1] // @379D stack[-3] // } 3797 5B JUMPDEST 3798 61 PUSH2 0x0d72 379B 84 DUP5 379C 82 DUP3 379D 85 DUP6 379E 01 ADD 379F 61 PUSH2 0x3206 37A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3798 stack[0] = 0x0d72 // @379B stack[1] = stack[-4] // @379E stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x3206, returns to 0x0D72 label_37A3: // Incoming call from 0x0324, returns to 0x0325 // Inputs[2] // { // @37AE stack[-1] // @37AF stack[-2] // } 37A3 5B JUMPDEST 37A4 60 PUSH1 0x00 37A6 80 DUP1 37A7 60 PUSH1 0x00 37A9 80 DUP1 37AA 60 PUSH1 0x00 37AC 60 PUSH1 0x80 37AE 86 DUP7 37AF 88 DUP9 37B0 03 SUB 37B1 12 SLT 37B2 15 ISZERO 37B3 61 PUSH2 0x37ba 37B6 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @37A4 stack[0] = 0x00 // @37A6 stack[1] = 0x00 // @37A7 stack[2] = 0x00 // @37A9 stack[3] = 0x00 // @37AA stack[4] = 0x00 // } // Block ends with conditional jump to 0x37ba, if !(stack[-2] - stack[-1] i< 0x80) label_37B7: // Incoming jump from 0x37B6, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @37B7 stack[-3] // @37B9 memory[stack[-3]:stack[-3] + stack[-3]] // } 37B7 82 DUP3 37B8 83 DUP4 37B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @37B9 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_37BA: // Incoming jump from 0x37B6, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @37BB stack[-6] // @37BC msg.data[stack[-6]:stack[-6] + 0x20] // } 37BA 5B JUMPDEST 37BB 85 DUP6 37BC 35 CALLDATALOAD 37BD 67 PUSH8 0xffffffffffffffff 37C6 80 DUP1 37C7 82 DUP3 37C8 11 GT 37C9 15 ISZERO 37CA 61 PUSH2 0x37d1 37CD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @37BC stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @37BD stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x37d1, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) label_37CE: // Incoming jump from 0x37CD, if not !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @37CE stack[-5] // @37D0 memory[stack[-5]:stack[-5] + stack[-5]] // } 37CE 84 DUP5 37CF 85 DUP6 37D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @37D0 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_37D1: // Incoming jump from 0x37CD, if !(msg.data[stack[-6]:stack[-6] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @37D5 stack[-9] // @37D6 stack[-2] // @37D7 stack[-8] // } 37D1 5B JUMPDEST 37D2 61 PUSH2 0x37dd 37D5 89 DUP10 37D6 83 DUP4 37D7 8A DUP11 37D8 01 ADD 37D9 61 PUSH2 0x3206 37DC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @37D2 stack[0] = 0x37dd // @37D5 stack[1] = stack[-9] // @37D8 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x3206, returns to 0x37DD label_37DD: // Incoming return from call to 0x3206 at 0x37DC // Inputs[7] // { // @37DE stack[-1] // @37DE stack[-8] // @37E2 stack[-9] // @37E4 msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @37E5 stack[-7] // @37EB msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @37EC stack[-3] // } 37DD 5B JUMPDEST 37DE 96 SWAP7 37DF 50 POP 37E0 60 PUSH1 0x20 37E2 88 DUP9 37E3 01 ADD 37E4 35 CALLDATALOAD 37E5 95 SWAP6 37E6 50 POP 37E7 60 PUSH1 0x40 37E9 88 DUP9 37EA 01 ADD 37EB 35 CALLDATALOAD 37EC 91 SWAP2 37ED 50 POP 37EE 61 PUSH2 0x37f6 37F1 82 DUP3 37F2 61 PUSH2 0x43fe 37F5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @37DE stack[-8] = stack[-1] // @37E5 stack[-7] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @37EC stack[-3] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @37EE stack[-1] = 0x37f6 // @37F1 stack[0] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x37F6 label_37F6: // Incoming return from call to 0x43FE at 0x37F5 // Inputs[5] // { // @37F7 stack[-1] // @37F7 stack[-2] // @37F8 stack[-5] // @37FC stack[-8] // @37FE msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } 37F6 5B JUMPDEST 37F7 90 SWAP1 37F8 93 SWAP4 37F9 50 POP 37FA 60 PUSH1 0x60 37FC 87 DUP8 37FD 01 ADD 37FE 35 CALLDATALOAD 37FF 90 SWAP1 3800 80 DUP1 3801 82 DUP3 3802 11 GT 3803 15 ISZERO 3804 61 PUSH2 0x380b 3807 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @37F8 stack[-5] = stack[-2] // @37FF stack[-2] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @37FF stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x380b, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-1]) label_3808: // Incoming jump from 0x3807, if not !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-1]) // Inputs[2] // { // @3808 stack[-3] // @380A memory[stack[-3]:stack[-3] + stack[-3]] // } 3808 82 DUP3 3809 83 DUP4 380A FD *REVERT // Stack delta = +0 // Outputs[1] { @380A revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_380B: // Incoming jump from 0x3807, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > stack[-1]) // Inputs[3] // { // @3810 stack[-9] // @3811 stack[-2] // @3812 stack[-8] // } 380B 5B JUMPDEST 380C 50 POP 380D 61 PUSH2 0x3818 3810 88 DUP9 3811 82 DUP3 3812 89 DUP10 3813 01 ADD 3814 61 PUSH2 0x31c6 3817 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @380D stack[-1] = 0x3818 // @3810 stack[0] = stack[-9] // @3813 stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x31c6, returns to 0x3818 label_3818: // Incoming return from call to 0x31C6 at 0x3817 // Inputs[9] // { // @3819 stack[-8] // @3819 stack[-1] // @381A stack[-11] // @381B stack[-7] // @381C stack[-10] // @381E stack[-6] // @381E stack[-2] // @381F stack[-9] // @3821 stack[-3] // } 3818 5B JUMPDEST 3819 96 SWAP7 381A 99 SWAP10 381B 95 SWAP6 381C 98 SWAP9 381D 50 POP 381E 93 SWAP4 381F 96 SWAP7 3820 50 POP 3821 92 SWAP3 3822 94 SWAP5 3823 93 SWAP4 3824 92 SWAP3 3825 50 POP 3826 50 POP 3827 50 POP 3828 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @381A stack[-11] = stack[-8] // @381C stack[-10] = stack[-7] // @381F stack[-9] = stack[-6] // @3822 stack[-8] = stack[-2] // @3823 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_3829: // Incoming call from 0x03A4, returns to 0x03A5 // Inputs[2] // { // @3832 stack[-1] // @3833 stack[-2] // } 3829 5B JUMPDEST 382A 60 PUSH1 0x00 382C 80 DUP1 382D 60 PUSH1 0x00 382F 80 DUP1 3830 60 PUSH1 0x80 3832 85 DUP6 3833 87 DUP8 3834 03 SUB 3835 12 SLT 3836 15 ISZERO 3837 61 PUSH2 0x383e 383A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @382A stack[0] = 0x00 // @382C stack[1] = 0x00 // @382D stack[2] = 0x00 // @382F stack[3] = 0x00 // } // Block ends with conditional jump to 0x383e, if !(stack[-2] - stack[-1] i< 0x80) label_383B: // Incoming jump from 0x383A, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @383B stack[-2] // @383D memory[stack[-2]:stack[-2] + stack[-2]] // } 383B 81 DUP2 383C 82 DUP3 383D FD *REVERT // Stack delta = +0 // Outputs[1] { @383D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_383E: // Incoming jump from 0x383A, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @383F stack[-5] // @3840 msg.data[stack[-5]:stack[-5] + 0x20] // } 383E 5B JUMPDEST 383F 84 DUP5 3840 35 CALLDATALOAD 3841 67 PUSH8 0xffffffffffffffff 384A 81 DUP2 384B 11 GT 384C 15 ISZERO 384D 61 PUSH2 0x3854 3850 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3840 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] } // Block ends with conditional jump to 0x3854, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_3851: // Incoming jump from 0x3850, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3851 stack[-3] // @3853 memory[stack[-3]:stack[-3] + stack[-3]] // } 3851 82 DUP3 3852 83 DUP4 3853 FD *REVERT // Stack delta = +0 // Outputs[1] { @3853 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3854: // Incoming jump from 0x3850, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3858 stack[-7] // @3859 stack[-1] // @385A stack[-6] // } 3854 5B JUMPDEST 3855 61 PUSH2 0x3860 3858 87 DUP8 3859 82 DUP3 385A 88 DUP9 385B 01 ADD 385C 61 PUSH2 0x3206 385F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3855 stack[0] = 0x3860 // @3858 stack[1] = stack[-7] // @385B stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x3206, returns to 0x3860 label_3860: // Incoming return from call to 0x3206 at 0x385F // Inputs[6] // { // @3861 stack[-6] // @3861 stack[-1] // @3866 stack[-7] // @3868 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @3869 stack[-5] // @386F msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 3860 5B JUMPDEST 3861 94 SWAP5 3862 50 POP 3863 50 POP 3864 60 PUSH1 0x20 3866 85 DUP6 3867 01 ADD 3868 35 CALLDATALOAD 3869 92 SWAP3 386A 50 POP 386B 60 PUSH1 0x40 386D 85 DUP6 386E 01 ADD 386F 35 CALLDATALOAD 3870 61 PUSH2 0x3878 3873 81 DUP2 3874 61 PUSH2 0x43fe 3877 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3861 stack[-6] = stack[-1] // @3869 stack[-5] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @386F stack[-2] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3870 stack[-1] = 0x3878 // @3873 stack[0] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x3878 label_3878: // Incoming return from call to 0x43FE at 0x3877 // Inputs[8] // { // @3879 stack[-1] // @3879 stack[-5] // @387A stack[-8] // @387B stack[-4] // @387C stack[-7] // @387E stack[-2] // @387F stack[-6] // @3883 msg.data[0x60 + stack[-6]:0x60 + stack[-6] + 0x20] // } 3878 5B JUMPDEST 3879 93 SWAP4 387A 96 SWAP7 387B 92 SWAP3 387C 95 SWAP6 387D 50 POP 387E 92 SWAP3 387F 93 SWAP4 3880 60 PUSH1 0x60 3882 01 ADD 3883 35 CALLDATALOAD 3884 92 SWAP3 3885 50 POP 3886 50 POP 3887 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @387A stack[-8] = stack[-5] // @387C stack[-7] = stack[-4] // @387F stack[-6] = stack[-1] // @3884 stack[-5] = msg.data[0x60 + stack[-6]:0x60 + stack[-6] + 0x20] // } // Block ends with unconditional jump to stack[-8] label_3888: // Incoming call from 0x25E7, returns to 0x25E8 // Inputs[2] // { // @3890 stack[-1] // @3891 stack[-2] // } 3888 5B JUMPDEST 3889 60 PUSH1 0x00 388B 80 DUP1 388C 60 PUSH1 0x00 388E 60 PUSH1 0x60 3890 84 DUP5 3891 86 DUP7 3892 03 SUB 3893 12 SLT 3894 15 ISZERO 3895 61 PUSH2 0x389c 3898 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3889 stack[0] = 0x00 // @388B stack[1] = 0x00 // @388C stack[2] = 0x00 // } // Block ends with conditional jump to 0x389c, if !(stack[-2] - stack[-1] i< 0x60) label_3899: // Incoming jump from 0x3898, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3899 stack[-1] // @389B memory[stack[-1]:stack[-1] + stack[-1]] // } 3899 80 DUP1 389A 81 DUP2 389B FD *REVERT // Stack delta = +0 // Outputs[1] { @389B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_389C: // Incoming jump from 0x3898, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @389D stack[-4] // @389E memory[stack[-4]:stack[-4] + 0x20] // } 389C 5B JUMPDEST 389D 83 DUP4 389E 51 MLOAD 389F 61 PUSH2 0x38a7 38A2 81 DUP2 38A3 61 PUSH2 0x4423 38A6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @389E stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @389F stack[1] = 0x38a7 // @38A2 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x4423, returns to 0x38A7 label_38A7: // Incoming return from call to 0x4423 at 0x38A6 // Inputs[4] // { // @38AA stack[-5] // @38AC memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @38AD stack[-1] // @38AE stack[-4] // } 38A7 5B JUMPDEST 38A8 60 PUSH1 0x20 38AA 85 DUP6 38AB 01 ADD 38AC 51 MLOAD 38AD 90 SWAP1 38AE 93 SWAP4 38AF 50 POP 38B0 61 PUSH2 0x38b8 38B3 81 DUP2 38B4 61 PUSH2 0x4423 38B7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @38AD stack[-1] = memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @38AE stack[-4] = stack[-1] // @38B0 stack[0] = 0x38b8 // @38B3 stack[1] = memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x4423, returns to 0x38B8 label_38B8: // Incoming return from call to 0x4423 at 0x38B7 // Inputs[4] // { // @38BB stack[-5] // @38BD memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @38BE stack[-1] // @38BF stack[-3] // } 38B8 5B JUMPDEST 38B9 60 PUSH1 0x40 38BB 85 DUP6 38BC 01 ADD 38BD 51 MLOAD 38BE 90 SWAP1 38BF 92 SWAP3 38C0 50 POP 38C1 63 PUSH4 0xffffffff 38C6 81 DUP2 38C7 16 AND 38C8 81 DUP2 38C9 14 EQ 38CA 61 PUSH2 0x38d1 38CD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @38BE stack[-1] = memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @38BF stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x38d1, if memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff label_38CE: // Incoming jump from 0x38CD, if not memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff // Inputs[2] // { // @38CE stack[-2] // @38D0 memory[stack[-2]:stack[-2] + stack[-2]] // } 38CE 81 DUP2 38CF 82 DUP3 38D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @38D0 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_38D1: // Incoming jump from 0x38CD, if memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffffffff // Inputs[7] // { // @38D2 stack[-1] // @38D3 stack[-2] // @38D6 stack[-5] // @38D8 stack[-6] // @38D8 stack[-3] // @38DA stack[-4] // @38DA stack[-7] // } 38D1 5B JUMPDEST 38D2 80 DUP1 38D3 91 SWAP2 38D4 50 POP 38D5 50 POP 38D6 92 SWAP3 38D7 50 POP 38D8 92 SWAP3 38D9 50 POP 38DA 92 SWAP3 38DB 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @38D6 stack[-5] = stack[-1] // @38D8 stack[-6] = stack[-3] // @38DA stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_38DC: // Incoming call from 0x13E0, returns to 0x13E1 // Incoming call from 0x0E76, returns to 0x0E77 // Incoming call from 0x1881, returns to 0x1882 // Incoming call from 0x1051, returns to 0x1052 // Incoming call from 0x229E, returns to 0x229F // Incoming call from 0x14EE, returns to 0x14EF // Incoming call from 0x1359, returns to 0x135A // Incoming call from 0x1467, returns to 0x1468 // Inputs[2] // { // @38E1 stack[-1] // @38E2 stack[-2] // } 38DC 5B JUMPDEST 38DD 60 PUSH1 0x00 38DF 60 PUSH1 0x20 38E1 82 DUP3 38E2 84 DUP5 38E3 03 SUB 38E4 12 SLT 38E5 15 ISZERO 38E6 61 PUSH2 0x38ed 38E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @38DD stack[0] = 0x00 } // Block ends with conditional jump to 0x38ed, if !(stack[-2] - stack[-1] i< 0x20) label_38EA: // Incoming jump from 0x38E9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @38EA stack[-1] // @38EC memory[stack[-1]:stack[-1] + stack[-1]] // } 38EA 80 DUP1 38EB 81 DUP2 38EC FD *REVERT // Stack delta = +0 // Outputs[1] { @38EC revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_38ED: // Incoming jump from 0x38E9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @38EF memory[stack[-2]:stack[-2] + 0x20] // @38EF stack[-2] // @38F0 stack[-4] // @38F1 stack[-3] // } 38ED 5B JUMPDEST 38EE 50 POP 38EF 51 MLOAD 38F0 91 SWAP2 38F1 90 SWAP1 38F2 50 POP 38F3 56 *JUMP // Stack delta = -3 // Outputs[1] { @38F0 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] 38F4 5B JUMPDEST 38F5 60 PUSH1 0x00 38F7 80 DUP1 38F8 60 PUSH1 0x60 38FA 83 DUP4 38FB 85 DUP6 38FC 03 SUB 38FD 12 SLT 38FE 15 ISZERO 38FF 61 PUSH2 0x3906 3902 57 *JUMPI 3903 81 DUP2 3904 82 DUP3 3905 FD *REVERT 3906 5B JUMPDEST 3907 82 DUP3 3908 51 MLOAD 3909 91 SWAP2 390A 50 POP 390B 60 PUSH1 0x20 390D 84 DUP5 390E 60 PUSH1 0x3f 3910 85 DUP6 3911 01 ADD 3912 12 SLT 3913 61 PUSH2 0x391a 3916 57 *JUMPI 3917 81 DUP2 3918 82 DUP3 3919 FD *REVERT 391A 5B JUMPDEST 391B 61 PUSH2 0x3924 391E 60 PUSH1 0x40 3920 61 PUSH2 0x43ab 3923 56 *JUMP 3924 5B JUMPDEST 3925 80 DUP1 3926 82 DUP3 3927 86 DUP7 3928 01 ADD 3929 87 DUP8 392A 60 PUSH1 0x60 392C 88 DUP9 392D 01 ADD 392E 11 GT 392F 15 ISZERO 3930 61 PUSH2 0x3937 3933 57 *JUMPI 3934 84 DUP5 3935 85 DUP6 3936 FD *REVERT 3937 5B JUMPDEST 3938 84 DUP5 3939 5B JUMPDEST 393A 60 PUSH1 0x02 393C 81 DUP2 393D 10 LT 393E 15 ISZERO 393F 61 PUSH2 0x3956 3942 57 *JUMPI 3943 81 DUP2 3944 51 MLOAD 3945 84 DUP5 3946 52 MSTORE 3947 92 SWAP3 3948 84 DUP5 3949 01 ADD 394A 92 SWAP3 394B 90 SWAP1 394C 84 DUP5 394D 01 ADD 394E 90 SWAP1 394F 60 PUSH1 0x01 3951 01 ADD 3952 61 PUSH2 0x3939 3955 56 *JUMP 3956 5B JUMPDEST 3957 50 POP 3958 94 SWAP5 3959 97 SWAP8 395A 90 SWAP1 395B 96 SWAP7 395C 50 POP 395D 94 SWAP5 395E 50 POP 395F 50 POP 3960 50 POP 3961 50 POP 3962 50 POP 3963 56 *JUMP label_3964: // Incoming call from 0x0200, returns to 0x0201 // Inputs[2] // { // @396F stack[-1] // @3970 stack[-2] // } 3964 5B JUMPDEST 3965 60 PUSH1 0x00 3967 80 DUP1 3968 60 PUSH1 0x00 396A 80 DUP1 396B 60 PUSH1 0x00 396D 60 PUSH1 0xc0 396F 86 DUP7 3970 88 DUP9 3971 03 SUB 3972 12 SLT 3973 15 ISZERO 3974 61 PUSH2 0x397b 3977 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3965 stack[0] = 0x00 // @3967 stack[1] = 0x00 // @3968 stack[2] = 0x00 // @396A stack[3] = 0x00 // @396B stack[4] = 0x00 // } // Block ends with conditional jump to 0x397b, if !(stack[-2] - stack[-1] i< 0xc0) label_3978: // Incoming jump from 0x3977, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @3978 stack[-3] // @397A memory[stack[-3]:stack[-3] + stack[-3]] // } 3978 82 DUP3 3979 83 DUP4 397A FD *REVERT // Stack delta = +0 // Outputs[1] { @397A revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_397B: // Incoming jump from 0x3977, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[4] // { // @397C stack[-6] // @397D msg.data[stack[-6]:stack[-6] + 0x20] // @397E stack[-5] // @3984 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 397B 5B JUMPDEST 397C 85 DUP6 397D 35 CALLDATALOAD 397E 94 SWAP5 397F 50 POP 3980 60 PUSH1 0x20 3982 86 DUP7 3983 01 ADD 3984 35 CALLDATALOAD 3985 61 PUSH2 0x398d 3988 81 DUP2 3989 61 PUSH2 0x43fe 398C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @397E stack[-5] = msg.data[stack[-6]:stack[-6] + 0x20] // @3984 stack[0] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @3985 stack[1] = 0x398d // @3988 stack[2] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x398D label_398D: // Incoming return from call to 0x43FE at 0x398C // Inputs[4] // { // @398E stack[-5] // @398E stack[-1] // @3992 stack[-7] // @3994 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 398D 5B JUMPDEST 398E 93 SWAP4 398F 50 POP 3990 60 PUSH1 0x40 3992 86 DUP7 3993 01 ADD 3994 35 CALLDATALOAD 3995 61 PUSH2 0x399d 3998 81 DUP2 3999 61 PUSH2 0x43fe 399C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @398E stack[-5] = stack[-1] // @3994 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @3995 stack[0] = 0x399d // @3998 stack[1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x399D label_399D: // Incoming return from call to 0x43FE at 0x399C // Inputs[4] // { // @399E stack[-4] // @399E stack[-1] // @39A3 stack[-8] // @39A6 stack[-7] // } 399D 5B JUMPDEST 399E 92 SWAP3 399F 50 POP 39A0 61 PUSH2 0x39ac 39A3 87 DUP8 39A4 60 PUSH1 0x60 39A6 88 DUP9 39A7 01 ADD 39A8 61 PUSH2 0x30a3 39AB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @399E stack[-4] = stack[-1] // @39A0 stack[-1] = 0x39ac // @39A3 stack[0] = stack[-8] // @39A7 stack[1] = stack[-7] + 0x60 // } // Block ends with call to 0x30a3, returns to 0x39AC label_39AC: // Incoming return from call to 0x30A3 at 0x39AB // Inputs[4] // { // @39AD stack[-1] // @39AD stack[-3] // @39B1 stack[-7] // @39B3 msg.data[stack[-7] + 0xa0:stack[-7] + 0xa0 + 0x20] // } 39AC 5B JUMPDEST 39AD 91 SWAP2 39AE 50 POP 39AF 60 PUSH1 0xa0 39B1 86 DUP7 39B2 01 ADD 39B3 35 CALLDATALOAD 39B4 61 PUSH2 0x39bc 39B7 81 DUP2 39B8 61 PUSH2 0x43fe 39BB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @39AD stack[-3] = stack[-1] // @39B3 stack[-1] = msg.data[stack[-7] + 0xa0:stack[-7] + 0xa0 + 0x20] // @39B4 stack[0] = 0x39bc // @39B7 stack[1] = msg.data[stack[-7] + 0xa0:stack[-7] + 0xa0 + 0x20] // } // Block ends with call to 0x43fe, returns to 0x39BC label_39BC: // Incoming return from call to 0x43FE at 0x39BB // Inputs[9] // { // @39BD stack[-1] // @39BE stack[-2] // @39C1 stack[-5] // @39C2 stack[-8] // @39C4 stack[-6] // @39C4 stack[-3] // @39C5 stack[-9] // @39C6 stack[-4] // @39C7 stack[-7] // } 39BC 5B JUMPDEST 39BD 80 DUP1 39BE 91 SWAP2 39BF 50 POP 39C0 50 POP 39C1 92 SWAP3 39C2 95 SWAP6 39C3 50 POP 39C4 92 SWAP3 39C5 95 SWAP6 39C6 90 SWAP1 39C7 93 SWAP4 39C8 50 POP 39C9 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @39C1 stack[-5] = stack[-1] // @39C2 stack[-8] = stack[-5] // @39C4 stack[-6] = stack[-3] // @39C5 stack[-9] = stack[-6] // @39C7 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_39CA: // Incoming call from 0x0297, returns to 0x0298 // Inputs[2] // { // @39D0 stack[-1] // @39D1 stack[-2] // } 39CA 5B JUMPDEST 39CB 60 PUSH1 0x00 39CD 80 DUP1 39CE 60 PUSH1 0x40 39D0 83 DUP4 39D1 85 DUP6 39D2 03 SUB 39D3 12 SLT 39D4 15 ISZERO 39D5 61 PUSH2 0x39dc 39D8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @39CB stack[0] = 0x00 // @39CD stack[1] = 0x00 // } // Block ends with conditional jump to 0x39dc, if !(stack[-2] - stack[-1] i< 0x40) label_39D9: // Incoming jump from 0x39D8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @39D9 stack[-2] // @39DB memory[stack[-2]:stack[-2] + stack[-2]] // } 39D9 81 DUP2 39DA 82 DUP3 39DB FD *REVERT // Stack delta = +0 // Outputs[1] { @39DB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_39DC: // Incoming jump from 0x39D8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @39DF stack[-3] // @39E0 msg.data[stack[-3]:stack[-3] + 0x20] // @39E1 stack[-5] // @39E7 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @39E8 stack[-4] // } 39DC 5B JUMPDEST 39DD 50 POP 39DE 50 POP 39DF 80 DUP1 39E0 35 CALLDATALOAD 39E1 92 SWAP3 39E2 60 PUSH1 0x20 39E4 90 SWAP1 39E5 91 SWAP2 39E6 01 ADD 39E7 35 CALLDATALOAD 39E8 91 SWAP2 39E9 50 POP 39EA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @39E1 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @39E8 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_39EB: // Incoming call from 0x1204, returns to 0x1205 // Incoming call from 0x17AA, returns to 0x17AB // Inputs[2] // { // @39F1 stack[-1] // @39F2 stack[-2] // } 39EB 5B JUMPDEST 39EC 60 PUSH1 0x00 39EE 80 DUP1 39EF 60 PUSH1 0x40 39F1 83 DUP4 39F2 85 DUP6 39F3 03 SUB 39F4 12 SLT 39F5 15 ISZERO 39F6 61 PUSH2 0x39fd 39F9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @39EC stack[0] = 0x00 // @39EE stack[1] = 0x00 // } // Block ends with conditional jump to 0x39fd, if !(stack[-2] - stack[-1] i< 0x40) label_39FA: // Incoming jump from 0x39F9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @39FA stack[-2] // @39FC memory[stack[-2]:stack[-2] + stack[-2]] // } 39FA 81 DUP2 39FB 82 DUP3 39FC FD *REVERT // Stack delta = +0 // Outputs[1] { @39FC revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_39FD: // Incoming jump from 0x39F9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @3A00 stack[-3] // @3A01 memory[stack[-3]:stack[-3] + 0x20] // @3A07 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3A09 stack[-5] // @3A0B stack[-4] // } 39FD 5B JUMPDEST 39FE 50 POP 39FF 50 POP 3A00 80 DUP1 3A01 51 MLOAD 3A02 60 PUSH1 0x20 3A04 90 SWAP1 3A05 91 SWAP2 3A06 01 ADD 3A07 51 MLOAD 3A08 90 SWAP1 3A09 92 SWAP3 3A0A 90 SWAP1 3A0B 91 SWAP2 3A0C 50 POP 3A0D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3A09 stack[-5] = memory[stack[-3]:stack[-3] + 0x20] // @3A0B stack[-4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_3A0E: // Incoming call from 0x0240, returns to 0x0241 // Inputs[2] // { // @3A16 stack[-1] // @3A17 stack[-2] // } 3A0E 5B JUMPDEST 3A0F 60 PUSH1 0x00 3A11 80 DUP1 3A12 60 PUSH1 0x00 3A14 60 PUSH1 0x60 3A16 84 DUP5 3A17 86 DUP7 3A18 03 SUB 3A19 12 SLT 3A1A 15 ISZERO 3A1B 61 PUSH2 0x3a22 3A1E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3A0F stack[0] = 0x00 // @3A11 stack[1] = 0x00 // @3A12 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3a22, if !(stack[-2] - stack[-1] i< 0x60) label_3A1F: // Incoming jump from 0x3A1E, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3A1F stack[-1] // @3A21 memory[stack[-1]:stack[-1] + stack[-1]] // } 3A1F 80 DUP1 3A20 81 DUP2 3A21 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A21 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3A22: // Incoming jump from 0x3A1E, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[7] // { // @3A25 stack[-4] // @3A26 msg.data[stack[-4]:stack[-4] + 0x20] // @3A27 stack[-6] // @3A2C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @3A2D stack[-5] // @3A34 msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @3A36 stack[-3] // } 3A22 5B JUMPDEST 3A23 50 POP 3A24 50 POP 3A25 81 DUP2 3A26 35 CALLDATALOAD 3A27 93 SWAP4 3A28 60 PUSH1 0x20 3A2A 83 DUP4 3A2B 01 ADD 3A2C 35 CALLDATALOAD 3A2D 93 SWAP4 3A2E 50 POP 3A2F 60 PUSH1 0x40 3A31 90 SWAP1 3A32 92 SWAP3 3A33 01 ADD 3A34 35 CALLDATALOAD 3A35 91 SWAP2 3A36 90 SWAP1 3A37 50 POP 3A38 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3A27 stack[-6] = msg.data[stack[-4]:stack[-4] + 0x20] // @3A2D stack[-5] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @3A35 stack[-4] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-6] label_3A39: // Incoming call from 0x12AC, returns to 0x12AD // Inputs[2] // { // @3A3E stack[-1] // @3A3F stack[-2] // } 3A39 5B JUMPDEST 3A3A 60 PUSH1 0x00 3A3C 60 PUSH1 0x20 3A3E 82 DUP3 3A3F 84 DUP5 3A40 03 SUB 3A41 12 SLT 3A42 15 ISZERO 3A43 61 PUSH2 0x3a4a 3A46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A3A stack[0] = 0x00 } // Block ends with conditional jump to 0x3a4a, if !(stack[-2] - stack[-1] i< 0x20) label_3A47: // Incoming jump from 0x3A46, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3A47 stack[-1] // @3A49 memory[stack[-1]:stack[-1] + stack[-1]] // } 3A47 80 DUP1 3A48 81 DUP2 3A49 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A49 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3A4A: // Incoming jump from 0x3A46, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3A4B stack[-2] // @3A4C memory[stack[-2]:stack[-2] + 0x20] // } 3A4A 5B JUMPDEST 3A4B 81 DUP2 3A4C 51 MLOAD 3A4D 60 PUSH1 0xff 3A4F 81 DUP2 3A50 16 AND 3A51 81 DUP2 3A52 14 EQ 3A53 61 PUSH2 0x0b19 3A56 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A4C stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0b19, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] & 0xff label_3A57: // Incoming jump from 0x3A56, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] & 0xff // Inputs[2] // { // @3A57 stack[-2] // @3A59 memory[stack[-2]:stack[-2] + stack[-2]] // } 3A57 81 DUP2 3A58 82 DUP3 3A59 FD *REVERT // Stack delta = +0 // Outputs[1] { @3A59 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3A5A: // Incoming call from 0x3DC0, returns to 0x3DC1 // Inputs[7] // { // @3A5D stack[-1] // @3A5E msg.data[stack[-1]:stack[-1] + 0x20] // @3A5F stack[-2] // @3A65 msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @3A6F msg.data[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @3A79 msg.data[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] // @3A9C msg.data.length // } 3A5A 5B JUMPDEST 3A5B 60 PUSH1 0x00 3A5D 81 DUP2 3A5E 35 CALLDATALOAD 3A5F 83 DUP4 3A60 52 MSTORE 3A61 60 PUSH1 0x20 3A63 82 DUP3 3A64 01 ADD 3A65 35 CALLDATALOAD 3A66 60 PUSH1 0x20 3A68 84 DUP5 3A69 01 ADD 3A6A 52 MSTORE 3A6B 60 PUSH1 0x40 3A6D 82 DUP3 3A6E 01 ADD 3A6F 35 CALLDATALOAD 3A70 60 PUSH1 0x40 3A72 84 DUP5 3A73 01 ADD 3A74 52 MSTORE 3A75 60 PUSH1 0x60 3A77 82 DUP3 3A78 01 ADD 3A79 35 CALLDATALOAD 3A7A 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 3A9B 83 DUP4 3A9C 36 CALLDATASIZE 3A9D 03 SUB 3A9E 01 ADD 3A9F 81 DUP2 3AA0 12 SLT 3AA1 61 PUSH2 0x3aa8 3AA4 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @3A5B stack[0] = 0x00 // @3A60 memory[stack[-2]:stack[-2] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @3A6A memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @3A74 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = msg.data[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @3A79 stack[1] = msg.data[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x3aa8, if msg.data[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 label_3AA5: // Incoming jump from 0x3AA4, if not msg.data[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[2] // { // @3AA5 stack[-2] // @3AA7 memory[stack[-2]:stack[-2] + stack[-2]] // } 3AA5 81 DUP2 3AA6 82 DUP3 3AA7 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AA7 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3AA8: // Incoming jump from 0x3AA4, if msg.data[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[3] // { // @3AA9 stack[-3] // @3AAA stack[-1] // @3AAC msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] // } 3AA8 5B JUMPDEST 3AA9 82 DUP3 3AAA 01 ADD 3AAB 80 DUP1 3AAC 35 CALLDATALOAD 3AAD 67 PUSH8 0xffffffffffffffff 3AB6 81 DUP2 3AB7 11 GT 3AB8 15 ISZERO 3AB9 61 PUSH2 0x3ac0 3ABC 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3AAA stack[-1] = stack[-3] + stack[-1] // @3AAC stack[0] = msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x3ac0, if !(msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > 0xffffffffffffffff) label_3ABD: // Incoming jump from 0x3ABC, if not !(msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3ABD stack[-3] // @3ABF memory[stack[-3]:stack[-3] + stack[-3]] // } 3ABD 82 DUP3 3ABE 83 DUP4 3ABF FD *REVERT // Stack delta = +0 // Outputs[1] { @3ABF revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3AC0: // Incoming jump from 0x3ABC, if !(msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3AC1 stack[-1] // @3AC2 msg.data.length // @3AC4 stack[-4] // } 3AC0 5B JUMPDEST 3AC1 80 DUP1 3AC2 36 CALLDATASIZE 3AC3 03 SUB 3AC4 84 DUP5 3AC5 13 SGT 3AC6 15 ISZERO 3AC7 61 PUSH2 0x3ace 3ACA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3ace, if !(stack[-4] i> msg.data.length - stack[-1]) label_3ACB: // Incoming jump from 0x3ACA, if not !(stack[-4] i> msg.data.length - stack[-1]) // Inputs[2] // { // @3ACB stack[-3] // @3ACD memory[stack[-3]:stack[-3] + stack[-3]] // } 3ACB 82 DUP3 3ACC 83 DUP4 3ACD FD *REVERT // Stack delta = +0 // Outputs[1] { @3ACD revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3ACE: // Incoming jump from 0x3ACA, if !(stack[-4] i> msg.data.length - stack[-1]) // Inputs[6] // { // @3AD3 stack[-5] // @3AD6 stack[-1] // @3ADF stack[-2] // @3AE5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] // @3AEE stack[-3] // @3B1B stack[-6] // } 3ACE 5B JUMPDEST 3ACF 60 PUSH1 0x80 3AD1 60 PUSH1 0x60 3AD3 86 DUP7 3AD4 01 ADD 3AD5 52 MSTORE 3AD6 80 DUP1 3AD7 60 PUSH1 0x80 3AD9 86 DUP7 3ADA 01 ADD 3ADB 52 MSTORE 3ADC 80 DUP1 3ADD 60 PUSH1 0x20 3ADF 83 DUP4 3AE0 01 ADD 3AE1 60 PUSH1 0xa0 3AE3 87 DUP8 3AE4 01 ADD 3AE5 37 CALLDATACOPY 3AE6 84 DUP5 3AE7 81 DUP2 3AE8 01 ADD 3AE9 60 PUSH1 0xa0 3AEB 90 SWAP1 3AEC 81 DUP2 3AED 01 ADD 3AEE 93 SWAP4 3AEF 90 SWAP1 3AF0 93 SWAP4 3AF1 52 MSTORE 3AF2 60 PUSH1 0x1f 3AF4 01 ADD 3AF5 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 3B16 16 AND 3B17 90 SWAP1 3B18 93 SWAP4 3B19 01 ADD 3B1A 01 ADD 3B1B 92 SWAP3 3B1C 91 SWAP2 3B1D 50 POP 3B1E 50 POP 3B1F 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @3AD5 memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] = 0x80 // @3ADB memory[stack[-5] + 0x80:stack[-5] + 0x80 + 0x20] = stack[-1] // @3AE5 memory[stack[-5] + 0xa0:stack[-5] + 0xa0 + stack[-1]] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] // @3AF1 memory[0xa0 + stack[-1] + stack[-5]:0xa0 + stack[-1] + stack[-5] + 0x20] = stack[-3] // @3B1B stack[-6] = stack[-5] + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) + 0xa0 // } // Block ends with unconditional jump to stack[-6] 3B20 5B JUMPDEST 3B21 80 DUP1 3B22 60 PUSH1 0x00 3B24 5B JUMPDEST 3B25 60 PUSH1 0x02 3B27 81 DUP2 3B28 10 LT 3B29 15 ISZERO 3B2A 61 PUSH2 0x0a5d 3B2D 57 *JUMPI 3B2E 81 DUP2 3B2F 51 MLOAD 3B30 84 DUP5 3B31 52 MSTORE 3B32 60 PUSH1 0x20 3B34 93 SWAP4 3B35 84 DUP5 3B36 01 ADD 3B37 93 SWAP4 3B38 90 SWAP1 3B39 91 SWAP2 3B3A 01 ADD 3B3B 90 SWAP1 3B3C 60 PUSH1 0x01 3B3E 01 ADD 3B3F 61 PUSH2 0x3b24 3B42 56 *JUMP label_3B43: // Incoming call from 0x08C7, returns to 0x08C8 // Incoming call from 0x0950, returns to 0x0951 // Incoming call from 0x0FB2, returns to 0x0FB3 // Incoming call from 0x0DA4, returns to 0x0DA5 // Inputs[5] // { // @3B46 stack[-2] // @3B47 stack[-3] // @3B48 stack[-1] // @3B49 msg.data[stack[-3]:stack[-3] + stack[-2]] // @3B4F stack[-4] // } 3B43 5B JUMPDEST 3B44 60 PUSH1 0x00 3B46 82 DUP3 3B47 84 DUP5 3B48 83 DUP4 3B49 37 CALLDATACOPY 3B4A 91 SWAP2 3B4B 01 ADD 3B4C 90 SWAP1 3B4D 81 DUP2 3B4E 52 MSTORE 3B4F 91 SWAP2 3B50 90 SWAP1 3B51 50 POP 3B52 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3B49 memory[stack[-1]:stack[-1] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @3B4E memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] = 0x00 // @3B4F stack[-4] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_3B53: // Incoming jump from 0x29AF // Incoming jump from 0x2CEE // Incoming jump from 0x1A59 // Incoming jump from 0x1ADA // Inputs[3] // { // @3B56 stack[-2] // @3B57 memory[stack[-2]:stack[-2] + 0x20] // @3B5C stack[-1] // } 3B53 5B JUMPDEST 3B54 60 PUSH1 0x00 3B56 82 DUP3 3B57 51 MLOAD 3B58 61 PUSH2 0x3b65 3B5B 81 DUP2 3B5C 84 DUP5 3B5D 60 PUSH1 0x20 3B5F 87 DUP8 3B60 01 ADD 3B61 61 PUSH2 0x43d2 3B64 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3B54 stack[0] = 0x00 // @3B57 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @3B58 stack[2] = 0x3b65 // @3B5B stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @3B5C stack[4] = stack[-1] // @3B60 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3B65 label_3B65: // Incoming jump from 0x43A7, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 // Incoming return from call to 0x43D2 at 0x3B64 // Inputs[5] // { // @3B66 stack[-1] // @3B66 stack[-3] // @3B67 stack[-2] // @3B6A stack[-5] // @3B6B stack[-4] // } 3B65 5B JUMPDEST 3B66 91 SWAP2 3B67 90 SWAP1 3B68 91 SWAP2 3B69 01 ADD 3B6A 92 SWAP3 3B6B 91 SWAP2 3B6C 50 POP 3B6D 50 POP 3B6E 56 *JUMP // Stack delta = -4 // Outputs[1] { @3B6A stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] 3B6F 5B JUMPDEST 3B70 60 PUSH1 0x00 3B72 83 DUP4 3B73 51 MLOAD 3B74 61 PUSH2 0x3b81 3B77 81 DUP2 3B78 84 DUP5 3B79 60 PUSH1 0x20 3B7B 88 DUP9 3B7C 01 ADD 3B7D 61 PUSH2 0x43d2 3B80 56 *JUMP 3B81 5B JUMPDEST 3B82 7F PUSH32 0x50616e6963280000000000000000000000000000000000000000000000000000 3BA3 90 SWAP1 3BA4 83 DUP4 3BA5 01 ADD 3BA6 90 SWAP1 3BA7 81 DUP2 3BA8 52 MSTORE 3BA9 83 DUP4 3BAA 51 MLOAD 3BAB 61 PUSH2 0x3bbb 3BAE 81 DUP2 3BAF 60 PUSH1 0x06 3BB1 84 DUP5 3BB2 01 ADD 3BB3 60 PUSH1 0x20 3BB5 88 DUP9 3BB6 01 ADD 3BB7 61 PUSH2 0x43d2 3BBA 56 *JUMP label_3BBB: // Incoming return from call to 0x43D2 at 0x3CBE // Inputs[4] // { // @3BDF stack[-2] // @3BE1 stack[-1] // @3BEA stack[-7] // @3BEB stack[-6] // } 3BBB 5B JUMPDEST 3BBC 7F PUSH32 0x2900000000000000000000000000000000000000000000000000000000000000 3BDD 60 PUSH1 0x06 3BDF 92 SWAP3 3BE0 90 SWAP1 3BE1 91 SWAP2 3BE2 01 ADD 3BE3 91 SWAP2 3BE4 82 DUP3 3BE5 01 ADD 3BE6 52 MSTORE 3BE7 60 PUSH1 0x07 3BE9 01 ADD 3BEA 94 SWAP5 3BEB 93 SWAP4 3BEC 50 POP 3BED 50 POP 3BEE 50 POP 3BEF 50 POP 3BF0 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @3BE6 memory[stack[-1] + stack[-2] + 0x06:stack[-1] + stack[-2] + 0x06 + 0x20] = 0x2900000000000000000000000000000000000000000000000000000000000000 // @3BEA stack[-7] = 0x07 + stack[-1] + stack[-2] // } // Block ends with unconditional jump to stack[-7] label_3BF1: // Incoming call from 0x21A1, returns to 0x21A2 // Inputs[3] // { // @3BF4 stack[-3] // @3BF5 memory[stack[-3]:stack[-3] + 0x20] // @3BFA stack[-1] // } 3BF1 5B JUMPDEST 3BF2 60 PUSH1 0x00 3BF4 83 DUP4 3BF5 51 MLOAD 3BF6 61 PUSH2 0x3c03 3BF9 81 DUP2 3BFA 84 DUP5 3BFB 60 PUSH1 0x20 3BFD 88 DUP9 3BFE 01 ADD 3BFF 61 PUSH2 0x43d2 3C02 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3BF2 stack[0] = 0x00 // @3BF5 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @3BF6 stack[2] = 0x3c03 // @3BF9 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @3BFA stack[4] = stack[-1] // @3BFE stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3C03 label_3C03: // Incoming return from call to 0x43D2 at 0x3C02 // Inputs[4] // { // @3C25 stack[-1] // @3C26 stack[-3] // @3C2B stack[-4] // @3C2C memory[stack[-4]:stack[-4] + 0x20] // } 3C03 5B JUMPDEST 3C04 7F PUSH32 0x556e6b6e6f776e28000000000000000000000000000000000000000000000000 3C25 90 SWAP1 3C26 83 DUP4 3C27 01 ADD 3C28 90 SWAP1 3C29 81 DUP2 3C2A 52 MSTORE 3C2B 83 DUP4 3C2C 51 MLOAD 3C2D 61 PUSH2 0x3c3d 3C30 81 DUP2 3C31 60 PUSH1 0x08 3C33 84 DUP5 3C34 01 ADD 3C35 60 PUSH1 0x20 3C37 88 DUP9 3C38 01 ADD 3C39 61 PUSH2 0x43d2 3C3C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @3C28 stack[-1] = stack[-3] + stack[-1] // @3C2A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = 0x556e6b6e6f776e28000000000000000000000000000000000000000000000000 // @3C2C stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3C2D stack[1] = 0x3c3d // @3C30 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3C34 stack[3] = stack[-3] + stack[-1] + 0x08 // @3C38 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3C3D label_3C3D: // Incoming return from call to 0x43D2 at 0x3C3C // Inputs[4] // { // @3C61 stack[-2] // @3C63 stack[-1] // @3C6C stack[-7] // @3C6D stack[-6] // } 3C3D 5B JUMPDEST 3C3E 7F PUSH32 0x2900000000000000000000000000000000000000000000000000000000000000 3C5F 60 PUSH1 0x08 3C61 92 SWAP3 3C62 90 SWAP1 3C63 91 SWAP2 3C64 01 ADD 3C65 91 SWAP2 3C66 82 DUP3 3C67 01 ADD 3C68 52 MSTORE 3C69 60 PUSH1 0x09 3C6B 01 ADD 3C6C 94 SWAP5 3C6D 93 SWAP4 3C6E 50 POP 3C6F 50 POP 3C70 50 POP 3C71 50 POP 3C72 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @3C68 memory[stack[-1] + stack[-2] + 0x08:stack[-1] + stack[-2] + 0x08 + 0x20] = 0x2900000000000000000000000000000000000000000000000000000000000000 // @3C6C stack[-7] = 0x09 + stack[-1] + stack[-2] // } // Block ends with unconditional jump to stack[-7] label_3C73: // Incoming call from 0x1FC9, returns to 0x1FCA // Inputs[3] // { // @3C76 stack[-3] // @3C77 memory[stack[-3]:stack[-3] + 0x20] // @3C7C stack[-1] // } 3C73 5B JUMPDEST 3C74 60 PUSH1 0x00 3C76 83 DUP4 3C77 51 MLOAD 3C78 61 PUSH2 0x3c85 3C7B 81 DUP2 3C7C 84 DUP5 3C7D 60 PUSH1 0x20 3C7F 88 DUP9 3C80 01 ADD 3C81 61 PUSH2 0x43d2 3C84 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3C74 stack[0] = 0x00 // @3C77 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @3C78 stack[2] = 0x3c85 // @3C7B stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @3C7C stack[4] = stack[-1] // @3C80 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3C85 label_3C85: // Incoming return from call to 0x43D2 at 0x3C84 // Inputs[4] // { // @3CA7 stack[-1] // @3CA8 stack[-3] // @3CAD stack[-4] // @3CAE memory[stack[-4]:stack[-4] + 0x20] // } 3C85 5B JUMPDEST 3C86 7F PUSH32 0x4572726f72280000000000000000000000000000000000000000000000000000 3CA7 90 SWAP1 3CA8 83 DUP4 3CA9 01 ADD 3CAA 90 SWAP1 3CAB 81 DUP2 3CAC 52 MSTORE 3CAD 83 DUP4 3CAE 51 MLOAD 3CAF 61 PUSH2 0x3bbb 3CB2 81 DUP2 3CB3 60 PUSH1 0x06 3CB5 84 DUP5 3CB6 01 ADD 3CB7 60 PUSH1 0x20 3CB9 88 DUP9 3CBA 01 ADD 3CBB 61 PUSH2 0x43d2 3CBE 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @3CAA stack[-1] = stack[-3] + stack[-1] // @3CAC memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = 0x4572726f72280000000000000000000000000000000000000000000000000000 // @3CAE stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3CAF stack[1] = 0x3bbb // @3CB2 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3CB6 stack[3] = stack[-3] + stack[-1] + 0x06 // @3CBA stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3BBB label_3CBF: // Incoming call from 0x189D, returns to 0x189E // Incoming call from 0x2A7A, returns to 0x2A7B // Incoming call from 0x02A9, returns to 0x0254 // Inputs[3] // { // @3CC0 stack[-1] // @3CC0 stack[-2] // @3CC6 stack[-3] // } 3CBF 5B JUMPDEST 3CC0 90 SWAP1 3CC1 81 DUP2 3CC2 52 MSTORE 3CC3 60 PUSH1 0x20 3CC5 01 ADD 3CC6 90 SWAP1 3CC7 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3CC2 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @3CC6 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3CC8: // Incoming call from 0x224E, returns to 0x224F // Incoming call from 0x1831, returns to 0x1832 // Incoming call from 0x1759, returns to 0x175A // Inputs[3] // { // @3CDE stack[-2] // @3CDF stack[-1] // @3CE7 stack[-3] // } 3CC8 5B JUMPDEST 3CC9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3CDE 91 SWAP2 3CDF 90 SWAP1 3CE0 91 SWAP2 3CE1 16 AND 3CE2 81 DUP2 3CE3 52 MSTORE 3CE4 60 PUSH1 0x20 3CE6 01 ADD 3CE7 90 SWAP1 3CE8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3CE3 memory[stack[-1]:stack[-1] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @3CE7 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3CE9: // Incoming call from 0x0253, returns to 0x0254 // Incoming call from 0x2321, returns to 0x2322 // Incoming call from 0x2926, returns to 0x2927 // Inputs[4] // { // @3CFF stack[-3] // @3D00 stack[-1] // @3D09 stack[-2] // @3D0D stack[-4] // } 3CE9 5B JUMPDEST 3CEA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3CFF 92 SWAP3 3D00 90 SWAP1 3D01 92 SWAP3 3D02 16 AND 3D03 82 DUP3 3D04 52 MSTORE 3D05 60 PUSH1 0x20 3D07 82 DUP3 3D08 01 ADD 3D09 52 MSTORE 3D0A 60 PUSH1 0x40 3D0C 01 ADD 3D0D 90 SWAP1 3D0E 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3D04 memory[stack[-1]:stack[-1] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @3D09 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-2] // @3D0D stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 3D0F 5B JUMPDEST 3D10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3D25 92 SWAP3 3D26 90 SWAP1 3D27 92 SWAP3 3D28 16 AND 3D29 82 DUP3 3D2A 52 MSTORE 3D2B 60 PUSH1 0xff 3D2D 16 AND 3D2E 60 PUSH1 0x20 3D30 82 DUP3 3D31 01 ADD 3D32 52 MSTORE 3D33 60 PUSH1 0x40 3D35 01 ADD 3D36 90 SWAP1 3D37 56 *JUMP label_3D38: // Incoming call from 0x0C3B, returns to 0x0C3C // Inputs[3] // { // @3D3C stack[-1] // @3D40 stack[-5] // @3D53 stack[-6] // } 3D38 5B JUMPDEST 3D39 60 PUSH1 0x80 3D3B 80 DUP1 3D3C 82 DUP3 3D3D 52 MSTORE 3D3E 81 DUP2 3D3F 01 ADD 3D40 85 DUP6 3D41 90 SWAP1 3D42 52 MSTORE 3D43 60 PUSH1 0x00 3D45 60 PUSH1 0x20 3D47 60 PUSH1 0xa0 3D49 80 DUP1 3D4A 84 DUP5 3D4B 01 ADD 3D4C 90 SWAP1 3D4D 82 DUP3 3D4E 89 DUP10 3D4F 02 MUL 3D50 85 DUP6 3D51 01 ADD 3D52 01 ADD 3D53 89 DUP10 3D54 84 DUP5 3D55 5B JUMPDEST 3D56 8A DUP11 3D57 81 DUP2 3D58 10 LT 3D59 15 ISZERO 3D5A 61 PUSH2 0x3dd4 3D5D 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @3D3D memory[stack[-1]:stack[-1] + 0x20] = 0x80 // @3D42 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = stack[-5] // @3D43 stack[0] = 0x00 // @3D45 stack[1] = 0x20 // @3D4C stack[2] = stack[-1] + 0xa0 // @3D52 stack[3] = stack[-1] + stack[-5] * 0x20 + 0xa0 // @3D53 stack[4] = stack[-6] // @3D54 stack[5] = 0x00 // } // Block ends with conditional jump to 0x3dd4, if !(0x00 < stack[-5]) label_3D5E: // Incoming jump from 0x3D5D, if not !(0x00 < stack[-5]) // Incoming jump from 0x3D5D, if not !(stack[-1] < stack[-11]) // Inputs[7] // { // @3D7F stack[-7] // @3D80 stack[-3] // @3D83 stack[-4] // @3D85 stack[-2] // @3D86 msg.data[stack[-2]:stack[-2] + 0x20] // @3DA8 stack[-12] // @3DA9 msg.data.length // } 3D5E 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60 3D7F 87 DUP8 3D80 84 DUP5 3D81 03 SUB 3D82 01 ADD 3D83 84 DUP5 3D84 52 MSTORE 3D85 81 DUP2 3D86 35 CALLDATALOAD 3D87 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 3DA8 8D DUP14 3DA9 36 CALLDATASIZE 3DAA 03 SUB 3DAB 01 ADD 3DAC 81 DUP2 3DAD 12 SLT 3DAE 61 PUSH2 0x3db5 3DB1 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3D84 memory[stack[-4]:stack[-4] + 0x20] = stack[-3] - stack[-7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60 // @3D86 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x3db5, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-12] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 label_3DB2: // Incoming jump from 0x3DB1, if not msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-12] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 // Inputs[2] // { // @3DB2 stack[-7] // @3DB4 memory[stack[-7]:stack[-7] + stack[-7]] // } 3DB2 86 DUP7 3DB3 87 DUP8 3DB4 FD *REVERT // Stack delta = +0 // Outputs[1] { @3DB4 revert(memory[stack[-7]:stack[-7] + stack[-7]]); } // Block terminates label_3DB5: // Incoming jump from 0x3DB1, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-12] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 // Inputs[3] // { // @3DB9 stack[-4] // @3DBA stack[-13] // @3DBB stack[-1] // } 3DB5 5B JUMPDEST 3DB6 61 PUSH2 0x3dc1 3DB9 84 DUP5 3DBA 8E DUP15 3DBB 83 DUP4 3DBC 01 ADD 3DBD 61 PUSH2 0x3a5a 3DC0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3DB6 stack[0] = 0x3dc1 // @3DB9 stack[1] = stack[-4] // @3DBC stack[2] = stack[-1] + stack[-13] // } // Block ends with call to 0x3a5a, returns to 0x3DC1 label_3DC1: // Incoming return from call to 0x3A5A at 0x3DC0 // Inputs[6] // { // @3DC2 stack[-6] // @3DC2 stack[-1] // @3DC3 stack[-7] // @3DC6 stack[-5] // @3DC9 stack[-3] // @3DC9 stack[-4] // } 3DC1 5B JUMPDEST 3DC2 94 SWAP5 3DC3 86 DUP7 3DC4 01 ADD 3DC5 94 SWAP5 3DC6 93 SWAP4 3DC7 50 POP 3DC8 50 POP 3DC9 90 SWAP1 3DCA 84 DUP5 3DCB 01 ADD 3DCC 90 SWAP1 3DCD 60 PUSH1 0x01 3DCF 01 ADD 3DD0 61 PUSH2 0x3d55 3DD3 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @3DC5 stack[-6] = stack[-7] + stack[-6] // @3DC6 stack[-5] = stack[-1] // @3DCC stack[-4] = stack[-7] + stack[-4] // @3DCF stack[-3] = 0x01 + stack[-3] // } // Block ends with unconditional jump to 0x3d55 label_3DD4: // Incoming jump from 0x3D5D, if !(0x00 < stack[-5]) // Incoming jump from 0x3D5D, if !(stack[-1] < stack[-11]) // Inputs[9] // { // @3DEC stack[-10] // @3DEF stack[-5] // @3DF0 stack[-7] // @3DF3 stack[-3] // @3DF7 stack[-9] // @3DF8 stack[-6] // @3E03 stack[-8] // @3E04 stack[-13] // @3E05 stack[-12] // } 3DD4 5B JUMPDEST 3DD5 50 POP 3DD6 50 POP 3DD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3DEC 97 SWAP8 3DED 88 DUP9 3DEE 16 AND 3DEF 92 SWAP3 3DF0 85 DUP6 3DF1 01 ADD 3DF2 92 SWAP3 3DF3 90 SWAP1 3DF4 92 SWAP3 3DF5 52 MSTORE 3DF6 50 POP 3DF7 93 SWAP4 3DF8 90 SWAP1 3DF9 94 SWAP5 3DFA 16 AND 3DFB 60 PUSH1 0x40 3DFD 82 DUP3 3DFE 01 ADD 3DFF 52 MSTORE 3E00 60 PUSH1 0x60 3E02 01 ADD 3E03 52 MSTORE 3E04 93 SWAP4 3E05 92 SWAP3 3E06 50 POP 3E07 50 POP 3E08 50 POP 3E09 56 *JUMP // Stack delta = -12 // Outputs[4] // { // @3DF5 memory[stack[-7] + stack[-5]:stack[-7] + stack[-5] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] // @3DFF memory[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @3E03 memory[0x60 + stack[-7]:0x60 + stack[-7] + 0x20] = stack[-8] // @3E04 stack[-13] = stack[-3] // } // Block ends with unconditional jump to stack[-13] 3E0A 5B JUMPDEST 3E0B 60 PUSH1 0xa0 3E0D 81 DUP2 3E0E 01 ADD 3E0F 61 PUSH2 0x3e18 3E12 82 DUP3 3E13 86 DUP7 3E14 61 PUSH2 0x3b20 3E17 56 *JUMP 3E18 5B JUMPDEST 3E19 61 PUSH2 0x3e25 3E1C 60 PUSH1 0x40 3E1E 83 DUP4 3E1F 01 ADD 3E20 85 DUP6 3E21 61 PUSH2 0x3b20 3E24 56 *JUMP 3E25 5B JUMPDEST 3E26 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E3B 83 DUP4 3E3C 16 AND 3E3D 60 PUSH1 0x80 3E3F 83 DUP4 3E40 01 ADD 3E41 52 MSTORE 3E42 94 SWAP5 3E43 93 SWAP4 3E44 50 POP 3E45 50 POP 3E46 50 POP 3E47 50 POP 3E48 56 *JUMP label_3E49: // Incoming call from 0x065C, returns to 0x065D // Incoming call from 0x0596, returns to 0x0597 // Inputs[5] // { // @3E5F stack[-4] // @3E62 stack[-1] // @3E64 stack[-3] // @3E65 stack[-2] // @3E78 stack[-5] // } 3E49 5B JUMPDEST 3E4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E5F 93 SWAP4 3E60 84 DUP5 3E61 16 AND 3E62 81 DUP2 3E63 52 MSTORE 3E64 91 SWAP2 3E65 90 SWAP1 3E66 92 SWAP3 3E67 16 AND 3E68 60 PUSH1 0x20 3E6A 82 DUP3 3E6B 01 ADD 3E6C 52 MSTORE 3E6D 60 PUSH1 0x40 3E6F 81 DUP2 3E70 01 ADD 3E71 91 SWAP2 3E72 90 SWAP1 3E73 91 SWAP2 3E74 52 MSTORE 3E75 60 PUSH1 0x60 3E77 01 ADD 3E78 90 SWAP1 3E79 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @3E63 memory[stack[-1]:stack[-1] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @3E6C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @3E74 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-2] // @3E78 stack[-5] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-5] label_3E7A: // Incoming call from 0x0A23, returns to 0x01C3 // Incoming call from 0x0E60, returns to 0x01C3 // Incoming call from 0x0A52, returns to 0x0A53 // Incoming call from 0x0D07, returns to 0x0D08 // Inputs[3] // { // @3E7F stack[-1] // @3E81 stack[-2] // @3E82 memory[stack[-2]:stack[-2] + 0x20] // } 3E7A 5B JUMPDEST 3E7B 60 PUSH1 0x00 3E7D 60 PUSH1 0x20 3E7F 82 DUP3 3E80 52 MSTORE 3E81 82 DUP3 3E82 51 MLOAD 3E83 80 DUP1 3E84 60 PUSH1 0x20 3E86 84 DUP5 3E87 01 ADD 3E88 52 MSTORE 3E89 61 PUSH2 0x3e99 3E8C 81 DUP2 3E8D 60 PUSH1 0x40 3E8F 85 DUP6 3E90 01 ADD 3E91 60 PUSH1 0x20 3E93 87 DUP8 3E94 01 ADD 3E95 61 PUSH2 0x43d2 3E98 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @3E7B stack[0] = 0x00 // @3E80 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3E82 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @3E88 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @3E89 stack[2] = 0x3e99 // @3E8C stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @3E90 stack[4] = stack[-1] + 0x40 // @3E94 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x43d2, returns to 0x3E99 label_3E99: // Incoming return from call to 0x43D2 at 0x3E98 // Inputs[5] // { // @3E9C stack[-1] // @3EBF stack[-3] // @3EC0 stack[-2] // @3EC6 stack[-5] // @3EC7 stack[-4] // } 3E99 5B JUMPDEST 3E9A 60 PUSH1 0x1f 3E9C 01 ADD 3E9D 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 3EBE 16 AND 3EBF 91 SWAP2 3EC0 90 SWAP1 3EC1 91 SWAP2 3EC2 01 ADD 3EC3 60 PUSH1 0x40 3EC5 01 ADD 3EC6 92 SWAP3 3EC7 91 SWAP2 3EC8 50 POP 3EC9 50 POP 3ECA 56 *JUMP // Stack delta = -4 // Outputs[1] { @3EC6 stack[-5] = 0x40 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) + stack[-3] } // Block ends with unconditional jump to stack[-5] label_3ECB: // Incoming call from 0x26D3, returns to 0x01C3 // Inputs[2] // { // @3ECF stack[-1] // @3F00 stack[-2] // } 3ECB 5B JUMPDEST 3ECC 60 PUSH1 0x20 3ECE 80 DUP1 3ECF 82 DUP3 3ED0 52 MSTORE 3ED1 60 PUSH1 0x1d 3ED3 90 SWAP1 3ED4 82 DUP3 3ED5 01 ADD 3ED6 52 MSTORE 3ED7 7F PUSH32 0x556e69563245787420726573756c74206973206e6f7420656e6f756768000000 3EF8 60 PUSH1 0x40 3EFA 82 DUP3 3EFB 01 ADD 3EFC 52 MSTORE 3EFD 60 PUSH1 0x60 3EFF 01 ADD 3F00 90 SWAP1 3F01 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3ED0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3ED6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1d // @3EFC memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x556e69563245787420726573756c74206973206e6f7420656e6f756768000000 // @3F00 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3F02: // Incoming call from 0x19EE, returns to 0x01C3 // Incoming call from 0x085A, returns to 0x01C3 // Inputs[2] // { // @3F06 stack[-1] // @3F37 stack[-2] // } 3F02 5B JUMPDEST 3F03 60 PUSH1 0x20 3F05 80 DUP1 3F06 82 DUP3 3F07 52 MSTORE 3F08 60 PUSH1 0x1d 3F0A 90 SWAP1 3F0B 82 DUP3 3F0C 01 ADD 3F0D 52 MSTORE 3F0E 7F PUSH32 0x496e73756666696369656e742062616c616e636520666f722063616c6c000000 3F2F 60 PUSH1 0x40 3F31 82 DUP3 3F32 01 ADD 3F33 52 MSTORE 3F34 60 PUSH1 0x60 3F36 01 ADD 3F37 90 SWAP1 3F38 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3F07 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3F0D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1d // @3F33 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e73756666696369656e742062616c616e636520666f722063616c6c000000 // @3F37 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3F39: // Incoming call from 0x2842, returns to 0x01C3 // Inputs[2] // { // @3F3D stack[-1] // @3F6E stack[-2] // } 3F39 5B JUMPDEST 3F3A 60 PUSH1 0x20 3F3C 80 DUP1 3F3D 82 DUP3 3F3E 52 MSTORE 3F3F 60 PUSH1 0x1b 3F41 90 SWAP1 3F42 82 DUP3 3F43 01 ADD 3F44 52 MSTORE 3F45 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 3F66 60 PUSH1 0x40 3F68 82 DUP3 3F69 01 ADD 3F6A 52 MSTORE 3F6B 60 PUSH1 0x60 3F6D 01 ADD 3F6E 90 SWAP1 3F6F 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3F3E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3F44 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1b // @3F6A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @3F6E stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3F70: // Incoming call from 0x01C2, returns to 0x01C3 // Inputs[2] // { // @3F74 stack[-1] // @3FA5 stack[-2] // } 3F70 5B JUMPDEST 3F71 60 PUSH1 0x20 3F73 80 DUP1 3F74 82 DUP3 3F75 52 MSTORE 3F76 60 PUSH1 0x14 3F78 90 SWAP1 3F79 82 DUP3 3F7A 01 ADD 3F7B 52 MSTORE 3F7C 7F PUSH32 0x455448206465706f7369742072656a6563746564000000000000000000000000 3F9D 60 PUSH1 0x40 3F9F 82 DUP3 3FA0 01 ADD 3FA1 52 MSTORE 3FA2 60 PUSH1 0x60 3FA4 01 ADD 3FA5 90 SWAP1 3FA6 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3F75 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3F7B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14 // @3FA1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455448206465706f7369742072656a6563746564000000000000000000000000 // @3FA5 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3FA7: // Incoming call from 0x1C8D, returns to 0x01C3 // Inputs[2] // { // @3FAB stack[-1] // @3FDC stack[-2] // } 3FA7 5B JUMPDEST 3FA8 60 PUSH1 0x20 3FAA 80 DUP1 3FAB 82 DUP3 3FAC 52 MSTORE 3FAD 60 PUSH1 0x1e 3FAF 90 SWAP1 3FB0 82 DUP3 3FB1 01 ADD 3FB2 52 MSTORE 3FB3 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 3FD4 60 PUSH1 0x40 3FD6 82 DUP3 3FD7 01 ADD 3FD8 52 MSTORE 3FD9 60 PUSH1 0x60 3FDB 01 ADD 3FDC 90 SWAP1 3FDD 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3FAC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3FB2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1e // @3FD8 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // @3FDC stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3FDE: // Incoming call from 0x1C40, returns to 0x01C3 // Inputs[2] // { // @3FE2 stack[-1] // @4013 stack[-2] // } 3FDE 5B JUMPDEST 3FDF 60 PUSH1 0x20 3FE1 80 DUP1 3FE2 82 DUP3 3FE3 52 MSTORE 3FE4 60 PUSH1 0x1a 3FE6 90 SWAP1 3FE7 82 DUP3 3FE8 01 ADD 3FE9 52 MSTORE 3FEA 7F PUSH32 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 400B 60 PUSH1 0x40 400D 82 DUP3 400E 01 ADD 400F 52 MSTORE 4010 60 PUSH1 0x60 4012 01 ADD 4013 90 SWAP1 4014 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3FE3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3FE9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1a // @400F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 // @4013 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4015: // Incoming call from 0x28F0, returns to 0x01C3 // Inputs[2] // { // @4019 stack[-1] // @404A stack[-2] // } 4015 5B JUMPDEST 4016 60 PUSH1 0x20 4018 80 DUP1 4019 82 DUP3 401A 52 MSTORE 401B 60 PUSH1 0x15 401D 90 SWAP1 401E 82 DUP3 401F 01 ADD 4020 52 MSTORE 4021 7F PUSH32 0x417070726f76652063616c6c6564206f6e204554480000000000000000000000 4042 60 PUSH1 0x40 4044 82 DUP3 4045 01 ADD 4046 52 MSTORE 4047 60 PUSH1 0x60 4049 01 ADD 404A 90 SWAP1 404B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @401A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4020 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x15 // @4046 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x417070726f76652063616c6c6564206f6e204554480000000000000000000000 // @404A stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_404C: // Incoming call from 0x23FF, returns to 0x01C3 // Inputs[2] // { // @4050 stack[-1] // @4081 stack[-2] // } 404C 5B JUMPDEST 404D 60 PUSH1 0x20 404F 80 DUP1 4050 82 DUP3 4051 52 MSTORE 4052 60 PUSH1 0x19 4054 90 SWAP1 4055 82 DUP3 4056 01 ADD 4057 52 MSTORE 4058 7F PUSH32 0x496e76616c696420736b69704d61736b416e644f666673657400000000000000 4079 60 PUSH1 0x40 407B 82 DUP3 407C 01 ADD 407D 52 MSTORE 407E 60 PUSH1 0x60 4080 01 ADD 4081 90 SWAP1 4082 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @4051 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4057 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @407D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e76616c696420736b69704d61736b416e644f666673657400000000000000 // @4081 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4083: // Incoming call from 0x0BB7, returns to 0x01C3 // Inputs[2] // { // @4087 stack[-1] // @40B8 stack[-2] // } 4083 5B JUMPDEST 4084 60 PUSH1 0x20 4086 80 DUP1 4087 82 DUP3 4088 52 MSTORE 4089 60 PUSH1 0x1b 408B 90 SWAP1 408C 82 DUP3 408D 01 ADD 408E 52 MSTORE 408F 7F PUSH32 0x52657475726e20616d6f756e74206973206e6f7420656e6f7567680000000000 40B0 60 PUSH1 0x40 40B2 82 DUP3 40B3 01 ADD 40B4 52 MSTORE 40B5 60 PUSH1 0x60 40B7 01 ADD 40B8 90 SWAP1 40B9 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @4088 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @408E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1b // @40B4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x52657475726e20616d6f756e74206973206e6f7420656e6f7567680000000000 // @40B8 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_40BA: // Incoming call from 0x1C05, returns to 0x01C3 // Inputs[2] // { // @40BE stack[-1] // @4115 stack[-2] // } 40BA 5B JUMPDEST 40BB 60 PUSH1 0x20 40BD 80 DUP1 40BE 82 DUP3 40BF 52 MSTORE 40C0 60 PUSH1 0x21 40C2 90 SWAP1 40C3 82 DUP3 40C4 01 ADD 40C5 52 MSTORE 40C6 7F PUSH32 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f 40E7 60 PUSH1 0x40 40E9 82 DUP3 40EA 01 ADD 40EB 52 MSTORE 40EC 7F PUSH32 0x7700000000000000000000000000000000000000000000000000000000000000 410D 60 PUSH1 0x60 410F 82 DUP3 4110 01 ADD 4111 52 MSTORE 4112 60 PUSH1 0x80 4114 01 ADD 4115 90 SWAP1 4116 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @40BF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @40C5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x21 // @40EB memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f // @4111 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7700000000000000000000000000000000000000000000000000000000000000 // @4115 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4117: // Incoming call from 0x0BF7, returns to 0x01C3 // Inputs[2] // { // @411B stack[-1] // @414C stack[-2] // } 4117 5B JUMPDEST 4118 60 PUSH1 0x20 411A 80 DUP1 411B 82 DUP3 411C 52 MSTORE 411D 60 PUSH1 0x0b 411F 90 SWAP1 4120 82 DUP3 4121 01 ADD 4122 52 MSTORE 4123 7F PUSH32 0x456d7074792063616c6c73000000000000000000000000000000000000000000 4144 60 PUSH1 0x40 4146 82 DUP3 4147 01 ADD 4148 52 MSTORE 4149 60 PUSH1 0x60 414B 01 ADD 414C 90 SWAP1 414D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @411C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4122 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0b // @4148 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456d7074792063616c6c73000000000000000000000000000000000000000000 // @414C stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 414E 5B JUMPDEST 414F 60 PUSH1 0x20 4151 80 DUP1 4152 82 DUP3 4153 52 MSTORE 4154 60 PUSH1 0x1f 4156 90 SWAP1 4157 82 DUP3 4158 01 ADD 4159 52 MSTORE 415A 7F PUSH32 0x4552433230206f7065726174696f6e20646964206e6f74207375636365656400 417B 60 PUSH1 0x40 417D 82 DUP3 417E 01 ADD 417F 52 MSTORE 4180 60 PUSH1 0x60 4182 01 ADD 4183 90 SWAP1 4184 56 *JUMP label_4185: // Incoming call from 0x0F87, returns to 0x01C3 // Inputs[2] // { // @4189 stack[-1] // @41BA stack[-2] // } 4185 5B JUMPDEST 4186 60 PUSH1 0x20 4188 80 DUP1 4189 82 DUP3 418A 52 MSTORE 418B 60 PUSH1 0x1d 418D 90 SWAP1 418E 82 DUP3 418F 01 ADD 4190 52 MSTORE 4191 7F PUSH32 0x417272617973206c656e6774682073686f756c6420626520657175616c000000 41B2 60 PUSH1 0x40 41B4 82 DUP3 41B5 01 ADD 41B6 52 MSTORE 41B7 60 PUSH1 0x60 41B9 01 ADD 41BA 90 SWAP1 41BB 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @418A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4190 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1d // @41B6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x417272617973206c656e6774682073686f756c6420626520657175616c000000 // @41BA stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_41BC: // Incoming call from 0x1FB6, returns to 0x01C3 // Inputs[2] // { // @41C0 stack[-1] // @41F1 stack[-2] // } 41BC 5B JUMPDEST 41BD 60 PUSH1 0x20 41BF 80 DUP1 41C0 82 DUP3 41C1 52 MSTORE 41C2 60 PUSH1 0x15 41C4 90 SWAP1 41C5 82 DUP3 41C6 01 ADD 41C7 52 MSTORE 41C8 7F PUSH32 0x496e76616c69642072657665727420726561736f6e0000000000000000000000 41E9 60 PUSH1 0x40 41EB 82 DUP3 41EC 01 ADD 41ED 52 MSTORE 41EE 60 PUSH1 0x60 41F0 01 ADD 41F1 90 SWAP1 41F2 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @41C1 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @41C7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x15 // @41ED memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e76616c69642072657665727420726561736f6e0000000000000000000000 // @41F1 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 41F3 5B JUMPDEST 41F4 60 PUSH1 0x20 41F6 80 DUP1 41F7 82 DUP3 41F8 52 MSTORE 41F9 60 PUSH1 0x15 41FB 90 SWAP1 41FC 82 DUP3 41FD 01 ADD 41FE 52 MSTORE 41FF 7F PUSH32 0x6c6f772d6c6576656c2063616c6c206661696c65640000000000000000000000 4220 60 PUSH1 0x40 4222 82 DUP3 4223 01 ADD 4224 52 MSTORE 4225 60 PUSH1 0x60 4227 01 ADD 4228 90 SWAP1 4229 56 *JUMP label_422A: // Incoming call from 0x24FA, returns to 0x01C3 // Inputs[2] // { // @422E stack[-1] // @425F stack[-2] // } 422A 5B JUMPDEST 422B 60 PUSH1 0x20 422D 80 DUP1 422E 82 DUP3 422F 52 MSTORE 4230 60 PUSH1 0x16 4232 90 SWAP1 4233 82 DUP3 4234 01 ADD 4235 52 MSTORE 4236 7F PUSH32 0x4f6666736574206973206f7574206f662072616e676500000000000000000000 4257 60 PUSH1 0x40 4259 82 DUP3 425A 01 ADD 425B 52 MSTORE 425C 60 PUSH1 0x60 425E 01 ADD 425F 90 SWAP1 4260 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @422F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @4235 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x16 // @425B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f6666736574206973206f7574206f662072616e676500000000000000000000 // @425F stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_4261: // Incoming call from 0x07DF, returns to 0x07E0 // Inputs[4] // { // @4266 stack[-1] // @4268 stack[-3] // @4274 stack[-2] // @4275 memory[stack[-2]:stack[-2] + 0x20] // } 4261 5B JUMPDEST 4262 60 PUSH1 0x00 4264 60 PUSH1 0x40 4266 82 DUP3 4267 01 ADD 4268 84 DUP5 4269 83 DUP4 426A 52 MSTORE 426B 60 PUSH1 0x20 426D 60 PUSH1 0x40 426F 81 DUP2 4270 85 DUP6 4271 01 ADD 4272 52 MSTORE 4273 81 DUP2 4274 85 DUP6 4275 51 MLOAD 4276 80 DUP1 4277 84 DUP5 4278 52 MSTORE 4279 60 PUSH1 0x60 427B 86 DUP7 427C 01 ADD 427D 91 SWAP2 427E 50 POP 427F 82 DUP3 4280 87 DUP8 4281 01 ADD 4282 93 SWAP4 4283 50 POP 4284 84 DUP5 4285 5B JUMPDEST 4286 81 DUP2 4287 81 DUP2 4288 10 LT 4289 15 ISZERO 428A 61 PUSH2 0x42a1 428D 57 *JUMPI // Stack delta = +6 // Outputs[9] // { // @4262 stack[0] = 0x00 // @426A memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @426B stack[2] = 0x20 // @4272 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x40 // @4275 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @4278 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @427D stack[3] = stack[-1] + 0x60 // @4282 stack[1] = stack[-2] + 0x20 // @4284 stack[5] = 0x00 // } // Block ends with conditional jump to 0x42a1, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_428E: // Incoming jump from 0x428D, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x428D, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @428E stack[-5] // @428F memory[stack[-5]:stack[-5] + 0x20] // @4290 stack[-3] // @4292 stack[-1] // @4293 stack[-4] // } 428E 84 DUP5 428F 51 MLOAD 4290 83 DUP4 4291 52 MSTORE 4292 93 SWAP4 4293 83 DUP4 4294 01 ADD 4295 93 SWAP4 4296 91 SWAP2 4297 83 DUP4 4298 01 ADD 4299 91 SWAP2 429A 60 PUSH1 0x01 429C 01 ADD 429D 61 PUSH2 0x4285 42A0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @4291 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-5]:stack[-5] + 0x20] // @4295 stack[-5] = stack[-4] + stack[-5] // @4299 stack[-3] = stack[-4] + stack[-3] // @429C stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x4285 label_42A1: // Incoming jump from 0x428D, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x428D, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @42A3 stack[-3] // @42A3 stack[-2] // @42A4 stack[-10] // @42A5 stack[-9] // } 42A1 5B JUMPDEST 42A2 50 POP 42A3 90 SWAP1 42A4 97 SWAP8 42A5 96 SWAP7 42A6 50 POP 42A7 50 POP 42A8 50 POP 42A9 50 POP 42AA 50 POP 42AB 50 POP 42AC 50 POP 42AD 56 *JUMP // Stack delta = -9 // Outputs[1] { @42A4 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_42AE: // Incoming call from 0x1946, returns to 0x1143 // Inputs[5] // { // @42AF stack[-4] // @42AF stack[-1] // @42B6 stack[-3] // @42B7 stack[-2] // @42D8 stack[-5] // } 42AE 5B JUMPDEST 42AF 92 SWAP3 42B0 83 DUP4 42B1 52 MSTORE 42B2 60 PUSH1 0x20 42B4 83 DUP4 42B5 01 ADD 42B6 91 SWAP2 42B7 90 SWAP1 42B8 91 SWAP2 42B9 52 MSTORE 42BA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 42CF 16 AND 42D0 60 PUSH1 0x40 42D2 82 DUP3 42D3 01 ADD 42D4 52 MSTORE 42D5 60 PUSH1 0x60 42D7 01 ADD 42D8 90 SWAP1 42D9 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @42B1 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @42B9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-3] // @42D4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @42D8 stack[-5] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-5] label_42DA: // Incoming call from 0x1142, returns to 0x1143 // Inputs[5] // { // @42DB stack[-4] // @42DB stack[-1] // @42E2 stack[-3] // @42E3 stack[-2] // @4313 stack[-5] // } 42DA 5B JUMPDEST 42DB 92 SWAP3 42DC 83 DUP4 42DD 52 MSTORE 42DE 60 PUSH1 0x20 42E0 83 DUP4 42E1 01 ADD 42E2 91 SWAP2 42E3 90 SWAP1 42E4 91 SWAP2 42E5 52 MSTORE 42E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 42FB 16 AND 42FC 60 PUSH1 0x40 42FE 82 DUP3 42FF 01 ADD 4300 52 MSTORE 4301 60 PUSH1 0x80 4303 60 PUSH1 0x60 4305 82 DUP3 4306 01 ADD 4307 81 DUP2 4308 90 SWAP1 4309 52 MSTORE 430A 60 PUSH1 0x00 430C 90 SWAP1 430D 82 DUP3 430E 01 ADD 430F 52 MSTORE 4310 60 PUSH1 0xa0 4312 01 ADD 4313 90 SWAP1 4314 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @42DD memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @42E5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-3] // @4300 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @4309 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @430F memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0x00 // @4313 stack[-5] = 0xa0 + stack[-1] // } // Block ends with unconditional jump to stack[-5] label_4315: // Incoming call from 0x08B9, returns to 0x08BA // Incoming call from 0x0942, returns to 0x0943 // Inputs[4] // { // @4319 stack[-2] // @431A msg.data[stack[-2]:stack[-2] + 0x20] // @433C stack[-1] // @433D msg.data.length // } 4315 5B JUMPDEST 4316 60 PUSH1 0x00 4318 80 DUP1 4319 83 DUP4 431A 35 CALLDATALOAD 431B 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 433C 84 DUP5 433D 36 CALLDATASIZE 433E 03 SUB 433F 01 ADD 4340 81 DUP2 4341 12 SLT 4342 61 PUSH2 0x4349 4345 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @4316 stack[0] = 0x00 // @4318 stack[1] = 0x00 // @431A stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x4349, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 label_4346: // Incoming jump from 0x4345, if not msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[2] // { // @4346 stack[-3] // @4348 memory[stack[-3]:stack[-3] + stack[-3]] // } 4346 82 DUP3 4347 83 DUP4 4348 FD *REVERT // Stack delta = +0 // Outputs[1] { @4348 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_4349: // Incoming jump from 0x4345, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[4] // { // @434A stack[-4] // @434B stack[-1] // @434D msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] // @434E stack[-2] // } 4349 5B JUMPDEST 434A 83 DUP4 434B 01 ADD 434C 80 DUP1 434D 35 CALLDATALOAD 434E 91 SWAP2 434F 50 POP 4350 67 PUSH8 0xffffffffffffffff 4359 82 DUP3 435A 11 GT 435B 15 ISZERO 435C 61 PUSH2 0x4363 435F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @434B stack[-1] = stack[-4] + stack[-1] // @434E stack[-2] = msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x4363, if !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) label_4360: // Incoming jump from 0x435F, if not !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @4360 stack[-3] // @4362 memory[stack[-3]:stack[-3] + stack[-3]] // } 4360 82 DUP3 4361 83 DUP4 4362 FD *REVERT // Stack delta = +0 // Outputs[1] { @4362 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_4363: // Incoming jump from 0x435F, if !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @4366 stack[-1] // @4367 stack[-3] // @4369 msg.data.length // @436A stack[-2] // } 4363 5B JUMPDEST 4364 60 PUSH1 0x20 4366 01 ADD 4367 91 SWAP2 4368 50 POP 4369 36 CALLDATASIZE 436A 81 DUP2 436B 90 SWAP1 436C 03 SUB 436D 82 DUP3 436E 13 SGT 436F 15 ISZERO 4370 61 PUSH2 0x3148 4373 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4367 stack[-3] = 0x20 + stack[-1] } // Block ends with conditional jump to 0x3148, if !(0x20 + stack[-1] i> msg.data.length - stack[-2]) label_4374: // Incoming jump from 0x4373, if not !(0x20 + stack[-1] i> msg.data.length - stack[-2]) // Inputs[1] { @4377 memory[0x00:0x00] } 4374 60 PUSH1 0x00 4376 80 DUP1 4377 FD *REVERT // Stack delta = +0 // Outputs[1] { @4377 revert(memory[0x00:0x00]); } // Block terminates label_4378: // Incoming call from 0x2538, returns to 0x0221 // Inputs[4] // { // @437B stack[-2] // @437C msg.data[stack[-2]:stack[-2] + 0x20] // @439E stack[-1] // @439F msg.data.length // } 4378 5B JUMPDEST 4379 60 PUSH1 0x00 437B 82 DUP3 437C 35 CALLDATALOAD 437D 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 439E 83 DUP4 439F 36 CALLDATASIZE 43A0 03 SUB 43A1 01 ADD 43A2 81 DUP2 43A3 12 SLT 43A4 61 PUSH2 0x3b65 43A7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4379 stack[0] = 0x00 // @437C stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x3b65, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 label_43A8: // Incoming jump from 0x43A7, if not msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81 // Inputs[2] // { // @43A8 stack[-2] // @43AA memory[stack[-2]:stack[-2] + stack[-2]] // } 43A8 81 DUP2 43A9 82 DUP3 43AA FD *REVERT // Stack delta = +0 // Outputs[1] { @43AA revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_43AB: // Incoming call from 0x3183, returns to 0x3184 // Incoming call from 0x3220, returns to 0x3221 // Incoming call from 0x30BC, returns to 0x30BD // Incoming call from 0x32A8, returns to 0x32A9 // Inputs[2] // { // @43AE memory[0x40:0x60] // @43AF stack[-1] // } 43AB 5B JUMPDEST 43AC 60 PUSH1 0x40 43AE 51 MLOAD 43AF 81 DUP2 43B0 81 DUP2 43B1 01 ADD 43B2 67 PUSH8 0xffffffffffffffff 43BB 81 DUP2 43BC 11 GT 43BD 82 DUP3 43BE 82 DUP3 43BF 10 LT 43C0 17 OR 43C1 15 ISZERO 43C2 61 PUSH2 0x43ca 43C5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @43AE stack[0] = memory[0x40:0x60] // @43B1 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x43ca, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_43C6: // Incoming jump from 0x43C5, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[1] { @43C9 memory[0x00:0x00] } 43C6 60 PUSH1 0x00 43C8 80 DUP1 43C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @43C9 revert(memory[0x00:0x00]); } // Block terminates label_43CA: // Incoming jump from 0x43C5, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @43CD stack[-1] // @43CE stack[-4] // @43CE stack[-2] // @43CF stack[-3] // } 43CA 5B JUMPDEST 43CB 60 PUSH1 0x40 43CD 52 MSTORE 43CE 91 SWAP2 43CF 90 SWAP1 43D0 50 POP 43D1 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @43CD memory[0x40:0x60] = stack[-1] // @43CE stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_43D2: // Incoming call from 0x3C3C, returns to 0x3C3D // Incoming call from 0x3B64, returns to 0x3B65 // Incoming call from 0x3C84, returns to 0x3C85 // Incoming call from 0x3E98, returns to 0x3E99 // Incoming call from 0x3C02, returns to 0x3C03 // Incoming call from 0x3CBE, returns to 0x3BBB // Inputs[1] { @43D6 stack[-3] } 43D2 5B JUMPDEST 43D3 60 PUSH1 0x00 43D5 5B JUMPDEST 43D6 83 DUP4 43D7 81 DUP2 43D8 10 LT 43D9 15 ISZERO 43DA 61 PUSH2 0x43ed 43DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @43D3 stack[0] = 0x00 } // Block ends with conditional jump to 0x43ed, if !(0x00 < stack[-3]) label_43DE: // Incoming jump from 0x43DD, if not !(0x00 < stack[-3]) // Incoming jump from 0x43DD, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @43DE stack[-2] // @43DF stack[-1] // @43E1 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @43E2 stack[-3] // } 43DE 81 DUP2 43DF 81 DUP2 43E0 01 ADD 43E1 51 MLOAD 43E2 83 DUP4 43E3 82 DUP3 43E4 01 ADD 43E5 52 MSTORE 43E6 60 PUSH1 0x20 43E8 01 ADD 43E9 61 PUSH2 0x43d5 43EC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @43E5 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @43E8 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x43d5 label_43ED: // Incoming jump from 0x43DD, if !(0x00 < stack[-3]) // Incoming jump from 0x43DD, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @43EE stack[-4] // @43EF stack[-1] // } 43ED 5B JUMPDEST 43EE 83 DUP4 43EF 81 DUP2 43F0 11 GT 43F1 15 ISZERO 43F2 61 PUSH2 0x0a5d 43F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a5d, if !(stack[-1] > stack[-4]) label_43F6: // Incoming jump from 0x43F5, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @43FA stack[-4] // @43FB stack[-3] // @43FD stack[-5] // } 43F6 50 POP 43F7 50 POP 43F8 60 PUSH1 0x00 43FA 91 SWAP2 43FB 01 ADD 43FC 52 MSTORE 43FD 56 *JUMP // Stack delta = -5 // Outputs[1] { @43FC memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_43FE: // Incoming call from 0x398C, returns to 0x398D // Incoming call from 0x399C, returns to 0x399D // Incoming call from 0x35DE, returns to 0x35DF // Incoming call from 0x33A6, returns to 0x33A7 // Incoming call from 0x359F, returns to 0x33A7 // Incoming call from 0x343F, returns to 0x3440 // Incoming call from 0x370D, returns to 0x370E // Incoming call from 0x34FB, returns to 0x34FC // Incoming call from 0x39BB, returns to 0x39BC // Incoming call from 0x3877, returns to 0x3878 // Incoming call from 0x342F, returns to 0x3430 // Incoming call from 0x372C, returns to 0x372D // Incoming call from 0x32FB, returns to 0x32FC // Incoming call from 0x36FD, returns to 0x36FE // Incoming call from 0x366E, returns to 0x366F // Incoming call from 0x3621, returns to 0x3622 // Incoming call from 0x340F, returns to 0x3410 // Incoming call from 0x36A5, returns to 0x36A6 // Incoming call from 0x35EE, returns to 0x35EF // Incoming call from 0x30E7, returns to 0x30E8 // Incoming call from 0x37F5, returns to 0x37F6 // Incoming call from 0x36B5, returns to 0x36B6 // Incoming call from 0x3631, returns to 0x3632 // Incoming call from 0x341F, returns to 0x3420 // Incoming call from 0x3396, returns to 0x3397 // Incoming call from 0x36C5, returns to 0x36C6 // Inputs[1] { @4414 stack[-1] } 43FE 5B JUMPDEST 43FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4414 81 DUP2 4415 16 AND 4416 81 DUP2 4417 14 EQ 4418 61 PUSH2 0x4420 441B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4420, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_441C: // Incoming jump from 0x441B, if not stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @441F memory[0x00:0x00] } 441C 60 PUSH1 0x00 441E 80 DUP1 441F FD *REVERT // Stack delta = +0 // Outputs[1] { @441F revert(memory[0x00:0x00]); } // Block terminates label_4420: // Incoming jump from 0x441B, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Incoming jump from 0x443A, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffff // Inputs[1] { @4422 stack[-2] } 4420 5B JUMPDEST 4421 50 POP 4422 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_4423: // Incoming call from 0x38A6, returns to 0x38A7 // Incoming call from 0x38B7, returns to 0x38B8 // Inputs[1] { @4433 stack[-1] } 4423 5B JUMPDEST 4424 6D PUSH14 0xffffffffffffffffffffffffffff 4433 81 DUP2 4434 16 AND 4435 81 DUP2 4436 14 EQ 4437 61 PUSH2 0x4420 443A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4420, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffff label_443B: // Incoming jump from 0x443A, if not stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffff // Inputs[1] { @443E memory[0x00:0x00] } 443B 60 PUSH1 0x00 443D 80 DUP1 443E FD *REVERT // Stack delta = +0 // Outputs[1] { @443E revert(memory[0x00:0x00]); } // Block terminates 443F FE *ASSERT 4440 A2 LOG2 4441 64 PUSH5 0x6970667358 4447 22 22 4448 12 SLT 4449 20 SHA3 444A 0E 0E 444B D2 D2 444C F7 F7 444D FC FC 444E CF CF 444F C6 C6 4450 DC DC 4451 1C SHR 4452 5A GAS 4453 05 SDIV 4454 64 PUSH5 0x4f6c12ffcc 445A D1 D1 445B 7D PUSH30 0x348bb4b8b4283416a84e91c1b79464736f6c634300060c0033