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 0x02c6 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02c6, 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 0x8545f4ea 0019 11 GT 001A 61 PUSH2 0x0179 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0179, if 0x8545f4ea > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x8545f4ea > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb1c9fe6e 0024 11 GT 0025 61 PUSH2 0x00d6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d6, if 0xb1c9fe6e > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb1c9fe6e > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd5abeb01 002F 11 GT 0030 61 PUSH2 0x008a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, if 0xd5abeb01 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd5abeb01 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xf2fde38b 003A 11 GT 003B 61 PUSH2 0x0064 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xf2fde38b > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xf2fde38b > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf2fde38b 0045 14 EQ 0046 61 PUSH2 0x07ae 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ae, if 0xf2fde38b == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf2fde38b == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf4217648 0050 14 EQ 0051 61 PUSH2 0x07ce 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ce, if 0xf4217648 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf4217648 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf57ea920 005B 14 EQ 005C 61 PUSH2 0x07ee 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ee, if 0xf57ea920 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf57ea920 == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x003E, if 0xf2fde38b > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xd5abeb01 006B 14 EQ 006C 61 PUSH2 0x073a 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073a, if 0xd5abeb01 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xdb97d4f8 0076 14 EQ 0077 61 PUSH2 0x0750 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0750, if 0xdb97d4f8 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xdb97d4f8 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xe985e9c5 0081 14 EQ 0082 61 PUSH2 0x0765 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0765, if 0xe985e9c5 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0089 memory[0x00:0x00] } 0086 60 PUSH1 0x00 0088 80 DUP1 0089 FD *REVERT // Stack delta = +0 // Outputs[1] { @0089 revert(memory[0x00:0x00]); } // Block terminates label_008A: // Incoming jump from 0x0033, if 0xd5abeb01 > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0xbdb4b848 0091 11 GT 0092 61 PUSH2 0x00bb 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bb, if 0xbdb4b848 > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xbdb4b848 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xbdb4b848 009C 14 EQ 009D 61 PUSH2 0x06e4 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e4, if 0xbdb4b848 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xbdb4b848 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xc03afb59 00A7 14 EQ 00A8 61 PUSH2 0x06fa 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fa, if 0xc03afb59 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xc03afb59 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xc87b56dd 00B2 14 EQ 00B3 61 PUSH2 0x071a 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x071a, if 0xc87b56dd == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00BA memory[0x00:0x00] } 00B7 60 PUSH1 0x00 00B9 80 DUP1 00BA FD *REVERT // Stack delta = +0 // Outputs[1] { @00BA revert(memory[0x00:0x00]); } // Block terminates label_00BB: // Incoming jump from 0x0095, if 0xbdb4b848 > stack[-1] // Inputs[1] { @00BC stack[-1] } 00BB 5B JUMPDEST 00BC 80 DUP1 00BD 63 PUSH4 0xb1c9fe6e 00C2 14 EQ 00C3 61 PUSH2 0x069d 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x069d, if 0xb1c9fe6e == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xb1c9fe6e == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0xb88d4fde 00CD 14 EQ 00CE 61 PUSH2 0x06c4 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c4, if 0xb88d4fde == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00D5 memory[0x00:0x00] } 00D2 60 PUSH1 0x00 00D4 80 DUP1 00D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D5 revert(memory[0x00:0x00]); } // Block terminates label_00D6: // Incoming jump from 0x0028, if 0xb1c9fe6e > stack[-1] // Inputs[1] { @00D7 stack[-1] } 00D6 5B JUMPDEST 00D7 80 DUP1 00D8 63 PUSH4 0x98a8cffe 00DD 11 GT 00DE 61 PUSH2 0x012d 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012d, if 0x98a8cffe > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x98a8cffe > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0xa0712d68 00E8 11 GT 00E9 61 PUSH2 0x0112 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0112, if 0xa0712d68 > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0xa0712d68 > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0xa0712d68 00F3 14 EQ 00F4 61 PUSH2 0x0654 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0654, if 0xa0712d68 == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0xa0712d68 == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0xa22cb465 00FE 14 EQ 00FF 61 PUSH2 0x0667 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0667, if 0xa22cb465 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0xa96af0f4 0109 14 EQ 010A 61 PUSH2 0x0687 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0687, if 0xa96af0f4 == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0xa96af0f4 == stack[-1] // Inputs[1] { @0111 memory[0x00:0x00] } 010E 60 PUSH1 0x00 0110 80 DUP1 0111 FD *REVERT // Stack delta = +0 // Outputs[1] { @0111 revert(memory[0x00:0x00]); } // Block terminates label_0112: // Incoming jump from 0x00EC, if 0xa0712d68 > stack[-1] // Inputs[1] { @0113 stack[-1] } 0112 5B JUMPDEST 0113 80 DUP1 0114 63 PUSH4 0x98a8cffe 0119 14 EQ 011A 61 PUSH2 0x05f7 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f7, if 0x98a8cffe == stack[-1] label_011E: // Incoming jump from 0x011D, if not 0x98a8cffe == stack[-1] // Inputs[1] { @011E stack[-1] } 011E 80 DUP1 011F 63 PUSH4 0x9b19251a 0124 14 EQ 0125 61 PUSH2 0x0624 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0624, if 0x9b19251a == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x9b19251a == stack[-1] // Inputs[1] { @012C memory[0x00:0x00] } 0129 60 PUSH1 0x00 012B 80 DUP1 012C FD *REVERT // Stack delta = +0 // Outputs[1] { @012C revert(memory[0x00:0x00]); } // Block terminates label_012D: // Incoming jump from 0x00E1, if 0x98a8cffe > stack[-1] // Inputs[1] { @012E stack[-1] } 012D 5B JUMPDEST 012E 80 DUP1 012F 63 PUSH4 0x868ff4a2 0134 11 GT 0135 61 PUSH2 0x015e 0138 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015e, if 0x868ff4a2 > stack[-1] label_0139: // Incoming jump from 0x0138, if not 0x868ff4a2 > stack[-1] // Inputs[1] { @0139 stack[-1] } 0139 80 DUP1 013A 63 PUSH4 0x868ff4a2 013F 14 EQ 0140 61 PUSH2 0x05b1 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b1, if 0x868ff4a2 == stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x868ff4a2 == stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x8da5cb5b 014A 14 EQ 014B 61 PUSH2 0x05c4 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c4, if 0x8da5cb5b == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x95d89b41 0155 14 EQ 0156 61 PUSH2 0x05e2 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e2, if 0x95d89b41 == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x95d89b41 == stack[-1] // Inputs[1] { @015D memory[0x00:0x00] } 015A 60 PUSH1 0x00 015C 80 DUP1 015D FD *REVERT // Stack delta = +0 // Outputs[1] { @015D revert(memory[0x00:0x00]); } // Block terminates label_015E: // Incoming jump from 0x0138, if 0x868ff4a2 > stack[-1] // Inputs[1] { @015F stack[-1] } 015E 5B JUMPDEST 015F 80 DUP1 0160 63 PUSH4 0x8545f4ea 0165 14 EQ 0166 61 PUSH2 0x0571 0169 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0571, if 0x8545f4ea == stack[-1] label_016A: // Incoming jump from 0x0169, if not 0x8545f4ea == stack[-1] // Inputs[1] { @016A stack[-1] } 016A 80 DUP1 016B 63 PUSH4 0x863c0891 0170 14 EQ 0171 61 PUSH2 0x0591 0174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0591, if 0x863c0891 == stack[-1] label_0175: // Incoming jump from 0x0174, if not 0x863c0891 == stack[-1] // Inputs[1] { @0178 memory[0x00:0x00] } 0175 60 PUSH1 0x00 0177 80 DUP1 0178 FD *REVERT // Stack delta = +0 // Outputs[1] { @0178 revert(memory[0x00:0x00]); } // Block terminates label_0179: // Incoming jump from 0x001D, if 0x8545f4ea > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @017A stack[-1] } 0179 5B JUMPDEST 017A 80 DUP1 017B 63 PUSH4 0x23b872dd 0180 11 GT 0181 61 PUSH2 0x0227 0184 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0227, if 0x23b872dd > stack[-1] label_0185: // Incoming jump from 0x0184, if not 0x23b872dd > stack[-1] // Inputs[1] { @0185 stack[-1] } 0185 80 DUP1 0186 63 PUSH4 0x6352211e 018B 11 GT 018C 61 PUSH2 0x01db 018F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01db, if 0x6352211e > stack[-1] label_0190: // Incoming jump from 0x018F, if not 0x6352211e > stack[-1] // Inputs[1] { @0190 stack[-1] } 0190 80 DUP1 0191 63 PUSH4 0x70a08231 0196 11 GT 0197 61 PUSH2 0x01c0 019A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c0, if 0x70a08231 > stack[-1] label_019B: // Incoming jump from 0x019A, if not 0x70a08231 > stack[-1] // Inputs[1] { @019B stack[-1] } 019B 80 DUP1 019C 63 PUSH4 0x70a08231 01A1 14 EQ 01A2 61 PUSH2 0x051c 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051c, if 0x70a08231 == stack[-1] label_01A6: // Incoming jump from 0x01A5, if not 0x70a08231 == stack[-1] // Inputs[1] { @01A6 stack[-1] } 01A6 80 DUP1 01A7 63 PUSH4 0x715018a6 01AC 14 EQ 01AD 61 PUSH2 0x053c 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053c, if 0x715018a6 == stack[-1] label_01B1: // Incoming jump from 0x01B0, if not 0x715018a6 == stack[-1] // Inputs[1] { @01B1 stack[-1] } 01B1 80 DUP1 01B2 63 PUSH4 0x780cf82a 01B7 14 EQ 01B8 61 PUSH2 0x0551 01BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0551, if 0x780cf82a == stack[-1] label_01BC: // Incoming jump from 0x01BB, if not 0x780cf82a == stack[-1] // Inputs[1] { @01BF memory[0x00:0x00] } 01BC 60 PUSH1 0x00 01BE 80 DUP1 01BF FD *REVERT // Stack delta = +0 // Outputs[1] { @01BF revert(memory[0x00:0x00]); } // Block terminates label_01C0: // Incoming jump from 0x019A, if 0x70a08231 > stack[-1] // Inputs[1] { @01C1 stack[-1] } 01C0 5B JUMPDEST 01C1 80 DUP1 01C2 63 PUSH4 0x6352211e 01C7 14 EQ 01C8 61 PUSH2 0x04e7 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e7, if 0x6352211e == stack[-1] label_01CC: // Incoming jump from 0x01CB, if not 0x6352211e == stack[-1] // Inputs[1] { @01CC stack[-1] } 01CC 80 DUP1 01CD 63 PUSH4 0x6c0360eb 01D2 14 EQ 01D3 61 PUSH2 0x0507 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0507, if 0x6c0360eb == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0x6c0360eb == stack[-1] // Inputs[1] { @01DA memory[0x00:0x00] } 01D7 60 PUSH1 0x00 01D9 80 DUP1 01DA FD *REVERT // Stack delta = +0 // Outputs[1] { @01DA revert(memory[0x00:0x00]); } // Block terminates label_01DB: // Incoming jump from 0x018F, if 0x6352211e > stack[-1] // Inputs[1] { @01DC stack[-1] } 01DB 5B JUMPDEST 01DC 80 DUP1 01DD 63 PUSH4 0x42842e0e 01E2 11 GT 01E3 61 PUSH2 0x020c 01E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020c, if 0x42842e0e > stack[-1] label_01E7: // Incoming jump from 0x01E6, if not 0x42842e0e > stack[-1] // Inputs[1] { @01E7 stack[-1] } 01E7 80 DUP1 01E8 63 PUSH4 0x42842e0e 01ED 14 EQ 01EE 61 PUSH2 0x0487 01F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0487, if 0x42842e0e == stack[-1] label_01F2: // Incoming jump from 0x01F1, if not 0x42842e0e == stack[-1] // Inputs[1] { @01F2 stack[-1] } 01F2 80 DUP1 01F3 63 PUSH4 0x46ab06db 01F8 14 EQ 01F9 61 PUSH2 0x04a7 01FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a7, if 0x46ab06db == stack[-1] label_01FD: // Incoming jump from 0x01FC, if not 0x46ab06db == stack[-1] // Inputs[1] { @01FD stack[-1] } 01FD 80 DUP1 01FE 63 PUSH4 0x55f804b3 0203 14 EQ 0204 61 PUSH2 0x04c7 0207 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c7, if 0x55f804b3 == stack[-1] label_0208: // Incoming jump from 0x0207, if not 0x55f804b3 == stack[-1] // Inputs[1] { @020B memory[0x00:0x00] } 0208 60 PUSH1 0x00 020A 80 DUP1 020B FD *REVERT // Stack delta = +0 // Outputs[1] { @020B revert(memory[0x00:0x00]); } // Block terminates label_020C: // Incoming jump from 0x01E6, if 0x42842e0e > stack[-1] // Inputs[1] { @020D stack[-1] } 020C 5B JUMPDEST 020D 80 DUP1 020E 63 PUSH4 0x23b872dd 0213 14 EQ 0214 61 PUSH2 0x0452 0217 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0452, if 0x23b872dd == stack[-1] label_0218: // Incoming jump from 0x0217, if not 0x23b872dd == stack[-1] // Inputs[1] { @0218 stack[-1] } 0218 80 DUP1 0219 63 PUSH4 0x3ccfd60b 021E 14 EQ 021F 61 PUSH2 0x0472 0222 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0472, if 0x3ccfd60b == stack[-1] label_0223: // Incoming jump from 0x0222, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0226 memory[0x00:0x00] } 0223 60 PUSH1 0x00 0225 80 DUP1 0226 FD *REVERT // Stack delta = +0 // Outputs[1] { @0226 revert(memory[0x00:0x00]); } // Block terminates label_0227: // Incoming jump from 0x0184, if 0x23b872dd > stack[-1] // Inputs[1] { @0228 stack[-1] } 0227 5B JUMPDEST 0228 80 DUP1 0229 63 PUSH4 0x095ea7b3 022E 11 GT 022F 61 PUSH2 0x027e 0232 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if 0x095ea7b3 > stack[-1] label_0233: // Incoming jump from 0x0232, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0233 stack[-1] } 0233 80 DUP1 0234 63 PUSH4 0x18160ddd 0239 11 GT 023A 61 PUSH2 0x0263 023D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0263, if 0x18160ddd > stack[-1] label_023E: // Incoming jump from 0x023D, if not 0x18160ddd > stack[-1] // Inputs[1] { @023E stack[-1] } 023E 80 DUP1 023F 63 PUSH4 0x18160ddd 0244 14 EQ 0245 61 PUSH2 0x03e8 0248 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e8, if 0x18160ddd == stack[-1] label_0249: // Incoming jump from 0x0248, if not 0x18160ddd == stack[-1] // Inputs[1] { @0249 stack[-1] } 0249 80 DUP1 024A 63 PUSH4 0x1e7269c5 024F 14 EQ 0250 61 PUSH2 0x0405 0253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0405, if 0x1e7269c5 == stack[-1] label_0254: // Incoming jump from 0x0253, if not 0x1e7269c5 == stack[-1] // Inputs[1] { @0254 stack[-1] } 0254 80 DUP1 0255 63 PUSH4 0x23245216 025A 14 EQ 025B 61 PUSH2 0x0432 025E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0432, if 0x23245216 == stack[-1] label_025F: // Incoming jump from 0x025E, if not 0x23245216 == stack[-1] // Inputs[1] { @0262 memory[0x00:0x00] } 025F 60 PUSH1 0x00 0261 80 DUP1 0262 FD *REVERT // Stack delta = +0 // Outputs[1] { @0262 revert(memory[0x00:0x00]); } // Block terminates label_0263: // Incoming jump from 0x023D, if 0x18160ddd > stack[-1] // Inputs[1] { @0264 stack[-1] } 0263 5B JUMPDEST 0264 80 DUP1 0265 63 PUSH4 0x095ea7b3 026A 14 EQ 026B 61 PUSH2 0x03a0 026E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a0, if 0x095ea7b3 == stack[-1] label_026F: // Incoming jump from 0x026E, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @026F stack[-1] } 026F 80 DUP1 0270 63 PUSH4 0x1581b600 0275 14 EQ 0276 61 PUSH2 0x03c0 0279 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c0, if 0x1581b600 == stack[-1] label_027A: // Incoming jump from 0x0279, if not 0x1581b600 == stack[-1] // Inputs[1] { @027D memory[0x00:0x00] } 027A 60 PUSH1 0x00 027C 80 DUP1 027D FD *REVERT // Stack delta = +0 // Outputs[1] { @027D revert(memory[0x00:0x00]); } // Block terminates label_027E: // Incoming jump from 0x0232, if 0x095ea7b3 > stack[-1] // Inputs[1] { @027F stack[-1] } 027E 5B JUMPDEST 027F 80 DUP1 0280 63 PUSH4 0x04db5eed 0285 11 GT 0286 61 PUSH2 0x02af 0289 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02af, if 0x04db5eed > stack[-1] label_028A: // Incoming jump from 0x0289, if not 0x04db5eed > stack[-1] // Inputs[1] { @028A stack[-1] } 028A 80 DUP1 028B 63 PUSH4 0x04db5eed 0290 14 EQ 0291 61 PUSH2 0x0324 0294 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0324, if 0x04db5eed == stack[-1] label_0295: // Incoming jump from 0x0294, if not 0x04db5eed == stack[-1] // Inputs[1] { @0295 stack[-1] } 0295 80 DUP1 0296 63 PUSH4 0x06fdde03 029B 14 EQ 029C 61 PUSH2 0x0346 029F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0346, if 0x06fdde03 == stack[-1] label_02A0: // Incoming jump from 0x029F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @02A0 stack[-1] } 02A0 80 DUP1 02A1 63 PUSH4 0x081812fc 02A6 14 EQ 02A7 61 PUSH2 0x0368 02AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0368, if 0x081812fc == stack[-1] label_02AB: // Incoming jump from 0x02AA, if not 0x081812fc == stack[-1] // Inputs[1] { @02AE memory[0x00:0x00] } 02AB 60 PUSH1 0x00 02AD 80 DUP1 02AE FD *REVERT // Stack delta = +0 // Outputs[1] { @02AE revert(memory[0x00:0x00]); } // Block terminates label_02AF: // Incoming jump from 0x0289, if 0x04db5eed > stack[-1] // Inputs[1] { @02B0 stack[-1] } 02AF 5B JUMPDEST 02B0 80 DUP1 02B1 63 PUSH4 0x01ffc9a7 02B6 14 EQ 02B7 61 PUSH2 0x02cb 02BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cb, if 0x01ffc9a7 == stack[-1] label_02BB: // Incoming jump from 0x02BA, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @02BB stack[-1] } 02BB 80 DUP1 02BC 63 PUSH4 0x0230318f 02C1 14 EQ 02C2 61 PUSH2 0x0300 02C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0300, if 0x0230318f == stack[-1] label_02C6: // Incoming jump from 0x02C5, if not 0x0230318f == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @02CA memory[0x00:0x00] } 02C6 5B JUMPDEST 02C7 60 PUSH1 0x00 02C9 80 DUP1 02CA FD *REVERT // Stack delta = +0 // Outputs[1] { @02CA revert(memory[0x00:0x00]); } // Block terminates label_02CB: // Incoming jump from 0x02BA, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02CC msg.value } 02CB 5B JUMPDEST 02CC 34 CALLVALUE 02CD 80 DUP1 02CE 15 ISZERO 02CF 61 PUSH2 0x02d7 02D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CC stack[0] = msg.value } // Block ends with conditional jump to 0x02d7, if !msg.value label_02D3: // Incoming jump from 0x02D2, if not !msg.value // Inputs[1] { @02D6 memory[0x00:0x00] } 02D3 60 PUSH1 0x00 02D5 80 DUP1 02D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D6 revert(memory[0x00:0x00]); } // Block terminates label_02D7: // Incoming jump from 0x02D2, if !msg.value // Inputs[1] { @02DF msg.data.length } 02D7 5B JUMPDEST 02D8 50 POP 02D9 61 PUSH2 0x02eb 02DC 61 PUSH2 0x02e6 02DF 36 CALLDATASIZE 02E0 60 PUSH1 0x04 02E2 61 PUSH2 0x1cba 02E5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D9 stack[-1] = 0x02eb // @02DC stack[0] = 0x02e6 // @02DF stack[1] = msg.data.length // @02E0 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1cba 02E6 5B JUMPDEST 02E7 61 PUSH2 0x0804 02EA 56 *JUMP label_02EB: // Incoming return from call to 0x0780 at 0x077F // Inputs[2] // { // @02EE memory[0x40:0x60] // @02EF stack[-1] // } 02EB 5B JUMPDEST 02EC 60 PUSH1 0x40 02EE 51 MLOAD 02EF 90 SWAP1 02F0 15 ISZERO 02F1 15 ISZERO 02F2 81 DUP2 02F3 52 MSTORE 02F4 60 PUSH1 0x20 02F6 01 ADD // Stack delta = +0 // Outputs[2] // { // @02F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02F6 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_02F7: // Incoming jump from 0x02F6 // Incoming jump from 0x0323 // Incoming return from call to 0x1FDF at 0x06C3 // Incoming jump from 0x039F // Inputs[3] // { // @02FA memory[0x40:0x60] // @02FC stack[-1] // @02FF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02F7 5B JUMPDEST 02F8 60 PUSH1 0x40 02FA 51 MLOAD 02FB 80 DUP1 02FC 91 SWAP2 02FD 03 SUB 02FE 90 SWAP1 02FF F3 *RETURN // Stack delta = -1 // Outputs[1] { @02FF return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0300: // Incoming jump from 0x02C5, if 0x0230318f == stack[-1] // Inputs[1] { @0301 msg.value } 0300 5B JUMPDEST 0301 34 CALLVALUE 0302 80 DUP1 0303 15 ISZERO 0304 61 PUSH2 0x030c 0307 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0301 stack[0] = msg.value } // Block ends with conditional jump to 0x030c, if !msg.value label_0308: // Incoming jump from 0x0307, if not !msg.value // Inputs[1] { @030B memory[0x00:0x00] } 0308 60 PUSH1 0x00 030A 80 DUP1 030B FD *REVERT // Stack delta = +0 // Outputs[1] { @030B revert(memory[0x00:0x00]); } // Block terminates label_030C: // Incoming jump from 0x0307, if !msg.value // Inputs[1] { @0313 storage[0x0f] } 030C 5B JUMPDEST 030D 50 POP 030E 61 PUSH2 0x0316 0311 60 PUSH1 0x0f 0313 54 SLOAD 0314 81 DUP2 0315 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @030E stack[-1] = 0x0316 // @0313 stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x0316 label_0316: // Incoming jump from 0x074F // Incoming jump from 0x0404 // Incoming jump from 0x069C // Incoming jump from 0x0315 // Incoming jump from 0x06F9 // Incoming jump from 0x0803 // Inputs[2] // { // @0319 memory[0x40:0x60] // @031A stack[-1] // } 0316 5B JUMPDEST 0317 60 PUSH1 0x40 0319 51 MLOAD 031A 90 SWAP1 031B 81 DUP2 031C 52 MSTORE 031D 60 PUSH1 0x20 031F 01 ADD 0320 61 PUSH2 0x02f7 0323 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @031C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @031F stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02f7 label_0324: // Incoming jump from 0x0294, if 0x04db5eed == stack[-1] // Inputs[1] { @0325 msg.value } 0324 5B JUMPDEST 0325 34 CALLVALUE 0326 80 DUP1 0327 15 ISZERO 0328 61 PUSH2 0x0330 032B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0325 stack[0] = msg.value } // Block ends with conditional jump to 0x0330, if !msg.value label_032C: // Incoming jump from 0x032B, if not !msg.value // Inputs[1] { @032F memory[0x00:0x00] } 032C 60 PUSH1 0x00 032E 80 DUP1 032F FD *REVERT // Stack delta = +0 // Outputs[1] { @032F revert(memory[0x00:0x00]); } // Block terminates label_0330: // Incoming jump from 0x032B, if !msg.value // Inputs[1] { @0338 msg.data.length } 0330 5B JUMPDEST 0331 50 POP 0332 61 PUSH2 0x0344 0335 61 PUSH2 0x033f 0338 36 CALLDATASIZE 0339 60 PUSH1 0x04 033B 61 PUSH2 0x1cd7 033E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0332 stack[-1] = 0x0344 // @0335 stack[0] = 0x033f // @0338 stack[1] = msg.data.length // @0339 stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x033F label_033F: // Incoming return from call to 0x1CD7 at 0x033E 033F 5B JUMPDEST 0340 61 PUSH2 0x0856 0343 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0856 label_0344: // Incoming return from call to 0x058C at 0x058B // Incoming return from call to 0x0715 at 0x0714 // Incoming return from call to 0x033F at 0x033E // Incoming return from call to 0x04C2 at 0x04C1 // Incoming return from call to 0x0D29 at 0x0550 // Incoming return from call to 0x05AC at 0x05AB // Incoming return from call to 0x03BB at 0x03BA // Incoming return from call to 0x0682 at 0x0681 // Incoming return from call to 0x044D at 0x044C // Incoming return from call to 0x07E9 at 0x07E8 // Incoming return from call to 0x0ACA at 0x0486 0344 5B JUMPDEST 0345 00 *STOP // Stack delta = +0 // Outputs[1] { @0345 stop(); } // Block terminates label_0346: // Incoming jump from 0x029F, if 0x06fdde03 == stack[-1] // Inputs[1] { @0347 msg.value } 0346 5B JUMPDEST 0347 34 CALLVALUE 0348 80 DUP1 0349 15 ISZERO 034A 61 PUSH2 0x0352 034D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0347 stack[0] = msg.value } // Block ends with conditional jump to 0x0352, if !msg.value label_034E: // Incoming jump from 0x034D, if not !msg.value // Inputs[1] { @0351 memory[0x00:0x00] } 034E 60 PUSH1 0x00 0350 80 DUP1 0351 FD *REVERT // Stack delta = +0 // Outputs[1] { @0351 revert(memory[0x00:0x00]); } // Block terminates label_0352: // Incoming jump from 0x034D, if !msg.value 0352 5B JUMPDEST 0353 50 POP 0354 61 PUSH2 0x035b 0357 61 PUSH2 0x08a8 035A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0354 stack[-1] = 0x035b } // Block ends with call to 0x08a8, returns to 0x035B label_035B: // Incoming return from call to 0x08A8 at 0x035A // Incoming return from call to 0x0C4C at 0x051B // Incoming return from call to 0x1260 at 0x0764 // Incoming return from call to 0x0FCF at 0x05F6 // Inputs[2] // { // @035E memory[0x40:0x60] // @0362 stack[-1] // } 035B 5B JUMPDEST 035C 60 PUSH1 0x40 035E 51 MLOAD 035F 61 PUSH2 0x02f7 0362 91 SWAP2 0363 90 SWAP1 0364 61 PUSH2 0x1d48 0367 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0362 stack[-1] = 0x02f7 // @0363 stack[1] = memory[0x40:0x60] // @0363 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1d48 label_0368: // Incoming jump from 0x02AA, if 0x081812fc == stack[-1] // Inputs[1] { @0369 msg.value } 0368 5B JUMPDEST 0369 34 CALLVALUE 036A 80 DUP1 036B 15 ISZERO 036C 61 PUSH2 0x0374 036F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0369 stack[0] = msg.value } // Block ends with conditional jump to 0x0374, if !msg.value label_0370: // Incoming jump from 0x036F, if not !msg.value // Inputs[1] { @0373 memory[0x00:0x00] } 0370 60 PUSH1 0x00 0372 80 DUP1 0373 FD *REVERT // Stack delta = +0 // Outputs[1] { @0373 revert(memory[0x00:0x00]); } // Block terminates label_0374: // Incoming jump from 0x036F, if !msg.value // Inputs[1] { @037C msg.data.length } 0374 5B JUMPDEST 0375 50 POP 0376 61 PUSH2 0x0388 0379 61 PUSH2 0x0383 037C 36 CALLDATASIZE 037D 60 PUSH1 0x04 037F 61 PUSH2 0x1cd7 0382 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0376 stack[-1] = 0x0388 // @0379 stack[0] = 0x0383 // @037C stack[1] = msg.data.length // @037D stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x0383 label_0383: // Incoming return from call to 0x1CD7 at 0x0382 0383 5B JUMPDEST 0384 61 PUSH2 0x093a 0387 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x093a label_0388: // Incoming return from call to 0x0502 at 0x0501 // Incoming jump from 0x03E7 // Incoming jump from 0x05E1 // Incoming return from call to 0x0383 at 0x0382 // Inputs[2] // { // @038B memory[0x40:0x60] // @0395 stack[-1] // } 0388 5B JUMPDEST 0389 60 PUSH1 0x40 038B 51 MLOAD 038C 60 PUSH1 0x01 038E 60 PUSH1 0x01 0390 60 PUSH1 0xa0 0392 1B SHL 0393 03 SUB 0394 90 SWAP1 0395 91 SWAP2 0396 16 AND 0397 81 DUP2 0398 52 MSTORE 0399 60 PUSH1 0x20 039B 01 ADD 039C 61 PUSH2 0x02f7 039F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0398 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @039B stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02f7 label_03A0: // Incoming jump from 0x026E, if 0x095ea7b3 == stack[-1] // Inputs[1] { @03A1 msg.value } 03A0 5B JUMPDEST 03A1 34 CALLVALUE 03A2 80 DUP1 03A3 15 ISZERO 03A4 61 PUSH2 0x03ac 03A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A1 stack[0] = msg.value } // Block ends with conditional jump to 0x03ac, if !msg.value label_03A8: // Incoming jump from 0x03A7, if not !msg.value // Inputs[1] { @03AB memory[0x00:0x00] } 03A8 60 PUSH1 0x00 03AA 80 DUP1 03AB FD *REVERT // Stack delta = +0 // Outputs[1] { @03AB revert(memory[0x00:0x00]); } // Block terminates label_03AC: // Incoming jump from 0x03A7, if !msg.value // Inputs[1] { @03B4 msg.data.length } 03AC 5B JUMPDEST 03AD 50 POP 03AE 61 PUSH2 0x0344 03B1 61 PUSH2 0x03bb 03B4 36 CALLDATASIZE 03B5 60 PUSH1 0x04 03B7 61 PUSH2 0x1d77 03BA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03AE stack[-1] = 0x0344 // @03B1 stack[0] = 0x03bb // @03B4 stack[1] = msg.data.length // @03B5 stack[2] = 0x04 // } // Block ends with call to 0x1d77, returns to 0x03BB label_03BB: // Incoming return from call to 0x1D77 at 0x03BA 03BB 5B JUMPDEST 03BC 61 PUSH2 0x097e 03BF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097e label_03C0: // Incoming jump from 0x0279, if 0x1581b600 == stack[-1] // Inputs[1] { @03C1 msg.value } 03C0 5B JUMPDEST 03C1 34 CALLVALUE 03C2 80 DUP1 03C3 15 ISZERO 03C4 61 PUSH2 0x03cc 03C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C1 stack[0] = msg.value } // Block ends with conditional jump to 0x03cc, if !msg.value label_03C8: // Incoming jump from 0x03C7, if not !msg.value // Inputs[1] { @03CB memory[0x00:0x00] } 03C8 60 PUSH1 0x00 03CA 80 DUP1 03CB FD *REVERT // Stack delta = +0 // Outputs[1] { @03CB revert(memory[0x00:0x00]); } // Block terminates label_03CC: // Incoming jump from 0x03C7, if !msg.value 03CC 5B JUMPDEST 03CD 50 POP 03CE 61 PUSH2 0x0388 03D1 73 PUSH20 0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4 03E6 81 DUP2 03E7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03CE stack[-1] = 0x0388 // @03D1 stack[0] = 0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4 // } // Block ends with unconditional jump to 0x0388 label_03E8: // Incoming jump from 0x0248, if 0x18160ddd == stack[-1] // Inputs[1] { @03E9 msg.value } 03E8 5B JUMPDEST 03E9 34 CALLVALUE 03EA 80 DUP1 03EB 15 ISZERO 03EC 61 PUSH2 0x03f4 03EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E9 stack[0] = msg.value } // Block ends with conditional jump to 0x03f4, if !msg.value label_03F0: // Incoming jump from 0x03EF, if not !msg.value // Inputs[1] { @03F3 memory[0x00:0x00] } 03F0 60 PUSH1 0x00 03F2 80 DUP1 03F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F3 revert(memory[0x00:0x00]); } // Block terminates label_03F4: // Incoming jump from 0x03EF, if !msg.value // Inputs[2] // { // @03F8 storage[0x01] // @03FB storage[0x00] // } 03F4 5B JUMPDEST 03F5 50 POP 03F6 60 PUSH1 0x01 03F8 54 SLOAD 03F9 60 PUSH1 0x00 03FB 54 SLOAD 03FC 03 SUB 03FD 60 PUSH1 0x00 03FF 19 NOT 0400 01 ADD 0401 61 PUSH2 0x0316 0404 56 *JUMP // Stack delta = +0 // Outputs[1] { @0400 stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block ends with unconditional jump to 0x0316 label_0405: // Incoming jump from 0x0253, if 0x1e7269c5 == stack[-1] // Inputs[1] { @0406 msg.value } 0405 5B JUMPDEST 0406 34 CALLVALUE 0407 80 DUP1 0408 15 ISZERO 0409 61 PUSH2 0x0411 040C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0406 stack[0] = msg.value } // Block ends with conditional jump to 0x0411, if !msg.value label_040D: // Incoming jump from 0x040C, if not !msg.value // Inputs[1] { @0410 memory[0x00:0x00] } 040D 60 PUSH1 0x00 040F 80 DUP1 0410 FD *REVERT // Stack delta = +0 // Outputs[1] { @0410 revert(memory[0x00:0x00]); } // Block terminates label_0411: // Incoming jump from 0x040C, if !msg.value // Inputs[1] { @0419 msg.data.length } 0411 5B JUMPDEST 0412 50 POP 0413 61 PUSH2 0x0316 0416 61 PUSH2 0x0420 0419 36 CALLDATASIZE 041A 60 PUSH1 0x04 041C 61 PUSH2 0x1da1 041F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0413 stack[-1] = 0x0316 // @0416 stack[0] = 0x0420 // @0419 stack[1] = msg.data.length // @041A stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1da1 0420 5B JUMPDEST 0421 60 PUSH1 0x0b 0423 60 PUSH1 0x20 0425 52 MSTORE 0426 60 PUSH1 0x00 0428 90 SWAP1 0429 81 DUP2 042A 52 MSTORE 042B 60 PUSH1 0x40 042D 90 SWAP1 042E 20 SHA3 042F 54 SLOAD 0430 81 DUP2 0431 56 *JUMP label_0432: // Incoming jump from 0x025E, if 0x23245216 == stack[-1] // Inputs[1] { @0433 msg.value } 0432 5B JUMPDEST 0433 34 CALLVALUE 0434 80 DUP1 0435 15 ISZERO 0436 61 PUSH2 0x043e 0439 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0433 stack[0] = msg.value } // Block ends with conditional jump to 0x043e, if !msg.value label_043A: // Incoming jump from 0x0439, if not !msg.value // Inputs[1] { @043D memory[0x00:0x00] } 043A 60 PUSH1 0x00 043C 80 DUP1 043D FD *REVERT // Stack delta = +0 // Outputs[1] { @043D revert(memory[0x00:0x00]); } // Block terminates label_043E: // Incoming jump from 0x0439, if !msg.value // Inputs[1] { @0446 msg.data.length } 043E 5B JUMPDEST 043F 50 POP 0440 61 PUSH2 0x0344 0443 61 PUSH2 0x044d 0446 36 CALLDATASIZE 0447 60 PUSH1 0x04 0449 61 PUSH2 0x1e03 044C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0440 stack[-1] = 0x0344 // @0443 stack[0] = 0x044d // @0446 stack[1] = msg.data.length // @0447 stack[2] = 0x04 // } // Block ends with call to 0x1e03, returns to 0x044D label_044D: // Incoming return from call to 0x1E03 at 0x044C 044D 5B JUMPDEST 044E 61 PUSH2 0x0a0b 0451 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a0b label_0452: // Incoming jump from 0x0217, if 0x23b872dd == stack[-1] // Inputs[1] { @0453 msg.value } 0452 5B JUMPDEST 0453 34 CALLVALUE 0454 80 DUP1 0455 15 ISZERO 0456 61 PUSH2 0x045e 0459 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0453 stack[0] = msg.value } // Block ends with conditional jump to 0x045e, if !msg.value label_045A: // Incoming jump from 0x0459, if not !msg.value // Inputs[1] { @045D memory[0x00:0x00] } 045A 60 PUSH1 0x00 045C 80 DUP1 045D FD *REVERT // Stack delta = +0 // Outputs[1] { @045D revert(memory[0x00:0x00]); } // Block terminates label_045E: // Incoming jump from 0x0459, if !msg.value // Inputs[1] { @0466 msg.data.length } 045E 5B JUMPDEST 045F 50 POP 0460 61 PUSH2 0x0344 0463 61 PUSH2 0x046d 0466 36 CALLDATASIZE 0467 60 PUSH1 0x04 0469 61 PUSH2 0x1eb0 046C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0460 stack[-1] = 0x0344 // @0463 stack[0] = 0x046d // @0466 stack[1] = msg.data.length // @0467 stack[2] = 0x04 // } // Block ends with call to 0x1eb0, returns to 0x046D label_046D: // Incoming return from call to 0x1EB0 at 0x046C 046D 5B JUMPDEST 046E 61 PUSH2 0x0abf 0471 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0abf label_0472: // Incoming jump from 0x0222, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0473 msg.value } 0472 5B JUMPDEST 0473 34 CALLVALUE 0474 80 DUP1 0475 15 ISZERO 0476 61 PUSH2 0x047e 0479 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0473 stack[0] = msg.value } // Block ends with conditional jump to 0x047e, if !msg.value label_047A: // Incoming jump from 0x0479, if not !msg.value // Inputs[1] { @047D memory[0x00:0x00] } 047A 60 PUSH1 0x00 047C 80 DUP1 047D FD *REVERT // Stack delta = +0 // Outputs[1] { @047D revert(memory[0x00:0x00]); } // Block terminates label_047E: // Incoming jump from 0x0479, if !msg.value 047E 5B JUMPDEST 047F 50 POP 0480 61 PUSH2 0x0344 0483 61 PUSH2 0x0aca 0486 56 *JUMP // Stack delta = +0 // Outputs[1] { @0480 stack[-1] = 0x0344 } // Block ends with call to 0x0aca, returns to 0x0344 label_0487: // Incoming jump from 0x01F1, if 0x42842e0e == stack[-1] // Inputs[1] { @0488 msg.value } 0487 5B JUMPDEST 0488 34 CALLVALUE 0489 80 DUP1 048A 15 ISZERO 048B 61 PUSH2 0x0493 048E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0488 stack[0] = msg.value } // Block ends with conditional jump to 0x0493, if !msg.value label_048F: // Incoming jump from 0x048E, if not !msg.value // Inputs[1] { @0492 memory[0x00:0x00] } 048F 60 PUSH1 0x00 0491 80 DUP1 0492 FD *REVERT // Stack delta = +0 // Outputs[1] { @0492 revert(memory[0x00:0x00]); } // Block terminates label_0493: // Incoming jump from 0x048E, if !msg.value // Inputs[1] { @049B msg.data.length } 0493 5B JUMPDEST 0494 50 POP 0495 61 PUSH2 0x0344 0498 61 PUSH2 0x04a2 049B 36 CALLDATASIZE 049C 60 PUSH1 0x04 049E 61 PUSH2 0x1eb0 04A1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0495 stack[-1] = 0x0344 // @0498 stack[0] = 0x04a2 // @049B stack[1] = msg.data.length // @049C stack[2] = 0x04 // } // Block ends with call to 0x1eb0, returns to 0x04A2 label_04A2: // Incoming return from call to 0x1EB0 at 0x04A1 04A2 5B JUMPDEST 04A3 61 PUSH2 0x0b7e 04A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b7e label_04A7: // Incoming jump from 0x01FC, if 0x46ab06db == stack[-1] // Inputs[1] { @04A8 msg.value } 04A7 5B JUMPDEST 04A8 34 CALLVALUE 04A9 80 DUP1 04AA 15 ISZERO 04AB 61 PUSH2 0x04b3 04AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A8 stack[0] = msg.value } // Block ends with conditional jump to 0x04b3, if !msg.value label_04AF: // Incoming jump from 0x04AE, if not !msg.value // Inputs[1] { @04B2 memory[0x00:0x00] } 04AF 60 PUSH1 0x00 04B1 80 DUP1 04B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B2 revert(memory[0x00:0x00]); } // Block terminates label_04B3: // Incoming jump from 0x04AE, if !msg.value // Inputs[1] { @04BB msg.data.length } 04B3 5B JUMPDEST 04B4 50 POP 04B5 61 PUSH2 0x0344 04B8 61 PUSH2 0x04c2 04BB 36 CALLDATASIZE 04BC 60 PUSH1 0x04 04BE 61 PUSH2 0x1cd7 04C1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B5 stack[-1] = 0x0344 // @04B8 stack[0] = 0x04c2 // @04BB stack[1] = msg.data.length // @04BC stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x04C2 label_04C2: // Incoming return from call to 0x1CD7 at 0x04C1 04C2 5B JUMPDEST 04C3 61 PUSH2 0x0b99 04C6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b99 label_04C7: // Incoming jump from 0x0207, if 0x55f804b3 == stack[-1] // Inputs[1] { @04C8 msg.value } 04C7 5B JUMPDEST 04C8 34 CALLVALUE 04C9 80 DUP1 04CA 15 ISZERO 04CB 61 PUSH2 0x04d3 04CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C8 stack[0] = msg.value } // Block ends with conditional jump to 0x04d3, if !msg.value label_04CF: // Incoming jump from 0x04CE, if not !msg.value // Inputs[1] { @04D2 memory[0x00:0x00] } 04CF 60 PUSH1 0x00 04D1 80 DUP1 04D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D2 revert(memory[0x00:0x00]); } // Block terminates label_04D3: // Incoming jump from 0x04CE, if !msg.value // Inputs[1] { @04DB msg.data.length } 04D3 5B JUMPDEST 04D4 50 POP 04D5 61 PUSH2 0x0344 04D8 61 PUSH2 0x04e2 04DB 36 CALLDATASIZE 04DC 60 PUSH1 0x04 04DE 61 PUSH2 0x1f44 04E1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D5 stack[-1] = 0x0344 // @04D8 stack[0] = 0x04e2 // @04DB stack[1] = msg.data.length // @04DC stack[2] = 0x04 // } // Block ends with call to 0x1f44, returns to 0x04E2 label_04E2: // Incoming return from call to 0x1F44 at 0x04E1 04E2 5B JUMPDEST 04E3 61 PUSH2 0x0be6 04E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0be6 label_04E7: // Incoming jump from 0x01CB, if 0x6352211e == stack[-1] // Inputs[1] { @04E8 msg.value } 04E7 5B JUMPDEST 04E8 34 CALLVALUE 04E9 80 DUP1 04EA 15 ISZERO 04EB 61 PUSH2 0x04f3 04EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E8 stack[0] = msg.value } // Block ends with conditional jump to 0x04f3, if !msg.value label_04EF: // Incoming jump from 0x04EE, if not !msg.value // Inputs[1] { @04F2 memory[0x00:0x00] } 04EF 60 PUSH1 0x00 04F1 80 DUP1 04F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F2 revert(memory[0x00:0x00]); } // Block terminates label_04F3: // Incoming jump from 0x04EE, if !msg.value // Inputs[1] { @04FB msg.data.length } 04F3 5B JUMPDEST 04F4 50 POP 04F5 61 PUSH2 0x0388 04F8 61 PUSH2 0x0502 04FB 36 CALLDATASIZE 04FC 60 PUSH1 0x04 04FE 61 PUSH2 0x1cd7 0501 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F5 stack[-1] = 0x0388 // @04F8 stack[0] = 0x0502 // @04FB stack[1] = msg.data.length // @04FC stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x0502 label_0502: // Incoming return from call to 0x1CD7 at 0x0501 0502 5B JUMPDEST 0503 61 PUSH2 0x0c3a 0506 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c3a label_0507: // Incoming jump from 0x01D6, if 0x6c0360eb == stack[-1] // Inputs[1] { @0508 msg.value } 0507 5B JUMPDEST 0508 34 CALLVALUE 0509 80 DUP1 050A 15 ISZERO 050B 61 PUSH2 0x0513 050E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0508 stack[0] = msg.value } // Block ends with conditional jump to 0x0513, if !msg.value label_050F: // Incoming jump from 0x050E, if not !msg.value // Inputs[1] { @0512 memory[0x00:0x00] } 050F 60 PUSH1 0x00 0511 80 DUP1 0512 FD *REVERT // Stack delta = +0 // Outputs[1] { @0512 revert(memory[0x00:0x00]); } // Block terminates label_0513: // Incoming jump from 0x050E, if !msg.value 0513 5B JUMPDEST 0514 50 POP 0515 61 PUSH2 0x035b 0518 61 PUSH2 0x0c4c 051B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0515 stack[-1] = 0x035b } // Block ends with call to 0x0c4c, returns to 0x035B label_051C: // Incoming jump from 0x01A5, if 0x70a08231 == stack[-1] // Inputs[1] { @051D msg.value } 051C 5B JUMPDEST 051D 34 CALLVALUE 051E 80 DUP1 051F 15 ISZERO 0520 61 PUSH2 0x0528 0523 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051D stack[0] = msg.value } // Block ends with conditional jump to 0x0528, if !msg.value label_0524: // Incoming jump from 0x0523, if not !msg.value // Inputs[1] { @0527 memory[0x00:0x00] } 0524 60 PUSH1 0x00 0526 80 DUP1 0527 FD *REVERT // Stack delta = +0 // Outputs[1] { @0527 revert(memory[0x00:0x00]); } // Block terminates label_0528: // Incoming jump from 0x0523, if !msg.value // Inputs[1] { @0530 msg.data.length } 0528 5B JUMPDEST 0529 50 POP 052A 61 PUSH2 0x0316 052D 61 PUSH2 0x0537 0530 36 CALLDATASIZE 0531 60 PUSH1 0x04 0533 61 PUSH2 0x1da1 0536 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @052A stack[-1] = 0x0316 // @052D stack[0] = 0x0537 // @0530 stack[1] = msg.data.length // @0531 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1da1 0537 5B JUMPDEST 0538 61 PUSH2 0x0cda 053B 56 *JUMP label_053C: // Incoming jump from 0x01B0, if 0x715018a6 == stack[-1] // Inputs[1] { @053D msg.value } 053C 5B JUMPDEST 053D 34 CALLVALUE 053E 80 DUP1 053F 15 ISZERO 0540 61 PUSH2 0x0548 0543 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053D stack[0] = msg.value } // Block ends with conditional jump to 0x0548, if !msg.value label_0544: // Incoming jump from 0x0543, if not !msg.value // Inputs[1] { @0547 memory[0x00:0x00] } 0544 60 PUSH1 0x00 0546 80 DUP1 0547 FD *REVERT // Stack delta = +0 // Outputs[1] { @0547 revert(memory[0x00:0x00]); } // Block terminates label_0548: // Incoming jump from 0x0543, if !msg.value 0548 5B JUMPDEST 0549 50 POP 054A 61 PUSH2 0x0344 054D 61 PUSH2 0x0d29 0550 56 *JUMP // Stack delta = +0 // Outputs[1] { @054A stack[-1] = 0x0344 } // Block ends with call to 0x0d29, returns to 0x0344 label_0551: // Incoming jump from 0x01BB, if 0x780cf82a == stack[-1] // Inputs[1] { @0552 msg.value } 0551 5B JUMPDEST 0552 34 CALLVALUE 0553 80 DUP1 0554 15 ISZERO 0555 61 PUSH2 0x055d 0558 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0552 stack[0] = msg.value } // Block ends with conditional jump to 0x055d, if !msg.value label_0559: // Incoming jump from 0x0558, if not !msg.value // Inputs[1] { @055C memory[0x00:0x00] } 0559 60 PUSH1 0x00 055B 80 DUP1 055C FD *REVERT // Stack delta = +0 // Outputs[1] { @055C revert(memory[0x00:0x00]); } // Block terminates label_055D: // Incoming jump from 0x0558, if !msg.value // Inputs[1] { @0565 msg.data.length } 055D 5B JUMPDEST 055E 50 POP 055F 61 PUSH2 0x0344 0562 61 PUSH2 0x056c 0565 36 CALLDATASIZE 0566 60 PUSH1 0x04 0568 61 PUSH2 0x1f44 056B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055F stack[-1] = 0x0344 // @0562 stack[0] = 0x056c // @0565 stack[1] = msg.data.length // @0566 stack[2] = 0x04 // } // Block ends with call to 0x1f44, returns to 0x056C label_056C: // Incoming return from call to 0x1F44 at 0x056B 056C 5B JUMPDEST 056D 61 PUSH2 0x0d7d 0570 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d7d label_0571: // Incoming jump from 0x0169, if 0x8545f4ea == stack[-1] // Inputs[1] { @0572 msg.value } 0571 5B JUMPDEST 0572 34 CALLVALUE 0573 80 DUP1 0574 15 ISZERO 0575 61 PUSH2 0x057d 0578 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0572 stack[0] = msg.value } // Block ends with conditional jump to 0x057d, if !msg.value label_0579: // Incoming jump from 0x0578, if not !msg.value // Inputs[1] { @057C memory[0x00:0x00] } 0579 60 PUSH1 0x00 057B 80 DUP1 057C FD *REVERT // Stack delta = +0 // Outputs[1] { @057C revert(memory[0x00:0x00]); } // Block terminates label_057D: // Incoming jump from 0x0578, if !msg.value // Inputs[1] { @0585 msg.data.length } 057D 5B JUMPDEST 057E 50 POP 057F 61 PUSH2 0x0344 0582 61 PUSH2 0x058c 0585 36 CALLDATASIZE 0586 60 PUSH1 0x04 0588 61 PUSH2 0x1cd7 058B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @057F stack[-1] = 0x0344 // @0582 stack[0] = 0x058c // @0585 stack[1] = msg.data.length // @0586 stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x058C label_058C: // Incoming return from call to 0x1CD7 at 0x058B 058C 5B JUMPDEST 058D 61 PUSH2 0x0dd1 0590 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd1 label_0591: // Incoming jump from 0x0174, if 0x863c0891 == stack[-1] // Inputs[1] { @0592 msg.value } 0591 5B JUMPDEST 0592 34 CALLVALUE 0593 80 DUP1 0594 15 ISZERO 0595 61 PUSH2 0x059d 0598 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0592 stack[0] = msg.value } // Block ends with conditional jump to 0x059d, if !msg.value label_0599: // Incoming jump from 0x0598, if not !msg.value // Inputs[1] { @059C memory[0x00:0x00] } 0599 60 PUSH1 0x00 059B 80 DUP1 059C FD *REVERT // Stack delta = +0 // Outputs[1] { @059C revert(memory[0x00:0x00]); } // Block terminates label_059D: // Incoming jump from 0x0598, if !msg.value // Inputs[1] { @05A5 msg.data.length } 059D 5B JUMPDEST 059E 50 POP 059F 61 PUSH2 0x0344 05A2 61 PUSH2 0x05ac 05A5 36 CALLDATASIZE 05A6 60 PUSH1 0x04 05A8 61 PUSH2 0x1cd7 05AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @059F stack[-1] = 0x0344 // @05A2 stack[0] = 0x05ac // @05A5 stack[1] = msg.data.length // @05A6 stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x05AC label_05AC: // Incoming return from call to 0x1CD7 at 0x05AB 05AC 5B JUMPDEST 05AD 61 PUSH2 0x0e1e 05B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e1e label_05B1: // Incoming jump from 0x0143, if 0x868ff4a2 == stack[-1] // Inputs[1] { @05B8 msg.data.length } 05B1 5B JUMPDEST 05B2 61 PUSH2 0x0344 05B5 61 PUSH2 0x05bf 05B8 36 CALLDATASIZE 05B9 60 PUSH1 0x04 05BB 61 PUSH2 0x1cd7 05BE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05B2 stack[0] = 0x0344 // @05B5 stack[1] = 0x05bf // @05B8 stack[2] = msg.data.length // @05B9 stack[3] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x05BF label_05BF: // Incoming return from call to 0x1CD7 at 0x05BE 05BF 5B JUMPDEST 05C0 61 PUSH2 0x0e6b 05C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e6b label_05C4: // Incoming jump from 0x014E, if 0x8da5cb5b == stack[-1] // Inputs[1] { @05C5 msg.value } 05C4 5B JUMPDEST 05C5 34 CALLVALUE 05C6 80 DUP1 05C7 15 ISZERO 05C8 61 PUSH2 0x05d0 05CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C5 stack[0] = msg.value } // Block ends with conditional jump to 0x05d0, if !msg.value label_05CC: // Incoming jump from 0x05CB, if not !msg.value // Inputs[1] { @05CF memory[0x00:0x00] } 05CC 60 PUSH1 0x00 05CE 80 DUP1 05CF FD *REVERT // Stack delta = +0 // Outputs[1] { @05CF revert(memory[0x00:0x00]); } // Block terminates label_05D0: // Incoming jump from 0x05CB, if !msg.value // Inputs[1] { @05D4 storage[0x08] } 05D0 5B JUMPDEST 05D1 50 POP 05D2 60 PUSH1 0x08 05D4 54 SLOAD 05D5 60 PUSH1 0x01 05D7 60 PUSH1 0x01 05D9 60 PUSH1 0xa0 05DB 1B SHL 05DC 03 SUB 05DD 16 AND 05DE 61 PUSH2 0x0388 05E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @05DD stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x0388 label_05E2: // Incoming jump from 0x0159, if 0x95d89b41 == stack[-1] // Inputs[1] { @05E3 msg.value } 05E2 5B JUMPDEST 05E3 34 CALLVALUE 05E4 80 DUP1 05E5 15 ISZERO 05E6 61 PUSH2 0x05ee 05E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E3 stack[0] = msg.value } // Block ends with conditional jump to 0x05ee, if !msg.value label_05EA: // Incoming jump from 0x05E9, if not !msg.value // Inputs[1] { @05ED memory[0x00:0x00] } 05EA 60 PUSH1 0x00 05EC 80 DUP1 05ED FD *REVERT // Stack delta = +0 // Outputs[1] { @05ED revert(memory[0x00:0x00]); } // Block terminates label_05EE: // Incoming jump from 0x05E9, if !msg.value 05EE 5B JUMPDEST 05EF 50 POP 05F0 61 PUSH2 0x035b 05F3 61 PUSH2 0x0fcf 05F6 56 *JUMP // Stack delta = +0 // Outputs[1] { @05F0 stack[-1] = 0x035b } // Block ends with call to 0x0fcf, returns to 0x035B label_05F7: // Incoming jump from 0x011D, if 0x98a8cffe == stack[-1] // Inputs[1] { @05F8 msg.value } 05F7 5B JUMPDEST 05F8 34 CALLVALUE 05F9 80 DUP1 05FA 15 ISZERO 05FB 61 PUSH2 0x0603 05FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0603, if !msg.value label_05FF: // Incoming jump from 0x05FE, if not !msg.value // Inputs[1] { @0602 memory[0x00:0x00] } 05FF 60 PUSH1 0x00 0601 80 DUP1 0602 FD *REVERT // Stack delta = +0 // Outputs[1] { @0602 revert(memory[0x00:0x00]); } // Block terminates label_0603: // Incoming jump from 0x05FE, if !msg.value // Inputs[1] { @060B msg.data.length } 0603 5B JUMPDEST 0604 50 POP 0605 61 PUSH2 0x0316 0608 61 PUSH2 0x0612 060B 36 CALLDATASIZE 060C 60 PUSH1 0x04 060E 61 PUSH2 0x1da1 0611 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0605 stack[-1] = 0x0316 // @0608 stack[0] = 0x0612 // @060B stack[1] = msg.data.length // @060C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1da1 0612 5B JUMPDEST 0613 60 PUSH1 0x0a 0615 60 PUSH1 0x20 0617 52 MSTORE 0618 60 PUSH1 0x00 061A 90 SWAP1 061B 81 DUP2 061C 52 MSTORE 061D 60 PUSH1 0x40 061F 90 SWAP1 0620 20 SHA3 0621 54 SLOAD 0622 81 DUP2 0623 56 *JUMP label_0624: // Incoming jump from 0x0128, if 0x9b19251a == stack[-1] // Inputs[1] { @0625 msg.value } 0624 5B JUMPDEST 0625 34 CALLVALUE 0626 80 DUP1 0627 15 ISZERO 0628 61 PUSH2 0x0630 062B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0625 stack[0] = msg.value } // Block ends with conditional jump to 0x0630, if !msg.value label_062C: // Incoming jump from 0x062B, if not !msg.value // Inputs[1] { @062F memory[0x00:0x00] } 062C 60 PUSH1 0x00 062E 80 DUP1 062F FD *REVERT // Stack delta = +0 // Outputs[1] { @062F revert(memory[0x00:0x00]); } // Block terminates label_0630: // Incoming jump from 0x062B, if !msg.value // Inputs[1] { @0638 msg.data.length } 0630 5B JUMPDEST 0631 50 POP 0632 61 PUSH2 0x02eb 0635 61 PUSH2 0x063f 0638 36 CALLDATASIZE 0639 60 PUSH1 0x04 063B 61 PUSH2 0x1da1 063E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0632 stack[-1] = 0x02eb // @0635 stack[0] = 0x063f // @0638 stack[1] = msg.data.length // @0639 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1da1 063F 5B JUMPDEST 0640 60 PUSH1 0x09 0642 60 PUSH1 0x20 0644 52 MSTORE 0645 60 PUSH1 0x00 0647 90 SWAP1 0648 81 DUP2 0649 52 MSTORE 064A 60 PUSH1 0x40 064C 90 SWAP1 064D 20 SHA3 064E 54 SLOAD 064F 60 PUSH1 0xff 0651 16 AND 0652 81 DUP2 0653 56 *JUMP label_0654: // Incoming jump from 0x00F7, if 0xa0712d68 == stack[-1] // Inputs[1] { @065B msg.data.length } 0654 5B JUMPDEST 0655 61 PUSH2 0x0344 0658 61 PUSH2 0x0662 065B 36 CALLDATASIZE 065C 60 PUSH1 0x04 065E 61 PUSH2 0x1cd7 0661 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0655 stack[0] = 0x0344 // @0658 stack[1] = 0x0662 // @065B stack[2] = msg.data.length // @065C stack[3] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x0662 label_0662: // Incoming return from call to 0x1CD7 at 0x0661 0662 5B JUMPDEST 0663 61 PUSH2 0x0fde 0666 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fde label_0667: // Incoming jump from 0x0102, if 0xa22cb465 == stack[-1] // Inputs[1] { @0668 msg.value } 0667 5B JUMPDEST 0668 34 CALLVALUE 0669 80 DUP1 066A 15 ISZERO 066B 61 PUSH2 0x0673 066E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0668 stack[0] = msg.value } // Block ends with conditional jump to 0x0673, if !msg.value label_066F: // Incoming jump from 0x066E, if not !msg.value // Inputs[1] { @0672 memory[0x00:0x00] } 066F 60 PUSH1 0x00 0671 80 DUP1 0672 FD *REVERT // Stack delta = +0 // Outputs[1] { @0672 revert(memory[0x00:0x00]); } // Block terminates label_0673: // Incoming jump from 0x066E, if !msg.value // Inputs[1] { @067B msg.data.length } 0673 5B JUMPDEST 0674 50 POP 0675 61 PUSH2 0x0344 0678 61 PUSH2 0x0682 067B 36 CALLDATASIZE 067C 60 PUSH1 0x04 067E 61 PUSH2 0x1f8d 0681 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0675 stack[-1] = 0x0344 // @0678 stack[0] = 0x0682 // @067B stack[1] = msg.data.length // @067C stack[2] = 0x04 // } // Block ends with call to 0x1f8d, returns to 0x0682 label_0682: // Incoming return from call to 0x1F8D at 0x0681 0682 5B JUMPDEST 0683 61 PUSH2 0x10d7 0686 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10d7 label_0687: // Incoming jump from 0x010D, if 0xa96af0f4 == stack[-1] // Inputs[1] { @0688 msg.value } 0687 5B JUMPDEST 0688 34 CALLVALUE 0689 80 DUP1 068A 15 ISZERO 068B 61 PUSH2 0x0693 068E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0688 stack[0] = msg.value } // Block ends with conditional jump to 0x0693, if !msg.value label_068F: // Incoming jump from 0x068E, if not !msg.value // Inputs[1] { @0692 memory[0x00:0x00] } 068F 60 PUSH1 0x00 0691 80 DUP1 0692 FD *REVERT // Stack delta = +0 // Outputs[1] { @0692 revert(memory[0x00:0x00]); } // Block terminates label_0693: // Incoming jump from 0x068E, if !msg.value // Inputs[1] { @069A storage[0x0e] } 0693 5B JUMPDEST 0694 50 POP 0695 61 PUSH2 0x0316 0698 60 PUSH1 0x0e 069A 54 SLOAD 069B 81 DUP2 069C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0695 stack[-1] = 0x0316 // @069A stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x0316 label_069D: // Incoming jump from 0x00C6, if 0xb1c9fe6e == stack[-1] // Inputs[1] { @069E msg.value } 069D 5B JUMPDEST 069E 34 CALLVALUE 069F 80 DUP1 06A0 15 ISZERO 06A1 61 PUSH2 0x06a9 06A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @069E stack[0] = msg.value } // Block ends with conditional jump to 0x06a9, if !msg.value label_06A5: // Incoming jump from 0x06A4, if not !msg.value // Inputs[1] { @06A8 memory[0x00:0x00] } 06A5 60 PUSH1 0x00 06A7 80 DUP1 06A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A8 revert(memory[0x00:0x00]); } // Block terminates label_06A9: // Incoming jump from 0x06A4, if !msg.value // Inputs[1] { @06AD storage[0x10] } 06A9 5B JUMPDEST 06AA 50 POP 06AB 60 PUSH1 0x10 06AD 54 SLOAD 06AE 61 PUSH2 0x06b7 06B1 90 SWAP1 06B2 60 PUSH1 0xff 06B4 16 AND 06B5 81 DUP2 06B6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06B1 stack[-1] = 0x06b7 // @06B4 stack[0] = 0xff & storage[0x10] // } // Block ends with unconditional jump to 0x06b7 label_06B7: // Incoming jump from 0x06B6 // Inputs[2] // { // @06BA memory[0x40:0x60] // @06BE stack[-1] // } 06B7 5B JUMPDEST 06B8 60 PUSH1 0x40 06BA 51 MLOAD 06BB 61 PUSH2 0x02f7 06BE 91 SWAP2 06BF 90 SWAP1 06C0 61 PUSH2 0x1fdf 06C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06BE stack[-1] = 0x02f7 // @06BF stack[1] = memory[0x40:0x60] // @06BF stack[0] = stack[-1] // } // Block ends with call to 0x1fdf, returns to 0x02F7 label_06C4: // Incoming jump from 0x00D1, if 0xb88d4fde == stack[-1] // Inputs[1] { @06C5 msg.value } 06C4 5B JUMPDEST 06C5 34 CALLVALUE 06C6 80 DUP1 06C7 15 ISZERO 06C8 61 PUSH2 0x06d0 06CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C5 stack[0] = msg.value } // Block ends with conditional jump to 0x06d0, if !msg.value label_06CC: // Incoming jump from 0x06CB, if not !msg.value // Inputs[1] { @06CF memory[0x00:0x00] } 06CC 60 PUSH1 0x00 06CE 80 DUP1 06CF FD *REVERT // Stack delta = +0 // Outputs[1] { @06CF revert(memory[0x00:0x00]); } // Block terminates label_06D0: // Incoming jump from 0x06CB, if !msg.value // Inputs[1] { @06D8 msg.data.length } 06D0 5B JUMPDEST 06D1 50 POP 06D2 61 PUSH2 0x0344 06D5 61 PUSH2 0x06df 06D8 36 CALLDATASIZE 06D9 60 PUSH1 0x04 06DB 61 PUSH2 0x2007 06DE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06D2 stack[-1] = 0x0344 // @06D5 stack[0] = 0x06df // @06D8 stack[1] = msg.data.length // @06D9 stack[2] = 0x04 // } // Block ends with call to 0x2007, returns to 0x06DF label_06DF: // Incoming return from call to 0x2007 at 0x06DE 06DF 5B JUMPDEST 06E0 61 PUSH2 0x116c 06E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x116c label_06E4: // Incoming jump from 0x00A0, if 0xbdb4b848 == stack[-1] // Inputs[1] { @06E5 msg.value } 06E4 5B JUMPDEST 06E5 34 CALLVALUE 06E6 80 DUP1 06E7 15 ISZERO 06E8 61 PUSH2 0x06f0 06EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E5 stack[0] = msg.value } // Block ends with conditional jump to 0x06f0, if !msg.value label_06EC: // Incoming jump from 0x06EB, if not !msg.value // Inputs[1] { @06EF memory[0x00:0x00] } 06EC 60 PUSH1 0x00 06EE 80 DUP1 06EF FD *REVERT // Stack delta = +0 // Outputs[1] { @06EF revert(memory[0x00:0x00]); } // Block terminates label_06F0: // Incoming jump from 0x06EB, if !msg.value // Inputs[1] { @06F7 storage[0x0c] } 06F0 5B JUMPDEST 06F1 50 POP 06F2 61 PUSH2 0x0316 06F5 60 PUSH1 0x0c 06F7 54 SLOAD 06F8 81 DUP2 06F9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06F2 stack[-1] = 0x0316 // @06F7 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x0316 label_06FA: // Incoming jump from 0x00AB, if 0xc03afb59 == stack[-1] // Inputs[1] { @06FB msg.value } 06FA 5B JUMPDEST 06FB 34 CALLVALUE 06FC 80 DUP1 06FD 15 ISZERO 06FE 61 PUSH2 0x0706 0701 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FB stack[0] = msg.value } // Block ends with conditional jump to 0x0706, if !msg.value label_0702: // Incoming jump from 0x0701, if not !msg.value // Inputs[1] { @0705 memory[0x00:0x00] } 0702 60 PUSH1 0x00 0704 80 DUP1 0705 FD *REVERT // Stack delta = +0 // Outputs[1] { @0705 revert(memory[0x00:0x00]); } // Block terminates label_0706: // Incoming jump from 0x0701, if !msg.value // Inputs[1] { @070E msg.data.length } 0706 5B JUMPDEST 0707 50 POP 0708 61 PUSH2 0x0344 070B 61 PUSH2 0x0715 070E 36 CALLDATASIZE 070F 60 PUSH1 0x04 0711 61 PUSH2 0x2083 0714 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0708 stack[-1] = 0x0344 // @070B stack[0] = 0x0715 // @070E stack[1] = msg.data.length // @070F stack[2] = 0x04 // } // Block ends with call to 0x2083, returns to 0x0715 label_0715: // Incoming return from call to 0x2083 at 0x0714 0715 5B JUMPDEST 0716 61 PUSH2 0x11bd 0719 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11bd label_071A: // Incoming jump from 0x00B6, if 0xc87b56dd == stack[-1] // Inputs[1] { @071B msg.value } 071A 5B JUMPDEST 071B 34 CALLVALUE 071C 80 DUP1 071D 15 ISZERO 071E 61 PUSH2 0x0726 0721 57 *JUMPI // Stack delta = +1 // Outputs[1] { @071B stack[0] = msg.value } // Block ends with conditional jump to 0x0726, if !msg.value label_0722: // Incoming jump from 0x0721, if not !msg.value // Inputs[1] { @0725 memory[0x00:0x00] } 0722 60 PUSH1 0x00 0724 80 DUP1 0725 FD *REVERT // Stack delta = +0 // Outputs[1] { @0725 revert(memory[0x00:0x00]); } // Block terminates label_0726: // Incoming jump from 0x0721, if !msg.value // Inputs[1] { @072E msg.data.length } 0726 5B JUMPDEST 0727 50 POP 0728 61 PUSH2 0x035b 072B 61 PUSH2 0x0735 072E 36 CALLDATASIZE 072F 60 PUSH1 0x04 0731 61 PUSH2 0x1cd7 0734 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0728 stack[-1] = 0x035b // @072B stack[0] = 0x0735 // @072E stack[1] = msg.data.length // @072F stack[2] = 0x04 // } // Block ends with call to 0x1cd7, returns to 0x0735 label_0735: // Incoming return from call to 0x1CD7 at 0x0734 0735 5B JUMPDEST 0736 61 PUSH2 0x122c 0739 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x122c label_073A: // Incoming jump from 0x006F, if 0xd5abeb01 == stack[-1] // Inputs[1] { @073B msg.value } 073A 5B JUMPDEST 073B 34 CALLVALUE 073C 80 DUP1 073D 15 ISZERO 073E 61 PUSH2 0x0746 0741 57 *JUMPI // Stack delta = +1 // Outputs[1] { @073B stack[0] = msg.value } // Block ends with conditional jump to 0x0746, if !msg.value label_0742: // Incoming jump from 0x0741, if not !msg.value // Inputs[1] { @0745 memory[0x00:0x00] } 0742 60 PUSH1 0x00 0744 80 DUP1 0745 FD *REVERT // Stack delta = +0 // Outputs[1] { @0745 revert(memory[0x00:0x00]); } // Block terminates label_0746: // Incoming jump from 0x0741, if !msg.value 0746 5B JUMPDEST 0747 50 POP 0748 61 PUSH2 0x0316 074B 61 PUSH2 0x03e8 074E 81 DUP2 074F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0748 stack[-1] = 0x0316 // @074B stack[0] = 0x03e8 // } // Block ends with unconditional jump to 0x0316 label_0750: // Incoming jump from 0x007A, if 0xdb97d4f8 == stack[-1] // Inputs[1] { @0751 msg.value } 0750 5B JUMPDEST 0751 34 CALLVALUE 0752 80 DUP1 0753 15 ISZERO 0754 61 PUSH2 0x075c 0757 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0751 stack[0] = msg.value } // Block ends with conditional jump to 0x075c, if !msg.value label_0758: // Incoming jump from 0x0757, if not !msg.value // Inputs[1] { @075B memory[0x00:0x00] } 0758 60 PUSH1 0x00 075A 80 DUP1 075B FD *REVERT // Stack delta = +0 // Outputs[1] { @075B revert(memory[0x00:0x00]); } // Block terminates label_075C: // Incoming jump from 0x0757, if !msg.value 075C 5B JUMPDEST 075D 50 POP 075E 61 PUSH2 0x035b 0761 61 PUSH2 0x1260 0764 56 *JUMP // Stack delta = +0 // Outputs[1] { @075E stack[-1] = 0x035b } // Block ends with call to 0x1260, returns to 0x035B label_0765: // Incoming jump from 0x0085, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0766 msg.value } 0765 5B JUMPDEST 0766 34 CALLVALUE 0767 80 DUP1 0768 15 ISZERO 0769 61 PUSH2 0x0771 076C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0766 stack[0] = msg.value } // Block ends with conditional jump to 0x0771, if !msg.value label_076D: // Incoming jump from 0x076C, if not !msg.value // Inputs[1] { @0770 memory[0x00:0x00] } 076D 60 PUSH1 0x00 076F 80 DUP1 0770 FD *REVERT // Stack delta = +0 // Outputs[1] { @0770 revert(memory[0x00:0x00]); } // Block terminates label_0771: // Incoming jump from 0x076C, if !msg.value // Inputs[1] { @0779 msg.data.length } 0771 5B JUMPDEST 0772 50 POP 0773 61 PUSH2 0x02eb 0776 61 PUSH2 0x0780 0779 36 CALLDATASIZE 077A 60 PUSH1 0x04 077C 61 PUSH2 0x20a4 077F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0773 stack[-1] = 0x02eb // @0776 stack[0] = 0x0780 // @0779 stack[1] = msg.data.length // @077A stack[2] = 0x04 // } // Block ends with call to 0x20a4, returns to 0x0780 label_0780: // Incoming call from 0x14FA, returns to 0x14FB // Incoming call from 0x09DA, returns to 0x09DB // Incoming return from call to 0x20A4 at 0x077F // Inputs[6] // { // @0789 stack[-2] // @079C memory[0x00:0x40] // @079D stack[-1] // @07A7 memory[0x00:0x40] // @07A8 storage[keccak256(memory[0x00:0x40])] // @07AC stack[-3] // } 0780 5B JUMPDEST 0781 60 PUSH1 0x01 0783 60 PUSH1 0x01 0785 60 PUSH1 0xa0 0787 1B SHL 0788 03 SUB 0789 91 SWAP2 078A 82 DUP3 078B 16 AND 078C 60 PUSH1 0x00 078E 90 SWAP1 078F 81 DUP2 0790 52 MSTORE 0791 60 PUSH1 0x07 0793 60 PUSH1 0x20 0795 90 SWAP1 0796 81 DUP2 0797 52 MSTORE 0798 60 PUSH1 0x40 079A 80 DUP1 079B 83 DUP4 079C 20 SHA3 079D 93 SWAP4 079E 90 SWAP1 079F 94 SWAP5 07A0 16 AND 07A1 82 DUP3 07A2 52 MSTORE 07A3 91 SWAP2 07A4 90 SWAP1 07A5 91 SWAP2 07A6 52 MSTORE 07A7 20 SHA3 07A8 54 SLOAD 07A9 60 PUSH1 0xff 07AB 16 AND 07AC 90 SWAP1 07AD 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0790 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0797 memory[0x20:0x40] = 0x07 // @07A2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @07A6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07AC stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_07AE: // Incoming jump from 0x0049, if 0xf2fde38b == stack[-1] // Inputs[1] { @07AF msg.value } 07AE 5B JUMPDEST 07AF 34 CALLVALUE 07B0 80 DUP1 07B1 15 ISZERO 07B2 61 PUSH2 0x07ba 07B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07AF stack[0] = msg.value } // Block ends with conditional jump to 0x07ba, if !msg.value label_07B6: // Incoming jump from 0x07B5, if not !msg.value // Inputs[1] { @07B9 memory[0x00:0x00] } 07B6 60 PUSH1 0x00 07B8 80 DUP1 07B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B9 revert(memory[0x00:0x00]); } // Block terminates label_07BA: // Incoming jump from 0x07B5, if !msg.value // Inputs[1] { @07C2 msg.data.length } 07BA 5B JUMPDEST 07BB 50 POP 07BC 61 PUSH2 0x0344 07BF 61 PUSH2 0x07c9 07C2 36 CALLDATASIZE 07C3 60 PUSH1 0x04 07C5 61 PUSH2 0x1da1 07C8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07BC stack[-1] = 0x0344 // @07BF stack[0] = 0x07c9 // @07C2 stack[1] = msg.data.length // @07C3 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1da1 07C9 5B JUMPDEST 07CA 61 PUSH2 0x126d 07CD 56 *JUMP label_07CE: // Incoming jump from 0x0054, if 0xf4217648 == stack[-1] // Inputs[1] { @07CF msg.value } 07CE 5B JUMPDEST 07CF 34 CALLVALUE 07D0 80 DUP1 07D1 15 ISZERO 07D2 61 PUSH2 0x07da 07D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07CF stack[0] = msg.value } // Block ends with conditional jump to 0x07da, if !msg.value label_07D6: // Incoming jump from 0x07D5, if not !msg.value // Inputs[1] { @07D9 memory[0x00:0x00] } 07D6 60 PUSH1 0x00 07D8 80 DUP1 07D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D9 revert(memory[0x00:0x00]); } // Block terminates label_07DA: // Incoming jump from 0x07D5, if !msg.value // Inputs[1] { @07E2 msg.data.length } 07DA 5B JUMPDEST 07DB 50 POP 07DC 61 PUSH2 0x0344 07DF 61 PUSH2 0x07e9 07E2 36 CALLDATASIZE 07E3 60 PUSH1 0x04 07E5 61 PUSH2 0x1e03 07E8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07DC stack[-1] = 0x0344 // @07DF stack[0] = 0x07e9 // @07E2 stack[1] = msg.data.length // @07E3 stack[2] = 0x04 // } // Block ends with call to 0x1e03, returns to 0x07E9 label_07E9: // Incoming return from call to 0x1E03 at 0x07E8 07E9 5B JUMPDEST 07EA 61 PUSH2 0x133a 07ED 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x133a label_07EE: // Incoming jump from 0x005F, if 0xf57ea920 == stack[-1] // Inputs[1] { @07EF msg.value } 07EE 5B JUMPDEST 07EF 34 CALLVALUE 07F0 80 DUP1 07F1 15 ISZERO 07F2 61 PUSH2 0x07fa 07F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07EF stack[0] = msg.value } // Block ends with conditional jump to 0x07fa, if !msg.value label_07F6: // Incoming jump from 0x07F5, if not !msg.value // 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 !msg.value // Inputs[1] { @0801 storage[0x0d] } 07FA 5B JUMPDEST 07FB 50 POP 07FC 61 PUSH2 0x0316 07FF 60 PUSH1 0x0d 0801 54 SLOAD 0802 81 DUP2 0803 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07FC stack[-1] = 0x0316 // @0801 stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x0316 0804 5B JUMPDEST 0805 60 PUSH1 0x00 0807 60 PUSH1 0x01 0809 60 PUSH1 0x01 080B 60 PUSH1 0xe0 080D 1B SHL 080E 03 SUB 080F 19 NOT 0810 82 DUP3 0811 16 AND 0812 63 PUSH4 0x80ac58cd 0817 60 PUSH1 0xe0 0819 1B SHL 081A 14 EQ 081B 80 DUP1 081C 61 PUSH2 0x0835 081F 57 *JUMPI 0820 50 POP 0821 60 PUSH1 0x01 0823 60 PUSH1 0x01 0825 60 PUSH1 0xe0 0827 1B SHL 0828 03 SUB 0829 19 NOT 082A 82 DUP3 082B 16 AND 082C 63 PUSH4 0x5b5e139f 0831 60 PUSH1 0xe0 0833 1B SHL 0834 14 EQ 0835 5B JUMPDEST 0836 80 DUP1 0837 61 PUSH2 0x0850 083A 57 *JUMPI 083B 50 POP 083C 63 PUSH4 0x01ffc9a7 0841 60 PUSH1 0xe0 0843 1B SHL 0844 60 PUSH1 0x01 0846 60 PUSH1 0x01 0848 60 PUSH1 0xe0 084A 1B SHL 084B 03 SUB 084C 19 NOT 084D 83 DUP4 084E 16 AND 084F 14 EQ label_0850: // Incoming jump from 0x1413, if !stack[-1] // Incoming jump from 0x1413, if !(stack[-3] < storage[0x00]) // Inputs[3] // { // @0851 stack[-4] // @0851 stack[-1] // @0852 stack[-3] // } 0850 5B JUMPDEST 0851 92 SWAP3 0852 91 SWAP2 0853 50 POP 0854 50 POP 0855 56 *JUMP // Stack delta = -3 // Outputs[1] { @0851 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0856: // Incoming jump from 0x0343 // Inputs[2] // { // @0859 storage[0x08] // @0863 msg.sender // } 0856 5B JUMPDEST 0857 60 PUSH1 0x08 0859 54 SLOAD 085A 60 PUSH1 0x01 085C 60 PUSH1 0x01 085E 60 PUSH1 0xa0 0860 1B SHL 0861 03 SUB 0862 16 AND 0863 33 CALLER 0864 14 EQ 0865 61 PUSH2 0x08a3 0868 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0869: // Incoming jump from 0x0868, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @086B memory[0x40:0x60] // @0886 memory[0x00:0x20] // @088F memory[0x00:0x20] // } 0869 60 PUSH1 0x40 086B 51 MLOAD 086C 62 PUSH3 0x461bcd 0870 60 PUSH1 0xe5 0872 1B SHL 0873 81 DUP2 0874 52 MSTORE 0875 60 PUSH1 0x20 0877 60 PUSH1 0x04 0879 82 DUP3 087A 01 ADD 087B 81 DUP2 087C 90 SWAP1 087D 52 MSTORE 087E 60 PUSH1 0x24 0880 82 DUP3 0881 01 ADD 0882 52 MSTORE 0883 60 PUSH1 0x00 0885 80 DUP1 0886 51 MLOAD 0887 60 PUSH1 0x20 0889 61 PUSH2 0x2406 088C 83 DUP4 088D 39 CODECOPY 088E 81 DUP2 088F 51 MLOAD 0890 91 SWAP2 0891 52 MSTORE 0892 60 PUSH1 0x44 0894 82 DUP3 0895 01 ADD 0896 52 MSTORE 0897 60 PUSH1 0x64 0899 01 ADD // Stack delta = +1 // Outputs[7] // { // @0874 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @087D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0882 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @088D memory[0x00:0x20] = code[0x2406:0x2426] // @0891 memory[0x00:0x20] = memory[0x00:0x20] // @0896 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0899 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_089A: // Incoming jump from 0x0899 // Incoming jump from 0x0D70 // Incoming jump from 0x1381 // Incoming jump from 0x0B11 // Incoming jump from 0x0A52 // Incoming jump from 0x0C2D // Incoming jump from 0x0DC4 // Incoming jump from 0x1204 // Incoming jump from 0x0BE0 // Incoming jump from 0x0E65 // Incoming jump from 0x0E18 // Inputs[3] // { // @089D memory[0x40:0x60] // @089F stack[-1] // @08A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 089A 5B JUMPDEST 089B 60 PUSH1 0x40 089D 51 MLOAD 089E 80 DUP1 089F 91 SWAP2 08A0 03 SUB 08A1 90 SWAP1 08A2 FD *REVERT // Stack delta = -1 // Outputs[1] { @08A2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_08A3: // Incoming jump from 0x0868, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @08A6 stack[-1] // @08A7 stack[-2] // } 08A3 5B JUMPDEST 08A4 60 PUSH1 0x0e 08A6 55 SSTORE 08A7 56 *JUMP // Stack delta = -2 // Outputs[1] { @08A6 storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_08A8: // Incoming call from 0x035A, returns to 0x035B // Inputs[1] { @08AE storage[0x02] } 08A8 5B JUMPDEST 08A9 60 PUSH1 0x60 08AB 60 PUSH1 0x02 08AD 80 DUP1 08AE 54 SLOAD 08AF 61 PUSH2 0x08b7 08B2 90 SWAP1 08B3 61 PUSH2 0x20d7 08B6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08A9 stack[0] = 0x60 // @08AB stack[1] = 0x02 // @08B2 stack[2] = 0x08b7 // @08B2 stack[3] = storage[0x02] // } // Block ends with call to 0x20d7, returns to 0x08B7 label_08B7: // Incoming return from call to 0x20D7 at 0x0FDD // Incoming return from call to 0x20D7 at 0x19B8 // Incoming return from call to 0x20D7 at 0x08B6 // Inputs[4] // { // @08B8 stack[-1] // @08C7 memory[0x40:0x60] // @08CF stack[-2] // @08DA storage[stack[-2]] // } 08B7 5B JUMPDEST 08B8 80 DUP1 08B9 60 PUSH1 0x1f 08BB 01 ADD 08BC 60 PUSH1 0x20 08BE 80 DUP1 08BF 91 SWAP2 08C0 04 DIV 08C1 02 MUL 08C2 60 PUSH1 0x20 08C4 01 ADD 08C5 60 PUSH1 0x40 08C7 51 MLOAD 08C8 90 SWAP1 08C9 81 DUP2 08CA 01 ADD 08CB 60 PUSH1 0x40 08CD 52 MSTORE 08CE 80 DUP1 08CF 92 SWAP3 08D0 91 SWAP2 08D1 90 SWAP1 08D2 81 DUP2 08D3 81 DUP2 08D4 52 MSTORE 08D5 60 PUSH1 0x20 08D7 01 ADD 08D8 82 DUP3 08D9 80 DUP1 08DA 54 SLOAD 08DB 61 PUSH2 0x08e3 08DE 90 SWAP1 08DF 61 PUSH2 0x20d7 08E2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @08CD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @08CF stack[-2] = memory[0x40:0x60] // @08D0 stack[-1] = stack[-2] // @08D1 stack[0] = stack[-1] // @08D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08D7 stack[1] = 0x20 + memory[0x40:0x60] // @08D8 stack[2] = stack[-2] // @08DE stack[4] = storage[stack[-2]] // @08DE stack[3] = 0x08e3 // } // Block ends with call to 0x20d7, returns to 0x08E3 label_08E3: // Incoming return from call to 0x20D7 at 0x08E2 // Inputs[1] { @08E4 stack[-1] } 08E3 5B JUMPDEST 08E4 80 DUP1 08E5 15 ISZERO 08E6 61 PUSH2 0x0930 08E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0930, if !stack[-1] label_08EA: // Incoming jump from 0x08E9, if not !stack[-1] // Inputs[1] { @08EA stack[-1] } 08EA 80 DUP1 08EB 60 PUSH1 0x1f 08ED 10 LT 08EE 61 PUSH2 0x0905 08F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0905, if 0x1f < stack[-1] label_08F2: // Incoming jump from 0x08F1, if not 0x1f < stack[-1] // Inputs[4] // { // @08F6 stack[-2] // @08F7 storage[stack[-2]] // @08FA stack[-3] // @08FC stack[-1] // } 08F2 61 PUSH2 0x0100 08F5 80 DUP1 08F6 83 DUP4 08F7 54 SLOAD 08F8 04 DIV 08F9 02 MUL 08FA 83 DUP4 08FB 52 MSTORE 08FC 91 SWAP2 08FD 60 PUSH1 0x20 08FF 01 ADD 0900 91 SWAP2 0901 61 PUSH2 0x0930 0904 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @08FB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0900 stack[-1] = stack[-1] // @0900 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0930 label_0905: // Incoming jump from 0x08F1, if 0x1f < stack[-1] // Inputs[5] // { // @0906 stack[-3] // @0907 stack[-1] // @0909 stack[-2] // @0911 memory[0x00:0x20] // @0915 storage[keccak256(memory[0x00:0x20])] // } 0905 5B JUMPDEST 0906 82 DUP3 0907 01 ADD 0908 91 SWAP2 0909 90 SWAP1 090A 60 PUSH1 0x00 090C 52 MSTORE 090D 60 PUSH1 0x20 090F 60 PUSH1 0x00 0911 20 SHA3 0912 90 SWAP1 0913 5B JUMPDEST 0914 81 DUP2 0915 54 SLOAD 0916 81 DUP2 0917 52 MSTORE 0918 90 SWAP1 0919 60 PUSH1 0x01 091B 01 ADD 091C 90 SWAP1 091D 60 PUSH1 0x20 091F 01 ADD 0920 80 DUP1 0921 83 DUP4 0922 11 GT 0923 61 PUSH2 0x0913 0926 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0908 stack[-3] = stack[-3] + stack[-1] // @090C memory[0x00:0x20] = stack[-2] // @0917 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @091C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @091F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0913, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0927: // Incoming jump from 0x0926, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0926, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0927 stack[-3] // @0928 stack[-1] // } 0927 82 DUP3 0928 90 SWAP1 0929 03 SUB 092A 60 PUSH1 0x1f 092C 16 AND 092D 82 DUP3 092E 01 ADD 092F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @092F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @092F stack[-1] = stack[-3] // } // Block continues label_0930: // Incoming jump from 0x092F // Incoming jump from 0x0904 // Incoming jump from 0x08E9, if !stack[-1] // Inputs[3] // { // @0936 stack[-6] // @0936 stack[-7] // @0938 stack[-8] // } 0930 5B JUMPDEST 0931 50 POP 0932 50 POP 0933 50 POP 0934 50 POP 0935 50 POP 0936 90 SWAP1 0937 50 POP 0938 90 SWAP1 0939 56 *JUMP // Stack delta = -7 // Outputs[1] { @0938 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_093A: // Incoming jump from 0x0387 // Incoming call from 0x150A, returns to 0x150B // Inputs[1] { @0940 stack[-1] } 093A 5B JUMPDEST 093B 60 PUSH1 0x00 093D 61 PUSH2 0x0945 0940 82 DUP3 0941 61 PUSH2 0x13f9 0944 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @093B stack[0] = 0x00 // @093D stack[1] = 0x0945 // @0940 stack[2] = stack[-1] // } // Block ends with call to 0x13f9, returns to 0x0945 label_0945: // Incoming return from call to 0x13F9 at 0x0944 // Inputs[1] { @0949 stack[-1] } 0945 5B JUMPDEST 0946 61 PUSH2 0x0962 0949 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0962, if stack[-1] label_094A: // Incoming jump from 0x0949, if not stack[-1] // Inputs[3] // { // @094C memory[0x40:0x60] // @095C memory[0x40:0x60] // @0961 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 094A 60 PUSH1 0x40 094C 51 MLOAD 094D 63 PUSH4 0x33d1c039 0952 60 PUSH1 0xe2 0954 1B SHL 0955 81 DUP2 0956 52 MSTORE 0957 60 PUSH1 0x04 0959 01 ADD 095A 60 PUSH1 0x40 095C 51 MLOAD 095D 80 DUP1 095E 91 SWAP2 095F 03 SUB 0960 90 SWAP1 0961 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0956 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @0961 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0962: // Incoming jump from 0x0949, if stack[-1] // Inputs[4] // { // @0966 stack[-2] // @0971 memory[0x00:0x40] // @0972 storage[keccak256(memory[0x00:0x40])] // @097C stack[-3] // } 0962 5B JUMPDEST 0963 50 POP 0964 60 PUSH1 0x00 0966 90 SWAP1 0967 81 DUP2 0968 52 MSTORE 0969 60 PUSH1 0x06 096B 60 PUSH1 0x20 096D 52 MSTORE 096E 60 PUSH1 0x40 0970 90 SWAP1 0971 20 SHA3 0972 54 SLOAD 0973 60 PUSH1 0x01 0975 60 PUSH1 0x01 0977 60 PUSH1 0xa0 0979 1B SHL 097A 03 SUB 097B 16 AND 097C 90 SWAP1 097D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0968 memory[0x00:0x20] = stack[-2] // @096D memory[0x20:0x40] = 0x06 // @097C stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_097E: // Incoming jump from 0x03BF // Inputs[1] { @0984 stack[-1] } 097E 5B JUMPDEST 097F 60 PUSH1 0x00 0981 61 PUSH2 0x0989 0984 82 DUP3 0985 61 PUSH2 0x0c3a 0988 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @097F stack[0] = 0x00 // @0981 stack[1] = 0x0989 // @0984 stack[2] = stack[-1] // } // Block ends with call to 0x0c3a, returns to 0x0989 label_0989: // Incoming return from call to 0x0C3A at 0x0988 // Inputs[3] // { // @098A stack[-1] // @098A stack[-2] // @0996 stack[-4] // } 0989 5B JUMPDEST 098A 90 SWAP1 098B 50 POP 098C 80 DUP1 098D 60 PUSH1 0x01 098F 60 PUSH1 0x01 0991 60 PUSH1 0xa0 0993 1B SHL 0994 03 SUB 0995 16 AND 0996 83 DUP4 0997 60 PUSH1 0x01 0999 60 PUSH1 0x01 099B 60 PUSH1 0xa0 099D 1B SHL 099E 03 SUB 099F 16 AND 09A0 03 SUB 09A1 61 PUSH2 0x09bd 09A4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @098A stack[-2] = stack[-1] } // Block ends with conditional jump to 0x09bd, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) label_09A5: // Incoming jump from 0x09A4, if not ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @09A7 memory[0x40:0x60] // @09B7 memory[0x40:0x60] // @09BC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09A5 60 PUSH1 0x40 09A7 51 MLOAD 09A8 63 PUSH4 0x250fdee3 09AD 60 PUSH1 0xe2 09AF 1B SHL 09B0 81 DUP2 09B1 52 MSTORE 09B2 60 PUSH1 0x04 09B4 01 ADD 09B5 60 PUSH1 0x40 09B7 51 MLOAD 09B8 80 DUP1 09B9 91 SWAP2 09BA 03 SUB 09BB 90 SWAP1 09BC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @09BC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09BD: // Incoming jump from 0x09A4, if ((0x01 << 0xa0) - 0x01 & stack[-4]) - ((0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @09BE msg.sender // @09C7 stack[-1] // } 09BD 5B JUMPDEST 09BE 33 CALLER 09BF 60 PUSH1 0x01 09C1 60 PUSH1 0x01 09C3 60 PUSH1 0xa0 09C5 1B SHL 09C6 03 SUB 09C7 82 DUP3 09C8 16 AND 09C9 14 EQ 09CA 80 DUP1 09CB 15 ISZERO 09CC 90 SWAP1 09CD 61 PUSH2 0x09dd 09D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09CC stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x09dd, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_09D1: // Incoming jump from 0x09D0, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @09D5 stack[-2] // @09D6 msg.sender // } 09D1 50 POP 09D2 61 PUSH2 0x09db 09D5 81 DUP2 09D6 33 CALLER 09D7 61 PUSH2 0x0780 09DA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09D2 stack[-1] = 0x09db // @09D5 stack[0] = stack[-2] // @09D6 stack[1] = msg.sender // } // Block ends with call to 0x0780, returns to 0x09DB label_09DB: // Incoming return from call to 0x0780 at 0x09DA // Inputs[1] { @09DC stack[-1] } 09DB 5B JUMPDEST 09DC 15 ISZERO // Stack delta = +0 // Outputs[1] { @09DC stack[-1] = !stack[-1] } // Block continues label_09DD: // Incoming jump from 0x09DC // Incoming jump from 0x09D0, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @09DE stack[-1] } 09DD 5B JUMPDEST 09DE 15 ISZERO 09DF 61 PUSH2 0x09fb 09E2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09fb, if !stack[-1] label_09E3: // Incoming jump from 0x09E2, if not !stack[-1] // Inputs[3] // { // @09E5 memory[0x40:0x60] // @09F5 memory[0x40:0x60] // @09FA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09E3 60 PUSH1 0x40 09E5 51 MLOAD 09E6 63 PUSH4 0x67d9dca1 09EB 60 PUSH1 0xe1 09ED 1B SHL 09EE 81 DUP2 09EF 52 MSTORE 09F0 60 PUSH1 0x04 09F2 01 ADD 09F3 60 PUSH1 0x40 09F5 51 MLOAD 09F6 80 DUP1 09F7 91 SWAP2 09F8 03 SUB 09F9 90 SWAP1 09FA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @09FA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09FB: // Incoming jump from 0x09E2, if !stack[-1] // Inputs[3] // { // @09FF stack[-3] // @0A00 stack[-2] // @0A01 stack[-1] // } 09FB 5B JUMPDEST 09FC 61 PUSH2 0x0a06 09FF 83 DUP4 0A00 83 DUP4 0A01 83 DUP4 0A02 61 PUSH2 0x1432 0A05 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09FC stack[0] = 0x0a06 // @09FF stack[1] = stack[-3] // @0A00 stack[2] = stack[-2] // @0A01 stack[3] = stack[-1] // } // Block ends with call to 0x1432, returns to 0x0A06 label_0A06: // Incoming return from call to 0x1AD2 at 0x19A9 // Incoming jump from 0x215F, if !(stack[-2] > 0x1f) // Incoming return from call to 0x1432 at 0x0A05 // Inputs[1] { @0A0A stack[-4] } 0A06 5B JUMPDEST 0A07 50 POP 0A08 50 POP 0A09 50 POP 0A0A 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0A0B: // Incoming jump from 0x0451 // Inputs[2] // { // @0A0E storage[0x08] // @0A18 msg.sender // } 0A0B 5B JUMPDEST 0A0C 60 PUSH1 0x08 0A0E 54 SLOAD 0A0F 60 PUSH1 0x01 0A11 60 PUSH1 0x01 0A13 60 PUSH1 0xa0 0A15 1B SHL 0A16 03 SUB 0A17 16 AND 0A18 33 CALLER 0A19 14 EQ 0A1A 61 PUSH2 0x0a53 0A1D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a53, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0A1E: // Incoming jump from 0x0A1D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0A20 memory[0x40:0x60] // @0A3B memory[0x00:0x20] // @0A44 memory[0x00:0x20] // } 0A1E 60 PUSH1 0x40 0A20 51 MLOAD 0A21 62 PUSH3 0x461bcd 0A25 60 PUSH1 0xe5 0A27 1B SHL 0A28 81 DUP2 0A29 52 MSTORE 0A2A 60 PUSH1 0x20 0A2C 60 PUSH1 0x04 0A2E 82 DUP3 0A2F 01 ADD 0A30 81 DUP2 0A31 90 SWAP1 0A32 52 MSTORE 0A33 60 PUSH1 0x24 0A35 82 DUP3 0A36 01 ADD 0A37 52 MSTORE 0A38 60 PUSH1 0x00 0A3A 80 DUP1 0A3B 51 MLOAD 0A3C 60 PUSH1 0x20 0A3E 61 PUSH2 0x2406 0A41 83 DUP4 0A42 39 CODECOPY 0A43 81 DUP2 0A44 51 MLOAD 0A45 91 SWAP2 0A46 52 MSTORE 0A47 60 PUSH1 0x44 0A49 82 DUP3 0A4A 01 ADD 0A4B 52 MSTORE 0A4C 60 PUSH1 0x64 0A4E 01 ADD 0A4F 61 PUSH2 0x089a 0A52 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0A29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A32 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A37 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A42 memory[0x00:0x20] = code[0x2406:0x2426] // @0A46 memory[0x00:0x20] = memory[0x00:0x20] // @0A4B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0A4E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0A53: // Incoming jump from 0x0A1D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0A57 stack[-1] // @0A58 memory[stack[-1]:stack[-1] + 0x20] // } 0A53 5B JUMPDEST 0A54 60 PUSH1 0x00 0A56 5B JUMPDEST 0A57 81 DUP2 0A58 51 MLOAD 0A59 81 DUP2 0A5A 10 LT 0A5B 15 ISZERO 0A5C 61 PUSH2 0x0abb 0A5F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A54 stack[0] = 0x00 } // Block ends with conditional jump to 0x0abb, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0A60: // Incoming jump from 0x0A5F, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0A5F, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0A66 stack[-2] // @0A67 stack[-1] // @0A69 memory[stack[-2]:stack[-2] + 0x20] // } 0A60 60 PUSH1 0x00 0A62 60 PUSH1 0x09 0A64 60 PUSH1 0x00 0A66 84 DUP5 0A67 84 DUP5 0A68 81 DUP2 0A69 51 MLOAD 0A6A 81 DUP2 0A6B 10 LT 0A6C 61 PUSH2 0x0a77 0A6F 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0A60 stack[0] = 0x00 // @0A62 stack[1] = 0x09 // @0A64 stack[2] = 0x00 // @0A66 stack[3] = stack[-2] // @0A67 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0a77, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0A70: // Incoming jump from 0x0A6F, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0A70 61 PUSH2 0x0a77 0A73 61 PUSH2 0x2111 0A76 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A70 stack[0] = 0x0a77 } // Block ends with unconditional jump to 0x2111 label_0A77: // Incoming jump from 0x0A6F, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[9] // { // @0A7A stack[-1] // @0A7D stack[-2] // @0A83 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0A8D stack[-3] // @0A91 stack[-4] // @0A9A memory[0x00:0x00 + 0x40 + stack[-3]] // @0A9C storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // @0AA1 stack[-5] // @0AAA stack[-6] // } 0A77 5B JUMPDEST 0A78 60 PUSH1 0x20 0A7A 90 SWAP1 0A7B 81 DUP2 0A7C 02 MUL 0A7D 91 SWAP2 0A7E 90 SWAP1 0A7F 91 SWAP2 0A80 01 ADD 0A81 81 DUP2 0A82 01 ADD 0A83 51 MLOAD 0A84 60 PUSH1 0x01 0A86 60 PUSH1 0x01 0A88 60 PUSH1 0xa0 0A8A 1B SHL 0A8B 03 SUB 0A8C 16 AND 0A8D 82 DUP3 0A8E 52 MSTORE 0A8F 81 DUP2 0A90 01 ADD 0A91 91 SWAP2 0A92 90 SWAP1 0A93 91 SWAP2 0A94 52 MSTORE 0A95 60 PUSH1 0x40 0A97 01 ADD 0A98 60 PUSH1 0x00 0A9A 20 SHA3 0A9B 80 DUP1 0A9C 54 SLOAD 0A9D 60 PUSH1 0xff 0A9F 19 NOT 0AA0 16 AND 0AA1 91 SWAP2 0AA2 15 ISZERO 0AA3 15 ISZERO 0AA4 91 SWAP2 0AA5 90 SWAP1 0AA6 91 SWAP2 0AA7 17 OR 0AA8 90 SWAP1 0AA9 55 SSTORE 0AAA 80 DUP1 0AAB 61 PUSH2 0x0ab3 0AAE 81 DUP2 0AAF 61 PUSH2 0x213d 0AB2 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @0A8E memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0A94 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // @0AA9 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] = !!stack[-5] | (~0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])]) // @0AAA stack[-5] = stack[-6] // @0AAB stack[-4] = 0x0ab3 // @0AAE stack[-3] = stack[-6] // } // Block ends with call to 0x213d, returns to 0x0AB3 label_0AB3: // Incoming return from call to 0x213D at 0x0AB2 // Inputs[2] // { // @0AB4 stack[-1] // @0AB4 stack[-3] // } 0AB3 5B JUMPDEST 0AB4 91 SWAP2 0AB5 50 POP 0AB6 50 POP 0AB7 61 PUSH2 0x0a56 0ABA 56 *JUMP // Stack delta = -2 // Outputs[1] { @0AB4 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0a56 label_0ABB: // Incoming return from call to 0x21A4 at 0x0C39 // Incoming return from call to 0x21A4 at 0x0DD0 // Incoming jump from 0x138E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x138E, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0A5F, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0A5F, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @0ABE stack[-3] } 0ABB 5B JUMPDEST 0ABC 50 POP 0ABD 50 POP 0ABE 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0ABF: // Incoming jump from 0x0471 // Inputs[3] // { // @0AC3 stack[-3] // @0AC4 stack[-2] // @0AC5 stack[-1] // } 0ABF 5B JUMPDEST 0AC0 61 PUSH2 0x0a06 0AC3 83 DUP4 0AC4 83 DUP4 0AC5 83 DUP4 0AC6 61 PUSH2 0x149b 0AC9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AC0 stack[0] = 0x0a06 // @0AC3 stack[1] = stack[-3] // @0AC4 stack[2] = stack[-2] // @0AC5 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x149b label_0ACA: // Incoming call from 0x0486, returns to 0x0344 // Inputs[2] // { // @0ACD storage[0x08] // @0AD7 msg.sender // } 0ACA 5B JUMPDEST 0ACB 60 PUSH1 0x08 0ACD 54 SLOAD 0ACE 60 PUSH1 0x01 0AD0 60 PUSH1 0x01 0AD2 60 PUSH1 0xa0 0AD4 1B SHL 0AD5 03 SUB 0AD6 16 AND 0AD7 33 CALLER 0AD8 14 EQ 0AD9 61 PUSH2 0x0b12 0ADC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b12, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0ADD: // Incoming jump from 0x0ADC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0ADF memory[0x40:0x60] // @0AFA memory[0x00:0x20] // @0B03 memory[0x00:0x20] // } 0ADD 60 PUSH1 0x40 0ADF 51 MLOAD 0AE0 62 PUSH3 0x461bcd 0AE4 60 PUSH1 0xe5 0AE6 1B SHL 0AE7 81 DUP2 0AE8 52 MSTORE 0AE9 60 PUSH1 0x20 0AEB 60 PUSH1 0x04 0AED 82 DUP3 0AEE 01 ADD 0AEF 81 DUP2 0AF0 90 SWAP1 0AF1 52 MSTORE 0AF2 60 PUSH1 0x24 0AF4 82 DUP3 0AF5 01 ADD 0AF6 52 MSTORE 0AF7 60 PUSH1 0x00 0AF9 80 DUP1 0AFA 51 MLOAD 0AFB 60 PUSH1 0x20 0AFD 61 PUSH2 0x2406 0B00 83 DUP4 0B01 39 CODECOPY 0B02 81 DUP2 0B03 51 MLOAD 0B04 91 SWAP2 0B05 52 MSTORE 0B06 60 PUSH1 0x44 0B08 82 DUP3 0B09 01 ADD 0B0A 52 MSTORE 0B0B 60 PUSH1 0x64 0B0D 01 ADD 0B0E 61 PUSH2 0x089a 0B11 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0AE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AF1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AF6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B01 memory[0x00:0x20] = code[0x2406:0x2426] // @0B05 memory[0x00:0x20] = memory[0x00:0x20] // @0B0A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0B0D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0B12: // Incoming jump from 0x0ADC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[7] // { // @0B15 memory[0x40:0x60] // @0B2F address(this) // @0B2F address(this).balance // @0B37 msg.gas // @0B38 address(0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B3D returndata.length // } 0B12 5B JUMPDEST 0B13 60 PUSH1 0x40 0B15 51 MLOAD 0B16 60 PUSH1 0x00 0B18 90 SWAP1 0B19 73 PUSH20 0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4 0B2E 90 SWAP1 0B2F 47 SELFBALANCE 0B30 90 SWAP1 0B31 83 DUP4 0B32 81 DUP2 0B33 81 DUP2 0B34 81 DUP2 0B35 85 DUP6 0B36 87 DUP8 0B37 5A GAS 0B38 F1 CALL 0B39 92 SWAP3 0B3A 50 POP 0B3B 50 POP 0B3C 50 POP 0B3D 3D RETURNDATASIZE 0B3E 80 DUP1 0B3F 60 PUSH1 0x00 0B41 81 DUP2 0B42 14 EQ 0B43 61 PUSH2 0x0b68 0B46 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0B18 stack[0] = 0x00 // @0B38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B39 stack[1] = address(0x7f429dc5ffda5374bb09a1ba390ffebdea4797a4).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B3D stack[2] = returndata.length // @0B3E stack[3] = returndata.length // } // Block ends with conditional jump to 0x0b68, if returndata.length == 0x00 label_0B47: // Incoming jump from 0x0B46, if not returndata.length == 0x00 // Inputs[6] // { // @0B49 memory[0x40:0x60] // @0B4A stack[-2] // @0B51 returndata.length // @0B59 returndata.length // @0B5C returndata.length // @0B63 returndata[0x00:0x00 + returndata.length] // } 0B47 60 PUSH1 0x40 0B49 51 MLOAD 0B4A 91 SWAP2 0B4B 50 POP 0B4C 60 PUSH1 0x1f 0B4E 19 NOT 0B4F 60 PUSH1 0x3f 0B51 3D RETURNDATASIZE 0B52 01 ADD 0B53 16 AND 0B54 82 DUP3 0B55 01 ADD 0B56 60 PUSH1 0x40 0B58 52 MSTORE 0B59 3D RETURNDATASIZE 0B5A 82 DUP3 0B5B 52 MSTORE 0B5C 3D RETURNDATASIZE 0B5D 60 PUSH1 0x00 0B5F 60 PUSH1 0x20 0B61 84 DUP5 0B62 01 ADD 0B63 3E RETURNDATACOPY 0B64 61 PUSH2 0x0b6d 0B67 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0B4A stack[-2] = memory[0x40:0x60] // @0B58 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0B5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0B63 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0b6d label_0B68: // Incoming jump from 0x0B46, if returndata.length == 0x00 // Inputs[3] // { // @0B6B stack[-2] // @0B70 stack[-4] // @0B70 stack[-3] // } 0B68 5B JUMPDEST 0B69 60 PUSH1 0x60 0B6B 91 SWAP2 0B6C 50 POP 0B6D 5B JUMPDEST 0B6E 50 POP 0B6F 50 POP 0B70 90 SWAP1 0B71 50 POP 0B72 80 DUP1 0B73 61 PUSH2 0x0b7b 0B76 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0B70 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0b7b, if stack[-3] label_0B77: // Incoming jump from 0x0B76, if not stack[-3] // Incoming jump from 0x0B76, if not stack[-3] // Inputs[1] { @0B7A memory[0x00:0x00] } 0B77 60 PUSH1 0x00 0B79 80 DUP1 0B7A FD *REVERT // Stack delta = +0 // Outputs[1] { @0B7A revert(memory[0x00:0x00]); } // Block terminates label_0B7B: // Incoming jump from 0x0B76, if stack[-3] // Incoming jump from 0x0B76, if stack[-3] // Incoming jump from 0x1CB5, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0B7D stack[-2] } 0B7B 5B JUMPDEST 0B7C 50 POP 0B7D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0B7E: // Incoming jump from 0x04A6 // Inputs[4] // { // @0B82 stack[-3] // @0B83 stack[-2] // @0B84 stack[-1] // @0B87 memory[0x40:0x60] // } 0B7E 5B JUMPDEST 0B7F 61 PUSH2 0x0a06 0B82 83 DUP4 0B83 83 DUP4 0B84 83 DUP4 0B85 60 PUSH1 0x40 0B87 51 MLOAD 0B88 80 DUP1 0B89 60 PUSH1 0x20 0B8B 01 ADD 0B8C 60 PUSH1 0x40 0B8E 52 MSTORE 0B8F 80 DUP1 0B90 60 PUSH1 0x00 0B92 81 DUP2 0B93 52 MSTORE 0B94 50 POP 0B95 61 PUSH2 0x116c 0B98 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0B7F stack[0] = 0x0a06 // @0B82 stack[1] = stack[-3] // @0B83 stack[2] = stack[-2] // @0B84 stack[3] = stack[-1] // @0B87 stack[4] = memory[0x40:0x60] // @0B8E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0B93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x116c label_0B99: // Incoming jump from 0x04C6 // Inputs[2] // { // @0B9C storage[0x08] // @0BA6 msg.sender // } 0B99 5B JUMPDEST 0B9A 60 PUSH1 0x08 0B9C 54 SLOAD 0B9D 60 PUSH1 0x01 0B9F 60 PUSH1 0x01 0BA1 60 PUSH1 0xa0 0BA3 1B SHL 0BA4 03 SUB 0BA5 16 AND 0BA6 33 CALLER 0BA7 14 EQ 0BA8 61 PUSH2 0x0be1 0BAB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0BAC: // Incoming jump from 0x0BAB, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0BAE memory[0x40:0x60] // @0BC9 memory[0x00:0x20] // @0BD2 memory[0x00:0x20] // } 0BAC 60 PUSH1 0x40 0BAE 51 MLOAD 0BAF 62 PUSH3 0x461bcd 0BB3 60 PUSH1 0xe5 0BB5 1B SHL 0BB6 81 DUP2 0BB7 52 MSTORE 0BB8 60 PUSH1 0x20 0BBA 60 PUSH1 0x04 0BBC 82 DUP3 0BBD 01 ADD 0BBE 81 DUP2 0BBF 90 SWAP1 0BC0 52 MSTORE 0BC1 60 PUSH1 0x24 0BC3 82 DUP3 0BC4 01 ADD 0BC5 52 MSTORE 0BC6 60 PUSH1 0x00 0BC8 80 DUP1 0BC9 51 MLOAD 0BCA 60 PUSH1 0x20 0BCC 61 PUSH2 0x2406 0BCF 83 DUP4 0BD0 39 CODECOPY 0BD1 81 DUP2 0BD2 51 MLOAD 0BD3 91 SWAP2 0BD4 52 MSTORE 0BD5 60 PUSH1 0x44 0BD7 82 DUP3 0BD8 01 ADD 0BD9 52 MSTORE 0BDA 60 PUSH1 0x64 0BDC 01 ADD 0BDD 61 PUSH2 0x089a 0BE0 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0BB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BC0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BC5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BD0 memory[0x00:0x20] = code[0x2406:0x2426] // @0BD4 memory[0x00:0x20] = memory[0x00:0x20] // @0BD9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0BDC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0BE1: // Incoming jump from 0x0BAB, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0BE4 stack[-1] // @0BE5 stack[-2] // } 0BE1 5B JUMPDEST 0BE2 60 PUSH1 0x0f 0BE4 55 SSTORE 0BE5 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BE4 storage[0x0f] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0BE6: // Incoming jump from 0x04E6 // Inputs[2] // { // @0BE9 storage[0x08] // @0BF3 msg.sender // } 0BE6 5B JUMPDEST 0BE7 60 PUSH1 0x08 0BE9 54 SLOAD 0BEA 60 PUSH1 0x01 0BEC 60 PUSH1 0x01 0BEE 60 PUSH1 0xa0 0BF0 1B SHL 0BF1 03 SUB 0BF2 16 AND 0BF3 33 CALLER 0BF4 14 EQ 0BF5 61 PUSH2 0x0c2e 0BF8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c2e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0BF9: // Incoming jump from 0x0BF8, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0BFB memory[0x40:0x60] // @0C16 memory[0x00:0x20] // @0C1F memory[0x00:0x20] // } 0BF9 60 PUSH1 0x40 0BFB 51 MLOAD 0BFC 62 PUSH3 0x461bcd 0C00 60 PUSH1 0xe5 0C02 1B SHL 0C03 81 DUP2 0C04 52 MSTORE 0C05 60 PUSH1 0x20 0C07 60 PUSH1 0x04 0C09 82 DUP3 0C0A 01 ADD 0C0B 81 DUP2 0C0C 90 SWAP1 0C0D 52 MSTORE 0C0E 60 PUSH1 0x24 0C10 82 DUP3 0C11 01 ADD 0C12 52 MSTORE 0C13 60 PUSH1 0x00 0C15 80 DUP1 0C16 51 MLOAD 0C17 60 PUSH1 0x20 0C19 61 PUSH2 0x2406 0C1C 83 DUP4 0C1D 39 CODECOPY 0C1E 81 DUP2 0C1F 51 MLOAD 0C20 91 SWAP2 0C21 52 MSTORE 0C22 60 PUSH1 0x44 0C24 82 DUP3 0C25 01 ADD 0C26 52 MSTORE 0C27 60 PUSH1 0x64 0C29 01 ADD 0C2A 61 PUSH2 0x089a 0C2D 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0C04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C0D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C12 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0C1D memory[0x00:0x20] = code[0x2406:0x2426] // @0C21 memory[0x00:0x20] = memory[0x00:0x20] // @0C26 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0C29 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0C2E: // Incoming jump from 0x0BF8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C34 stack[-1] } 0C2E 5B JUMPDEST 0C2F 60 PUSH1 0x11 0C31 61 PUSH2 0x0abb 0C34 82 DUP3 0C35 82 DUP3 0C36 61 PUSH2 0x21a4 0C39 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C2F stack[0] = 0x11 // @0C31 stack[1] = 0x0abb // @0C34 stack[2] = stack[-1] // @0C35 stack[3] = 0x11 // } // Block ends with call to 0x21a4, returns to 0x0ABB label_0C3A: // Incoming call from 0x0988, returns to 0x0989 // Incoming jump from 0x0506 // Inputs[1] { @0C40 stack[-1] } 0C3A 5B JUMPDEST 0C3B 60 PUSH1 0x00 0C3D 61 PUSH2 0x0c45 0C40 82 DUP3 0C41 61 PUSH2 0x168b 0C44 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C3B stack[0] = 0x00 // @0C3D stack[1] = 0x0c45 // @0C40 stack[2] = stack[-1] // } // Block ends with call to 0x168b, returns to 0x0C45 label_0C45: // Incoming return from call to 0x168B at 0x0C44 // Inputs[4] // { // @0C46 stack[-1] // @0C46 memory[stack[-1]:stack[-1] + 0x20] // @0C47 stack[-4] // @0C48 stack[-3] // } 0C45 5B JUMPDEST 0C46 51 MLOAD 0C47 92 SWAP3 0C48 91 SWAP2 0C49 50 POP 0C4A 50 POP 0C4B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C47 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0C4C: // Incoming call from 0x051B, returns to 0x035B // Inputs[1] { @0C50 storage[0x11] } 0C4C 5B JUMPDEST 0C4D 60 PUSH1 0x11 0C4F 80 DUP1 0C50 54 SLOAD 0C51 61 PUSH2 0x0c59 0C54 90 SWAP1 0C55 61 PUSH2 0x20d7 0C58 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C4D stack[0] = 0x11 // @0C54 stack[1] = 0x0c59 // @0C54 stack[2] = storage[0x11] // } // Block ends with call to 0x20d7, returns to 0x0C59 label_0C59: // Incoming return from call to 0x20D7 at 0x0C58 // Incoming return from call to 0x20D7 at 0x126C // Inputs[4] // { // @0C5A stack[-1] // @0C69 memory[0x40:0x60] // @0C71 stack[-2] // @0C7C storage[stack[-2]] // } 0C59 5B JUMPDEST 0C5A 80 DUP1 0C5B 60 PUSH1 0x1f 0C5D 01 ADD 0C5E 60 PUSH1 0x20 0C60 80 DUP1 0C61 91 SWAP2 0C62 04 DIV 0C63 02 MUL 0C64 60 PUSH1 0x20 0C66 01 ADD 0C67 60 PUSH1 0x40 0C69 51 MLOAD 0C6A 90 SWAP1 0C6B 81 DUP2 0C6C 01 ADD 0C6D 60 PUSH1 0x40 0C6F 52 MSTORE 0C70 80 DUP1 0C71 92 SWAP3 0C72 91 SWAP2 0C73 90 SWAP1 0C74 81 DUP2 0C75 81 DUP2 0C76 52 MSTORE 0C77 60 PUSH1 0x20 0C79 01 ADD 0C7A 82 DUP3 0C7B 80 DUP1 0C7C 54 SLOAD 0C7D 61 PUSH2 0x0c85 0C80 90 SWAP1 0C81 61 PUSH2 0x20d7 0C84 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0C6F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0C71 stack[-2] = memory[0x40:0x60] // @0C72 stack[-1] = stack[-2] // @0C73 stack[0] = stack[-1] // @0C76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0C79 stack[1] = 0x20 + memory[0x40:0x60] // @0C7A stack[2] = stack[-2] // @0C80 stack[4] = storage[stack[-2]] // @0C80 stack[3] = 0x0c85 // } // Block ends with call to 0x20d7, returns to 0x0C85 label_0C85: // Incoming return from call to 0x20D7 at 0x0C84 // Inputs[1] { @0C86 stack[-1] } 0C85 5B JUMPDEST 0C86 80 DUP1 0C87 15 ISZERO 0C88 61 PUSH2 0x0cd2 0C8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd2, if !stack[-1] label_0C8C: // Incoming jump from 0x0C8B, if not !stack[-1] // Inputs[1] { @0C8C stack[-1] } 0C8C 80 DUP1 0C8D 60 PUSH1 0x1f 0C8F 10 LT 0C90 61 PUSH2 0x0ca7 0C93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ca7, if 0x1f < stack[-1] label_0C94: // Incoming jump from 0x0C93, if not 0x1f < stack[-1] // Inputs[4] // { // @0C98 stack[-2] // @0C99 storage[stack[-2]] // @0C9C stack[-3] // @0C9E stack[-1] // } 0C94 61 PUSH2 0x0100 0C97 80 DUP1 0C98 83 DUP4 0C99 54 SLOAD 0C9A 04 DIV 0C9B 02 MUL 0C9C 83 DUP4 0C9D 52 MSTORE 0C9E 91 SWAP2 0C9F 60 PUSH1 0x20 0CA1 01 ADD 0CA2 91 SWAP2 0CA3 61 PUSH2 0x0cd2 0CA6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C9D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0CA2 stack[-1] = stack[-1] // @0CA2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0cd2 label_0CA7: // Incoming jump from 0x0C93, if 0x1f < stack[-1] // Inputs[5] // { // @0CA8 stack[-3] // @0CA9 stack[-1] // @0CAB stack[-2] // @0CB3 memory[0x00:0x20] // @0CB7 storage[keccak256(memory[0x00:0x20])] // } 0CA7 5B JUMPDEST 0CA8 82 DUP3 0CA9 01 ADD 0CAA 91 SWAP2 0CAB 90 SWAP1 0CAC 60 PUSH1 0x00 0CAE 52 MSTORE 0CAF 60 PUSH1 0x20 0CB1 60 PUSH1 0x00 0CB3 20 SHA3 0CB4 90 SWAP1 0CB5 5B JUMPDEST 0CB6 81 DUP2 0CB7 54 SLOAD 0CB8 81 DUP2 0CB9 52 MSTORE 0CBA 90 SWAP1 0CBB 60 PUSH1 0x01 0CBD 01 ADD 0CBE 90 SWAP1 0CBF 60 PUSH1 0x20 0CC1 01 ADD 0CC2 80 DUP1 0CC3 83 DUP4 0CC4 11 GT 0CC5 61 PUSH2 0x0cb5 0CC8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0CAA stack[-3] = stack[-3] + stack[-1] // @0CAE memory[0x00:0x20] = stack[-2] // @0CB9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0CBE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0CC1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0cb5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0CC9: // Incoming jump from 0x0CC8, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0CC8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0CC9 stack[-3] // @0CCA stack[-1] // } 0CC9 82 DUP3 0CCA 90 SWAP1 0CCB 03 SUB 0CCC 60 PUSH1 0x1f 0CCE 16 AND 0CCF 82 DUP3 0CD0 01 ADD 0CD1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0CD1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0CD1 stack[-1] = stack[-3] // } // Block continues label_0CD2: // Incoming jump from 0x0C8B, if !stack[-1] // Incoming jump from 0x0CD1 // Incoming jump from 0x0CA6 // Inputs[1] { @0CD8 stack[-7] } 0CD2 5B JUMPDEST 0CD3 50 POP 0CD4 50 POP 0CD5 50 POP 0CD6 50 POP 0CD7 50 POP 0CD8 81 DUP2 0CD9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 0CDA 5B JUMPDEST 0CDB 60 PUSH1 0x00 0CDD 60 PUSH1 0x01 0CDF 60 PUSH1 0x01 0CE1 60 PUSH1 0xa0 0CE3 1B SHL 0CE4 03 SUB 0CE5 82 DUP3 0CE6 16 AND 0CE7 61 PUSH2 0x0d03 0CEA 57 *JUMPI 0CEB 60 PUSH1 0x40 0CED 51 MLOAD 0CEE 63 PUSH4 0x23d3ad81 0CF3 60 PUSH1 0xe2 0CF5 1B SHL 0CF6 81 DUP2 0CF7 52 MSTORE 0CF8 60 PUSH1 0x04 0CFA 01 ADD 0CFB 60 PUSH1 0x40 0CFD 51 MLOAD 0CFE 80 DUP1 0CFF 91 SWAP2 0D00 03 SUB 0D01 90 SWAP1 0D02 FD *REVERT 0D03 5B JUMPDEST 0D04 50 POP 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0x01 0D09 60 PUSH1 0xa0 0D0B 1B SHL 0D0C 03 SUB 0D0D 16 AND 0D0E 60 PUSH1 0x00 0D10 90 SWAP1 0D11 81 DUP2 0D12 52 MSTORE 0D13 60 PUSH1 0x05 0D15 60 PUSH1 0x20 0D17 52 MSTORE 0D18 60 PUSH1 0x40 0D1A 90 SWAP1 0D1B 20 SHA3 0D1C 54 SLOAD 0D1D 67 PUSH8 0xffffffffffffffff 0D26 16 AND 0D27 90 SWAP1 0D28 56 *JUMP label_0D29: // Incoming call from 0x0550, returns to 0x0344 // Inputs[2] // { // @0D2C storage[0x08] // @0D36 msg.sender // } 0D29 5B JUMPDEST 0D2A 60 PUSH1 0x08 0D2C 54 SLOAD 0D2D 60 PUSH1 0x01 0D2F 60 PUSH1 0x01 0D31 60 PUSH1 0xa0 0D33 1B SHL 0D34 03 SUB 0D35 16 AND 0D36 33 CALLER 0D37 14 EQ 0D38 61 PUSH2 0x0d71 0D3B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d71, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D3C: // Incoming jump from 0x0D3B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0D3E memory[0x40:0x60] // @0D59 memory[0x00:0x20] // @0D62 memory[0x00:0x20] // } 0D3C 60 PUSH1 0x40 0D3E 51 MLOAD 0D3F 62 PUSH3 0x461bcd 0D43 60 PUSH1 0xe5 0D45 1B SHL 0D46 81 DUP2 0D47 52 MSTORE 0D48 60 PUSH1 0x20 0D4A 60 PUSH1 0x04 0D4C 82 DUP3 0D4D 01 ADD 0D4E 81 DUP2 0D4F 90 SWAP1 0D50 52 MSTORE 0D51 60 PUSH1 0x24 0D53 82 DUP3 0D54 01 ADD 0D55 52 MSTORE 0D56 60 PUSH1 0x00 0D58 80 DUP1 0D59 51 MLOAD 0D5A 60 PUSH1 0x20 0D5C 61 PUSH2 0x2406 0D5F 83 DUP4 0D60 39 CODECOPY 0D61 81 DUP2 0D62 51 MLOAD 0D63 91 SWAP2 0D64 52 MSTORE 0D65 60 PUSH1 0x44 0D67 82 DUP3 0D68 01 ADD 0D69 52 MSTORE 0D6A 60 PUSH1 0x64 0D6C 01 ADD 0D6D 61 PUSH2 0x089a 0D70 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0D47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D50 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D55 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0D60 memory[0x00:0x20] = code[0x2406:0x2426] // @0D64 memory[0x00:0x20] = memory[0x00:0x20] // @0D69 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0D6C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0D71: // Incoming jump from 0x0D3B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0D71 5B JUMPDEST 0D72 61 PUSH2 0x0d7b 0D75 60 PUSH1 0x00 0D77 61 PUSH2 0x17b4 0D7A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D72 stack[0] = 0x0d7b // @0D75 stack[1] = 0x00 // } // Block ends with call to 0x17b4, returns to 0x0D7B label_0D7B: // Incoming return from call to 0x17B4 at 0x0D7A // Inputs[1] { @0D7C stack[-1] } 0D7B 5B JUMPDEST 0D7C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0D7D: // Incoming jump from 0x0570 // Inputs[2] // { // @0D80 storage[0x08] // @0D8A msg.sender // } 0D7D 5B JUMPDEST 0D7E 60 PUSH1 0x08 0D80 54 SLOAD 0D81 60 PUSH1 0x01 0D83 60 PUSH1 0x01 0D85 60 PUSH1 0xa0 0D87 1B SHL 0D88 03 SUB 0D89 16 AND 0D8A 33 CALLER 0D8B 14 EQ 0D8C 61 PUSH2 0x0dc5 0D8F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0D90: // Incoming jump from 0x0D8F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0D92 memory[0x40:0x60] // @0DAD memory[0x00:0x20] // @0DB6 memory[0x00:0x20] // } 0D90 60 PUSH1 0x40 0D92 51 MLOAD 0D93 62 PUSH3 0x461bcd 0D97 60 PUSH1 0xe5 0D99 1B SHL 0D9A 81 DUP2 0D9B 52 MSTORE 0D9C 60 PUSH1 0x20 0D9E 60 PUSH1 0x04 0DA0 82 DUP3 0DA1 01 ADD 0DA2 81 DUP2 0DA3 90 SWAP1 0DA4 52 MSTORE 0DA5 60 PUSH1 0x24 0DA7 82 DUP3 0DA8 01 ADD 0DA9 52 MSTORE 0DAA 60 PUSH1 0x00 0DAC 80 DUP1 0DAD 51 MLOAD 0DAE 60 PUSH1 0x20 0DB0 61 PUSH2 0x2406 0DB3 83 DUP4 0DB4 39 CODECOPY 0DB5 81 DUP2 0DB6 51 MLOAD 0DB7 91 SWAP2 0DB8 52 MSTORE 0DB9 60 PUSH1 0x44 0DBB 82 DUP3 0DBC 01 ADD 0DBD 52 MSTORE 0DBE 60 PUSH1 0x64 0DC0 01 ADD 0DC1 61 PUSH2 0x089a 0DC4 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0D9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DA9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0DB4 memory[0x00:0x20] = code[0x2406:0x2426] // @0DB8 memory[0x00:0x20] = memory[0x00:0x20] // @0DBD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0DC0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0DC5: // Incoming jump from 0x0D8F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DCB stack[-1] } 0DC5 5B JUMPDEST 0DC6 60 PUSH1 0x12 0DC8 61 PUSH2 0x0abb 0DCB 82 DUP3 0DCC 82 DUP3 0DCD 61 PUSH2 0x21a4 0DD0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DC6 stack[0] = 0x12 // @0DC8 stack[1] = 0x0abb // @0DCB stack[2] = stack[-1] // @0DCC stack[3] = 0x12 // } // Block ends with call to 0x21a4, returns to 0x0ABB label_0DD1: // Incoming jump from 0x0590 // Inputs[2] // { // @0DD4 storage[0x08] // @0DDE msg.sender // } 0DD1 5B JUMPDEST 0DD2 60 PUSH1 0x08 0DD4 54 SLOAD 0DD5 60 PUSH1 0x01 0DD7 60 PUSH1 0x01 0DD9 60 PUSH1 0xa0 0DDB 1B SHL 0DDC 03 SUB 0DDD 16 AND 0DDE 33 CALLER 0DDF 14 EQ 0DE0 61 PUSH2 0x0e19 0DE3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e19, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DE4: // Incoming jump from 0x0DE3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0DE6 memory[0x40:0x60] // @0E01 memory[0x00:0x20] // @0E0A memory[0x00:0x20] // } 0DE4 60 PUSH1 0x40 0DE6 51 MLOAD 0DE7 62 PUSH3 0x461bcd 0DEB 60 PUSH1 0xe5 0DED 1B SHL 0DEE 81 DUP2 0DEF 52 MSTORE 0DF0 60 PUSH1 0x20 0DF2 60 PUSH1 0x04 0DF4 82 DUP3 0DF5 01 ADD 0DF6 81 DUP2 0DF7 90 SWAP1 0DF8 52 MSTORE 0DF9 60 PUSH1 0x24 0DFB 82 DUP3 0DFC 01 ADD 0DFD 52 MSTORE 0DFE 60 PUSH1 0x00 0E00 80 DUP1 0E01 51 MLOAD 0E02 60 PUSH1 0x20 0E04 61 PUSH2 0x2406 0E07 83 DUP4 0E08 39 CODECOPY 0E09 81 DUP2 0E0A 51 MLOAD 0E0B 91 SWAP2 0E0C 52 MSTORE 0E0D 60 PUSH1 0x44 0E0F 82 DUP3 0E10 01 ADD 0E11 52 MSTORE 0E12 60 PUSH1 0x64 0E14 01 ADD 0E15 61 PUSH2 0x089a 0E18 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0DEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DFD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E08 memory[0x00:0x20] = code[0x2406:0x2426] // @0E0C memory[0x00:0x20] = memory[0x00:0x20] // @0E11 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0E14 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0E19: // Incoming jump from 0x0DE3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E1C stack[-1] // @0E1D stack[-2] // } 0E19 5B JUMPDEST 0E1A 60 PUSH1 0x0c 0E1C 55 SSTORE 0E1D 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E1C storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0E1E: // Incoming jump from 0x05B0 // Inputs[2] // { // @0E21 storage[0x08] // @0E2B msg.sender // } 0E1E 5B JUMPDEST 0E1F 60 PUSH1 0x08 0E21 54 SLOAD 0E22 60 PUSH1 0x01 0E24 60 PUSH1 0x01 0E26 60 PUSH1 0xa0 0E28 1B SHL 0E29 03 SUB 0E2A 16 AND 0E2B 33 CALLER 0E2C 14 EQ 0E2D 61 PUSH2 0x0e66 0E30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e66, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E31: // Incoming jump from 0x0E30, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @0E33 memory[0x40:0x60] // @0E4E memory[0x00:0x20] // @0E57 memory[0x00:0x20] // } 0E31 60 PUSH1 0x40 0E33 51 MLOAD 0E34 62 PUSH3 0x461bcd 0E38 60 PUSH1 0xe5 0E3A 1B SHL 0E3B 81 DUP2 0E3C 52 MSTORE 0E3D 60 PUSH1 0x20 0E3F 60 PUSH1 0x04 0E41 82 DUP3 0E42 01 ADD 0E43 81 DUP2 0E44 90 SWAP1 0E45 52 MSTORE 0E46 60 PUSH1 0x24 0E48 82 DUP3 0E49 01 ADD 0E4A 52 MSTORE 0E4B 60 PUSH1 0x00 0E4D 80 DUP1 0E4E 51 MLOAD 0E4F 60 PUSH1 0x20 0E51 61 PUSH2 0x2406 0E54 83 DUP4 0E55 39 CODECOPY 0E56 81 DUP2 0E57 51 MLOAD 0E58 91 SWAP2 0E59 52 MSTORE 0E5A 60 PUSH1 0x44 0E5C 82 DUP3 0E5D 01 ADD 0E5E 52 MSTORE 0E5F 60 PUSH1 0x64 0E61 01 ADD 0E62 61 PUSH2 0x089a 0E65 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @0E3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E45 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E4A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0E55 memory[0x00:0x20] = code[0x2406:0x2426] // @0E59 memory[0x00:0x20] = memory[0x00:0x20] // @0E5E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0E61 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_0E66: // Incoming jump from 0x0E30, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E69 stack[-1] // @0E6A stack[-2] // } 0E66 5B JUMPDEST 0E67 60 PUSH1 0x0d 0E69 55 SSTORE 0E6A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E69 storage[0x0d] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0E6B: // Incoming jump from 0x05C3 // Inputs[1] { @0E70 storage[0x10] } 0E6B 5B JUMPDEST 0E6C 60 PUSH1 0x01 0E6E 60 PUSH1 0x10 0E70 54 SLOAD 0E71 60 PUSH1 0xff 0E73 16 AND 0E74 60 PUSH1 0x02 0E76 81 DUP2 0E77 11 GT 0E78 15 ISZERO 0E79 61 PUSH2 0x0e84 0E7C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E6C stack[0] = 0x01 // @0E73 stack[1] = 0xff & storage[0x10] // } // Block ends with conditional jump to 0x0e84, if !(0xff & storage[0x10] > 0x02) label_0E7D: // Incoming jump from 0x0E7C, if not !(0xff & storage[0x10] > 0x02) 0E7D 61 PUSH2 0x0e84 0E80 61 PUSH2 0x1fc9 0E83 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E7D stack[0] = 0x0e84 } // Block ends with unconditional jump to 0x1fc9 label_0E84: // Incoming jump from 0x0E7C, if !(0xff & storage[0x10] > 0x02) // Inputs[2] // { // @0E85 stack[-2] // @0E85 stack[-1] // } 0E84 5B JUMPDEST 0E85 14 EQ 0E86 61 PUSH2 0x0ea2 0E89 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ea2, if stack[-1] == stack[-2] label_0E8A: // Incoming jump from 0x0E89, if not stack[-1] == stack[-2] // Inputs[3] // { // @0E8C memory[0x40:0x60] // @0E9C memory[0x40:0x60] // @0EA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E8A 60 PUSH1 0x40 0E8C 51 MLOAD 0E8D 63 PUSH4 0xd1dc4c07 0E92 60 PUSH1 0xe0 0E94 1B SHL 0E95 81 DUP2 0E96 52 MSTORE 0E97 60 PUSH1 0x04 0E99 01 ADD 0E9A 60 PUSH1 0x40 0E9C 51 MLOAD 0E9D 80 DUP1 0E9E 91 SWAP2 0E9F 03 SUB 0EA0 90 SWAP1 0EA1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd1dc4c07 << 0xe0 // @0EA1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EA2: // Incoming jump from 0x0E89, if stack[-1] == stack[-2] // Inputs[3] // { // @0EA5 storage[0x01] // @0EA8 storage[0x00] // @0EAD stack[-1] // } 0EA2 5B JUMPDEST 0EA3 60 PUSH1 0x01 0EA5 54 SLOAD 0EA6 60 PUSH1 0x00 0EA8 54 SLOAD 0EA9 61 PUSH2 0x03e8 0EAC 91 SWAP2 0EAD 83 DUP4 0EAE 91 SWAP2 0EAF 03 SUB 0EB0 60 PUSH1 0x00 0EB2 19 NOT 0EB3 01 ADD 0EB4 61 PUSH2 0x0ebd 0EB7 91 SWAP2 0EB8 90 SWAP1 0EB9 61 PUSH2 0x2264 0EBC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EAC stack[0] = 0x03e8 // @0EB7 stack[1] = 0x0ebd // @0EB8 stack[2] = stack[-1] // @0EB8 stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x2264, returns to 0x0EBD label_0EBD: // Incoming return from call to 0x2264 at 0x0EBC // Inputs[2] // { // @0EBE stack[-1] // @0EBE stack[-2] // } 0EBD 5B JUMPDEST 0EBE 11 GT 0EBF 15 ISZERO 0EC0 61 PUSH2 0x0edc 0EC3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0edc, if !(stack[-1] > stack[-2]) label_0EC4: // Incoming jump from 0x0EC3, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @0EC6 memory[0x40:0x60] // @0ED6 memory[0x40:0x60] // @0EDB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EC4 60 PUSH1 0x40 0EC6 51 MLOAD 0EC7 63 PUSH4 0x07b8358f 0ECC 60 PUSH1 0xe0 0ECE 1B SHL 0ECF 81 DUP2 0ED0 52 MSTORE 0ED1 60 PUSH1 0x04 0ED3 01 ADD 0ED4 60 PUSH1 0x40 0ED6 51 MLOAD 0ED7 80 DUP1 0ED8 91 SWAP2 0ED9 03 SUB 0EDA 90 SWAP1 0EDB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ED0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07b8358f << 0xe0 // @0EDB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EDC: // Incoming jump from 0x0EC3, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @0EDD msg.sender // @0EEB memory[0x00:0x40] // @0EEC storage[keccak256(memory[0x00:0x40])] // } 0EDC 5B JUMPDEST 0EDD 33 CALLER 0EDE 60 PUSH1 0x00 0EE0 90 SWAP1 0EE1 81 DUP2 0EE2 52 MSTORE 0EE3 60 PUSH1 0x09 0EE5 60 PUSH1 0x20 0EE7 52 MSTORE 0EE8 60 PUSH1 0x40 0EEA 90 SWAP1 0EEB 20 SHA3 0EEC 54 SLOAD 0EED 60 PUSH1 0xff 0EEF 16 AND 0EF0 61 PUSH2 0x0f0c 0EF3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0EE2 memory[0x00:0x20] = msg.sender // @0EE7 memory[0x20:0x40] = 0x09 // } // Block ends with conditional jump to 0x0f0c, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0EF4: // Incoming jump from 0x0EF3, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0EF6 memory[0x40:0x60] // @0F06 memory[0x40:0x60] // @0F0B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EF4 60 PUSH1 0x40 0EF6 51 MLOAD 0EF7 63 PUSH4 0xd2e1f489 0EFC 60 PUSH1 0xe0 0EFE 1B SHL 0EFF 81 DUP2 0F00 52 MSTORE 0F01 60 PUSH1 0x04 0F03 01 ADD 0F04 60 PUSH1 0x40 0F06 51 MLOAD 0F07 80 DUP1 0F08 91 SWAP2 0F09 03 SUB 0F0A 90 SWAP1 0F0B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd2e1f489 << 0xe0 // @0F0B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F0C: // Incoming jump from 0x0EF3, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @0F0F storage[0x0f] // @0F10 msg.sender // @0F1E memory[0x00:0x40] // @0F1F storage[keccak256(memory[0x00:0x40])] // @0F24 stack[-1] // } 0F0C 5B JUMPDEST 0F0D 60 PUSH1 0x0f 0F0F 54 SLOAD 0F10 33 CALLER 0F11 60 PUSH1 0x00 0F13 90 SWAP1 0F14 81 DUP2 0F15 52 MSTORE 0F16 60 PUSH1 0x0a 0F18 60 PUSH1 0x20 0F1A 52 MSTORE 0F1B 60 PUSH1 0x40 0F1D 90 SWAP1 0F1E 20 SHA3 0F1F 54 SLOAD 0F20 61 PUSH2 0x0f2a 0F23 90 SWAP1 0F24 83 DUP4 0F25 90 SWAP1 0F26 61 PUSH2 0x2264 0F29 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0F0F stack[0] = storage[0x0f] // @0F15 memory[0x00:0x20] = msg.sender // @0F1A memory[0x20:0x40] = 0x0a // @0F23 stack[1] = 0x0f2a // @0F25 stack[2] = stack[-1] // @0F25 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2264, returns to 0x0F2A label_0F2A: // Incoming return from call to 0x2264 at 0x0F29 // Inputs[2] // { // @0F2B stack[-2] // @0F2B stack[-1] // } 0F2A 5B JUMPDEST 0F2B 11 GT 0F2C 15 ISZERO 0F2D 61 PUSH2 0x0f49 0F30 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f49, if !(stack[-1] > stack[-2]) label_0F31: // Incoming jump from 0x0F30, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @0F33 memory[0x40:0x60] // @0F43 memory[0x40:0x60] // @0F48 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F31 60 PUSH1 0x40 0F33 51 MLOAD 0F34 63 PUSH4 0x961c2f0d 0F39 60 PUSH1 0xe0 0F3B 1B SHL 0F3C 81 DUP2 0F3D 52 MSTORE 0F3E 60 PUSH1 0x04 0F40 01 ADD 0F41 60 PUSH1 0x40 0F43 51 MLOAD 0F44 80 DUP1 0F45 91 SWAP2 0F46 03 SUB 0F47 90 SWAP1 0F48 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x961c2f0d << 0xe0 // @0F48 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F49: // Incoming jump from 0x0F30, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0F4C storage[0x08] // @0F56 msg.sender // } 0F49 5B JUMPDEST 0F4A 60 PUSH1 0x08 0F4C 54 SLOAD 0F4D 60 PUSH1 0x01 0F4F 60 PUSH1 0x01 0F51 60 PUSH1 0xa0 0F53 1B SHL 0F54 03 SUB 0F55 16 AND 0F56 33 CALLER 0F57 14 EQ 0F58 61 PUSH2 0x0f89 0F5B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f89, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0F5C: // Incoming jump from 0x0F5B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0F5C stack[-1] // @0F5F storage[0x0d] // } 0F5C 80 DUP1 0F5D 60 PUSH1 0x0d 0F5F 54 SLOAD 0F60 61 PUSH2 0x0f69 0F63 91 SWAP2 0F64 90 SWAP1 0F65 61 PUSH2 0x227c 0F68 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F63 stack[0] = 0x0f69 // @0F64 stack[1] = stack[-1] // @0F64 stack[2] = storage[0x0d] // } // Block ends with call to 0x227c, returns to 0x0F69 label_0F69: // Incoming return from call to 0x227C at 0x0F68 // Inputs[2] // { // @0F6A msg.value // @0F6B stack[-1] // } 0F69 5B JUMPDEST 0F6A 34 CALLVALUE 0F6B 10 LT 0F6C 15 ISZERO 0F6D 61 PUSH2 0x0f89 0F70 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f89, if !(msg.value < stack[-1]) label_0F71: // Incoming jump from 0x0F70, if not !(msg.value < stack[-1]) // Inputs[3] // { // @0F73 memory[0x40:0x60] // @0F83 memory[0x40:0x60] // @0F88 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F71 60 PUSH1 0x40 0F73 51 MLOAD 0F74 63 PUSH4 0xb4fcb7ab 0F79 60 PUSH1 0xe0 0F7B 1B SHL 0F7C 81 DUP2 0F7D 52 MSTORE 0F7E 60 PUSH1 0x04 0F80 01 ADD 0F81 60 PUSH1 0x40 0F83 51 MLOAD 0F84 80 DUP1 0F85 91 SWAP2 0F86 03 SUB 0F87 90 SWAP1 0F88 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb4fcb7ab << 0xe0 // @0F88 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F89: // Incoming jump from 0x0F5B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Incoming jump from 0x0F70, if !(msg.value < stack[-1]) // Inputs[2] // { // @0F8A stack[-1] // @0F8F msg.sender // } 0F89 5B JUMPDEST 0F8A 80 DUP1 0F8B 60 PUSH1 0x0a 0F8D 60 PUSH1 0x00 0F8F 33 CALLER // Stack delta = +4 // Outputs[4] // { // @0F8A stack[0] = stack[-1] // @0F8B stack[1] = 0x0a // @0F8D stack[2] = 0x00 // @0F8F stack[3] = msg.sender // } // Block continues label_0F90: // Incoming jump from 0x10D6 // Incoming jump from 0x0F8F // Inputs[6] // { // @0F99 stack[-1] // @0FA3 stack[-2] // @0FA8 stack[-3] // @0FB0 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0FB3 stack[-4] // @0FB5 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // } 0F90 5B JUMPDEST 0F91 60 PUSH1 0x01 0F93 60 PUSH1 0x01 0F95 60 PUSH1 0xa0 0F97 1B SHL 0F98 03 SUB 0F99 16 AND 0F9A 60 PUSH1 0x01 0F9C 60 PUSH1 0x01 0F9E 60 PUSH1 0xa0 0FA0 1B SHL 0FA1 03 SUB 0FA2 16 AND 0FA3 81 DUP2 0FA4 52 MSTORE 0FA5 60 PUSH1 0x20 0FA7 01 ADD 0FA8 90 SWAP1 0FA9 81 DUP2 0FAA 52 MSTORE 0FAB 60 PUSH1 0x20 0FAD 01 ADD 0FAE 60 PUSH1 0x00 0FB0 20 SHA3 0FB1 60 PUSH1 0x00 0FB3 82 DUP3 0FB4 82 DUP3 0FB5 54 SLOAD 0FB6 61 PUSH2 0x0fbf 0FB9 91 SWAP2 0FBA 90 SWAP1 0FBB 61 PUSH2 0x2264 0FBE 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @0FA4 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-1] // @0FAA memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0FB0 stack[-3] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0FB1 stack[-2] = 0x00 // @0FB9 stack[-1] = 0x0fbf // @0FBA stack[0] = stack[-4] // @0FBA stack[1] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // } // Block ends with call to 0x2264, returns to 0x0FBF label_0FBF: // Incoming return from call to 0x2264 at 0x0FBE // Inputs[6] // { // @0FC0 stack[-1] // @0FC0 stack[-2] // @0FC1 stack[-3] // @0FC7 stack[-4] // @0FC9 msg.sender // @0FCA stack[-5] // } 0FBF 5B JUMPDEST 0FC0 90 SWAP1 0FC1 91 SWAP2 0FC2 55 SSTORE 0FC3 50 POP 0FC4 61 PUSH2 0x0b7b 0FC7 90 SWAP1 0FC8 50 POP 0FC9 33 CALLER 0FCA 82 DUP3 0FCB 61 PUSH2 0x1813 0FCE 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0FC2 storage[stack[-3]] = stack[-1] // @0FC7 stack[-4] = 0x0b7b // @0FC9 stack[-3] = msg.sender // @0FCA stack[-2] = stack[-5] // } // Block ends with unconditional jump to 0x1813 label_0FCF: // Incoming call from 0x05F6, returns to 0x035B // Inputs[1] { @0FD5 storage[0x03] } 0FCF 5B JUMPDEST 0FD0 60 PUSH1 0x60 0FD2 60 PUSH1 0x03 0FD4 80 DUP1 0FD5 54 SLOAD 0FD6 61 PUSH2 0x08b7 0FD9 90 SWAP1 0FDA 61 PUSH2 0x20d7 0FDD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FD0 stack[0] = 0x60 // @0FD2 stack[1] = 0x03 // @0FD9 stack[2] = 0x08b7 // @0FD9 stack[3] = storage[0x03] // } // Block ends with call to 0x20d7, returns to 0x08B7 label_0FDE: // Incoming jump from 0x0666 // Inputs[1] { @0FE3 storage[0x10] } 0FDE 5B JUMPDEST 0FDF 60 PUSH1 0x02 0FE1 60 PUSH1 0x10 0FE3 54 SLOAD 0FE4 60 PUSH1 0xff 0FE6 16 AND 0FE7 60 PUSH1 0x02 0FE9 81 DUP2 0FEA 11 GT 0FEB 15 ISZERO 0FEC 61 PUSH2 0x0ff7 0FEF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0FDF stack[0] = 0x02 // @0FE6 stack[1] = 0xff & storage[0x10] // } // Block ends with conditional jump to 0x0ff7, if !(0xff & storage[0x10] > 0x02) label_0FF0: // Incoming jump from 0x0FEF, if not !(0xff & storage[0x10] > 0x02) 0FF0 61 PUSH2 0x0ff7 0FF3 61 PUSH2 0x1fc9 0FF6 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FF0 stack[0] = 0x0ff7 } // Block ends with unconditional jump to 0x1fc9 label_0FF7: // Incoming jump from 0x0FEF, if !(0xff & storage[0x10] > 0x02) // Inputs[2] // { // @0FF8 stack[-2] // @0FF8 stack[-1] // } 0FF7 5B JUMPDEST 0FF8 14 EQ 0FF9 61 PUSH2 0x1015 0FFC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1015, if stack[-1] == stack[-2] label_0FFD: // Incoming jump from 0x0FFC, if not stack[-1] == stack[-2] // Inputs[3] // { // @0FFF memory[0x40:0x60] // @100F memory[0x40:0x60] // @1014 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FFD 60 PUSH1 0x40 0FFF 51 MLOAD 1000 63 PUSH4 0xd1dc4c07 1005 60 PUSH1 0xe0 1007 1B SHL 1008 81 DUP2 1009 52 MSTORE 100A 60 PUSH1 0x04 100C 01 ADD 100D 60 PUSH1 0x40 100F 51 MLOAD 1010 80 DUP1 1011 91 SWAP2 1012 03 SUB 1013 90 SWAP1 1014 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1009 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd1dc4c07 << 0xe0 // @1014 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1015: // Incoming jump from 0x0FFC, if stack[-1] == stack[-2] // Inputs[3] // { // @1018 storage[0x01] // @101B storage[0x00] // @1020 stack[-1] // } 1015 5B JUMPDEST 1016 60 PUSH1 0x01 1018 54 SLOAD 1019 60 PUSH1 0x00 101B 54 SLOAD 101C 61 PUSH2 0x03e8 101F 91 SWAP2 1020 83 DUP4 1021 91 SWAP2 1022 03 SUB 1023 60 PUSH1 0x00 1025 19 NOT 1026 01 ADD 1027 61 PUSH2 0x1030 102A 91 SWAP2 102B 90 SWAP1 102C 61 PUSH2 0x2264 102F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @101F stack[0] = 0x03e8 // @102A stack[1] = 0x1030 // @102B stack[2] = stack[-1] // @102B stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x2264, returns to 0x1030 label_1030: // Incoming return from call to 0x2264 at 0x102F // Inputs[2] // { // @1031 stack[-1] // @1031 stack[-2] // } 1030 5B JUMPDEST 1031 11 GT 1032 15 ISZERO 1033 61 PUSH2 0x104f 1036 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x104f, if !(stack[-1] > stack[-2]) label_1037: // Incoming jump from 0x1036, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1039 memory[0x40:0x60] // @1049 memory[0x40:0x60] // @104E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1037 60 PUSH1 0x40 1039 51 MLOAD 103A 63 PUSH4 0x07b8358f 103F 60 PUSH1 0xe0 1041 1B SHL 1042 81 DUP2 1043 52 MSTORE 1044 60 PUSH1 0x04 1046 01 ADD 1047 60 PUSH1 0x40 1049 51 MLOAD 104A 80 DUP1 104B 91 SWAP2 104C 03 SUB 104D 90 SWAP1 104E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1043 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07b8358f << 0xe0 // @104E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_104F: // Incoming jump from 0x1036, if !(stack[-1] > stack[-2]) // Inputs[5] // { // @1052 storage[0x0e] // @1053 msg.sender // @1061 memory[0x00:0x40] // @1062 storage[keccak256(memory[0x00:0x40])] // @1067 stack[-1] // } 104F 5B JUMPDEST 1050 60 PUSH1 0x0e 1052 54 SLOAD 1053 33 CALLER 1054 60 PUSH1 0x00 1056 90 SWAP1 1057 81 DUP2 1058 52 MSTORE 1059 60 PUSH1 0x0b 105B 60 PUSH1 0x20 105D 52 MSTORE 105E 60 PUSH1 0x40 1060 90 SWAP1 1061 20 SHA3 1062 54 SLOAD 1063 61 PUSH2 0x106d 1066 90 SWAP1 1067 83 DUP4 1068 90 SWAP1 1069 61 PUSH2 0x2264 106C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1052 stack[0] = storage[0x0e] // @1058 memory[0x00:0x20] = msg.sender // @105D memory[0x20:0x40] = 0x0b // @1066 stack[1] = 0x106d // @1068 stack[2] = stack[-1] // @1068 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2264, returns to 0x106D label_106D: // Incoming return from call to 0x2264 at 0x106C // Inputs[2] // { // @106E stack[-1] // @106E stack[-2] // } 106D 5B JUMPDEST 106E 11 GT 106F 15 ISZERO 1070 61 PUSH2 0x108c 1073 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x108c, if !(stack[-1] > stack[-2]) label_1074: // Incoming jump from 0x1073, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1076 memory[0x40:0x60] // @1086 memory[0x40:0x60] // @108B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1074 60 PUSH1 0x40 1076 51 MLOAD 1077 63 PUSH4 0x965b2097 107C 60 PUSH1 0xe0 107E 1B SHL 107F 81 DUP2 1080 52 MSTORE 1081 60 PUSH1 0x04 1083 01 ADD 1084 60 PUSH1 0x40 1086 51 MLOAD 1087 80 DUP1 1088 91 SWAP2 1089 03 SUB 108A 90 SWAP1 108B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1080 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x965b2097 << 0xe0 // @108B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_108C: // Incoming jump from 0x1073, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @108F storage[0x08] // @1099 msg.sender // } 108C 5B JUMPDEST 108D 60 PUSH1 0x08 108F 54 SLOAD 1090 60 PUSH1 0x01 1092 60 PUSH1 0x01 1094 60 PUSH1 0xa0 1096 1B SHL 1097 03 SUB 1098 16 AND 1099 33 CALLER 109A 14 EQ 109B 61 PUSH2 0x10cc 109E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10cc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_109F: // Incoming jump from 0x109E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @109F stack[-1] // @10A2 storage[0x0c] // } 109F 80 DUP1 10A0 60 PUSH1 0x0c 10A2 54 SLOAD 10A3 61 PUSH2 0x10ac 10A6 91 SWAP2 10A7 90 SWAP1 10A8 61 PUSH2 0x227c 10AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10A6 stack[0] = 0x10ac // @10A7 stack[1] = stack[-1] // @10A7 stack[2] = storage[0x0c] // } // Block ends with call to 0x227c, returns to 0x10AC label_10AC: // Incoming return from call to 0x227C at 0x10AB // Inputs[2] // { // @10AD msg.value // @10AE stack[-1] // } 10AC 5B JUMPDEST 10AD 34 CALLVALUE 10AE 10 LT 10AF 15 ISZERO 10B0 61 PUSH2 0x10cc 10B3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10cc, if !(msg.value < stack[-1]) label_10B4: // Incoming jump from 0x10B3, if not !(msg.value < stack[-1]) // Inputs[3] // { // @10B6 memory[0x40:0x60] // @10C6 memory[0x40:0x60] // @10CB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10B4 60 PUSH1 0x40 10B6 51 MLOAD 10B7 63 PUSH4 0xb4fcb7ab 10BC 60 PUSH1 0xe0 10BE 1B SHL 10BF 81 DUP2 10C0 52 MSTORE 10C1 60 PUSH1 0x04 10C3 01 ADD 10C4 60 PUSH1 0x40 10C6 51 MLOAD 10C7 80 DUP1 10C8 91 SWAP2 10C9 03 SUB 10CA 90 SWAP1 10CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb4fcb7ab << 0xe0 // @10CB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_10CC: // Incoming jump from 0x109E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Incoming jump from 0x10B3, if !(msg.value < stack[-1]) // Inputs[2] // { // @10CD stack[-1] // @10D2 msg.sender // } 10CC 5B JUMPDEST 10CD 80 DUP1 10CE 60 PUSH1 0x0b 10D0 60 PUSH1 0x00 10D2 33 CALLER 10D3 61 PUSH2 0x0f90 10D6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10CD stack[0] = stack[-1] // @10CE stack[1] = 0x0b // @10D0 stack[2] = 0x00 // @10D2 stack[3] = msg.sender // } // Block ends with unconditional jump to 0x0f90 label_10D7: // Incoming jump from 0x0686 // Inputs[2] // { // @10D8 msg.sender // @10E1 stack[-2] // } 10D7 5B JUMPDEST 10D8 33 CALLER 10D9 60 PUSH1 0x01 10DB 60 PUSH1 0x01 10DD 60 PUSH1 0xa0 10DF 1B SHL 10E0 03 SUB 10E1 83 DUP4 10E2 16 AND 10E3 03 SUB 10E4 61 PUSH2 0x1100 10E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1100, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender label_10E8: // Incoming jump from 0x10E7, if not (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[3] // { // @10EA memory[0x40:0x60] // @10FA memory[0x40:0x60] // @10FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10E8 60 PUSH1 0x40 10EA 51 MLOAD 10EB 63 PUSH4 0xb06307db 10F0 60 PUSH1 0xe0 10F2 1B SHL 10F3 81 DUP2 10F4 52 MSTORE 10F5 60 PUSH1 0x04 10F7 01 ADD 10F8 60 PUSH1 0x40 10FA 51 MLOAD 10FB 80 DUP1 10FC 91 SWAP2 10FD 03 SUB 10FE 90 SWAP1 10FF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @10FF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1100: // Incoming jump from 0x10E7, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[10] // { // @1101 msg.sender // @1112 memory[0x00:0x40] // @111B stack[-2] // @1126 memory[0x00:0x40] // @1128 storage[keccak256(memory[0x00:0x40])] // @112D stack[-1] // @1137 memory[0x40:0x60] // @1163 memory[0x40:0x60] // @1168 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @116B stack[-3] // } 1100 5B JUMPDEST 1101 33 CALLER 1102 60 PUSH1 0x00 1104 81 DUP2 1105 81 DUP2 1106 52 MSTORE 1107 60 PUSH1 0x07 1109 60 PUSH1 0x20 110B 90 SWAP1 110C 81 DUP2 110D 52 MSTORE 110E 60 PUSH1 0x40 1110 80 DUP1 1111 83 DUP4 1112 20 SHA3 1113 60 PUSH1 0x01 1115 60 PUSH1 0x01 1117 60 PUSH1 0xa0 1119 1B SHL 111A 03 SUB 111B 87 DUP8 111C 16 AND 111D 80 DUP1 111E 85 DUP6 111F 52 MSTORE 1120 90 SWAP1 1121 83 DUP4 1122 52 MSTORE 1123 92 SWAP3 1124 81 DUP2 1125 90 SWAP1 1126 20 SHA3 1127 80 DUP1 1128 54 SLOAD 1129 60 PUSH1 0xff 112B 19 NOT 112C 16 AND 112D 86 DUP7 112E 15 ISZERO 112F 15 ISZERO 1130 90 SWAP1 1131 81 DUP2 1132 17 OR 1133 90 SWAP1 1134 91 SWAP2 1135 55 SSTORE 1136 90 SWAP1 1137 51 MLOAD 1138 90 SWAP1 1139 81 DUP2 113A 52 MSTORE 113B 91 SWAP2 113C 92 SWAP3 113D 91 SWAP2 113E 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 115F 91 SWAP2 1160 01 ADD 1161 60 PUSH1 0x40 1163 51 MLOAD 1164 80 DUP1 1165 91 SWAP2 1166 03 SUB 1167 90 SWAP1 1168 A3 LOG3 1169 50 POP 116A 50 POP 116B 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1106 memory[0x00:0x20] = msg.sender // @110D memory[0x20:0x40] = 0x07 // @111F memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1122 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1135 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @113A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1168 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_116C: // Incoming jump from 0x06E3 // Incoming jump from 0x0B98 // Inputs[3] // { // @1170 stack[-4] // @1171 stack[-3] // @1172 stack[-2] // } 116C 5B JUMPDEST 116D 61 PUSH2 0x1177 1170 84 DUP5 1171 84 DUP5 1172 84 DUP5 1173 61 PUSH2 0x149b 1176 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @116D stack[0] = 0x1177 // @1170 stack[1] = stack[-4] // @1171 stack[2] = stack[-3] // @1172 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x149b 1177 5B JUMPDEST 1178 60 PUSH1 0x01 117A 60 PUSH1 0x01 117C 60 PUSH1 0xa0 117E 1B SHL 117F 03 SUB 1180 83 DUP4 1181 16 AND 1182 3B EXTCODESIZE 1183 15 ISZERO 1184 15 ISZERO 1185 80 DUP1 1186 15 ISZERO 1187 61 PUSH2 0x1199 118A 57 *JUMPI 118B 50 POP 118C 61 PUSH2 0x1197 118F 84 DUP5 1190 84 DUP5 1191 84 DUP5 1192 84 DUP5 1193 61 PUSH2 0x182d 1196 56 *JUMP 1197 5B JUMPDEST 1198 15 ISZERO 1199 5B JUMPDEST 119A 15 ISZERO 119B 61 PUSH2 0x11b7 119E 57 *JUMPI 119F 60 PUSH1 0x40 11A1 51 MLOAD 11A2 63 PUSH4 0x68d2bf6b 11A7 60 PUSH1 0xe1 11A9 1B SHL 11AA 81 DUP2 11AB 52 MSTORE 11AC 60 PUSH1 0x04 11AE 01 ADD 11AF 60 PUSH1 0x40 11B1 51 MLOAD 11B2 80 DUP1 11B3 91 SWAP2 11B4 03 SUB 11B5 90 SWAP1 11B6 FD *REVERT label_11B7: // Incoming jump from 0x1D13, if !(stack[-1] > stack[-4]) // Inputs[1] { @11BC stack[-5] } 11B7 5B JUMPDEST 11B8 50 POP 11B9 50 POP 11BA 50 POP 11BB 50 POP 11BC 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_11BD: // Incoming jump from 0x0719 // Inputs[2] // { // @11C0 storage[0x08] // @11CA msg.sender // } 11BD 5B JUMPDEST 11BE 60 PUSH1 0x08 11C0 54 SLOAD 11C1 60 PUSH1 0x01 11C3 60 PUSH1 0x01 11C5 60 PUSH1 0xa0 11C7 1B SHL 11C8 03 SUB 11C9 16 AND 11CA 33 CALLER 11CB 14 EQ 11CC 61 PUSH2 0x1205 11CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1205, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_11D0: // Incoming jump from 0x11CF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @11D2 memory[0x40:0x60] // @11ED memory[0x00:0x20] // @11F6 memory[0x00:0x20] // } 11D0 60 PUSH1 0x40 11D2 51 MLOAD 11D3 62 PUSH3 0x461bcd 11D7 60 PUSH1 0xe5 11D9 1B SHL 11DA 81 DUP2 11DB 52 MSTORE 11DC 60 PUSH1 0x20 11DE 60 PUSH1 0x04 11E0 82 DUP3 11E1 01 ADD 11E2 81 DUP2 11E3 90 SWAP1 11E4 52 MSTORE 11E5 60 PUSH1 0x24 11E7 82 DUP3 11E8 01 ADD 11E9 52 MSTORE 11EA 60 PUSH1 0x00 11EC 80 DUP1 11ED 51 MLOAD 11EE 60 PUSH1 0x20 11F0 61 PUSH2 0x2406 11F3 83 DUP4 11F4 39 CODECOPY 11F5 81 DUP2 11F6 51 MLOAD 11F7 91 SWAP2 11F8 52 MSTORE 11F9 60 PUSH1 0x44 11FB 82 DUP3 11FC 01 ADD 11FD 52 MSTORE 11FE 60 PUSH1 0x64 1200 01 ADD 1201 61 PUSH2 0x089a 1204 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @11DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11E4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11E9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @11F4 memory[0x00:0x20] = code[0x2406:0x2426] // @11F8 memory[0x00:0x20] = memory[0x00:0x20] // @11FD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @1200 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_1205: // Incoming jump from 0x11CF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1209 storage[0x10] // @120A stack[-1] // } 1205 5B JUMPDEST 1206 60 PUSH1 0x10 1208 80 DUP1 1209 54 SLOAD 120A 82 DUP3 120B 91 SWAP2 120C 90 SWAP1 120D 60 PUSH1 0xff 120F 19 NOT 1210 16 AND 1211 60 PUSH1 0x01 1213 83 DUP4 1214 60 PUSH1 0x02 1216 81 DUP2 1217 11 GT 1218 15 ISZERO 1219 61 PUSH2 0x1224 121C 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @120B stack[0] = stack[-1] // @120C stack[1] = 0x10 // @1210 stack[2] = ~0xff & storage[0x10] // @1211 stack[3] = 0x01 // @1213 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1224, if !(stack[-1] > 0x02) label_121D: // Incoming jump from 0x121C, if not !(stack[-1] > 0x02) 121D 61 PUSH2 0x1224 1220 61 PUSH2 0x1fc9 1223 56 *JUMP // Stack delta = +1 // Outputs[1] { @121D stack[0] = 0x1224 } // Block ends with unconditional jump to 0x1fc9 label_1224: // Incoming jump from 0x121C, if !(stack[-1] > 0x02) // Inputs[5] // { // @1225 stack[-1] // @1225 stack[-2] // @1226 stack[-3] // @1227 stack[-4] // @122B stack[-7] // } 1224 5B JUMPDEST 1225 02 MUL 1226 17 OR 1227 90 SWAP1 1228 55 SSTORE 1229 50 POP 122A 50 POP 122B 56 *JUMP // Stack delta = -7 // Outputs[1] { @1228 storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] } // Block ends with unconditional jump to stack[-7] label_122C: // Incoming jump from 0x0739 // Inputs[1] { @1232 stack[-1] } 122C 5B JUMPDEST 122D 60 PUSH1 0x60 122F 61 PUSH2 0x1237 1232 82 DUP3 1233 61 PUSH2 0x1919 1236 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @122D stack[0] = 0x60 // @122F stack[1] = 0x1237 // @1232 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1919 1237 5B JUMPDEST 1238 60 PUSH1 0x12 123A 60 PUSH1 0x40 123C 51 MLOAD 123D 60 PUSH1 0x20 123F 01 ADD 1240 61 PUSH2 0x124a 1243 92 SWAP3 1244 91 SWAP2 1245 90 SWAP1 1246 61 PUSH2 0x229b 1249 56 *JUMP 124A 5B JUMPDEST 124B 60 PUSH1 0x40 124D 51 MLOAD 124E 60 PUSH1 0x20 1250 81 DUP2 1251 83 DUP4 1252 03 SUB 1253 03 SUB 1254 81 DUP2 1255 52 MSTORE 1256 90 SWAP1 1257 60 PUSH1 0x40 1259 52 MSTORE 125A 90 SWAP1 125B 50 POP 125C 91 SWAP2 125D 90 SWAP1 125E 50 POP 125F 56 *JUMP label_1260: // Incoming call from 0x0764, returns to 0x035B // Inputs[1] { @1264 storage[0x12] } 1260 5B JUMPDEST 1261 60 PUSH1 0x12 1263 80 DUP1 1264 54 SLOAD 1265 61 PUSH2 0x0c59 1268 90 SWAP1 1269 61 PUSH2 0x20d7 126C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1261 stack[0] = 0x12 // @1268 stack[1] = 0x0c59 // @1268 stack[2] = storage[0x12] // } // Block ends with call to 0x20d7, returns to 0x0C59 126D 5B JUMPDEST 126E 60 PUSH1 0x08 1270 54 SLOAD 1271 60 PUSH1 0x01 1273 60 PUSH1 0x01 1275 60 PUSH1 0xa0 1277 1B SHL 1278 03 SUB 1279 16 AND 127A 33 CALLER 127B 14 EQ 127C 61 PUSH2 0x12b5 127F 57 *JUMPI 1280 60 PUSH1 0x40 1282 51 MLOAD 1283 62 PUSH3 0x461bcd 1287 60 PUSH1 0xe5 1289 1B SHL 128A 81 DUP2 128B 52 MSTORE 128C 60 PUSH1 0x20 128E 60 PUSH1 0x04 1290 82 DUP3 1291 01 ADD 1292 81 DUP2 1293 90 SWAP1 1294 52 MSTORE 1295 60 PUSH1 0x24 1297 82 DUP3 1298 01 ADD 1299 52 MSTORE 129A 60 PUSH1 0x00 129C 80 DUP1 129D 51 MLOAD 129E 60 PUSH1 0x20 12A0 61 PUSH2 0x2406 12A3 83 DUP4 12A4 39 CODECOPY 12A5 81 DUP2 12A6 51 MLOAD 12A7 91 SWAP2 12A8 52 MSTORE 12A9 60 PUSH1 0x44 12AB 82 DUP3 12AC 01 ADD 12AD 52 MSTORE 12AE 60 PUSH1 0x64 12B0 01 ADD 12B1 61 PUSH2 0x089a 12B4 56 *JUMP 12B5 5B JUMPDEST 12B6 60 PUSH1 0x01 12B8 60 PUSH1 0x01 12BA 60 PUSH1 0xa0 12BC 1B SHL 12BD 03 SUB 12BE 81 DUP2 12BF 16 AND 12C0 61 PUSH2 0x1331 12C3 57 *JUMPI 12C4 60 PUSH1 0x40 12C6 51 MLOAD 12C7 62 PUSH3 0x461bcd 12CB 60 PUSH1 0xe5 12CD 1B SHL 12CE 81 DUP2 12CF 52 MSTORE 12D0 60 PUSH1 0x20 12D2 60 PUSH1 0x04 12D4 82 DUP3 12D5 01 ADD 12D6 52 MSTORE 12D7 60 PUSH1 0x26 12D9 60 PUSH1 0x24 12DB 82 DUP3 12DC 01 ADD 12DD 52 MSTORE 12DE 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 12FF 60 PUSH1 0x44 1301 82 DUP3 1302 01 ADD 1303 52 MSTORE 1304 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1325 60 PUSH1 0x64 1327 82 DUP3 1328 01 ADD 1329 52 MSTORE 132A 60 PUSH1 0x84 132C 01 ADD 132D 61 PUSH2 0x089a 1330 56 *JUMP 1331 5B JUMPDEST 1332 61 PUSH2 0x0b7b 1335 81 DUP2 1336 61 PUSH2 0x17b4 1339 56 *JUMP label_133A: // Incoming jump from 0x07ED // Inputs[2] // { // @133D storage[0x08] // @1347 msg.sender // } 133A 5B JUMPDEST 133B 60 PUSH1 0x08 133D 54 SLOAD 133E 60 PUSH1 0x01 1340 60 PUSH1 0x01 1342 60 PUSH1 0xa0 1344 1B SHL 1345 03 SUB 1346 16 AND 1347 33 CALLER 1348 14 EQ 1349 61 PUSH2 0x1382 134C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1382, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_134D: // Incoming jump from 0x134C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @134F memory[0x40:0x60] // @136A memory[0x00:0x20] // @1373 memory[0x00:0x20] // } 134D 60 PUSH1 0x40 134F 51 MLOAD 1350 62 PUSH3 0x461bcd 1354 60 PUSH1 0xe5 1356 1B SHL 1357 81 DUP2 1358 52 MSTORE 1359 60 PUSH1 0x20 135B 60 PUSH1 0x04 135D 82 DUP3 135E 01 ADD 135F 81 DUP2 1360 90 SWAP1 1361 52 MSTORE 1362 60 PUSH1 0x24 1364 82 DUP3 1365 01 ADD 1366 52 MSTORE 1367 60 PUSH1 0x00 1369 80 DUP1 136A 51 MLOAD 136B 60 PUSH1 0x20 136D 61 PUSH2 0x2406 1370 83 DUP4 1371 39 CODECOPY 1372 81 DUP2 1373 51 MLOAD 1374 91 SWAP2 1375 52 MSTORE 1376 60 PUSH1 0x44 1378 82 DUP3 1379 01 ADD 137A 52 MSTORE 137B 60 PUSH1 0x64 137D 01 ADD 137E 61 PUSH2 0x089a 1381 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @1358 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1361 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1366 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1371 memory[0x00:0x20] = code[0x2406:0x2426] // @1375 memory[0x00:0x20] = memory[0x00:0x20] // @137A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @137D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x089a label_1382: // Incoming jump from 0x134C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1386 stack[-1] // @1387 memory[stack[-1]:stack[-1] + 0x20] // } 1382 5B JUMPDEST 1383 60 PUSH1 0x00 1385 5B JUMPDEST 1386 81 DUP2 1387 51 MLOAD 1388 81 DUP2 1389 10 LT 138A 15 ISZERO 138B 61 PUSH2 0x0abb 138E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1383 stack[0] = 0x00 } // Block ends with conditional jump to 0x0abb, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_138F: // Incoming jump from 0x138E, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x138E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1395 stack[-2] // @1396 stack[-1] // @1398 memory[stack[-2]:stack[-2] + 0x20] // } 138F 60 PUSH1 0x01 1391 60 PUSH1 0x09 1393 60 PUSH1 0x00 1395 84 DUP5 1396 84 DUP5 1397 81 DUP2 1398 51 MLOAD 1399 81 DUP2 139A 10 LT 139B 61 PUSH2 0x13a6 139E 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @138F stack[0] = 0x01 // @1391 stack[1] = 0x09 // @1393 stack[2] = 0x00 // @1395 stack[3] = stack[-2] // @1396 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x13a6, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_139F: // Incoming jump from 0x139E, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 139F 61 PUSH2 0x13a6 13A2 61 PUSH2 0x2111 13A5 56 *JUMP // Stack delta = +1 // Outputs[1] { @139F stack[0] = 0x13a6 } // Block ends with unconditional jump to 0x2111 label_13A6: // Incoming jump from 0x139E, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[9] // { // @13A9 stack[-1] // @13AC stack[-2] // @13B2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13BC stack[-3] // @13C0 stack[-4] // @13C9 memory[0x00:0x00 + 0x40 + stack[-3]] // @13CB storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // @13D0 stack[-5] // @13D9 stack[-6] // } 13A6 5B JUMPDEST 13A7 60 PUSH1 0x20 13A9 90 SWAP1 13AA 81 DUP2 13AB 02 MUL 13AC 91 SWAP2 13AD 90 SWAP1 13AE 91 SWAP2 13AF 01 ADD 13B0 81 DUP2 13B1 01 ADD 13B2 51 MLOAD 13B3 60 PUSH1 0x01 13B5 60 PUSH1 0x01 13B7 60 PUSH1 0xa0 13B9 1B SHL 13BA 03 SUB 13BB 16 AND 13BC 82 DUP3 13BD 52 MSTORE 13BE 81 DUP2 13BF 01 ADD 13C0 91 SWAP2 13C1 90 SWAP1 13C2 91 SWAP2 13C3 52 MSTORE 13C4 60 PUSH1 0x40 13C6 01 ADD 13C7 60 PUSH1 0x00 13C9 20 SHA3 13CA 80 DUP1 13CB 54 SLOAD 13CC 60 PUSH1 0xff 13CE 19 NOT 13CF 16 AND 13D0 91 SWAP2 13D1 15 ISZERO 13D2 15 ISZERO 13D3 91 SWAP2 13D4 90 SWAP1 13D5 91 SWAP2 13D6 17 OR 13D7 90 SWAP1 13D8 55 SSTORE 13D9 80 DUP1 13DA 61 PUSH2 0x13e2 13DD 81 DUP2 13DE 61 PUSH2 0x213d 13E1 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @13BD memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13C3 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // @13D8 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] = !!stack[-5] | (~0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])]) // @13D9 stack[-5] = stack[-6] // @13DA stack[-4] = 0x13e2 // @13DD stack[-3] = stack[-6] // } // Block ends with call to 0x213d, returns to 0x13E2 label_13E2: // Incoming return from call to 0x213D at 0x13E1 // Inputs[2] // { // @13E3 stack[-1] // @13E3 stack[-3] // } 13E2 5B JUMPDEST 13E3 91 SWAP2 13E4 50 POP 13E5 50 POP 13E6 61 PUSH2 0x1385 13E9 56 *JUMP // Stack delta = -2 // Outputs[1] { @13E3 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1385 13EA 5B JUMPDEST 13EB 60 PUSH1 0x01 13ED 60 PUSH1 0x01 13EF 60 PUSH1 0xa0 13F1 1B SHL 13F2 03 SUB 13F3 16 AND 13F4 3B EXTCODESIZE 13F5 15 ISZERO 13F6 15 ISZERO 13F7 90 SWAP1 13F8 56 *JUMP label_13F9: // Incoming call from 0x1923, returns to 0x1924 // Incoming call from 0x0944, returns to 0x0945 // Inputs[1] { @13FC stack[-1] } 13F9 5B JUMPDEST 13FA 60 PUSH1 0x00 13FC 81 DUP2 13FD 60 PUSH1 0x01 13FF 11 GT 1400 15 ISZERO 1401 80 DUP1 1402 15 ISZERO 1403 61 PUSH2 0x140d 1406 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13FA stack[0] = 0x00 // @1400 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x140d, if !!(0x01 > stack[-1]) label_1407: // Incoming jump from 0x1406, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @140A storage[0x00] // @140B stack[-3] // } 1407 50 POP 1408 60 PUSH1 0x00 140A 54 SLOAD 140B 82 DUP3 140C 10 LT 140D 5B JUMPDEST 140E 80 DUP1 140F 15 ISZERO 1410 61 PUSH2 0x0850 1413 57 *JUMPI // Stack delta = +0 // Outputs[1] { @140C stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x0850, if !(stack[-3] < storage[0x00]) label_1414: // Incoming jump from 0x1413, if not !stack[-1] // Incoming jump from 0x1413, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @1418 stack[-3] // @1423 memory[0x00:0x40] // @1424 storage[keccak256(memory[0x00:0x40])] // @1430 stack[-4] // } 1414 50 POP 1415 50 POP 1416 60 PUSH1 0x00 1418 90 SWAP1 1419 81 DUP2 141A 52 MSTORE 141B 60 PUSH1 0x04 141D 60 PUSH1 0x20 141F 52 MSTORE 1420 60 PUSH1 0x40 1422 90 SWAP1 1423 20 SHA3 1424 54 SLOAD 1425 60 PUSH1 0x01 1427 60 PUSH1 0xe0 1429 1B SHL 142A 90 SWAP1 142B 04 DIV 142C 60 PUSH1 0xff 142E 16 AND 142F 15 ISZERO 1430 90 SWAP1 1431 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @141A memory[0x00:0x20] = stack[-3] // @141F memory[0x20:0x40] = 0x04 // @1430 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_1432: // Incoming call from 0x1568, returns to 0x1569 // Incoming call from 0x0A05, returns to 0x0A06 // Inputs[8] // { // @1435 stack[-2] // @1441 memory[0x00:0x40] // @1443 storage[keccak256(memory[0x00:0x40])] // @1463 stack[-3] // @146D memory[0x40:0x60] // @1471 stack[-1] // @1496 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @149A stack[-4] // } 1432 5B JUMPDEST 1433 60 PUSH1 0x00 1435 82 DUP3 1436 81 DUP2 1437 52 MSTORE 1438 60 PUSH1 0x06 143A 60 PUSH1 0x20 143C 52 MSTORE 143D 60 PUSH1 0x40 143F 80 DUP1 1440 82 DUP3 1441 20 SHA3 1442 80 DUP1 1443 54 SLOAD 1444 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1459 19 NOT 145A 16 AND 145B 60 PUSH1 0x01 145D 60 PUSH1 0x01 145F 60 PUSH1 0xa0 1461 1B SHL 1462 03 SUB 1463 87 DUP8 1464 81 DUP2 1465 16 AND 1466 91 SWAP2 1467 82 DUP3 1468 17 OR 1469 90 SWAP1 146A 92 SWAP3 146B 55 SSTORE 146C 91 SWAP2 146D 51 MLOAD 146E 85 DUP6 146F 93 SWAP4 1470 91 SWAP2 1471 85 DUP6 1472 16 AND 1473 91 SWAP2 1474 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1495 91 SWAP2 1496 A4 LOG4 1497 50 POP 1498 50 POP 1499 50 POP 149A 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1437 memory[0x00:0x20] = stack[-2] // @143C memory[0x20:0x40] = 0x06 // @146B storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1496 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_149B: // Incoming jump from 0x1176 // Incoming jump from 0x0AC9 // Inputs[1] { @14A1 stack[-1] } 149B 5B JUMPDEST 149C 60 PUSH1 0x00 149E 61 PUSH2 0x14a6 14A1 82 DUP3 14A2 61 PUSH2 0x168b 14A5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @149C stack[0] = 0x00 // @149E stack[1] = 0x14a6 // @14A1 stack[2] = stack[-1] // } // Block ends with call to 0x168b, returns to 0x14A6 label_14A6: // Incoming return from call to 0x168B at 0x14A5 // Inputs[4] // { // @14A7 stack[-1] // @14A7 stack[-2] // @14A9 stack[-5] // @14B7 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 14A6 5B JUMPDEST 14A7 90 SWAP1 14A8 50 POP 14A9 83 DUP4 14AA 60 PUSH1 0x01 14AC 60 PUSH1 0x01 14AE 60 PUSH1 0xa0 14B0 1B SHL 14B1 03 SUB 14B2 16 AND 14B3 81 DUP2 14B4 60 PUSH1 0x00 14B6 01 ADD 14B7 51 MLOAD 14B8 60 PUSH1 0x01 14BA 60 PUSH1 0x01 14BC 60 PUSH1 0xa0 14BE 1B SHL 14BF 03 SUB 14C0 16 AND 14C1 14 EQ 14C2 61 PUSH2 0x14dd 14C5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @14A7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x14dd, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_14C6: // Incoming jump from 0x14C5, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @14C8 memory[0x40:0x60] // @14D7 memory[0x40:0x60] // @14DC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 14C6 60 PUSH1 0x40 14C8 51 MLOAD 14C9 62 PUSH3 0xa11481 14CD 60 PUSH1 0xe8 14CF 1B SHL 14D0 81 DUP2 14D1 52 MSTORE 14D2 60 PUSH1 0x04 14D4 01 ADD 14D5 60 PUSH1 0x40 14D7 51 MLOAD 14D8 80 DUP1 14D9 91 SWAP2 14DA 03 SUB 14DB 90 SWAP1 14DC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @14DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_14DD: // Incoming jump from 0x14C5, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @14E0 msg.sender // @14E9 stack[-4] // } 14DD 5B JUMPDEST 14DE 60 PUSH1 0x00 14E0 33 CALLER 14E1 60 PUSH1 0x01 14E3 60 PUSH1 0x01 14E5 60 PUSH1 0xa0 14E7 1B SHL 14E8 03 SUB 14E9 86 DUP7 14EA 16 AND 14EB 14 EQ 14EC 80 DUP1 14ED 61 PUSH2 0x14fb 14F0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14DE stack[0] = 0x00 // @14EB stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x14fb, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_14F1: // Incoming jump from 0x14F0, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @14F5 stack[-6] // @14F6 msg.sender // } 14F1 50 POP 14F2 61 PUSH2 0x14fb 14F5 85 DUP6 14F6 33 CALLER 14F7 61 PUSH2 0x0780 14FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14F2 stack[-1] = 0x14fb // @14F5 stack[0] = stack[-6] // @14F6 stack[1] = msg.sender // } // Block ends with call to 0x0780, returns to 0x14FB label_14FB: // Incoming return from call to 0x0780 at 0x14FA // Incoming jump from 0x14F0, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @14FC stack[-1] } 14FB 5B JUMPDEST 14FC 80 DUP1 14FD 61 PUSH2 0x1516 1500 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1516, if stack[-1] label_1501: // Incoming jump from 0x1500, if not stack[-1] // Inputs[2] // { // @1502 msg.sender // @1506 stack[-4] // } 1501 50 POP 1502 33 CALLER 1503 61 PUSH2 0x150b 1506 84 DUP5 1507 61 PUSH2 0x093a 150A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1502 stack[-1] = msg.sender // @1503 stack[0] = 0x150b // @1506 stack[1] = stack[-4] // } // Block ends with call to 0x093a, returns to 0x150B label_150B: // Incoming return from call to 0x093A at 0x150A // Inputs[2] // { // @1514 stack[-1] // @1515 stack[-2] // } 150B 5B JUMPDEST 150C 60 PUSH1 0x01 150E 60 PUSH1 0x01 1510 60 PUSH1 0xa0 1512 1B SHL 1513 03 SUB 1514 16 AND 1515 14 EQ // Stack delta = -1 // Outputs[1] { @1515 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1516: // Incoming jump from 0x1515 // Incoming jump from 0x1500, if stack[-1] // Inputs[2] // { // @1517 stack[-2] // @1517 stack[-1] // } 1516 5B JUMPDEST 1517 90 SWAP1 1518 50 POP 1519 80 DUP1 151A 61 PUSH2 0x1536 151D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1517 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1536, if stack[-1] label_151E: // Incoming jump from 0x151D, if not stack[-1] // Inputs[3] // { // @1520 memory[0x40:0x60] // @1530 memory[0x40:0x60] // @1535 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 151E 60 PUSH1 0x40 1520 51 MLOAD 1521 63 PUSH4 0x2ce44b5f 1526 60 PUSH1 0xe1 1528 1B SHL 1529 81 DUP2 152A 52 MSTORE 152B 60 PUSH1 0x04 152D 01 ADD 152E 60 PUSH1 0x40 1530 51 MLOAD 1531 80 DUP1 1532 91 SWAP2 1533 03 SUB 1534 90 SWAP1 1535 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @152A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @1535 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1536: // Incoming jump from 0x151D, if stack[-1] // Inputs[1] { @153F stack[-4] } 1536 5B JUMPDEST 1537 60 PUSH1 0x01 1539 60 PUSH1 0x01 153B 60 PUSH1 0xa0 153D 1B SHL 153E 03 SUB 153F 84 DUP5 1540 16 AND 1541 61 PUSH2 0x155d 1544 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x155d, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1545: // Incoming jump from 0x1544, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1547 memory[0x40:0x60] // @1557 memory[0x40:0x60] // @155C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1545 60 PUSH1 0x40 1547 51 MLOAD 1548 63 PUSH4 0x3a954ecd 154D 60 PUSH1 0xe2 154F 1B SHL 1550 81 DUP2 1551 52 MSTORE 1552 60 PUSH1 0x04 1554 01 ADD 1555 60 PUSH1 0x40 1557 51 MLOAD 1558 80 DUP1 1559 91 SWAP2 155A 03 SUB 155B 90 SWAP1 155C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1551 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @155C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_155D: // Incoming jump from 0x1544, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1563 stack[-3] // @1564 stack[-5] // } 155D 5B JUMPDEST 155E 61 PUSH2 0x1569 1561 60 PUSH1 0x00 1563 84 DUP5 1564 87 DUP8 1565 61 PUSH2 0x1432 1568 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @155E stack[0] = 0x1569 // @1561 stack[1] = 0x00 // @1563 stack[2] = stack[-3] // @1564 stack[3] = stack[-5] // } // Block ends with call to 0x1432, returns to 0x1569 label_1569: // Incoming return from call to 0x1432 at 0x1568 // Inputs[12] // { // @1572 stack[-5] // @1585 memory[0x00:0x40] // @1587 storage[keccak256(memory[0x00:0x40])] // @15AB stack[-4] // @15B3 memory[0x00:0x40] // @15B5 storage[keccak256(memory[0x00:0x40])] // @15C9 stack[-3] // @15D3 memory[0x00:0x40] // @15D5 storage[keccak256(memory[0x00:0x40])] // @15E8 block.timestamp // @15F9 memory[0x00:0x40] // @15FB storage[keccak256(memory[0x00:0x40])] // } 1569 5B JUMPDEST 156A 60 PUSH1 0x01 156C 60 PUSH1 0x01 156E 60 PUSH1 0xa0 1570 1B SHL 1571 03 SUB 1572 85 DUP6 1573 81 DUP2 1574 16 AND 1575 60 PUSH1 0x00 1577 90 SWAP1 1578 81 DUP2 1579 52 MSTORE 157A 60 PUSH1 0x05 157C 60 PUSH1 0x20 157E 90 SWAP1 157F 81 DUP2 1580 52 MSTORE 1581 60 PUSH1 0x40 1583 80 DUP1 1584 83 DUP4 1585 20 SHA3 1586 80 DUP1 1587 54 SLOAD 1588 67 PUSH8 0xffffffffffffffff 1591 19 NOT 1592 80 DUP1 1593 82 DUP3 1594 16 AND 1595 67 PUSH8 0xffffffffffffffff 159E 92 SWAP3 159F 83 DUP4 15A0 16 AND 15A1 60 PUSH1 0x00 15A3 19 NOT 15A4 01 ADD 15A5 83 DUP4 15A6 16 AND 15A7 17 OR 15A8 90 SWAP1 15A9 92 SWAP3 15AA 55 SSTORE 15AB 89 DUP10 15AC 86 DUP7 15AD 16 AND 15AE 80 DUP1 15AF 86 DUP7 15B0 52 MSTORE 15B1 83 DUP4 15B2 86 DUP7 15B3 20 SHA3 15B4 80 DUP1 15B5 54 SLOAD 15B6 93 SWAP4 15B7 84 DUP5 15B8 16 AND 15B9 93 SWAP4 15BA 83 DUP4 15BB 16 AND 15BC 60 PUSH1 0x01 15BE 90 SWAP1 15BF 81 DUP2 15C0 01 ADD 15C1 84 DUP5 15C2 16 AND 15C3 94 SWAP5 15C4 90 SWAP1 15C5 94 SWAP5 15C6 17 OR 15C7 90 SWAP1 15C8 55 SSTORE 15C9 89 DUP10 15CA 86 DUP7 15CB 52 MSTORE 15CC 60 PUSH1 0x04 15CE 90 SWAP1 15CF 94 SWAP5 15D0 52 MSTORE 15D1 82 DUP3 15D2 85 DUP6 15D3 20 SHA3 15D4 80 DUP1 15D5 54 SLOAD 15D6 60 PUSH1 0x01 15D8 60 PUSH1 0x01 15DA 60 PUSH1 0xe0 15DC 1B SHL 15DD 03 SUB 15DE 19 NOT 15DF 16 AND 15E0 90 SWAP1 15E1 94 SWAP5 15E2 17 OR 15E3 60 PUSH1 0x01 15E5 60 PUSH1 0xa0 15E7 1B SHL 15E8 42 TIMESTAMP 15E9 90 SWAP1 15EA 92 SWAP3 15EB 16 AND 15EC 91 SWAP2 15ED 90 SWAP1 15EE 91 SWAP2 15EF 02 MUL 15F0 17 OR 15F1 83 DUP4 15F2 55 SSTORE 15F3 87 DUP8 15F4 01 ADD 15F5 80 DUP1 15F6 84 DUP5 15F7 52 MSTORE 15F8 92 SWAP3 15F9 20 SHA3 15FA 80 DUP1 15FB 54 SLOAD 15FC 91 SWAP2 15FD 93 SWAP4 15FE 90 SWAP1 15FF 91 SWAP2 1600 16 AND 1601 61 PUSH2 0x163f 1604 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @1579 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1580 memory[0x20:0x40] = 0x05 // @15AA storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @15B0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @15C8 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @15CB memory[0x00:0x20] = stack[-3] // @15D0 memory[0x20:0x40] = 0x04 // @15F2 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @15F7 memory[0x00:0x20] = stack[-3] + 0x01 // @15F8 stack[1] = stack[-3] + 0x01 // @15FD stack[0] = keccak256(memory[0x00:0x40]) // @15FF stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x163f, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_1605: // Incoming jump from 0x1604, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1607 storage[0x00] // @1608 stack[-2] // } 1605 60 PUSH1 0x00 1607 54 SLOAD 1608 82 DUP3 1609 14 EQ 160A 61 PUSH2 0x163f 160D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x163f, if stack[-2] == storage[0x00] label_160E: // Incoming jump from 0x160D, if not stack[-2] == storage[0x00] // Inputs[5] // { // @160E stack[-1] // @160F storage[stack[-1]] // @1612 stack[-5] // @1614 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1639 stack[-8] // } 160E 80 DUP1 160F 54 SLOAD 1610 60 PUSH1 0x20 1612 86 DUP7 1613 01 ADD 1614 51 MLOAD 1615 67 PUSH8 0xffffffffffffffff 161E 16 AND 161F 60 PUSH1 0x01 1621 60 PUSH1 0xa0 1623 1B SHL 1624 02 MUL 1625 60 PUSH1 0x01 1627 60 PUSH1 0x01 1629 60 PUSH1 0xe0 162B 1B SHL 162C 03 SUB 162D 19 NOT 162E 90 SWAP1 162F 91 SWAP2 1630 16 AND 1631 60 PUSH1 0x01 1633 60 PUSH1 0x01 1635 60 PUSH1 0xa0 1637 1B SHL 1638 03 SUB 1639 8A DUP11 163A 16 AND 163B 17 OR 163C 17 OR 163D 81 DUP2 163E 55 SSTORE // Stack delta = +0 // Outputs[1] { @163E storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_163F: // Incoming jump from 0x160D, if stack[-2] == storage[0x00] // Incoming jump from 0x1604, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x163E // Inputs[6] // { // @1643 stack[-6] // @1644 stack[-7] // @164E stack[-8] // @167B memory[0x40:0x60] // @167E memory[0x40:0x60] // @1683 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 163F 5B JUMPDEST 1640 50 POP 1641 50 POP 1642 50 POP 1643 82 DUP3 1644 84 DUP5 1645 60 PUSH1 0x01 1647 60 PUSH1 0x01 1649 60 PUSH1 0xa0 164B 1B SHL 164C 03 SUB 164D 16 AND 164E 86 DUP7 164F 60 PUSH1 0x01 1651 60 PUSH1 0x01 1653 60 PUSH1 0xa0 1655 1B SHL 1656 03 SUB 1657 16 AND 1658 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1679 60 PUSH1 0x40 167B 51 MLOAD 167C 60 PUSH1 0x40 167E 51 MLOAD 167F 80 DUP1 1680 91 SWAP2 1681 03 SUB 1682 90 SWAP1 1683 A4 LOG4 // Stack delta = -3 // Outputs[1] { @1683 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_1684: // Incoming jump from 0x1683 // Incoming jump from 0x1CA3 // Inputs[1] { @168A stack[-6] } 1684 5B JUMPDEST 1685 50 POP 1686 50 POP 1687 50 POP 1688 50 POP 1689 50 POP 168A 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_168B: // Incoming call from 0x14A5, returns to 0x14A6 // Incoming call from 0x0C44, returns to 0x0C45 // Inputs[2] // { // @168F memory[0x40:0x60] // @16A9 stack[-1] // } 168B 5B JUMPDEST 168C 60 PUSH1 0x40 168E 80 DUP1 168F 51 MLOAD 1690 60 PUSH1 0x60 1692 81 DUP2 1693 01 ADD 1694 82 DUP3 1695 52 MSTORE 1696 60 PUSH1 0x00 1698 80 DUP1 1699 82 DUP3 169A 52 MSTORE 169B 60 PUSH1 0x20 169D 82 DUP3 169E 01 ADD 169F 81 DUP2 16A0 90 SWAP1 16A1 52 MSTORE 16A2 91 SWAP2 16A3 81 DUP2 16A4 01 ADD 16A5 91 SWAP2 16A6 90 SWAP1 16A7 91 SWAP2 16A8 52 MSTORE 16A9 81 DUP2 16AA 80 DUP1 16AB 60 PUSH1 0x01 16AD 11 GT 16AE 15 ISZERO 16AF 80 DUP1 16B0 15 ISZERO 16B1 61 PUSH2 0x16bb 16B4 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1695 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @169A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @16A1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @16A7 stack[0] = memory[0x40:0x60] // @16A8 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @16A9 stack[1] = stack[-1] // @16AE stack[2] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x16bb, if !!(0x01 > stack[-1]) label_16B5: // Incoming jump from 0x16B4, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @16B8 storage[0x00] // @16B9 stack[-2] // } 16B5 50 POP 16B6 60 PUSH1 0x00 16B8 54 SLOAD 16B9 81 DUP2 16BA 10 LT 16BB 5B JUMPDEST 16BC 15 ISZERO 16BD 61 PUSH2 0x179b 16C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x179b, if !(stack[-2] < storage[0x00]) label_16C1: // Incoming jump from 0x16C0, if not !(stack[-2] < storage[0x00]) // Incoming jump from 0x16C0, if not !stack[-1] // Inputs[4] // { // @16C3 stack[-1] // @16D2 memory[0x00:0x40] // @16D4 memory[0x40:0x60] // @16DC storage[keccak256(memory[0x00:0x40])] // } 16C1 60 PUSH1 0x00 16C3 81 DUP2 16C4 81 DUP2 16C5 52 MSTORE 16C6 60 PUSH1 0x04 16C8 60 PUSH1 0x20 16CA 90 SWAP1 16CB 81 DUP2 16CC 52 MSTORE 16CD 60 PUSH1 0x40 16CF 91 SWAP2 16D0 82 DUP3 16D1 90 SWAP1 16D2 20 SHA3 16D3 82 DUP3 16D4 51 MLOAD 16D5 60 PUSH1 0x60 16D7 81 DUP2 16D8 01 ADD 16D9 84 DUP5 16DA 52 MSTORE 16DB 90 SWAP1 16DC 54 SLOAD 16DD 60 PUSH1 0x01 16DF 60 PUSH1 0x01 16E1 60 PUSH1 0xa0 16E3 1B SHL 16E4 03 SUB 16E5 81 DUP2 16E6 16 AND 16E7 82 DUP3 16E8 52 MSTORE 16E9 60 PUSH1 0x01 16EB 60 PUSH1 0xa0 16ED 1B SHL 16EE 81 DUP2 16EF 04 DIV 16F0 67 PUSH8 0xffffffffffffffff 16F9 16 AND 16FA 92 SWAP3 16FB 82 DUP3 16FC 01 ADD 16FD 92 SWAP3 16FE 90 SWAP1 16FF 92 SWAP3 1700 52 MSTORE 1701 60 PUSH1 0x01 1703 60 PUSH1 0xe0 1705 1B SHL 1706 90 SWAP1 1707 91 SWAP2 1708 04 DIV 1709 60 PUSH1 0xff 170B 16 AND 170C 15 ISZERO 170D 15 ISZERO 170E 91 SWAP2 170F 81 DUP2 1710 01 ADD 1711 82 DUP3 1712 90 SWAP1 1713 52 MSTORE 1714 90 SWAP1 1715 61 PUSH2 0x1799 1718 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @16C5 memory[0x00:0x20] = stack[-1] // @16CC memory[0x20:0x40] = 0x04 // @16DA memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @16E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1700 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1713 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @1714 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1799, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1719: // Incoming jump from 0x1718, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1719 stack[-1] // @171A memory[stack[-1]:stack[-1] + 0x20] // } 1719 80 DUP1 171A 51 MLOAD 171B 60 PUSH1 0x01 171D 60 PUSH1 0x01 171F 60 PUSH1 0xa0 1721 1B SHL 1722 03 SUB 1723 16 AND 1724 15 ISZERO 1725 61 PUSH2 0x172f 1728 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x172f, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1729: // Incoming jump from 0x1728, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1729 stack[-1] // @1729 stack[-5] // @172A stack[-4] // } 1729 93 SWAP4 172A 92 SWAP3 172B 50 POP 172C 50 POP 172D 50 POP 172E 56 *JUMP // Stack delta = -4 // Outputs[1] { @1729 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_172F: // Incoming jump from 0x1728, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1798 // Inputs[4] // { // @1734 stack[-2] // @1746 memory[0x00:0x40] // @1748 memory[0x40:0x60] // @1750 storage[keccak256(memory[0x00:0x40])] // } 172F 5B JUMPDEST 1730 50 POP 1731 60 PUSH1 0x00 1733 19 NOT 1734 01 ADD 1735 60 PUSH1 0x00 1737 81 DUP2 1738 81 DUP2 1739 52 MSTORE 173A 60 PUSH1 0x04 173C 60 PUSH1 0x20 173E 90 SWAP1 173F 81 DUP2 1740 52 MSTORE 1741 60 PUSH1 0x40 1743 91 SWAP2 1744 82 DUP3 1745 90 SWAP1 1746 20 SHA3 1747 82 DUP3 1748 51 MLOAD 1749 60 PUSH1 0x60 174B 81 DUP2 174C 01 ADD 174D 84 DUP5 174E 52 MSTORE 174F 90 SWAP1 1750 54 SLOAD 1751 60 PUSH1 0x01 1753 60 PUSH1 0x01 1755 60 PUSH1 0xa0 1757 1B SHL 1758 03 SUB 1759 81 DUP2 175A 16 AND 175B 80 DUP1 175C 83 DUP4 175D 52 MSTORE 175E 60 PUSH1 0x01 1760 60 PUSH1 0xa0 1762 1B SHL 1763 82 DUP3 1764 04 DIV 1765 67 PUSH8 0xffffffffffffffff 176E 16 AND 176F 93 SWAP4 1770 83 DUP4 1771 01 ADD 1772 93 SWAP4 1773 90 SWAP1 1774 93 SWAP4 1775 52 MSTORE 1776 60 PUSH1 0x01 1778 60 PUSH1 0xe0 177A 1B SHL 177B 90 SWAP1 177C 04 DIV 177D 60 PUSH1 0xff 177F 16 AND 1780 15 ISZERO 1781 15 ISZERO 1782 92 SWAP3 1783 81 DUP2 1784 01 ADD 1785 92 SWAP3 1786 90 SWAP1 1787 92 SWAP3 1788 52 MSTORE 1789 15 ISZERO 178A 61 PUSH2 0x1794 178D 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1734 stack[-2] = ~0x00 + stack[-2] // @1739 memory[0x00:0x20] = ~0x00 + stack[-2] // @1740 memory[0x20:0x40] = 0x04 // @174E memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @175D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1775 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1787 stack[-1] = memory[0x40:0x60] // @1788 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1794, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_178E: // Incoming jump from 0x178D, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @178E stack[-5] // @178E stack[-1] // @178F stack[-4] // } 178E 93 SWAP4 178F 92 SWAP3 1790 50 POP 1791 50 POP 1792 50 POP 1793 56 *JUMP // Stack delta = -4 // Outputs[1] { @178E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1794: // Incoming jump from 0x178D, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1794 5B JUMPDEST 1795 61 PUSH2 0x172f 1798 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x172f label_1799: // Incoming jump from 0x1718, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1799 5B JUMPDEST 179A 50 POP // Stack delta = -1 // Block continues label_179B: // Incoming jump from 0x16C0, if !(stack[-2] < storage[0x00]) // Incoming jump from 0x179A // Incoming jump from 0x16C0, if !stack[-1] // Inputs[3] // { // @179E memory[0x40:0x60] // @17AE memory[0x40:0x60] // @17B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 179B 5B JUMPDEST 179C 60 PUSH1 0x40 179E 51 MLOAD 179F 63 PUSH4 0x6f96cda1 17A4 60 PUSH1 0xe1 17A6 1B SHL 17A7 81 DUP2 17A8 52 MSTORE 17A9 60 PUSH1 0x04 17AB 01 ADD 17AC 60 PUSH1 0x40 17AE 51 MLOAD 17AF 80 DUP1 17B0 91 SWAP2 17B1 03 SUB 17B2 90 SWAP1 17B3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @17B3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17B4: // Incoming call from 0x0D7A, returns to 0x0D7B // Inputs[5] // { // @17B8 storage[0x08] // @17C1 stack[-1] // @17E3 memory[0x40:0x60] // @180F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1812 stack[-2] // } 17B4 5B JUMPDEST 17B5 60 PUSH1 0x08 17B7 80 DUP1 17B8 54 SLOAD 17B9 60 PUSH1 0x01 17BB 60 PUSH1 0x01 17BD 60 PUSH1 0xa0 17BF 1B SHL 17C0 03 SUB 17C1 83 DUP4 17C2 81 DUP2 17C3 16 AND 17C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D9 19 NOT 17DA 83 DUP4 17DB 16 AND 17DC 81 DUP2 17DD 17 OR 17DE 90 SWAP1 17DF 93 SWAP4 17E0 55 SSTORE 17E1 60 PUSH1 0x40 17E3 51 MLOAD 17E4 91 SWAP2 17E5 16 AND 17E6 91 SWAP2 17E7 90 SWAP1 17E8 82 DUP3 17E9 90 SWAP1 17EA 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 180B 90 SWAP1 180C 60 PUSH1 0x00 180E 90 SWAP1 180F A3 LOG3 1810 50 POP 1811 50 POP 1812 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @17E0 storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~0xffffffffffffffffffffffffffffffffffffffff) // @180F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1813: // Incoming jump from 0x0FCE // Inputs[3] // { // @1817 stack[-2] // @1818 stack[-1] // @181B memory[0x40:0x60] // } 1813 5B JUMPDEST 1814 61 PUSH2 0x0abb 1817 82 DUP3 1818 82 DUP3 1819 60 PUSH1 0x40 181B 51 MLOAD 181C 80 DUP1 181D 60 PUSH1 0x20 181F 01 ADD 1820 60 PUSH1 0x40 1822 52 MSTORE 1823 80 DUP1 1824 60 PUSH1 0x00 1826 81 DUP2 1827 52 MSTORE 1828 50 POP 1829 61 PUSH2 0x199d 182C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1814 stack[0] = 0x0abb // @1817 stack[1] = stack[-2] // @1818 stack[2] = stack[-1] // @181B stack[3] = memory[0x40:0x60] // @1822 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1827 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x199d label_182D: // Incoming jump from 0x1C1E // Inputs[6] // { // @1830 memory[0x40:0x60] // @1846 stack[-3] // @1853 msg.sender // @1855 stack[-4] // @1857 stack[-2] // @1859 stack[-1] // } 182D 5B JUMPDEST 182E 60 PUSH1 0x40 1830 51 MLOAD 1831 63 PUSH4 0x0a85bd01 1836 60 PUSH1 0xe1 1838 1B SHL 1839 81 DUP2 183A 52 MSTORE 183B 60 PUSH1 0x00 183D 90 SWAP1 183E 60 PUSH1 0x01 1840 60 PUSH1 0x01 1842 60 PUSH1 0xa0 1844 1B SHL 1845 03 SUB 1846 85 DUP6 1847 16 AND 1848 90 SWAP1 1849 63 PUSH4 0x150b7a02 184E 90 SWAP1 184F 61 PUSH2 0x1862 1852 90 SWAP1 1853 33 CALLER 1854 90 SWAP1 1855 89 DUP10 1856 90 SWAP1 1857 88 DUP9 1858 90 SWAP1 1859 88 DUP9 185A 90 SWAP1 185B 60 PUSH1 0x04 185D 01 ADD 185E 61 PUSH2 0x2328 1861 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @183A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @183D stack[0] = 0x00 // @1848 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @184E stack[2] = 0x150b7a02 // @1852 stack[3] = 0x1862 // @1854 stack[4] = msg.sender // @1856 stack[5] = stack[-4] // @1858 stack[6] = stack[-2] // @185A stack[7] = stack[-1] // @185D stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2328, returns to 0x1862 label_1862: // Incoming return from call to 0x2328 at 0x1861 // Inputs[6] // { // @1867 memory[0x40:0x60] // @1869 stack[-1] // @186E stack[-3] // @186F msg.gas // @1870 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1870 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1862 5B JUMPDEST 1863 60 PUSH1 0x20 1865 60 PUSH1 0x40 1867 51 MLOAD 1868 80 DUP1 1869 83 DUP4 186A 03 SUB 186B 81 DUP2 186C 60 PUSH1 0x00 186E 87 DUP8 186F 5A GAS 1870 F1 CALL 1871 92 SWAP3 1872 50 POP 1873 50 POP 1874 50 POP 1875 80 DUP1 1876 15 ISZERO 1877 61 PUSH2 0x189d 187A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1870 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1871 stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x189d, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_187B: // Incoming jump from 0x187A, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @187F memory[0x40:0x60] // @1882 returndata.length // } 187B 50 POP 187C 60 PUSH1 0x40 187E 80 DUP1 187F 51 MLOAD 1880 60 PUSH1 0x1f 1882 3D RETURNDATASIZE 1883 90 SWAP1 1884 81 DUP2 1885 01 ADD 1886 60 PUSH1 0x1f 1888 19 NOT 1889 16 AND 188A 82 DUP3 188B 01 ADD 188C 90 SWAP1 188D 92 SWAP3 188E 52 MSTORE 188F 61 PUSH2 0x189a 1892 91 SWAP2 1893 81 DUP2 1894 01 ADD 1895 90 SWAP1 1896 61 PUSH2 0x2364 1899 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @188E memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1892 stack[-1] = 0x189a // @1895 stack[1] = memory[0x40:0x60] // @1895 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2364 189A 5B JUMPDEST 189B 60 PUSH1 0x01 label_189D: // Incoming jump from 0x187A, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @18A1 stack[-1] } 189D 5B JUMPDEST 189E 61 PUSH2 0x18fb 18A1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18fb, if stack[-1] label_18A2: // Incoming jump from 0x18A1, if not stack[-1] // Inputs[1] { @18A2 returndata.length } 18A2 3D RETURNDATASIZE 18A3 80 DUP1 18A4 80 DUP1 18A5 15 ISZERO 18A6 61 PUSH2 0x18cb 18A9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18A2 stack[0] = returndata.length // @18A3 stack[1] = returndata.length // } // Block ends with conditional jump to 0x18cb, if !returndata.length label_18AA: // Incoming jump from 0x18A9, if not !returndata.length // Inputs[6] // { // @18AC memory[0x40:0x60] // @18AD stack[-2] // @18B4 returndata.length // @18BC returndata.length // @18BF returndata.length // @18C6 returndata[0x00:0x00 + returndata.length] // } 18AA 60 PUSH1 0x40 18AC 51 MLOAD 18AD 91 SWAP2 18AE 50 POP 18AF 60 PUSH1 0x1f 18B1 19 NOT 18B2 60 PUSH1 0x3f 18B4 3D RETURNDATASIZE 18B5 01 ADD 18B6 16 AND 18B7 82 DUP3 18B8 01 ADD 18B9 60 PUSH1 0x40 18BB 52 MSTORE 18BC 3D RETURNDATASIZE 18BD 82 DUP3 18BE 52 MSTORE 18BF 3D RETURNDATASIZE 18C0 60 PUSH1 0x00 18C2 60 PUSH1 0x20 18C4 84 DUP5 18C5 01 ADD 18C6 3E RETURNDATACOPY 18C7 61 PUSH2 0x18d0 18CA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @18AD stack[-2] = memory[0x40:0x60] // @18BB memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @18BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @18C6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x18d0 label_18CB: // Incoming jump from 0x18A9, if !returndata.length // Inputs[2] // { // @18CE stack[-2] // @18D3 memory[0x60:0x80] // } 18CB 5B JUMPDEST 18CC 60 PUSH1 0x60 18CE 91 SWAP2 18CF 50 POP 18D0 5B JUMPDEST 18D1 50 POP 18D2 80 DUP1 18D3 51 MLOAD 18D4 60 PUSH1 0x00 18D6 03 SUB 18D7 61 PUSH2 0x18f3 18DA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @18CE stack[-2] = 0x60 } // Block ends with conditional jump to 0x18f3, if 0x00 - memory[0x60:0x80] label_18DB: // Incoming jump from 0x18DA, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x18DA, if not 0x00 - memory[0x60:0x80] // Inputs[3] // { // @18DD memory[0x40:0x60] // @18ED memory[0x40:0x60] // @18F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18DB 60 PUSH1 0x40 18DD 51 MLOAD 18DE 63 PUSH4 0x68d2bf6b 18E3 60 PUSH1 0xe1 18E5 1B SHL 18E6 81 DUP2 18E7 52 MSTORE 18E8 60 PUSH1 0x04 18EA 01 ADD 18EB 60 PUSH1 0x40 18ED 51 MLOAD 18EE 80 DUP1 18EF 91 SWAP2 18F0 03 SUB 18F1 90 SWAP1 18F2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @18F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18F3: // Incoming jump from 0x18DA, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x18DA, if 0x00 - memory[0x60:0x80] // Inputs[3] // { // @18F4 stack[-1] // @18F5 memory[stack[-1]:stack[-1] + 0x20] // @18FA memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 18F3 5B JUMPDEST 18F4 80 DUP1 18F5 51 MLOAD 18F6 81 DUP2 18F7 60 PUSH1 0x20 18F9 01 ADD 18FA FD *REVERT // Stack delta = +0 // Outputs[1] { @18FA revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_18FB: // Incoming jump from 0x18A1, if stack[-1] // Inputs[2] // { // @1905 stack[-1] // @190F stack[-2] // } 18FB 5B JUMPDEST 18FC 60 PUSH1 0x01 18FE 60 PUSH1 0x01 1900 60 PUSH1 0xe0 1902 1B SHL 1903 03 SUB 1904 19 NOT 1905 16 AND 1906 63 PUSH4 0x0a85bd01 190B 60 PUSH1 0xe1 190D 1B SHL 190E 14 EQ 190F 90 SWAP1 1910 50 POP // Stack delta = -1 // Outputs[1] { @190F stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1911: // Incoming return from call to 0x1EEC at 0x1F8C // Incoming jump from 0x1910 // Inputs[3] // { // @1912 stack[-6] // @1912 stack[-1] // @1913 stack[-5] // } 1911 5B JUMPDEST 1912 94 SWAP5 1913 93 SWAP4 1914 50 POP 1915 50 POP 1916 50 POP 1917 50 POP 1918 56 *JUMP // Stack delta = -5 // Outputs[1] { @1912 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1919: // Incoming jump from 0x1236 // Inputs[1] { @191F stack[-1] } 1919 5B JUMPDEST 191A 60 PUSH1 0x60 191C 61 PUSH2 0x1924 191F 82 DUP3 1920 61 PUSH2 0x13f9 1923 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @191A stack[0] = 0x60 // @191C stack[1] = 0x1924 // @191F stack[2] = stack[-1] // } // Block ends with call to 0x13f9, returns to 0x1924 label_1924: // Incoming return from call to 0x13F9 at 0x1923 // Inputs[1] { @1928 stack[-1] } 1924 5B JUMPDEST 1925 61 PUSH2 0x1941 1928 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1941, if stack[-1] label_1929: // Incoming jump from 0x1928, if not stack[-1] // Inputs[3] // { // @192B memory[0x40:0x60] // @193B memory[0x40:0x60] // @1940 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1929 60 PUSH1 0x40 192B 51 MLOAD 192C 63 PUSH4 0x0a14c4b5 1931 60 PUSH1 0xe4 1933 1B SHL 1934 81 DUP2 1935 52 MSTORE 1936 60 PUSH1 0x04 1938 01 ADD 1939 60 PUSH1 0x40 193B 51 MLOAD 193C 80 DUP1 193D 91 SWAP2 193E 03 SUB 193F 90 SWAP1 1940 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1935 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @1940 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1941: // Incoming jump from 0x1928, if stack[-1] 1941 5B JUMPDEST 1942 60 PUSH1 0x00 1944 61 PUSH2 0x194b 1947 61 PUSH2 0x19aa 194A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1942 stack[0] = 0x00 // @1944 stack[1] = 0x194b // } // Block ends with unconditional jump to 0x19aa 194B 5B JUMPDEST 194C 90 SWAP1 194D 50 POP 194E 80 DUP1 194F 51 MLOAD 1950 60 PUSH1 0x00 1952 03 SUB 1953 61 PUSH2 0x196b 1956 57 *JUMPI 1957 60 PUSH1 0x40 1959 51 MLOAD 195A 80 DUP1 195B 60 PUSH1 0x20 195D 01 ADD 195E 60 PUSH1 0x40 1960 52 MSTORE 1961 80 DUP1 1962 60 PUSH1 0x00 1964 81 DUP2 1965 52 MSTORE 1966 50 POP 1967 61 PUSH2 0x1996 196A 56 *JUMP 196B 5B JUMPDEST 196C 80 DUP1 196D 61 PUSH2 0x1975 1970 84 DUP5 1971 61 PUSH2 0x19b9 1974 56 *JUMP 1975 5B JUMPDEST 1976 60 PUSH1 0x40 1978 51 MLOAD 1979 60 PUSH1 0x20 197B 01 ADD 197C 61 PUSH2 0x1986 197F 92 SWAP3 1980 91 SWAP2 1981 90 SWAP1 1982 61 PUSH2 0x2381 1985 56 *JUMP 1986 5B JUMPDEST 1987 60 PUSH1 0x40 1989 51 MLOAD 198A 60 PUSH1 0x20 198C 81 DUP2 198D 83 DUP4 198E 03 SUB 198F 03 SUB 1990 81 DUP2 1991 52 MSTORE 1992 90 SWAP1 1993 60 PUSH1 0x40 1995 52 MSTORE label_1996: // Incoming return from call to 0x1CA4 at 0x2380 // Incoming return from call to 0x1CA4 at 0x1CD6 // Incoming return from call to 0x1D5B at 0x1DBB // Incoming jump from 0x209F, if msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 // Incoming return from call to 0x1D1C at 0x1D5A // Inputs[3] // { // @1997 stack[-5] // @1997 stack[-1] // @1998 stack[-4] // } 1996 5B JUMPDEST 1997 93 SWAP4 1998 92 SWAP3 1999 50 POP 199A 50 POP 199B 50 POP 199C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1997 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_199D: // Incoming jump from 0x182C // Inputs[3] // { // @19A1 stack[-3] // @19A2 stack[-2] // @19A3 stack[-1] // } 199D 5B JUMPDEST 199E 61 PUSH2 0x0a06 19A1 83 DUP4 19A2 83 DUP4 19A3 83 DUP4 19A4 60 PUSH1 0x01 19A6 61 PUSH2 0x1ad2 19A9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @199E stack[0] = 0x0a06 // @19A1 stack[1] = stack[-3] // @19A2 stack[2] = stack[-2] // @19A3 stack[3] = stack[-1] // @19A4 stack[4] = 0x01 // } // Block ends with call to 0x1ad2, returns to 0x0A06 label_19AA: // Incoming jump from 0x194A // Inputs[1] { @19B0 storage[0x11] } 19AA 5B JUMPDEST 19AB 60 PUSH1 0x60 19AD 60 PUSH1 0x11 19AF 80 DUP1 19B0 54 SLOAD 19B1 61 PUSH2 0x08b7 19B4 90 SWAP1 19B5 61 PUSH2 0x20d7 19B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19AB stack[0] = 0x60 // @19AD stack[1] = 0x11 // @19B4 stack[2] = 0x08b7 // @19B4 stack[3] = storage[0x11] // } // Block ends with call to 0x20d7, returns to 0x08B7 19B9 5B JUMPDEST 19BA 60 PUSH1 0x60 19BC 81 DUP2 19BD 60 PUSH1 0x00 19BF 03 SUB 19C0 61 PUSH2 0x19e0 19C3 57 *JUMPI 19C4 50 POP 19C5 50 POP 19C6 60 PUSH1 0x40 19C8 80 DUP1 19C9 51 MLOAD 19CA 80 DUP1 19CB 82 DUP3 19CC 01 ADD 19CD 90 SWAP1 19CE 91 SWAP2 19CF 52 MSTORE 19D0 60 PUSH1 0x01 19D2 81 DUP2 19D3 52 MSTORE 19D4 60 PUSH1 0x03 19D6 60 PUSH1 0xfc 19D8 1B SHL 19D9 60 PUSH1 0x20 19DB 82 DUP3 19DC 01 ADD 19DD 52 MSTORE 19DE 90 SWAP1 19DF 56 *JUMP 19E0 5B JUMPDEST 19E1 81 DUP2 19E2 60 PUSH1 0x00 19E4 5B JUMPDEST 19E5 81 DUP2 19E6 15 ISZERO 19E7 61 PUSH2 0x1a0a 19EA 57 *JUMPI 19EB 80 DUP1 19EC 61 PUSH2 0x19f4 19EF 81 DUP2 19F0 61 PUSH2 0x213d 19F3 56 *JUMP 19F4 5B JUMPDEST 19F5 91 SWAP2 19F6 50 POP 19F7 61 PUSH2 0x1a03 19FA 90 SWAP1 19FB 50 POP 19FC 60 PUSH1 0x0a 19FE 83 DUP4 19FF 61 PUSH2 0x23c6 1A02 56 *JUMP 1A03 5B JUMPDEST 1A04 91 SWAP2 1A05 50 POP 1A06 61 PUSH2 0x19e4 1A09 56 *JUMP 1A0A 5B JUMPDEST 1A0B 60 PUSH1 0x00 1A0D 81 DUP2 1A0E 67 PUSH8 0xffffffffffffffff 1A17 81 DUP2 1A18 11 GT 1A19 15 ISZERO 1A1A 61 PUSH2 0x1a25 1A1D 57 *JUMPI 1A1E 61 PUSH2 0x1a25 1A21 61 PUSH2 0x1dbc 1A24 56 *JUMP 1A25 5B JUMPDEST 1A26 60 PUSH1 0x40 1A28 51 MLOAD 1A29 90 SWAP1 1A2A 80 DUP1 1A2B 82 DUP3 1A2C 52 MSTORE 1A2D 80 DUP1 1A2E 60 PUSH1 0x1f 1A30 01 ADD 1A31 60 PUSH1 0x1f 1A33 19 NOT 1A34 16 AND 1A35 60 PUSH1 0x20 1A37 01 ADD 1A38 82 DUP3 1A39 01 ADD 1A3A 60 PUSH1 0x40 1A3C 52 MSTORE 1A3D 80 DUP1 1A3E 15 ISZERO 1A3F 61 PUSH2 0x1a4f 1A42 57 *JUMPI 1A43 60 PUSH1 0x20 1A45 82 DUP3 1A46 01 ADD 1A47 81 DUP2 1A48 80 DUP1 1A49 36 CALLDATASIZE 1A4A 83 DUP4 1A4B 37 CALLDATACOPY 1A4C 01 ADD 1A4D 90 SWAP1 1A4E 50 POP 1A4F 5B JUMPDEST 1A50 50 POP 1A51 90 SWAP1 1A52 50 POP 1A53 5B JUMPDEST 1A54 84 DUP5 1A55 15 ISZERO 1A56 61 PUSH2 0x1911 1A59 57 *JUMPI 1A5A 61 PUSH2 0x1a64 1A5D 60 PUSH1 0x01 1A5F 83 DUP4 1A60 61 PUSH2 0x23da 1A63 56 *JUMP 1A64 5B JUMPDEST 1A65 91 SWAP2 1A66 50 POP 1A67 61 PUSH2 0x1a71 1A6A 60 PUSH1 0x0a 1A6C 86 DUP7 1A6D 61 PUSH2 0x23f1 1A70 56 *JUMP 1A71 5B JUMPDEST 1A72 61 PUSH2 0x1a7c 1A75 90 SWAP1 1A76 60 PUSH1 0x30 1A78 61 PUSH2 0x2264 1A7B 56 *JUMP 1A7C 5B JUMPDEST 1A7D 60 PUSH1 0xf8 1A7F 1B SHL 1A80 81 DUP2 1A81 83 DUP4 1A82 81 DUP2 1A83 51 MLOAD 1A84 81 DUP2 1A85 10 LT 1A86 61 PUSH2 0x1a91 1A89 57 *JUMPI 1A8A 61 PUSH2 0x1a91 1A8D 61 PUSH2 0x2111 1A90 56 *JUMP 1A91 5B JUMPDEST 1A92 60 PUSH1 0x20 1A94 01 ADD 1A95 01 ADD 1A96 90 SWAP1 1A97 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1AB7 19 NOT 1AB8 16 AND 1AB9 90 SWAP1 1ABA 81 DUP2 1ABB 60 PUSH1 0x00 1ABD 1A BYTE 1ABE 90 SWAP1 1ABF 53 MSTORE8 1AC0 50 POP 1AC1 61 PUSH2 0x1acb 1AC4 60 PUSH1 0x0a 1AC6 86 DUP7 1AC7 61 PUSH2 0x23c6 1ACA 56 *JUMP 1ACB 5B JUMPDEST 1ACC 94 SWAP5 1ACD 50 POP 1ACE 61 PUSH2 0x1a53 1AD1 56 *JUMP label_1AD2: // Incoming call from 0x19A9, returns to 0x0A06 // Inputs[2] // { // @1AD5 storage[0x00] // @1ADE stack[-4] // } 1AD2 5B JUMPDEST 1AD3 60 PUSH1 0x00 1AD5 54 SLOAD 1AD6 60 PUSH1 0x01 1AD8 60 PUSH1 0x01 1ADA 60 PUSH1 0xa0 1ADC 1B SHL 1ADD 03 SUB 1ADE 85 DUP6 1ADF 16 AND 1AE0 61 PUSH2 0x1afb 1AE3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AD5 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1afb, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1AE4: // Incoming jump from 0x1AE3, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1AE6 memory[0x40:0x60] // @1AF5 memory[0x40:0x60] // @1AFA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AE4 60 PUSH1 0x40 1AE6 51 MLOAD 1AE7 62 PUSH3 0x2e0763 1AEB 60 PUSH1 0xe8 1AED 1B SHL 1AEE 81 DUP2 1AEF 52 MSTORE 1AF0 60 PUSH1 0x04 1AF2 01 ADD 1AF3 60 PUSH1 0x40 1AF5 51 MLOAD 1AF6 80 DUP1 1AF7 91 SWAP2 1AF8 03 SUB 1AF9 90 SWAP1 1AFA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1AFA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AFB: // Incoming jump from 0x1AE3, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1AFC stack[-4] } 1AFB 5B JUMPDEST 1AFC 83 DUP4 1AFD 60 PUSH1 0x00 1AFF 03 SUB 1B00 61 PUSH2 0x1b1c 1B03 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b1c, if 0x00 - stack[-4] label_1B04: // Incoming jump from 0x1B03, if not 0x00 - stack[-4] // Inputs[3] // { // @1B06 memory[0x40:0x60] // @1B16 memory[0x40:0x60] // @1B1B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B04 60 PUSH1 0x40 1B06 51 MLOAD 1B07 63 PUSH4 0xb562e8dd 1B0C 60 PUSH1 0xe0 1B0E 1B SHL 1B0F 81 DUP2 1B10 52 MSTORE 1B11 60 PUSH1 0x04 1B13 01 ADD 1B14 60 PUSH1 0x40 1B16 51 MLOAD 1B17 80 DUP1 1B18 91 SWAP2 1B19 03 SUB 1B1A 90 SWAP1 1B1B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1B1B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B1C: // Incoming jump from 0x1B03, if 0x00 - stack[-4] // Inputs[9] // { // @1B25 stack[-5] // @1B37 memory[0x00:0x40] // @1B39 storage[keccak256(memory[0x00:0x40])] // @1B5A stack[-4] // @1B8B stack[-1] // @1B95 memory[0x00:0x40] // @1B97 storage[keccak256(memory[0x00:0x40])] // @1BAA block.timestamp // @1BB9 stack[-2] // } 1B1C 5B JUMPDEST 1B1D 60 PUSH1 0x01 1B1F 60 PUSH1 0x01 1B21 60 PUSH1 0xa0 1B23 1B SHL 1B24 03 SUB 1B25 85 DUP6 1B26 16 AND 1B27 60 PUSH1 0x00 1B29 81 DUP2 1B2A 81 DUP2 1B2B 52 MSTORE 1B2C 60 PUSH1 0x05 1B2E 60 PUSH1 0x20 1B30 90 SWAP1 1B31 81 DUP2 1B32 52 MSTORE 1B33 60 PUSH1 0x40 1B35 80 DUP1 1B36 83 DUP4 1B37 20 SHA3 1B38 80 DUP1 1B39 54 SLOAD 1B3A 6F PUSH16 0xffffffffffffffffffffffffffffffff 1B4B 19 NOT 1B4C 81 DUP2 1B4D 16 AND 1B4E 67 PUSH8 0xffffffffffffffff 1B57 80 DUP1 1B58 83 DUP4 1B59 16 AND 1B5A 8C DUP13 1B5B 01 ADD 1B5C 81 DUP2 1B5D 16 AND 1B5E 91 SWAP2 1B5F 82 DUP3 1B60 17 OR 1B61 68 PUSH9 0x010000000000000000 1B6B 67 PUSH8 0xffffffffffffffff 1B74 19 NOT 1B75 90 SWAP1 1B76 94 SWAP5 1B77 16 AND 1B78 90 SWAP1 1B79 92 SWAP3 1B7A 17 OR 1B7B 83 DUP4 1B7C 90 SWAP1 1B7D 04 DIV 1B7E 81 DUP2 1B7F 16 AND 1B80 8C DUP13 1B81 01 ADD 1B82 81 DUP2 1B83 16 AND 1B84 90 SWAP1 1B85 92 SWAP3 1B86 02 MUL 1B87 17 OR 1B88 90 SWAP1 1B89 91 SWAP2 1B8A 55 SSTORE 1B8B 85 DUP6 1B8C 84 DUP5 1B8D 52 MSTORE 1B8E 60 PUSH1 0x04 1B90 90 SWAP1 1B91 92 SWAP3 1B92 52 MSTORE 1B93 90 SWAP1 1B94 91 SWAP2 1B95 20 SHA3 1B96 80 DUP1 1B97 54 SLOAD 1B98 60 PUSH1 0x01 1B9A 60 PUSH1 0x01 1B9C 60 PUSH1 0xe0 1B9E 1B SHL 1B9F 03 SUB 1BA0 19 NOT 1BA1 16 AND 1BA2 90 SWAP1 1BA3 92 SWAP3 1BA4 17 OR 1BA5 60 PUSH1 0x01 1BA7 60 PUSH1 0xa0 1BA9 1B SHL 1BAA 42 TIMESTAMP 1BAB 90 SWAP1 1BAC 92 SWAP3 1BAD 16 AND 1BAE 91 SWAP2 1BAF 90 SWAP1 1BB0 91 SWAP2 1BB1 02 MUL 1BB2 17 OR 1BB3 90 SWAP1 1BB4 55 SSTORE 1BB5 80 DUP1 1BB6 80 DUP1 1BB7 85 DUP6 1BB8 01 ADD 1BB9 83 DUP4 1BBA 80 DUP1 1BBB 15 ISZERO 1BBC 61 PUSH2 0x1bce 1BBF 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1B2B memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1B32 memory[0x20:0x40] = 0x05 // @1B8A storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-4] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1B8D memory[0x00:0x20] = stack[-1] // @1B92 memory[0x20:0x40] = 0x04 // @1BB4 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1BB5 stack[0] = stack[-1] // @1BB8 stack[1] = stack[-4] + stack[-1] // @1BB9 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1bce, if !stack[-2] label_1BC0: // Incoming jump from 0x1BBF, if not !stack[-2] // Inputs[2] // { // @1BC9 stack[-8] // @1BCB address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1BC0 50 POP 1BC1 60 PUSH1 0x01 1BC3 60 PUSH1 0x01 1BC5 60 PUSH1 0xa0 1BC7 1B SHL 1BC8 03 SUB 1BC9 87 DUP8 1BCA 16 AND 1BCB 3B EXTCODESIZE 1BCC 15 ISZERO 1BCD 15 ISZERO 1BCE 5B JUMPDEST 1BCF 15 ISZERO 1BD0 61 PUSH2 0x1c56 1BD3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c56, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1BD4: // Incoming jump from 0x1BD3, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1BD3, if not !stack[-1] // Inputs[5] // { // @1BD7 memory[0x40:0x60] // @1BD8 stack[-2] // @1BE2 stack[-7] // @1C0C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C1A stack[-5] // } 1BD4 5B JUMPDEST 1BD5 60 PUSH1 0x40 1BD7 51 MLOAD 1BD8 82 DUP3 1BD9 90 SWAP1 1BDA 60 PUSH1 0x01 1BDC 60 PUSH1 0x01 1BDE 60 PUSH1 0xa0 1BE0 1B SHL 1BE1 03 SUB 1BE2 89 DUP10 1BE3 16 AND 1BE4 90 SWAP1 1BE5 60 PUSH1 0x00 1BE7 90 SWAP1 1BE8 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1C09 90 SWAP1 1C0A 82 DUP3 1C0B 90 SWAP1 1C0C A4 LOG4 1C0D 61 PUSH2 0x1c1f 1C10 60 PUSH1 0x00 1C12 88 DUP9 1C13 84 DUP5 1C14 80 DUP1 1C15 60 PUSH1 0x01 1C17 01 ADD 1C18 95 SWAP6 1C19 50 POP 1C1A 88 DUP9 1C1B 61 PUSH2 0x182d 1C1E 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1C0C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1C0D stack[0] = 0x1c1f // @1C10 stack[1] = 0x00 // @1C12 stack[2] = stack[-7] // @1C13 stack[3] = stack[-2] // @1C18 stack[-2] = 0x01 + stack[-2] // @1C1A stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x182d 1C1F 5B JUMPDEST 1C20 61 PUSH2 0x1c3c 1C23 57 *JUMPI 1C24 60 PUSH1 0x40 1C26 51 MLOAD 1C27 63 PUSH4 0x68d2bf6b 1C2C 60 PUSH1 0xe1 1C2E 1B SHL 1C2F 81 DUP2 1C30 52 MSTORE 1C31 60 PUSH1 0x04 1C33 01 ADD 1C34 60 PUSH1 0x40 1C36 51 MLOAD 1C37 80 DUP1 1C38 91 SWAP2 1C39 03 SUB 1C3A 90 SWAP1 1C3B FD *REVERT 1C3C 5B JUMPDEST 1C3D 80 DUP1 1C3E 82 DUP3 1C3F 03 SUB 1C40 61 PUSH2 0x1bd4 1C43 57 *JUMPI 1C44 82 DUP3 1C45 60 PUSH1 0x00 1C47 54 SLOAD 1C48 14 EQ 1C49 61 PUSH2 0x1c51 1C4C 57 *JUMPI 1C4D 60 PUSH1 0x00 1C4F 80 DUP1 1C50 FD *REVERT 1C51 5B JUMPDEST 1C52 61 PUSH2 0x1c9b 1C55 56 *JUMP label_1C56: // Incoming jump from 0x1BD3, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1BD3, if !stack[-1] // Inputs[5] // { // @1C5A memory[0x40:0x60] // @1C5D stack[-2] // @1C69 stack[-7] // @1C93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C94 stack[-1] // } 1C56 5B JUMPDEST 1C57 5B JUMPDEST 1C58 60 PUSH1 0x40 1C5A 51 MLOAD 1C5B 60 PUSH1 0x01 1C5D 83 DUP4 1C5E 01 ADD 1C5F 92 SWAP3 1C60 90 SWAP1 1C61 60 PUSH1 0x01 1C63 60 PUSH1 0x01 1C65 60 PUSH1 0xa0 1C67 1B SHL 1C68 03 SUB 1C69 89 DUP10 1C6A 16 AND 1C6B 90 SWAP1 1C6C 60 PUSH1 0x00 1C6E 90 SWAP1 1C6F 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1C90 90 SWAP1 1C91 82 DUP3 1C92 90 SWAP1 1C93 A4 LOG4 1C94 80 DUP1 1C95 82 DUP3 1C96 03 SUB 1C97 61 PUSH2 0x1c57 1C9A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1C5F stack[-2] = stack[-2] + 0x01 // @1C93 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1c57, if (stack[-2] + 0x01) - stack[-1] label_1C9B: // Incoming jump from 0x1C9A, if not (stack[-2] + 0x01) - stack[-1] // Incoming jump from 0x1C9A, if not (stack[-2] + 0x01) - stack[-1] // Inputs[1] { @1C9F stack[-2] } 1C9B 5B JUMPDEST 1C9C 50 POP 1C9D 60 PUSH1 0x00 1C9F 55 SSTORE 1CA0 61 PUSH2 0x1684 1CA3 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C9F storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1684 label_1CA4: // Incoming call from 0x1CD6, returns to 0x1996 // Incoming call from 0x2380, returns to 0x1996 // Inputs[1] { @1CAE stack[-1] } 1CA4 5B JUMPDEST 1CA5 60 PUSH1 0x01 1CA7 60 PUSH1 0x01 1CA9 60 PUSH1 0xe0 1CAB 1B SHL 1CAC 03 SUB 1CAD 19 NOT 1CAE 81 DUP2 1CAF 16 AND 1CB0 81 DUP2 1CB1 14 EQ 1CB2 61 PUSH2 0x0b7b 1CB5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b7b, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1CB6: // Incoming jump from 0x1CB5, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1CB9 memory[0x00:0x00] } 1CB6 60 PUSH1 0x00 1CB8 80 DUP1 1CB9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB9 revert(memory[0x00:0x00]); } // Block terminates label_1CBA: // Incoming jump from 0x02E5 // Inputs[2] // { // @1CBF stack[-1] // @1CC0 stack[-2] // } 1CBA 5B JUMPDEST 1CBB 60 PUSH1 0x00 1CBD 60 PUSH1 0x20 1CBF 82 DUP3 1CC0 84 DUP5 1CC1 03 SUB 1CC2 12 SLT 1CC3 15 ISZERO 1CC4 61 PUSH2 0x1ccc 1CC7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CBB stack[0] = 0x00 } // Block ends with conditional jump to 0x1ccc, if !(stack[-2] - stack[-1] i< 0x20) label_1CC8: // Incoming jump from 0x1CC7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CCB memory[0x00:0x00] } 1CC8 60 PUSH1 0x00 1CCA 80 DUP1 1CCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CCB revert(memory[0x00:0x00]); } // Block terminates label_1CCC: // Incoming jump from 0x1CC7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1CCD stack[-2] // @1CCE msg.data[stack[-2]:stack[-2] + 0x20] // } 1CCC 5B JUMPDEST 1CCD 81 DUP2 1CCE 35 CALLDATALOAD 1CCF 61 PUSH2 0x1996 1CD2 81 DUP2 1CD3 61 PUSH2 0x1ca4 1CD6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CCE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1CCF stack[1] = 0x1996 // @1CD2 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1ca4, returns to 0x1996 label_1CD7: // Incoming call from 0x0734, returns to 0x0735 // Incoming call from 0x0501, returns to 0x0502 // Incoming call from 0x058B, returns to 0x058C // Incoming call from 0x033E, returns to 0x033F // Incoming call from 0x04C1, returns to 0x04C2 // Incoming call from 0x05AB, returns to 0x05AC // Incoming call from 0x0382, returns to 0x0383 // Incoming call from 0x0661, returns to 0x0662 // Incoming call from 0x05BE, returns to 0x05BF // Inputs[2] // { // @1CDC stack[-1] // @1CDD stack[-2] // } 1CD7 5B JUMPDEST 1CD8 60 PUSH1 0x00 1CDA 60 PUSH1 0x20 1CDC 82 DUP3 1CDD 84 DUP5 1CDE 03 SUB 1CDF 12 SLT 1CE0 15 ISZERO 1CE1 61 PUSH2 0x1ce9 1CE4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CD8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ce9, if !(stack[-2] - stack[-1] i< 0x20) label_1CE5: // Incoming jump from 0x1CE4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CE8 memory[0x00:0x00] } 1CE5 60 PUSH1 0x00 1CE7 80 DUP1 1CE8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CE8 revert(memory[0x00:0x00]); } // Block terminates label_1CE9: // Incoming jump from 0x1CE4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1CEB msg.data[stack[-2]:stack[-2] + 0x20] // @1CEB stack[-2] // @1CEC stack[-4] // @1CED stack[-3] // } 1CE9 5B JUMPDEST 1CEA 50 POP 1CEB 35 CALLDATALOAD 1CEC 91 SWAP2 1CED 90 SWAP1 1CEE 50 POP 1CEF 56 *JUMP // Stack delta = -3 // Outputs[1] { @1CEC stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1CF0: // Incoming call from 0x1D33, returns to 0x1D34 // Inputs[1] { @1CF4 stack[-3] } 1CF0 5B JUMPDEST 1CF1 60 PUSH1 0x00 1CF3 5B JUMPDEST 1CF4 83 DUP4 1CF5 81 DUP2 1CF6 10 LT 1CF7 15 ISZERO 1CF8 61 PUSH2 0x1d0b 1CFB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CF1 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d0b, if !(0x00 < stack[-3]) label_1CFC: // Incoming jump from 0x1CFB, if not !(0x00 < stack[-3]) // Incoming jump from 0x1CFB, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1CFC stack[-2] // @1CFD stack[-1] // @1CFF memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D00 stack[-3] // } 1CFC 81 DUP2 1CFD 81 DUP2 1CFE 01 ADD 1CFF 51 MLOAD 1D00 83 DUP4 1D01 82 DUP3 1D02 01 ADD 1D03 52 MSTORE 1D04 60 PUSH1 0x20 1D06 01 ADD 1D07 61 PUSH2 0x1cf3 1D0A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D03 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D06 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1cf3 label_1D0B: // Incoming jump from 0x1CFB, if !(0x00 < stack[-3]) // Incoming jump from 0x1CFB, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1D0C stack[-4] // @1D0D stack[-1] // } 1D0B 5B JUMPDEST 1D0C 83 DUP4 1D0D 81 DUP2 1D0E 11 GT 1D0F 15 ISZERO 1D10 61 PUSH2 0x11b7 1D13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11b7, if !(stack[-1] > stack[-4]) label_1D14: // Incoming jump from 0x1D13, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1D18 stack[-4] // @1D19 stack[-3] // @1D1B stack[-5] // } 1D14 50 POP 1D15 50 POP 1D16 60 PUSH1 0x00 1D18 91 SWAP2 1D19 01 ADD 1D1A 52 MSTORE 1D1B 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D1A memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1D1C: // Incoming call from 0x1D5A, returns to 0x1996 // Incoming call from 0x2359, returns to 0x235A // Inputs[3] // { // @1D1F stack[-1] // @1D20 memory[stack[-1]:stack[-1] + 0x20] // @1D22 stack[-2] // } 1D1C 5B JUMPDEST 1D1D 60 PUSH1 0x00 1D1F 81 DUP2 1D20 51 MLOAD 1D21 80 DUP1 1D22 84 DUP5 1D23 52 MSTORE 1D24 61 PUSH2 0x1d34 1D27 81 DUP2 1D28 60 PUSH1 0x20 1D2A 86 DUP7 1D2B 01 ADD 1D2C 60 PUSH1 0x20 1D2E 86 DUP7 1D2F 01 ADD 1D30 61 PUSH2 0x1cf0 1D33 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1D1D stack[0] = 0x00 // @1D20 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1D23 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1D24 stack[2] = 0x1d34 // @1D27 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1D2B stack[4] = stack[-2] + 0x20 // @1D2F stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1cf0, returns to 0x1D34 label_1D34: // Incoming return from call to 0x1CF0 at 0x1D33 // Inputs[4] // { // @1D37 stack[-1] // @1D3C stack[-4] // @1D3D stack[-2] // @1D43 stack[-5] // } 1D34 5B JUMPDEST 1D35 60 PUSH1 0x1f 1D37 01 ADD 1D38 60 PUSH1 0x1f 1D3A 19 NOT 1D3B 16 AND 1D3C 92 SWAP3 1D3D 90 SWAP1 1D3E 92 SWAP3 1D3F 01 ADD 1D40 60 PUSH1 0x20 1D42 01 ADD 1D43 92 SWAP3 1D44 91 SWAP2 1D45 50 POP 1D46 50 POP 1D47 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D43 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1D48: // Incoming jump from 0x0367 // Inputs[2] // { // @1D4B stack[-1] // @1D56 stack[-2] // } 1D48 5B JUMPDEST 1D49 60 PUSH1 0x20 1D4B 81 DUP2 1D4C 52 MSTORE 1D4D 60 PUSH1 0x00 1D4F 61 PUSH2 0x1996 1D52 60 PUSH1 0x20 1D54 83 DUP4 1D55 01 ADD 1D56 84 DUP5 1D57 61 PUSH2 0x1d1c 1D5A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1D4C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1D4D stack[0] = 0x00 // @1D4F stack[1] = 0x1996 // @1D55 stack[2] = stack[-1] + 0x20 // @1D56 stack[3] = stack[-2] // } // Block ends with call to 0x1d1c, returns to 0x1996 label_1D5B: // Incoming call from 0x2025, returns to 0x2026 // Incoming call from 0x1DBB, returns to 0x1996 // Incoming call from 0x1FA8, returns to 0x1FA9 // Incoming call from 0x2033, returns to 0x2034 // Incoming call from 0x1ECD, returns to 0x1ECE // Incoming call from 0x1E94, returns to 0x1E95 // Incoming call from 0x20BF, returns to 0x20C0 // Incoming call from 0x1D92, returns to 0x1D93 // Incoming call from 0x1EDB, returns to 0x1EDC // Incoming call from 0x20CD, returns to 0x20CE // Inputs[2] // { // @1D5C stack[-1] // @1D5D msg.data[stack[-1]:stack[-1] + 0x20] // } 1D5B 5B JUMPDEST 1D5C 80 DUP1 1D5D 35 CALLDATALOAD 1D5E 60 PUSH1 0x01 1D60 60 PUSH1 0x01 1D62 60 PUSH1 0xa0 1D64 1B SHL 1D65 03 SUB 1D66 81 DUP2 1D67 16 AND 1D68 81 DUP2 1D69 14 EQ 1D6A 61 PUSH2 0x1d72 1D6D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D5D stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1d72, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1D6E: // Incoming jump from 0x1D6D, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1D71 memory[0x00:0x00] } 1D6E 60 PUSH1 0x00 1D70 80 DUP1 1D71 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D71 revert(memory[0x00:0x00]); } // Block terminates label_1D72: // Incoming jump from 0x1D6D, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1D73 stack[-3] // @1D73 stack[-1] // @1D74 stack[-2] // } 1D72 5B JUMPDEST 1D73 91 SWAP2 1D74 90 SWAP1 1D75 50 POP 1D76 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D73 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1D77: // Incoming call from 0x03BA, returns to 0x03BB // Inputs[2] // { // @1D7D stack[-1] // @1D7E stack[-2] // } 1D77 5B JUMPDEST 1D78 60 PUSH1 0x00 1D7A 80 DUP1 1D7B 60 PUSH1 0x40 1D7D 83 DUP4 1D7E 85 DUP6 1D7F 03 SUB 1D80 12 SLT 1D81 15 ISZERO 1D82 61 PUSH2 0x1d8a 1D85 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D78 stack[0] = 0x00 // @1D7A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d8a, if !(stack[-2] - stack[-1] i< 0x40) label_1D86: // Incoming jump from 0x1D85, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D89 memory[0x00:0x00] } 1D86 60 PUSH1 0x00 1D88 80 DUP1 1D89 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D89 revert(memory[0x00:0x00]); } // Block terminates label_1D8A: // Incoming jump from 0x1D85, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D8E stack[-3] } 1D8A 5B JUMPDEST 1D8B 61 PUSH2 0x1d93 1D8E 83 DUP4 1D8F 61 PUSH2 0x1d5b 1D92 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D8B stack[0] = 0x1d93 // @1D8E stack[1] = stack[-3] // } // Block ends with call to 0x1d5b, returns to 0x1D93 label_1D93: // Incoming return from call to 0x1D5B at 0x1D92 // Inputs[5] // { // @1D94 stack[-6] // @1D94 stack[-1] // @1D97 stack[-4] // @1D9B msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1D9C stack[-5] // } 1D93 5B JUMPDEST 1D94 94 SWAP5 1D95 60 PUSH1 0x20 1D97 93 SWAP4 1D98 90 SWAP1 1D99 93 SWAP4 1D9A 01 ADD 1D9B 35 CALLDATALOAD 1D9C 93 SWAP4 1D9D 50 POP 1D9E 50 POP 1D9F 50 POP 1DA0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D94 stack[-6] = stack[-1] // @1D9C stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1DA1: // Incoming jump from 0x0611 // Incoming jump from 0x0536 // Incoming jump from 0x041F // Incoming jump from 0x063E // Incoming jump from 0x07C8 // Inputs[2] // { // @1DA6 stack[-1] // @1DA7 stack[-2] // } 1DA1 5B JUMPDEST 1DA2 60 PUSH1 0x00 1DA4 60 PUSH1 0x20 1DA6 82 DUP3 1DA7 84 DUP5 1DA8 03 SUB 1DA9 12 SLT 1DAA 15 ISZERO 1DAB 61 PUSH2 0x1db3 1DAE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DA2 stack[0] = 0x00 } // Block ends with conditional jump to 0x1db3, if !(stack[-2] - stack[-1] i< 0x20) label_1DAF: // Incoming jump from 0x1DAE, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DB2 memory[0x00:0x00] } 1DAF 60 PUSH1 0x00 1DB1 80 DUP1 1DB2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DB2 revert(memory[0x00:0x00]); } // Block terminates label_1DB3: // Incoming jump from 0x1DAE, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1DB7 stack[-2] } 1DB3 5B JUMPDEST 1DB4 61 PUSH2 0x1996 1DB7 82 DUP3 1DB8 61 PUSH2 0x1d5b 1DBB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DB4 stack[0] = 0x1996 // @1DB7 stack[1] = stack[-2] // } // Block ends with call to 0x1d5b, returns to 0x1996 label_1DBC: // Incoming jump from 0x21BD // Incoming jump from 0x1E53 // Incoming jump from 0x1F05 // Incoming jump from 0x1DFA // Inputs[1] { @1DD1 memory[0x00:0x24] } 1DBC 5B JUMPDEST 1DBD 63 PUSH4 0x4e487b71 1DC2 60 PUSH1 0xe0 1DC4 1B SHL 1DC5 60 PUSH1 0x00 1DC7 52 MSTORE 1DC8 60 PUSH1 0x41 1DCA 60 PUSH1 0x04 1DCC 52 MSTORE 1DCD 60 PUSH1 0x24 1DCF 60 PUSH1 0x00 1DD1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1DC7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1DCC memory[0x04:0x24] = 0x41 // @1DD1 revert(memory[0x00:0x24]); // } // Block terminates label_1DD2: // Incoming call from 0x1E64, returns to 0x1E65 // Incoming call from 0x1F18, returns to 0x1F19 // Inputs[2] // { // @1DD5 memory[0x40:0x60] // @1DD8 stack[-1] // } 1DD2 5B JUMPDEST 1DD3 60 PUSH1 0x40 1DD5 51 MLOAD 1DD6 60 PUSH1 0x1f 1DD8 82 DUP3 1DD9 01 ADD 1DDA 60 PUSH1 0x1f 1DDC 19 NOT 1DDD 16 AND 1DDE 81 DUP2 1DDF 01 ADD 1DE0 67 PUSH8 0xffffffffffffffff 1DE9 81 DUP2 1DEA 11 GT 1DEB 82 DUP3 1DEC 82 DUP3 1DED 10 LT 1DEE 17 OR 1DEF 15 ISZERO 1DF0 61 PUSH2 0x1dfb 1DF3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DD5 stack[0] = memory[0x40:0x60] // @1DDF stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x1dfb, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_1DF4: // Incoming jump from 0x1DF3, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 1DF4 61 PUSH2 0x1dfb 1DF7 61 PUSH2 0x1dbc 1DFA 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DF4 stack[0] = 0x1dfb } // Block ends with unconditional jump to 0x1dbc label_1DFB: // Incoming jump from 0x1DF3, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @1DFE stack[-1] // @1DFF stack[-4] // @1DFF stack[-2] // @1E00 stack[-3] // } 1DFB 5B JUMPDEST 1DFC 60 PUSH1 0x40 1DFE 52 MSTORE 1DFF 91 SWAP2 1E00 90 SWAP1 1E01 50 POP 1E02 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1DFE memory[0x40:0x60] = stack[-1] // @1DFF stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_1E03: // Incoming call from 0x07E8, returns to 0x07E9 // Incoming call from 0x044C, returns to 0x044D // Inputs[2] // { // @1E09 stack[-1] // @1E0A stack[-2] // } 1E03 5B JUMPDEST 1E04 60 PUSH1 0x00 1E06 60 PUSH1 0x20 1E08 80 DUP1 1E09 83 DUP4 1E0A 85 DUP6 1E0B 03 SUB 1E0C 12 SLT 1E0D 15 ISZERO 1E0E 61 PUSH2 0x1e16 1E11 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E04 stack[0] = 0x00 // @1E06 stack[1] = 0x20 // } // Block ends with conditional jump to 0x1e16, if !(stack[-2] - stack[-1] i< 0x20) label_1E12: // Incoming jump from 0x1E11, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E15 memory[0x00:0x00] } 1E12 60 PUSH1 0x00 1E14 80 DUP1 1E15 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E15 revert(memory[0x00:0x00]); } // Block terminates label_1E16: // Incoming jump from 0x1E11, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E17 stack[-3] // @1E18 msg.data[stack[-3]:stack[-3] + 0x20] // } 1E16 5B JUMPDEST 1E17 82 DUP3 1E18 35 CALLDATALOAD 1E19 67 PUSH8 0xffffffffffffffff 1E22 80 DUP1 1E23 82 DUP3 1E24 11 GT 1E25 15 ISZERO 1E26 61 PUSH2 0x1e2e 1E29 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E18 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1E19 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1e2e, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1E2A: // Incoming jump from 0x1E29, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1E2D memory[0x00:0x00] } 1E2A 60 PUSH1 0x00 1E2C 80 DUP1 1E2D FD *REVERT // Stack delta = +0 // Outputs[1] { @1E2D revert(memory[0x00:0x00]); } // Block terminates label_1E2E: // Incoming jump from 0x1E29, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E2F stack[-2] // @1E30 stack[-5] // @1E34 stack[-6] // } 1E2E 5B JUMPDEST 1E2F 81 DUP2 1E30 85 DUP6 1E31 01 ADD 1E32 91 SWAP2 1E33 50 POP 1E34 85 DUP6 1E35 60 PUSH1 0x1f 1E37 83 DUP4 1E38 01 ADD 1E39 12 SLT 1E3A 61 PUSH2 0x1e42 1E3D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E32 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1e42, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1E3E: // Incoming jump from 0x1E3D, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1E41 memory[0x00:0x00] } 1E3E 60 PUSH1 0x00 1E40 80 DUP1 1E41 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E41 revert(memory[0x00:0x00]); } // Block terminates label_1E42: // Incoming jump from 0x1E3D, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1E43 stack[-2] // @1E44 msg.data[stack[-2]:stack[-2] + 0x20] // @1E45 stack[-1] // } 1E42 5B JUMPDEST 1E43 81 DUP2 1E44 35 CALLDATALOAD 1E45 81 DUP2 1E46 81 DUP2 1E47 11 GT 1E48 15 ISZERO 1E49 61 PUSH2 0x1e54 1E4C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E44 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e54, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1E4D: // Incoming jump from 0x1E4C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 1E4D 61 PUSH2 0x1e54 1E50 61 PUSH2 0x1dbc 1E53 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E4D stack[0] = 0x1e54 } // Block ends with unconditional jump to 0x1dbc label_1E54: // Incoming jump from 0x1E4C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1E55 stack[-1] // @1E59 stack[-2] // @1E5E stack[-4] // } 1E54 5B JUMPDEST 1E55 80 DUP1 1E56 60 PUSH1 0x05 1E58 1B SHL 1E59 91 SWAP2 1E5A 50 POP 1E5B 61 PUSH2 0x1e65 1E5E 84 DUP5 1E5F 83 DUP4 1E60 01 ADD 1E61 61 PUSH2 0x1dd2 1E64 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E59 stack[-2] = stack[-1] << 0x05 // @1E5B stack[0] = 0x1e65 // @1E60 stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x1dd2, returns to 0x1E65 label_1E65: // Incoming return from call to 0x1DD2 at 0x1E64 // Inputs[6] // { // @1E66 stack[-2] // @1E67 stack[-1] // @1E69 stack[-3] // @1E6A stack[-4] // @1E6C stack[-5] // @1E73 stack[-8] // } 1E65 5B JUMPDEST 1E66 81 DUP2 1E67 81 DUP2 1E68 52 MSTORE 1E69 91 SWAP2 1E6A 83 DUP4 1E6B 01 ADD 1E6C 84 DUP5 1E6D 01 ADD 1E6E 91 SWAP2 1E6F 84 DUP5 1E70 81 DUP2 1E71 01 ADD 1E72 90 SWAP1 1E73 88 DUP9 1E74 84 DUP5 1E75 11 GT 1E76 15 ISZERO 1E77 61 PUSH2 0x1e7f 1E7A 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1E68 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1E6E stack[-3] = stack[-5] + stack[-4] + stack[-3] // @1E72 stack[-1] = stack[-1] + stack[-5] // @1E72 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x1e7f, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_1E7B: // Incoming jump from 0x1E7A, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @1E7E memory[0x00:0x00] } 1E7B 60 PUSH1 0x00 1E7D 80 DUP1 1E7E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E7E revert(memory[0x00:0x00]); } // Block terminates label_1E7F: // Incoming jump from 0x1E7A, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @1E80 stack[-5] // @1E80 stack[-1] // @1E81 stack[-6] // @1E85 stack[-4] // } 1E7F 5B JUMPDEST 1E80 93 SWAP4 1E81 85 DUP6 1E82 01 ADD 1E83 93 SWAP4 1E84 5B JUMPDEST 1E85 83 DUP4 1E86 85 DUP6 1E87 10 LT 1E88 15 ISZERO 1E89 61 PUSH2 0x1ea4 1E8C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E83 stack[-5] = stack[-6] + stack[-5] // @1E83 stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x1ea4, if !(stack[-6] + stack[-5] < stack[-4]) label_1E8D: // Incoming jump from 0x1E8C, if not !(stack[-5] < stack[-4]) // Incoming jump from 0x1E8C, if not !(stack[-6] + stack[-5] < stack[-4]) // Inputs[1] { @1E90 stack[-5] } 1E8D 61 PUSH2 0x1e95 1E90 85 DUP6 1E91 61 PUSH2 0x1d5b 1E94 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E8D stack[0] = 0x1e95 // @1E90 stack[1] = stack[-5] // } // Block ends with call to 0x1d5b, returns to 0x1E95 label_1E95: // Incoming return from call to 0x1D5B at 0x1E94 // Inputs[5] // { // @1E96 stack[-3] // @1E97 stack[-1] // @1E98 stack[-2] // @1E98 stack[-6] // @1E99 stack[-7] // } 1E95 5B JUMPDEST 1E96 82 DUP3 1E97 52 MSTORE 1E98 93 SWAP4 1E99 85 DUP6 1E9A 01 ADD 1E9B 93 SWAP4 1E9C 90 SWAP1 1E9D 85 DUP6 1E9E 01 ADD 1E9F 90 SWAP1 1EA0 61 PUSH2 0x1e84 1EA3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1E97 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1E9B stack[-6] = stack[-7] + stack[-6] // @1E9F stack[-2] = stack[-2] // @1E9F stack[-3] = stack[-7] + stack[-3] // } // Block ends with unconditional jump to 0x1e84 label_1EA4: // Incoming jump from 0x1E8C, if !(stack[-5] < stack[-4]) // Incoming jump from 0x1E8C, if !(stack[-6] + stack[-5] < stack[-4]) // Inputs[3] // { // @1EA5 stack[-1] // @1EA5 stack[-10] // @1EA6 stack[-9] // } 1EA4 5B JUMPDEST 1EA5 98 SWAP9 1EA6 97 SWAP8 1EA7 50 POP 1EA8 50 POP 1EA9 50 POP 1EAA 50 POP 1EAB 50 POP 1EAC 50 POP 1EAD 50 POP 1EAE 50 POP 1EAF 56 *JUMP // Stack delta = -9 // Outputs[1] { @1EA5 stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_1EB0: // Incoming call from 0x04A1, returns to 0x04A2 // Incoming call from 0x046C, returns to 0x046D // Inputs[2] // { // @1EB8 stack[-1] // @1EB9 stack[-2] // } 1EB0 5B JUMPDEST 1EB1 60 PUSH1 0x00 1EB3 80 DUP1 1EB4 60 PUSH1 0x00 1EB6 60 PUSH1 0x60 1EB8 84 DUP5 1EB9 86 DUP7 1EBA 03 SUB 1EBB 12 SLT 1EBC 15 ISZERO 1EBD 61 PUSH2 0x1ec5 1EC0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1EB1 stack[0] = 0x00 // @1EB3 stack[1] = 0x00 // @1EB4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ec5, if !(stack[-2] - stack[-1] i< 0x60) label_1EC1: // Incoming jump from 0x1EC0, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1EC4 memory[0x00:0x00] } 1EC1 60 PUSH1 0x00 1EC3 80 DUP1 1EC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EC4 revert(memory[0x00:0x00]); } // Block terminates label_1EC5: // Incoming jump from 0x1EC0, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1EC9 stack[-4] } 1EC5 5B JUMPDEST 1EC6 61 PUSH2 0x1ece 1EC9 84 DUP5 1ECA 61 PUSH2 0x1d5b 1ECD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1EC6 stack[0] = 0x1ece // @1EC9 stack[1] = stack[-4] // } // Block ends with call to 0x1d5b, returns to 0x1ECE label_1ECE: // Incoming return from call to 0x1D5B at 0x1ECD // Inputs[3] // { // @1ECF stack[-1] // @1ECF stack[-4] // @1ED6 stack[-5] // } 1ECE 5B JUMPDEST 1ECF 92 SWAP3 1ED0 50 POP 1ED1 61 PUSH2 0x1edc 1ED4 60 PUSH1 0x20 1ED6 85 DUP6 1ED7 01 ADD 1ED8 61 PUSH2 0x1d5b 1EDB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1ECF stack[-4] = stack[-1] // @1ED1 stack[-1] = 0x1edc // @1ED7 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1d5b, returns to 0x1EDC label_1EDC: // Incoming return from call to 0x1D5B at 0x1EDB // Inputs[8] // { // @1EDD stack[-3] // @1EDD stack[-1] // @1EE1 stack[-5] // @1EE3 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1EE4 stack[-2] // @1EE8 stack[-6] // @1EEA stack[-4] // @1EEA stack[-7] // } 1EDC 5B JUMPDEST 1EDD 91 SWAP2 1EDE 50 POP 1EDF 60 PUSH1 0x40 1EE1 84 DUP5 1EE2 01 ADD 1EE3 35 CALLDATALOAD 1EE4 90 SWAP1 1EE5 50 POP 1EE6 92 SWAP3 1EE7 50 POP 1EE8 92 SWAP3 1EE9 50 POP 1EEA 92 SWAP3 1EEB 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1EE6 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1EE8 stack[-6] = stack[-1] // @1EEA stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1EEC: // Incoming call from 0x1F8C, returns to 0x1911 // Incoming call from 0x2076, returns to 0x2077 // Inputs[1] { @1EF8 stack[-2] } 1EEC 5B JUMPDEST 1EED 60 PUSH1 0x00 1EEF 67 PUSH8 0xffffffffffffffff 1EF8 83 DUP4 1EF9 11 GT 1EFA 15 ISZERO 1EFB 61 PUSH2 0x1f06 1EFE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EED stack[0] = 0x00 } // Block ends with conditional jump to 0x1f06, if !(stack[-2] > 0xffffffffffffffff) label_1EFF: // Incoming jump from 0x1EFE, if not !(stack[-2] > 0xffffffffffffffff) 1EFF 61 PUSH2 0x1f06 1F02 61 PUSH2 0x1dbc 1F05 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EFF stack[0] = 0x1f06 } // Block ends with unconditional jump to 0x1dbc label_1F06: // Incoming jump from 0x1EFE, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @1F0C stack[-3] } 1F06 5B JUMPDEST 1F07 61 PUSH2 0x1f19 1F0A 60 PUSH1 0x1f 1F0C 84 DUP5 1F0D 01 ADD 1F0E 60 PUSH1 0x1f 1F10 19 NOT 1F11 16 AND 1F12 60 PUSH1 0x20 1F14 01 ADD 1F15 61 PUSH2 0x1dd2 1F18 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F07 stack[0] = 0x1f19 // @1F14 stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x1dd2, returns to 0x1F19 label_1F19: // Incoming return from call to 0x1DD2 at 0x1F18 // Inputs[5] // { // @1F1A stack[-2] // @1F1A stack[-1] // @1F1C stack[-4] // @1F1F stack[-5] // @1F21 stack[-3] // } 1F19 5B JUMPDEST 1F1A 90 SWAP1 1F1B 50 POP 1F1C 82 DUP3 1F1D 81 DUP2 1F1E 52 MSTORE 1F1F 83 DUP4 1F20 83 DUP4 1F21 83 DUP4 1F22 01 ADD 1F23 11 GT 1F24 15 ISZERO 1F25 61 PUSH2 0x1f2d 1F28 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1F1A stack[-2] = stack[-1] // @1F1E memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x1f2d, if !(stack[-3] + stack[-4] > stack[-5]) label_1F29: // Incoming jump from 0x1F28, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1F2C memory[0x00:0x00] } 1F29 60 PUSH1 0x00 1F2B 80 DUP1 1F2C FD *REVERT // Stack delta = +0 // Outputs[1] { @1F2C revert(memory[0x00:0x00]); } // Block terminates label_1F2D: // Incoming jump from 0x1F28, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @1F2E stack[-3] // @1F2F stack[-2] // @1F32 stack[-1] // @1F34 msg.data[stack[-2]:stack[-2] + stack[-3]] // @1F3E stack[-5] // @1F3F stack[-4] // } 1F2D 5B JUMPDEST 1F2E 82 DUP3 1F2F 82 DUP3 1F30 60 PUSH1 0x20 1F32 83 DUP4 1F33 01 ADD 1F34 37 CALLDATACOPY 1F35 60 PUSH1 0x00 1F37 60 PUSH1 0x20 1F39 84 DUP5 1F3A 83 DUP4 1F3B 01 ADD 1F3C 01 ADD 1F3D 52 MSTORE 1F3E 93 SWAP4 1F3F 92 SWAP3 1F40 50 POP 1F41 50 POP 1F42 50 POP 1F43 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1F34 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @1F3D memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @1F3E stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_1F44: // Incoming call from 0x04E1, returns to 0x04E2 // Incoming call from 0x056B, returns to 0x056C // Inputs[2] // { // @1F49 stack[-1] // @1F4A stack[-2] // } 1F44 5B JUMPDEST 1F45 60 PUSH1 0x00 1F47 60 PUSH1 0x20 1F49 82 DUP3 1F4A 84 DUP5 1F4B 03 SUB 1F4C 12 SLT 1F4D 15 ISZERO 1F4E 61 PUSH2 0x1f56 1F51 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F45 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f56, if !(stack[-2] - stack[-1] i< 0x20) label_1F52: // Incoming jump from 0x1F51, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F55 memory[0x00:0x00] } 1F52 60 PUSH1 0x00 1F54 80 DUP1 1F55 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F55 revert(memory[0x00:0x00]); } // Block terminates label_1F56: // Incoming jump from 0x1F51, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F57 stack[-2] // @1F58 msg.data[stack[-2]:stack[-2] + 0x20] // } 1F56 5B JUMPDEST 1F57 81 DUP2 1F58 35 CALLDATALOAD 1F59 67 PUSH8 0xffffffffffffffff 1F62 81 DUP2 1F63 11 GT 1F64 15 ISZERO 1F65 61 PUSH2 0x1f6d 1F68 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F58 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1f6d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1F69: // Incoming jump from 0x1F68, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1F6C memory[0x00:0x00] } 1F69 60 PUSH1 0x00 1F6B 80 DUP1 1F6C FD *REVERT // Stack delta = +0 // Outputs[1] { @1F6C revert(memory[0x00:0x00]); } // Block terminates label_1F6D: // Incoming jump from 0x1F68, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1F6E stack[-3] // @1F6F stack[-1] // @1F74 stack[-4] // } 1F6D 5B JUMPDEST 1F6E 82 DUP3 1F6F 01 ADD 1F70 60 PUSH1 0x1f 1F72 81 DUP2 1F73 01 ADD 1F74 84 DUP5 1F75 13 SGT 1F76 61 PUSH2 0x1f7e 1F79 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F6F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1f7e, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1F7A: // Incoming jump from 0x1F79, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1F7D memory[0x00:0x00] } 1F7A 60 PUSH1 0x00 1F7C 80 DUP1 1F7D FD *REVERT // Stack delta = +0 // Outputs[1] { @1F7D revert(memory[0x00:0x00]); } // Block terminates label_1F7E: // Incoming jump from 0x1F79, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1F82 stack[-4] // @1F83 stack[-1] // @1F84 msg.data[stack[-1]:stack[-1] + 0x20] // } 1F7E 5B JUMPDEST 1F7F 61 PUSH2 0x1911 1F82 84 DUP5 1F83 82 DUP3 1F84 35 CALLDATALOAD 1F85 60 PUSH1 0x20 1F87 84 DUP5 1F88 01 ADD 1F89 61 PUSH2 0x1eec 1F8C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F7F stack[0] = 0x1911 // @1F82 stack[1] = stack[-4] // @1F84 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1F88 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1eec, returns to 0x1911 label_1F8D: // Incoming call from 0x0681, returns to 0x0682 // Inputs[2] // { // @1F93 stack[-1] // @1F94 stack[-2] // } 1F8D 5B JUMPDEST 1F8E 60 PUSH1 0x00 1F90 80 DUP1 1F91 60 PUSH1 0x40 1F93 83 DUP4 1F94 85 DUP6 1F95 03 SUB 1F96 12 SLT 1F97 15 ISZERO 1F98 61 PUSH2 0x1fa0 1F9B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F8E stack[0] = 0x00 // @1F90 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fa0, if !(stack[-2] - stack[-1] i< 0x40) label_1F9C: // Incoming jump from 0x1F9B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F9F memory[0x00:0x00] } 1F9C 60 PUSH1 0x00 1F9E 80 DUP1 1F9F FD *REVERT // Stack delta = +0 // Outputs[1] { @1F9F revert(memory[0x00:0x00]); } // Block terminates label_1FA0: // Incoming jump from 0x1F9B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1FA4 stack[-3] } 1FA0 5B JUMPDEST 1FA1 61 PUSH2 0x1fa9 1FA4 83 DUP4 1FA5 61 PUSH2 0x1d5b 1FA8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FA1 stack[0] = 0x1fa9 // @1FA4 stack[1] = stack[-3] // } // Block ends with call to 0x1d5b, returns to 0x1FA9 label_1FA9: // Incoming return from call to 0x1D5B at 0x1FA8 // Inputs[4] // { // @1FAA stack[-1] // @1FAA stack[-3] // @1FAE stack[-4] // @1FB0 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1FA9 5B JUMPDEST 1FAA 91 SWAP2 1FAB 50 POP 1FAC 60 PUSH1 0x20 1FAE 83 DUP4 1FAF 01 ADD 1FB0 35 CALLDATALOAD 1FB1 80 DUP1 1FB2 15 ISZERO 1FB3 15 ISZERO 1FB4 81 DUP2 1FB5 14 EQ 1FB6 61 PUSH2 0x1fbe 1FB9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FAA stack[-3] = stack[-1] // @1FB0 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1fbe, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1FBA: // Incoming jump from 0x1FB9, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @1FBD memory[0x00:0x00] } 1FBA 60 PUSH1 0x00 1FBC 80 DUP1 1FBD FD *REVERT // Stack delta = +0 // Outputs[1] { @1FBD revert(memory[0x00:0x00]); } // Block terminates label_1FBE: // Incoming jump from 0x1FB9, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1FBF stack[-1] // @1FC0 stack[-2] // @1FC3 stack[-5] // @1FC5 stack[-6] // @1FC5 stack[-3] // @1FC6 stack[-4] // } 1FBE 5B JUMPDEST 1FBF 80 DUP1 1FC0 91 SWAP2 1FC1 50 POP 1FC2 50 POP 1FC3 92 SWAP3 1FC4 50 POP 1FC5 92 SWAP3 1FC6 90 SWAP1 1FC7 50 POP 1FC8 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1FC3 stack[-5] = stack[-1] // @1FC5 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1FC9: // Incoming jump from 0x0E83 // Incoming jump from 0x0FF6 // Incoming jump from 0x1223 // Inputs[1] { @1FDE memory[0x00:0x24] } 1FC9 5B JUMPDEST 1FCA 63 PUSH4 0x4e487b71 1FCF 60 PUSH1 0xe0 1FD1 1B SHL 1FD2 60 PUSH1 0x00 1FD4 52 MSTORE 1FD5 60 PUSH1 0x21 1FD7 60 PUSH1 0x04 1FD9 52 MSTORE 1FDA 60 PUSH1 0x24 1FDC 60 PUSH1 0x00 1FDE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1FD4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1FD9 memory[0x04:0x24] = 0x21 // @1FDE revert(memory[0x00:0x24]); // } // Block terminates label_1FDF: // Incoming call from 0x06C3, returns to 0x02F7 // Inputs[2] // { // @1FE2 stack[-1] // @1FE6 stack[-2] // } 1FDF 5B JUMPDEST 1FE0 60 PUSH1 0x20 1FE2 81 DUP2 1FE3 01 ADD 1FE4 60 PUSH1 0x03 1FE6 83 DUP4 1FE7 10 LT 1FE8 61 PUSH2 0x2001 1FEB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FE3 stack[0] = stack[-1] + 0x20 } // Block ends with conditional jump to 0x2001, if stack[-2] < 0x03 label_1FEC: // Incoming jump from 0x1FEB, if not stack[-2] < 0x03 // Inputs[1] { @2000 memory[0x00:0x24] } 1FEC 63 PUSH4 0x4e487b71 1FF1 60 PUSH1 0xe0 1FF3 1B SHL 1FF4 60 PUSH1 0x00 1FF6 52 MSTORE 1FF7 60 PUSH1 0x21 1FF9 60 PUSH1 0x04 1FFB 52 MSTORE 1FFC 60 PUSH1 0x24 1FFE 60 PUSH1 0x00 2000 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1FF6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1FFB memory[0x04:0x24] = 0x21 // @2000 revert(memory[0x00:0x24]); // } // Block terminates label_2001: // Incoming jump from 0x1FEB, if stack[-2] < 0x03 // Inputs[4] // { // @2002 stack[-1] // @2002 stack[-3] // @2003 stack[-2] // @2005 stack[-4] // } 2001 5B JUMPDEST 2002 91 SWAP2 2003 90 SWAP1 2004 52 MSTORE 2005 90 SWAP1 2006 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2004 memory[stack[-2]:stack[-2] + 0x20] = stack[-3] // @2005 stack[-4] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_2007: // Incoming call from 0x06DE, returns to 0x06DF // Inputs[2] // { // @2010 stack[-1] // @2011 stack[-2] // } 2007 5B JUMPDEST 2008 60 PUSH1 0x00 200A 80 DUP1 200B 60 PUSH1 0x00 200D 80 DUP1 200E 60 PUSH1 0x80 2010 85 DUP6 2011 87 DUP8 2012 03 SUB 2013 12 SLT 2014 15 ISZERO 2015 61 PUSH2 0x201d 2018 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2008 stack[0] = 0x00 // @200A stack[1] = 0x00 // @200B stack[2] = 0x00 // @200D stack[3] = 0x00 // } // Block ends with conditional jump to 0x201d, if !(stack[-2] - stack[-1] i< 0x80) label_2019: // Incoming jump from 0x2018, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @201C memory[0x00:0x00] } 2019 60 PUSH1 0x00 201B 80 DUP1 201C FD *REVERT // Stack delta = +0 // Outputs[1] { @201C revert(memory[0x00:0x00]); } // Block terminates label_201D: // Incoming jump from 0x2018, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2021 stack[-5] } 201D 5B JUMPDEST 201E 61 PUSH2 0x2026 2021 85 DUP6 2022 61 PUSH2 0x1d5b 2025 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @201E stack[0] = 0x2026 // @2021 stack[1] = stack[-5] // } // Block ends with call to 0x1d5b, returns to 0x2026 label_2026: // Incoming return from call to 0x1D5B at 0x2025 // Inputs[3] // { // @2027 stack[-5] // @2027 stack[-1] // @202E stack[-6] // } 2026 5B JUMPDEST 2027 93 SWAP4 2028 50 POP 2029 61 PUSH2 0x2034 202C 60 PUSH1 0x20 202E 86 DUP7 202F 01 ADD 2030 61 PUSH2 0x1d5b 2033 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2027 stack[-5] = stack[-1] // @2029 stack[-1] = 0x2034 // @202F stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1d5b, returns to 0x2034 label_2034: // Incoming return from call to 0x1D5B at 0x2033 // Inputs[6] // { // @2035 stack[-1] // @2035 stack[-4] // @2039 stack[-6] // @203B msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @203C stack[-3] // @2042 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2034 5B JUMPDEST 2035 92 SWAP3 2036 50 POP 2037 60 PUSH1 0x40 2039 85 DUP6 203A 01 ADD 203B 35 CALLDATALOAD 203C 91 SWAP2 203D 50 POP 203E 60 PUSH1 0x60 2040 85 DUP6 2041 01 ADD 2042 35 CALLDATALOAD 2043 67 PUSH8 0xffffffffffffffff 204C 81 DUP2 204D 11 GT 204E 15 ISZERO 204F 61 PUSH2 0x2057 2052 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2035 stack[-4] = stack[-1] // @203C stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2042 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2057, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2053: // Incoming jump from 0x2052, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2056 memory[0x00:0x00] } 2053 60 PUSH1 0x00 2055 80 DUP1 2056 FD *REVERT // Stack delta = +0 // Outputs[1] { @2056 revert(memory[0x00:0x00]); } // Block terminates label_2057: // Incoming jump from 0x2052, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2058 stack[-6] // @2059 stack[-1] // @205E stack[-7] // } 2057 5B JUMPDEST 2058 85 DUP6 2059 01 ADD 205A 60 PUSH1 0x1f 205C 81 DUP2 205D 01 ADD 205E 87 DUP8 205F 13 SGT 2060 61 PUSH2 0x2068 2063 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2059 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2068, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2064: // Incoming jump from 0x2063, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2067 memory[0x00:0x00] } 2064 60 PUSH1 0x00 2066 80 DUP1 2067 FD *REVERT // Stack delta = +0 // Outputs[1] { @2067 revert(memory[0x00:0x00]); } // Block terminates label_2068: // Incoming jump from 0x2063, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @206C stack[-7] // @206D stack[-1] // @206E msg.data[stack[-1]:stack[-1] + 0x20] // } 2068 5B JUMPDEST 2069 61 PUSH2 0x2077 206C 87 DUP8 206D 82 DUP3 206E 35 CALLDATALOAD 206F 60 PUSH1 0x20 2071 84 DUP5 2072 01 ADD 2073 61 PUSH2 0x1eec 2076 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2069 stack[0] = 0x2077 // @206C stack[1] = stack[-7] // @206E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2072 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1eec, returns to 0x2077 label_2077: // Incoming return from call to 0x1EEC at 0x2076 // Inputs[8] // { // @2078 stack[-1] // @2078 stack[-3] // @207B stack[-6] // @207C stack[-9] // @207D stack[-5] // @207E stack[-8] // @2080 stack[-4] // @2080 stack[-7] // } 2077 5B JUMPDEST 2078 91 SWAP2 2079 50 POP 207A 50 POP 207B 92 SWAP3 207C 95 SWAP6 207D 91 SWAP2 207E 94 SWAP5 207F 50 POP 2080 92 SWAP3 2081 50 POP 2082 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @207B stack[-6] = stack[-1] // @207C stack[-9] = stack[-6] // @207E stack[-8] = stack[-5] // @2080 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2083: // Incoming call from 0x0714, returns to 0x0715 // Inputs[2] // { // @2088 stack[-1] // @2089 stack[-2] // } 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 60 PUSH1 0x20 2088 82 DUP3 2089 84 DUP5 208A 03 SUB 208B 12 SLT 208C 15 ISZERO 208D 61 PUSH2 0x2095 2090 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2084 stack[0] = 0x00 } // Block ends with conditional jump to 0x2095, if !(stack[-2] - stack[-1] i< 0x20) label_2091: // Incoming jump from 0x2090, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2094 memory[0x00:0x00] } 2091 60 PUSH1 0x00 2093 80 DUP1 2094 FD *REVERT // Stack delta = +0 // Outputs[1] { @2094 revert(memory[0x00:0x00]); } // Block terminates label_2095: // Incoming jump from 0x2090, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2096 stack[-2] // @2097 msg.data[stack[-2]:stack[-2] + 0x20] // } 2095 5B JUMPDEST 2096 81 DUP2 2097 35 CALLDATALOAD 2098 60 PUSH1 0x03 209A 81 DUP2 209B 10 LT 209C 61 PUSH2 0x1996 209F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2097 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1996, if msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 label_20A0: // Incoming jump from 0x209F, if not msg.data[stack[-2]:stack[-2] + 0x20] < 0x03 // Inputs[1] { @20A3 memory[0x00:0x00] } 20A0 60 PUSH1 0x00 20A2 80 DUP1 20A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @20A3 revert(memory[0x00:0x00]); } // Block terminates label_20A4: // Incoming call from 0x077F, returns to 0x0780 // Inputs[2] // { // @20AA stack[-1] // @20AB stack[-2] // } 20A4 5B JUMPDEST 20A5 60 PUSH1 0x00 20A7 80 DUP1 20A8 60 PUSH1 0x40 20AA 83 DUP4 20AB 85 DUP6 20AC 03 SUB 20AD 12 SLT 20AE 15 ISZERO 20AF 61 PUSH2 0x20b7 20B2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20A5 stack[0] = 0x00 // @20A7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20b7, if !(stack[-2] - stack[-1] i< 0x40) label_20B3: // Incoming jump from 0x20B2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20B6 memory[0x00:0x00] } 20B3 60 PUSH1 0x00 20B5 80 DUP1 20B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @20B6 revert(memory[0x00:0x00]); } // Block terminates label_20B7: // Incoming jump from 0x20B2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20BB stack[-3] } 20B7 5B JUMPDEST 20B8 61 PUSH2 0x20c0 20BB 83 DUP4 20BC 61 PUSH2 0x1d5b 20BF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20B8 stack[0] = 0x20c0 // @20BB stack[1] = stack[-3] // } // Block ends with call to 0x1d5b, returns to 0x20C0 label_20C0: // Incoming return from call to 0x1D5B at 0x20BF // Inputs[3] // { // @20C1 stack[-3] // @20C1 stack[-1] // @20C8 stack[-4] // } 20C0 5B JUMPDEST 20C1 91 SWAP2 20C2 50 POP 20C3 61 PUSH2 0x20ce 20C6 60 PUSH1 0x20 20C8 84 DUP5 20C9 01 ADD 20CA 61 PUSH2 0x1d5b 20CD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @20C1 stack[-3] = stack[-1] // @20C3 stack[-1] = 0x20ce // @20C9 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1d5b, returns to 0x20CE label_20CE: // Incoming return from call to 0x1D5B at 0x20CD // Inputs[6] // { // @20CF stack[-1] // @20CF stack[-2] // @20D1 stack[-5] // @20D3 stack[-3] // @20D3 stack[-6] // @20D4 stack[-4] // } 20CE 5B JUMPDEST 20CF 90 SWAP1 20D0 50 POP 20D1 92 SWAP3 20D2 50 POP 20D3 92 SWAP3 20D4 90 SWAP1 20D5 50 POP 20D6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @20D1 stack[-5] = stack[-1] // @20D3 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_20D7: // Incoming call from 0x0FDD, returns to 0x08B7 // Incoming call from 0x08E2, returns to 0x08E3 // Incoming call from 0x0C58, returns to 0x0C59 // Incoming call from 0x0C84, returns to 0x0C85 // Incoming call from 0x19B8, returns to 0x08B7 // Incoming call from 0x21CB, returns to 0x21CC // Incoming call from 0x126C, returns to 0x0C59 // Incoming call from 0x08B6, returns to 0x08B7 // Inputs[1] { @20DA stack[-1] } 20D7 5B JUMPDEST 20D8 60 PUSH1 0x01 20DA 81 DUP2 20DB 81 DUP2 20DC 1C SHR 20DD 90 SWAP1 20DE 82 DUP3 20DF 16 AND 20E0 80 DUP1 20E1 61 PUSH2 0x20eb 20E4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20DD stack[0] = stack[-1] >> 0x01 // @20DF stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x20eb, if stack[-1] & 0x01 label_20E5: // Incoming jump from 0x20E4, if not stack[-1] & 0x01 // Inputs[2] // { // @20E7 stack[-2] // @20F0 stack[-1] // } 20E5 60 PUSH1 0x7f 20E7 82 DUP3 20E8 16 AND 20E9 91 SWAP2 20EA 50 POP 20EB 5B JUMPDEST 20EC 60 PUSH1 0x20 20EE 82 DUP3 20EF 10 LT 20F0 81 DUP2 20F1 03 SUB 20F2 61 PUSH2 0x210b 20F5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20E9 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x210b, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_20F6: // Incoming jump from 0x20F5, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x20F5, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @210A memory[0x00:0x24] } 20F6 63 PUSH4 0x4e487b71 20FB 60 PUSH1 0xe0 20FD 1B SHL 20FE 60 PUSH1 0x00 2100 52 MSTORE 2101 60 PUSH1 0x22 2103 60 PUSH1 0x04 2105 52 MSTORE 2106 60 PUSH1 0x24 2108 60 PUSH1 0x00 210A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2100 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2105 memory[0x04:0x24] = 0x22 // @210A revert(memory[0x00:0x24]); // } // Block terminates label_210B: // Incoming jump from 0x20F5, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x20F5, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @210D stack[-4] // @210D stack[-2] // @210E stack[-3] // } 210B 5B JUMPDEST 210C 50 POP 210D 91 SWAP2 210E 90 SWAP1 210F 50 POP 2110 56 *JUMP // Stack delta = -3 // Outputs[1] { @210D stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2111: // Incoming jump from 0x13A5 // Incoming jump from 0x0A76 // Inputs[1] { @2126 memory[0x00:0x24] } 2111 5B JUMPDEST 2112 63 PUSH4 0x4e487b71 2117 60 PUSH1 0xe0 2119 1B SHL 211A 60 PUSH1 0x00 211C 52 MSTORE 211D 60 PUSH1 0x32 211F 60 PUSH1 0x04 2121 52 MSTORE 2122 60 PUSH1 0x24 2124 60 PUSH1 0x00 2126 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @211C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2121 memory[0x04:0x24] = 0x32 // @2126 revert(memory[0x00:0x24]); // } // Block terminates label_2127: // Incoming jump from 0x2295 // Incoming jump from 0x2276 // Incoming jump from 0x214E // Inputs[1] { @213C memory[0x00:0x24] } 2127 5B JUMPDEST 2128 63 PUSH4 0x4e487b71 212D 60 PUSH1 0xe0 212F 1B SHL 2130 60 PUSH1 0x00 2132 52 MSTORE 2133 60 PUSH1 0x11 2135 60 PUSH1 0x04 2137 52 MSTORE 2138 60 PUSH1 0x24 213A 60 PUSH1 0x00 213C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2132 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2137 memory[0x04:0x24] = 0x11 // @213C revert(memory[0x00:0x24]); // } // Block terminates label_213D: // Incoming call from 0x0AB2, returns to 0x0AB3 // Incoming call from 0x13E1, returns to 0x13E2 // Inputs[1] { @2142 stack[-1] } 213D 5B JUMPDEST 213E 60 PUSH1 0x00 2140 60 PUSH1 0x01 2142 82 DUP3 2143 01 ADD 2144 61 PUSH2 0x214f 2147 57 *JUMPI // Stack delta = +1 // Outputs[1] { @213E stack[0] = 0x00 } // Block ends with conditional jump to 0x214f, if stack[-1] + 0x01 label_2148: // Incoming jump from 0x2147, if not stack[-1] + 0x01 2148 61 PUSH2 0x214f 214B 61 PUSH2 0x2127 214E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2148 stack[0] = 0x214f } // Block ends with unconditional jump to 0x2127 label_214F: // Incoming jump from 0x2147, if stack[-1] + 0x01 // Inputs[2] // { // @2153 stack[-2] // @2154 stack[-3] // } 214F 5B JUMPDEST 2150 50 POP 2151 60 PUSH1 0x01 2153 01 ADD 2154 90 SWAP1 2155 56 *JUMP // Stack delta = -2 // Outputs[1] { @2154 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2156: // Incoming jump from 0x21D1 // Inputs[1] { @2159 stack[-2] } 2156 5B JUMPDEST 2157 60 PUSH1 0x1f 2159 82 DUP3 215A 11 GT 215B 15 ISZERO 215C 61 PUSH2 0x0a06 215F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a06, if !(stack[-2] > 0x1f) label_2160: // Incoming jump from 0x215F, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @2162 stack[-1] // @2168 memory[0x00:0x20] // @216B stack[-3] // } 2160 60 PUSH1 0x00 2162 81 DUP2 2163 81 DUP2 2164 52 MSTORE 2165 60 PUSH1 0x20 2167 81 DUP2 2168 20 SHA3 2169 60 PUSH1 0x1f 216B 85 DUP6 216C 01 ADD 216D 60 PUSH1 0x05 216F 1C SHR 2170 81 DUP2 2171 01 ADD 2172 60 PUSH1 0x20 2174 86 DUP7 2175 10 LT 2176 15 ISZERO 2177 61 PUSH2 0x217d 217A 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @2160 stack[0] = 0x00 // @2164 memory[0x00:0x20] = stack[-1] // @2168 stack[1] = keccak256(memory[0x00:0x20]) // @2171 stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x217d, if !(stack[-3] < 0x20) label_217B: // Incoming jump from 0x217A, if not !(stack[-3] < 0x20) // Inputs[2] // { // @217C stack[-2] // @2180 stack[-5] // } 217B 50 POP 217C 80 DUP1 217D 5B JUMPDEST 217E 60 PUSH1 0x1f 2180 85 DUP6 2181 01 ADD 2182 60 PUSH1 0x05 2184 1C SHR 2185 82 DUP3 2186 01 ADD 2187 91 SWAP2 2188 50 POP 2189 5B JUMPDEST 218A 81 DUP2 218B 81 DUP2 218C 10 LT 218D 15 ISZERO 218E 61 PUSH2 0x219c 2191 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @217C stack[-1] = stack[-2] // @2187 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x219c, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_2192: // Incoming jump from 0x2191, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2191, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2191, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[2] // { // @2192 stack[-3] // @2193 stack[-1] // } 2192 82 DUP3 2193 81 DUP2 2194 55 SSTORE 2195 60 PUSH1 0x01 2197 01 ADD 2198 61 PUSH2 0x2189 219B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2194 storage[stack[-1]] = stack[-3] // @2197 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2189 label_219C: // Incoming jump from 0x2191, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2206 // Incoming jump from 0x2206 // Incoming jump from 0x2191, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2191, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[1] { @21A3 stack[-7] } 219C 5B JUMPDEST 219D 50 POP 219E 50 POP 219F 50 POP 21A0 50 POP 21A1 50 POP 21A2 50 POP 21A3 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_21A4: // Incoming call from 0x0DD0, returns to 0x0ABB // Incoming call from 0x0C39, returns to 0x0ABB // Inputs[2] // { // @21A5 stack[-2] // @21A6 memory[stack[-2]:stack[-2] + 0x20] // } 21A4 5B JUMPDEST 21A5 81 DUP2 21A6 51 MLOAD 21A7 67 PUSH8 0xffffffffffffffff 21B0 81 DUP2 21B1 11 GT 21B2 15 ISZERO 21B3 61 PUSH2 0x21be 21B6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21A6 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x21be, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_21B7: // Incoming jump from 0x21B6, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 21B7 61 PUSH2 0x21be 21BA 61 PUSH2 0x1dbc 21BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @21B7 stack[0] = 0x21be } // Block ends with unconditional jump to 0x1dbc label_21BE: // Incoming jump from 0x21B6, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @21C2 stack[-1] // @21C6 stack[-2] // @21C7 storage[stack[-2]] // } 21BE 5B JUMPDEST 21BF 61 PUSH2 0x21d2 21C2 81 DUP2 21C3 61 PUSH2 0x21cc 21C6 84 DUP5 21C7 54 SLOAD 21C8 61 PUSH2 0x20d7 21CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21BF stack[0] = 0x21d2 // @21C2 stack[1] = stack[-1] // @21C3 stack[2] = 0x21cc // @21C7 stack[3] = storage[stack[-2]] // } // Block ends with call to 0x20d7, returns to 0x21CC label_21CC: // Incoming return from call to 0x20D7 at 0x21CB // Inputs[1] { @21CD stack[-5] } 21CC 5B JUMPDEST 21CD 84 DUP5 21CE 61 PUSH2 0x2156 21D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @21CD stack[0] = stack[-5] } // Block ends with unconditional jump to 0x2156 label_21D2: // Incoming return from call to 0x21CC at 0x21CB // Inputs[1] { @21D8 stack[-1] } 21D2 5B JUMPDEST 21D3 60 PUSH1 0x20 21D5 80 DUP1 21D6 60 PUSH1 0x1f 21D8 83 DUP4 21D9 11 GT 21DA 60 PUSH1 0x01 21DC 81 DUP2 21DD 14 EQ 21DE 61 PUSH2 0x2207 21E1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @21D3 stack[0] = 0x20 // @21D5 stack[1] = 0x20 // @21D9 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x2207, if (stack[-1] > 0x1f) == 0x01 label_21E2: // Incoming jump from 0x21E1, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @21E4 stack[-4] } 21E2 60 PUSH1 0x00 21E4 84 DUP5 21E5 15 ISZERO 21E6 61 PUSH2 0x21ef 21E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21E2 stack[0] = 0x00 } // Block ends with conditional jump to 0x21ef, if !stack[-4] label_21EA: // Incoming jump from 0x21E9, if not !stack[-4] // Inputs[5] // { // @21EB stack[-7] // @21EC stack[-4] // @21EE memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @21F5 stack[-5] // @2201 stack[-6] // } 21EA 50 POP 21EB 85 DUP6 21EC 83 DUP4 21ED 01 ADD 21EE 51 MLOAD 21EF 5B JUMPDEST 21F0 60 PUSH1 0x00 21F2 19 NOT 21F3 60 PUSH1 0x03 21F5 86 DUP7 21F6 90 SWAP1 21F7 1B SHL 21F8 1C SHR 21F9 19 NOT 21FA 16 AND 21FB 60 PUSH1 0x01 21FD 85 DUP6 21FE 90 SWAP1 21FF 1B SHL 2200 17 OR 2201 85 DUP6 2202 55 SSTORE 2203 61 PUSH2 0x219c 2206 56 *JUMP // Stack delta = -1 // Outputs[1] { @2202 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x219c label_2207: // Incoming jump from 0x21E1, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @220A stack[-5] // @2210 memory[0x00:0x20] // @2214 stack[-4] // } 2207 5B JUMPDEST 2208 60 PUSH1 0x00 220A 85 DUP6 220B 81 DUP2 220C 52 MSTORE 220D 60 PUSH1 0x20 220F 81 DUP2 2210 20 SHA3 2211 60 PUSH1 0x1f 2213 19 NOT 2214 86 DUP7 2215 16 AND 2216 91 SWAP2 2217 5B JUMPDEST 2218 82 DUP3 2219 81 DUP2 221A 10 LT 221B 15 ISZERO 221C 61 PUSH2 0x2236 221F 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @220C memory[0x00:0x20] = stack[-5] // @2210 stack[1] = keccak256(memory[0x00:0x20]) // @2216 stack[0] = stack[-4] & ~0x1f // @2216 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2236, if !(0x00 < stack[-4] & ~0x1f) label_2220: // Incoming jump from 0x221F, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x221F, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @2220 stack[-9] // @2221 stack[-6] // @2223 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @2224 stack[-2] // @2226 stack[-1] // @2227 stack[-5] // } 2220 88 DUP9 2221 86 DUP7 2222 01 ADD 2223 51 MLOAD 2224 82 DUP3 2225 55 SSTORE 2226 94 SWAP5 2227 84 DUP5 2228 01 ADD 2229 94 SWAP5 222A 60 PUSH1 0x01 222C 90 SWAP1 222D 91 SWAP2 222E 01 ADD 222F 90 SWAP1 2230 84 DUP5 2231 01 ADD 2232 61 PUSH2 0x2217 2235 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2225 storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @2229 stack[-6] = stack[-5] + stack[-6] // @222F stack[-2] = stack[-2] + 0x01 // @2231 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x2217 label_2236: // Incoming jump from 0x221F, if !(stack[-1] < stack[-3]) // Incoming jump from 0x221F, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @2238 stack[-7] // @2239 stack[-3] // } 2236 5B JUMPDEST 2237 50 POP 2238 85 DUP6 2239 82 DUP3 223A 10 LT 223B 15 ISZERO 223C 61 PUSH2 0x2254 223F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2254, if !(stack[-3] < stack[-7]) label_2240: // Incoming jump from 0x223F, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @2240 stack[-8] // @2241 stack[-5] // @2243 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2249 stack[-6] // @2252 stack[-1] // @2260 stack[-7] // @2263 stack[-9] // } 2240 87 DUP8 2241 85 DUP6 2242 01 ADD 2243 51 MLOAD 2244 60 PUSH1 0x00 2246 19 NOT 2247 60 PUSH1 0x03 2249 88 DUP9 224A 90 SWAP1 224B 1B SHL 224C 60 PUSH1 0xf8 224E 16 AND 224F 1C SHR 2250 19 NOT 2251 16 AND 2252 81 DUP2 2253 55 SSTORE 2254 5B JUMPDEST 2255 50 POP 2256 50 POP 2257 50 POP 2258 50 POP 2259 50 POP 225A 60 PUSH1 0x01 225C 90 SWAP1 225D 81 DUP2 225E 1B SHL 225F 01 ADD 2260 90 SWAP1 2261 55 SSTORE 2262 50 POP 2263 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @2253 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2261 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_2264: // Incoming call from 0x0F29, returns to 0x0F2A // Incoming call from 0x0FBE, returns to 0x0FBF // Incoming call from 0x0EBC, returns to 0x0EBD // Incoming call from 0x106C, returns to 0x106D // Incoming call from 0x102F, returns to 0x1030 // Inputs[2] // { // @2267 stack[-2] // @2269 stack[-1] // } 2264 5B JUMPDEST 2265 60 PUSH1 0x00 2267 82 DUP3 2268 19 NOT 2269 82 DUP3 226A 11 GT 226B 15 ISZERO 226C 61 PUSH2 0x2277 226F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2265 stack[0] = 0x00 } // Block ends with conditional jump to 0x2277, if !(stack[-1] > ~stack[-2]) label_2270: // Incoming jump from 0x226F, if not !(stack[-1] > ~stack[-2]) 2270 61 PUSH2 0x2277 2273 61 PUSH2 0x2127 2276 56 *JUMP // Stack delta = +1 // Outputs[1] { @2270 stack[0] = 0x2277 } // Block ends with unconditional jump to 0x2127 label_2277: // Incoming jump from 0x226F, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2279 stack[-3] // @2279 stack[-2] // @227A stack[-4] // } 2277 5B JUMPDEST 2278 50 POP 2279 01 ADD 227A 90 SWAP1 227B 56 *JUMP // Stack delta = -3 // Outputs[1] { @227A stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_227C: // Incoming call from 0x10AB, returns to 0x10AC // Incoming call from 0x0F68, returns to 0x0F69 // Inputs[2] // { // @227F stack[-1] // @2284 stack[-2] // } 227C 5B JUMPDEST 227D 60 PUSH1 0x00 227F 81 DUP2 2280 60 PUSH1 0x00 2282 19 NOT 2283 04 DIV 2284 83 DUP4 2285 11 GT 2286 82 DUP3 2287 15 ISZERO 2288 15 ISZERO 2289 16 AND 228A 15 ISZERO 228B 61 PUSH2 0x2296 228E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @227D stack[0] = 0x00 } // Block ends with conditional jump to 0x2296, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_228F: // Incoming jump from 0x228E, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 228F 61 PUSH2 0x2296 2292 61 PUSH2 0x2127 2295 56 *JUMP // Stack delta = +1 // Outputs[1] { @228F stack[0] = 0x2296 } // Block ends with unconditional jump to 0x2127 label_2296: // Incoming jump from 0x228E, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2298 stack[-2] // @2298 stack[-3] // @2299 stack[-4] // } 2296 5B JUMPDEST 2297 50 POP 2298 02 MUL 2299 90 SWAP1 229A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2299 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 229B 5B JUMPDEST 229C 60 PUSH1 0x00 229E 83 DUP4 229F 51 MLOAD 22A0 60 PUSH1 0x20 22A2 61 PUSH2 0x22ae 22A5 82 DUP3 22A6 85 DUP6 22A7 83 DUP4 22A8 89 DUP10 22A9 01 ADD 22AA 61 PUSH2 0x1cf0 22AD 56 *JUMP 22AE 5B JUMPDEST 22AF 81 DUP2 22B0 84 DUP5 22B1 01 ADD 22B2 91 SWAP2 22B3 50 POP 22B4 60 PUSH1 0x00 22B6 85 DUP6 22B7 54 SLOAD 22B8 61 PUSH2 0x22c0 22BB 81 DUP2 22BC 61 PUSH2 0x20d7 22BF 56 *JUMP 22C0 5B JUMPDEST 22C1 60 PUSH1 0x01 22C3 82 DUP3 22C4 81 DUP2 22C5 16 AND 22C6 80 DUP1 22C7 15 ISZERO 22C8 61 PUSH2 0x22d8 22CB 57 *JUMPI 22CC 60 PUSH1 0x01 22CE 81 DUP2 22CF 14 EQ 22D0 61 PUSH2 0x22ed 22D3 57 *JUMPI 22D4 61 PUSH2 0x2319 22D7 56 *JUMP 22D8 5B JUMPDEST 22D9 60 PUSH1 0xff 22DB 19 NOT 22DC 84 DUP5 22DD 16 AND 22DE 87 DUP8 22DF 52 MSTORE 22E0 82 DUP3 22E1 15 ISZERO 22E2 15 ISZERO 22E3 83 DUP4 22E4 02 MUL 22E5 87 DUP8 22E6 01 ADD 22E7 94 SWAP5 22E8 50 POP 22E9 61 PUSH2 0x2319 22EC 56 *JUMP 22ED 5B JUMPDEST 22EE 89 DUP10 22EF 60 PUSH1 0x00 22F1 52 MSTORE 22F2 85 DUP6 22F3 60 PUSH1 0x00 22F5 20 SHA3 22F6 60 PUSH1 0x00 22F8 5B JUMPDEST 22F9 84 DUP5 22FA 81 DUP2 22FB 10 LT 22FC 15 ISZERO 22FD 61 PUSH2 0x2311 2300 57 *JUMPI 2301 81 DUP2 2302 54 SLOAD 2303 89 DUP10 2304 82 DUP3 2305 01 ADD 2306 52 MSTORE 2307 90 SWAP1 2308 83 DUP4 2309 01 ADD 230A 90 SWAP1 230B 87 DUP8 230C 01 ADD 230D 61 PUSH2 0x22f8 2310 56 *JUMP 2311 5B JUMPDEST 2312 50 POP 2313 50 POP 2314 82 DUP3 2315 87 DUP8 2316 01 ADD 2317 94 SWAP5 2318 50 POP 2319 5B JUMPDEST 231A 50 POP 231B 92 SWAP3 231C 99 SWAP10 231D 98 SWAP9 231E 50 POP 231F 50 POP 2320 50 POP 2321 50 POP 2322 50 POP 2323 50 POP 2324 50 POP 2325 50 POP 2326 50 POP 2327 56 *JUMP label_2328: // Incoming call from 0x1861, returns to 0x1862 // Inputs[5] // { // @2334 stack[-5] // @2336 stack[-1] // @2339 stack[-4] // @2341 stack[-3] // @2355 stack[-2] // } 2328 5B JUMPDEST 2329 60 PUSH1 0x00 232B 60 PUSH1 0x01 232D 60 PUSH1 0x01 232F 60 PUSH1 0xa0 2331 1B SHL 2332 03 SUB 2333 80 DUP1 2334 87 DUP8 2335 16 AND 2336 83 DUP4 2337 52 MSTORE 2338 80 DUP1 2339 86 DUP7 233A 16 AND 233B 60 PUSH1 0x20 233D 84 DUP5 233E 01 ADD 233F 52 MSTORE 2340 50 POP 2341 83 DUP4 2342 60 PUSH1 0x40 2344 83 DUP4 2345 01 ADD 2346 52 MSTORE 2347 60 PUSH1 0x80 2349 60 PUSH1 0x60 234B 83 DUP4 234C 01 ADD 234D 52 MSTORE 234E 61 PUSH2 0x235a 2351 60 PUSH1 0x80 2353 83 DUP4 2354 01 ADD 2355 84 DUP5 2356 61 PUSH2 0x1d1c 2359 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2329 stack[0] = 0x00 // @2337 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @233F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2346 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @234D memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @234E stack[1] = 0x235a // @2354 stack[2] = stack[-1] + 0x80 // @2355 stack[3] = stack[-2] // } // Block ends with call to 0x1d1c, returns to 0x235A label_235A: // Incoming return from call to 0x1D1C at 0x2359 // Inputs[3] // { // @235B stack[-1] // @235B stack[-8] // @235C stack[-7] // } 235A 5B JUMPDEST 235B 96 SWAP7 235C 95 SWAP6 235D 50 POP 235E 50 POP 235F 50 POP 2360 50 POP 2361 50 POP 2362 50 POP 2363 56 *JUMP // Stack delta = -7 // Outputs[1] { @235B stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2364: // Incoming jump from 0x1899 // Inputs[2] // { // @2369 stack[-1] // @236A stack[-2] // } 2364 5B JUMPDEST 2365 60 PUSH1 0x00 2367 60 PUSH1 0x20 2369 82 DUP3 236A 84 DUP5 236B 03 SUB 236C 12 SLT 236D 15 ISZERO 236E 61 PUSH2 0x2376 2371 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2365 stack[0] = 0x00 } // Block ends with conditional jump to 0x2376, if !(stack[-2] - stack[-1] i< 0x20) label_2372: // Incoming jump from 0x2371, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2375 memory[0x00:0x00] } 2372 60 PUSH1 0x00 2374 80 DUP1 2375 FD *REVERT // Stack delta = +0 // Outputs[1] { @2375 revert(memory[0x00:0x00]); } // Block terminates label_2376: // Incoming jump from 0x2371, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2377 stack[-2] // @2378 memory[stack[-2]:stack[-2] + 0x20] // } 2376 5B JUMPDEST 2377 81 DUP2 2378 51 MLOAD 2379 61 PUSH2 0x1996 237C 81 DUP2 237D 61 PUSH2 0x1ca4 2380 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2378 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2379 stack[1] = 0x1996 // @237C stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1ca4, returns to 0x1996 2381 5B JUMPDEST 2382 60 PUSH1 0x00 2384 83 DUP4 2385 51 MLOAD 2386 61 PUSH2 0x2393 2389 81 DUP2 238A 84 DUP5 238B 60 PUSH1 0x20 238D 88 DUP9 238E 01 ADD 238F 61 PUSH2 0x1cf0 2392 56 *JUMP 2393 5B JUMPDEST 2394 83 DUP4 2395 51 MLOAD 2396 90 SWAP1 2397 83 DUP4 2398 01 ADD 2399 90 SWAP1 239A 61 PUSH2 0x23a7 239D 81 DUP2 239E 83 DUP4 239F 60 PUSH1 0x20 23A1 88 DUP9 23A2 01 ADD 23A3 61 PUSH2 0x1cf0 23A6 56 *JUMP 23A7 5B JUMPDEST 23A8 01 ADD 23A9 94 SWAP5 23AA 93 SWAP4 23AB 50 POP 23AC 50 POP 23AD 50 POP 23AE 50 POP 23AF 56 *JUMP 23B0 5B JUMPDEST 23B1 63 PUSH4 0x4e487b71 23B6 60 PUSH1 0xe0 23B8 1B SHL 23B9 60 PUSH1 0x00 23BB 52 MSTORE 23BC 60 PUSH1 0x12 23BE 60 PUSH1 0x04 23C0 52 MSTORE 23C1 60 PUSH1 0x24 23C3 60 PUSH1 0x00 23C5 FD *REVERT 23C6 5B JUMPDEST 23C7 60 PUSH1 0x00 23C9 82 DUP3 23CA 61 PUSH2 0x23d5 23CD 57 *JUMPI 23CE 61 PUSH2 0x23d5 23D1 61 PUSH2 0x23b0 23D4 56 *JUMP 23D5 5B JUMPDEST 23D6 50 POP 23D7 04 DIV 23D8 90 SWAP1 23D9 56 *JUMP 23DA 5B JUMPDEST 23DB 60 PUSH1 0x00 23DD 82 DUP3 23DE 82 DUP3 23DF 10 LT 23E0 15 ISZERO 23E1 61 PUSH2 0x23ec 23E4 57 *JUMPI 23E5 61 PUSH2 0x23ec 23E8 61 PUSH2 0x2127 23EB 56 *JUMP 23EC 5B JUMPDEST 23ED 50 POP 23EE 03 SUB 23EF 90 SWAP1 23F0 56 *JUMP 23F1 5B JUMPDEST 23F2 60 PUSH1 0x00 23F4 82 DUP3 23F5 61 PUSH2 0x2400 23F8 57 *JUMPI 23F9 61 PUSH2 0x2400 23FC 61 PUSH2 0x23b0 23FF 56 *JUMP 2400 5B JUMPDEST 2401 50 POP 2402 06 MOD 2403 90 SWAP1 2404 56 *JUMP 2405 FE *ASSERT 2406 4F 4F 2407 77 PUSH24 0x6e61626c653a2063616c6c6572206973206e6f7420746865 2420 20 SHA3 2421 6F PUSH16 0x776e6572a2646970667358221220afd3 2432 40 BLOCKHASH 2433 46 CHAINID 2434 CB CB 2435 AC AC 2436 83 DUP4 2437 0C 0C 2438 42 TIMESTAMP 2439 7A PUSH27 0x59372a33d0a1f433a7c396e364dd418c66305f2241a864736f6c63 2455 43 NUMBER 2456 00 *STOP 2457 08 ADDMOD 2458 0F 0F 2459 00 *STOP 245A 33 CALLER