Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0266 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x0266, 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 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 62 PUSH3 0x6f0231 003B 14 EQ 003C 61 PUSH2 0x0271 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0271, if 0x6f0231 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0040: // Incoming jump from 0x003F, if not 0x6f0231 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x06fdde03 0046 14 EQ 0047 61 PUSH2 0x0294 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0294, if 0x06fdde03 == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x083c6323 0051 14 EQ 0052 61 PUSH2 0x0322 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0322, if 0x083c6323 == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x083c6323 == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x095ea7b3 005C 14 EQ 005D 61 PUSH2 0x034b 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034b, if 0x095ea7b3 == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x09fd8212 0067 14 EQ 0068 61 PUSH2 0x03a5 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a5, if 0x09fd8212 == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x09fd8212 == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0x121cd7ed 0072 14 EQ 0073 61 PUSH2 0x03f6 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f6, if 0x121cd7ed == stack[-1] label_0077: // Incoming jump from 0x0076, if not 0x121cd7ed == stack[-1] // Inputs[1] { @0077 stack[-1] } 0077 80 DUP1 0078 63 PUSH4 0x18160ddd 007D 14 EQ 007E 61 PUSH2 0x0423 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0423, if 0x18160ddd == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0x18160ddd == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0x190eaaba 0088 14 EQ 0089 61 PUSH2 0x044c 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044c, if 0x190eaaba == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x190eaaba == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x202bf004 0093 14 EQ 0094 61 PUSH2 0x0475 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0475, if 0x202bf004 == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x202bf004 == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x23b872dd 009E 14 EQ 009F 61 PUSH2 0x0498 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0498, if 0x23b872dd == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x23b872dd == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x2a004bb2 00A9 14 EQ 00AA 61 PUSH2 0x0511 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0511, if 0x2a004bb2 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x2a004bb2 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x313ce567 00B4 14 EQ 00B5 61 PUSH2 0x054a 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054a, if 0x313ce567 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x313ce567 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x3ccfd60b 00BF 14 EQ 00C0 61 PUSH2 0x0579 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0579, if 0x3ccfd60b == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x42667f34 00CA 14 EQ 00CB 61 PUSH2 0x058e 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058e, if 0x42667f34 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x42667f34 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x486c96fa 00D5 14 EQ 00D6 61 PUSH2 0x05b7 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b7, if 0x486c96fa == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x486c96fa == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x48cd4cb1 00E0 14 EQ 00E1 61 PUSH2 0x060c 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060c, if 0x48cd4cb1 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x48cd4cb1 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x5e6f6045 00EB 14 EQ 00EC 61 PUSH2 0x0635 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0635, if 0x5e6f6045 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x5e6f6045 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x5ffde7be 00F6 14 EQ 00F7 61 PUSH2 0x068a 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068a, if 0x5ffde7be == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x5ffde7be == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0x643a7695 0101 14 EQ 0102 61 PUSH2 0x06b3 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b3, if 0x643a7695 == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0x643a7695 == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0x645006ca 010C 14 EQ 010D 61 PUSH2 0x06ec 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ec, if 0x645006ca == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0x645006ca == stack[-1] // Inputs[1] { @0111 stack[-1] } 0111 80 DUP1 0112 63 PUSH4 0x6be4cf1f 0117 14 EQ 0118 61 PUSH2 0x0715 011B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0715, if 0x6be4cf1f == stack[-1] label_011C: // Incoming jump from 0x011B, if not 0x6be4cf1f == stack[-1] // Inputs[1] { @011C stack[-1] } 011C 80 DUP1 011D 63 PUSH4 0x70a08231 0122 14 EQ 0123 61 PUSH2 0x0743 0126 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0743, if 0x70a08231 == stack[-1] label_0127: // Incoming jump from 0x0126, if not 0x70a08231 == stack[-1] // Inputs[1] { @0127 stack[-1] } 0127 80 DUP1 0128 63 PUSH4 0x74991569 012D 14 EQ 012E 61 PUSH2 0x0790 0131 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0790, if 0x74991569 == stack[-1] label_0132: // Incoming jump from 0x0131, if not 0x74991569 == stack[-1] // Inputs[1] { @0132 stack[-1] } 0132 80 DUP1 0133 63 PUSH4 0x8a8c523c 0138 14 EQ 0139 61 PUSH2 0x07c9 013C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c9, if 0x8a8c523c == stack[-1] label_013D: // Incoming jump from 0x013C, if not 0x8a8c523c == stack[-1] // Inputs[1] { @013D stack[-1] } 013D 80 DUP1 013E 63 PUSH4 0x8b4ecbe0 0143 14 EQ 0144 61 PUSH2 0x07de 0147 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07de, if 0x8b4ecbe0 == stack[-1] label_0148: // Incoming jump from 0x0147, if not 0x8b4ecbe0 == stack[-1] // Inputs[1] { @0148 stack[-1] } 0148 80 DUP1 0149 63 PUSH4 0x8d6cc56d 014E 14 EQ 014F 61 PUSH2 0x0801 0152 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0801, if 0x8d6cc56d == stack[-1] label_0153: // Incoming jump from 0x0152, if not 0x8d6cc56d == stack[-1] // Inputs[1] { @0153 stack[-1] } 0153 80 DUP1 0154 63 PUSH4 0x8f11e5f9 0159 14 EQ 015A 61 PUSH2 0x0824 015D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0824, if 0x8f11e5f9 == stack[-1] label_015E: // Incoming jump from 0x015D, if not 0x8f11e5f9 == stack[-1] // Inputs[1] { @015E stack[-1] } 015E 80 DUP1 015F 63 PUSH4 0x9281cd65 0164 14 EQ 0165 61 PUSH2 0x085b 0168 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085b, if 0x9281cd65 == stack[-1] label_0169: // Incoming jump from 0x0168, if not 0x9281cd65 == stack[-1] // Inputs[1] { @0169 stack[-1] } 0169 80 DUP1 016A 63 PUSH4 0x95d89b41 016F 14 EQ 0170 61 PUSH2 0x08be 0173 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08be, if 0x95d89b41 == stack[-1] label_0174: // Incoming jump from 0x0173, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0174 stack[-1] } 0174 80 DUP1 0175 63 PUSH4 0x9b19251a 017A 14 EQ 017B 61 PUSH2 0x094c 017E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x094c, if 0x9b19251a == stack[-1] label_017F: // Incoming jump from 0x017E, if not 0x9b19251a == stack[-1] // Inputs[1] { @017F stack[-1] } 017F 80 DUP1 0180 63 PUSH4 0x9c8f9f23 0185 14 EQ 0186 61 PUSH2 0x099d 0189 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x099d, if 0x9c8f9f23 == stack[-1] label_018A: // Incoming jump from 0x0189, if not 0x9c8f9f23 == stack[-1] // Inputs[1] { @018A stack[-1] } 018A 80 DUP1 018B 63 PUSH4 0x9d1b464a 0190 14 EQ 0191 61 PUSH2 0x09c0 0194 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c0, if 0x9d1b464a == stack[-1] label_0195: // Incoming jump from 0x0194, if not 0x9d1b464a == stack[-1] // Inputs[1] { @0195 stack[-1] } 0195 80 DUP1 0196 63 PUSH4 0x9ee679e8 019B 14 EQ 019C 61 PUSH2 0x09f0 019F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f0, if 0x9ee679e8 == stack[-1] label_01A0: // Incoming jump from 0x019F, if not 0x9ee679e8 == stack[-1] // Inputs[1] { @01A0 stack[-1] } 01A0 80 DUP1 01A1 63 PUSH4 0xa301ba6f 01A6 14 EQ 01A7 61 PUSH2 0x0a13 01AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a13, if 0xa301ba6f == stack[-1] label_01AB: // Incoming jump from 0x01AA, if not 0xa301ba6f == stack[-1] // Inputs[1] { @01AB stack[-1] } 01AB 80 DUP1 01AC 63 PUSH4 0xa9059cbb 01B1 14 EQ 01B2 61 PUSH2 0x0a28 01B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a28, if 0xa9059cbb == stack[-1] label_01B6: // Incoming jump from 0x01B5, if not 0xa9059cbb == stack[-1] // Inputs[1] { @01B6 stack[-1] } 01B6 80 DUP1 01B7 63 PUSH4 0xb19a81fd 01BC 14 EQ 01BD 61 PUSH2 0x0a82 01C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a82, if 0xb19a81fd == stack[-1] label_01C1: // Incoming jump from 0x01C0, if not 0xb19a81fd == stack[-1] // Inputs[1] { @01C1 stack[-1] } 01C1 80 DUP1 01C2 63 PUSH4 0xb27a0484 01C7 14 EQ 01C8 61 PUSH2 0x0aab 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aab, if 0xb27a0484 == stack[-1] label_01CC: // Incoming jump from 0x01CB, if not 0xb27a0484 == stack[-1] // Inputs[1] { @01CC stack[-1] } 01CC 80 DUP1 01CD 63 PUSH4 0xc8cd65e5 01D2 14 EQ 01D3 61 PUSH2 0x0ae9 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae9, if 0xc8cd65e5 == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0xc8cd65e5 == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0xcbcf98e6 01DD 14 EQ 01DE 61 PUSH2 0x0b2b 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b2b, if 0xcbcf98e6 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0xcbcf98e6 == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0xd0febe4c 01E8 14 EQ 01E9 61 PUSH2 0x0b64 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b64, if 0xd0febe4c == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0xd0febe4c == stack[-1] // Inputs[1] { @01ED stack[-1] } 01ED 80 DUP1 01EE 63 PUSH4 0xd876e10c 01F3 14 EQ 01F4 61 PUSH2 0x0b6e 01F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b6e, if 0xd876e10c == stack[-1] label_01F8: // Incoming jump from 0x01F7, if not 0xd876e10c == stack[-1] // Inputs[1] { @01F8 stack[-1] } 01F8 80 DUP1 01F9 63 PUSH4 0xdbb24554 01FE 14 EQ 01FF 61 PUSH2 0x0b83 0202 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b83, if 0xdbb24554 == stack[-1] label_0203: // Incoming jump from 0x0202, if not 0xdbb24554 == stack[-1] // Inputs[1] { @0203 stack[-1] } 0203 80 DUP1 0204 63 PUSH4 0xdd54291b 0209 14 EQ 020A 61 PUSH2 0x0ba6 020D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ba6, if 0xdd54291b == stack[-1] label_020E: // Incoming jump from 0x020D, if not 0xdd54291b == stack[-1] // Inputs[1] { @020E stack[-1] } 020E 80 DUP1 020F 63 PUSH4 0xdd62ed3e 0214 14 EQ 0215 61 PUSH2 0x0bcf 0218 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bcf, if 0xdd62ed3e == stack[-1] label_0219: // Incoming jump from 0x0218, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0219 stack[-1] } 0219 80 DUP1 021A 63 PUSH4 0xdf8de3e7 021F 14 EQ 0220 61 PUSH2 0x0c3b 0223 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c3b, if 0xdf8de3e7 == stack[-1] label_0224: // Incoming jump from 0x0223, if not 0xdf8de3e7 == stack[-1] // Inputs[1] { @0224 stack[-1] } 0224 80 DUP1 0225 63 PUSH4 0xe2aa8435 022A 14 EQ 022B 61 PUSH2 0x0c74 022E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c74, if 0xe2aa8435 == stack[-1] label_022F: // Incoming jump from 0x022E, if not 0xe2aa8435 == stack[-1] // Inputs[1] { @022F stack[-1] } 022F 80 DUP1 0230 63 PUSH4 0xe8078d94 0235 14 EQ 0236 61 PUSH2 0x0c97 0239 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c97, if 0xe8078d94 == stack[-1] label_023A: // Incoming jump from 0x0239, if not 0xe8078d94 == stack[-1] // Inputs[1] { @023A stack[-1] } 023A 80 DUP1 023B 63 PUSH4 0xf5ac9db6 0240 14 EQ 0241 61 PUSH2 0x0ca1 0244 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ca1, if 0xf5ac9db6 == stack[-1] label_0245: // Incoming jump from 0x0244, if not 0xf5ac9db6 == stack[-1] // Inputs[1] { @0245 stack[-1] } 0245 80 DUP1 0246 63 PUSH4 0xf66a79a0 024B 14 EQ 024C 61 PUSH2 0x0cce 024F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cce, if 0xf66a79a0 == stack[-1] label_0250: // Incoming jump from 0x024F, if not 0xf66a79a0 == stack[-1] // Inputs[1] { @0250 stack[-1] } 0250 80 DUP1 0251 63 PUSH4 0xfac2b9ba 0256 14 EQ 0257 61 PUSH2 0x0d23 025A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d23, if 0xfac2b9ba == stack[-1] label_025B: // Incoming jump from 0x025A, if not 0xfac2b9ba == stack[-1] // Inputs[1] { @025B stack[-1] } 025B 80 DUP1 025C 63 PUSH4 0xfc60dcf9 0261 14 EQ 0262 61 PUSH2 0x0d46 0265 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d46, if 0xfc60dcf9 == stack[-1] label_0266: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0265, if not 0xfc60dcf9 == stack[-1] // Inputs[1] { @026A msg.sender } 0266 5B JUMPDEST 0267 61 PUSH2 0x026f 026A 33 CALLER 026B 61 PUSH2 0x0d6f 026E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0267 stack[0] = 0x026f // @026A stack[1] = msg.sender // } // Block ends with call to 0x0d6f, returns to 0x026F label_026F: // Incoming return from call to 0x0D6F at 0x026E 026F 5B JUMPDEST 0270 00 *STOP // Stack delta = +0 // Outputs[1] { @0270 stop(); } // Block terminates label_0271: // Incoming jump from 0x003F, if 0x6f0231 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0272 msg.value } 0271 5B JUMPDEST 0272 34 CALLVALUE 0273 15 ISZERO 0274 61 PUSH2 0x027c 0277 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027c, if !msg.value label_0278: // Incoming jump from 0x0277, if not !msg.value // Inputs[1] { @027B memory[0x00:0x00] } 0278 60 PUSH1 0x00 027A 80 DUP1 027B FD *REVERT // Stack delta = +0 // Outputs[1] { @027B revert(memory[0x00:0x00]); } // Block terminates label_027C: // Incoming jump from 0x0277, if !msg.value // Inputs[1] { @0284 msg.data[0x04:0x24] } 027C 5B JUMPDEST 027D 61 PUSH2 0x0292 0280 60 PUSH1 0x04 0282 80 DUP1 0283 80 DUP1 0284 35 CALLDATALOAD 0285 90 SWAP1 0286 60 PUSH1 0x20 0288 01 ADD 0289 90 SWAP1 028A 91 SWAP2 028B 90 SWAP1 028C 50 POP 028D 50 POP 028E 61 PUSH2 0x0f50 0291 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @027D stack[0] = 0x0292 // @028A stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x0f50, returns to 0x0292 label_0292: // Incoming return from call to 0x0F50 at 0x0291 0292 5B JUMPDEST 0293 00 *STOP // Stack delta = +0 // Outputs[1] { @0293 stop(); } // Block terminates label_0294: // Incoming jump from 0x004A, if 0x06fdde03 == stack[-1] // Inputs[1] { @0295 msg.value } 0294 5B JUMPDEST 0295 34 CALLVALUE 0296 15 ISZERO 0297 61 PUSH2 0x029f 029A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029f, if !msg.value label_029B: // Incoming jump from 0x029A, if not !msg.value // Inputs[1] { @029E memory[0x00:0x00] } 029B 60 PUSH1 0x00 029D 80 DUP1 029E FD *REVERT // Stack delta = +0 // Outputs[1] { @029E revert(memory[0x00:0x00]); } // Block terminates label_029F: // Incoming jump from 0x029A, if !msg.value 029F 5B JUMPDEST 02A0 61 PUSH2 0x02a7 02A3 61 PUSH2 0x0fd4 02A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @02A0 stack[0] = 0x02a7 } // Block ends with call to 0x0fd4, returns to 0x02A7 label_02A7: // Incoming return from call to 0x0FD4 at 0x02A6 // Inputs[4] // { // @02AA memory[0x40:0x60] // @02B5 stack[-1] // @02B8 memory[stack[-1]:stack[-1] + 0x20] // @02C1 memory[stack[-1]:stack[-1] + 0x20] // } 02A7 5B JUMPDEST 02A8 60 PUSH1 0x40 02AA 51 MLOAD 02AB 80 DUP1 02AC 80 DUP1 02AD 60 PUSH1 0x20 02AF 01 ADD 02B0 82 DUP3 02B1 81 DUP2 02B2 03 SUB 02B3 82 DUP3 02B4 52 MSTORE 02B5 83 DUP4 02B6 81 DUP2 02B7 81 DUP2 02B8 51 MLOAD 02B9 81 DUP2 02BA 52 MSTORE 02BB 60 PUSH1 0x20 02BD 01 ADD 02BE 91 SWAP2 02BF 50 POP 02C0 80 DUP1 02C1 51 MLOAD 02C2 90 SWAP1 02C3 60 PUSH1 0x20 02C5 01 ADD 02C6 90 SWAP1 02C7 80 DUP1 02C8 83 DUP4 02C9 83 DUP4 02CA 60 PUSH1 0x00 02CC 5B JUMPDEST 02CD 83 DUP4 02CE 81 DUP2 02CF 10 LT 02D0 15 ISZERO 02D1 61 PUSH2 0x02e7 02D4 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02AA stack[0] = memory[0x40:0x60] // @02AB stack[1] = memory[0x40:0x60] // @02B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @02BA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02BE stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @02C6 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02C6 stack[3] = 0x20 + stack[-1] // @02C7 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02C8 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @02C9 stack[7] = 0x20 + stack[-1] // @02CA stack[8] = 0x00 // } // Block ends with conditional jump to 0x02e7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02D5: // Incoming jump from 0x02D4, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x02D4, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @02D5 stack[-1] // @02D6 stack[-2] // @02D8 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02DA stack[-3] // } 02D5 80 DUP1 02D6 82 DUP3 02D7 01 ADD 02D8 51 MLOAD 02D9 81 DUP2 02DA 84 DUP5 02DB 01 ADD 02DC 52 MSTORE 02DD 60 PUSH1 0x20 02DF 81 DUP2 02E0 01 ADD 02E1 90 SWAP1 02E2 50 POP 02E3 61 PUSH2 0x02cc 02E6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02DC memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02E1 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x02cc label_02E7: // Incoming jump from 0x02D4, if !(stack[-1] < stack[-4]) // Incoming jump from 0x02D4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @02EC stack[-6] // @02EC stack[-5] // @02EE stack[-7] // } 02E7 5B JUMPDEST 02E8 50 POP 02E9 50 POP 02EA 50 POP 02EB 50 POP 02EC 90 SWAP1 02ED 50 POP 02EE 90 SWAP1 02EF 81 DUP2 02F0 01 ADD 02F1 90 SWAP1 02F2 60 PUSH1 0x1f 02F4 16 AND 02F5 80 DUP1 02F6 15 ISZERO 02F7 61 PUSH2 0x0314 02FA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02F1 stack[-7] = stack[-5] + stack[-7] // @02F4 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0314, if !(0x1f & stack[-5]) label_02FB: // Incoming jump from 0x02FA, if not !(0x1f & stack[-5]) // Inputs[6] // { // @02FB stack[-1] // @02FC stack[-2] // @02FF memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0316 stack[-5] // @031C memory[0x40:0x60] // @0321 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 02FB 80 DUP1 02FC 82 DUP3 02FD 03 SUB 02FE 80 DUP1 02FF 51 MLOAD 0300 60 PUSH1 0x01 0302 83 DUP4 0303 60 PUSH1 0x20 0305 03 SUB 0306 61 PUSH2 0x0100 0309 0A EXP 030A 03 SUB 030B 19 NOT 030C 16 AND 030D 81 DUP2 030E 52 MSTORE 030F 60 PUSH1 0x20 0311 01 ADD 0312 91 SWAP2 0313 50 POP 0314 5B JUMPDEST 0315 50 POP 0316 92 SWAP3 0317 50 POP 0318 50 POP 0319 50 POP 031A 60 PUSH1 0x40 031C 51 MLOAD 031D 80 DUP1 031E 91 SWAP2 031F 03 SUB 0320 90 SWAP1 0321 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @030E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0321 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0322: // Incoming jump from 0x0055, if 0x083c6323 == stack[-1] // Inputs[1] { @0323 msg.value } 0322 5B JUMPDEST 0323 34 CALLVALUE 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032d, if !msg.value label_0329: // Incoming jump from 0x0328, if not !msg.value // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming jump from 0x0328, if !msg.value 032D 5B JUMPDEST 032E 61 PUSH2 0x0335 0331 61 PUSH2 0x107c 0334 56 *JUMP // Stack delta = +1 // Outputs[1] { @032E stack[0] = 0x0335 } // Block ends with call to 0x107c, returns to 0x0335 label_0335: // Incoming return from call to 0x107C at 0x0334 // Inputs[4] // { // @0338 memory[0x40:0x60] // @033A stack[-1] // @0345 memory[0x40:0x60] // @034A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0335 5B JUMPDEST 0336 60 PUSH1 0x40 0338 51 MLOAD 0339 80 DUP1 033A 82 DUP3 033B 81 DUP2 033C 52 MSTORE 033D 60 PUSH1 0x20 033F 01 ADD 0340 91 SWAP2 0341 50 POP 0342 50 POP 0343 60 PUSH1 0x40 0345 51 MLOAD 0346 80 DUP1 0347 91 SWAP2 0348 03 SUB 0349 90 SWAP1 034A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @033C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @034A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_034B: // Incoming jump from 0x0060, if 0x095ea7b3 == stack[-1] // Inputs[1] { @034C msg.value } 034B 5B JUMPDEST 034C 34 CALLVALUE 034D 15 ISZERO 034E 61 PUSH2 0x0356 0351 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0356, if !msg.value label_0352: // Incoming jump from 0x0351, if not !msg.value // Inputs[1] { @0355 memory[0x00:0x00] } 0352 60 PUSH1 0x00 0354 80 DUP1 0355 FD *REVERT // Stack delta = +0 // Outputs[1] { @0355 revert(memory[0x00:0x00]); } // Block terminates label_0356: // Incoming jump from 0x0351, if !msg.value // Inputs[2] // { // @035E msg.data[0x04:0x24] // @037D msg.data[0x24:0x44] // } 0356 5B JUMPDEST 0357 61 PUSH2 0x038b 035A 60 PUSH1 0x04 035C 80 DUP1 035D 80 DUP1 035E 35 CALLDATALOAD 035F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0374 16 AND 0375 90 SWAP1 0376 60 PUSH1 0x20 0378 01 ADD 0379 90 SWAP1 037A 91 SWAP2 037B 90 SWAP1 037C 80 DUP1 037D 35 CALLDATALOAD 037E 90 SWAP1 037F 60 PUSH1 0x20 0381 01 ADD 0382 90 SWAP1 0383 91 SWAP2 0384 90 SWAP1 0385 50 POP 0386 50 POP 0387 61 PUSH2 0x1082 038A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0357 stack[0] = 0x038b // @037A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0383 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x1082, returns to 0x038B label_038B: // Incoming return from call to 0x1082 at 0x038A // Inputs[4] // { // @038E memory[0x40:0x60] // @0390 stack[-1] // @039F memory[0x40:0x60] // @03A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 038B 5B JUMPDEST 038C 60 PUSH1 0x40 038E 51 MLOAD 038F 80 DUP1 0390 82 DUP3 0391 15 ISZERO 0392 15 ISZERO 0393 15 ISZERO 0394 15 ISZERO 0395 81 DUP2 0396 52 MSTORE 0397 60 PUSH1 0x20 0399 01 ADD 039A 91 SWAP2 039B 50 POP 039C 50 POP 039D 60 PUSH1 0x40 039F 51 MLOAD 03A0 80 DUP1 03A1 91 SWAP2 03A2 03 SUB 03A3 90 SWAP1 03A4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0396 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @03A4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03A5: // Incoming jump from 0x006B, if 0x09fd8212 == stack[-1] // Inputs[1] { @03A6 msg.value } 03A5 5B JUMPDEST 03A6 34 CALLVALUE 03A7 15 ISZERO 03A8 61 PUSH2 0x03b0 03AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b0, if !msg.value label_03AC: // Incoming jump from 0x03AB, if not !msg.value // Inputs[1] { @03AF memory[0x00:0x00] } 03AC 60 PUSH1 0x00 03AE 80 DUP1 03AF FD *REVERT // Stack delta = +0 // Outputs[1] { @03AF revert(memory[0x00:0x00]); } // Block terminates label_03B0: // Incoming jump from 0x03AB, if !msg.value // Inputs[1] { @03B8 msg.data[0x04:0x24] } 03B0 5B JUMPDEST 03B1 61 PUSH2 0x03dc 03B4 60 PUSH1 0x04 03B6 80 DUP1 03B7 80 DUP1 03B8 35 CALLDATALOAD 03B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03CE 16 AND 03CF 90 SWAP1 03D0 60 PUSH1 0x20 03D2 01 ADD 03D3 90 SWAP1 03D4 91 SWAP2 03D5 90 SWAP1 03D6 50 POP 03D7 50 POP 03D8 61 PUSH2 0x1223 03DB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03B1 stack[0] = 0x03dc // @03D4 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1223, returns to 0x03DC label_03DC: // Incoming return from call to 0x1223 at 0x03DB // Inputs[4] // { // @03DF memory[0x40:0x60] // @03E1 stack[-1] // @03F0 memory[0x40:0x60] // @03F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03DC 5B JUMPDEST 03DD 60 PUSH1 0x40 03DF 51 MLOAD 03E0 80 DUP1 03E1 82 DUP3 03E2 15 ISZERO 03E3 15 ISZERO 03E4 15 ISZERO 03E5 15 ISZERO 03E6 81 DUP2 03E7 52 MSTORE 03E8 60 PUSH1 0x20 03EA 01 ADD 03EB 91 SWAP2 03EC 50 POP 03ED 50 POP 03EE 60 PUSH1 0x40 03F0 51 MLOAD 03F1 80 DUP1 03F2 91 SWAP2 03F3 03 SUB 03F4 90 SWAP1 03F5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @03F5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03F6: // Incoming jump from 0x0076, if 0x121cd7ed == stack[-1] // Inputs[1] { @03F7 msg.value } 03F6 5B JUMPDEST 03F7 34 CALLVALUE 03F8 15 ISZERO 03F9 61 PUSH2 0x0401 03FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0401, if !msg.value label_03FD: // Incoming jump from 0x03FC, if not !msg.value // Inputs[1] { @0400 memory[0x00:0x00] } 03FD 60 PUSH1 0x00 03FF 80 DUP1 0400 FD *REVERT // Stack delta = +0 // Outputs[1] { @0400 revert(memory[0x00:0x00]); } // Block terminates label_0401: // Incoming jump from 0x03FC, if !msg.value 0401 5B JUMPDEST 0402 61 PUSH2 0x0409 0405 61 PUSH2 0x1279 0408 56 *JUMP // Stack delta = +1 // Outputs[1] { @0402 stack[0] = 0x0409 } // Block ends with call to 0x1279, returns to 0x0409 label_0409: // Incoming return from call to 0x1279 at 0x0408 // Inputs[4] // { // @040C memory[0x40:0x60] // @040E stack[-1] // @041D memory[0x40:0x60] // @0422 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0409 5B JUMPDEST 040A 60 PUSH1 0x40 040C 51 MLOAD 040D 80 DUP1 040E 82 DUP3 040F 15 ISZERO 0410 15 ISZERO 0411 15 ISZERO 0412 15 ISZERO 0413 81 DUP2 0414 52 MSTORE 0415 60 PUSH1 0x20 0417 01 ADD 0418 91 SWAP2 0419 50 POP 041A 50 POP 041B 60 PUSH1 0x40 041D 51 MLOAD 041E 80 DUP1 041F 91 SWAP2 0420 03 SUB 0421 90 SWAP1 0422 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0414 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0422 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0423: // Incoming jump from 0x0081, if 0x18160ddd == stack[-1] // Inputs[1] { @0424 msg.value } 0423 5B JUMPDEST 0424 34 CALLVALUE 0425 15 ISZERO 0426 61 PUSH2 0x042e 0429 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042e, if !msg.value label_042A: // Incoming jump from 0x0429, if not !msg.value // Inputs[1] { @042D memory[0x00:0x00] } 042A 60 PUSH1 0x00 042C 80 DUP1 042D FD *REVERT // Stack delta = +0 // Outputs[1] { @042D revert(memory[0x00:0x00]); } // Block terminates label_042E: // Incoming jump from 0x0429, if !msg.value 042E 5B JUMPDEST 042F 61 PUSH2 0x0436 0432 61 PUSH2 0x128c 0435 56 *JUMP // Stack delta = +1 // Outputs[1] { @042F stack[0] = 0x0436 } // Block ends with call to 0x128c, returns to 0x0436 label_0436: // Incoming return from call to 0x128C at 0x0435 // Inputs[4] // { // @0439 memory[0x40:0x60] // @043B stack[-1] // @0446 memory[0x40:0x60] // @044B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0436 5B JUMPDEST 0437 60 PUSH1 0x40 0439 51 MLOAD 043A 80 DUP1 043B 82 DUP3 043C 81 DUP2 043D 52 MSTORE 043E 60 PUSH1 0x20 0440 01 ADD 0441 91 SWAP2 0442 50 POP 0443 50 POP 0444 60 PUSH1 0x40 0446 51 MLOAD 0447 80 DUP1 0448 91 SWAP2 0449 03 SUB 044A 90 SWAP1 044B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @043D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @044B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_044C: // Incoming jump from 0x008C, if 0x190eaaba == stack[-1] // Inputs[1] { @044D msg.value } 044C 5B JUMPDEST 044D 34 CALLVALUE 044E 15 ISZERO 044F 61 PUSH2 0x0457 0452 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0457, if !msg.value label_0453: // Incoming jump from 0x0452, if not !msg.value // Inputs[1] { @0456 memory[0x00:0x00] } 0453 60 PUSH1 0x00 0455 80 DUP1 0456 FD *REVERT // Stack delta = +0 // Outputs[1] { @0456 revert(memory[0x00:0x00]); } // Block terminates label_0457: // Incoming jump from 0x0452, if !msg.value 0457 5B JUMPDEST 0458 61 PUSH2 0x045f 045B 61 PUSH2 0x1296 045E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0458 stack[0] = 0x045f } // Block ends with call to 0x1296, returns to 0x045F label_045F: // Incoming return from call to 0x1296 at 0x045E // Inputs[4] // { // @0462 memory[0x40:0x60] // @0464 stack[-1] // @046F memory[0x40:0x60] // @0474 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 045F 5B JUMPDEST 0460 60 PUSH1 0x40 0462 51 MLOAD 0463 80 DUP1 0464 82 DUP3 0465 81 DUP2 0466 52 MSTORE 0467 60 PUSH1 0x20 0469 01 ADD 046A 91 SWAP2 046B 50 POP 046C 50 POP 046D 60 PUSH1 0x40 046F 51 MLOAD 0470 80 DUP1 0471 91 SWAP2 0472 03 SUB 0473 90 SWAP1 0474 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0466 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0474 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0475: // Incoming jump from 0x0097, if 0x202bf004 == stack[-1] // Inputs[1] { @0476 msg.value } 0475 5B JUMPDEST 0476 34 CALLVALUE 0477 15 ISZERO 0478 61 PUSH2 0x0480 047B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0480, if !msg.value label_047C: // Incoming jump from 0x047B, if not !msg.value // Inputs[1] { @047F memory[0x00:0x00] } 047C 60 PUSH1 0x00 047E 80 DUP1 047F FD *REVERT // Stack delta = +0 // Outputs[1] { @047F revert(memory[0x00:0x00]); } // Block terminates label_0480: // Incoming jump from 0x047B, if !msg.value // Inputs[1] { @0488 msg.data[0x04:0x24] } 0480 5B JUMPDEST 0481 61 PUSH2 0x0496 0484 60 PUSH1 0x04 0486 80 DUP1 0487 80 DUP1 0488 35 CALLDATALOAD 0489 90 SWAP1 048A 60 PUSH1 0x20 048C 01 ADD 048D 90 SWAP1 048E 91 SWAP2 048F 90 SWAP1 0490 50 POP 0491 50 POP 0492 61 PUSH2 0x1310 0495 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0481 stack[0] = 0x0496 // @048E stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x1310, returns to 0x0496 label_0496: // Incoming return from call to 0x1310 at 0x0495 0496 5B JUMPDEST 0497 00 *STOP // Stack delta = +0 // Outputs[1] { @0497 stop(); } // Block terminates label_0498: // Incoming jump from 0x00A2, if 0x23b872dd == stack[-1] // Inputs[1] { @0499 msg.value } 0498 5B JUMPDEST 0499 34 CALLVALUE 049A 15 ISZERO 049B 61 PUSH2 0x04a3 049E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a3, if !msg.value label_049F: // Incoming jump from 0x049E, if not !msg.value // Inputs[1] { @04A2 memory[0x00:0x00] } 049F 60 PUSH1 0x00 04A1 80 DUP1 04A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A2 revert(memory[0x00:0x00]); } // Block terminates label_04A3: // Incoming jump from 0x049E, if !msg.value // Inputs[3] // { // @04AB msg.data[0x04:0x24] // @04CA msg.data[0x24:0x44] // @04E9 msg.data[0x44:0x64] // } 04A3 5B JUMPDEST 04A4 61 PUSH2 0x04f7 04A7 60 PUSH1 0x04 04A9 80 DUP1 04AA 80 DUP1 04AB 35 CALLDATALOAD 04AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C1 16 AND 04C2 90 SWAP1 04C3 60 PUSH1 0x20 04C5 01 ADD 04C6 90 SWAP1 04C7 91 SWAP2 04C8 90 SWAP1 04C9 80 DUP1 04CA 35 CALLDATALOAD 04CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04E0 16 AND 04E1 90 SWAP1 04E2 60 PUSH1 0x20 04E4 01 ADD 04E5 90 SWAP1 04E6 91 SWAP2 04E7 90 SWAP1 04E8 80 DUP1 04E9 35 CALLDATALOAD 04EA 90 SWAP1 04EB 60 PUSH1 0x20 04ED 01 ADD 04EE 90 SWAP1 04EF 91 SWAP2 04F0 90 SWAP1 04F1 50 POP 04F2 50 POP 04F3 61 PUSH2 0x1376 04F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04A4 stack[0] = 0x04f7 // @04C7 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @04E6 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @04EF stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x1376, returns to 0x04F7 label_04F7: // Incoming return from call to 0x1376 at 0x04F6 // Inputs[4] // { // @04FA memory[0x40:0x60] // @04FC stack[-1] // @050B memory[0x40:0x60] // @0510 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04F7 5B JUMPDEST 04F8 60 PUSH1 0x40 04FA 51 MLOAD 04FB 80 DUP1 04FC 82 DUP3 04FD 15 ISZERO 04FE 15 ISZERO 04FF 15 ISZERO 0500 15 ISZERO 0501 81 DUP2 0502 52 MSTORE 0503 60 PUSH1 0x20 0505 01 ADD 0506 91 SWAP2 0507 50 POP 0508 50 POP 0509 60 PUSH1 0x40 050B 51 MLOAD 050C 80 DUP1 050D 91 SWAP2 050E 03 SUB 050F 90 SWAP1 0510 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0502 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0510 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0511: // Incoming jump from 0x00AD, if 0x2a004bb2 == stack[-1] // Inputs[1] { @0512 msg.value } 0511 5B JUMPDEST 0512 34 CALLVALUE 0513 15 ISZERO 0514 61 PUSH2 0x051c 0517 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051c, if !msg.value label_0518: // Incoming jump from 0x0517, if not !msg.value // Inputs[1] { @051B memory[0x00:0x00] } 0518 60 PUSH1 0x00 051A 80 DUP1 051B FD *REVERT // Stack delta = +0 // Outputs[1] { @051B revert(memory[0x00:0x00]); } // Block terminates label_051C: // Incoming jump from 0x0517, if !msg.value // Inputs[1] { @0524 msg.data[0x04:0x24] } 051C 5B JUMPDEST 051D 61 PUSH2 0x0548 0520 60 PUSH1 0x04 0522 80 DUP1 0523 80 DUP1 0524 35 CALLDATALOAD 0525 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 053A 16 AND 053B 90 SWAP1 053C 60 PUSH1 0x20 053E 01 ADD 053F 90 SWAP1 0540 91 SWAP2 0541 90 SWAP1 0542 50 POP 0543 50 POP 0544 61 PUSH2 0x1457 0547 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @051D stack[0] = 0x0548 // @0540 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1457, returns to 0x0548 label_0548: // Incoming return from call to 0x1457 at 0x0547 0548 5B JUMPDEST 0549 00 *STOP // Stack delta = +0 // Outputs[1] { @0549 stop(); } // Block terminates label_054A: // Incoming jump from 0x00B8, if 0x313ce567 == stack[-1] // Inputs[1] { @054B msg.value } 054A 5B JUMPDEST 054B 34 CALLVALUE 054C 15 ISZERO 054D 61 PUSH2 0x0555 0550 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0555, if !msg.value label_0551: // Incoming jump from 0x0550, if not !msg.value // Inputs[1] { @0554 memory[0x00:0x00] } 0551 60 PUSH1 0x00 0553 80 DUP1 0554 FD *REVERT // Stack delta = +0 // Outputs[1] { @0554 revert(memory[0x00:0x00]); } // Block terminates label_0555: // Incoming jump from 0x0550, if !msg.value 0555 5B JUMPDEST 0556 61 PUSH2 0x055d 0559 61 PUSH2 0x1533 055C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0556 stack[0] = 0x055d } // Block ends with call to 0x1533, returns to 0x055D label_055D: // Incoming return from call to 0x1533 at 0x055C // Inputs[4] // { // @0560 memory[0x40:0x60] // @0562 stack[-1] // @0573 memory[0x40:0x60] // @0578 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 055D 5B JUMPDEST 055E 60 PUSH1 0x40 0560 51 MLOAD 0561 80 DUP1 0562 82 DUP3 0563 60 PUSH1 0xff 0565 16 AND 0566 60 PUSH1 0xff 0568 16 AND 0569 81 DUP2 056A 52 MSTORE 056B 60 PUSH1 0x20 056D 01 ADD 056E 91 SWAP2 056F 50 POP 0570 50 POP 0571 60 PUSH1 0x40 0573 51 MLOAD 0574 80 DUP1 0575 91 SWAP2 0576 03 SUB 0577 90 SWAP1 0578 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @056A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @0578 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0579: // Incoming jump from 0x00C3, if 0x3ccfd60b == stack[-1] // Inputs[1] { @057A msg.value } 0579 5B JUMPDEST 057A 34 CALLVALUE 057B 15 ISZERO 057C 61 PUSH2 0x0584 057F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0584, if !msg.value label_0580: // Incoming jump from 0x057F, if not !msg.value // Inputs[1] { @0583 memory[0x00:0x00] } 0580 60 PUSH1 0x00 0582 80 DUP1 0583 FD *REVERT // Stack delta = +0 // Outputs[1] { @0583 revert(memory[0x00:0x00]); } // Block terminates label_0584: // Incoming jump from 0x057F, if !msg.value 0584 5B JUMPDEST 0585 61 PUSH2 0x058c 0588 61 PUSH2 0x154a 058B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0585 stack[0] = 0x058c } // Block ends with call to 0x154a, returns to 0x058C label_058C: // Incoming return from call to 0x154A at 0x058B 058C 5B JUMPDEST 058D 00 *STOP // Stack delta = +0 // Outputs[1] { @058D stop(); } // Block terminates label_058E: // Incoming jump from 0x00CE, if 0x42667f34 == stack[-1] // Inputs[1] { @058F msg.value } 058E 5B JUMPDEST 058F 34 CALLVALUE 0590 15 ISZERO 0591 61 PUSH2 0x0599 0594 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0599, if !msg.value label_0595: // Incoming jump from 0x0594, if not !msg.value // Inputs[1] { @0598 memory[0x00:0x00] } 0595 60 PUSH1 0x00 0597 80 DUP1 0598 FD *REVERT // Stack delta = +0 // Outputs[1] { @0598 revert(memory[0x00:0x00]); } // Block terminates label_0599: // Incoming jump from 0x0594, if !msg.value 0599 5B JUMPDEST 059A 61 PUSH2 0x05a1 059D 61 PUSH2 0x18f3 05A0 56 *JUMP // Stack delta = +1 // Outputs[1] { @059A stack[0] = 0x05a1 } // Block ends with call to 0x18f3, returns to 0x05A1 label_05A1: // Incoming return from call to 0x18F3 at 0x05A0 // Inputs[4] // { // @05A4 memory[0x40:0x60] // @05A6 stack[-1] // @05B1 memory[0x40:0x60] // @05B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A1 5B JUMPDEST 05A2 60 PUSH1 0x40 05A4 51 MLOAD 05A5 80 DUP1 05A6 82 DUP3 05A7 81 DUP2 05A8 52 MSTORE 05A9 60 PUSH1 0x20 05AB 01 ADD 05AC 91 SWAP2 05AD 50 POP 05AE 50 POP 05AF 60 PUSH1 0x40 05B1 51 MLOAD 05B2 80 DUP1 05B3 91 SWAP2 05B4 03 SUB 05B5 90 SWAP1 05B6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05B6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05B7: // Incoming jump from 0x00D9, if 0x486c96fa == stack[-1] // Inputs[1] { @05B8 msg.value } 05B7 5B JUMPDEST 05B8 34 CALLVALUE 05B9 15 ISZERO 05BA 61 PUSH2 0x05c2 05BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c2, if !msg.value label_05BE: // Incoming jump from 0x05BD, if not !msg.value // Inputs[1] { @05C1 memory[0x00:0x00] } 05BE 60 PUSH1 0x00 05C0 80 DUP1 05C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C1 revert(memory[0x00:0x00]); } // Block terminates label_05C2: // Incoming jump from 0x05BD, if !msg.value 05C2 5B JUMPDEST 05C3 61 PUSH2 0x05ca 05C6 61 PUSH2 0x18f9 05C9 56 *JUMP // Stack delta = +1 // Outputs[1] { @05C3 stack[0] = 0x05ca } // Block ends with call to 0x18f9, returns to 0x05CA label_05CA: // Incoming return from call to 0x18F9 at 0x05C9 // Inputs[4] // { // @05CD memory[0x40:0x60] // @05CF stack[-1] // @0606 memory[0x40:0x60] // @060B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05CA 5B JUMPDEST 05CB 60 PUSH1 0x40 05CD 51 MLOAD 05CE 80 DUP1 05CF 82 DUP3 05D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E5 16 AND 05E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05FB 16 AND 05FC 81 DUP2 05FD 52 MSTORE 05FE 60 PUSH1 0x20 0600 01 ADD 0601 91 SWAP2 0602 50 POP 0603 50 POP 0604 60 PUSH1 0x40 0606 51 MLOAD 0607 80 DUP1 0608 91 SWAP2 0609 03 SUB 060A 90 SWAP1 060B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @060B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_060C: // Incoming jump from 0x00E4, if 0x48cd4cb1 == stack[-1] // Inputs[1] { @060D msg.value } 060C 5B JUMPDEST 060D 34 CALLVALUE 060E 15 ISZERO 060F 61 PUSH2 0x0617 0612 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0617, if !msg.value label_0613: // Incoming jump from 0x0612, if not !msg.value // Inputs[1] { @0616 memory[0x00:0x00] } 0613 60 PUSH1 0x00 0615 80 DUP1 0616 FD *REVERT // Stack delta = +0 // Outputs[1] { @0616 revert(memory[0x00:0x00]); } // Block terminates label_0617: // Incoming jump from 0x0612, if !msg.value 0617 5B JUMPDEST 0618 61 PUSH2 0x061f 061B 61 PUSH2 0x191f 061E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0618 stack[0] = 0x061f } // Block ends with call to 0x191f, returns to 0x061F label_061F: // Incoming return from call to 0x191F at 0x061E // Inputs[4] // { // @0622 memory[0x40:0x60] // @0624 stack[-1] // @062F memory[0x40:0x60] // @0634 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 061F 5B JUMPDEST 0620 60 PUSH1 0x40 0622 51 MLOAD 0623 80 DUP1 0624 82 DUP3 0625 81 DUP2 0626 52 MSTORE 0627 60 PUSH1 0x20 0629 01 ADD 062A 91 SWAP2 062B 50 POP 062C 50 POP 062D 60 PUSH1 0x40 062F 51 MLOAD 0630 80 DUP1 0631 91 SWAP2 0632 03 SUB 0633 90 SWAP1 0634 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0626 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0634 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0635: // Incoming jump from 0x00EF, if 0x5e6f6045 == stack[-1] // Inputs[1] { @0636 msg.value } 0635 5B JUMPDEST 0636 34 CALLVALUE 0637 15 ISZERO 0638 61 PUSH2 0x0640 063B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0640, if !msg.value label_063C: // Incoming jump from 0x063B, if not !msg.value // Inputs[1] { @063F memory[0x00:0x00] } 063C 60 PUSH1 0x00 063E 80 DUP1 063F FD *REVERT // Stack delta = +0 // Outputs[1] { @063F revert(memory[0x00:0x00]); } // Block terminates label_0640: // Incoming jump from 0x063B, if !msg.value 0640 5B JUMPDEST 0641 61 PUSH2 0x0648 0644 61 PUSH2 0x1925 0647 56 *JUMP // Stack delta = +1 // Outputs[1] { @0641 stack[0] = 0x0648 } // Block ends with call to 0x1925, returns to 0x0648 label_0648: // Incoming return from call to 0x1925 at 0x0647 // Inputs[4] // { // @064B memory[0x40:0x60] // @064D stack[-1] // @0684 memory[0x40:0x60] // @0689 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0648 5B JUMPDEST 0649 60 PUSH1 0x40 064B 51 MLOAD 064C 80 DUP1 064D 82 DUP3 064E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0663 16 AND 0664 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0679 16 AND 067A 81 DUP2 067B 52 MSTORE 067C 60 PUSH1 0x20 067E 01 ADD 067F 91 SWAP2 0680 50 POP 0681 50 POP 0682 60 PUSH1 0x40 0684 51 MLOAD 0685 80 DUP1 0686 91 SWAP2 0687 03 SUB 0688 90 SWAP1 0689 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @067B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0689 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_068A: // Incoming jump from 0x00FA, if 0x5ffde7be == stack[-1] // Inputs[1] { @068B msg.value } 068A 5B JUMPDEST 068B 34 CALLVALUE 068C 15 ISZERO 068D 61 PUSH2 0x0695 0690 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0695, if !msg.value label_0691: // Incoming jump from 0x0690, if not !msg.value // Inputs[1] { @0694 memory[0x00:0x00] } 0691 60 PUSH1 0x00 0693 80 DUP1 0694 FD *REVERT // Stack delta = +0 // Outputs[1] { @0694 revert(memory[0x00:0x00]); } // Block terminates label_0695: // Incoming jump from 0x0690, if !msg.value 0695 5B JUMPDEST 0696 61 PUSH2 0x069d 0699 61 PUSH2 0x194b 069C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0696 stack[0] = 0x069d } // Block ends with call to 0x194b, returns to 0x069D label_069D: // Incoming return from call to 0x194B at 0x069C // Inputs[4] // { // @06A0 memory[0x40:0x60] // @06A2 stack[-1] // @06AD memory[0x40:0x60] // @06B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 069D 5B JUMPDEST 069E 60 PUSH1 0x40 06A0 51 MLOAD 06A1 80 DUP1 06A2 82 DUP3 06A3 81 DUP2 06A4 52 MSTORE 06A5 60 PUSH1 0x20 06A7 01 ADD 06A8 91 SWAP2 06A9 50 POP 06AA 50 POP 06AB 60 PUSH1 0x40 06AD 51 MLOAD 06AE 80 DUP1 06AF 91 SWAP2 06B0 03 SUB 06B1 90 SWAP1 06B2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06B2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06B3: // Incoming jump from 0x0105, if 0x643a7695 == stack[-1] // Inputs[1] { @06B4 msg.value } 06B3 5B JUMPDEST 06B4 34 CALLVALUE 06B5 15 ISZERO 06B6 61 PUSH2 0x06be 06B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06be, if !msg.value label_06BA: // Incoming jump from 0x06B9, if not !msg.value // Inputs[1] { @06BD memory[0x00:0x00] } 06BA 60 PUSH1 0x00 06BC 80 DUP1 06BD FD *REVERT // Stack delta = +0 // Outputs[1] { @06BD revert(memory[0x00:0x00]); } // Block terminates label_06BE: // Incoming jump from 0x06B9, if !msg.value // Inputs[1] { @06C6 msg.data[0x04:0x24] } 06BE 5B JUMPDEST 06BF 61 PUSH2 0x06ea 06C2 60 PUSH1 0x04 06C4 80 DUP1 06C5 80 DUP1 06C6 35 CALLDATALOAD 06C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06DC 16 AND 06DD 90 SWAP1 06DE 60 PUSH1 0x20 06E0 01 ADD 06E1 90 SWAP1 06E2 91 SWAP2 06E3 90 SWAP1 06E4 50 POP 06E5 50 POP 06E6 61 PUSH2 0x1951 06E9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06BF stack[0] = 0x06ea // @06E2 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1951, returns to 0x06EA label_06EA: // Incoming return from call to 0x1951 at 0x06E9 06EA 5B JUMPDEST 06EB 00 *STOP // Stack delta = +0 // Outputs[1] { @06EB stop(); } // Block terminates label_06EC: // Incoming jump from 0x0110, if 0x645006ca == stack[-1] // Inputs[1] { @06ED msg.value } 06EC 5B JUMPDEST 06ED 34 CALLVALUE 06EE 15 ISZERO 06EF 61 PUSH2 0x06f7 06F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f7, if !msg.value label_06F3: // Incoming jump from 0x06F2, if not !msg.value // Inputs[1] { @06F6 memory[0x00:0x00] } 06F3 60 PUSH1 0x00 06F5 80 DUP1 06F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F6 revert(memory[0x00:0x00]); } // Block terminates label_06F7: // Incoming jump from 0x06F2, if !msg.value 06F7 5B JUMPDEST 06F8 61 PUSH2 0x06ff 06FB 61 PUSH2 0x1aa3 06FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @06F8 stack[0] = 0x06ff } // Block ends with call to 0x1aa3, returns to 0x06FF label_06FF: // Incoming return from call to 0x1AA3 at 0x06FE // Inputs[4] // { // @0702 memory[0x40:0x60] // @0704 stack[-1] // @070F memory[0x40:0x60] // @0714 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06FF 5B JUMPDEST 0700 60 PUSH1 0x40 0702 51 MLOAD 0703 80 DUP1 0704 82 DUP3 0705 81 DUP2 0706 52 MSTORE 0707 60 PUSH1 0x20 0709 01 ADD 070A 91 SWAP2 070B 50 POP 070C 50 POP 070D 60 PUSH1 0x40 070F 51 MLOAD 0710 80 DUP1 0711 91 SWAP2 0712 03 SUB 0713 90 SWAP1 0714 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0706 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0714 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0715: // Incoming jump from 0x011B, if 0x6be4cf1f == stack[-1] // Inputs[1] { @071D msg.data[0x04:0x24] } 0715 5B JUMPDEST 0716 61 PUSH2 0x0741 0719 60 PUSH1 0x04 071B 80 DUP1 071C 80 DUP1 071D 35 CALLDATALOAD 071E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0733 16 AND 0734 90 SWAP1 0735 60 PUSH1 0x20 0737 01 ADD 0738 90 SWAP1 0739 91 SWAP2 073A 90 SWAP1 073B 50 POP 073C 50 POP 073D 61 PUSH2 0x0d6f 0740 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0716 stack[0] = 0x0741 // @0739 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0d6f, returns to 0x0741 label_0741: // Incoming return from call to 0x0D6F at 0x0740 0741 5B JUMPDEST 0742 00 *STOP // Stack delta = +0 // Outputs[1] { @0742 stop(); } // Block terminates label_0743: // Incoming jump from 0x0126, if 0x70a08231 == stack[-1] // Inputs[1] { @0744 msg.value } 0743 5B JUMPDEST 0744 34 CALLVALUE 0745 15 ISZERO 0746 61 PUSH2 0x074e 0749 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074e, if !msg.value label_074A: // Incoming jump from 0x0749, if not !msg.value // Inputs[1] { @074D memory[0x00:0x00] } 074A 60 PUSH1 0x00 074C 80 DUP1 074D FD *REVERT // Stack delta = +0 // Outputs[1] { @074D revert(memory[0x00:0x00]); } // Block terminates label_074E: // Incoming jump from 0x0749, if !msg.value // Inputs[1] { @0756 msg.data[0x04:0x24] } 074E 5B JUMPDEST 074F 61 PUSH2 0x077a 0752 60 PUSH1 0x04 0754 80 DUP1 0755 80 DUP1 0756 35 CALLDATALOAD 0757 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 076C 16 AND 076D 90 SWAP1 076E 60 PUSH1 0x20 0770 01 ADD 0771 90 SWAP1 0772 91 SWAP2 0773 90 SWAP1 0774 50 POP 0775 50 POP 0776 61 PUSH2 0x1aa9 0779 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @074F stack[0] = 0x077a // @0772 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1aa9, returns to 0x077A label_077A: // Incoming return from call to 0x1AA9 at 0x0779 // Inputs[4] // { // @077D memory[0x40:0x60] // @077F stack[-1] // @078A memory[0x40:0x60] // @078F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 077A 5B JUMPDEST 077B 60 PUSH1 0x40 077D 51 MLOAD 077E 80 DUP1 077F 82 DUP3 0780 81 DUP2 0781 52 MSTORE 0782 60 PUSH1 0x20 0784 01 ADD 0785 91 SWAP2 0786 50 POP 0787 50 POP 0788 60 PUSH1 0x40 078A 51 MLOAD 078B 80 DUP1 078C 91 SWAP2 078D 03 SUB 078E 90 SWAP1 078F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0781 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @078F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0790: // Incoming jump from 0x0131, if 0x74991569 == stack[-1] // Inputs[1] { @0791 msg.value } 0790 5B JUMPDEST 0791 34 CALLVALUE 0792 15 ISZERO 0793 61 PUSH2 0x079b 0796 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079b, if !msg.value label_0797: // Incoming jump from 0x0796, if not !msg.value // Inputs[1] { @079A memory[0x00:0x00] } 0797 60 PUSH1 0x00 0799 80 DUP1 079A FD *REVERT // Stack delta = +0 // Outputs[1] { @079A revert(memory[0x00:0x00]); } // Block terminates label_079B: // Incoming jump from 0x0796, if !msg.value // Inputs[1] { @07A3 msg.data[0x04:0x24] } 079B 5B JUMPDEST 079C 61 PUSH2 0x07c7 079F 60 PUSH1 0x04 07A1 80 DUP1 07A2 80 DUP1 07A3 35 CALLDATALOAD 07A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07B9 16 AND 07BA 90 SWAP1 07BB 60 PUSH1 0x20 07BD 01 ADD 07BE 90 SWAP1 07BF 91 SWAP2 07C0 90 SWAP1 07C1 50 POP 07C2 50 POP 07C3 61 PUSH2 0x1af2 07C6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @079C stack[0] = 0x07c7 // @07BF stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1af2, returns to 0x07C7 label_07C7: // Incoming return from call to 0x1AF2 at 0x07C6 07C7 5B JUMPDEST 07C8 00 *STOP // Stack delta = +0 // Outputs[1] { @07C8 stop(); } // Block terminates label_07C9: // Incoming jump from 0x013C, if 0x8a8c523c == stack[-1] // Inputs[1] { @07CA msg.value } 07C9 5B JUMPDEST 07CA 34 CALLVALUE 07CB 15 ISZERO 07CC 61 PUSH2 0x07d4 07CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07d4, if !msg.value label_07D0: // Incoming jump from 0x07CF, if not !msg.value // Inputs[1] { @07D3 memory[0x00:0x00] } 07D0 60 PUSH1 0x00 07D2 80 DUP1 07D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D3 revert(memory[0x00:0x00]); } // Block terminates label_07D4: // Incoming jump from 0x07CF, if !msg.value 07D4 5B JUMPDEST 07D5 61 PUSH2 0x07dc 07D8 61 PUSH2 0x1c63 07DB 56 *JUMP // Stack delta = +1 // Outputs[1] { @07D5 stack[0] = 0x07dc } // Block ends with call to 0x1c63, returns to 0x07DC label_07DC: // Incoming return from call to 0x1C63 at 0x07DB 07DC 5B JUMPDEST 07DD 00 *STOP // Stack delta = +0 // Outputs[1] { @07DD stop(); } // Block terminates label_07DE: // Incoming jump from 0x0147, if 0x8b4ecbe0 == stack[-1] // Inputs[1] { @07DF msg.value } 07DE 5B JUMPDEST 07DF 34 CALLVALUE 07E0 15 ISZERO 07E1 61 PUSH2 0x07e9 07E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e9, if !msg.value label_07E5: // Incoming jump from 0x07E4, if not !msg.value // Inputs[1] { @07E8 memory[0x00:0x00] } 07E5 60 PUSH1 0x00 07E7 80 DUP1 07E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E8 revert(memory[0x00:0x00]); } // Block terminates label_07E9: // Incoming jump from 0x07E4, if !msg.value // Inputs[1] { @07F1 msg.data[0x04:0x24] } 07E9 5B JUMPDEST 07EA 61 PUSH2 0x07ff 07ED 60 PUSH1 0x04 07EF 80 DUP1 07F0 80 DUP1 07F1 35 CALLDATALOAD 07F2 90 SWAP1 07F3 60 PUSH1 0x20 07F5 01 ADD 07F6 90 SWAP1 07F7 91 SWAP2 07F8 90 SWAP1 07F9 50 POP 07FA 50 POP 07FB 61 PUSH2 0x1cec 07FE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07EA stack[0] = 0x07ff // @07F7 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x1cec, returns to 0x07FF label_07FF: // Incoming return from call to 0x1CEC at 0x07FE 07FF 5B JUMPDEST 0800 00 *STOP // Stack delta = +0 // Outputs[1] { @0800 stop(); } // Block terminates label_0801: // Incoming jump from 0x0152, if 0x8d6cc56d == stack[-1] // Inputs[1] { @0802 msg.value } 0801 5B JUMPDEST 0802 34 CALLVALUE 0803 15 ISZERO 0804 61 PUSH2 0x080c 0807 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x080c, if !msg.value label_0808: // Incoming jump from 0x0807, if not !msg.value // Inputs[1] { @080B memory[0x00:0x00] } 0808 60 PUSH1 0x00 080A 80 DUP1 080B FD *REVERT // Stack delta = +0 // Outputs[1] { @080B revert(memory[0x00:0x00]); } // Block terminates label_080C: // Incoming jump from 0x0807, if !msg.value // Inputs[1] { @0814 msg.data[0x04:0x24] } 080C 5B JUMPDEST 080D 61 PUSH2 0x0822 0810 60 PUSH1 0x04 0812 80 DUP1 0813 80 DUP1 0814 35 CALLDATALOAD 0815 90 SWAP1 0816 60 PUSH1 0x20 0818 01 ADD 0819 90 SWAP1 081A 91 SWAP2 081B 90 SWAP1 081C 50 POP 081D 50 POP 081E 61 PUSH2 0x1d86 0821 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @080D stack[0] = 0x0822 // @081A stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x1d86, returns to 0x0822 label_0822: // Incoming return from call to 0x1D86 at 0x0821 0822 5B JUMPDEST 0823 00 *STOP // Stack delta = +0 // Outputs[1] { @0823 stop(); } // Block terminates label_0824: // Incoming jump from 0x015D, if 0x8f11e5f9 == stack[-1] // Inputs[1] { @0825 msg.value } 0824 5B JUMPDEST 0825 34 CALLVALUE 0826 15 ISZERO 0827 61 PUSH2 0x082f 082A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082f, if !msg.value label_082B: // Incoming jump from 0x082A, if not !msg.value // Inputs[1] { @082E memory[0x00:0x00] } 082B 60 PUSH1 0x00 082D 80 DUP1 082E FD *REVERT // Stack delta = +0 // Outputs[1] { @082E revert(memory[0x00:0x00]); } // Block terminates label_082F: // Incoming jump from 0x082A, if !msg.value // Inputs[1] { @0837 msg.data[0x04:0x24] } 082F 5B JUMPDEST 0830 61 PUSH2 0x0845 0833 60 PUSH1 0x04 0835 80 DUP1 0836 80 DUP1 0837 35 CALLDATALOAD 0838 90 SWAP1 0839 60 PUSH1 0x20 083B 01 ADD 083C 90 SWAP1 083D 91 SWAP2 083E 90 SWAP1 083F 50 POP 0840 50 POP 0841 61 PUSH2 0x1ed8 0844 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0830 stack[0] = 0x0845 // @083D stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x1ed8, returns to 0x0845 label_0845: // Incoming return from call to 0x1ED8 at 0x0844 // Inputs[4] // { // @0848 memory[0x40:0x60] // @084A stack[-1] // @0855 memory[0x40:0x60] // @085A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0845 5B JUMPDEST 0846 60 PUSH1 0x40 0848 51 MLOAD 0849 80 DUP1 084A 82 DUP3 084B 81 DUP2 084C 52 MSTORE 084D 60 PUSH1 0x20 084F 01 ADD 0850 91 SWAP2 0851 50 POP 0852 50 POP 0853 60 PUSH1 0x40 0855 51 MLOAD 0856 80 DUP1 0857 91 SWAP2 0858 03 SUB 0859 90 SWAP1 085A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @084C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @085A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_085B: // Incoming jump from 0x0168, if 0x9281cd65 == stack[-1] // Inputs[1] { @085C msg.value } 085B 5B JUMPDEST 085C 34 CALLVALUE 085D 15 ISZERO 085E 61 PUSH2 0x0866 0861 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0866, if !msg.value label_0862: // Incoming jump from 0x0861, if not !msg.value // Inputs[1] { @0865 memory[0x00:0x00] } 0862 60 PUSH1 0x00 0864 80 DUP1 0865 FD *REVERT // Stack delta = +0 // Outputs[1] { @0865 revert(memory[0x00:0x00]); } // Block terminates label_0866: // Incoming jump from 0x0861, if !msg.value // Inputs[3] // { // @086E msg.data[0x04:0x24] // @088D msg.data[0x24:0x44] // @0896 msg.data[0x44:0x64] // } 0866 5B JUMPDEST 0867 61 PUSH2 0x08a4 086A 60 PUSH1 0x04 086C 80 DUP1 086D 80 DUP1 086E 35 CALLDATALOAD 086F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0884 16 AND 0885 90 SWAP1 0886 60 PUSH1 0x20 0888 01 ADD 0889 90 SWAP1 088A 91 SWAP2 088B 90 SWAP1 088C 80 DUP1 088D 35 CALLDATALOAD 088E 90 SWAP1 088F 60 PUSH1 0x20 0891 01 ADD 0892 90 SWAP1 0893 91 SWAP2 0894 90 SWAP1 0895 80 DUP1 0896 35 CALLDATALOAD 0897 90 SWAP1 0898 60 PUSH1 0x20 089A 01 ADD 089B 90 SWAP1 089C 91 SWAP2 089D 90 SWAP1 089E 50 POP 089F 50 POP 08A0 61 PUSH2 0x1f51 08A3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0867 stack[0] = 0x08a4 // @088A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0893 stack[2] = msg.data[0x24:0x44] // @089C stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x1f51, returns to 0x08A4 label_08A4: // Incoming return from call to 0x1F51 at 0x08A3 // Inputs[4] // { // @08A7 memory[0x40:0x60] // @08A9 stack[-1] // @08B8 memory[0x40:0x60] // @08BD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08A4 5B JUMPDEST 08A5 60 PUSH1 0x40 08A7 51 MLOAD 08A8 80 DUP1 08A9 82 DUP3 08AA 15 ISZERO 08AB 15 ISZERO 08AC 15 ISZERO 08AD 15 ISZERO 08AE 81 DUP2 08AF 52 MSTORE 08B0 60 PUSH1 0x20 08B2 01 ADD 08B3 91 SWAP2 08B4 50 POP 08B5 50 POP 08B6 60 PUSH1 0x40 08B8 51 MLOAD 08B9 80 DUP1 08BA 91 SWAP2 08BB 03 SUB 08BC 90 SWAP1 08BD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @08BD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_08BE: // Incoming jump from 0x0173, if 0x95d89b41 == stack[-1] // Inputs[1] { @08BF msg.value } 08BE 5B JUMPDEST 08BF 34 CALLVALUE 08C0 15 ISZERO 08C1 61 PUSH2 0x08c9 08C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08c9, if !msg.value label_08C5: // Incoming jump from 0x08C4, if not !msg.value // Inputs[1] { @08C8 memory[0x00:0x00] } 08C5 60 PUSH1 0x00 08C7 80 DUP1 08C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @08C8 revert(memory[0x00:0x00]); } // Block terminates label_08C9: // Incoming jump from 0x08C4, if !msg.value 08C9 5B JUMPDEST 08CA 61 PUSH2 0x08d1 08CD 61 PUSH2 0x20e7 08D0 56 *JUMP // Stack delta = +1 // Outputs[1] { @08CA stack[0] = 0x08d1 } // Block ends with call to 0x20e7, returns to 0x08D1 label_08D1: // Incoming return from call to 0x20E7 at 0x08D0 // Inputs[4] // { // @08D4 memory[0x40:0x60] // @08DF stack[-1] // @08E2 memory[stack[-1]:stack[-1] + 0x20] // @08EB memory[stack[-1]:stack[-1] + 0x20] // } 08D1 5B JUMPDEST 08D2 60 PUSH1 0x40 08D4 51 MLOAD 08D5 80 DUP1 08D6 80 DUP1 08D7 60 PUSH1 0x20 08D9 01 ADD 08DA 82 DUP3 08DB 81 DUP2 08DC 03 SUB 08DD 82 DUP3 08DE 52 MSTORE 08DF 83 DUP4 08E0 81 DUP2 08E1 81 DUP2 08E2 51 MLOAD 08E3 81 DUP2 08E4 52 MSTORE 08E5 60 PUSH1 0x20 08E7 01 ADD 08E8 91 SWAP2 08E9 50 POP 08EA 80 DUP1 08EB 51 MLOAD 08EC 90 SWAP1 08ED 60 PUSH1 0x20 08EF 01 ADD 08F0 90 SWAP1 08F1 80 DUP1 08F2 83 DUP4 08F3 83 DUP4 08F4 60 PUSH1 0x00 08F6 5B JUMPDEST 08F7 83 DUP4 08F8 81 DUP2 08F9 10 LT 08FA 15 ISZERO 08FB 61 PUSH2 0x0911 08FE 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @08D4 stack[0] = memory[0x40:0x60] // @08D5 stack[1] = memory[0x40:0x60] // @08DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @08E4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @08E8 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @08F0 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @08F0 stack[3] = 0x20 + stack[-1] // @08F1 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @08F2 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @08F3 stack[7] = 0x20 + stack[-1] // @08F4 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0911, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_08FF: // Incoming jump from 0x08FE, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x08FE, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @08FF stack[-1] // @0900 stack[-2] // @0902 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0904 stack[-3] // } 08FF 80 DUP1 0900 82 DUP3 0901 01 ADD 0902 51 MLOAD 0903 81 DUP2 0904 84 DUP5 0905 01 ADD 0906 52 MSTORE 0907 60 PUSH1 0x20 0909 81 DUP2 090A 01 ADD 090B 90 SWAP1 090C 50 POP 090D 61 PUSH2 0x08f6 0910 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0906 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @090B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x08f6 label_0911: // Incoming jump from 0x08FE, if !(stack[-1] < stack[-4]) // Incoming jump from 0x08FE, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0916 stack[-6] // @0916 stack[-5] // @0918 stack[-7] // } 0911 5B JUMPDEST 0912 50 POP 0913 50 POP 0914 50 POP 0915 50 POP 0916 90 SWAP1 0917 50 POP 0918 90 SWAP1 0919 81 DUP2 091A 01 ADD 091B 90 SWAP1 091C 60 PUSH1 0x1f 091E 16 AND 091F 80 DUP1 0920 15 ISZERO 0921 61 PUSH2 0x093e 0924 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @091B stack[-7] = stack[-5] + stack[-7] // @091E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x093e, if !(0x1f & stack[-5]) label_0925: // Incoming jump from 0x0924, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0925 stack[-1] // @0926 stack[-2] // @0929 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0940 stack[-5] // @0946 memory[0x40:0x60] // @094B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0925 80 DUP1 0926 82 DUP3 0927 03 SUB 0928 80 DUP1 0929 51 MLOAD 092A 60 PUSH1 0x01 092C 83 DUP4 092D 60 PUSH1 0x20 092F 03 SUB 0930 61 PUSH2 0x0100 0933 0A EXP 0934 03 SUB 0935 19 NOT 0936 16 AND 0937 81 DUP2 0938 52 MSTORE 0939 60 PUSH1 0x20 093B 01 ADD 093C 91 SWAP2 093D 50 POP 093E 5B JUMPDEST 093F 50 POP 0940 92 SWAP3 0941 50 POP 0942 50 POP 0943 50 POP 0944 60 PUSH1 0x40 0946 51 MLOAD 0947 80 DUP1 0948 91 SWAP2 0949 03 SUB 094A 90 SWAP1 094B F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0938 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @094B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_094C: // Incoming jump from 0x017E, if 0x9b19251a == stack[-1] // Inputs[1] { @094D msg.value } 094C 5B JUMPDEST 094D 34 CALLVALUE 094E 15 ISZERO 094F 61 PUSH2 0x0957 0952 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0957, if !msg.value label_0953: // Incoming jump from 0x0952, if not !msg.value // Inputs[1] { @0956 memory[0x00:0x00] } 0953 60 PUSH1 0x00 0955 80 DUP1 0956 FD *REVERT // Stack delta = +0 // Outputs[1] { @0956 revert(memory[0x00:0x00]); } // Block terminates label_0957: // Incoming jump from 0x0952, if !msg.value // Inputs[1] { @095F msg.data[0x04:0x24] } 0957 5B JUMPDEST 0958 61 PUSH2 0x0983 095B 60 PUSH1 0x04 095D 80 DUP1 095E 80 DUP1 095F 35 CALLDATALOAD 0960 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0975 16 AND 0976 90 SWAP1 0977 60 PUSH1 0x20 0979 01 ADD 097A 90 SWAP1 097B 91 SWAP2 097C 90 SWAP1 097D 50 POP 097E 50 POP 097F 61 PUSH2 0x218f 0982 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0958 stack[0] = 0x0983 // @097B stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x218f, returns to 0x0983 label_0983: // Incoming return from call to 0x218F at 0x0982 // Inputs[4] // { // @0986 memory[0x40:0x60] // @0988 stack[-1] // @0997 memory[0x40:0x60] // @099C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0983 5B JUMPDEST 0984 60 PUSH1 0x40 0986 51 MLOAD 0987 80 DUP1 0988 82 DUP3 0989 15 ISZERO 098A 15 ISZERO 098B 15 ISZERO 098C 15 ISZERO 098D 81 DUP2 098E 52 MSTORE 098F 60 PUSH1 0x20 0991 01 ADD 0992 91 SWAP2 0993 50 POP 0994 50 POP 0995 60 PUSH1 0x40 0997 51 MLOAD 0998 80 DUP1 0999 91 SWAP2 099A 03 SUB 099B 90 SWAP1 099C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @098E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @099C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_099D: // Incoming jump from 0x0189, if 0x9c8f9f23 == stack[-1] // Inputs[1] { @099E msg.value } 099D 5B JUMPDEST 099E 34 CALLVALUE 099F 15 ISZERO 09A0 61 PUSH2 0x09a8 09A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09a8, if !msg.value label_09A4: // Incoming jump from 0x09A3, if not !msg.value // Inputs[1] { @09A7 memory[0x00:0x00] } 09A4 60 PUSH1 0x00 09A6 80 DUP1 09A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @09A7 revert(memory[0x00:0x00]); } // Block terminates label_09A8: // Incoming jump from 0x09A3, if !msg.value // Inputs[1] { @09B0 msg.data[0x04:0x24] } 09A8 5B JUMPDEST 09A9 61 PUSH2 0x09be 09AC 60 PUSH1 0x04 09AE 80 DUP1 09AF 80 DUP1 09B0 35 CALLDATALOAD 09B1 90 SWAP1 09B2 60 PUSH1 0x20 09B4 01 ADD 09B5 90 SWAP1 09B6 91 SWAP2 09B7 90 SWAP1 09B8 50 POP 09B9 50 POP 09BA 61 PUSH2 0x21af 09BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09A9 stack[0] = 0x09be // @09B6 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x21af, returns to 0x09BE label_09BE: // Incoming return from call to 0x21AF at 0x09BD 09BE 5B JUMPDEST 09BF 00 *STOP // Stack delta = +0 // Outputs[1] { @09BF stop(); } // Block terminates label_09C0: // Incoming jump from 0x0194, if 0x9d1b464a == stack[-1] // Inputs[1] { @09C1 msg.value } 09C0 5B JUMPDEST 09C1 34 CALLVALUE 09C2 15 ISZERO 09C3 61 PUSH2 0x09cb 09C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09cb, if !msg.value label_09C7: // Incoming jump from 0x09C6, if not !msg.value // Inputs[1] { @09CA memory[0x00:0x00] } 09C7 60 PUSH1 0x00 09C9 80 DUP1 09CA FD *REVERT // Stack delta = +0 // Outputs[1] { @09CA revert(memory[0x00:0x00]); } // Block terminates label_09CB: // Incoming jump from 0x09C6, if !msg.value 09CB 5B JUMPDEST 09CC 61 PUSH2 0x09d3 09CF 61 PUSH2 0x2325 09D2 56 *JUMP // Stack delta = +1 // Outputs[1] { @09CC stack[0] = 0x09d3 } // Block ends with call to 0x2325, returns to 0x09D3 label_09D3: // Incoming return from call to 0x2325 at 0x09D2 // Inputs[5] // { // @09D6 memory[0x40:0x60] // @09D8 stack[-2] // @09DE stack[-1] // @09EA memory[0x40:0x60] // @09EF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09D3 5B JUMPDEST 09D4 60 PUSH1 0x40 09D6 51 MLOAD 09D7 80 DUP1 09D8 83 DUP4 09D9 81 DUP2 09DA 52 MSTORE 09DB 60 PUSH1 0x20 09DD 01 ADD 09DE 82 DUP3 09DF 81 DUP2 09E0 52 MSTORE 09E1 60 PUSH1 0x20 09E3 01 ADD 09E4 92 SWAP3 09E5 50 POP 09E6 50 POP 09E7 50 POP 09E8 60 PUSH1 0x40 09EA 51 MLOAD 09EB 80 DUP1 09EC 91 SWAP2 09ED 03 SUB 09EE 90 SWAP1 09EF F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @09DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @09E0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @09EF return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_09F0: // Incoming jump from 0x019F, if 0x9ee679e8 == stack[-1] // Inputs[1] { @09F1 msg.value } 09F0 5B JUMPDEST 09F1 34 CALLVALUE 09F2 15 ISZERO 09F3 61 PUSH2 0x09fb 09F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09fb, if !msg.value label_09F7: // Incoming jump from 0x09F6, if not !msg.value // Inputs[1] { @09FA memory[0x00:0x00] } 09F7 60 PUSH1 0x00 09F9 80 DUP1 09FA FD *REVERT // Stack delta = +0 // Outputs[1] { @09FA revert(memory[0x00:0x00]); } // Block terminates label_09FB: // Incoming jump from 0x09F6, if !msg.value // Inputs[1] { @0A03 msg.data[0x04:0x24] } 09FB 5B JUMPDEST 09FC 61 PUSH2 0x0a11 09FF 60 PUSH1 0x04 0A01 80 DUP1 0A02 80 DUP1 0A03 35 CALLDATALOAD 0A04 90 SWAP1 0A05 60 PUSH1 0x20 0A07 01 ADD 0A08 90 SWAP1 0A09 91 SWAP2 0A0A 90 SWAP1 0A0B 50 POP 0A0C 50 POP 0A0D 61 PUSH2 0x2337 0A10 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09FC stack[0] = 0x0a11 // @0A09 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x2337, returns to 0x0A11 label_0A11: // Incoming return from call to 0x2337 at 0x0A10 0A11 5B JUMPDEST 0A12 00 *STOP // Stack delta = +0 // Outputs[1] { @0A12 stop(); } // Block terminates label_0A13: // Incoming jump from 0x01AA, if 0xa301ba6f == stack[-1] // Inputs[1] { @0A14 msg.value } 0A13 5B JUMPDEST 0A14 34 CALLVALUE 0A15 15 ISZERO 0A16 61 PUSH2 0x0a1e 0A19 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a1e, if !msg.value label_0A1A: // Incoming jump from 0x0A19, if not !msg.value // Inputs[1] { @0A1D memory[0x00:0x00] } 0A1A 60 PUSH1 0x00 0A1C 80 DUP1 0A1D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A1D revert(memory[0x00:0x00]); } // Block terminates label_0A1E: // Incoming jump from 0x0A19, if !msg.value 0A1E 5B JUMPDEST 0A1F 61 PUSH2 0x0a26 0A22 61 PUSH2 0x25fa 0A25 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A1F stack[0] = 0x0a26 } // Block ends with call to 0x25fa, returns to 0x0A26 label_0A26: // Incoming return from call to 0x25FA at 0x0A25 0A26 5B JUMPDEST 0A27 00 *STOP // Stack delta = +0 // Outputs[1] { @0A27 stop(); } // Block terminates label_0A28: // Incoming jump from 0x01B5, if 0xa9059cbb == stack[-1] // Inputs[1] { @0A29 msg.value } 0A28 5B JUMPDEST 0A29 34 CALLVALUE 0A2A 15 ISZERO 0A2B 61 PUSH2 0x0a33 0A2E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a33, if !msg.value label_0A2F: // Incoming jump from 0x0A2E, if not !msg.value // Inputs[1] { @0A32 memory[0x00:0x00] } 0A2F 60 PUSH1 0x00 0A31 80 DUP1 0A32 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A32 revert(memory[0x00:0x00]); } // Block terminates label_0A33: // Incoming jump from 0x0A2E, if !msg.value // Inputs[2] // { // @0A3B msg.data[0x04:0x24] // @0A5A msg.data[0x24:0x44] // } 0A33 5B JUMPDEST 0A34 61 PUSH2 0x0a68 0A37 60 PUSH1 0x04 0A39 80 DUP1 0A3A 80 DUP1 0A3B 35 CALLDATALOAD 0A3C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A51 16 AND 0A52 90 SWAP1 0A53 60 PUSH1 0x20 0A55 01 ADD 0A56 90 SWAP1 0A57 91 SWAP2 0A58 90 SWAP1 0A59 80 DUP1 0A5A 35 CALLDATALOAD 0A5B 90 SWAP1 0A5C 60 PUSH1 0x20 0A5E 01 ADD 0A5F 90 SWAP1 0A60 91 SWAP2 0A61 90 SWAP1 0A62 50 POP 0A63 50 POP 0A64 61 PUSH2 0x2673 0A67 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A34 stack[0] = 0x0a68 // @0A57 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0A60 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x2673, returns to 0x0A68 label_0A68: // Incoming return from call to 0x2673 at 0x0A67 // Inputs[4] // { // @0A6B memory[0x40:0x60] // @0A6D stack[-1] // @0A7C memory[0x40:0x60] // @0A81 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A68 5B JUMPDEST 0A69 60 PUSH1 0x40 0A6B 51 MLOAD 0A6C 80 DUP1 0A6D 82 DUP3 0A6E 15 ISZERO 0A6F 15 ISZERO 0A70 15 ISZERO 0A71 15 ISZERO 0A72 81 DUP2 0A73 52 MSTORE 0A74 60 PUSH1 0x20 0A76 01 ADD 0A77 91 SWAP2 0A78 50 POP 0A79 50 POP 0A7A 60 PUSH1 0x40 0A7C 51 MLOAD 0A7D 80 DUP1 0A7E 91 SWAP2 0A7F 03 SUB 0A80 90 SWAP1 0A81 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0A81 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A82: // Incoming jump from 0x01C0, if 0xb19a81fd == stack[-1] // Inputs[1] { @0A83 msg.value } 0A82 5B JUMPDEST 0A83 34 CALLVALUE 0A84 15 ISZERO 0A85 61 PUSH2 0x0a8d 0A88 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a8d, if !msg.value label_0A89: // Incoming jump from 0x0A88, if not !msg.value // Inputs[1] { @0A8C memory[0x00:0x00] } 0A89 60 PUSH1 0x00 0A8B 80 DUP1 0A8C FD *REVERT // Stack delta = +0 // Outputs[1] { @0A8C revert(memory[0x00:0x00]); } // Block terminates label_0A8D: // Incoming jump from 0x0A88, if !msg.value 0A8D 5B JUMPDEST 0A8E 61 PUSH2 0x0a95 0A91 61 PUSH2 0x2752 0A94 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A8E stack[0] = 0x0a95 } // Block ends with call to 0x2752, returns to 0x0A95 label_0A95: // Incoming return from call to 0x2752 at 0x0A94 // Inputs[4] // { // @0A98 memory[0x40:0x60] // @0A9A stack[-1] // @0AA5 memory[0x40:0x60] // @0AAA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A95 5B JUMPDEST 0A96 60 PUSH1 0x40 0A98 51 MLOAD 0A99 80 DUP1 0A9A 82 DUP3 0A9B 81 DUP2 0A9C 52 MSTORE 0A9D 60 PUSH1 0x20 0A9F 01 ADD 0AA0 91 SWAP2 0AA1 50 POP 0AA2 50 POP 0AA3 60 PUSH1 0x40 0AA5 51 MLOAD 0AA6 80 DUP1 0AA7 91 SWAP2 0AA8 03 SUB 0AA9 90 SWAP1 0AAA F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AAA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0AAB: // Incoming jump from 0x01CB, if 0xb27a0484 == stack[-1] // Inputs[1] { @0AAC msg.value } 0AAB 5B JUMPDEST 0AAC 34 CALLVALUE 0AAD 15 ISZERO 0AAE 61 PUSH2 0x0ab6 0AB1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ab6, if !msg.value label_0AB2: // Incoming jump from 0x0AB1, if not !msg.value // Inputs[1] { @0AB5 memory[0x00:0x00] } 0AB2 60 PUSH1 0x00 0AB4 80 DUP1 0AB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB5 revert(memory[0x00:0x00]); } // Block terminates label_0AB6: // Incoming jump from 0x0AB1, if !msg.value // Inputs[1] { @0ABE msg.data[0x04:0x24] } 0AB6 5B JUMPDEST 0AB7 61 PUSH2 0x0acc 0ABA 60 PUSH1 0x04 0ABC 80 DUP1 0ABD 80 DUP1 0ABE 35 CALLDATALOAD 0ABF 90 SWAP1 0AC0 60 PUSH1 0x20 0AC2 01 ADD 0AC3 90 SWAP1 0AC4 91 SWAP2 0AC5 90 SWAP1 0AC6 50 POP 0AC7 50 POP 0AC8 61 PUSH2 0x2758 0ACB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AB7 stack[0] = 0x0acc // @0AC4 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x2758, returns to 0x0ACC label_0ACC: // Incoming return from call to 0x2758 at 0x0ACB // Inputs[5] // { // @0ACF memory[0x40:0x60] // @0AD1 stack[-2] // @0AD7 stack[-1] // @0AE3 memory[0x40:0x60] // @0AE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0ACC 5B JUMPDEST 0ACD 60 PUSH1 0x40 0ACF 51 MLOAD 0AD0 80 DUP1 0AD1 83 DUP4 0AD2 81 DUP2 0AD3 52 MSTORE 0AD4 60 PUSH1 0x20 0AD6 01 ADD 0AD7 82 DUP3 0AD8 81 DUP2 0AD9 52 MSTORE 0ADA 60 PUSH1 0x20 0ADC 01 ADD 0ADD 92 SWAP3 0ADE 50 POP 0ADF 50 POP 0AE0 50 POP 0AE1 60 PUSH1 0x40 0AE3 51 MLOAD 0AE4 80 DUP1 0AE5 91 SWAP2 0AE6 03 SUB 0AE7 90 SWAP1 0AE8 F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @0AD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0AD9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0AE8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0AE9: // Incoming jump from 0x01D6, if 0xc8cd65e5 == stack[-1] // Inputs[1] { @0AEA msg.value } 0AE9 5B JUMPDEST 0AEA 34 CALLVALUE 0AEB 15 ISZERO 0AEC 61 PUSH2 0x0af4 0AEF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0af4, if !msg.value label_0AF0: // Incoming jump from 0x0AEF, if not !msg.value // Inputs[1] { @0AF3 memory[0x00:0x00] } 0AF0 60 PUSH1 0x00 0AF2 80 DUP1 0AF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AF3 revert(memory[0x00:0x00]); } // Block terminates label_0AF4: // Incoming jump from 0x0AEF, if !msg.value // Inputs[2] // { // @0AFC msg.data[0x04:0x24] // @0B1B msg.data[0x24:0x44] // } 0AF4 5B JUMPDEST 0AF5 61 PUSH2 0x0b29 0AF8 60 PUSH1 0x04 0AFA 80 DUP1 0AFB 80 DUP1 0AFC 35 CALLDATALOAD 0AFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B12 16 AND 0B13 90 SWAP1 0B14 60 PUSH1 0x20 0B16 01 ADD 0B17 90 SWAP1 0B18 91 SWAP2 0B19 90 SWAP1 0B1A 80 DUP1 0B1B 35 CALLDATALOAD 0B1C 90 SWAP1 0B1D 60 PUSH1 0x20 0B1F 01 ADD 0B20 90 SWAP1 0B21 91 SWAP2 0B22 90 SWAP1 0B23 50 POP 0B24 50 POP 0B25 61 PUSH2 0x277c 0B28 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AF5 stack[0] = 0x0b29 // @0B18 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0B21 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x277c, returns to 0x0B29 label_0B29: // Incoming return from call to 0x277C at 0x0B28 0B29 5B JUMPDEST 0B2A 00 *STOP // Stack delta = +0 // Outputs[1] { @0B2A stop(); } // Block terminates label_0B2B: // Incoming jump from 0x01E1, if 0xcbcf98e6 == stack[-1] // Inputs[1] { @0B2C msg.value } 0B2B 5B JUMPDEST 0B2C 34 CALLVALUE 0B2D 15 ISZERO 0B2E 61 PUSH2 0x0b36 0B31 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b36, if !msg.value label_0B32: // Incoming jump from 0x0B31, if not !msg.value // Inputs[1] { @0B35 memory[0x00:0x00] } 0B32 60 PUSH1 0x00 0B34 80 DUP1 0B35 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B35 revert(memory[0x00:0x00]); } // Block terminates label_0B36: // Incoming jump from 0x0B31, if !msg.value // Inputs[1] { @0B3E msg.data[0x04:0x24] } 0B36 5B JUMPDEST 0B37 61 PUSH2 0x0b62 0B3A 60 PUSH1 0x04 0B3C 80 DUP1 0B3D 80 DUP1 0B3E 35 CALLDATALOAD 0B3F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B54 16 AND 0B55 90 SWAP1 0B56 60 PUSH1 0x20 0B58 01 ADD 0B59 90 SWAP1 0B5A 91 SWAP2 0B5B 90 SWAP1 0B5C 50 POP 0B5D 50 POP 0B5E 61 PUSH2 0x291b 0B61 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B37 stack[0] = 0x0b62 // @0B5A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x291b, returns to 0x0B62 label_0B62: // Incoming return from call to 0x291B at 0x0B61 0B62 5B JUMPDEST 0B63 00 *STOP // Stack delta = +0 // Outputs[1] { @0B63 stop(); } // Block terminates label_0B64: // Incoming jump from 0x01EC, if 0xd0febe4c == stack[-1] 0B64 5B JUMPDEST 0B65 61 PUSH2 0x0b6c 0B68 61 PUSH2 0x29f7 0B6B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B65 stack[0] = 0x0b6c } // Block ends with call to 0x29f7, returns to 0x0B6C label_0B6C: // Incoming return from call to 0x29F7 at 0x0B6B 0B6C 5B JUMPDEST 0B6D 00 *STOP // Stack delta = +0 // Outputs[1] { @0B6D stop(); } // Block terminates label_0B6E: // Incoming jump from 0x01F7, if 0xd876e10c == stack[-1] // Inputs[1] { @0B6F msg.value } 0B6E 5B JUMPDEST 0B6F 34 CALLVALUE 0B70 15 ISZERO 0B71 61 PUSH2 0x0b79 0B74 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b79, if !msg.value label_0B75: // Incoming jump from 0x0B74, if not !msg.value // Inputs[1] { @0B78 memory[0x00:0x00] } 0B75 60 PUSH1 0x00 0B77 80 DUP1 0B78 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B78 revert(memory[0x00:0x00]); } // Block terminates label_0B79: // Incoming jump from 0x0B74, if !msg.value 0B79 5B JUMPDEST 0B7A 61 PUSH2 0x0b81 0B7D 61 PUSH2 0x2a02 0B80 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B7A stack[0] = 0x0b81 } // Block ends with call to 0x2a02, returns to 0x0B81 label_0B81: // Incoming return from call to 0x2A02 at 0x0B80 0B81 5B JUMPDEST 0B82 00 *STOP // Stack delta = +0 // Outputs[1] { @0B82 stop(); } // Block terminates label_0B83: // Incoming jump from 0x0202, if 0xdbb24554 == stack[-1] // Inputs[1] { @0B84 msg.value } 0B83 5B JUMPDEST 0B84 34 CALLVALUE 0B85 15 ISZERO 0B86 61 PUSH2 0x0b8e 0B89 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b8e, if !msg.value label_0B8A: // Incoming jump from 0x0B89, if not !msg.value // Inputs[1] { @0B8D memory[0x00:0x00] } 0B8A 60 PUSH1 0x00 0B8C 80 DUP1 0B8D FD *REVERT // Stack delta = +0 // Outputs[1] { @0B8D revert(memory[0x00:0x00]); } // Block terminates label_0B8E: // Incoming jump from 0x0B89, if !msg.value // Inputs[1] { @0B96 msg.data[0x04:0x24] } 0B8E 5B JUMPDEST 0B8F 61 PUSH2 0x0ba4 0B92 60 PUSH1 0x04 0B94 80 DUP1 0B95 80 DUP1 0B96 35 CALLDATALOAD 0B97 90 SWAP1 0B98 60 PUSH1 0x20 0B9A 01 ADD 0B9B 90 SWAP1 0B9C 91 SWAP2 0B9D 90 SWAP1 0B9E 50 POP 0B9F 50 POP 0BA0 61 PUSH2 0x2a7b 0BA3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B8F stack[0] = 0x0ba4 // @0B9C stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x2a7b, returns to 0x0BA4 label_0BA4: // Incoming return from call to 0x2A7B at 0x0BA3 0BA4 5B JUMPDEST 0BA5 00 *STOP // Stack delta = +0 // Outputs[1] { @0BA5 stop(); } // Block terminates label_0BA6: // Incoming jump from 0x020D, if 0xdd54291b == stack[-1] // Inputs[1] { @0BA7 msg.value } 0BA6 5B JUMPDEST 0BA7 34 CALLVALUE 0BA8 15 ISZERO 0BA9 61 PUSH2 0x0bb1 0BAC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bb1, if !msg.value label_0BAD: // Incoming jump from 0x0BAC, if not !msg.value // Inputs[1] { @0BB0 memory[0x00:0x00] } 0BAD 60 PUSH1 0x00 0BAF 80 DUP1 0BB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BB0 revert(memory[0x00:0x00]); } // Block terminates label_0BB1: // Incoming jump from 0x0BAC, if !msg.value 0BB1 5B JUMPDEST 0BB2 61 PUSH2 0x0bb9 0BB5 61 PUSH2 0x2b7c 0BB8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BB2 stack[0] = 0x0bb9 } // Block ends with call to 0x2b7c, returns to 0x0BB9 label_0BB9: // Incoming return from call to 0x2B7C at 0x0BB8 // Inputs[4] // { // @0BBC memory[0x40:0x60] // @0BBE stack[-1] // @0BC9 memory[0x40:0x60] // @0BCE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BB9 5B JUMPDEST 0BBA 60 PUSH1 0x40 0BBC 51 MLOAD 0BBD 80 DUP1 0BBE 82 DUP3 0BBF 81 DUP2 0BC0 52 MSTORE 0BC1 60 PUSH1 0x20 0BC3 01 ADD 0BC4 91 SWAP2 0BC5 50 POP 0BC6 50 POP 0BC7 60 PUSH1 0x40 0BC9 51 MLOAD 0BCA 80 DUP1 0BCB 91 SWAP2 0BCC 03 SUB 0BCD 90 SWAP1 0BCE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0BC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0BCE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0BCF: // Incoming jump from 0x0218, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0BD0 msg.value } 0BCF 5B JUMPDEST 0BD0 34 CALLVALUE 0BD1 15 ISZERO 0BD2 61 PUSH2 0x0bda 0BD5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bda, if !msg.value label_0BD6: // Incoming jump from 0x0BD5, if not !msg.value // Inputs[1] { @0BD9 memory[0x00:0x00] } 0BD6 60 PUSH1 0x00 0BD8 80 DUP1 0BD9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BD9 revert(memory[0x00:0x00]); } // Block terminates label_0BDA: // Incoming jump from 0x0BD5, if !msg.value // Inputs[2] // { // @0BE2 msg.data[0x04:0x24] // @0C01 msg.data[0x24:0x44] // } 0BDA 5B JUMPDEST 0BDB 61 PUSH2 0x0c25 0BDE 60 PUSH1 0x04 0BE0 80 DUP1 0BE1 80 DUP1 0BE2 35 CALLDATALOAD 0BE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BF8 16 AND 0BF9 90 SWAP1 0BFA 60 PUSH1 0x20 0BFC 01 ADD 0BFD 90 SWAP1 0BFE 91 SWAP2 0BFF 90 SWAP1 0C00 80 DUP1 0C01 35 CALLDATALOAD 0C02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C17 16 AND 0C18 90 SWAP1 0C19 60 PUSH1 0x20 0C1B 01 ADD 0C1C 90 SWAP1 0C1D 91 SWAP2 0C1E 90 SWAP1 0C1F 50 POP 0C20 50 POP 0C21 61 PUSH2 0x2b82 0C24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BDB stack[0] = 0x0c25 // @0BFE stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0C1D stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x2b82, returns to 0x0C25 label_0C25: // Incoming return from call to 0x2B82 at 0x0C24 // Inputs[4] // { // @0C28 memory[0x40:0x60] // @0C2A stack[-1] // @0C35 memory[0x40:0x60] // @0C3A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C25 5B JUMPDEST 0C26 60 PUSH1 0x40 0C28 51 MLOAD 0C29 80 DUP1 0C2A 82 DUP3 0C2B 81 DUP2 0C2C 52 MSTORE 0C2D 60 PUSH1 0x20 0C2F 01 ADD 0C30 91 SWAP2 0C31 50 POP 0C32 50 POP 0C33 60 PUSH1 0x40 0C35 51 MLOAD 0C36 80 DUP1 0C37 91 SWAP2 0C38 03 SUB 0C39 90 SWAP1 0C3A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0C2C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0C3A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0C3B: // Incoming jump from 0x0223, if 0xdf8de3e7 == stack[-1] // Inputs[1] { @0C3C msg.value } 0C3B 5B JUMPDEST 0C3C 34 CALLVALUE 0C3D 15 ISZERO 0C3E 61 PUSH2 0x0c46 0C41 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c46, if !msg.value label_0C42: // Incoming jump from 0x0C41, if not !msg.value // Inputs[1] { @0C45 memory[0x00:0x00] } 0C42 60 PUSH1 0x00 0C44 80 DUP1 0C45 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C45 revert(memory[0x00:0x00]); } // Block terminates label_0C46: // Incoming jump from 0x0C41, if !msg.value // Inputs[1] { @0C4E msg.data[0x04:0x24] } 0C46 5B JUMPDEST 0C47 61 PUSH2 0x0c72 0C4A 60 PUSH1 0x04 0C4C 80 DUP1 0C4D 80 DUP1 0C4E 35 CALLDATALOAD 0C4F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C64 16 AND 0C65 90 SWAP1 0C66 60 PUSH1 0x20 0C68 01 ADD 0C69 90 SWAP1 0C6A 91 SWAP2 0C6B 90 SWAP1 0C6C 50 POP 0C6D 50 POP 0C6E 61 PUSH2 0x2c09 0C71 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C47 stack[0] = 0x0c72 // @0C6A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x2c09, returns to 0x0C72 label_0C72: // Incoming return from call to 0x2C09 at 0x0C71 0C72 5B JUMPDEST 0C73 00 *STOP // Stack delta = +0 // Outputs[1] { @0C73 stop(); } // Block terminates label_0C74: // Incoming jump from 0x022E, if 0xe2aa8435 == stack[-1] // Inputs[1] { @0C75 msg.value } 0C74 5B JUMPDEST 0C75 34 CALLVALUE 0C76 15 ISZERO 0C77 61 PUSH2 0x0c7f 0C7A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c7f, if !msg.value label_0C7B: // Incoming jump from 0x0C7A, if not !msg.value // Inputs[1] { @0C7E memory[0x00:0x00] } 0C7B 60 PUSH1 0x00 0C7D 80 DUP1 0C7E FD *REVERT // Stack delta = +0 // Outputs[1] { @0C7E revert(memory[0x00:0x00]); } // Block terminates label_0C7F: // Incoming jump from 0x0C7A, if !msg.value // Inputs[1] { @0C87 msg.data[0x04:0x24] } 0C7F 5B JUMPDEST 0C80 61 PUSH2 0x0c95 0C83 60 PUSH1 0x04 0C85 80 DUP1 0C86 80 DUP1 0C87 35 CALLDATALOAD 0C88 90 SWAP1 0C89 60 PUSH1 0x20 0C8B 01 ADD 0C8C 90 SWAP1 0C8D 91 SWAP2 0C8E 90 SWAP1 0C8F 50 POP 0C90 50 POP 0C91 61 PUSH2 0x2e3b 0C94 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C80 stack[0] = 0x0c95 // @0C8D stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x2e3b, returns to 0x0C95 label_0C95: // Incoming return from call to 0x2E3B at 0x0C94 0C95 5B JUMPDEST 0C96 00 *STOP // Stack delta = +0 // Outputs[1] { @0C96 stop(); } // Block terminates label_0C97: // Incoming jump from 0x0239, if 0xe8078d94 == stack[-1] 0C97 5B JUMPDEST 0C98 61 PUSH2 0x0c9f 0C9B 61 PUSH2 0x2ed5 0C9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C98 stack[0] = 0x0c9f } // Block ends with call to 0x2ed5, returns to 0x0C9F label_0C9F: // Incoming return from call to 0x2ED5 at 0x0C9E 0C9F 5B JUMPDEST 0CA0 00 *STOP // Stack delta = +0 // Outputs[1] { @0CA0 stop(); } // Block terminates label_0CA1: // Incoming jump from 0x0244, if 0xf5ac9db6 == stack[-1] // Inputs[1] { @0CA2 msg.value } 0CA1 5B JUMPDEST 0CA2 34 CALLVALUE 0CA3 15 ISZERO 0CA4 61 PUSH2 0x0cac 0CA7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cac, if !msg.value label_0CA8: // Incoming jump from 0x0CA7, if not !msg.value // Inputs[1] { @0CAB memory[0x00:0x00] } 0CA8 60 PUSH1 0x00 0CAA 80 DUP1 0CAB FD *REVERT // Stack delta = +0 // Outputs[1] { @0CAB revert(memory[0x00:0x00]); } // Block terminates label_0CAC: // Incoming jump from 0x0CA7, if !msg.value 0CAC 5B JUMPDEST 0CAD 61 PUSH2 0x0cb4 0CB0 61 PUSH2 0x2fd1 0CB3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CAD stack[0] = 0x0cb4 } // Block ends with call to 0x2fd1, returns to 0x0CB4 label_0CB4: // Incoming return from call to 0x2FD1 at 0x0CB3 // Inputs[4] // { // @0CB7 memory[0x40:0x60] // @0CB9 stack[-1] // @0CC8 memory[0x40:0x60] // @0CCD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CB4 5B JUMPDEST 0CB5 60 PUSH1 0x40 0CB7 51 MLOAD 0CB8 80 DUP1 0CB9 82 DUP3 0CBA 15 ISZERO 0CBB 15 ISZERO 0CBC 15 ISZERO 0CBD 15 ISZERO 0CBE 81 DUP2 0CBF 52 MSTORE 0CC0 60 PUSH1 0x20 0CC2 01 ADD 0CC3 91 SWAP2 0CC4 50 POP 0CC5 50 POP 0CC6 60 PUSH1 0x40 0CC8 51 MLOAD 0CC9 80 DUP1 0CCA 91 SWAP2 0CCB 03 SUB 0CCC 90 SWAP1 0CCD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0CBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0CCD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0CCE: // Incoming jump from 0x024F, if 0xf66a79a0 == stack[-1] // Inputs[1] { @0CCF msg.value } 0CCE 5B JUMPDEST 0CCF 34 CALLVALUE 0CD0 15 ISZERO 0CD1 61 PUSH2 0x0cd9 0CD4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd9, if !msg.value label_0CD5: // Incoming jump from 0x0CD4, if not !msg.value // Inputs[1] { @0CD8 memory[0x00:0x00] } 0CD5 60 PUSH1 0x00 0CD7 80 DUP1 0CD8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CD8 revert(memory[0x00:0x00]); } // Block terminates label_0CD9: // Incoming jump from 0x0CD4, if !msg.value 0CD9 5B JUMPDEST 0CDA 61 PUSH2 0x0ce1 0CDD 61 PUSH2 0x2fe4 0CE0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CDA stack[0] = 0x0ce1 } // Block ends with call to 0x2fe4, returns to 0x0CE1 label_0CE1: // Incoming return from call to 0x2FE4 at 0x0CE0 // Inputs[4] // { // @0CE4 memory[0x40:0x60] // @0CE6 stack[-1] // @0D1D memory[0x40:0x60] // @0D22 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CE1 5B JUMPDEST 0CE2 60 PUSH1 0x40 0CE4 51 MLOAD 0CE5 80 DUP1 0CE6 82 DUP3 0CE7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CFC 16 AND 0CFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D12 16 AND 0D13 81 DUP2 0D14 52 MSTORE 0D15 60 PUSH1 0x20 0D17 01 ADD 0D18 91 SWAP2 0D19 50 POP 0D1A 50 POP 0D1B 60 PUSH1 0x40 0D1D 51 MLOAD 0D1E 80 DUP1 0D1F 91 SWAP2 0D20 03 SUB 0D21 90 SWAP1 0D22 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0D14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0D22 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0D23: // Incoming jump from 0x025A, if 0xfac2b9ba == stack[-1] // Inputs[1] { @0D24 msg.value } 0D23 5B JUMPDEST 0D24 34 CALLVALUE 0D25 15 ISZERO 0D26 61 PUSH2 0x0d2e 0D29 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d2e, if !msg.value label_0D2A: // Incoming jump from 0x0D29, if not !msg.value // Inputs[1] { @0D2D memory[0x00:0x00] } 0D2A 60 PUSH1 0x00 0D2C 80 DUP1 0D2D FD *REVERT // Stack delta = +0 // Outputs[1] { @0D2D revert(memory[0x00:0x00]); } // Block terminates label_0D2E: // Incoming jump from 0x0D29, if !msg.value // Inputs[1] { @0D36 msg.data[0x04:0x24] } 0D2E 5B JUMPDEST 0D2F 61 PUSH2 0x0d44 0D32 60 PUSH1 0x04 0D34 80 DUP1 0D35 80 DUP1 0D36 35 CALLDATALOAD 0D37 90 SWAP1 0D38 60 PUSH1 0x20 0D3A 01 ADD 0D3B 90 SWAP1 0D3C 91 SWAP2 0D3D 90 SWAP1 0D3E 50 POP 0D3F 50 POP 0D40 61 PUSH2 0x300a 0D43 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D2F stack[0] = 0x0d44 // @0D3C stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x300a, returns to 0x0D44 label_0D44: // Incoming return from call to 0x300A at 0x0D43 0D44 5B JUMPDEST 0D45 00 *STOP // Stack delta = +0 // Outputs[1] { @0D45 stop(); } // Block terminates label_0D46: // Incoming jump from 0x0265, if 0xfc60dcf9 == stack[-1] // Inputs[1] { @0D47 msg.value } 0D46 5B JUMPDEST 0D47 34 CALLVALUE 0D48 15 ISZERO 0D49 61 PUSH2 0x0d51 0D4C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d51, if !msg.value label_0D4D: // Incoming jump from 0x0D4C, if not !msg.value // Inputs[1] { @0D50 memory[0x00:0x00] } 0D4D 60 PUSH1 0x00 0D4F 80 DUP1 0D50 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D50 revert(memory[0x00:0x00]); } // Block terminates label_0D51: // Incoming jump from 0x0D4C, if !msg.value 0D51 5B JUMPDEST 0D52 61 PUSH2 0x0d59 0D55 61 PUSH2 0x308e 0D58 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D52 stack[0] = 0x0d59 } // Block ends with call to 0x308e, returns to 0x0D59 label_0D59: // Incoming return from call to 0x308E at 0x0D58 // Inputs[4] // { // @0D5C memory[0x40:0x60] // @0D5E stack[-1] // @0D69 memory[0x40:0x60] // @0D6E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D59 5B JUMPDEST 0D5A 60 PUSH1 0x40 0D5C 51 MLOAD 0D5D 80 DUP1 0D5E 82 DUP3 0D5F 81 DUP2 0D60 52 MSTORE 0D61 60 PUSH1 0x20 0D63 01 ADD 0D64 91 SWAP2 0D65 50 POP 0D66 50 POP 0D67 60 PUSH1 0x40 0D69 51 MLOAD 0D6A 80 DUP1 0D6B 91 SWAP2 0D6C 03 SUB 0D6D 90 SWAP1 0D6E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0D60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D6E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0D6F: // Incoming call from 0x29FF, returns to 0x2A00 // Incoming call from 0x026E, returns to 0x026F // Incoming call from 0x0740, returns to 0x0741 // Inputs[3] // { // @0D76 msg.sender // @0DB0 memory[0x00:0x40] // @0DB4 storage[keccak256(memory[0x00:0x40])] // } 0D6F 5B JUMPDEST 0D70 60 PUSH1 0x00 0D72 60 PUSH1 0x10 0D74 60 PUSH1 0x00 0D76 33 CALLER 0D77 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D8C 16 AND 0D8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DA2 16 AND 0DA3 81 DUP2 0DA4 52 MSTORE 0DA5 60 PUSH1 0x20 0DA7 01 ADD 0DA8 90 SWAP1 0DA9 81 DUP2 0DAA 52 MSTORE 0DAB 60 PUSH1 0x20 0DAD 01 ADD 0DAE 60 PUSH1 0x00 0DB0 20 SHA3 0DB1 60 PUSH1 0x00 0DB3 90 SWAP1 0DB4 54 SLOAD 0DB5 90 SWAP1 0DB6 61 PUSH2 0x0100 0DB9 0A EXP 0DBA 90 SWAP1 0DBB 04 DIV 0DBC 60 PUSH1 0xff 0DBE 16 AND 0DBF 15 ISZERO 0DC0 15 ISZERO 0DC1 61 PUSH2 0x0dc9 0DC4 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0D70 stack[0] = 0x00 // @0DA4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0DAA memory[0x20:0x40] = 0x10 // } // Block ends with conditional jump to 0x0dc9, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_0DC5: // Incoming jump from 0x0DC4, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @0DC8 memory[0x00:0x00] } 0DC5 60 PUSH1 0x00 0DC7 80 DUP1 0DC8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DC8 revert(memory[0x00:0x00]); } // Block terminates label_0DC9: // Incoming jump from 0x0DC4, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @0DCF storage[0x08] } 0DC9 5B JUMPDEST 0DCA 60 PUSH1 0x08 0DCC 60 PUSH1 0x00 0DCE 90 SWAP1 0DCF 54 SLOAD 0DD0 90 SWAP1 0DD1 61 PUSH2 0x0100 0DD4 0A EXP 0DD5 90 SWAP1 0DD6 04 DIV 0DD7 60 PUSH1 0xff 0DD9 16 AND 0DDA 15 ISZERO 0DDB 15 ISZERO 0DDC 15 ISZERO 0DDD 61 PUSH2 0x0de5 0DE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0de5, if !!!(0xff & storage[0x08] / 0x0100 ** 0x00) label_0DE1: // Incoming jump from 0x0DE0, if not !!!(0xff & storage[0x08] / 0x0100 ** 0x00) // Inputs[1] { @0DE4 memory[0x00:0x00] } 0DE1 60 PUSH1 0x00 0DE3 80 DUP1 0DE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DE4 revert(memory[0x00:0x00]); } // Block terminates label_0DE5: // Incoming jump from 0x0DE0, if !!!(0xff & storage[0x08] / 0x0100 ** 0x00) // Inputs[1] { @0DFE stack[-2] } 0DE5 5B JUMPDEST 0DE6 60 PUSH1 0x00 0DE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DFD 16 AND 0DFE 82 DUP3 0DFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E14 16 AND 0E15 14 EQ 0E16 15 ISZERO 0E17 15 ISZERO 0E18 15 ISZERO 0E19 61 PUSH2 0x0e21 0E1C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e21, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0E1D: // Incoming jump from 0x0E1C, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0E20 memory[0x00:0x00] } 0E1D 60 PUSH1 0x00 0E1F 80 DUP1 0E20 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E20 revert(memory[0x00:0x00]); } // Block terminates label_0E21: // Incoming jump from 0x0E1C, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @0E24 storage[0x07] // @0E25 msg.value // } 0E21 5B JUMPDEST 0E22 60 PUSH1 0x07 0E24 54 SLOAD 0E25 34 CALLVALUE 0E26 10 LT 0E27 15 ISZERO 0E28 15 ISZERO 0E29 15 ISZERO 0E2A 61 PUSH2 0x0e32 0E2D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e32, if !!!(msg.value < storage[0x07]) label_0E2E: // Incoming jump from 0x0E2D, if not !!!(msg.value < storage[0x07]) // Inputs[1] { @0E31 memory[0x00:0x00] } 0E2E 60 PUSH1 0x00 0E30 80 DUP1 0E31 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E31 revert(memory[0x00:0x00]); } // Block terminates label_0E32: // Incoming jump from 0x0E2D, if !!!(msg.value < storage[0x07]) // Inputs[2] // { // @0E35 storage[0x09] // @0E36 block.number // } 0E32 5B JUMPDEST 0E33 60 PUSH1 0x09 0E35 54 SLOAD 0E36 43 NUMBER 0E37 10 LT 0E38 15 ISZERO 0E39 80 DUP1 0E3A 15 ISZERO 0E3B 61 PUSH2 0x0e45 0E3E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E38 stack[0] = !(block.number < storage[0x09]) } // Block ends with conditional jump to 0x0e45, if !!(block.number < storage[0x09]) label_0E3F: // Incoming jump from 0x0E3E, if not !!(block.number < storage[0x09]) // Inputs[2] // { // @0E42 storage[0x0a] // @0E43 block.number // } 0E3F 50 POP 0E40 60 PUSH1 0x0a 0E42 54 SLOAD 0E43 43 NUMBER 0E44 10 LT 0E45 5B JUMPDEST 0E46 15 ISZERO 0E47 15 ISZERO 0E48 61 PUSH2 0x0e50 0E4B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e50, if !!(block.number < storage[0x0a]) label_0E4C: // Incoming jump from 0x0E4B, if not !!stack[-1] // Incoming jump from 0x0E4B, if not !!(block.number < storage[0x0a]) // Inputs[1] { @0E4F memory[0x00:0x00] } 0E4C 60 PUSH1 0x00 0E4E 80 DUP1 0E4F FD *REVERT // Stack delta = +0 // Outputs[1] { @0E4F revert(memory[0x00:0x00]); } // Block terminates label_0E50: // Incoming jump from 0x0E4B, if !!stack[-1] // Incoming jump from 0x0E4B, if !!(block.number < storage[0x0a]) 0E50 5B JUMPDEST 0E51 61 PUSH2 0x0e58 0E54 61 PUSH2 0x1296 0E57 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E51 stack[0] = 0x0e58 } // Block ends with call to 0x1296, returns to 0x0E58 label_0E58: // Incoming return from call to 0x1296 at 0x0E57 // Inputs[2] // { // @0E5C msg.value // @0E62 storage[0x11] // } 0E58 5B JUMPDEST 0E59 61 PUSH2 0x0e67 0E5C 34 CALLVALUE 0E5D 60 PUSH1 0x11 0E5F 60 PUSH1 0x00 0E61 01 ADD 0E62 54 SLOAD 0E63 61 PUSH2 0x3094 0E66 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E59 stack[0] = 0x0e67 // @0E5C stack[1] = msg.value // @0E62 stack[2] = storage[0x11] // } // Block ends with call to 0x3094, returns to 0x0E67 label_0E67: // Incoming return from call to 0x3094 at 0x0E66 // Inputs[1] { @0E68 stack[-2] } 0E67 5B JUMPDEST 0E68 81 DUP2 0E69 15 ISZERO 0E6A 15 ISZERO 0E6B 61 PUSH2 0x0e70 0E6E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e70, if !!stack[-2] label_0E6F: // Incoming jump from 0x0E6E, if not !!stack[-2] 0E6F FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E6F assert(); } // Block terminates label_0E70: // Incoming jump from 0x0E6E, if !!stack[-2] // Inputs[4] // { // @0E71 stack[-2] // @0E71 stack[-1] // @0E72 stack[-3] // @0E77 stack[-4] // } 0E70 5B JUMPDEST 0E71 04 DIV 0E72 90 SWAP1 0E73 50 POP 0E74 61 PUSH2 0x0e7d 0E77 82 DUP3 0E78 82 DUP3 0E79 61 PUSH2 0x30c7 0E7C 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0E72 stack[-3] = stack[-1] / stack[-2] // @0E74 stack[-2] = 0x0e7d // @0E77 stack[-1] = stack[-4] // @0E78 stack[0] = stack[-1] / stack[-2] // } // Block ends with call to 0x30c7, returns to 0x0E7D label_0E7D: // Incoming return from call to 0x30C7 at 0x0E7C // Inputs[6] // { // @0E83 storage[0x0d] // @0EBA msg.value // @0EC2 memory[0x40:0x60] // @0EC7 memory[0x40:0x60] // @0ECF address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0ECF memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 0E7D 5B JUMPDEST 0E7E 60 PUSH1 0x0d 0E80 60 PUSH1 0x00 0E82 90 SWAP1 0E83 54 SLOAD 0E84 90 SWAP1 0E85 61 PUSH2 0x0100 0E88 0A EXP 0E89 90 SWAP1 0E8A 04 DIV 0E8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EA0 16 AND 0EA1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EB6 16 AND 0EB7 61 PUSH2 0x08fc 0EBA 34 CALLVALUE 0EBB 90 SWAP1 0EBC 81 DUP2 0EBD 15 ISZERO 0EBE 02 MUL 0EBF 90 SWAP1 0EC0 60 PUSH1 0x40 0EC2 51 MLOAD 0EC3 60 PUSH1 0x00 0EC5 60 PUSH1 0x40 0EC7 51 MLOAD 0EC8 80 DUP1 0EC9 83 DUP4 0ECA 03 SUB 0ECB 81 DUP2 0ECC 85 DUP6 0ECD 88 DUP9 0ECE 88 DUP9 0ECF F1 CALL 0ED0 93 SWAP4 0ED1 50 POP 0ED2 50 POP 0ED3 50 POP 0ED4 50 POP 0ED5 15 ISZERO 0ED6 15 ISZERO 0ED7 61 PUSH2 0x0edf 0EDA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0ECF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) } // Block ends with conditional jump to 0x0edf, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_0EDB: // Incoming jump from 0x0EDA, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @0EDE memory[0x00:0x00] } 0EDB 60 PUSH1 0x00 0EDD 80 DUP1 0EDE FD *REVERT // Stack delta = +0 // Outputs[1] { @0EDE revert(memory[0x00:0x00]); } // Block terminates label_0EDF: // Incoming jump from 0x0EDA, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[8] // { // @0EE0 stack[-2] // @0EF7 msg.sender // @0F2F msg.value // @0F30 stack[-1] // @0F33 memory[0x40:0x60] // @0F47 memory[0x40:0x60] // @0F4C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0F4F stack[-3] // } 0EDF 5B JUMPDEST 0EE0 81 DUP2 0EE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF6 16 AND 0EF7 33 CALLER 0EF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0D 16 AND 0F0E 7F PUSH32 0xdeb69f41b4c1fc2384209e922e035ca10841e61e6b1f685e0699f9dfa886009f 0F2F 34 CALLVALUE 0F30 84 DUP5 0F31 60 PUSH1 0x40 0F33 51 MLOAD 0F34 80 DUP1 0F35 83 DUP4 0F36 81 DUP2 0F37 52 MSTORE 0F38 60 PUSH1 0x20 0F3A 01 ADD 0F3B 82 DUP3 0F3C 81 DUP2 0F3D 52 MSTORE 0F3E 60 PUSH1 0x20 0F40 01 ADD 0F41 92 SWAP3 0F42 50 POP 0F43 50 POP 0F44 50 POP 0F45 60 PUSH1 0x40 0F47 51 MLOAD 0F48 80 DUP1 0F49 91 SWAP2 0F4A 03 SUB 0F4B 90 SWAP1 0F4C A3 LOG3 0F4D 50 POP 0F4E 50 POP 0F4F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0F37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.value // @0F3D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0F4C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xdeb69f41b4c1fc2384209e922e035ca10841e61e6b1f685e0699f9dfa886009f, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_0F50: // Incoming call from 0x0291, returns to 0x0292 // Inputs[2] // { // @0F56 storage[0x0d] // @0F8A msg.sender // } 0F50 5B JUMPDEST 0F51 60 PUSH1 0x0d 0F53 60 PUSH1 0x00 0F55 90 SWAP1 0F56 54 SLOAD 0F57 90 SWAP1 0F58 61 PUSH2 0x0100 0F5B 0A EXP 0F5C 90 SWAP1 0F5D 04 DIV 0F5E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F73 16 AND 0F74 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F89 16 AND 0F8A 33 CALLER 0F8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FA0 16 AND 0FA1 14 EQ 0FA2 15 ISZERO 0FA3 15 ISZERO 0FA4 61 PUSH2 0x0fac 0FA7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fac, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_0FA8: // Incoming jump from 0x0FA7, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @0FAB memory[0x00:0x00] } 0FA8 60 PUSH1 0x00 0FAA 80 DUP1 0FAB FD *REVERT // Stack delta = +0 // Outputs[1] { @0FAB revert(memory[0x00:0x00]); } // Block terminates label_0FAC: // Incoming jump from 0x0FA7, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @0FAF storage[0x0a] // @0FB0 block.number // } 0FAC 5B JUMPDEST 0FAD 60 PUSH1 0x0a 0FAF 54 SLOAD 0FB0 43 NUMBER 0FB1 10 LT 0FB2 15 ISZERO 0FB3 15 ISZERO 0FB4 61 PUSH2 0x0fbc 0FB7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fbc, if !!(block.number < storage[0x0a]) label_0FB8: // Incoming jump from 0x0FB7, if not !!(block.number < storage[0x0a]) // Inputs[1] { @0FBB memory[0x00:0x00] } 0FB8 60 PUSH1 0x00 0FBA 80 DUP1 0FBB FD *REVERT // Stack delta = +0 // Outputs[1] { @0FBB revert(memory[0x00:0x00]); } // Block terminates label_0FBC: // Incoming jump from 0x0FB7, if !!(block.number < storage[0x0a]) // Inputs[2] // { // @0FBD stack[-1] // @0FBE block.number // } 0FBC 5B JUMPDEST 0FBD 80 DUP1 0FBE 43 NUMBER 0FBF 10 LT 0FC0 15 ISZERO 0FC1 15 ISZERO 0FC2 61 PUSH2 0x0fca 0FC5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fca, if !!(block.number < stack[-1]) label_0FC6: // Incoming jump from 0x0FC5, if not !!(block.number < stack[-1]) // Inputs[1] { @0FC9 memory[0x00:0x00] } 0FC6 60 PUSH1 0x00 0FC8 80 DUP1 0FC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FC9 revert(memory[0x00:0x00]); } // Block terminates label_0FCA: // Incoming jump from 0x0FC5, if !!(block.number < stack[-1]) // Inputs[2] // { // @0FCB stack[-1] // @0FD3 stack[-2] // } 0FCA 5B JUMPDEST 0FCB 80 DUP1 0FCC 60 PUSH1 0x0a 0FCE 81 DUP2 0FCF 90 SWAP1 0FD0 55 SSTORE 0FD1 50 POP 0FD2 50 POP 0FD3 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FD0 storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0FD4: // Incoming call from 0x02A6, returns to 0x02A7 0FD4 5B JUMPDEST 0FD5 61 PUSH2 0x0fdc 0FD8 61 PUSH2 0x3a80 0FDB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FD5 stack[0] = 0x0fdc } // Block ends with call to 0x3a80, returns to 0x0FDC label_0FDC: // Incoming return from call to 0x3A80 at 0x0FDB // Inputs[3] // { // @0FE0 storage[0x00] // @1001 memory[0x40:0x60] // @1014 storage[0x00] // } 0FDC 5B JUMPDEST 0FDD 60 PUSH1 0x00 0FDF 80 DUP1 0FE0 54 SLOAD 0FE1 60 PUSH1 0x01 0FE3 81 DUP2 0FE4 60 PUSH1 0x01 0FE6 16 AND 0FE7 15 ISZERO 0FE8 61 PUSH2 0x0100 0FEB 02 MUL 0FEC 03 SUB 0FED 16 AND 0FEE 60 PUSH1 0x02 0FF0 90 SWAP1 0FF1 04 DIV 0FF2 80 DUP1 0FF3 60 PUSH1 0x1f 0FF5 01 ADD 0FF6 60 PUSH1 0x20 0FF8 80 DUP1 0FF9 91 SWAP2 0FFA 04 DIV 0FFB 02 MUL 0FFC 60 PUSH1 0x20 0FFE 01 ADD 0FFF 60 PUSH1 0x40 1001 51 MLOAD 1002 90 SWAP1 1003 81 DUP2 1004 01 ADD 1005 60 PUSH1 0x40 1007 52 MSTORE 1008 80 DUP1 1009 92 SWAP3 100A 91 SWAP2 100B 90 SWAP1 100C 81 DUP2 100D 81 DUP2 100E 52 MSTORE 100F 60 PUSH1 0x20 1011 01 ADD 1012 82 DUP3 1013 80 DUP1 1014 54 SLOAD 1015 60 PUSH1 0x01 1017 81 DUP2 1018 60 PUSH1 0x01 101A 16 AND 101B 15 ISZERO 101C 61 PUSH2 0x0100 101F 02 MUL 1020 03 SUB 1021 16 AND 1022 60 PUSH1 0x02 1024 90 SWAP1 1025 04 DIV 1026 80 DUP1 1027 15 ISZERO 1028 61 PUSH2 0x1072 102B 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1007 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @1009 stack[0] = memory[0x40:0x60] // @100A stack[1] = 0x00 // @100B stack[2] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @100E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @1011 stack[3] = 0x20 + memory[0x40:0x60] // @1012 stack[4] = 0x00 // @1025 stack[5] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x1072, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_102C: // Incoming jump from 0x102B, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @102C stack[-1] } 102C 80 DUP1 102D 60 PUSH1 0x1f 102F 10 LT 1030 61 PUSH2 0x1047 1033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1047, if 0x1f < stack[-1] label_1034: // Incoming jump from 0x1033, if not 0x1f < stack[-1] // Inputs[4] // { // @1038 stack[-2] // @1039 storage[stack[-2]] // @103C stack[-3] // @103E stack[-1] // } 1034 61 PUSH2 0x0100 1037 80 DUP1 1038 83 DUP4 1039 54 SLOAD 103A 04 DIV 103B 02 MUL 103C 83 DUP4 103D 52 MSTORE 103E 91 SWAP2 103F 60 PUSH1 0x20 1041 01 ADD 1042 91 SWAP2 1043 61 PUSH2 0x1072 1046 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @103D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1042 stack[-1] = stack[-1] // @1042 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1072 label_1047: // Incoming jump from 0x1033, if 0x1f < stack[-1] // Inputs[5] // { // @1048 stack[-3] // @1049 stack[-1] // @104B stack[-2] // @1053 memory[0x00:0x20] // @1057 storage[keccak256(memory[0x00:0x20])] // } 1047 5B JUMPDEST 1048 82 DUP3 1049 01 ADD 104A 91 SWAP2 104B 90 SWAP1 104C 60 PUSH1 0x00 104E 52 MSTORE 104F 60 PUSH1 0x20 1051 60 PUSH1 0x00 1053 20 SHA3 1054 90 SWAP1 1055 5B JUMPDEST 1056 81 DUP2 1057 54 SLOAD 1058 81 DUP2 1059 52 MSTORE 105A 90 SWAP1 105B 60 PUSH1 0x01 105D 01 ADD 105E 90 SWAP1 105F 60 PUSH1 0x20 1061 01 ADD 1062 80 DUP1 1063 83 DUP4 1064 11 GT 1065 61 PUSH2 0x1055 1068 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @104A stack[-3] = stack[-3] + stack[-1] // @104E memory[0x00:0x20] = stack[-2] // @1059 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @105E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1061 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1055, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1069: // Incoming jump from 0x1068, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1068, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1069 stack[-3] // @106A stack[-1] // } 1069 82 DUP3 106A 90 SWAP1 106B 03 SUB 106C 60 PUSH1 0x1f 106E 16 AND 106F 82 DUP3 1070 01 ADD 1071 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1071 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1071 stack[-1] = stack[-3] // } // Block continues label_1072: // Incoming jump from 0x1071 // Incoming jump from 0x1046 // Incoming jump from 0x102B, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[3] // { // @1078 stack[-6] // @1078 stack[-7] // @107A stack[-8] // } 1072 5B JUMPDEST 1073 50 POP 1074 50 POP 1075 50 POP 1076 50 POP 1077 50 POP 1078 90 SWAP1 1079 50 POP 107A 90 SWAP1 107B 56 *JUMP // Stack delta = -7 // Outputs[1] { @107A stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_107C: // Incoming call from 0x0334, returns to 0x0335 // Inputs[2] // { // @107F storage[0x0a] // @1080 stack[-1] // } 107C 5B JUMPDEST 107D 60 PUSH1 0x0a 107F 54 SLOAD 1080 81 DUP2 1081 56 *JUMP // Stack delta = +1 // Outputs[1] { @107F stack[0] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_1082: // Incoming call from 0x038A, returns to 0x038B // Inputs[1] { @1090 msg.data.length } 1082 5B JUMPDEST 1083 60 PUSH1 0x00 1085 60 PUSH1 0x02 1087 60 PUSH1 0x04 1089 60 PUSH1 0x20 108B 82 DUP3 108C 02 MUL 108D 01 ADD 108E 60 PUSH1 0x00 1090 36 CALLDATASIZE 1091 90 SWAP1 1092 50 POP 1093 10 LT 1094 15 ISZERO 1095 15 ISZERO 1096 15 ISZERO 1097 61 PUSH2 0x109c 109A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1083 stack[0] = 0x00 // @1085 stack[1] = 0x02 // } // Block ends with conditional jump to 0x109c, if !!!(msg.data.length < 0x02 * 0x20 + 0x04) label_109B: // Incoming jump from 0x109A, if not !!!(msg.data.length < 0x02 * 0x20 + 0x04) 109B FE *ASSERT // Stack delta = +0 // Outputs[1] { @109B assert(); } // Block terminates label_109C: // Incoming jump from 0x109A, if !!!(msg.data.length < 0x02 * 0x20 + 0x04) // Inputs[1] { @109F stack[-3] } 109C 5B JUMPDEST 109D 60 PUSH1 0x00 109F 83 DUP4 10A0 14 EQ 10A1 80 DUP1 10A2 61 PUSH2 0x1127 10A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10A0 stack[0] = stack[-3] == 0x00 } // Block ends with conditional jump to 0x1127, if stack[-3] == 0x00 label_10A6: // Incoming jump from 0x10A5, if not stack[-3] == 0x00 // Inputs[5] // { // @10AD msg.sender // @10E7 memory[0x00:0x40] // @10EA stack[-5] // @1124 memory[0x00:0x40] // @1125 storage[keccak256(memory[0x00:0x40])] // } 10A6 50 POP 10A7 60 PUSH1 0x00 10A9 60 PUSH1 0x05 10AB 60 PUSH1 0x00 10AD 33 CALLER 10AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C3 16 AND 10C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10D9 16 AND 10DA 81 DUP2 10DB 52 MSTORE 10DC 60 PUSH1 0x20 10DE 01 ADD 10DF 90 SWAP1 10E0 81 DUP2 10E1 52 MSTORE 10E2 60 PUSH1 0x20 10E4 01 ADD 10E5 60 PUSH1 0x00 10E7 20 SHA3 10E8 60 PUSH1 0x00 10EA 86 DUP7 10EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1100 16 AND 1101 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1116 16 AND 1117 81 DUP2 1118 52 MSTORE 1119 60 PUSH1 0x20 111B 01 ADD 111C 90 SWAP1 111D 81 DUP2 111E 52 MSTORE 111F 60 PUSH1 0x20 1121 01 ADD 1122 60 PUSH1 0x00 1124 20 SHA3 1125 54 SLOAD 1126 14 EQ 1127 5B JUMPDEST 1128 15 ISZERO 1129 15 ISZERO 112A 61 PUSH2 0x1132 112D 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @10DB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @10E1 memory[0x20:0x40] = 0x05 // @1118 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @111E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x1132, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) label_112E: // Incoming jump from 0x112D, if not !!stack[-1] // Incoming jump from 0x112D, if not !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @1131 memory[0x00:0x00] } 112E 60 PUSH1 0x00 1130 80 DUP1 1131 FD *REVERT // Stack delta = +0 // Outputs[1] { @1131 revert(memory[0x00:0x00]); } // Block terminates label_1132: // Incoming jump from 0x112D, if !!stack[-1] // Incoming jump from 0x112D, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[11] // { // @1133 stack[-3] // @1138 msg.sender // @1172 memory[0x00:0x40] // @1175 stack[-4] // @11AF memory[0x00:0x40] // @11CB msg.sender // @1206 memory[0x40:0x60] // @1213 memory[0x40:0x60] // @1218 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @121B stack[-2] // @121E stack[-5] // } 1132 5B JUMPDEST 1133 82 DUP3 1134 60 PUSH1 0x05 1136 60 PUSH1 0x00 1138 33 CALLER 1139 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 114E 16 AND 114F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1164 16 AND 1165 81 DUP2 1166 52 MSTORE 1167 60 PUSH1 0x20 1169 01 ADD 116A 90 SWAP1 116B 81 DUP2 116C 52 MSTORE 116D 60 PUSH1 0x20 116F 01 ADD 1170 60 PUSH1 0x00 1172 20 SHA3 1173 60 PUSH1 0x00 1175 86 DUP7 1176 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 118B 16 AND 118C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11A1 16 AND 11A2 81 DUP2 11A3 52 MSTORE 11A4 60 PUSH1 0x20 11A6 01 ADD 11A7 90 SWAP1 11A8 81 DUP2 11A9 52 MSTORE 11AA 60 PUSH1 0x20 11AC 01 ADD 11AD 60 PUSH1 0x00 11AF 20 SHA3 11B0 81 DUP2 11B1 90 SWAP1 11B2 55 SSTORE 11B3 50 POP 11B4 83 DUP4 11B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11CA 16 AND 11CB 33 CALLER 11CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E1 16 AND 11E2 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1203 85 DUP6 1204 60 PUSH1 0x40 1206 51 MLOAD 1207 80 DUP1 1208 82 DUP3 1209 81 DUP2 120A 52 MSTORE 120B 60 PUSH1 0x20 120D 01 ADD 120E 91 SWAP2 120F 50 POP 1210 50 POP 1211 60 PUSH1 0x40 1213 51 MLOAD 1214 80 DUP1 1215 91 SWAP2 1216 03 SUB 1217 90 SWAP1 1218 A3 LOG3 1219 60 PUSH1 0x01 121B 91 SWAP2 121C 50 POP 121D 50 POP 121E 92 SWAP3 121F 91 SWAP2 1220 50 POP 1221 50 POP 1222 56 *JUMP // Stack delta = -4 // Outputs[8] // { // @1166 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @116C memory[0x20:0x40] = 0x05 // @11A3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @11A9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @11B2 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @120A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @1218 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @121E stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_1223: // Incoming call from 0x03DB, returns to 0x03DC // Inputs[4] // { // @122A stack[-1] // @1264 memory[0x00:0x40] // @1268 storage[keccak256(memory[0x00:0x40])] // @1275 stack[-2] // } 1223 5B JUMPDEST 1224 60 PUSH1 0x00 1226 60 PUSH1 0x10 1228 60 PUSH1 0x00 122A 83 DUP4 122B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1240 16 AND 1241 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1256 16 AND 1257 81 DUP2 1258 52 MSTORE 1259 60 PUSH1 0x20 125B 01 ADD 125C 90 SWAP1 125D 81 DUP2 125E 52 MSTORE 125F 60 PUSH1 0x20 1261 01 ADD 1262 60 PUSH1 0x00 1264 20 SHA3 1265 60 PUSH1 0x00 1267 90 SWAP1 1268 54 SLOAD 1269 90 SWAP1 126A 61 PUSH2 0x0100 126D 0A EXP 126E 90 SWAP1 126F 04 DIV 1270 60 PUSH1 0xff 1272 16 AND 1273 90 SWAP1 1274 50 POP 1275 91 SWAP2 1276 90 SWAP1 1277 50 POP 1278 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1258 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @125E memory[0x20:0x40] = 0x10 // @1275 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1279: // Incoming call from 0x0408, returns to 0x0409 // Inputs[2] // { // @127F storage[0x08] // @128A stack[-1] // } 1279 5B JUMPDEST 127A 60 PUSH1 0x08 127C 60 PUSH1 0x00 127E 90 SWAP1 127F 54 SLOAD 1280 90 SWAP1 1281 61 PUSH2 0x0100 1284 0A EXP 1285 90 SWAP1 1286 04 DIV 1287 60 PUSH1 0xff 1289 16 AND 128A 81 DUP2 128B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1289 stack[0] = 0xff & storage[0x08] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_128C: // Incoming call from 0x0435, returns to 0x0436 // Inputs[2] // { // @1291 storage[0x03] // @1294 stack[-1] // } 128C 5B JUMPDEST 128D 60 PUSH1 0x00 128F 60 PUSH1 0x03 1291 54 SLOAD 1292 90 SWAP1 1293 50 POP 1294 90 SWAP1 1295 56 *JUMP // Stack delta = +0 // Outputs[1] { @1294 stack[-1] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_1296: // Incoming call from 0x0E57, returns to 0x0E58 // Incoming call from 0x045E, returns to 0x045F // Inputs[2] // { // @129D block.number // @12A0 storage[0x09] // } 1296 5B JUMPDEST 1297 60 PUSH1 0x00 1299 80 DUP1 129A 61 PUSH2 0x12a5 129D 43 NUMBER 129E 60 PUSH1 0x09 12A0 54 SLOAD 12A1 61 PUSH2 0x337e 12A4 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1297 stack[0] = 0x00 // @1299 stack[1] = 0x00 // @129A stack[2] = 0x12a5 // @129D stack[3] = block.number // @12A0 stack[4] = storage[0x09] // } // Block ends with call to 0x337e, returns to 0x12A5 label_12A5: // Incoming return from call to 0x337E at 0x12A4 // Inputs[3] // { // @12A6 stack[-1] // @12A6 stack[-2] // @12AA storage[0x0b] // } 12A5 5B JUMPDEST 12A6 90 SWAP1 12A7 50 POP 12A8 60 PUSH1 0x0b 12AA 54 SLOAD 12AB 81 DUP2 12AC 10 LT 12AD 15 ISZERO 12AE 61 PUSH2 0x12be 12B1 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12A6 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x12be, if !(stack[-1] < storage[0x0b]) label_12B2: // Incoming jump from 0x12B1, if not !(stack[-1] < storage[0x0b]) // Inputs[2] // { // @12B7 storage[0x12] // @12B8 stack[-2] // } 12B2 60 PUSH1 0x11 12B4 60 PUSH1 0x01 12B6 01 ADD 12B7 54 SLOAD 12B8 91 SWAP2 12B9 50 POP 12BA 61 PUSH2 0x130c 12BD 56 *JUMP // Stack delta = +0 // Outputs[1] { @12B8 stack[-2] = storage[0x12] } // Block ends with unconditional jump to 0x130c label_12BE: // Incoming jump from 0x12B1, if !(stack[-1] < storage[0x0b]) // Inputs[2] // { // @12C1 storage[0x0c] // @12C2 stack[-1] // } 12BE 5B JUMPDEST 12BF 60 PUSH1 0x0c 12C1 54 SLOAD 12C2 81 DUP2 12C3 10 LT 12C4 15 ISZERO 12C5 61 PUSH2 0x12ed 12C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12ed, if !(stack[-1] < storage[0x0c]) label_12C9: // Incoming jump from 0x12C8, if not !(stack[-1] < storage[0x0c]) // Inputs[1] { @12D4 storage[0x12] } 12C9 61 PUSH2 0x03e8 12CC 61 PUSH2 0x12dc 12CF 60 PUSH1 0x11 12D1 60 PUSH1 0x01 12D3 01 ADD 12D4 54 SLOAD 12D5 61 PUSH2 0x0401 12D8 61 PUSH2 0x3094 12DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12C9 stack[0] = 0x03e8 // @12CC stack[1] = 0x12dc // @12D4 stack[2] = storage[0x12] // @12D5 stack[3] = 0x0401 // } // Block ends with call to 0x3094, returns to 0x12DC label_12DC: // Incoming return from call to 0x3094 at 0x12DB // Inputs[1] { @12DD stack[-2] } 12DC 5B JUMPDEST 12DD 81 DUP2 12DE 15 ISZERO 12DF 15 ISZERO 12E0 61 PUSH2 0x12e5 12E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12e5, if !!stack[-2] label_12E4: // Incoming jump from 0x12E3, if not !!stack[-2] 12E4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12E4 assert(); } // Block terminates label_12E5: // Incoming jump from 0x12E3, if !!stack[-2] // Inputs[3] // { // @12E6 stack[-1] // @12E6 stack[-2] // @12E7 stack[-4] // } 12E5 5B JUMPDEST 12E6 04 DIV 12E7 91 SWAP2 12E8 50 POP 12E9 61 PUSH2 0x130c 12EC 56 *JUMP // Stack delta = -2 // Outputs[1] { @12E7 stack[-4] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x130c label_12ED: // Incoming jump from 0x12C8, if !(stack[-1] < storage[0x0c]) // Inputs[1] { @12F8 storage[0x12] } 12ED 5B JUMPDEST 12EE 60 PUSH1 0x64 12F0 61 PUSH2 0x12ff 12F3 60 PUSH1 0x11 12F5 60 PUSH1 0x01 12F7 01 ADD 12F8 54 SLOAD 12F9 60 PUSH1 0x69 12FB 61 PUSH2 0x3094 12FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12EE stack[0] = 0x64 // @12F0 stack[1] = 0x12ff // @12F8 stack[2] = storage[0x12] // @12F9 stack[3] = 0x69 // } // Block ends with call to 0x3094, returns to 0x12FF label_12FF: // Incoming return from call to 0x3094 at 0x12FE // Inputs[1] { @1300 stack[-2] } 12FF 5B JUMPDEST 1300 81 DUP2 1301 15 ISZERO 1302 15 ISZERO 1303 61 PUSH2 0x1308 1306 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1308, if !!stack[-2] label_1307: // Incoming jump from 0x1306, if not !!stack[-2] 1307 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1307 assert(); } // Block terminates label_1308: // Incoming jump from 0x1306, if !!stack[-2] // Inputs[3] // { // @1309 stack[-2] // @1309 stack[-1] // @130A stack[-4] // } 1308 5B JUMPDEST 1309 04 DIV 130A 91 SWAP2 130B 50 POP // Stack delta = -2 // Outputs[1] { @130A stack[-4] = stack[-1] / stack[-2] } // Block continues label_130C: // Incoming jump from 0x130B // Incoming jump from 0x12BD // Incoming jump from 0x12EC // Inputs[2] // { // @130E stack[-2] // @130E stack[-3] // } 130C 5B JUMPDEST 130D 50 POP 130E 90 SWAP1 130F 56 *JUMP // Stack delta = -2 // Outputs[1] { @130E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1310: // Incoming call from 0x0495, returns to 0x0496 // Inputs[2] // { // @1316 storage[0x0d] // @134A msg.sender // } 1310 5B JUMPDEST 1311 60 PUSH1 0x0d 1313 60 PUSH1 0x00 1315 90 SWAP1 1316 54 SLOAD 1317 90 SWAP1 1318 61 PUSH2 0x0100 131B 0A EXP 131C 90 SWAP1 131D 04 DIV 131E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1333 16 AND 1334 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1349 16 AND 134A 33 CALLER 134B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1360 16 AND 1361 14 EQ 1362 15 ISZERO 1363 15 ISZERO 1364 61 PUSH2 0x136c 1367 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x136c, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1368: // Incoming jump from 0x1367, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @136B memory[0x00:0x00] } 1368 60 PUSH1 0x00 136A 80 DUP1 136B FD *REVERT // Stack delta = +0 // Outputs[1] { @136B revert(memory[0x00:0x00]); } // Block terminates label_136C: // Incoming jump from 0x1367, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @136D stack[-1] // @1375 stack[-2] // } 136C 5B JUMPDEST 136D 80 DUP1 136E 60 PUSH1 0x13 1370 81 DUP2 1371 90 SWAP1 1372 55 SSTORE 1373 50 POP 1374 50 POP 1375 56 *JUMP // Stack delta = -2 // Outputs[1] { @1372 storage[0x13] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1376: // Incoming call from 0x04F6, returns to 0x04F7 // Inputs[1] { @137E storage[0x08] } 1376 5B JUMPDEST 1377 60 PUSH1 0x00 1379 60 PUSH1 0x08 137B 60 PUSH1 0x01 137D 90 SWAP1 137E 54 SLOAD 137F 90 SWAP1 1380 61 PUSH2 0x0100 1383 0A EXP 1384 90 SWAP1 1385 04 DIV 1386 60 PUSH1 0xff 1388 16 AND 1389 80 DUP1 138A 61 PUSH2 0x13e0 138D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1377 stack[0] = 0x00 // @1388 stack[1] = 0xff & storage[0x08] / 0x0100 ** 0x01 // } // Block ends with conditional jump to 0x13e0, if 0xff & storage[0x08] / 0x0100 ** 0x01 label_138E: // Incoming jump from 0x138D, if not 0xff & storage[0x08] / 0x0100 ** 0x01 // Inputs[2] // { // @1394 storage[0x0d] // @13C8 msg.sender // } 138E 50 POP 138F 60 PUSH1 0x0d 1391 60 PUSH1 0x00 1393 90 SWAP1 1394 54 SLOAD 1395 90 SWAP1 1396 61 PUSH2 0x0100 1399 0A EXP 139A 90 SWAP1 139B 04 DIV 139C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13B1 16 AND 13B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13C7 16 AND 13C8 33 CALLER 13C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13DE 16 AND 13DF 14 EQ 13E0 5B JUMPDEST 13E1 80 DUP1 13E2 61 PUSH2 0x1438 13E5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @13DF stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x1438, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 label_13E6: // Incoming jump from 0x13E5, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // Incoming jump from 0x13E5, if not stack[-1] // Inputs[2] // { // @13EC storage[0x0f] // @1420 msg.sender // } 13E6 50 POP 13E7 60 PUSH1 0x0f 13E9 60 PUSH1 0x00 13EB 90 SWAP1 13EC 54 SLOAD 13ED 90 SWAP1 13EE 61 PUSH2 0x0100 13F1 0A EXP 13F2 90 SWAP1 13F3 04 DIV 13F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1409 16 AND 140A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 141F 16 AND 1420 33 CALLER 1421 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1436 16 AND 1437 14 EQ 1438 5B JUMPDEST 1439 15 ISZERO 143A 15 ISZERO 143B 61 PUSH2 0x1443 143E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1443, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) label_143F: // Incoming jump from 0x143E, if not !!stack[-1] // Incoming jump from 0x143E, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[1] { @1442 memory[0x00:0x00] } 143F 60 PUSH1 0x00 1441 80 DUP1 1442 FD *REVERT // Stack delta = +0 // Outputs[1] { @1442 revert(memory[0x00:0x00]); } // Block terminates label_1443: // Incoming jump from 0x143E, if !!stack[-1] // Incoming jump from 0x143E, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[3] // { // @1447 stack[-4] // @1448 stack[-3] // @1449 stack[-2] // } 1443 5B JUMPDEST 1444 61 PUSH2 0x144e 1447 84 DUP5 1448 84 DUP5 1449 84 DUP5 144A 61 PUSH2 0x3397 144D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1444 stack[0] = 0x144e // @1447 stack[1] = stack[-4] // @1448 stack[2] = stack[-3] // @1449 stack[3] = stack[-2] // } // Block ends with call to 0x3397, returns to 0x144E label_144E: // Incoming return from call to 0x3397 at 0x144D // Inputs[4] // { // @144F stack[-2] // @144F stack[-1] // @1451 stack[-6] // @1452 stack[-5] // } 144E 5B JUMPDEST 144F 90 SWAP1 1450 50 POP 1451 93 SWAP4 1452 92 SWAP3 1453 50 POP 1454 50 POP 1455 50 POP 1456 56 *JUMP // Stack delta = -5 // Outputs[1] { @1451 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1457: // Incoming call from 0x0547, returns to 0x0548 // Inputs[2] // { // @145D storage[0x0d] // @1491 msg.sender // } 1457 5B JUMPDEST 1458 60 PUSH1 0x0d 145A 60 PUSH1 0x00 145C 90 SWAP1 145D 54 SLOAD 145E 90 SWAP1 145F 61 PUSH2 0x0100 1462 0A EXP 1463 90 SWAP1 1464 04 DIV 1465 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 147A 16 AND 147B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1490 16 AND 1491 33 CALLER 1492 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14A7 16 AND 14A8 14 EQ 14A9 15 ISZERO 14AA 15 ISZERO 14AB 61 PUSH2 0x14b3 14AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14b3, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_14AF: // Incoming jump from 0x14AE, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @14B2 memory[0x00:0x00] } 14AF 60 PUSH1 0x00 14B1 80 DUP1 14B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @14B2 revert(memory[0x00:0x00]); } // Block terminates label_14B3: // Incoming jump from 0x14AE, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @14CC stack[-1] } 14B3 5B JUMPDEST 14B4 60 PUSH1 0x00 14B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CB 16 AND 14CC 81 DUP2 14CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14E2 16 AND 14E3 14 EQ 14E4 15 ISZERO 14E5 15 ISZERO 14E6 15 ISZERO 14E7 61 PUSH2 0x14ef 14EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ef, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_14EB: // Incoming jump from 0x14EA, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @14EE memory[0x00:0x00] } 14EB 60 PUSH1 0x00 14ED 80 DUP1 14EE FD *REVERT // Stack delta = +0 // Outputs[1] { @14EE revert(memory[0x00:0x00]); } // Block terminates label_14EF: // Incoming jump from 0x14EA, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @14F0 stack[-1] // @14FA storage[0x0d] // @1532 stack[-2] // } 14EF 5B JUMPDEST 14F0 80 DUP1 14F1 60 PUSH1 0x0d 14F3 60 PUSH1 0x00 14F5 61 PUSH2 0x0100 14F8 0A EXP 14F9 81 DUP2 14FA 54 SLOAD 14FB 81 DUP2 14FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1511 02 MUL 1512 19 NOT 1513 16 AND 1514 90 SWAP1 1515 83 DUP4 1516 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 152B 16 AND 152C 02 MUL 152D 17 OR 152E 90 SWAP1 152F 55 SSTORE 1530 50 POP 1531 50 POP 1532 56 *JUMP // Stack delta = -2 // Outputs[1] { @152F storage[0x0d] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] label_1533: // Incoming call from 0x055C, returns to 0x055D // Inputs[2] // { // @153B storage[0x02] // @1548 stack[-1] // } 1533 5B JUMPDEST 1534 60 PUSH1 0x00 1536 60 PUSH1 0x02 1538 60 PUSH1 0x00 153A 90 SWAP1 153B 54 SLOAD 153C 90 SWAP1 153D 61 PUSH2 0x0100 1540 0A EXP 1541 90 SWAP1 1542 04 DIV 1543 60 PUSH1 0xff 1545 16 AND 1546 90 SWAP1 1547 50 POP 1548 90 SWAP1 1549 56 *JUMP // Stack delta = +0 // Outputs[1] { @1548 stack[-1] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_154A: // Incoming call from 0x058B, returns to 0x058C // Inputs[3] // { // @1553 msg.sender // @1594 memory[0x00:0x40] // @1598 storage[0x00 + keccak256(memory[0x00:0x40])] // } 154A 5B JUMPDEST 154B 60 PUSH1 0x00 154D 80 DUP1 154E 60 PUSH1 0x00 1550 80 DUP1 1551 60 PUSH1 0x00 1553 33 CALLER 1554 94 SWAP5 1555 50 POP 1556 60 PUSH1 0x16 1558 60 PUSH1 0x00 155A 86 DUP7 155B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1570 16 AND 1571 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1586 16 AND 1587 81 DUP2 1588 52 MSTORE 1589 60 PUSH1 0x20 158B 01 ADD 158C 90 SWAP1 158D 81 DUP2 158E 52 MSTORE 158F 60 PUSH1 0x20 1591 01 ADD 1592 60 PUSH1 0x00 1594 20 SHA3 1595 60 PUSH1 0x00 1597 01 ADD 1598 54 SLOAD 1599 93 SWAP4 159A 50 POP 159B 60 PUSH1 0x00 159D 84 DUP5 159E 11 GT 159F 15 ISZERO 15A0 15 ISZERO 15A1 61 PUSH2 0x15a9 15A4 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @154E stack[2] = 0x00 // @1550 stack[3] = 0x00 // @1551 stack[4] = 0x00 // @1554 stack[0] = msg.sender // @1588 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @158E memory[0x20:0x40] = 0x16 // @1599 stack[1] = storage[0x00 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x15a9, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) label_15A5: // Incoming jump from 0x15A4, if not !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) // Inputs[1] { @15A8 memory[0x00:0x00] } 15A5 60 PUSH1 0x00 15A7 80 DUP1 15A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @15A8 revert(memory[0x00:0x00]); } // Block terminates label_15A9: // Incoming jump from 0x15A4, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) // Inputs[7] // { // @15AE stack[-5] // @15E8 memory[0x00:0x40] // @15EC storage[0x01 + keccak256(memory[0x00:0x40])] // @15ED stack[-3] // @1601 memory[0x00:0x40] // @1602 stack[-2] // @160A storage[0x00 + keccak256(memory[0x00:0x40])] // } 15A9 5B JUMPDEST 15AA 60 PUSH1 0x16 15AC 60 PUSH1 0x00 15AE 86 DUP7 15AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15C4 16 AND 15C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15DA 16 AND 15DB 81 DUP2 15DC 52 MSTORE 15DD 60 PUSH1 0x20 15DF 01 ADD 15E0 90 SWAP1 15E1 81 DUP2 15E2 52 MSTORE 15E3 60 PUSH1 0x20 15E5 01 ADD 15E6 60 PUSH1 0x00 15E8 20 SHA3 15E9 60 PUSH1 0x01 15EB 01 ADD 15EC 54 SLOAD 15ED 92 SWAP3 15EE 50 POP 15EF 60 PUSH1 0x14 15F1 60 PUSH1 0x00 15F3 84 DUP5 15F4 81 DUP2 15F5 52 MSTORE 15F6 60 PUSH1 0x20 15F8 01 ADD 15F9 90 SWAP1 15FA 81 DUP2 15FB 52 MSTORE 15FC 60 PUSH1 0x20 15FE 01 ADD 15FF 60 PUSH1 0x00 1601 20 SHA3 1602 91 SWAP2 1603 50 POP 1604 60 PUSH1 0x00 1606 82 DUP3 1607 60 PUSH1 0x00 1609 01 ADD 160A 54 SLOAD 160B 11 GT 160C 15 ISZERO 160D 15 ISZERO 160E 61 PUSH2 0x1616 1611 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @15DC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @15E2 memory[0x20:0x40] = 0x16 // @15ED stack[-3] = storage[0x01 + keccak256(memory[0x00:0x40])] // @15F5 memory[0x00:0x20] = storage[0x01 + keccak256(memory[0x00:0x40])] // @15FB memory[0x20:0x40] = 0x14 // @1602 stack[-2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x1616, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) label_1612: // Incoming jump from 0x1611, if not !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) // Inputs[1] { @1615 memory[0x00:0x00] } 1612 60 PUSH1 0x00 1614 80 DUP1 1615 FD *REVERT // Stack delta = +0 // Outputs[1] { @1615 revert(memory[0x00:0x00]); } // Block terminates label_1616: // Incoming jump from 0x1611, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] > 0x00) // Inputs[4] // { // @1617 stack[-2] // @161B storage[0x00 + stack[-2]] // @161F stack[-4] // @1624 storage[0x01 + stack[-2]] // } 1616 5B JUMPDEST 1617 81 DUP2 1618 60 PUSH1 0x00 161A 01 ADD 161B 54 SLOAD 161C 61 PUSH2 0x1629 161F 85 DUP6 1620 84 DUP5 1621 60 PUSH1 0x01 1623 01 ADD 1624 54 SLOAD 1625 61 PUSH2 0x3094 1628 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @161B stack[0] = storage[0x00 + stack[-2]] // @161C stack[1] = 0x1629 // @161F stack[2] = stack[-4] // @1624 stack[3] = storage[0x01 + stack[-2]] // } // Block ends with call to 0x3094, returns to 0x1629 label_1629: // Incoming return from call to 0x3094 at 0x1628 // Inputs[1] { @162A stack[-2] } 1629 5B JUMPDEST 162A 81 DUP2 162B 15 ISZERO 162C 15 ISZERO 162D 61 PUSH2 0x1632 1630 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1632, if !!stack[-2] label_1631: // Incoming jump from 0x1630, if not !!stack[-2] 1631 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1631 assert(); } // Block terminates label_1632: // Incoming jump from 0x1630, if !!stack[-2] // Inputs[7] // { // @1633 stack[-2] // @1633 stack[-1] // @1634 stack[-3] // @163C stack[-7] // @1676 memory[0x00:0x40] // @167F address(this) // @1696 address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance // } 1632 5B JUMPDEST 1633 04 DIV 1634 90 SWAP1 1635 50 POP 1636 60 PUSH1 0x00 1638 60 PUSH1 0x16 163A 60 PUSH1 0x00 163C 87 DUP8 163D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1652 16 AND 1653 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1668 16 AND 1669 81 DUP2 166A 52 MSTORE 166B 60 PUSH1 0x20 166D 01 ADD 166E 90 SWAP1 166F 81 DUP2 1670 52 MSTORE 1671 60 PUSH1 0x20 1673 01 ADD 1674 60 PUSH1 0x00 1676 20 SHA3 1677 60 PUSH1 0x00 1679 01 ADD 167A 81 DUP2 167B 90 SWAP1 167C 55 SSTORE 167D 50 POP 167E 80 DUP1 167F 30 ADDRESS 1680 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1695 16 AND 1696 31 BALANCE 1697 10 LT 1698 15 ISZERO 1699 15 ISZERO 169A 61 PUSH2 0x1808 169D 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @1634 stack[-3] = stack[-1] / stack[-2] // @166A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1670 memory[0x20:0x40] = 0x16 // @167C storage[0x00 + keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with conditional jump to 0x1808, if !!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) label_169E: // Incoming jump from 0x169D, if not !!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) // Inputs[4] // { // @16AA storage[0x0d] // @1701 memory[0x00:0x40] // @1702 storage[keccak256(memory[0x00:0x40])] // @1703 stack[-4] // } 169E 61 PUSH2 0x1708 16A1 60 PUSH1 0x04 16A3 60 PUSH1 0x00 16A5 60 PUSH1 0x0d 16A7 60 PUSH1 0x00 16A9 90 SWAP1 16AA 54 SLOAD 16AB 90 SWAP1 16AC 61 PUSH2 0x0100 16AF 0A EXP 16B0 90 SWAP1 16B1 04 DIV 16B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16C7 16 AND 16C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16DD 16 AND 16DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16F3 16 AND 16F4 81 DUP2 16F5 52 MSTORE 16F6 60 PUSH1 0x20 16F8 01 ADD 16F9 90 SWAP1 16FA 81 DUP2 16FB 52 MSTORE 16FC 60 PUSH1 0x20 16FE 01 ADD 16FF 60 PUSH1 0x00 1701 20 SHA3 1702 54 SLOAD 1703 85 DUP6 1704 61 PUSH2 0x375e 1707 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @169E stack[0] = 0x1708 // @16F5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @16FB memory[0x20:0x40] = 0x04 // @1702 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1703 stack[2] = stack[-4] // } // Block ends with call to 0x375e, returns to 0x1708 label_1708: // Incoming return from call to 0x375E at 0x1707 // Inputs[9] // { // @1712 storage[0x0d] // @1769 memory[0x00:0x40] // @176A stack[-1] // @176E stack[-6] // @1788 stack[-2] // @1790 memory[0x40:0x60] // @1795 memory[0x40:0x60] // @179D memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @179D address(0xffffffffffffffffffffffffffffffffffffffff & stack[-6]).call.gas(!stack[-2] * 0x08fc).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 1708 5B JUMPDEST 1709 60 PUSH1 0x04 170B 60 PUSH1 0x00 170D 60 PUSH1 0x0d 170F 60 PUSH1 0x00 1711 90 SWAP1 1712 54 SLOAD 1713 90 SWAP1 1714 61 PUSH2 0x0100 1717 0A EXP 1718 90 SWAP1 1719 04 DIV 171A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 172F 16 AND 1730 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1745 16 AND 1746 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 175B 16 AND 175C 81 DUP2 175D 52 MSTORE 175E 60 PUSH1 0x20 1760 01 ADD 1761 90 SWAP1 1762 81 DUP2 1763 52 MSTORE 1764 60 PUSH1 0x20 1766 01 ADD 1767 60 PUSH1 0x00 1769 20 SHA3 176A 81 DUP2 176B 90 SWAP1 176C 55 SSTORE 176D 50 POP 176E 84 DUP5 176F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1784 16 AND 1785 61 PUSH2 0x08fc 1788 82 DUP3 1789 90 SWAP1 178A 81 DUP2 178B 15 ISZERO 178C 02 MUL 178D 90 SWAP1 178E 60 PUSH1 0x40 1790 51 MLOAD 1791 60 PUSH1 0x00 1793 60 PUSH1 0x40 1795 51 MLOAD 1796 80 DUP1 1797 83 DUP4 1798 03 SUB 1799 81 DUP2 179A 85 DUP6 179B 88 DUP9 179C 88 DUP9 179D F1 CALL 179E 93 SWAP4 179F 50 POP 17A0 50 POP 17A1 50 POP 17A2 50 POP 17A3 15 ISZERO 17A4 15 ISZERO 17A5 61 PUSH2 0x17ad 17A8 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @175D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @1763 memory[0x20:0x40] = 0x04 // @176C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @179D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-6]).call.gas(!stack[-2] * 0x08fc).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x17ad, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-6]).call.gas(!stack[-2] * 0x08fc).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_17A9: // Incoming jump from 0x17A8, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-6]).call.gas(!stack[-2] * 0x08fc).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @17AC memory[0x00:0x00] } 17A9 60 PUSH1 0x00 17AB 80 DUP1 17AC FD *REVERT // Stack delta = +0 // Outputs[1] { @17AC revert(memory[0x00:0x00]); } // Block terminates label_17AD: // Incoming jump from 0x17A8, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-6]).call.gas(!stack[-2] * 0x08fc).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[6] // { // @17AE stack[-5] // @17E6 stack[-1] // @17E7 stack[-4] // @17EA memory[0x40:0x60] // @17FE memory[0x40:0x60] // @1803 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 17AD 5B JUMPDEST 17AE 84 DUP5 17AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17C4 16 AND 17C5 7F PUSH32 0xadec52fcd1408589179b85e44b434374db078b4eaf793e7d1a1bb0ae4ecfeee5 17E6 82 DUP3 17E7 86 DUP7 17E8 60 PUSH1 0x40 17EA 51 MLOAD 17EB 80 DUP1 17EC 83 DUP4 17ED 81 DUP2 17EE 52 MSTORE 17EF 60 PUSH1 0x20 17F1 01 ADD 17F2 82 DUP3 17F3 81 DUP2 17F4 52 MSTORE 17F5 60 PUSH1 0x20 17F7 01 ADD 17F8 92 SWAP3 17F9 50 POP 17FA 50 POP 17FB 50 POP 17FC 60 PUSH1 0x40 17FE 51 MLOAD 17FF 80 DUP1 1800 91 SWAP2 1801 03 SUB 1802 90 SWAP1 1803 A2 LOG2 1804 61 PUSH2 0x18ec 1807 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @17EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @17F4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @1803 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xadec52fcd1408589179b85e44b434374db078b4eaf793e7d1a1bb0ae4ecfeee5, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x18ec label_1808: // Incoming jump from 0x169D, if !!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) // Inputs[4] // { // @1810 stack[-5] // @184A memory[0x00:0x40] // @184B storage[keccak256(memory[0x00:0x40])] // @184C stack[-4] // } 1808 5B JUMPDEST 1809 61 PUSH2 0x1851 180C 60 PUSH1 0x04 180E 60 PUSH1 0x00 1810 87 DUP8 1811 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1826 16 AND 1827 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 183C 16 AND 183D 81 DUP2 183E 52 MSTORE 183F 60 PUSH1 0x20 1841 01 ADD 1842 90 SWAP1 1843 81 DUP2 1844 52 MSTORE 1845 60 PUSH1 0x20 1847 01 ADD 1848 60 PUSH1 0x00 184A 20 SHA3 184B 54 SLOAD 184C 85 DUP6 184D 61 PUSH2 0x375e 1850 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1809 stack[0] = 0x1851 // @183E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1844 memory[0x20:0x40] = 0x04 // @184B stack[1] = storage[keccak256(memory[0x00:0x40])] // @184C stack[2] = stack[-4] // } // Block ends with call to 0x375e, returns to 0x1851 label_1851: // Incoming return from call to 0x375E at 0x1850 // Inputs[8] // { // @1856 stack[-6] // @1890 memory[0x00:0x40] // @1891 stack[-1] // @18CD stack[-2] // @18D2 memory[0x40:0x60] // @18E6 memory[0x40:0x60] // @18EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @18F2 stack[-7] // } 1851 5B JUMPDEST 1852 60 PUSH1 0x04 1854 60 PUSH1 0x00 1856 87 DUP8 1857 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 186C 16 AND 186D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1882 16 AND 1883 81 DUP2 1884 52 MSTORE 1885 60 PUSH1 0x20 1887 01 ADD 1888 90 SWAP1 1889 81 DUP2 188A 52 MSTORE 188B 60 PUSH1 0x20 188D 01 ADD 188E 60 PUSH1 0x00 1890 20 SHA3 1891 81 DUP2 1892 90 SWAP1 1893 55 SSTORE 1894 50 POP 1895 84 DUP5 1896 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18AB 16 AND 18AC 7F PUSH32 0xadec52fcd1408589179b85e44b434374db078b4eaf793e7d1a1bb0ae4ecfeee5 18CD 82 DUP3 18CE 60 PUSH1 0x00 18D0 60 PUSH1 0x40 18D2 51 MLOAD 18D3 80 DUP1 18D4 83 DUP4 18D5 81 DUP2 18D6 52 MSTORE 18D7 60 PUSH1 0x20 18D9 01 ADD 18DA 82 DUP3 18DB 81 DUP2 18DC 52 MSTORE 18DD 60 PUSH1 0x20 18DF 01 ADD 18E0 92 SWAP3 18E1 50 POP 18E2 50 POP 18E3 50 POP 18E4 60 PUSH1 0x40 18E6 51 MLOAD 18E7 80 DUP1 18E8 91 SWAP2 18E9 03 SUB 18EA 90 SWAP1 18EB A2 LOG2 18EC 5B JUMPDEST 18ED 50 POP 18EE 50 POP 18EF 50 POP 18F0 50 POP 18F1 50 POP 18F2 56 *JUMP // Stack delta = -7 // Outputs[6] // { // @1884 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @188A memory[0x20:0x40] = 0x04 // @1893 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @18D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @18DC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @18EB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xadec52fcd1408589179b85e44b434374db078b4eaf793e7d1a1bb0ae4ecfeee5, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-7] label_18F3: // Incoming call from 0x05A0, returns to 0x05A1 // Inputs[2] // { // @18F6 storage[0x0c] // @18F7 stack[-1] // } 18F3 5B JUMPDEST 18F4 60 PUSH1 0x0c 18F6 54 SLOAD 18F7 81 DUP2 18F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @18F6 stack[0] = storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_18F9: // Incoming call from 0x05C9, returns to 0x05CA // Inputs[2] // { // @18FF storage[0x0d] // @191D stack[-1] // } 18F9 5B JUMPDEST 18FA 60 PUSH1 0x0d 18FC 60 PUSH1 0x00 18FE 90 SWAP1 18FF 54 SLOAD 1900 90 SWAP1 1901 61 PUSH2 0x0100 1904 0A EXP 1905 90 SWAP1 1906 04 DIV 1907 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 191C 16 AND 191D 81 DUP2 191E 56 *JUMP // Stack delta = +1 // Outputs[1] { @191C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_191F: // Incoming call from 0x061E, returns to 0x061F // Inputs[2] // { // @1922 storage[0x09] // @1923 stack[-1] // } 191F 5B JUMPDEST 1920 60 PUSH1 0x09 1922 54 SLOAD 1923 81 DUP2 1924 56 *JUMP // Stack delta = +1 // Outputs[1] { @1922 stack[0] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_1925: // Incoming call from 0x0647, returns to 0x0648 // Inputs[2] // { // @192B storage[0x0f] // @1949 stack[-1] // } 1925 5B JUMPDEST 1926 60 PUSH1 0x0f 1928 60 PUSH1 0x00 192A 90 SWAP1 192B 54 SLOAD 192C 90 SWAP1 192D 61 PUSH2 0x0100 1930 0A EXP 1931 90 SWAP1 1932 04 DIV 1933 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1948 16 AND 1949 81 DUP2 194A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1948 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_194B: // Incoming call from 0x069C, returns to 0x069D // Inputs[2] // { // @194E storage[0x13] // @194F stack[-1] // } 194B 5B JUMPDEST 194C 60 PUSH1 0x13 194E 54 SLOAD 194F 81 DUP2 1950 56 *JUMP // Stack delta = +1 // Outputs[1] { @194E stack[0] = storage[0x13] } // Block ends with unconditional jump to stack[-1] label_1951: // Incoming call from 0x06E9, returns to 0x06EA // Inputs[2] // { // @1957 storage[0x0e] // @198B msg.sender // } 1951 5B JUMPDEST 1952 60 PUSH1 0x0e 1954 60 PUSH1 0x00 1956 90 SWAP1 1957 54 SLOAD 1958 90 SWAP1 1959 61 PUSH2 0x0100 195C 0A EXP 195D 90 SWAP1 195E 04 DIV 195F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1974 16 AND 1975 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 198A 16 AND 198B 33 CALLER 198C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A1 16 AND 19A2 14 EQ 19A3 80 DUP1 19A4 61 PUSH2 0x19fa 19A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19A2 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x19fa, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 label_19A8: // Incoming jump from 0x19A7, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // Inputs[2] // { // @19AE storage[0x0d] // @19E2 msg.sender // } 19A8 50 POP 19A9 60 PUSH1 0x0d 19AB 60 PUSH1 0x00 19AD 90 SWAP1 19AE 54 SLOAD 19AF 90 SWAP1 19B0 61 PUSH2 0x0100 19B3 0A EXP 19B4 90 SWAP1 19B5 04 DIV 19B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19CB 16 AND 19CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19E1 16 AND 19E2 33 CALLER 19E3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19F8 16 AND 19F9 14 EQ 19FA 5B JUMPDEST 19FB 15 ISZERO 19FC 15 ISZERO 19FD 61 PUSH2 0x1a05 1A00 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a05, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1A01: // Incoming jump from 0x1A00, if not !!stack[-1] // Incoming jump from 0x1A00, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1A04 memory[0x00:0x00] } 1A01 60 PUSH1 0x00 1A03 80 DUP1 1A04 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A04 revert(memory[0x00:0x00]); } // Block terminates label_1A05: // Incoming jump from 0x1A00, if !!stack[-1] // Incoming jump from 0x1A00, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[7] // { // @1A0C stack[-1] // @1A46 memory[0x00:0x40] // @1A4E storage[keccak256(memory[0x00:0x40])] // @1A98 memory[0x40:0x60] // @1A9B memory[0x40:0x60] // @1AA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1AA2 stack[-2] // } 1A05 5B JUMPDEST 1A06 60 PUSH1 0x01 1A08 60 PUSH1 0x10 1A0A 60 PUSH1 0x00 1A0C 83 DUP4 1A0D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A22 16 AND 1A23 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A38 16 AND 1A39 81 DUP2 1A3A 52 MSTORE 1A3B 60 PUSH1 0x20 1A3D 01 ADD 1A3E 90 SWAP1 1A3F 81 DUP2 1A40 52 MSTORE 1A41 60 PUSH1 0x20 1A43 01 ADD 1A44 60 PUSH1 0x00 1A46 20 SHA3 1A47 60 PUSH1 0x00 1A49 61 PUSH2 0x0100 1A4C 0A EXP 1A4D 81 DUP2 1A4E 54 SLOAD 1A4F 81 DUP2 1A50 60 PUSH1 0xff 1A52 02 MUL 1A53 19 NOT 1A54 16 AND 1A55 90 SWAP1 1A56 83 DUP4 1A57 15 ISZERO 1A58 15 ISZERO 1A59 02 MUL 1A5A 17 OR 1A5B 90 SWAP1 1A5C 55 SSTORE 1A5D 50 POP 1A5E 80 DUP1 1A5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A74 16 AND 1A75 7F PUSH32 0xaab7954e9d246b167ef88aeddad35209ca2489d95a8aeb59e288d9b19fae5a54 1A96 60 PUSH1 0x40 1A98 51 MLOAD 1A99 60 PUSH1 0x40 1A9B 51 MLOAD 1A9C 80 DUP1 1A9D 91 SWAP2 1A9E 03 SUB 1A9F 90 SWAP1 1AA0 A2 LOG2 1AA1 50 POP 1AA2 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1A3A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1A40 memory[0x20:0x40] = 0x10 // @1A5C storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1AA0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xaab7954e9d246b167ef88aeddad35209ca2489d95a8aeb59e288d9b19fae5a54, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_1AA3: // Incoming call from 0x06FE, returns to 0x06FF // Inputs[2] // { // @1AA6 storage[0x07] // @1AA7 stack[-1] // } 1AA3 5B JUMPDEST 1AA4 60 PUSH1 0x07 1AA6 54 SLOAD 1AA7 81 DUP2 1AA8 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AA6 stack[0] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_1AA9: // Incoming call from 0x24F1, returns to 0x24F2 // Incoming call from 0x0779, returns to 0x077A // Incoming call from 0x2487, returns to 0x2488 // Incoming call from 0x1EF3, returns to 0x1EF4 // Inputs[4] // { // @1AB0 stack[-1] // @1AEA memory[0x00:0x40] // @1AEB storage[keccak256(memory[0x00:0x40])] // @1AEE stack[-2] // } 1AA9 5B JUMPDEST 1AAA 60 PUSH1 0x00 1AAC 60 PUSH1 0x04 1AAE 60 PUSH1 0x00 1AB0 83 DUP4 1AB1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AC6 16 AND 1AC7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1ADC 16 AND 1ADD 81 DUP2 1ADE 52 MSTORE 1ADF 60 PUSH1 0x20 1AE1 01 ADD 1AE2 90 SWAP1 1AE3 81 DUP2 1AE4 52 MSTORE 1AE5 60 PUSH1 0x20 1AE7 01 ADD 1AE8 60 PUSH1 0x00 1AEA 20 SHA3 1AEB 54 SLOAD 1AEC 90 SWAP1 1AED 50 POP 1AEE 91 SWAP2 1AEF 90 SWAP1 1AF0 50 POP 1AF1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1ADE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1AE4 memory[0x20:0x40] = 0x04 // @1AEE stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1AF2: // Incoming call from 0x07C6, returns to 0x07C7 // Inputs[2] // { // @1AF8 storage[0x0d] // @1B2C msg.sender // } 1AF2 5B JUMPDEST 1AF3 60 PUSH1 0x0d 1AF5 60 PUSH1 0x00 1AF7 90 SWAP1 1AF8 54 SLOAD 1AF9 90 SWAP1 1AFA 61 PUSH2 0x0100 1AFD 0A EXP 1AFE 90 SWAP1 1AFF 04 DIV 1B00 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B15 16 AND 1B16 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B2B 16 AND 1B2C 33 CALLER 1B2D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B42 16 AND 1B43 14 EQ 1B44 15 ISZERO 1B45 15 ISZERO 1B46 61 PUSH2 0x1b4e 1B49 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b4e, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1B4A: // Incoming jump from 0x1B49, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1B4D memory[0x00:0x00] } 1B4A 60 PUSH1 0x00 1B4C 80 DUP1 1B4D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B4D revert(memory[0x00:0x00]); } // Block terminates label_1B4E: // Incoming jump from 0x1B49, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1B67 stack[-1] } 1B4E 5B JUMPDEST 1B4F 60 PUSH1 0x00 1B51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B66 16 AND 1B67 81 DUP2 1B68 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B7D 16 AND 1B7E 14 EQ 1B7F 15 ISZERO 1B80 15 ISZERO 1B81 15 ISZERO 1B82 61 PUSH2 0x1b8a 1B85 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b8a, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1B86: // Incoming jump from 0x1B85, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1B89 memory[0x00:0x00] } 1B86 60 PUSH1 0x00 1B88 80 DUP1 1B89 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B89 revert(memory[0x00:0x00]); } // Block terminates label_1B8A: // Incoming jump from 0x1B85, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @1B8B stack[-1] // @1B95 storage[0x0f] // @1BD7 storage[0x0f] // @1C2E memory[0x00:0x40] // @1C36 storage[keccak256(memory[0x00:0x40])] // @1C51 storage[0x0f] // @1C62 stack[-2] // } 1B8A 5B JUMPDEST 1B8B 80 DUP1 1B8C 60 PUSH1 0x0f 1B8E 60 PUSH1 0x00 1B90 61 PUSH2 0x0100 1B93 0A EXP 1B94 81 DUP2 1B95 54 SLOAD 1B96 81 DUP2 1B97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BAC 02 MUL 1BAD 19 NOT 1BAE 16 AND 1BAF 90 SWAP1 1BB0 83 DUP4 1BB1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BC6 16 AND 1BC7 02 MUL 1BC8 17 OR 1BC9 90 SWAP1 1BCA 55 SSTORE 1BCB 50 POP 1BCC 60 PUSH1 0x01 1BCE 60 PUSH1 0x10 1BD0 60 PUSH1 0x00 1BD2 60 PUSH1 0x0f 1BD4 60 PUSH1 0x00 1BD6 90 SWAP1 1BD7 54 SLOAD 1BD8 90 SWAP1 1BD9 61 PUSH2 0x0100 1BDC 0A EXP 1BDD 90 SWAP1 1BDE 04 DIV 1BDF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BF4 16 AND 1BF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C0A 16 AND 1C0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C20 16 AND 1C21 81 DUP2 1C22 52 MSTORE 1C23 60 PUSH1 0x20 1C25 01 ADD 1C26 90 SWAP1 1C27 81 DUP2 1C28 52 MSTORE 1C29 60 PUSH1 0x20 1C2B 01 ADD 1C2C 60 PUSH1 0x00 1C2E 20 SHA3 1C2F 60 PUSH1 0x00 1C31 61 PUSH2 0x0100 1C34 0A EXP 1C35 81 DUP2 1C36 54 SLOAD 1C37 81 DUP2 1C38 60 PUSH1 0xff 1C3A 02 MUL 1C3B 19 NOT 1C3C 16 AND 1C3D 90 SWAP1 1C3E 83 DUP4 1C3F 15 ISZERO 1C40 15 ISZERO 1C41 02 MUL 1C42 17 OR 1C43 90 SWAP1 1C44 55 SSTORE 1C45 50 POP 1C46 60 PUSH1 0x01 1C48 60 PUSH1 0x0f 1C4A 60 PUSH1 0x14 1C4C 61 PUSH2 0x0100 1C4F 0A EXP 1C50 81 DUP2 1C51 54 SLOAD 1C52 81 DUP2 1C53 60 PUSH1 0xff 1C55 02 MUL 1C56 19 NOT 1C57 16 AND 1C58 90 SWAP1 1C59 83 DUP4 1C5A 15 ISZERO 1C5B 15 ISZERO 1C5C 02 MUL 1C5D 17 OR 1C5E 90 SWAP1 1C5F 55 SSTORE 1C60 50 POP 1C61 50 POP 1C62 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1BCA storage[0x0f] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0f]) // @1C22 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00 // @1C28 memory[0x20:0x40] = 0x10 // @1C44 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1C5F storage[0x0f] = !!0x01 * 0x0100 ** 0x14 | (~(0xff * 0x0100 ** 0x14) & storage[0x0f]) // } // Block ends with unconditional jump to stack[-2] label_1C63: // Incoming call from 0x07DB, returns to 0x07DC // Inputs[2] // { // @1C69 storage[0x0d] // @1C9D msg.sender // } 1C63 5B JUMPDEST 1C64 60 PUSH1 0x0d 1C66 60 PUSH1 0x00 1C68 90 SWAP1 1C69 54 SLOAD 1C6A 90 SWAP1 1C6B 61 PUSH2 0x0100 1C6E 0A EXP 1C6F 90 SWAP1 1C70 04 DIV 1C71 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C86 16 AND 1C87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C9C 16 AND 1C9D 33 CALLER 1C9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CB3 16 AND 1CB4 14 EQ 1CB5 15 ISZERO 1CB6 15 ISZERO 1CB7 61 PUSH2 0x1cbf 1CBA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1cbf, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1CBB: // Incoming jump from 0x1CBA, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1CBE memory[0x00:0x00] } 1CBB 60 PUSH1 0x00 1CBD 80 DUP1 1CBE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CBE revert(memory[0x00:0x00]); } // Block terminates label_1CBF: // Incoming jump from 0x1CBA, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @1CC2 storage[0x0a] // @1CC3 block.number // } 1CBF 5B JUMPDEST 1CC0 60 PUSH1 0x0a 1CC2 54 SLOAD 1CC3 43 NUMBER 1CC4 11 GT 1CC5 15 ISZERO 1CC6 15 ISZERO 1CC7 61 PUSH2 0x1ccf 1CCA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ccf, if !!(block.number > storage[0x0a]) label_1CCB: // Incoming jump from 0x1CCA, if not !!(block.number > storage[0x0a]) // Inputs[1] { @1CCE memory[0x00:0x00] } 1CCB 60 PUSH1 0x00 1CCD 80 DUP1 1CCE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CCE revert(memory[0x00:0x00]); } // Block terminates label_1CCF: // Incoming jump from 0x1CCA, if !!(block.number > storage[0x0a]) // Inputs[2] // { // @1CDB storage[0x08] // @1CEB stack[-1] // } 1CCF 5B JUMPDEST 1CD0 60 PUSH1 0x01 1CD2 60 PUSH1 0x08 1CD4 60 PUSH1 0x01 1CD6 61 PUSH2 0x0100 1CD9 0A EXP 1CDA 81 DUP2 1CDB 54 SLOAD 1CDC 81 DUP2 1CDD 60 PUSH1 0xff 1CDF 02 MUL 1CE0 19 NOT 1CE1 16 AND 1CE2 90 SWAP1 1CE3 83 DUP4 1CE4 15 ISZERO 1CE5 15 ISZERO 1CE6 02 MUL 1CE7 17 OR 1CE8 90 SWAP1 1CE9 55 SSTORE 1CEA 50 POP 1CEB 56 *JUMP // Stack delta = -1 // Outputs[1] { @1CE9 storage[0x08] = !!0x01 * 0x0100 ** 0x01 | (~(0xff * 0x0100 ** 0x01) & storage[0x08]) } // Block ends with unconditional jump to stack[-1] label_1CEC: // Incoming call from 0x07FE, returns to 0x07FF // Inputs[2] // { // @1CF2 storage[0x0d] // @1D26 msg.sender // } 1CEC 5B JUMPDEST 1CED 60 PUSH1 0x0d 1CEF 60 PUSH1 0x00 1CF1 90 SWAP1 1CF2 54 SLOAD 1CF3 90 SWAP1 1CF4 61 PUSH2 0x0100 1CF7 0A EXP 1CF8 90 SWAP1 1CF9 04 DIV 1CFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D0F 16 AND 1D10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D25 16 AND 1D26 33 CALLER 1D27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3C 16 AND 1D3D 14 EQ 1D3E 15 ISZERO 1D3F 15 ISZERO 1D40 61 PUSH2 0x1d48 1D43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d48, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1D44: // Incoming jump from 0x1D43, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @1D47 memory[0x00:0x00] } 1D44 60 PUSH1 0x00 1D46 80 DUP1 1D47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D47 revert(memory[0x00:0x00]); } // Block terminates label_1D48: // Incoming jump from 0x1D43, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @1D4E storage[0x09] // @1D51 storage[0x0c] // } 1D48 5B JUMPDEST 1D49 61 PUSH2 0x1d56 1D4C 60 PUSH1 0x09 1D4E 54 SLOAD 1D4F 60 PUSH1 0x0c 1D51 54 SLOAD 1D52 61 PUSH2 0x375e 1D55 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D49 stack[0] = 0x1d56 // @1D4E stack[1] = storage[0x09] // @1D51 stack[2] = storage[0x0c] // } // Block ends with call to 0x375e, returns to 0x1D56 label_1D56: // Incoming return from call to 0x375E at 0x1D55 // Inputs[2] // { // @1D57 block.number // @1D58 stack[-1] // } 1D56 5B JUMPDEST 1D57 43 NUMBER 1D58 10 LT 1D59 15 ISZERO 1D5A 15 ISZERO 1D5B 61 PUSH2 0x1d63 1D5E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d63, if !!(block.number < stack[-1]) label_1D5F: // Incoming jump from 0x1D5E, if not !!(block.number < stack[-1]) // Inputs[1] { @1D62 memory[0x00:0x00] } 1D5F 60 PUSH1 0x00 1D61 80 DUP1 1D62 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D62 revert(memory[0x00:0x00]); } // Block terminates label_1D63: // Incoming jump from 0x1D5E, if !!(block.number < stack[-1]) // Inputs[2] // { // @1D69 storage[0x09] // @1D6A stack[-1] // } 1D63 5B JUMPDEST 1D64 61 PUSH2 0x1d6f 1D67 60 PUSH1 0x09 1D69 54 SLOAD 1D6A 82 DUP3 1D6B 61 PUSH2 0x375e 1D6E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D64 stack[0] = 0x1d6f // @1D69 stack[1] = storage[0x09] // @1D6A stack[2] = stack[-1] // } // Block ends with call to 0x375e, returns to 0x1D6F label_1D6F: // Incoming return from call to 0x375E at 0x1D6E // Inputs[2] // { // @1D70 block.number // @1D71 stack[-1] // } 1D6F 5B JUMPDEST 1D70 43 NUMBER 1D71 10 LT 1D72 15 ISZERO 1D73 15 ISZERO 1D74 61 PUSH2 0x1d7c 1D77 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d7c, if !!(block.number < stack[-1]) label_1D78: // Incoming jump from 0x1D77, if not !!(block.number < stack[-1]) // Inputs[1] { @1D7B memory[0x00:0x00] } 1D78 60 PUSH1 0x00 1D7A 80 DUP1 1D7B FD *REVERT // Stack delta = +0 // Outputs[1] { @1D7B revert(memory[0x00:0x00]); } // Block terminates label_1D7C: // Incoming jump from 0x1D77, if !!(block.number < stack[-1]) // Inputs[2] // { // @1D7D stack[-1] // @1D85 stack[-2] // } 1D7C 5B JUMPDEST 1D7D 80 DUP1 1D7E 60 PUSH1 0x0c 1D80 81 DUP2 1D81 90 SWAP1 1D82 55 SSTORE 1D83 50 POP 1D84 50 POP 1D85 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D82 storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1D86: // Incoming call from 0x0821, returns to 0x0822 // Inputs[2] // { // @1D8C storage[0x0e] // @1DC0 msg.sender // } 1D86 5B JUMPDEST 1D87 60 PUSH1 0x0e 1D89 60 PUSH1 0x00 1D8B 90 SWAP1 1D8C 54 SLOAD 1D8D 90 SWAP1 1D8E 61 PUSH2 0x0100 1D91 0A EXP 1D92 90 SWAP1 1D93 04 DIV 1D94 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DA9 16 AND 1DAA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DBF 16 AND 1DC0 33 CALLER 1DC1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DD6 16 AND 1DD7 14 EQ 1DD8 80 DUP1 1DD9 61 PUSH2 0x1e2f 1DDC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DD7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x1e2f, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 label_1DDD: // Incoming jump from 0x1DDC, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // Inputs[2] // { // @1DE3 storage[0x0d] // @1E17 msg.sender // } 1DDD 50 POP 1DDE 60 PUSH1 0x0d 1DE0 60 PUSH1 0x00 1DE2 90 SWAP1 1DE3 54 SLOAD 1DE4 90 SWAP1 1DE5 61 PUSH2 0x0100 1DE8 0A EXP 1DE9 90 SWAP1 1DEA 04 DIV 1DEB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E00 16 AND 1E01 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E16 16 AND 1E17 33 CALLER 1E18 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E2D 16 AND 1E2E 14 EQ 1E2F 5B JUMPDEST 1E30 15 ISZERO 1E31 15 ISZERO 1E32 61 PUSH2 0x1e3a 1E35 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e3a, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_1E36: // Incoming jump from 0x1E35, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x1E35, if not !!stack[-1] // Inputs[1] { @1E39 memory[0x00:0x00] } 1E36 60 PUSH1 0x00 1E38 80 DUP1 1E39 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E39 revert(memory[0x00:0x00]); } // Block terminates label_1E3A: // Incoming jump from 0x1E35, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x1E35, if !!stack[-1] // Inputs[1] { @1E3D stack[-1] } 1E3A 5B JUMPDEST 1E3B 60 PUSH1 0x00 1E3D 81 DUP2 1E3E 11 GT 1E3F 15 ISZERO 1E40 15 ISZERO 1E41 61 PUSH2 0x1e49 1E44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e49, if !!(stack[-1] > 0x00) label_1E45: // Incoming jump from 0x1E44, if not !!(stack[-1] > 0x00) // Inputs[1] { @1E48 memory[0x00:0x00] } 1E45 60 PUSH1 0x00 1E47 80 DUP1 1E48 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E48 revert(memory[0x00:0x00]); } // Block terminates label_1E49: // Incoming jump from 0x1E44, if !!(stack[-1] > 0x00) // Inputs[1] { @1E4D stack[-1] } 1E49 5B JUMPDEST 1E4A 61 PUSH2 0x1e52 1E4D 81 DUP2 1E4E 61 PUSH2 0x3788 1E51 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E4A stack[0] = 0x1e52 // @1E4D stack[1] = stack[-1] // } // Block ends with call to 0x3788, returns to 0x1E52 label_1E52: // Incoming return from call to 0x3788 at 0x1E51 // Inputs[11] // { // @1E53 stack[-1] // @1E65 storage[0x15] // @1E73 memory[0x00:0x40] // @1E78 storage[0x11] // @1E82 storage[0x12] // @1E8B block.timestamp // @1EB9 storage[0x12] // @1EBC memory[0x40:0x60] // @1ED0 memory[0x40:0x60] // @1ED5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1ED7 stack[-2] // } 1E52 5B JUMPDEST 1E53 80 DUP1 1E54 60 PUSH1 0x11 1E56 60 PUSH1 0x00 1E58 01 ADD 1E59 81 DUP2 1E5A 90 SWAP1 1E5B 55 SSTORE 1E5C 50 POP 1E5D 60 PUSH1 0x11 1E5F 60 PUSH1 0x14 1E61 60 PUSH1 0x00 1E63 60 PUSH1 0x15 1E65 54 SLOAD 1E66 81 DUP2 1E67 52 MSTORE 1E68 60 PUSH1 0x20 1E6A 01 ADD 1E6B 90 SWAP1 1E6C 81 DUP2 1E6D 52 MSTORE 1E6E 60 PUSH1 0x20 1E70 01 ADD 1E71 60 PUSH1 0x00 1E73 20 SHA3 1E74 60 PUSH1 0x00 1E76 82 DUP3 1E77 01 ADD 1E78 54 SLOAD 1E79 81 DUP2 1E7A 60 PUSH1 0x00 1E7C 01 ADD 1E7D 55 SSTORE 1E7E 60 PUSH1 0x01 1E80 82 DUP3 1E81 01 ADD 1E82 54 SLOAD 1E83 81 DUP2 1E84 60 PUSH1 0x01 1E86 01 ADD 1E87 55 SSTORE 1E88 90 SWAP1 1E89 50 POP 1E8A 50 POP 1E8B 42 TIMESTAMP 1E8C 60 PUSH1 0x15 1E8E 81 DUP2 1E8F 90 SWAP1 1E90 55 SSTORE 1E91 50 POP 1E92 7F PUSH32 0x945c1c4e99aa89f648fbfe3df471b916f719e16d960fcec0737d4d56bd696838 1EB3 81 DUP2 1EB4 60 PUSH1 0x11 1EB6 60 PUSH1 0x01 1EB8 01 ADD 1EB9 54 SLOAD 1EBA 60 PUSH1 0x40 1EBC 51 MLOAD 1EBD 80 DUP1 1EBE 83 DUP4 1EBF 81 DUP2 1EC0 52 MSTORE 1EC1 60 PUSH1 0x20 1EC3 01 ADD 1EC4 82 DUP3 1EC5 81 DUP2 1EC6 52 MSTORE 1EC7 60 PUSH1 0x20 1EC9 01 ADD 1ECA 92 SWAP3 1ECB 50 POP 1ECC 50 POP 1ECD 50 POP 1ECE 60 PUSH1 0x40 1ED0 51 MLOAD 1ED1 80 DUP1 1ED2 91 SWAP2 1ED3 03 SUB 1ED4 90 SWAP1 1ED5 A1 LOG1 1ED6 50 POP 1ED7 56 *JUMP // Stack delta = -2 // Outputs[9] // { // @1E5B storage[0x11] = stack[-1] // @1E67 memory[0x00:0x20] = storage[0x15] // @1E6D memory[0x20:0x40] = 0x14 // @1E7D storage[0x00 + keccak256(memory[0x00:0x40])] = storage[0x11] // @1E87 storage[0x01 + keccak256(memory[0x00:0x40])] = storage[0x12] // @1E90 storage[0x15] = block.timestamp // @1EC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1EC6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = storage[0x12] // @1ED5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x945c1c4e99aa89f648fbfe3df471b916f719e16d960fcec0737d4d56bd696838]); // } // Block ends with unconditional jump to stack[-2] label_1ED8: // Incoming call from 0x0844, returns to 0x0845 // Inputs[1] { @1EDE stack[-1] } 1ED8 5B JUMPDEST 1ED9 60 PUSH1 0x00 1EDB 80 DUP1 1EDC 60 PUSH1 0x00 1EDE 83 DUP4 1EDF 11 GT 1EE0 15 ISZERO 1EE1 15 ISZERO 1EE2 61 PUSH2 0x1eea 1EE5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ED9 stack[0] = 0x00 // @1EDB stack[1] = 0x00 // } // Block ends with conditional jump to 0x1eea, if !!(stack[-1] > 0x00) label_1EE6: // Incoming jump from 0x1EE5, if not !!(stack[-1] > 0x00) // Inputs[1] { @1EE9 memory[0x00:0x00] } 1EE6 60 PUSH1 0x00 1EE8 80 DUP1 1EE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EE9 revert(memory[0x00:0x00]); } // Block terminates label_1EEA: // Incoming jump from 0x1EE5, if !!(stack[-1] > 0x00) // Inputs[2] // { // @1EEB stack[-3] // @1EEF msg.sender // } 1EEA 5B JUMPDEST 1EEB 82 DUP3 1EEC 61 PUSH2 0x1ef4 1EEF 33 CALLER 1EF0 61 PUSH2 0x1aa9 1EF3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EEB stack[0] = stack[-3] // @1EEC stack[1] = 0x1ef4 // @1EEF stack[2] = msg.sender // } // Block ends with call to 0x1aa9, returns to 0x1EF4 label_1EF4: // Incoming return from call to 0x1AA9 at 0x1EF3 // Inputs[2] // { // @1EF5 stack[-1] // @1EF5 stack[-2] // } 1EF4 5B JUMPDEST 1EF5 10 LT 1EF6 15 ISZERO 1EF7 15 ISZERO 1EF8 15 ISZERO 1EF9 61 PUSH2 0x1f01 1EFC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1f01, if !!!(stack[-1] < stack[-2]) label_1EFD: // Incoming jump from 0x1EFC, if not !!!(stack[-1] < stack[-2]) // Inputs[1] { @1F00 memory[0x00:0x00] } 1EFD 60 PUSH1 0x00 1EFF 80 DUP1 1F00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F00 revert(memory[0x00:0x00]); } // Block terminates label_1F01: // Incoming jump from 0x1EFC, if !!!(stack[-1] < stack[-2]) // Inputs[3] // { // @1F07 storage[0x11] // @1F0B stack[-3] // @1F11 storage[0x12] // } 1F01 5B JUMPDEST 1F02 60 PUSH1 0x11 1F04 60 PUSH1 0x00 1F06 01 ADD 1F07 54 SLOAD 1F08 61 PUSH2 0x1f16 1F0B 84 DUP5 1F0C 60 PUSH1 0x11 1F0E 60 PUSH1 0x01 1F10 01 ADD 1F11 54 SLOAD 1F12 61 PUSH2 0x3094 1F15 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F07 stack[0] = storage[0x11] // @1F08 stack[1] = 0x1f16 // @1F0B stack[2] = stack[-3] // @1F11 stack[3] = storage[0x12] // } // Block ends with call to 0x3094, returns to 0x1F16 label_1F16: // Incoming return from call to 0x3094 at 0x1F15 // Inputs[1] { @1F17 stack[-2] } 1F16 5B JUMPDEST 1F17 81 DUP2 1F18 15 ISZERO 1F19 15 ISZERO 1F1A 61 PUSH2 0x1f1f 1F1D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f1f, if !!stack[-2] label_1F1E: // Incoming jump from 0x1F1D, if not !!stack[-2] 1F1E FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F1E assert(); } // Block terminates label_1F1F: // Incoming jump from 0x1F1D, if !!stack[-2] // Inputs[5] // { // @1F20 stack[-1] // @1F20 stack[-2] // @1F21 stack[-3] // @1F24 address(this) // @1F3B address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance // } 1F1F 5B JUMPDEST 1F20 04 DIV 1F21 90 SWAP1 1F22 50 POP 1F23 80 DUP1 1F24 30 ADDRESS 1F25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F3A 16 AND 1F3B 31 BALANCE 1F3C 10 LT 1F3D 15 ISZERO 1F3E 15 ISZERO 1F3F 15 ISZERO 1F40 61 PUSH2 0x1f48 1F43 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1F21 stack[-3] = stack[-1] / stack[-2] } // Block ends with conditional jump to 0x1f48, if !!!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) label_1F44: // Incoming jump from 0x1F43, if not !!!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) // Inputs[1] { @1F47 memory[0x00:0x00] } 1F44 60 PUSH1 0x00 1F46 80 DUP1 1F47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F47 revert(memory[0x00:0x00]); } // Block terminates label_1F48: // Incoming jump from 0x1F43, if !!!(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance < stack[-1] / stack[-2]) // Inputs[4] // { // @1F49 stack[-1] // @1F4A stack[-2] // @1F4D stack[-4] // @1F4E stack[-3] // } 1F48 5B JUMPDEST 1F49 80 DUP1 1F4A 91 SWAP2 1F4B 50 POP 1F4C 50 POP 1F4D 91 SWAP2 1F4E 90 SWAP1 1F4F 50 POP 1F50 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F4D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F51: // Incoming call from 0x08A3, returns to 0x08A4 // Inputs[1] { @1F5F msg.data.length } 1F51 5B JUMPDEST 1F52 60 PUSH1 0x00 1F54 60 PUSH1 0x03 1F56 60 PUSH1 0x04 1F58 60 PUSH1 0x20 1F5A 82 DUP3 1F5B 02 MUL 1F5C 01 ADD 1F5D 60 PUSH1 0x00 1F5F 36 CALLDATASIZE 1F60 90 SWAP1 1F61 50 POP 1F62 10 LT 1F63 15 ISZERO 1F64 15 ISZERO 1F65 15 ISZERO 1F66 61 PUSH2 0x1f6b 1F69 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F52 stack[0] = 0x00 // @1F54 stack[1] = 0x03 // } // Block ends with conditional jump to 0x1f6b, if !!!(msg.data.length < 0x03 * 0x20 + 0x04) label_1F6A: // Incoming jump from 0x1F69, if not !!!(msg.data.length < 0x03 * 0x20 + 0x04) 1F6A FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F6A assert(); } // Block terminates label_1F6B: // Incoming jump from 0x1F69, if !!!(msg.data.length < 0x03 * 0x20 + 0x04) // Inputs[6] // { // @1F6C stack[-4] // @1F71 msg.sender // @1FAB memory[0x00:0x40] // @1FAE stack[-5] // @1FE8 memory[0x00:0x40] // @1FE9 storage[keccak256(memory[0x00:0x40])] // } 1F6B 5B JUMPDEST 1F6C 83 DUP4 1F6D 60 PUSH1 0x05 1F6F 60 PUSH1 0x00 1F71 33 CALLER 1F72 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F87 16 AND 1F88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F9D 16 AND 1F9E 81 DUP2 1F9F 52 MSTORE 1FA0 60 PUSH1 0x20 1FA2 01 ADD 1FA3 90 SWAP1 1FA4 81 DUP2 1FA5 52 MSTORE 1FA6 60 PUSH1 0x20 1FA8 01 ADD 1FA9 60 PUSH1 0x00 1FAB 20 SHA3 1FAC 60 PUSH1 0x00 1FAE 87 DUP8 1FAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FC4 16 AND 1FC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FDA 16 AND 1FDB 81 DUP2 1FDC 52 MSTORE 1FDD 60 PUSH1 0x20 1FDF 01 ADD 1FE0 90 SWAP1 1FE1 81 DUP2 1FE2 52 MSTORE 1FE3 60 PUSH1 0x20 1FE5 01 ADD 1FE6 60 PUSH1 0x00 1FE8 20 SHA3 1FE9 54 SLOAD 1FEA 14 EQ 1FEB 15 ISZERO 1FEC 15 ISZERO 1FED 61 PUSH2 0x1ff5 1FF0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F9F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1FA5 memory[0x20:0x40] = 0x05 // @1FDC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1FE2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x1ff5, if !!(storage[keccak256(memory[0x00:0x40])] == stack[-4]) label_1FF1: // Incoming jump from 0x1FF0, if not !!(storage[keccak256(memory[0x00:0x40])] == stack[-4]) // Inputs[1] { @1FF4 memory[0x00:0x00] } 1FF1 60 PUSH1 0x00 1FF3 80 DUP1 1FF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FF4 revert(memory[0x00:0x00]); } // Block terminates label_1FF5: // Incoming jump from 0x1FF0, if !!(storage[keccak256(memory[0x00:0x40])] == stack[-4]) // Inputs[11] // { // @1FF6 stack[-3] // @1FFB msg.sender // @2035 memory[0x00:0x40] // @2038 stack[-5] // @2072 memory[0x00:0x40] // @208E msg.sender // @20C9 memory[0x40:0x60] // @20D6 memory[0x40:0x60] // @20DB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @20DE stack[-2] // @20E1 stack[-6] // } 1FF5 5B JUMPDEST 1FF6 82 DUP3 1FF7 60 PUSH1 0x05 1FF9 60 PUSH1 0x00 1FFB 33 CALLER 1FFC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2011 16 AND 2012 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2027 16 AND 2028 81 DUP2 2029 52 MSTORE 202A 60 PUSH1 0x20 202C 01 ADD 202D 90 SWAP1 202E 81 DUP2 202F 52 MSTORE 2030 60 PUSH1 0x20 2032 01 ADD 2033 60 PUSH1 0x00 2035 20 SHA3 2036 60 PUSH1 0x00 2038 87 DUP8 2039 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 204E 16 AND 204F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2064 16 AND 2065 81 DUP2 2066 52 MSTORE 2067 60 PUSH1 0x20 2069 01 ADD 206A 90 SWAP1 206B 81 DUP2 206C 52 MSTORE 206D 60 PUSH1 0x20 206F 01 ADD 2070 60 PUSH1 0x00 2072 20 SHA3 2073 81 DUP2 2074 90 SWAP1 2075 55 SSTORE 2076 50 POP 2077 84 DUP5 2078 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 208D 16 AND 208E 33 CALLER 208F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20A4 16 AND 20A5 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 20C6 85 DUP6 20C7 60 PUSH1 0x40 20C9 51 MLOAD 20CA 80 DUP1 20CB 82 DUP3 20CC 81 DUP2 20CD 52 MSTORE 20CE 60 PUSH1 0x20 20D0 01 ADD 20D1 91 SWAP2 20D2 50 POP 20D3 50 POP 20D4 60 PUSH1 0x40 20D6 51 MLOAD 20D7 80 DUP1 20D8 91 SWAP2 20D9 03 SUB 20DA 90 SWAP1 20DB A3 LOG3 20DC 60 PUSH1 0x01 20DE 91 SWAP2 20DF 50 POP 20E0 50 POP 20E1 93 SWAP4 20E2 92 SWAP3 20E3 50 POP 20E4 50 POP 20E5 50 POP 20E6 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @2029 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @202F memory[0x20:0x40] = 0x05 // @2066 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @206C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2075 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @20CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @20DB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // @20E1 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_20E7: // Incoming call from 0x08D0, returns to 0x08D1 20E7 5B JUMPDEST 20E8 61 PUSH2 0x20ef 20EB 61 PUSH2 0x3a80 20EE 56 *JUMP // Stack delta = +1 // Outputs[1] { @20E8 stack[0] = 0x20ef } // Block ends with call to 0x3a80, returns to 0x20EF label_20EF: // Incoming return from call to 0x3A80 at 0x20EE // Inputs[3] // { // @20F3 storage[0x01] // @2114 memory[0x40:0x60] // @2127 storage[0x01] // } 20EF 5B JUMPDEST 20F0 60 PUSH1 0x01 20F2 80 DUP1 20F3 54 SLOAD 20F4 60 PUSH1 0x01 20F6 81 DUP2 20F7 60 PUSH1 0x01 20F9 16 AND 20FA 15 ISZERO 20FB 61 PUSH2 0x0100 20FE 02 MUL 20FF 03 SUB 2100 16 AND 2101 60 PUSH1 0x02 2103 90 SWAP1 2104 04 DIV 2105 80 DUP1 2106 60 PUSH1 0x1f 2108 01 ADD 2109 60 PUSH1 0x20 210B 80 DUP1 210C 91 SWAP2 210D 04 DIV 210E 02 MUL 210F 60 PUSH1 0x20 2111 01 ADD 2112 60 PUSH1 0x40 2114 51 MLOAD 2115 90 SWAP1 2116 81 DUP2 2117 01 ADD 2118 60 PUSH1 0x40 211A 52 MSTORE 211B 80 DUP1 211C 92 SWAP3 211D 91 SWAP2 211E 90 SWAP1 211F 81 DUP2 2120 81 DUP2 2121 52 MSTORE 2122 60 PUSH1 0x20 2124 01 ADD 2125 82 DUP3 2126 80 DUP1 2127 54 SLOAD 2128 60 PUSH1 0x01 212A 81 DUP2 212B 60 PUSH1 0x01 212D 16 AND 212E 15 ISZERO 212F 61 PUSH2 0x0100 2132 02 MUL 2133 03 SUB 2134 16 AND 2135 60 PUSH1 0x02 2137 90 SWAP1 2138 04 DIV 2139 80 DUP1 213A 15 ISZERO 213B 61 PUSH2 0x2185 213E 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @211A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @211C stack[0] = memory[0x40:0x60] // @211D stack[1] = 0x01 // @211E stack[2] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @2121 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @2124 stack[3] = 0x20 + memory[0x40:0x60] // @2125 stack[4] = 0x01 // @2138 stack[5] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x2185, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_213F: // Incoming jump from 0x213E, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @213F stack[-1] } 213F 80 DUP1 2140 60 PUSH1 0x1f 2142 10 LT 2143 61 PUSH2 0x215a 2146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x215a, if 0x1f < stack[-1] label_2147: // Incoming jump from 0x2146, if not 0x1f < stack[-1] // Inputs[4] // { // @214B stack[-2] // @214C storage[stack[-2]] // @214F stack[-3] // @2151 stack[-1] // } 2147 61 PUSH2 0x0100 214A 80 DUP1 214B 83 DUP4 214C 54 SLOAD 214D 04 DIV 214E 02 MUL 214F 83 DUP4 2150 52 MSTORE 2151 91 SWAP2 2152 60 PUSH1 0x20 2154 01 ADD 2155 91 SWAP2 2156 61 PUSH2 0x2185 2159 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2150 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2155 stack[-1] = stack[-1] // @2155 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2185 label_215A: // Incoming jump from 0x2146, if 0x1f < stack[-1] // Inputs[5] // { // @215B stack[-3] // @215C stack[-1] // @215E stack[-2] // @2166 memory[0x00:0x20] // @216A storage[keccak256(memory[0x00:0x20])] // } 215A 5B JUMPDEST 215B 82 DUP3 215C 01 ADD 215D 91 SWAP2 215E 90 SWAP1 215F 60 PUSH1 0x00 2161 52 MSTORE 2162 60 PUSH1 0x20 2164 60 PUSH1 0x00 2166 20 SHA3 2167 90 SWAP1 2168 5B JUMPDEST 2169 81 DUP2 216A 54 SLOAD 216B 81 DUP2 216C 52 MSTORE 216D 90 SWAP1 216E 60 PUSH1 0x01 2170 01 ADD 2171 90 SWAP1 2172 60 PUSH1 0x20 2174 01 ADD 2175 80 DUP1 2176 83 DUP4 2177 11 GT 2178 61 PUSH2 0x2168 217B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @215D stack[-3] = stack[-3] + stack[-1] // @2161 memory[0x00:0x20] = stack[-2] // @216C memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2171 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2174 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2168, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_217C: // Incoming jump from 0x217B, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x217B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @217C stack[-3] // @217D stack[-1] // } 217C 82 DUP3 217D 90 SWAP1 217E 03 SUB 217F 60 PUSH1 0x1f 2181 16 AND 2182 82 DUP3 2183 01 ADD 2184 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2184 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2184 stack[-1] = stack[-3] // } // Block continues label_2185: // Incoming jump from 0x2159 // Incoming jump from 0x2184 // Incoming jump from 0x213E, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[3] // { // @218B stack[-7] // @218B stack[-6] // @218D stack[-8] // } 2185 5B JUMPDEST 2186 50 POP 2187 50 POP 2188 50 POP 2189 50 POP 218A 50 POP 218B 90 SWAP1 218C 50 POP 218D 90 SWAP1 218E 56 *JUMP // Stack delta = -7 // Outputs[1] { @218D stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_218F: // Incoming call from 0x0982, returns to 0x0983 // Inputs[4] // { // @2195 stack[-1] // @219D memory[0x00:0x40] // @21A2 storage[keccak256(memory[0x00:0x40])] // @21AD stack[-2] // } 218F 5B JUMPDEST 2190 60 PUSH1 0x10 2192 60 PUSH1 0x20 2194 52 MSTORE 2195 80 DUP1 2196 60 PUSH1 0x00 2198 52 MSTORE 2199 60 PUSH1 0x40 219B 60 PUSH1 0x00 219D 20 SHA3 219E 60 PUSH1 0x00 21A0 91 SWAP2 21A1 50 POP 21A2 54 SLOAD 21A3 90 SWAP1 21A4 61 PUSH2 0x0100 21A7 0A EXP 21A8 90 SWAP1 21A9 04 DIV 21AA 60 PUSH1 0xff 21AC 16 AND 21AD 81 DUP2 21AE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2194 memory[0x20:0x40] = 0x10 // @2198 memory[0x00:0x20] = stack[-1] // @21AC stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_21AF: // Incoming call from 0x09BD, returns to 0x09BE // Inputs[2] // { // @21B5 storage[0x0e] // @21E9 msg.sender // } 21AF 5B JUMPDEST 21B0 60 PUSH1 0x0e 21B2 60 PUSH1 0x00 21B4 90 SWAP1 21B5 54 SLOAD 21B6 90 SWAP1 21B7 61 PUSH2 0x0100 21BA 0A EXP 21BB 90 SWAP1 21BC 04 DIV 21BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21D2 16 AND 21D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21E8 16 AND 21E9 33 CALLER 21EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21FF 16 AND 2200 14 EQ 2201 80 DUP1 2202 61 PUSH2 0x2258 2205 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2200 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x2258, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 label_2206: // Incoming jump from 0x2205, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // Inputs[2] // { // @220C storage[0x0d] // @2240 msg.sender // } 2206 50 POP 2207 60 PUSH1 0x0d 2209 60 PUSH1 0x00 220B 90 SWAP1 220C 54 SLOAD 220D 90 SWAP1 220E 61 PUSH2 0x0100 2211 0A EXP 2212 90 SWAP1 2213 04 DIV 2214 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2229 16 AND 222A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 223F 16 AND 2240 33 CALLER 2241 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2256 16 AND 2257 14 EQ 2258 5B JUMPDEST 2259 15 ISZERO 225A 15 ISZERO 225B 61 PUSH2 0x2263 225E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2263, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_225F: // Incoming jump from 0x225E, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x225E, if not !!stack[-1] // Inputs[1] { @2262 memory[0x00:0x00] } 225F 60 PUSH1 0x00 2261 80 DUP1 2262 FD *REVERT // Stack delta = +0 // Outputs[1] { @2262 revert(memory[0x00:0x00]); } // Block terminates label_2263: // Incoming jump from 0x225E, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x225E, if !!stack[-1] // Inputs[3] // { // @2264 address(this) // @227B address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance // @227C stack[-1] // } 2263 5B JUMPDEST 2264 30 ADDRESS 2265 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 227A 16 AND 227B 31 BALANCE 227C 81 DUP2 227D 11 GT 227E 15 ISZERO 227F 15 ISZERO 2280 15 ISZERO 2281 61 PUSH2 0x2289 2284 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2289, if !!!(stack[-1] > address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance) label_2285: // Incoming jump from 0x2284, if not !!!(stack[-1] > address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance) // Inputs[1] { @2288 memory[0x00:0x00] } 2285 60 PUSH1 0x00 2287 80 DUP1 2288 FD *REVERT // Stack delta = +0 // Outputs[1] { @2288 revert(memory[0x00:0x00]); } // Block terminates label_2289: // Incoming jump from 0x2284, if !!!(stack[-1] > address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance) // Inputs[6] // { // @228F storage[0x0d] // @22C6 stack[-1] // @22CE memory[0x40:0x60] // @22D3 memory[0x40:0x60] // @22DB address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @22DB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 2289 5B JUMPDEST 228A 60 PUSH1 0x0d 228C 60 PUSH1 0x00 228E 90 SWAP1 228F 54 SLOAD 2290 90 SWAP1 2291 61 PUSH2 0x0100 2294 0A EXP 2295 90 SWAP1 2296 04 DIV 2297 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22AC 16 AND 22AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22C2 16 AND 22C3 61 PUSH2 0x08fc 22C6 82 DUP3 22C7 90 SWAP1 22C8 81 DUP2 22C9 15 ISZERO 22CA 02 MUL 22CB 90 SWAP1 22CC 60 PUSH1 0x40 22CE 51 MLOAD 22CF 60 PUSH1 0x00 22D1 60 PUSH1 0x40 22D3 51 MLOAD 22D4 80 DUP1 22D5 83 DUP4 22D6 03 SUB 22D7 81 DUP2 22D8 85 DUP6 22D9 88 DUP9 22DA 88 DUP9 22DB F1 CALL 22DC 93 SWAP4 22DD 50 POP 22DE 50 POP 22DF 50 POP 22E0 50 POP 22E1 15 ISZERO 22E2 15 ISZERO 22E3 61 PUSH2 0x22eb 22E6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) } // Block ends with conditional jump to 0x22eb, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_22E7: // Incoming jump from 0x22E6, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @22EA memory[0x00:0x00] } 22E7 60 PUSH1 0x00 22E9 80 DUP1 22EA FD *REVERT // Stack delta = +0 // Outputs[1] { @22EA revert(memory[0x00:0x00]); } // Block terminates label_22EB: // Incoming jump from 0x22E6, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[5] // { // @230D stack[-1] // @2310 memory[0x40:0x60] // @231D memory[0x40:0x60] // @2322 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2324 stack[-2] // } 22EB 5B JUMPDEST 22EC 7F PUSH32 0x0a2ac2d0ff5dd766a6215edf0289e7aedf3647514518fb2694c0c0584902e7cc 230D 81 DUP2 230E 60 PUSH1 0x40 2310 51 MLOAD 2311 80 DUP1 2312 82 DUP3 2313 81 DUP2 2314 52 MSTORE 2315 60 PUSH1 0x20 2317 01 ADD 2318 91 SWAP2 2319 50 POP 231A 50 POP 231B 60 PUSH1 0x40 231D 51 MLOAD 231E 80 DUP1 231F 91 SWAP2 2320 03 SUB 2321 90 SWAP1 2322 A1 LOG1 2323 50 POP 2324 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2314 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2322 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x0a2ac2d0ff5dd766a6215edf0289e7aedf3647514518fb2694c0c0584902e7cc]); // } // Block ends with unconditional jump to stack[-2] label_2325: // Incoming call from 0x09D2, returns to 0x09D3 // Inputs[3] // { // @232C storage[0x11] // @2332 storage[0x12] // @2335 stack[-1] // } 2325 5B JUMPDEST 2326 60 PUSH1 0x11 2328 80 DUP1 2329 60 PUSH1 0x00 232B 01 ADD 232C 54 SLOAD 232D 90 SWAP1 232E 80 DUP1 232F 60 PUSH1 0x01 2331 01 ADD 2332 54 SLOAD 2333 90 SWAP1 2334 50 POP 2335 82 DUP3 2336 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @232D stack[0] = storage[0x11] // @2333 stack[1] = storage[0x12] // } // Block ends with unconditional jump to stack[-1] label_2337: // Incoming call from 0x0A10, returns to 0x0A11 // Inputs[1] { @233F storage[0x08] } 2337 5B JUMPDEST 2338 60 PUSH1 0x00 233A 60 PUSH1 0x08 233C 60 PUSH1 0x01 233E 90 SWAP1 233F 54 SLOAD 2340 90 SWAP1 2341 61 PUSH2 0x0100 2344 0A EXP 2345 90 SWAP1 2346 04 DIV 2347 60 PUSH1 0xff 2349 16 AND 234A 80 DUP1 234B 61 PUSH2 0x23a1 234E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2338 stack[0] = 0x00 // @2349 stack[1] = 0xff & storage[0x08] / 0x0100 ** 0x01 // } // Block ends with conditional jump to 0x23a1, if 0xff & storage[0x08] / 0x0100 ** 0x01 label_234F: // Incoming jump from 0x234E, if not 0xff & storage[0x08] / 0x0100 ** 0x01 // Inputs[2] // { // @2355 storage[0x0d] // @2389 msg.sender // } 234F 50 POP 2350 60 PUSH1 0x0d 2352 60 PUSH1 0x00 2354 90 SWAP1 2355 54 SLOAD 2356 90 SWAP1 2357 61 PUSH2 0x0100 235A 0A EXP 235B 90 SWAP1 235C 04 DIV 235D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2372 16 AND 2373 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2388 16 AND 2389 33 CALLER 238A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 239F 16 AND 23A0 14 EQ 23A1 5B JUMPDEST 23A2 80 DUP1 23A3 61 PUSH2 0x23f9 23A6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @23A0 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x23f9, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 label_23A7: // Incoming jump from 0x23A6, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // Incoming jump from 0x23A6, if not stack[-1] // Inputs[2] // { // @23AD storage[0x0f] // @23E1 msg.sender // } 23A7 50 POP 23A8 60 PUSH1 0x0f 23AA 60 PUSH1 0x00 23AC 90 SWAP1 23AD 54 SLOAD 23AE 90 SWAP1 23AF 61 PUSH2 0x0100 23B2 0A EXP 23B3 90 SWAP1 23B4 04 DIV 23B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23CA 16 AND 23CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23E0 16 AND 23E1 33 CALLER 23E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23F7 16 AND 23F8 14 EQ 23F9 5B JUMPDEST 23FA 15 ISZERO 23FB 15 ISZERO 23FC 61 PUSH2 0x2404 23FF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2404, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) label_2400: // Incoming jump from 0x23FF, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Incoming jump from 0x23FF, if not !!stack[-1] // Inputs[1] { @2403 memory[0x00:0x00] } 2400 60 PUSH1 0x00 2402 80 DUP1 2403 FD *REVERT // Stack delta = +0 // Outputs[1] { @2403 revert(memory[0x00:0x00]); } // Block terminates label_2404: // Incoming jump from 0x23FF, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Incoming jump from 0x23FF, if !!stack[-1] // Inputs[3] // { // @2409 msg.sender // @2443 memory[0x00:0x40] // @2447 storage[keccak256(memory[0x00:0x40])] // } 2404 5B JUMPDEST 2405 60 PUSH1 0x10 2407 60 PUSH1 0x00 2409 33 CALLER 240A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 241F 16 AND 2420 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2435 16 AND 2436 81 DUP2 2437 52 MSTORE 2438 60 PUSH1 0x20 243A 01 ADD 243B 90 SWAP1 243C 81 DUP2 243D 52 MSTORE 243E 60 PUSH1 0x20 2440 01 ADD 2441 60 PUSH1 0x00 2443 20 SHA3 2444 60 PUSH1 0x00 2446 90 SWAP1 2447 54 SLOAD 2448 90 SWAP1 2449 61 PUSH2 0x0100 244C 0A EXP 244D 90 SWAP1 244E 04 DIV 244F 60 PUSH1 0xff 2451 16 AND 2452 15 ISZERO 2453 15 ISZERO 2454 61 PUSH2 0x245c 2457 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2437 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @243D memory[0x20:0x40] = 0x10 // } // Block ends with conditional jump to 0x245c, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_2458: // Incoming jump from 0x2457, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @245B memory[0x00:0x00] } 2458 60 PUSH1 0x00 245A 80 DUP1 245B FD *REVERT // Stack delta = +0 // Outputs[1] { @245B revert(memory[0x00:0x00]); } // Block terminates label_245C: // Incoming jump from 0x2457, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[2] // { // @245F storage[0x0a] // @2460 block.number // } 245C 5B JUMPDEST 245D 60 PUSH1 0x0a 245F 54 SLOAD 2460 43 NUMBER 2461 11 GT 2462 15 ISZERO 2463 15 ISZERO 2464 61 PUSH2 0x246c 2467 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x246c, if !!(block.number > storage[0x0a]) label_2468: // Incoming jump from 0x2467, if not !!(block.number > storage[0x0a]) // Inputs[1] { @246B memory[0x00:0x00] } 2468 60 PUSH1 0x00 246A 80 DUP1 246B FD *REVERT // Stack delta = +0 // Outputs[1] { @246B revert(memory[0x00:0x00]); } // Block terminates label_246C: // Incoming jump from 0x2467, if !!(block.number > storage[0x0a]) // Inputs[1] { @246F stack[-2] } 246C 5B JUMPDEST 246D 60 PUSH1 0x00 246F 82 DUP3 2470 11 GT 2471 15 ISZERO 2472 15 ISZERO 2473 61 PUSH2 0x247b 2476 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x247b, if !!(stack[-2] > 0x00) label_2477: // Incoming jump from 0x2476, if not !!(stack[-2] > 0x00) // Inputs[1] { @247A memory[0x00:0x00] } 2477 60 PUSH1 0x00 2479 80 DUP1 247A FD *REVERT // Stack delta = +0 // Outputs[1] { @247A revert(memory[0x00:0x00]); } // Block terminates label_247B: // Incoming jump from 0x2476, if !!(stack[-2] > 0x00) // Inputs[3] // { // @247C msg.sender // @247D stack[-1] // @247F stack[-2] // } 247B 5B JUMPDEST 247C 33 CALLER 247D 90 SWAP1 247E 50 POP 247F 81 DUP2 2480 61 PUSH2 0x2488 2483 82 DUP3 2484 61 PUSH2 0x1aa9 2487 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @247D stack[-1] = msg.sender // @247F stack[0] = stack[-2] // @2480 stack[1] = 0x2488 // @2483 stack[2] = msg.sender // } // Block ends with call to 0x1aa9, returns to 0x2488 label_2488: // Incoming return from call to 0x1AA9 at 0x2487 // Inputs[2] // { // @2489 stack[-2] // @2489 stack[-1] // } 2488 5B JUMPDEST 2489 10 LT 248A 15 ISZERO 248B 15 ISZERO 248C 15 ISZERO 248D 61 PUSH2 0x2495 2490 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2495, if !!!(stack[-1] < stack[-2]) label_2491: // Incoming jump from 0x2490, if not !!!(stack[-1] < stack[-2]) // Inputs[1] { @2494 memory[0x00:0x00] } 2491 60 PUSH1 0x00 2493 80 DUP1 2494 FD *REVERT // Stack delta = +0 // Outputs[1] { @2494 revert(memory[0x00:0x00]); } // Block terminates label_2495: // Incoming jump from 0x2490, if !!!(stack[-1] < stack[-2]) // Inputs[3] // { // @249C stack[-1] // @24D6 memory[0x00:0x40] // @24DA storage[0x00 + keccak256(memory[0x00:0x40])] // } 2495 5B JUMPDEST 2496 60 PUSH1 0x00 2498 60 PUSH1 0x16 249A 60 PUSH1 0x00 249C 83 DUP4 249D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24B2 16 AND 24B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24C8 16 AND 24C9 81 DUP2 24CA 52 MSTORE 24CB 60 PUSH1 0x20 24CD 01 ADD 24CE 90 SWAP1 24CF 81 DUP2 24D0 52 MSTORE 24D1 60 PUSH1 0x20 24D3 01 ADD 24D4 60 PUSH1 0x00 24D6 20 SHA3 24D7 60 PUSH1 0x00 24D9 01 ADD 24DA 54 SLOAD 24DB 14 EQ 24DC 15 ISZERO 24DD 15 ISZERO 24DE 61 PUSH2 0x24e6 24E1 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @24CA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @24D0 memory[0x20:0x40] = 0x16 // } // Block ends with conditional jump to 0x24e6, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) label_24E2: // Incoming jump from 0x24E1, if not !!(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @24E5 memory[0x00:0x00] } 24E2 60 PUSH1 0x00 24E4 80 DUP1 24E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @24E5 revert(memory[0x00:0x00]); } // Block terminates label_24E6: // Incoming jump from 0x24E1, if !!(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @24ED stack[-1] } 24E6 5B JUMPDEST 24E7 61 PUSH2 0x24f8 24EA 61 PUSH2 0x24f2 24ED 82 DUP3 24EE 61 PUSH2 0x1aa9 24F1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24E7 stack[0] = 0x24f8 // @24EA stack[1] = 0x24f2 // @24ED stack[2] = stack[-1] // } // Block ends with call to 0x1aa9, returns to 0x24F2 label_24F2: // Incoming return from call to 0x1AA9 at 0x24F1 // Inputs[1] { @24F3 stack[-4] } 24F2 5B JUMPDEST 24F3 83 DUP4 24F4 61 PUSH2 0x337e 24F7 56 *JUMP // Stack delta = +1 // Outputs[1] { @24F3 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x337e label_24F8: // Incoming return from call to 0x24F2 at 0x24F1 // Inputs[13] // { // @24FD stack[-2] // @2537 memory[0x00:0x40] // @2538 stack[-1] // @253F memory[0x40:0x60] // @2547 stack[-3] // @254F storage[0x15] // @2591 memory[0x00:0x40] // @2596 memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @25A0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @25E4 memory[0x40:0x60] // @25F1 memory[0x40:0x60] // @25F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @25F9 stack[-4] // } 24F8 5B JUMPDEST 24F9 60 PUSH1 0x04 24FB 60 PUSH1 0x00 24FD 83 DUP4 24FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2513 16 AND 2514 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2529 16 AND 252A 81 DUP2 252B 52 MSTORE 252C 60 PUSH1 0x20 252E 01 ADD 252F 90 SWAP1 2530 81 DUP2 2531 52 MSTORE 2532 60 PUSH1 0x20 2534 01 ADD 2535 60 PUSH1 0x00 2537 20 SHA3 2538 81 DUP2 2539 90 SWAP1 253A 55 SSTORE 253B 50 POP 253C 60 PUSH1 0x40 253E 80 DUP1 253F 51 MLOAD 2540 90 SWAP1 2541 81 DUP2 2542 01 ADD 2543 60 PUSH1 0x40 2545 52 MSTORE 2546 80 DUP1 2547 83 DUP4 2548 81 DUP2 2549 52 MSTORE 254A 60 PUSH1 0x20 254C 01 ADD 254D 60 PUSH1 0x15 254F 54 SLOAD 2550 81 DUP2 2551 52 MSTORE 2552 50 POP 2553 60 PUSH1 0x16 2555 60 PUSH1 0x00 2557 83 DUP4 2558 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 256D 16 AND 256E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2583 16 AND 2584 81 DUP2 2585 52 MSTORE 2586 60 PUSH1 0x20 2588 01 ADD 2589 90 SWAP1 258A 81 DUP2 258B 52 MSTORE 258C 60 PUSH1 0x20 258E 01 ADD 258F 60 PUSH1 0x00 2591 20 SHA3 2592 60 PUSH1 0x00 2594 82 DUP3 2595 01 ADD 2596 51 MLOAD 2597 81 DUP2 2598 60 PUSH1 0x00 259A 01 ADD 259B 55 SSTORE 259C 60 PUSH1 0x20 259E 82 DUP3 259F 01 ADD 25A0 51 MLOAD 25A1 81 DUP2 25A2 60 PUSH1 0x01 25A4 01 ADD 25A5 55 SSTORE 25A6 90 SWAP1 25A7 50 POP 25A8 50 POP 25A9 80 DUP1 25AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25BF 16 AND 25C0 7F PUSH32 0xe670e4e82118d22a1f9ee18920455ebc958bae26a90a05d31d3378788b1b0e44 25E1 83 DUP4 25E2 60 PUSH1 0x40 25E4 51 MLOAD 25E5 80 DUP1 25E6 82 DUP3 25E7 81 DUP2 25E8 52 MSTORE 25E9 60 PUSH1 0x20 25EB 01 ADD 25EC 91 SWAP2 25ED 50 POP 25EE 50 POP 25EF 60 PUSH1 0x40 25F1 51 MLOAD 25F2 80 DUP1 25F3 91 SWAP2 25F4 03 SUB 25F5 90 SWAP1 25F6 A2 LOG2 25F7 50 POP 25F8 50 POP 25F9 56 *JUMP // Stack delta = -4 // Outputs[12] // { // @252B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2531 memory[0x20:0x40] = 0x04 // @253A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2545 memory[0x40:0x60] = memory[0x40:0x60] + 0x40 // @2549 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @2551 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = storage[0x15] // @2585 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @258B memory[0x20:0x40] = 0x16 // @259B storage[0x00 + keccak256(memory[0x00:0x40])] = memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @25A5 storage[0x01 + keccak256(memory[0x00:0x40])] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @25E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @25F6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xe670e4e82118d22a1f9ee18920455ebc958bae26a90a05d31d3378788b1b0e44, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_25FA: // Incoming call from 0x0A25, returns to 0x0A26 // Inputs[2] // { // @2600 storage[0x0d] // @2634 msg.sender // } 25FA 5B JUMPDEST 25FB 60 PUSH1 0x0d 25FD 60 PUSH1 0x00 25FF 90 SWAP1 2600 54 SLOAD 2601 90 SWAP1 2602 61 PUSH2 0x0100 2605 0A EXP 2606 90 SWAP1 2607 04 DIV 2608 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 261D 16 AND 261E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2633 16 AND 2634 33 CALLER 2635 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 264A 16 AND 264B 14 EQ 264C 15 ISZERO 264D 15 ISZERO 264E 61 PUSH2 0x2656 2651 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2656, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2652: // Incoming jump from 0x2651, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2655 memory[0x00:0x00] } 2652 60 PUSH1 0x00 2654 80 DUP1 2655 FD *REVERT // Stack delta = +0 // Outputs[1] { @2655 revert(memory[0x00:0x00]); } // Block terminates label_2656: // Incoming jump from 0x2651, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @2662 storage[0x08] // @2672 stack[-1] // } 2656 5B JUMPDEST 2657 60 PUSH1 0x01 2659 60 PUSH1 0x08 265B 60 PUSH1 0x00 265D 61 PUSH2 0x0100 2660 0A EXP 2661 81 DUP2 2662 54 SLOAD 2663 81 DUP2 2664 60 PUSH1 0xff 2666 02 MUL 2667 19 NOT 2668 16 AND 2669 90 SWAP1 266A 83 DUP4 266B 15 ISZERO 266C 15 ISZERO 266D 02 MUL 266E 17 OR 266F 90 SWAP1 2670 55 SSTORE 2671 50 POP 2672 56 *JUMP // Stack delta = -1 // Outputs[1] { @2670 storage[0x08] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x08]) } // Block ends with unconditional jump to stack[-1] label_2673: // Incoming call from 0x0A67, returns to 0x0A68 // Inputs[1] { @267B storage[0x08] } 2673 5B JUMPDEST 2674 60 PUSH1 0x00 2676 60 PUSH1 0x08 2678 60 PUSH1 0x01 267A 90 SWAP1 267B 54 SLOAD 267C 90 SWAP1 267D 61 PUSH2 0x0100 2680 0A EXP 2681 90 SWAP1 2682 04 DIV 2683 60 PUSH1 0xff 2685 16 AND 2686 80 DUP1 2687 61 PUSH2 0x26dd 268A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2674 stack[0] = 0x00 // @2685 stack[1] = 0xff & storage[0x08] / 0x0100 ** 0x01 // } // Block ends with conditional jump to 0x26dd, if 0xff & storage[0x08] / 0x0100 ** 0x01 label_268B: // Incoming jump from 0x268A, if not 0xff & storage[0x08] / 0x0100 ** 0x01 // Inputs[2] // { // @2691 storage[0x0d] // @26C5 msg.sender // } 268B 50 POP 268C 60 PUSH1 0x0d 268E 60 PUSH1 0x00 2690 90 SWAP1 2691 54 SLOAD 2692 90 SWAP1 2693 61 PUSH2 0x0100 2696 0A EXP 2697 90 SWAP1 2698 04 DIV 2699 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26AE 16 AND 26AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26C4 16 AND 26C5 33 CALLER 26C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26DB 16 AND 26DC 14 EQ 26DD 5B JUMPDEST 26DE 80 DUP1 26DF 61 PUSH2 0x2735 26E2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26DC stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x2735, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 label_26E3: // Incoming jump from 0x26E2, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // Incoming jump from 0x26E2, if not stack[-1] // Inputs[2] // { // @26E9 storage[0x0f] // @271D msg.sender // } 26E3 50 POP 26E4 60 PUSH1 0x0f 26E6 60 PUSH1 0x00 26E8 90 SWAP1 26E9 54 SLOAD 26EA 90 SWAP1 26EB 61 PUSH2 0x0100 26EE 0A EXP 26EF 90 SWAP1 26F0 04 DIV 26F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2706 16 AND 2707 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 271C 16 AND 271D 33 CALLER 271E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2733 16 AND 2734 14 EQ 2735 5B JUMPDEST 2736 15 ISZERO 2737 15 ISZERO 2738 61 PUSH2 0x2740 273B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2740, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) label_273C: // Incoming jump from 0x273B, if not !!stack[-1] // Incoming jump from 0x273B, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[1] { @273F memory[0x00:0x00] } 273C 60 PUSH1 0x00 273E 80 DUP1 273F FD *REVERT // Stack delta = +0 // Outputs[1] { @273F revert(memory[0x00:0x00]); } // Block terminates label_2740: // Incoming jump from 0x273B, if !!stack[-1] // Incoming jump from 0x273B, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00) // Inputs[2] // { // @2744 stack[-3] // @2745 stack[-2] // } 2740 5B JUMPDEST 2741 61 PUSH2 0x274a 2744 83 DUP4 2745 83 DUP4 2746 61 PUSH2 0x3848 2749 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2741 stack[0] = 0x274a // @2744 stack[1] = stack[-3] // @2745 stack[2] = stack[-2] // } // Block ends with call to 0x3848, returns to 0x274A label_274A: // Incoming return from call to 0x3848 at 0x2749 // Inputs[4] // { // @274B stack[-2] // @274B stack[-1] // @274D stack[-5] // @274E stack[-4] // } 274A 5B JUMPDEST 274B 90 SWAP1 274C 50 POP 274D 92 SWAP3 274E 91 SWAP2 274F 50 POP 2750 50 POP 2751 56 *JUMP // Stack delta = -4 // Outputs[1] { @274D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2752: // Incoming call from 0x0A94, returns to 0x0A95 // Inputs[2] // { // @2755 storage[0x15] // @2756 stack[-1] // } 2752 5B JUMPDEST 2753 60 PUSH1 0x15 2755 54 SLOAD 2756 81 DUP2 2757 56 *JUMP // Stack delta = +1 // Outputs[1] { @2755 stack[0] = storage[0x15] } // Block ends with unconditional jump to stack[-1] label_2758: // Incoming call from 0x0ACB, returns to 0x0ACC // Inputs[5] // { // @275E stack[-1] // @2766 memory[0x00:0x40] // @2771 storage[0x00 + keccak256(memory[0x00:0x40])] // @2777 storage[0x01 + keccak256(memory[0x00:0x40])] // @277A stack[-2] // } 2758 5B JUMPDEST 2759 60 PUSH1 0x14 275B 60 PUSH1 0x20 275D 52 MSTORE 275E 80 DUP1 275F 60 PUSH1 0x00 2761 52 MSTORE 2762 60 PUSH1 0x40 2764 60 PUSH1 0x00 2766 20 SHA3 2767 60 PUSH1 0x00 2769 91 SWAP2 276A 50 POP 276B 90 SWAP1 276C 50 POP 276D 80 DUP1 276E 60 PUSH1 0x00 2770 01 ADD 2771 54 SLOAD 2772 90 SWAP1 2773 80 DUP1 2774 60 PUSH1 0x01 2776 01 ADD 2777 54 SLOAD 2778 90 SWAP1 2779 50 POP 277A 82 DUP3 277B 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @275D memory[0x20:0x40] = 0x14 // @2761 memory[0x00:0x20] = stack[-1] // @2772 stack[-1] = storage[0x00 + keccak256(memory[0x00:0x40])] // @2778 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_277C: // Incoming call from 0x0B28, returns to 0x0B29 // Inputs[2] // { // @2782 storage[0x0d] // @27B6 msg.sender // } 277C 5B JUMPDEST 277D 60 PUSH1 0x0d 277F 60 PUSH1 0x00 2781 90 SWAP1 2782 54 SLOAD 2783 90 SWAP1 2784 61 PUSH2 0x0100 2787 0A EXP 2788 90 SWAP1 2789 04 DIV 278A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 279F 16 AND 27A0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B5 16 AND 27B6 33 CALLER 27B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27CC 16 AND 27CD 14 EQ 27CE 15 ISZERO 27CF 15 ISZERO 27D0 61 PUSH2 0x27d8 27D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27d8, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_27D4: // Incoming jump from 0x27D3, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @27D7 memory[0x00:0x00] } 27D4 60 PUSH1 0x00 27D6 80 DUP1 27D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D7 revert(memory[0x00:0x00]); } // Block terminates label_27D8: // Incoming jump from 0x27D3, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @27DB storage[0x0a] // @27DC block.number // } 27D8 5B JUMPDEST 27D9 60 PUSH1 0x0a 27DB 54 SLOAD 27DC 43 NUMBER 27DD 10 LT 27DE 15 ISZERO 27DF 15 ISZERO 27E0 61 PUSH2 0x27e8 27E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27e8, if !!(block.number < storage[0x0a]) label_27E4: // Incoming jump from 0x27E3, if not !!(block.number < storage[0x0a]) // Inputs[1] { @27E7 memory[0x00:0x00] } 27E4 60 PUSH1 0x00 27E6 80 DUP1 27E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @27E7 revert(memory[0x00:0x00]); } // Block terminates label_27E8: // Incoming jump from 0x27E3, if !!(block.number < storage[0x0a]) // Inputs[1] { @2801 stack[-2] } 27E8 5B JUMPDEST 27E9 60 PUSH1 0x00 27EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2800 16 AND 2801 82 DUP3 2802 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2817 16 AND 2818 14 EQ 2819 15 ISZERO 281A 15 ISZERO 281B 15 ISZERO 281C 61 PUSH2 0x2824 281F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2824, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2820: // Incoming jump from 0x281F, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2823 memory[0x00:0x00] } 2820 60 PUSH1 0x00 2822 80 DUP1 2823 FD *REVERT // Stack delta = +0 // Outputs[1] { @2823 revert(memory[0x00:0x00]); } // Block terminates label_2824: // Incoming jump from 0x281F, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @282B stack[-2] // @2865 memory[0x00:0x40] // @286D storage[keccak256(memory[0x00:0x40])] // @2881 stack[-1] // } 2824 5B JUMPDEST 2825 60 PUSH1 0x01 2827 60 PUSH1 0x10 2829 60 PUSH1 0x00 282B 84 DUP5 282C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2841 16 AND 2842 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2857 16 AND 2858 81 DUP2 2859 52 MSTORE 285A 60 PUSH1 0x20 285C 01 ADD 285D 90 SWAP1 285E 81 DUP2 285F 52 MSTORE 2860 60 PUSH1 0x20 2862 01 ADD 2863 60 PUSH1 0x00 2865 20 SHA3 2866 60 PUSH1 0x00 2868 61 PUSH2 0x0100 286B 0A EXP 286C 81 DUP2 286D 54 SLOAD 286E 81 DUP2 286F 60 PUSH1 0xff 2871 02 MUL 2872 19 NOT 2873 16 AND 2874 90 SWAP1 2875 83 DUP4 2876 15 ISZERO 2877 15 ISZERO 2878 02 MUL 2879 17 OR 287A 90 SWAP1 287B 55 SSTORE 287C 50 POP 287D 61 PUSH2 0x2886 2880 82 DUP3 2881 82 DUP3 2882 61 PUSH2 0x30c7 2885 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @2859 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @285F memory[0x20:0x40] = 0x10 // @287B storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @287D stack[0] = 0x2886 // @2880 stack[1] = stack[-2] // @2881 stack[2] = stack[-1] // } // Block ends with call to 0x30c7, returns to 0x2886 label_2886: // Incoming return from call to 0x30C7 at 0x2885 // Inputs[9] // { // @2887 stack[-2] // @28C1 memory[0x40:0x60] // @28C4 memory[0x40:0x60] // @28C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2902 stack[-1] // @2905 memory[0x40:0x60] // @2912 memory[0x40:0x60] // @2917 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @291A stack[-3] // } 2886 5B JUMPDEST 2887 81 DUP2 2888 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 289D 16 AND 289E 7F PUSH32 0xaab7954e9d246b167ef88aeddad35209ca2489d95a8aeb59e288d9b19fae5a54 28BF 60 PUSH1 0x40 28C1 51 MLOAD 28C2 60 PUSH1 0x40 28C4 51 MLOAD 28C5 80 DUP1 28C6 91 SWAP2 28C7 03 SUB 28C8 90 SWAP1 28C9 A2 LOG2 28CA 81 DUP2 28CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28E0 16 AND 28E1 7F PUSH32 0x85a190caa61692b36b63a55e069330d18ab9af179fed7a25c16a4262bc63b7d2 2902 82 DUP3 2903 60 PUSH1 0x40 2905 51 MLOAD 2906 80 DUP1 2907 82 DUP3 2908 81 DUP2 2909 52 MSTORE 290A 60 PUSH1 0x20 290C 01 ADD 290D 91 SWAP2 290E 50 POP 290F 50 POP 2910 60 PUSH1 0x40 2912 51 MLOAD 2913 80 DUP1 2914 91 SWAP2 2915 03 SUB 2916 90 SWAP1 2917 A2 LOG2 2918 50 POP 2919 50 POP 291A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @28C9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xaab7954e9d246b167ef88aeddad35209ca2489d95a8aeb59e288d9b19fae5a54, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @2909 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2917 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x85a190caa61692b36b63a55e069330d18ab9af179fed7a25c16a4262bc63b7d2, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_291B: // Incoming call from 0x0B61, returns to 0x0B62 // Inputs[2] // { // @2921 storage[0x0d] // @2955 msg.sender // } 291B 5B JUMPDEST 291C 60 PUSH1 0x0d 291E 60 PUSH1 0x00 2920 90 SWAP1 2921 54 SLOAD 2922 90 SWAP1 2923 61 PUSH2 0x0100 2926 0A EXP 2927 90 SWAP1 2928 04 DIV 2929 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 293E 16 AND 293F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2954 16 AND 2955 33 CALLER 2956 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 296B 16 AND 296C 14 EQ 296D 15 ISZERO 296E 15 ISZERO 296F 61 PUSH2 0x2977 2972 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2977, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2973: // Incoming jump from 0x2972, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2976 memory[0x00:0x00] } 2973 60 PUSH1 0x00 2975 80 DUP1 2976 FD *REVERT // Stack delta = +0 // Outputs[1] { @2976 revert(memory[0x00:0x00]); } // Block terminates label_2977: // Incoming jump from 0x2972, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2990 stack[-1] } 2977 5B JUMPDEST 2978 60 PUSH1 0x00 297A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 298F 16 AND 2990 81 DUP2 2991 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29A6 16 AND 29A7 14 EQ 29A8 15 ISZERO 29A9 15 ISZERO 29AA 15 ISZERO 29AB 61 PUSH2 0x29b3 29AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x29b3, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_29AF: // Incoming jump from 0x29AE, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @29B2 memory[0x00:0x00] } 29AF 60 PUSH1 0x00 29B1 80 DUP1 29B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @29B2 revert(memory[0x00:0x00]); } // Block terminates label_29B3: // Incoming jump from 0x29AE, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @29B4 stack[-1] // @29BE storage[0x0e] // @29F6 stack[-2] // } 29B3 5B JUMPDEST 29B4 80 DUP1 29B5 60 PUSH1 0x0e 29B7 60 PUSH1 0x00 29B9 61 PUSH2 0x0100 29BC 0A EXP 29BD 81 DUP2 29BE 54 SLOAD 29BF 81 DUP2 29C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29D5 02 MUL 29D6 19 NOT 29D7 16 AND 29D8 90 SWAP1 29D9 83 DUP4 29DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29EF 16 AND 29F0 02 MUL 29F1 17 OR 29F2 90 SWAP1 29F3 55 SSTORE 29F4 50 POP 29F5 50 POP 29F6 56 *JUMP // Stack delta = -2 // Outputs[1] { @29F3 storage[0x0e] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0e]) } // Block ends with unconditional jump to stack[-2] label_29F7: // Incoming call from 0x0B6B, returns to 0x0B6C // Inputs[1] { @29FB msg.sender } 29F7 5B JUMPDEST 29F8 61 PUSH2 0x2a00 29FB 33 CALLER 29FC 61 PUSH2 0x0d6f 29FF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29F8 stack[0] = 0x2a00 // @29FB stack[1] = msg.sender // } // Block ends with call to 0x0d6f, returns to 0x2A00 label_2A00: // Incoming return from call to 0x0D6F at 0x29FF // Inputs[1] { @2A01 stack[-1] } 2A00 5B JUMPDEST 2A01 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2A02: // Incoming call from 0x0B80, returns to 0x0B81 // Inputs[2] // { // @2A08 storage[0x0d] // @2A3C msg.sender // } 2A02 5B JUMPDEST 2A03 60 PUSH1 0x0d 2A05 60 PUSH1 0x00 2A07 90 SWAP1 2A08 54 SLOAD 2A09 90 SWAP1 2A0A 61 PUSH2 0x0100 2A0D 0A EXP 2A0E 90 SWAP1 2A0F 04 DIV 2A10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A25 16 AND 2A26 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A3B 16 AND 2A3C 33 CALLER 2A3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A52 16 AND 2A53 14 EQ 2A54 15 ISZERO 2A55 15 ISZERO 2A56 61 PUSH2 0x2a5e 2A59 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a5e, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2A5A: // Incoming jump from 0x2A59, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2A5D memory[0x00:0x00] } 2A5A 60 PUSH1 0x00 2A5C 80 DUP1 2A5D FD *REVERT // Stack delta = +0 // Outputs[1] { @2A5D revert(memory[0x00:0x00]); } // Block terminates label_2A5E: // Incoming jump from 0x2A59, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @2A6A storage[0x08] // @2A7A stack[-1] // } 2A5E 5B JUMPDEST 2A5F 60 PUSH1 0x00 2A61 60 PUSH1 0x08 2A63 60 PUSH1 0x00 2A65 61 PUSH2 0x0100 2A68 0A EXP 2A69 81 DUP2 2A6A 54 SLOAD 2A6B 81 DUP2 2A6C 60 PUSH1 0xff 2A6E 02 MUL 2A6F 19 NOT 2A70 16 AND 2A71 90 SWAP1 2A72 83 DUP4 2A73 15 ISZERO 2A74 15 ISZERO 2A75 02 MUL 2A76 17 OR 2A77 90 SWAP1 2A78 55 SSTORE 2A79 50 POP 2A7A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2A78 storage[0x08] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x08]) } // Block ends with unconditional jump to stack[-1] label_2A7B: // Incoming call from 0x0BA3, returns to 0x0BA4 // Inputs[2] // { // @2A81 storage[0x0d] // @2AB5 msg.sender // } 2A7B 5B JUMPDEST 2A7C 60 PUSH1 0x0d 2A7E 60 PUSH1 0x00 2A80 90 SWAP1 2A81 54 SLOAD 2A82 90 SWAP1 2A83 61 PUSH2 0x0100 2A86 0A EXP 2A87 90 SWAP1 2A88 04 DIV 2A89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A9E 16 AND 2A9F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AB4 16 AND 2AB5 33 CALLER 2AB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2ACB 16 AND 2ACC 14 EQ 2ACD 15 ISZERO 2ACE 15 ISZERO 2ACF 61 PUSH2 0x2ad7 2AD2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ad7, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2AD3: // Incoming jump from 0x2AD2, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2AD6 memory[0x00:0x00] } 2AD3 60 PUSH1 0x00 2AD5 80 DUP1 2AD6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AD6 revert(memory[0x00:0x00]); } // Block terminates label_2AD7: // Incoming jump from 0x2AD2, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @2ADA storage[0x0a] // @2ADB block.number // } 2AD7 5B JUMPDEST 2AD8 60 PUSH1 0x0a 2ADA 54 SLOAD 2ADB 43 NUMBER 2ADC 11 GT 2ADD 15 ISZERO 2ADE 15 ISZERO 2ADF 61 PUSH2 0x2ae7 2AE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ae7, if !!(block.number > storage[0x0a]) label_2AE3: // Incoming jump from 0x2AE2, if not !!(block.number > storage[0x0a]) // Inputs[1] { @2AE6 memory[0x00:0x00] } 2AE3 60 PUSH1 0x00 2AE5 80 DUP1 2AE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AE6 revert(memory[0x00:0x00]); } // Block terminates label_2AE7: // Incoming jump from 0x2AE2, if !!(block.number > storage[0x0a]) // Inputs[1] { @2AEA stack[-1] } 2AE7 5B JUMPDEST 2AE8 60 PUSH1 0x00 2AEA 81 DUP2 2AEB 11 GT 2AEC 15 ISZERO 2AED 15 ISZERO 2AEE 61 PUSH2 0x2af6 2AF1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2af6, if !!(stack[-1] > 0x00) label_2AF2: // Incoming jump from 0x2AF1, if not !!(stack[-1] > 0x00) // Inputs[1] { @2AF5 memory[0x00:0x00] } 2AF2 60 PUSH1 0x00 2AF4 80 DUP1 2AF5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AF5 revert(memory[0x00:0x00]); } // Block terminates label_2AF6: // Incoming jump from 0x2AF1, if !!(stack[-1] > 0x00) // Inputs[11] // { // @2AF7 stack[-1] // @2B09 storage[0x15] // @2B17 memory[0x00:0x40] // @2B1C storage[0x11] // @2B26 storage[0x12] // @2B2F block.timestamp // @2B5C storage[0x11] // @2B60 memory[0x40:0x60] // @2B74 memory[0x40:0x60] // @2B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2B7B stack[-2] // } 2AF6 5B JUMPDEST 2AF7 80 DUP1 2AF8 60 PUSH1 0x11 2AFA 60 PUSH1 0x01 2AFC 01 ADD 2AFD 81 DUP2 2AFE 90 SWAP1 2AFF 55 SSTORE 2B00 50 POP 2B01 60 PUSH1 0x11 2B03 60 PUSH1 0x14 2B05 60 PUSH1 0x00 2B07 60 PUSH1 0x15 2B09 54 SLOAD 2B0A 81 DUP2 2B0B 52 MSTORE 2B0C 60 PUSH1 0x20 2B0E 01 ADD 2B0F 90 SWAP1 2B10 81 DUP2 2B11 52 MSTORE 2B12 60 PUSH1 0x20 2B14 01 ADD 2B15 60 PUSH1 0x00 2B17 20 SHA3 2B18 60 PUSH1 0x00 2B1A 82 DUP3 2B1B 01 ADD 2B1C 54 SLOAD 2B1D 81 DUP2 2B1E 60 PUSH1 0x00 2B20 01 ADD 2B21 55 SSTORE 2B22 60 PUSH1 0x01 2B24 82 DUP3 2B25 01 ADD 2B26 54 SLOAD 2B27 81 DUP2 2B28 60 PUSH1 0x01 2B2A 01 ADD 2B2B 55 SSTORE 2B2C 90 SWAP1 2B2D 50 POP 2B2E 50 POP 2B2F 42 TIMESTAMP 2B30 60 PUSH1 0x15 2B32 81 DUP2 2B33 90 SWAP1 2B34 55 SSTORE 2B35 50 POP 2B36 7F PUSH32 0x945c1c4e99aa89f648fbfe3df471b916f719e16d960fcec0737d4d56bd696838 2B57 60 PUSH1 0x11 2B59 60 PUSH1 0x00 2B5B 01 ADD 2B5C 54 SLOAD 2B5D 82 DUP3 2B5E 60 PUSH1 0x40 2B60 51 MLOAD 2B61 80 DUP1 2B62 83 DUP4 2B63 81 DUP2 2B64 52 MSTORE 2B65 60 PUSH1 0x20 2B67 01 ADD 2B68 82 DUP3 2B69 81 DUP2 2B6A 52 MSTORE 2B6B 60 PUSH1 0x20 2B6D 01 ADD 2B6E 92 SWAP3 2B6F 50 POP 2B70 50 POP 2B71 50 POP 2B72 60 PUSH1 0x40 2B74 51 MLOAD 2B75 80 DUP1 2B76 91 SWAP2 2B77 03 SUB 2B78 90 SWAP1 2B79 A1 LOG1 2B7A 50 POP 2B7B 56 *JUMP // Stack delta = -2 // Outputs[9] // { // @2AFF storage[0x12] = stack[-1] // @2B0B memory[0x00:0x20] = storage[0x15] // @2B11 memory[0x20:0x40] = 0x14 // @2B21 storage[0x00 + keccak256(memory[0x00:0x40])] = storage[0x11] // @2B2B storage[0x01 + keccak256(memory[0x00:0x40])] = storage[0x12] // @2B34 storage[0x15] = block.timestamp // @2B64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x11] // @2B6A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @2B79 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x945c1c4e99aa89f648fbfe3df471b916f719e16d960fcec0737d4d56bd696838]); // } // Block ends with unconditional jump to stack[-2] label_2B7C: // Incoming call from 0x0BB8, returns to 0x0BB9 // Inputs[2] // { // @2B7F storage[0x06] // @2B80 stack[-1] // } 2B7C 5B JUMPDEST 2B7D 60 PUSH1 0x06 2B7F 54 SLOAD 2B80 81 DUP2 2B81 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B7F stack[0] = storage[0x06] } // Block ends with unconditional jump to stack[-1] label_2B82: // Incoming call from 0x0C24, returns to 0x0C25 // Inputs[6] // { // @2B89 stack[-2] // @2BC3 memory[0x00:0x40] // @2BC6 stack[-1] // @2C00 memory[0x00:0x40] // @2C01 storage[keccak256(memory[0x00:0x40])] // @2C04 stack[-3] // } 2B82 5B JUMPDEST 2B83 60 PUSH1 0x00 2B85 60 PUSH1 0x05 2B87 60 PUSH1 0x00 2B89 84 DUP5 2B8A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B9F 16 AND 2BA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BB5 16 AND 2BB6 81 DUP2 2BB7 52 MSTORE 2BB8 60 PUSH1 0x20 2BBA 01 ADD 2BBB 90 SWAP1 2BBC 81 DUP2 2BBD 52 MSTORE 2BBE 60 PUSH1 0x20 2BC0 01 ADD 2BC1 60 PUSH1 0x00 2BC3 20 SHA3 2BC4 60 PUSH1 0x00 2BC6 83 DUP4 2BC7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BDC 16 AND 2BDD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BF2 16 AND 2BF3 81 DUP2 2BF4 52 MSTORE 2BF5 60 PUSH1 0x20 2BF7 01 ADD 2BF8 90 SWAP1 2BF9 81 DUP2 2BFA 52 MSTORE 2BFB 60 PUSH1 0x20 2BFD 01 ADD 2BFE 60 PUSH1 0x00 2C00 20 SHA3 2C01 54 SLOAD 2C02 90 SWAP1 2C03 50 POP 2C04 92 SWAP3 2C05 91 SWAP2 2C06 50 POP 2C07 50 POP 2C08 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @2BB7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2BBD memory[0x20:0x40] = 0x05 // @2BF4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2BFA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2C04 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_2C09: // Incoming call from 0x0C71, returns to 0x0C72 // Inputs[2] // { // @2C12 storage[0x0d] // @2C46 msg.sender // } 2C09 5B JUMPDEST 2C0A 60 PUSH1 0x00 2C0C 80 DUP1 2C0D 60 PUSH1 0x0d 2C0F 60 PUSH1 0x00 2C11 90 SWAP1 2C12 54 SLOAD 2C13 90 SWAP1 2C14 61 PUSH2 0x0100 2C17 0A EXP 2C18 90 SWAP1 2C19 04 DIV 2C1A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C2F 16 AND 2C30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C45 16 AND 2C46 33 CALLER 2C47 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C5C 16 AND 2C5D 14 EQ 2C5E 15 ISZERO 2C5F 15 ISZERO 2C60 61 PUSH2 0x2c68 2C63 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C0A stack[0] = 0x00 // @2C0C stack[1] = 0x00 // } // Block ends with conditional jump to 0x2c68, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2C64: // Incoming jump from 0x2C63, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2C67 memory[0x00:0x00] } 2C64 60 PUSH1 0x00 2C66 80 DUP1 2C67 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C67 revert(memory[0x00:0x00]); } // Block terminates label_2C68: // Incoming jump from 0x2C63, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2C81 stack[-3] } 2C68 5B JUMPDEST 2C69 60 PUSH1 0x00 2C6B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C80 16 AND 2C81 83 DUP4 2C82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C97 16 AND 2C98 14 EQ 2C99 15 ISZERO 2C9A 15 ISZERO 2C9B 15 ISZERO 2C9C 61 PUSH2 0x2ca4 2C9F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ca4, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2CA0: // Incoming jump from 0x2C9F, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2CA3 memory[0x00:0x00] } 2CA0 60 PUSH1 0x00 2CA2 80 DUP1 2CA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @2CA3 revert(memory[0x00:0x00]); } // Block terminates label_2CA4: // Incoming jump from 0x2C9F, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @2CA5 stack[-3] // @2CA6 stack[-2] // @2CC4 address(this) // @2CC7 memory[0x40:0x60] // @2D2D memory[0x40:0x60] // @2D36 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // } 2CA4 5B JUMPDEST 2CA5 82 DUP3 2CA6 91 SWAP2 2CA7 50 POP 2CA8 81 DUP2 2CA9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CBE 16 AND 2CBF 63 PUSH4 0x70a08231 2CC4 30 ADDRESS 2CC5 60 PUSH1 0x40 2CC7 51 MLOAD 2CC8 82 DUP3 2CC9 63 PUSH4 0xffffffff 2CCE 16 AND 2CCF 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 2CED 02 MUL 2CEE 81 DUP2 2CEF 52 MSTORE 2CF0 60 PUSH1 0x04 2CF2 01 ADD 2CF3 80 DUP1 2CF4 82 DUP3 2CF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D0A 16 AND 2D0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D20 16 AND 2D21 81 DUP2 2D22 52 MSTORE 2D23 60 PUSH1 0x20 2D25 01 ADD 2D26 91 SWAP2 2D27 50 POP 2D28 50 POP 2D29 60 PUSH1 0x20 2D2B 60 PUSH1 0x40 2D2D 51 MLOAD 2D2E 80 DUP1 2D2F 83 DUP4 2D30 03 SUB 2D31 81 DUP2 2D32 60 PUSH1 0x00 2D34 87 DUP8 2D35 80 DUP1 2D36 3B EXTCODESIZE 2D37 15 ISZERO 2D38 15 ISZERO 2D39 61 PUSH2 0x2d41 2D3C 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @2CA6 stack[-2] = stack[-3] // @2CBE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2CBF stack[1] = 0x70a08231 // @2CEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x70a08231) // @2D22 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @2D26 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @2D29 stack[3] = 0x20 // @2D2D stack[4] = memory[0x40:0x60] // @2D30 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2D31 stack[6] = memory[0x40:0x60] // @2D32 stack[7] = 0x00 // @2D34 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with conditional jump to 0x2d41, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length label_2D3D: // Incoming jump from 0x2D3C, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[1] { @2D40 memory[0x00:0x00] } 2D3D 60 PUSH1 0x00 2D3F 80 DUP1 2D40 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D40 revert(memory[0x00:0x00]); } // Block terminates label_2D41: // Incoming jump from 0x2D3C, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[9] // { // @2D42 msg.gas // @2D43 stack[-1] // @2D43 stack[-5] // @2D43 address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @2D43 stack[-4] // @2D43 memory[stack[-3]:stack[-3] + stack[-4]] // @2D43 stack[-2] // @2D43 stack[-6] // @2D43 stack[-3] // } 2D41 5B JUMPDEST 2D42 5A GAS 2D43 F1 CALL 2D44 15 ISZERO 2D45 15 ISZERO 2D46 61 PUSH2 0x2d4e 2D49 57 *JUMPI // Stack delta = -6 // Outputs[1] { @2D43 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x2d4e, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_2D4A: // Incoming jump from 0x2D49, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @2D4D memory[0x00:0x00] } 2D4A 60 PUSH1 0x00 2D4C 80 DUP1 2D4D FD *REVERT // Stack delta = +0 // Outputs[1] { @2D4D revert(memory[0x00:0x00]); } // Block terminates label_2D4E: // Incoming jump from 0x2D49, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[8] // { // @2D54 memory[0x40:0x60] // @2D56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2D59 stack[-4] // @2D5B stack[-5] // @2D7C storage[0x0d] // @2D9D memory[0x40:0x60] // @2E0A memory[0x40:0x60] // @2E13 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } 2D4E 5B JUMPDEST 2D4F 50 POP 2D50 50 POP 2D51 50 POP 2D52 60 PUSH1 0x40 2D54 51 MLOAD 2D55 80 DUP1 2D56 51 MLOAD 2D57 90 SWAP1 2D58 50 POP 2D59 90 SWAP1 2D5A 50 POP 2D5B 81 DUP2 2D5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D71 16 AND 2D72 63 PUSH4 0xa9059cbb 2D77 60 PUSH1 0x0d 2D79 60 PUSH1 0x00 2D7B 90 SWAP1 2D7C 54 SLOAD 2D7D 90 SWAP1 2D7E 61 PUSH2 0x0100 2D81 0A EXP 2D82 90 SWAP1 2D83 04 DIV 2D84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D99 16 AND 2D9A 83 DUP4 2D9B 60 PUSH1 0x40 2D9D 51 MLOAD 2D9E 83 DUP4 2D9F 63 PUSH4 0xffffffff 2DA4 16 AND 2DA5 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 2DC3 02 MUL 2DC4 81 DUP2 2DC5 52 MSTORE 2DC6 60 PUSH1 0x04 2DC8 01 ADD 2DC9 80 DUP1 2DCA 83 DUP4 2DCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DE0 16 AND 2DE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2DF6 16 AND 2DF7 81 DUP2 2DF8 52 MSTORE 2DF9 60 PUSH1 0x20 2DFB 01 ADD 2DFC 82 DUP3 2DFD 81 DUP2 2DFE 52 MSTORE 2DFF 60 PUSH1 0x20 2E01 01 ADD 2E02 92 SWAP3 2E03 50 POP 2E04 50 POP 2E05 50 POP 2E06 60 PUSH1 0x20 2E08 60 PUSH1 0x40 2E0A 51 MLOAD 2E0B 80 DUP1 2E0C 83 DUP4 2E0D 03 SUB 2E0E 81 DUP2 2E0F 60 PUSH1 0x00 2E11 87 DUP8 2E12 80 DUP1 2E13 3B EXTCODESIZE 2E14 15 ISZERO 2E15 15 ISZERO 2E16 61 PUSH2 0x2e1e 2E19 57 *JUMPI // Stack delta = +6 // Outputs[13] // { // @2D59 stack[-4] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2D71 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @2D72 stack[-2] = 0xa9059cbb // @2DC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xa9059cbb) // @2DF8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @2DFE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2E02 stack[-1] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2E06 stack[0] = 0x20 // @2E0A stack[1] = memory[0x40:0x60] // @2E0D stack[2] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2E0E stack[3] = memory[0x40:0x60] // @2E0F stack[4] = 0x00 // @2E11 stack[5] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // } // Block ends with conditional jump to 0x2e1e, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length label_2E1A: // Incoming jump from 0x2E19, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[1] { @2E1D memory[0x00:0x00] } 2E1A 60 PUSH1 0x00 2E1C 80 DUP1 2E1D FD *REVERT // Stack delta = +0 // Outputs[1] { @2E1D revert(memory[0x00:0x00]); } // Block terminates label_2E1E: // Incoming jump from 0x2E19, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[9] // { // @2E1F msg.gas // @2E20 stack[-3] // @2E20 stack[-5] // @2E20 memory[stack[-3]:stack[-3] + stack[-4]] // @2E20 address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @2E20 stack[-6] // @2E20 stack[-4] // @2E20 stack[-2] // @2E20 stack[-1] // } 2E1E 5B JUMPDEST 2E1F 5A GAS 2E20 F1 CALL 2E21 15 ISZERO 2E22 15 ISZERO 2E23 61 PUSH2 0x2e2b 2E26 57 *JUMPI // Stack delta = -6 // Outputs[1] { @2E20 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x2e2b, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_2E27: // Incoming jump from 0x2E26, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @2E2A memory[0x00:0x00] } 2E27 60 PUSH1 0x00 2E29 80 DUP1 2E2A FD *REVERT // Stack delta = +0 // Outputs[1] { @2E2A revert(memory[0x00:0x00]); } // Block terminates label_2E2B: // Incoming jump from 0x2E26, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[3] // { // @2E31 memory[0x40:0x60] // @2E33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2E3A stack[-7] // } 2E2B 5B JUMPDEST 2E2C 50 POP 2E2D 50 POP 2E2E 50 POP 2E2F 60 PUSH1 0x40 2E31 51 MLOAD 2E32 80 DUP1 2E33 51 MLOAD 2E34 90 SWAP1 2E35 50 POP 2E36 50 POP 2E37 50 POP 2E38 50 POP 2E39 50 POP 2E3A 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_2E3B: // Incoming call from 0x0C94, returns to 0x0C95 // Inputs[2] // { // @2E41 storage[0x0d] // @2E75 msg.sender // } 2E3B 5B JUMPDEST 2E3C 60 PUSH1 0x0d 2E3E 60 PUSH1 0x00 2E40 90 SWAP1 2E41 54 SLOAD 2E42 90 SWAP1 2E43 61 PUSH2 0x0100 2E46 0A EXP 2E47 90 SWAP1 2E48 04 DIV 2E49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E5E 16 AND 2E5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E74 16 AND 2E75 33 CALLER 2E76 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E8B 16 AND 2E8C 14 EQ 2E8D 15 ISZERO 2E8E 15 ISZERO 2E8F 61 PUSH2 0x2e97 2E92 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2e97, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2E93: // Incoming jump from 0x2E92, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @2E96 memory[0x00:0x00] } 2E93 60 PUSH1 0x00 2E95 80 DUP1 2E96 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E96 revert(memory[0x00:0x00]); } // Block terminates label_2E97: // Incoming jump from 0x2E92, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @2E9D storage[0x09] // @2EA0 storage[0x0b] // } 2E97 5B JUMPDEST 2E98 61 PUSH2 0x2ea5 2E9B 60 PUSH1 0x09 2E9D 54 SLOAD 2E9E 60 PUSH1 0x0b 2EA0 54 SLOAD 2EA1 61 PUSH2 0x375e 2EA4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E98 stack[0] = 0x2ea5 // @2E9D stack[1] = storage[0x09] // @2EA0 stack[2] = storage[0x0b] // } // Block ends with call to 0x375e, returns to 0x2EA5 label_2EA5: // Incoming return from call to 0x375E at 0x2EA4 // Inputs[2] // { // @2EA6 block.number // @2EA7 stack[-1] // } 2EA5 5B JUMPDEST 2EA6 43 NUMBER 2EA7 10 LT 2EA8 15 ISZERO 2EA9 15 ISZERO 2EAA 61 PUSH2 0x2eb2 2EAD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2eb2, if !!(block.number < stack[-1]) label_2EAE: // Incoming jump from 0x2EAD, if not !!(block.number < stack[-1]) // Inputs[1] { @2EB1 memory[0x00:0x00] } 2EAE 60 PUSH1 0x00 2EB0 80 DUP1 2EB1 FD *REVERT // Stack delta = +0 // Outputs[1] { @2EB1 revert(memory[0x00:0x00]); } // Block terminates label_2EB2: // Incoming jump from 0x2EAD, if !!(block.number < stack[-1]) // Inputs[2] // { // @2EB8 storage[0x09] // @2EB9 stack[-1] // } 2EB2 5B JUMPDEST 2EB3 61 PUSH2 0x2ebe 2EB6 60 PUSH1 0x09 2EB8 54 SLOAD 2EB9 82 DUP3 2EBA 61 PUSH2 0x375e 2EBD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2EB3 stack[0] = 0x2ebe // @2EB8 stack[1] = storage[0x09] // @2EB9 stack[2] = stack[-1] // } // Block ends with call to 0x375e, returns to 0x2EBE label_2EBE: // Incoming return from call to 0x375E at 0x2EBD // Inputs[2] // { // @2EBF block.number // @2EC0 stack[-1] // } 2EBE 5B JUMPDEST 2EBF 43 NUMBER 2EC0 10 LT 2EC1 15 ISZERO 2EC2 15 ISZERO 2EC3 61 PUSH2 0x2ecb 2EC6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ecb, if !!(block.number < stack[-1]) label_2EC7: // Incoming jump from 0x2EC6, if not !!(block.number < stack[-1]) // Inputs[1] { @2ECA memory[0x00:0x00] } 2EC7 60 PUSH1 0x00 2EC9 80 DUP1 2ECA FD *REVERT // Stack delta = +0 // Outputs[1] { @2ECA revert(memory[0x00:0x00]); } // Block terminates label_2ECB: // Incoming jump from 0x2EC6, if !!(block.number < stack[-1]) // Inputs[2] // { // @2ECC stack[-1] // @2ED4 stack[-2] // } 2ECB 5B JUMPDEST 2ECC 80 DUP1 2ECD 60 PUSH1 0x0b 2ECF 81 DUP2 2ED0 90 SWAP1 2ED1 55 SSTORE 2ED2 50 POP 2ED3 50 POP 2ED4 56 *JUMP // Stack delta = -2 // Outputs[1] { @2ED1 storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2ED5: // Incoming call from 0x0C9E, returns to 0x0C9F // Inputs[2] // { // @2EDB storage[0x0e] // @2F0F msg.sender // } 2ED5 5B JUMPDEST 2ED6 60 PUSH1 0x0e 2ED8 60 PUSH1 0x00 2EDA 90 SWAP1 2EDB 54 SLOAD 2EDC 90 SWAP1 2EDD 61 PUSH2 0x0100 2EE0 0A EXP 2EE1 90 SWAP1 2EE2 04 DIV 2EE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EF8 16 AND 2EF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F0E 16 AND 2F0F 33 CALLER 2F10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F25 16 AND 2F26 14 EQ 2F27 80 DUP1 2F28 61 PUSH2 0x2f7e 2F2B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2F26 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x2f7e, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 label_2F2C: // Incoming jump from 0x2F2B, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // Inputs[2] // { // @2F32 storage[0x0d] // @2F66 msg.sender // } 2F2C 50 POP 2F2D 60 PUSH1 0x0d 2F2F 60 PUSH1 0x00 2F31 90 SWAP1 2F32 54 SLOAD 2F33 90 SWAP1 2F34 61 PUSH2 0x0100 2F37 0A EXP 2F38 90 SWAP1 2F39 04 DIV 2F3A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F4F 16 AND 2F50 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F65 16 AND 2F66 33 CALLER 2F67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2F7C 16 AND 2F7D 14 EQ 2F7E 5B JUMPDEST 2F7F 15 ISZERO 2F80 15 ISZERO 2F81 61 PUSH2 0x2f89 2F84 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2f89, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_2F85: // Incoming jump from 0x2F84, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x2F84, if not !!stack[-1] // Inputs[1] { @2F88 memory[0x00:0x00] } 2F85 60 PUSH1 0x00 2F87 80 DUP1 2F88 FD *REVERT // Stack delta = +0 // Outputs[1] { @2F88 revert(memory[0x00:0x00]); } // Block terminates label_2F89: // Incoming jump from 0x2F84, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Incoming jump from 0x2F84, if !!stack[-1] // Inputs[1] { @2F8C msg.value } 2F89 5B JUMPDEST 2F8A 60 PUSH1 0x00 2F8C 34 CALLVALUE 2F8D 11 GT 2F8E 15 ISZERO 2F8F 15 ISZERO 2F90 61 PUSH2 0x2f98 2F93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2f98, if !!(msg.value > 0x00) label_2F94: // Incoming jump from 0x2F93, if not !!(msg.value > 0x00) // Inputs[1] { @2F97 memory[0x00:0x00] } 2F94 60 PUSH1 0x00 2F96 80 DUP1 2F97 FD *REVERT // Stack delta = +0 // Outputs[1] { @2F97 revert(memory[0x00:0x00]); } // Block terminates label_2F98: // Incoming jump from 0x2F93, if !!(msg.value > 0x00) // Inputs[5] // { // @2FBA msg.value // @2FBD memory[0x40:0x60] // @2FCA memory[0x40:0x60] // @2FCF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2FD0 stack[-1] // } 2F98 5B JUMPDEST 2F99 7F PUSH32 0xfdb748c915e4e67b4bb23287bf4295a4595ce48b50343214369f72ccfb974cfa 2FBA 34 CALLVALUE 2FBB 60 PUSH1 0x40 2FBD 51 MLOAD 2FBE 80 DUP1 2FBF 82 DUP3 2FC0 81 DUP2 2FC1 52 MSTORE 2FC2 60 PUSH1 0x20 2FC4 01 ADD 2FC5 91 SWAP2 2FC6 50 POP 2FC7 50 POP 2FC8 60 PUSH1 0x40 2FCA 51 MLOAD 2FCB 80 DUP1 2FCC 91 SWAP2 2FCD 03 SUB 2FCE 90 SWAP1 2FCF A1 LOG1 2FD0 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2FC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.value // @2FCF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xfdb748c915e4e67b4bb23287bf4295a4595ce48b50343214369f72ccfb974cfa]); // } // Block ends with unconditional jump to stack[-1] label_2FD1: // Incoming call from 0x0CB3, returns to 0x0CB4 // Inputs[2] // { // @2FD7 storage[0x08] // @2FE2 stack[-1] // } 2FD1 5B JUMPDEST 2FD2 60 PUSH1 0x08 2FD4 60 PUSH1 0x01 2FD6 90 SWAP1 2FD7 54 SLOAD 2FD8 90 SWAP1 2FD9 61 PUSH2 0x0100 2FDC 0A EXP 2FDD 90 SWAP1 2FDE 04 DIV 2FDF 60 PUSH1 0xff 2FE1 16 AND 2FE2 81 DUP2 2FE3 56 *JUMP // Stack delta = +1 // Outputs[1] { @2FE1 stack[0] = 0xff & storage[0x08] / 0x0100 ** 0x01 } // Block ends with unconditional jump to stack[-1] label_2FE4: // Incoming call from 0x0CE0, returns to 0x0CE1 // Inputs[2] // { // @2FEA storage[0x0e] // @3008 stack[-1] // } 2FE4 5B JUMPDEST 2FE5 60 PUSH1 0x0e 2FE7 60 PUSH1 0x00 2FE9 90 SWAP1 2FEA 54 SLOAD 2FEB 90 SWAP1 2FEC 61 PUSH2 0x0100 2FEF 0A EXP 2FF0 90 SWAP1 2FF1 04 DIV 2FF2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3007 16 AND 3008 81 DUP2 3009 56 *JUMP // Stack delta = +1 // Outputs[1] { @3007 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_300A: // Incoming call from 0x0D43, returns to 0x0D44 // Inputs[2] // { // @3010 storage[0x0d] // @3044 msg.sender // } 300A 5B JUMPDEST 300B 60 PUSH1 0x0d 300D 60 PUSH1 0x00 300F 90 SWAP1 3010 54 SLOAD 3011 90 SWAP1 3012 61 PUSH2 0x0100 3015 0A EXP 3016 90 SWAP1 3017 04 DIV 3018 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 302D 16 AND 302E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3043 16 AND 3044 33 CALLER 3045 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 305A 16 AND 305B 14 EQ 305C 15 ISZERO 305D 15 ISZERO 305E 61 PUSH2 0x3066 3061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3066, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) label_3062: // Incoming jump from 0x3061, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[1] { @3065 memory[0x00:0x00] } 3062 60 PUSH1 0x00 3064 80 DUP1 3065 FD *REVERT // Stack delta = +0 // Outputs[1] { @3065 revert(memory[0x00:0x00]); } // Block terminates label_3066: // Incoming jump from 0x3061, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00) // Inputs[2] // { // @3069 storage[0x09] // @306A block.number // } 3066 5B JUMPDEST 3067 60 PUSH1 0x09 3069 54 SLOAD 306A 43 NUMBER 306B 10 LT 306C 15 ISZERO 306D 15 ISZERO 306E 61 PUSH2 0x3076 3071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3076, if !!(block.number < storage[0x09]) label_3072: // Incoming jump from 0x3071, if not !!(block.number < storage[0x09]) // Inputs[1] { @3075 memory[0x00:0x00] } 3072 60 PUSH1 0x00 3074 80 DUP1 3075 FD *REVERT // Stack delta = +0 // Outputs[1] { @3075 revert(memory[0x00:0x00]); } // Block terminates label_3076: // Incoming jump from 0x3071, if !!(block.number < storage[0x09]) // Inputs[2] // { // @3077 stack[-1] // @3078 block.number // } 3076 5B JUMPDEST 3077 80 DUP1 3078 43 NUMBER 3079 10 LT 307A 15 ISZERO 307B 15 ISZERO 307C 61 PUSH2 0x3084 307F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3084, if !!(block.number < stack[-1]) label_3080: // Incoming jump from 0x307F, if not !!(block.number < stack[-1]) // Inputs[1] { @3083 memory[0x00:0x00] } 3080 60 PUSH1 0x00 3082 80 DUP1 3083 FD *REVERT // Stack delta = +0 // Outputs[1] { @3083 revert(memory[0x00:0x00]); } // Block terminates label_3084: // Incoming jump from 0x307F, if !!(block.number < stack[-1]) // Inputs[2] // { // @3085 stack[-1] // @308D stack[-2] // } 3084 5B JUMPDEST 3085 80 DUP1 3086 60 PUSH1 0x09 3088 81 DUP2 3089 90 SWAP1 308A 55 SSTORE 308B 50 POP 308C 50 POP 308D 56 *JUMP // Stack delta = -2 // Outputs[1] { @308A storage[0x09] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_308E: // Incoming call from 0x0D58, returns to 0x0D59 // Inputs[2] // { // @3091 storage[0x0b] // @3092 stack[-1] // } 308E 5B JUMPDEST 308F 60 PUSH1 0x0b 3091 54 SLOAD 3092 81 DUP2 3093 56 *JUMP // Stack delta = +1 // Outputs[1] { @3091 stack[0] = storage[0x0b] } // Block ends with unconditional jump to stack[-1] label_3094: // Incoming call from 0x12DB, returns to 0x12DC // Incoming call from 0x12FE, returns to 0x12FF // Incoming call from 0x381D, returns to 0x381E // Incoming call from 0x1F15, returns to 0x1F16 // Incoming call from 0x0E66, returns to 0x0E67 // Incoming call from 0x1628, returns to 0x1629 // Inputs[2] // { // @3098 stack[-1] // @3099 stack[-2] // } 3094 5B JUMPDEST 3095 60 PUSH1 0x00 3097 80 DUP1 3098 82 DUP3 3099 84 DUP5 309A 02 MUL 309B 90 SWAP1 309C 50 POP 309D 60 PUSH1 0x00 309F 84 DUP5 30A0 14 EQ 30A1 80 DUP1 30A2 61 PUSH2 0x30b5 30A5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3095 stack[0] = 0x00 // @309B stack[1] = stack[-2] * stack[-1] // @30A0 stack[2] = stack[-2] == 0x00 // } // Block ends with conditional jump to 0x30b5, if stack[-2] == 0x00 label_30A6: // Incoming jump from 0x30A5, if not stack[-2] == 0x00 // Inputs[3] // { // @30A7 stack[-4] // @30A8 stack[-5] // @30A9 stack[-2] // } 30A6 50 POP 30A7 82 DUP3 30A8 84 DUP5 30A9 82 DUP3 30AA 81 DUP2 30AB 15 ISZERO 30AC 15 ISZERO 30AD 61 PUSH2 0x30b2 30B0 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @30A7 stack[-1] = stack[-4] // @30A8 stack[0] = stack[-5] // @30A9 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x30b2, if !!stack[-5] label_30B1: // Incoming jump from 0x30B0, if not !!stack[-5] 30B1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @30B1 assert(); } // Block terminates label_30B2: // Incoming jump from 0x30B0, if !!stack[-5] // Inputs[3] // { // @30B3 stack[-1] // @30B3 stack[-2] // @30B4 stack[-3] // } 30B2 5B JUMPDEST 30B3 04 DIV 30B4 14 EQ // Stack delta = -2 // Outputs[1] { @30B4 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_30B5: // Incoming jump from 0x30A5, if stack[-2] == 0x00 // Incoming jump from 0x30B4 // Inputs[1] { @30B6 stack[-1] } 30B5 5B JUMPDEST 30B6 15 ISZERO 30B7 15 ISZERO 30B8 61 PUSH2 0x30bd 30BB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x30bd, if !!stack[-1] label_30BC: // Incoming jump from 0x30BB, if not !!stack[-1] 30BC FE *ASSERT // Stack delta = +0 // Outputs[1] { @30BC assert(); } // Block terminates label_30BD: // Incoming jump from 0x30BB, if !!stack[-1] // Inputs[4] // { // @30BE stack[-1] // @30BF stack[-2] // @30C2 stack[-5] // @30C3 stack[-4] // } 30BD 5B JUMPDEST 30BE 80 DUP1 30BF 91 SWAP2 30C0 50 POP 30C1 50 POP 30C2 92 SWAP3 30C3 91 SWAP2 30C4 50 POP 30C5 50 POP 30C6 56 *JUMP // Stack delta = -4 // Outputs[1] { @30C2 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_30C7: // Incoming call from 0x0E7C, returns to 0x0E7D // Incoming call from 0x2885, returns to 0x2886 // Inputs[1] { @30D0 storage[0x0f] } 30C7 5B JUMPDEST 30C8 60 PUSH1 0x00 30CA 80 DUP1 30CB 60 PUSH1 0x0f 30CD 60 PUSH1 0x14 30CF 90 SWAP1 30D0 54 SLOAD 30D1 90 SWAP1 30D2 61 PUSH2 0x0100 30D5 0A EXP 30D6 90 SWAP1 30D7 04 DIV 30D8 60 PUSH1 0xff 30DA 16 AND 30DB 15 ISZERO 30DC 15 ISZERO 30DD 61 PUSH2 0x30e5 30E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @30C8 stack[0] = 0x00 // @30CA stack[1] = 0x00 // } // Block ends with conditional jump to 0x30e5, if !!(0xff & storage[0x0f] / 0x0100 ** 0x14) label_30E1: // Incoming jump from 0x30E0, if not !!(0xff & storage[0x0f] / 0x0100 ** 0x14) // Inputs[1] { @30E4 memory[0x00:0x00] } 30E1 60 PUSH1 0x00 30E3 80 DUP1 30E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @30E4 revert(memory[0x00:0x00]); } // Block terminates label_30E5: // Incoming jump from 0x30E0, if !!(0xff & storage[0x0f] / 0x0100 ** 0x14) // Inputs[1] { @30E8 stack[-3] } 30E5 5B JUMPDEST 30E6 60 PUSH1 0x0a 30E8 83 DUP4 30E9 81 DUP2 30EA 15 ISZERO 30EB 15 ISZERO 30EC 61 PUSH2 0x30f1 30EF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @30E6 stack[0] = 0x0a // @30E8 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x30f1, if !!0x0a label_30F0: // Incoming jump from 0x30EF, if not !!0x0a 30F0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @30F0 assert(); } // Block terminates label_30F1: // Incoming jump from 0x30EF, if !!0x0a // Inputs[4] // { // @30F2 stack[-2] // @30F2 stack[-1] // @30F3 stack[-4] // @30F8 stack[-5] // } 30F1 5B JUMPDEST 30F2 04 DIV 30F3 91 SWAP2 30F4 50 POP 30F5 61 PUSH2 0x30fe 30F8 83 DUP4 30F9 83 DUP4 30FA 61 PUSH2 0x375e 30FD 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @30F3 stack[-4] = stack[-1] / stack[-2] // @30F5 stack[-2] = 0x30fe // @30F8 stack[-1] = stack[-5] // @30F9 stack[0] = stack[-1] / stack[-2] // } // Block ends with call to 0x375e, returns to 0x30FE label_30FE: // Incoming return from call to 0x375E at 0x30FD // Inputs[4] // { // @30FF stack[-2] // @30FF stack[-1] // @3103 storage[0x06] // @3109 storage[0x03] // } 30FE 5B JUMPDEST 30FF 90 SWAP1 3100 50 POP 3101 60 PUSH1 0x06 3103 54 SLOAD 3104 61 PUSH2 0x310f 3107 60 PUSH1 0x03 3109 54 SLOAD 310A 83 DUP4 310B 61 PUSH2 0x375e 310E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @30FF stack[-2] = stack[-1] // @3103 stack[-1] = storage[0x06] // @3104 stack[0] = 0x310f // @3109 stack[1] = storage[0x03] // @310A stack[2] = stack[-1] // } // Block ends with call to 0x375e, returns to 0x310F label_310F: // Incoming return from call to 0x375E at 0x310E // Inputs[2] // { // @3110 stack[-2] // @3110 stack[-1] // } 310F 5B JUMPDEST 3110 11 GT 3111 15 ISZERO 3112 15 ISZERO 3113 15 ISZERO 3114 61 PUSH2 0x311c 3117 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x311c, if !!!(stack[-1] > stack[-2]) label_3118: // Incoming jump from 0x3117, if not !!!(stack[-1] > stack[-2]) // Inputs[1] { @311B memory[0x00:0x00] } 3118 60 PUSH1 0x00 311A 80 DUP1 311B FD *REVERT // Stack delta = +0 // Outputs[1] { @311B revert(memory[0x00:0x00]); } // Block terminates label_311C: // Incoming jump from 0x3117, if !!!(stack[-1] > stack[-2]) // Inputs[2] // { // @3122 storage[0x03] // @3123 stack[-1] // } 311C 5B JUMPDEST 311D 61 PUSH2 0x3128 3120 60 PUSH1 0x03 3122 54 SLOAD 3123 82 DUP3 3124 61 PUSH2 0x375e 3127 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @311D stack[0] = 0x3128 // @3122 stack[1] = storage[0x03] // @3123 stack[2] = stack[-1] // } // Block ends with call to 0x375e, returns to 0x3128 label_3128: // Incoming return from call to 0x375E at 0x3127 // Inputs[5] // { // @312B stack[-1] // @3136 stack[-5] // @3170 memory[0x00:0x40] // @3171 storage[keccak256(memory[0x00:0x40])] // @3172 stack[-4] // } 3128 5B JUMPDEST 3129 60 PUSH1 0x03 312B 81 DUP2 312C 90 SWAP1 312D 55 SSTORE 312E 50 POP 312F 61 PUSH2 0x3177 3132 60 PUSH1 0x04 3134 60 PUSH1 0x00 3136 86 DUP7 3137 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 314C 16 AND 314D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3162 16 AND 3163 81 DUP2 3164 52 MSTORE 3165 60 PUSH1 0x20 3167 01 ADD 3168 90 SWAP1 3169 81 DUP2 316A 52 MSTORE 316B 60 PUSH1 0x20 316D 01 ADD 316E 60 PUSH1 0x00 3170 20 SHA3 3171 54 SLOAD 3172 84 DUP5 3173 61 PUSH2 0x375e 3176 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @312D storage[0x03] = stack[-1] // @312F stack[-1] = 0x3177 // @3164 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @316A memory[0x20:0x40] = 0x04 // @3171 stack[0] = storage[keccak256(memory[0x00:0x40])] // @3172 stack[1] = stack[-4] // } // Block ends with call to 0x375e, returns to 0x3177 label_3177: // Incoming return from call to 0x375E at 0x3176 // Inputs[7] // { // @317C stack[-5] // @31B6 memory[0x00:0x40] // @31B7 stack[-1] // @31C7 storage[0x0f] // @321E memory[0x00:0x40] // @321F storage[keccak256(memory[0x00:0x40])] // @3220 stack[-3] // } 3177 5B JUMPDEST 3178 60 PUSH1 0x04 317A 60 PUSH1 0x00 317C 86 DUP7 317D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3192 16 AND 3193 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31A8 16 AND 31A9 81 DUP2 31AA 52 MSTORE 31AB 60 PUSH1 0x20 31AD 01 ADD 31AE 90 SWAP1 31AF 81 DUP2 31B0 52 MSTORE 31B1 60 PUSH1 0x20 31B3 01 ADD 31B4 60 PUSH1 0x00 31B6 20 SHA3 31B7 81 DUP2 31B8 90 SWAP1 31B9 55 SSTORE 31BA 50 POP 31BB 61 PUSH2 0x3225 31BE 60 PUSH1 0x04 31C0 60 PUSH1 0x00 31C2 60 PUSH1 0x0f 31C4 60 PUSH1 0x00 31C6 90 SWAP1 31C7 54 SLOAD 31C8 90 SWAP1 31C9 61 PUSH2 0x0100 31CC 0A EXP 31CD 90 SWAP1 31CE 04 DIV 31CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31E4 16 AND 31E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 31FA 16 AND 31FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3210 16 AND 3211 81 DUP2 3212 52 MSTORE 3213 60 PUSH1 0x20 3215 01 ADD 3216 90 SWAP1 3217 81 DUP2 3218 52 MSTORE 3219 60 PUSH1 0x20 321B 01 ADD 321C 60 PUSH1 0x00 321E 20 SHA3 321F 54 SLOAD 3220 83 DUP4 3221 61 PUSH2 0x375e 3224 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @31AA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @31B0 memory[0x20:0x40] = 0x04 // @31B9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @31BB stack[-1] = 0x3225 // @3212 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00 // @3218 memory[0x20:0x40] = 0x04 // @321F stack[0] = storage[keccak256(memory[0x00:0x40])] // @3220 stack[1] = stack[-3] // } // Block ends with call to 0x375e, returns to 0x3225 label_3225: // Incoming return from call to 0x375E at 0x3224 // Inputs[14] // { // @322F storage[0x0f] // @3286 memory[0x00:0x40] // @3287 stack[-1] // @328B stack[-5] // @32DB stack[-4] // @32DE memory[0x40:0x60] // @32EB memory[0x40:0x60] // @32F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @32F6 storage[0x0f] // @3363 stack[-3] // @3366 memory[0x40:0x60] // @3373 memory[0x40:0x60] // @3378 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @337D stack[-6] // } 3225 5B JUMPDEST 3226 60 PUSH1 0x04 3228 60 PUSH1 0x00 322A 60 PUSH1 0x0f 322C 60 PUSH1 0x00 322E 90 SWAP1 322F 54 SLOAD 3230 90 SWAP1 3231 61 PUSH2 0x0100 3234 0A EXP 3235 90 SWAP1 3236 04 DIV 3237 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 324C 16 AND 324D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3262 16 AND 3263 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3278 16 AND 3279 81 DUP2 327A 52 MSTORE 327B 60 PUSH1 0x20 327D 01 ADD 327E 90 SWAP1 327F 81 DUP2 3280 52 MSTORE 3281 60 PUSH1 0x20 3283 01 ADD 3284 60 PUSH1 0x00 3286 20 SHA3 3287 81 DUP2 3288 90 SWAP1 3289 55 SSTORE 328A 50 POP 328B 83 DUP4 328C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32A1 16 AND 32A2 60 PUSH1 0x00 32A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 32B9 16 AND 32BA 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 32DB 85 DUP6 32DC 60 PUSH1 0x40 32DE 51 MLOAD 32DF 80 DUP1 32E0 82 DUP3 32E1 81 DUP2 32E2 52 MSTORE 32E3 60 PUSH1 0x20 32E5 01 ADD 32E6 91 SWAP2 32E7 50 POP 32E8 50 POP 32E9 60 PUSH1 0x40 32EB 51 MLOAD 32EC 80 DUP1 32ED 91 SWAP2 32EE 03 SUB 32EF 90 SWAP1 32F0 A3 LOG3 32F1 60 PUSH1 0x0f 32F3 60 PUSH1 0x00 32F5 90 SWAP1 32F6 54 SLOAD 32F7 90 SWAP1 32F8 61 PUSH2 0x0100 32FB 0A EXP 32FC 90 SWAP1 32FD 04 DIV 32FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3313 16 AND 3314 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3329 16 AND 332A 60 PUSH1 0x00 332C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3341 16 AND 3342 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3363 84 DUP5 3364 60 PUSH1 0x40 3366 51 MLOAD 3367 80 DUP1 3368 82 DUP3 3369 81 DUP2 336A 52 MSTORE 336B 60 PUSH1 0x20 336D 01 ADD 336E 91 SWAP2 336F 50 POP 3370 50 POP 3371 60 PUSH1 0x40 3373 51 MLOAD 3374 80 DUP1 3375 91 SWAP2 3376 03 SUB 3377 90 SWAP1 3378 A3 LOG3 3379 50 POP 337A 50 POP 337B 50 POP 337C 50 POP 337D 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @327A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0f] / 0x0100 ** 0x00 // @3280 memory[0x20:0x40] = 0x04 // @3289 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @32E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @32F0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // @336A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @3378 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, storage[0x0f] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-6] label_337E: // Incoming jump from 0x24F7 // Incoming call from 0x37EE, returns to 0x37EF // Incoming call from 0x3940, returns to 0x3941 // Incoming call from 0x366C, returns to 0x366D // Incoming call from 0x3517, returns to 0x3518 // Incoming jump from 0x382E // Incoming call from 0x12A4, returns to 0x12A5 // Inputs[2] // { // @3381 stack[-2] // @3382 stack[-1] // } 337E 5B JUMPDEST 337F 60 PUSH1 0x00 3381 82 DUP3 3382 82 DUP3 3383 11 GT 3384 15 ISZERO 3385 15 ISZERO 3386 15 ISZERO 3387 61 PUSH2 0x338c 338A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @337F stack[0] = 0x00 } // Block ends with conditional jump to 0x338c, if !!!(stack[-1] > stack[-2]) label_338B: // Incoming jump from 0x338A, if not !!!(stack[-1] > stack[-2]) 338B FE *ASSERT // Stack delta = +0 // Outputs[1] { @338B assert(); } // Block terminates label_338C: // Incoming jump from 0x338A, if !!!(stack[-1] > stack[-2]) // Inputs[4] // { // @338D stack[-2] // @338E stack[-3] // @3390 stack[-1] // @3392 stack[-4] // } 338C 5B JUMPDEST 338D 81 DUP2 338E 83 DUP4 338F 03 SUB 3390 90 SWAP1 3391 50 POP 3392 92 SWAP3 3393 91 SWAP2 3394 50 POP 3395 50 POP 3396 56 *JUMP // Stack delta = -3 // Outputs[1] { @3392 stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_3397: // Incoming call from 0x144D, returns to 0x144E // Inputs[1] { @33A5 msg.data.length } 3397 5B JUMPDEST 3398 60 PUSH1 0x00 339A 60 PUSH1 0x03 339C 60 PUSH1 0x04 339E 60 PUSH1 0x20 33A0 82 DUP3 33A1 02 MUL 33A2 01 ADD 33A3 60 PUSH1 0x00 33A5 36 CALLDATASIZE 33A6 90 SWAP1 33A7 50 POP 33A8 10 LT 33A9 15 ISZERO 33AA 15 ISZERO 33AB 15 ISZERO 33AC 61 PUSH2 0x33b1 33AF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3398 stack[0] = 0x00 // @339A stack[1] = 0x03 // } // Block ends with conditional jump to 0x33b1, if !!!(msg.data.length < 0x03 * 0x20 + 0x04) label_33B0: // Incoming jump from 0x33AF, if not !!!(msg.data.length < 0x03 * 0x20 + 0x04) 33B0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @33B0 assert(); } // Block terminates label_33B1: // Incoming jump from 0x33AF, if !!!(msg.data.length < 0x03 * 0x20 + 0x04) // Inputs[1] { @33CA stack[-4] } 33B1 5B JUMPDEST 33B2 60 PUSH1 0x00 33B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33C9 16 AND 33CA 84 DUP5 33CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 33E0 16 AND 33E1 14 EQ 33E2 15 ISZERO 33E3 15 ISZERO 33E4 15 ISZERO 33E5 61 PUSH2 0x33ed 33E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x33ed, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_33E9: // Incoming jump from 0x33E8, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @33EC memory[0x00:0x00] } 33E9 60 PUSH1 0x00 33EB 80 DUP1 33EC FD *REVERT // Stack delta = +0 // Outputs[1] { @33EC revert(memory[0x00:0x00]); } // Block terminates label_33ED: // Incoming jump from 0x33E8, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @33EE stack[-3] // @33F3 stack[-5] // @342D memory[0x00:0x40] // @342E storage[keccak256(memory[0x00:0x40])] // } 33ED 5B JUMPDEST 33EE 82 DUP3 33EF 60 PUSH1 0x04 33F1 60 PUSH1 0x00 33F3 87 DUP8 33F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3409 16 AND 340A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 341F 16 AND 3420 81 DUP2 3421 52 MSTORE 3422 60 PUSH1 0x20 3424 01 ADD 3425 90 SWAP1 3426 81 DUP2 3427 52 MSTORE 3428 60 PUSH1 0x20 342A 01 ADD 342B 60 PUSH1 0x00 342D 20 SHA3 342E 54 SLOAD 342F 10 LT 3430 15 ISZERO 3431 80 DUP1 3432 15 ISZERO 3433 61 PUSH2 0x34b8 3436 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @3421 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3427 memory[0x20:0x40] = 0x04 // @3430 stack[0] = !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // } // Block ends with conditional jump to 0x34b8, if !!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_3437: // Incoming jump from 0x3436, if not !!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[6] // { // @3438 stack[-4] // @343D stack[-6] // @3477 memory[0x00:0x40] // @347A msg.sender // @34B4 memory[0x00:0x40] // @34B5 storage[keccak256(memory[0x00:0x40])] // } 3437 50 POP 3438 82 DUP3 3439 60 PUSH1 0x05 343B 60 PUSH1 0x00 343D 87 DUP8 343E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3453 16 AND 3454 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3469 16 AND 346A 81 DUP2 346B 52 MSTORE 346C 60 PUSH1 0x20 346E 01 ADD 346F 90 SWAP1 3470 81 DUP2 3471 52 MSTORE 3472 60 PUSH1 0x20 3474 01 ADD 3475 60 PUSH1 0x00 3477 20 SHA3 3478 60 PUSH1 0x00 347A 33 CALLER 347B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3490 16 AND 3491 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34A6 16 AND 34A7 81 DUP2 34A8 52 MSTORE 34A9 60 PUSH1 0x20 34AB 01 ADD 34AC 90 SWAP1 34AD 81 DUP2 34AE 52 MSTORE 34AF 60 PUSH1 0x20 34B1 01 ADD 34B2 60 PUSH1 0x00 34B4 20 SHA3 34B5 54 SLOAD 34B6 10 LT 34B7 15 ISZERO 34B8 5B JUMPDEST 34B9 80 DUP1 34BA 15 ISZERO 34BB 61 PUSH2 0x34c4 34BE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @346B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @3471 memory[0x20:0x40] = 0x05 // @34A8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @34AE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @34B7 stack[-1] = !(storage[keccak256(memory[0x00:0x40])] < stack[-4]) // } // Block ends with conditional jump to 0x34c4, if !!(storage[keccak256(memory[0x00:0x40])] < stack[-4]) label_34BF: // Incoming jump from 0x34BE, if not !stack[-1] // Incoming jump from 0x34BE, if not !!(storage[keccak256(memory[0x00:0x40])] < stack[-4]) // Inputs[1] { @34C2 stack[-4] } 34BF 50 POP 34C0 60 PUSH1 0x00 34C2 83 DUP4 34C3 11 GT 34C4 5B JUMPDEST 34C5 15 ISZERO 34C6 15 ISZERO 34C7 61 PUSH2 0x34cf 34CA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x34cf, if !!(stack[-4] > 0x00) label_34CB: // Incoming jump from 0x34CA, if not !!(stack[-4] > 0x00) // Incoming jump from 0x34CA, if not !!stack[-1] // Inputs[1] { @34CE memory[0x00:0x00] } 34CB 60 PUSH1 0x00 34CD 80 DUP1 34CE FD *REVERT // Stack delta = +0 // Outputs[1] { @34CE revert(memory[0x00:0x00]); } // Block terminates label_34CF: // Incoming jump from 0x34CA, if !!(stack[-4] > 0x00) // Incoming jump from 0x34CA, if !!stack[-1] // Inputs[4] // { // @34D7 stack[-5] // @3511 memory[0x00:0x40] // @3512 storage[keccak256(memory[0x00:0x40])] // @3513 stack[-3] // } 34CF 5B JUMPDEST 34D0 61 PUSH2 0x3518 34D3 60 PUSH1 0x04 34D5 60 PUSH1 0x00 34D7 87 DUP8 34D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34ED 16 AND 34EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3503 16 AND 3504 81 DUP2 3505 52 MSTORE 3506 60 PUSH1 0x20 3508 01 ADD 3509 90 SWAP1 350A 81 DUP2 350B 52 MSTORE 350C 60 PUSH1 0x20 350E 01 ADD 350F 60 PUSH1 0x00 3511 20 SHA3 3512 54 SLOAD 3513 84 DUP5 3514 61 PUSH2 0x337e 3517 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @34D0 stack[0] = 0x3518 // @3505 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @350B memory[0x20:0x40] = 0x04 // @3512 stack[1] = storage[keccak256(memory[0x00:0x40])] // @3513 stack[2] = stack[-3] // } // Block ends with call to 0x337e, returns to 0x3518 label_3518: // Incoming return from call to 0x337E at 0x3517 // Inputs[7] // { // @351D stack[-6] // @3557 memory[0x00:0x40] // @3558 stack[-1] // @3563 stack[-5] // @359D memory[0x00:0x40] // @359E storage[keccak256(memory[0x00:0x40])] // @359F stack[-4] // } 3518 5B JUMPDEST 3519 60 PUSH1 0x04 351B 60 PUSH1 0x00 351D 87 DUP8 351E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3533 16 AND 3534 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3549 16 AND 354A 81 DUP2 354B 52 MSTORE 354C 60 PUSH1 0x20 354E 01 ADD 354F 90 SWAP1 3550 81 DUP2 3551 52 MSTORE 3552 60 PUSH1 0x20 3554 01 ADD 3555 60 PUSH1 0x00 3557 20 SHA3 3558 81 DUP2 3559 90 SWAP1 355A 55 SSTORE 355B 50 POP 355C 61 PUSH2 0x35a4 355F 60 PUSH1 0x04 3561 60 PUSH1 0x00 3563 86 DUP7 3564 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3579 16 AND 357A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 358F 16 AND 3590 81 DUP2 3591 52 MSTORE 3592 60 PUSH1 0x20 3594 01 ADD 3595 90 SWAP1 3596 81 DUP2 3597 52 MSTORE 3598 60 PUSH1 0x20 359A 01 ADD 359B 60 PUSH1 0x00 359D 20 SHA3 359E 54 SLOAD 359F 84 DUP5 35A0 61 PUSH2 0x375e 35A3 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @354B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @3551 memory[0x20:0x40] = 0x04 // @355A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @355C stack[-1] = 0x35a4 // @3591 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3597 memory[0x20:0x40] = 0x04 // @359E stack[0] = storage[keccak256(memory[0x00:0x40])] // @359F stack[1] = stack[-4] // } // Block ends with call to 0x375e, returns to 0x35A4 label_35A4: // Incoming return from call to 0x375E at 0x35A3 // Inputs[9] // { // @35A9 stack[-5] // @35E3 memory[0x00:0x40] // @35E4 stack[-1] // @35EF stack[-6] // @3629 memory[0x00:0x40] // @362C msg.sender // @3666 memory[0x00:0x40] // @3667 storage[keccak256(memory[0x00:0x40])] // @3668 stack[-4] // } 35A4 5B JUMPDEST 35A5 60 PUSH1 0x04 35A7 60 PUSH1 0x00 35A9 86 DUP7 35AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35BF 16 AND 35C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 35D5 16 AND 35D6 81 DUP2 35D7 52 MSTORE 35D8 60 PUSH1 0x20 35DA 01 ADD 35DB 90 SWAP1 35DC 81 DUP2 35DD 52 MSTORE 35DE 60 PUSH1 0x20 35E0 01 ADD 35E1 60 PUSH1 0x00 35E3 20 SHA3 35E4 81 DUP2 35E5 90 SWAP1 35E6 55 SSTORE 35E7 50 POP 35E8 61 PUSH2 0x366d 35EB 60 PUSH1 0x05 35ED 60 PUSH1 0x00 35EF 87 DUP8 35F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3605 16 AND 3606 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 361B 16 AND 361C 81 DUP2 361D 52 MSTORE 361E 60 PUSH1 0x20 3620 01 ADD 3621 90 SWAP1 3622 81 DUP2 3623 52 MSTORE 3624 60 PUSH1 0x20 3626 01 ADD 3627 60 PUSH1 0x00 3629 20 SHA3 362A 60 PUSH1 0x00 362C 33 CALLER 362D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3642 16 AND 3643 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3658 16 AND 3659 81 DUP2 365A 52 MSTORE 365B 60 PUSH1 0x20 365D 01 ADD 365E 90 SWAP1 365F 81 DUP2 3660 52 MSTORE 3661 60 PUSH1 0x20 3663 01 ADD 3664 60 PUSH1 0x00 3666 20 SHA3 3667 54 SLOAD 3668 84 DUP5 3669 61 PUSH2 0x337e 366C 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @35D7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @35DD memory[0x20:0x40] = 0x04 // @35E6 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @35E8 stack[-1] = 0x366d // @361D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @3623 memory[0x20:0x40] = 0x05 // @365A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @3660 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3667 stack[0] = storage[keccak256(memory[0x00:0x40])] // @3668 stack[1] = stack[-4] // } // Block ends with call to 0x337e, returns to 0x366D label_366D: // Incoming return from call to 0x337E at 0x366C // Inputs[12] // { // @3672 stack[-6] // @36AC memory[0x00:0x40] // @36AF msg.sender // @36E9 memory[0x00:0x40] // @36EA stack[-1] // @36EE stack[-5] // @373D stack[-4] // @3740 memory[0x40:0x60] // @374D memory[0x40:0x60] // @3752 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3755 stack[-3] // @3758 stack[-7] // } 366D 5B JUMPDEST 366E 60 PUSH1 0x05 3670 60 PUSH1 0x00 3672 87 DUP8 3673 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3688 16 AND 3689 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 369E 16 AND 369F 81 DUP2 36A0 52 MSTORE 36A1 60 PUSH1 0x20 36A3 01 ADD 36A4 90 SWAP1 36A5 81 DUP2 36A6 52 MSTORE 36A7 60 PUSH1 0x20 36A9 01 ADD 36AA 60 PUSH1 0x00 36AC 20 SHA3 36AD 60 PUSH1 0x00 36AF 33 CALLER 36B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 36C5 16 AND 36C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 36DB 16 AND 36DC 81 DUP2 36DD 52 MSTORE 36DE 60 PUSH1 0x20 36E0 01 ADD 36E1 90 SWAP1 36E2 81 DUP2 36E3 52 MSTORE 36E4 60 PUSH1 0x20 36E6 01 ADD 36E7 60 PUSH1 0x00 36E9 20 SHA3 36EA 81 DUP2 36EB 90 SWAP1 36EC 55 SSTORE 36ED 50 POP 36EE 83 DUP4 36EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3704 16 AND 3705 85 DUP6 3706 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 371B 16 AND 371C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 373D 85 DUP6 373E 60 PUSH1 0x40 3740 51 MLOAD 3741 80 DUP1 3742 82 DUP3 3743 81 DUP2 3744 52 MSTORE 3745 60 PUSH1 0x20 3747 01 ADD 3748 91 SWAP2 3749 50 POP 374A 50 POP 374B 60 PUSH1 0x40 374D 51 MLOAD 374E 80 DUP1 374F 91 SWAP2 3750 03 SUB 3751 90 SWAP1 3752 A3 LOG3 3753 60 PUSH1 0x01 3755 91 SWAP2 3756 50 POP 3757 50 POP 3758 93 SWAP4 3759 92 SWAP3 375A 50 POP 375B 50 POP 375C 50 POP 375D 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @36A0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @36A6 memory[0x20:0x40] = 0x05 // @36DD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @36E3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @36EC storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3744 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @3752 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // @3758 stack[-7] = 0x01 // } // Block ends with unconditional jump to stack[-7] label_375E: // Incoming call from 0x3176, returns to 0x3177 // Incoming call from 0x1D55, returns to 0x1D56 // Incoming call from 0x1707, returns to 0x1708 // Incoming call from 0x35A3, returns to 0x35A4 // Incoming call from 0x2EA4, returns to 0x2EA5 // Incoming call from 0x1D6E, returns to 0x1D6F // Incoming call from 0x3127, returns to 0x3128 // Incoming call from 0x310E, returns to 0x310F // Incoming call from 0x39CC, returns to 0x39CD // Incoming call from 0x3224, returns to 0x3225 // Incoming call from 0x2EBD, returns to 0x2EBE // Incoming call from 0x30FD, returns to 0x30FE // Incoming call from 0x1850, returns to 0x1851 // Inputs[2] // { // @3762 stack[-1] // @3763 stack[-2] // } 375E 5B JUMPDEST 375F 60 PUSH1 0x00 3761 80 DUP1 3762 82 DUP3 3763 84 DUP5 3764 01 ADD 3765 90 SWAP1 3766 50 POP 3767 83 DUP4 3768 81 DUP2 3769 10 LT 376A 15 ISZERO 376B 80 DUP1 376C 15 ISZERO 376D 61 PUSH2 0x3776 3770 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @375F stack[0] = 0x00 // @3765 stack[1] = stack[-2] + stack[-1] // @376A stack[2] = !(stack[-2] + stack[-1] < stack[-2]) // } // Block ends with conditional jump to 0x3776, if !!(stack[-2] + stack[-1] < stack[-2]) label_3771: // Incoming jump from 0x3770, if not !!(stack[-2] + stack[-1] < stack[-2]) // Inputs[2] // { // @3772 stack[-4] // @3773 stack[-2] // } 3771 50 POP 3772 82 DUP3 3773 81 DUP2 3774 10 LT 3775 15 ISZERO 3776 5B JUMPDEST 3777 15 ISZERO 3778 15 ISZERO 3779 61 PUSH2 0x377e 377C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x377e, if !!!(stack[-2] < stack[-4]) label_377D: // Incoming jump from 0x377C, if not !!stack[-1] // Incoming jump from 0x377C, if not !!!(stack[-2] < stack[-4]) 377D FE *ASSERT // Stack delta = +0 // Outputs[1] { @377D assert(); } // Block terminates label_377E: // Incoming jump from 0x377C, if !!stack[-1] // Incoming jump from 0x377C, if !!!(stack[-2] < stack[-4]) // Inputs[4] // { // @377F stack[-1] // @3780 stack[-2] // @3783 stack[-5] // @3784 stack[-4] // } 377E 5B JUMPDEST 377F 80 DUP1 3780 91 SWAP2 3781 50 POP 3782 50 POP 3783 92 SWAP3 3784 91 SWAP2 3785 50 POP 3786 50 POP 3787 56 *JUMP // Stack delta = -4 // Outputs[1] { @3783 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_3788: // Incoming call from 0x1E51, returns to 0x1E52 // Inputs[2] // { // @3790 storage[0x0e] // @37C4 msg.sender // } 3788 5B JUMPDEST 3789 60 PUSH1 0x00 378B 60 PUSH1 0x0e 378D 60 PUSH1 0x00 378F 90 SWAP1 3790 54 SLOAD 3791 90 SWAP1 3792 61 PUSH2 0x0100 3795 0A EXP 3796 90 SWAP1 3797 04 DIV 3798 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 37AD 16 AND 37AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 37C3 16 AND 37C4 33 CALLER 37C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 37DA 16 AND 37DB 14 EQ 37DC 15 ISZERO 37DD 61 PUSH2 0x3844 37E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3789 stack[0] = 0x00 } // Block ends with conditional jump to 0x3844, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00) label_37E1: // Incoming jump from 0x37E0, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00) // Inputs[3] // { // @37E3 storage[0x15] // @37E7 block.timestamp // @37EA storage[0x13] // } 37E1 60 PUSH1 0x15 37E3 54 SLOAD 37E4 61 PUSH2 0x37ef 37E7 42 TIMESTAMP 37E8 60 PUSH1 0x13 37EA 54 SLOAD 37EB 61 PUSH2 0x337e 37EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @37E3 stack[0] = storage[0x15] // @37E4 stack[1] = 0x37ef // @37E7 stack[2] = block.timestamp // @37EA stack[3] = storage[0x13] // } // Block ends with call to 0x337e, returns to 0x37EF label_37EF: // Incoming return from call to 0x337E at 0x37EE // Inputs[2] // { // @37F0 stack[-2] // @37F0 stack[-1] // } 37EF 5B JUMPDEST 37F0 10 LT 37F1 15 ISZERO 37F2 15 ISZERO 37F3 15 ISZERO 37F4 61 PUSH2 0x37fc 37F7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x37fc, if !!!(stack[-1] < stack[-2]) label_37F8: // Incoming jump from 0x37F7, if not !!!(stack[-1] < stack[-2]) // Inputs[1] { @37FB memory[0x00:0x00] } 37F8 60 PUSH1 0x00 37FA 80 DUP1 37FB FD *REVERT // Stack delta = +0 // Outputs[1] { @37FB revert(memory[0x00:0x00]); } // Block terminates label_37FC: // Incoming jump from 0x37F7, if !!!(stack[-1] < stack[-2]) // Inputs[2] // { // @37FD stack[-2] // @3803 storage[0x11] // } 37FC 5B JUMPDEST 37FD 81 DUP2 37FE 60 PUSH1 0x11 3800 60 PUSH1 0x00 3802 01 ADD 3803 54 SLOAD 3804 81 DUP2 3805 11 GT 3806 15 ISZERO 3807 61 PUSH2 0x3842 380A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37FD stack[0] = stack[-2] } // Block ends with conditional jump to 0x3842, if !(stack[-2] > storage[0x11]) label_380B: // Incoming jump from 0x380A, if not !(stack[-2] > storage[0x11]) // Inputs[2] // { // @3813 storage[0x11] // @3817 stack[-3] // } 380B 61 PUSH2 0x382f 380E 60 PUSH1 0x11 3810 60 PUSH1 0x00 3812 01 ADD 3813 54 SLOAD 3814 61 PUSH2 0x381e 3817 85 DUP6 3818 60 PUSH1 0x64 381A 61 PUSH2 0x3094 381D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @380B stack[0] = 0x382f // @3813 stack[1] = storage[0x11] // @3814 stack[2] = 0x381e // @3817 stack[3] = stack[-3] // @3818 stack[4] = 0x64 // } // Block ends with call to 0x3094, returns to 0x381E label_381E: // Incoming return from call to 0x3094 at 0x381D // Inputs[1] { @381F stack[-2] } 381E 5B JUMPDEST 381F 81 DUP2 3820 15 ISZERO 3821 15 ISZERO 3822 61 PUSH2 0x3827 3825 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3827, if !!stack[-2] label_3826: // Incoming jump from 0x3825, if not !!stack[-2] 3826 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3826 assert(); } // Block terminates label_3827: // Incoming jump from 0x3825, if !!stack[-2] // Inputs[2] // { // @3828 stack[-2] // @3828 stack[-1] // } 3827 5B JUMPDEST 3828 04 DIV 3829 60 PUSH1 0x64 382B 61 PUSH2 0x337e 382E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3828 stack[-2] = stack[-1] / stack[-2] // @3829 stack[-1] = 0x64 // } // Block ends with unconditional jump to 0x337e label_382F: // Incoming return from call to 0x381E at 0x381D // Inputs[2] // { // @3830 stack[-3] // @3830 stack[-1] // } 382F 5B JUMPDEST 3830 91 SWAP2 3831 50 POP 3832 60 PUSH1 0x14 3834 82 DUP3 3835 11 GT 3836 15 ISZERO 3837 15 ISZERO 3838 15 ISZERO 3839 61 PUSH2 0x3841 383C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3830 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x3841, if !!!(stack[-1] > 0x14) label_383D: // Incoming jump from 0x383C, if not !!!(stack[-1] > 0x14) // Inputs[1] { @3840 memory[0x00:0x00] } 383D 60 PUSH1 0x00 383F 80 DUP1 3840 FD *REVERT // Stack delta = +0 // Outputs[1] { @3840 revert(memory[0x00:0x00]); } // Block terminates label_3841: // Incoming jump from 0x383C, if !!!(stack[-1] > 0x14) 3841 5B JUMPDEST // Stack delta = +0 // Block continues label_3842: // Incoming jump from 0x3841 // Incoming jump from 0x380A, if !(stack[-2] > storage[0x11]) 3842 5B JUMPDEST 3843 50 POP // Stack delta = -1 // Block continues label_3844: // Incoming jump from 0x37E0, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00) // Incoming jump from 0x3843 // Inputs[1] { @3847 stack[-3] } 3844 5B JUMPDEST 3845 50 POP 3846 50 POP 3847 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_3848: // Incoming call from 0x2749, returns to 0x274A // Inputs[1] { @3856 msg.data.length } 3848 5B JUMPDEST 3849 60 PUSH1 0x00 384B 60 PUSH1 0x02 384D 60 PUSH1 0x04 384F 60 PUSH1 0x20 3851 82 DUP3 3852 02 MUL 3853 01 ADD 3854 60 PUSH1 0x00 3856 36 CALLDATASIZE 3857 90 SWAP1 3858 50 POP 3859 10 LT 385A 15 ISZERO 385B 15 ISZERO 385C 15 ISZERO 385D 61 PUSH2 0x3862 3860 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3849 stack[0] = 0x00 // @384B stack[1] = 0x02 // } // Block ends with conditional jump to 0x3862, if !!!(msg.data.length < 0x02 * 0x20 + 0x04) label_3861: // Incoming jump from 0x3860, if not !!!(msg.data.length < 0x02 * 0x20 + 0x04) 3861 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3861 assert(); } // Block terminates label_3862: // Incoming jump from 0x3860, if !!!(msg.data.length < 0x02 * 0x20 + 0x04) // Inputs[1] { @387B stack[-4] } 3862 5B JUMPDEST 3863 60 PUSH1 0x00 3865 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 387A 16 AND 387B 84 DUP5 387C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3891 16 AND 3892 14 EQ 3893 15 ISZERO 3894 15 ISZERO 3895 15 ISZERO 3896 61 PUSH2 0x389e 3899 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x389e, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_389A: // Incoming jump from 0x3899, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @389D memory[0x00:0x00] } 389A 60 PUSH1 0x00 389C 80 DUP1 389D FD *REVERT // Stack delta = +0 // Outputs[1] { @389D revert(memory[0x00:0x00]); } // Block terminates label_389E: // Incoming jump from 0x3899, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @389F stack[-3] // @38A4 msg.sender // @38DE memory[0x00:0x40] // @38DF storage[keccak256(memory[0x00:0x40])] // } 389E 5B JUMPDEST 389F 82 DUP3 38A0 60 PUSH1 0x04 38A2 60 PUSH1 0x00 38A4 33 CALLER 38A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 38BA 16 AND 38BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 38D0 16 AND 38D1 81 DUP2 38D2 52 MSTORE 38D3 60 PUSH1 0x20 38D5 01 ADD 38D6 90 SWAP1 38D7 81 DUP2 38D8 52 MSTORE 38D9 60 PUSH1 0x20 38DB 01 ADD 38DC 60 PUSH1 0x00 38DE 20 SHA3 38DF 54 SLOAD 38E0 10 LT 38E1 15 ISZERO 38E2 80 DUP1 38E3 15 ISZERO 38E4 61 PUSH2 0x38ed 38E7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @38D2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @38D8 memory[0x20:0x40] = 0x04 // @38E1 stack[0] = !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // } // Block ends with conditional jump to 0x38ed, if !!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_38E8: // Incoming jump from 0x38E7, if not !!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[1] { @38EB stack[-4] } 38E8 50 POP 38E9 60 PUSH1 0x00 38EB 83 DUP4 38EC 11 GT 38ED 5B JUMPDEST 38EE 15 ISZERO 38EF 15 ISZERO 38F0 61 PUSH2 0x38f8 38F3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x38f8, if !!(stack[-4] > 0x00) label_38F4: // Incoming jump from 0x38F3, if not !!stack[-1] // Incoming jump from 0x38F3, if not !!(stack[-4] > 0x00) // Inputs[1] { @38F7 memory[0x00:0x00] } 38F4 60 PUSH1 0x00 38F6 80 DUP1 38F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @38F7 revert(memory[0x00:0x00]); } // Block terminates label_38F8: // Incoming jump from 0x38F3, if !!stack[-1] // Incoming jump from 0x38F3, if !!(stack[-4] > 0x00) // Inputs[4] // { // @3900 msg.sender // @393A memory[0x00:0x40] // @393B storage[keccak256(memory[0x00:0x40])] // @393C stack[-3] // } 38F8 5B JUMPDEST 38F9 61 PUSH2 0x3941 38FC 60 PUSH1 0x04 38FE 60 PUSH1 0x00 3900 33 CALLER 3901 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3916 16 AND 3917 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 392C 16 AND 392D 81 DUP2 392E 52 MSTORE 392F 60 PUSH1 0x20 3931 01 ADD 3932 90 SWAP1 3933 81 DUP2 3934 52 MSTORE 3935 60 PUSH1 0x20 3937 01 ADD 3938 60 PUSH1 0x00 393A 20 SHA3 393B 54 SLOAD 393C 84 DUP5 393D 61 PUSH2 0x337e 3940 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @38F9 stack[0] = 0x3941 // @392E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @3934 memory[0x20:0x40] = 0x04 // @393B stack[1] = storage[keccak256(memory[0x00:0x40])] // @393C stack[2] = stack[-3] // } // Block ends with call to 0x337e, returns to 0x3941 label_3941: // Incoming return from call to 0x337E at 0x3940 // Inputs[7] // { // @3946 msg.sender // @3980 memory[0x00:0x40] // @3981 stack[-1] // @398C stack[-5] // @39C6 memory[0x00:0x40] // @39C7 storage[keccak256(memory[0x00:0x40])] // @39C8 stack[-4] // } 3941 5B JUMPDEST 3942 60 PUSH1 0x04 3944 60 PUSH1 0x00 3946 33 CALLER 3947 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 395C 16 AND 395D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3972 16 AND 3973 81 DUP2 3974 52 MSTORE 3975 60 PUSH1 0x20 3977 01 ADD 3978 90 SWAP1 3979 81 DUP2 397A 52 MSTORE 397B 60 PUSH1 0x20 397D 01 ADD 397E 60 PUSH1 0x00 3980 20 SHA3 3981 81 DUP2 3982 90 SWAP1 3983 55 SSTORE 3984 50 POP 3985 61 PUSH2 0x39cd 3988 60 PUSH1 0x04 398A 60 PUSH1 0x00 398C 86 DUP7 398D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39A2 16 AND 39A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39B8 16 AND 39B9 81 DUP2 39BA 52 MSTORE 39BB 60 PUSH1 0x20 39BD 01 ADD 39BE 90 SWAP1 39BF 81 DUP2 39C0 52 MSTORE 39C1 60 PUSH1 0x20 39C3 01 ADD 39C4 60 PUSH1 0x00 39C6 20 SHA3 39C7 54 SLOAD 39C8 84 DUP5 39C9 61 PUSH2 0x375e 39CC 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @3974 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @397A memory[0x20:0x40] = 0x04 // @3983 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3985 stack[-1] = 0x39cd // @39BA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @39C0 memory[0x20:0x40] = 0x04 // @39C7 stack[0] = storage[keccak256(memory[0x00:0x40])] // @39C8 stack[1] = stack[-4] // } // Block ends with call to 0x375e, returns to 0x39CD label_39CD: // Incoming return from call to 0x375E at 0x39CC // Inputs[10] // { // @39D2 stack[-5] // @3A0C memory[0x00:0x40] // @3A0D stack[-1] // @3A28 msg.sender // @3A60 stack[-4] // @3A63 memory[0x40:0x60] // @3A70 memory[0x40:0x60] // @3A75 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3A78 stack[-3] // @3A7B stack[-6] // } 39CD 5B JUMPDEST 39CE 60 PUSH1 0x04 39D0 60 PUSH1 0x00 39D2 86 DUP7 39D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39E8 16 AND 39E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39FE 16 AND 39FF 81 DUP2 3A00 52 MSTORE 3A01 60 PUSH1 0x20 3A03 01 ADD 3A04 90 SWAP1 3A05 81 DUP2 3A06 52 MSTORE 3A07 60 PUSH1 0x20 3A09 01 ADD 3A0A 60 PUSH1 0x00 3A0C 20 SHA3 3A0D 81 DUP2 3A0E 90 SWAP1 3A0F 55 SSTORE 3A10 50 POP 3A11 83 DUP4 3A12 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A27 16 AND 3A28 33 CALLER 3A29 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A3E 16 AND 3A3F 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3A60 85 DUP6 3A61 60 PUSH1 0x40 3A63 51 MLOAD 3A64 80 DUP1 3A65 82 DUP3 3A66 81 DUP2 3A67 52 MSTORE 3A68 60 PUSH1 0x20 3A6A 01 ADD 3A6B 91 SWAP2 3A6C 50 POP 3A6D 50 POP 3A6E 60 PUSH1 0x40 3A70 51 MLOAD 3A71 80 DUP1 3A72 91 SWAP2 3A73 03 SUB 3A74 90 SWAP1 3A75 A3 LOG3 3A76 60 PUSH1 0x01 3A78 91 SWAP2 3A79 50 POP 3A7A 50 POP 3A7B 92 SWAP3 3A7C 91 SWAP2 3A7D 50 POP 3A7E 50 POP 3A7F 56 *JUMP // Stack delta = -5 // Outputs[6] // { // @3A00 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3A06 memory[0x20:0x40] = 0x04 // @3A0F storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3A67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @3A75 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff]); // @3A7B stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_3A80: // Incoming call from 0x20EE, returns to 0x20EF // Incoming call from 0x0FDB, returns to 0x0FDC // Inputs[2] // { // @3A85 memory[0x40:0x60] // @3A92 stack[-1] // } 3A80 5B JUMPDEST 3A81 60 PUSH1 0x20 3A83 60 PUSH1 0x40 3A85 51 MLOAD 3A86 90 SWAP1 3A87 81 DUP2 3A88 01 ADD 3A89 60 PUSH1 0x40 3A8B 52 MSTORE 3A8C 80 DUP1 3A8D 60 PUSH1 0x00 3A8F 81 DUP2 3A90 52 MSTORE 3A91 50 POP 3A92 90 SWAP1 3A93 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @3A8B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @3A90 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @3A92 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] 3A94 00 *STOP 3A95 A1 LOG1 3A96 65 PUSH6 0x627a7a723058 3A9D 20 SHA3 3A9E B0 PUSH 3A9F 9C SWAP13 3AA0 07 SMOD 3AA1 BE BE 3AA2 A8 A8 3AA3 EF EF 3AA4 13 SGT 3AA5 92 SWAP3 3AA6 A0 LOG0 3AA7 BF BF 3AA8 2A 2A 3AA9 DF DF 3AAA A8 A8 3AAB 37 CALLDATACOPY 3AAC C4 C4 3AAD 7F PUSH32 0x67bdd590009dad20061e3715ac38b2a80029