Online Solidity Decompiler

« Decompile another contract

Address

0xb663b3a8492650dddcb9891faedff84a8bc9b6c3 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x095ea7b3 approve(address,uint256)
0x18160ddd totalSupply()
0x23b872dd transferFrom(address,address,uint256)
0x313ce567 decimals()
0x6bc344bc payforflag(string)
0x70a08231 balanceOf(address)
0x8da5cb5b owner()
0xa6f9dae1 changeOwner(address)
0xdd62ed3e allowance(address,address)

Internal Methods

approve(arg0, arg1) returns (r0)
totalSupply(arg0) returns (r0)
transferFrom(arg0, arg1, arg2) returns (r0)
decimals(arg0) returns (r0)
payforflag(arg0)
balanceOf(arg0) returns (r0)
owner(arg0) returns (r0)
changeOwner(arg0)
allowance(arg0, arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x095ea7b3) { // Dispatch table entry for approve(address,uint256) if (msg.value) { revert(memory[0x00:0x00]); } var var1 = 0x00de; var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var var3 = msg.data[0x24:0x44]; var1 = approve(var2, var3); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = !!var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x18160ddd) { // Dispatch table entry for totalSupply() if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x010b; var2 = totalSupply(); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var2; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else if (var0 == 0x23b872dd) { // Dispatch table entry for transferFrom(address,address,uint256) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0180; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = msg.data[0x44:0x64]; var1 = transferFrom(var2, var3, var4); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = !!var1; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var0 == 0x313ce567) { // Dispatch table entry for decimals() if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x01ad; var2 = decimals(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var2 & 0xff; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var0 == 0x6bc344bc) { // Dispatch table entry for payforflag(string) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0224; var temp8 = msg.data[0x04:0x24] + 0x04; var temp9 = msg.data[temp8:temp8 + 0x20]; var temp10 = memory[0x40:0x60]; memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp10:temp10 + 0x20] = temp9; memory[temp10 + 0x20:temp10 + 0x20 + temp9] = msg.data[temp8 + 0x20:temp8 + 0x20 + temp9]; var2 = temp10; payforflag(var2); stop(); } else if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x025d; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var1 = balanceOf(var2); var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = var1; var temp12 = memory[0x40:0x60]; return memory[temp12:temp12 + (temp11 + 0x20) - temp12]; } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0286; var2 = owner(); var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var temp14 = memory[0x40:0x60]; return memory[temp14:temp14 + (temp13 + 0x20) - temp14]; } else if (var0 == 0xa6f9dae1) { // Dispatch table entry for changeOwner(address) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x02ff; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; changeOwner(var2); stop(); } else if (var0 == 0xdd62ed3e) { // Dispatch table entry for allowance(address,address) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0357; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff; var1 = allowance(var2, var3); var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = var1; var temp16 = memory[0x40:0x60]; return memory[temp16:temp16 + (temp15 + 0x20) - temp16]; } else { revert(memory[0x00:0x00]); } } function approve(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x04; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; storage[keccak256(memory[0x00:0x40])] = arg1; return 0x01; } function totalSupply() returns (var r0) { return storage[0x01]; } function transferFrom(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = var0; if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff == 0x00) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])] < arg2) { revert(memory[0x00:0x00]); } var temp0 = arg1; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp1 = storage[keccak256(memory[0x00:0x40])]; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])] + arg2 <= temp1) { revert(memory[0x00:0x00]); } var temp2 = arg1; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp3 = storage[keccak256(memory[0x00:0x40])]; var temp4 = arg0; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp5 = storage[keccak256(memory[0x00:0x40])] + temp3; var1 = temp5; var temp6 = arg2; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp7 = keccak256(memory[0x00:0x40]); storage[temp7] = storage[temp7] - temp6; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp8 = keccak256(memory[0x00:0x40]); storage[temp8] = storage[temp8] + temp6; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; var temp9 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp9; var temp10 = keccak256(memory[0x00:0x40]); storage[temp10] = storage[temp10] - temp6; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp11 = storage[keccak256(memory[0x00:0x40])]; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])] + temp11 == var1) { return 0x01; } else { assert(); } } function decimals() returns (var r0) { return storage[0x00] & 0xff; } function payforflag(var arg0) { var var0 = 0x2710; var var1 = 0x0761; var var2 = msg.sender; var1 = balanceOf(var2); if (var1 < var0) { revert(memory[0x00:0x00]); } if (storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff != msg.sender) { revert(memory[0x00:0x00]); } var0 = 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10; var temp0 = arg0; var1 = temp0; var temp1 = memory[0x40:0x60]; var2 = temp1; var var3 = var2; var var4 = var3 + 0x20; var temp2 = var4 + 0x20; memory[var3:var3 + 0x20] = temp2 - var3; memory[temp2:temp2 + 0x20] = memory[var1:var1 + 0x20]; var var5 = temp2 + 0x20; var var7 = memory[var1:var1 + 0x20]; var var6 = var1 + 0x20; var var8 = var7; var var9 = var5; var var10 = var6; var var11 = 0x00; if (var11 >= var8) { label_0830: var temp3 = var7; var5 = temp3 + var5; var6 = temp3 & 0x1f; if (!var6) { var temp4 = var5; memory[var4:var4 + 0x20] = temp4 - var2; memory[temp4:temp4 + 0x20] = 0x06; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x20] = 0x627261766f210000000000000000000000000000000000000000000000000000; var temp6 = memory[0x40:0x60]; log(memory[temp6:temp6 + (temp5 + 0x20) - temp6], [stack[-7]]); return; } else { var temp7 = var6; var temp8 = var5 - temp7; memory[temp8:temp8 + 0x20] = ~(0x0100 ** (0x20 - temp7) - 0x01) & memory[temp8:temp8 + 0x20]; var temp9 = temp8 + 0x20; memory[var4:var4 + 0x20] = temp9 - var2; memory[temp9:temp9 + 0x20] = 0x06; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = 0x627261766f210000000000000000000000000000000000000000000000000000; var temp11 = memory[0x40:0x60]; log(memory[temp11:temp11 + (temp10 + 0x20) - temp11], [stack[-7]]); return; } } else { label_081E: var temp12 = var11; memory[var9 + temp12:var9 + temp12 + 0x20] = memory[var10 + temp12:var10 + temp12 + 0x20]; var11 = temp12 + 0x20; if (var11 >= var8) { goto label_0830; } else { goto label_081E; } } } function balanceOf(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; return storage[keccak256(memory[0x00:0x40])]; } function owner() returns (var r0) { return storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff; } function changeOwner(var arg0) { if (tx.origin == msg.sender) { return; } storage[0x02] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x02] & ~0xffffffffffffffffffffffffffffffffffffffff); } function allowance(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])]; } }

Disassembly

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 0x0099 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x0099, 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 63 PUSH4 0x095ea7b3 003C 14 EQ 003D 61 PUSH2 0x009e 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x009e, if 0x095ea7b3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x095ea7b3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x18160ddd 0047 14 EQ 0048 61 PUSH2 0x00f8 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f8, if 0x18160ddd == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x18160ddd == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x23b872dd 0052 14 EQ 0053 61 PUSH2 0x0121 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0121, if 0x23b872dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x23b872dd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x313ce567 005D 14 EQ 005E 61 PUSH2 0x019a 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019a, if 0x313ce567 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x313ce567 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x6bc344bc 0068 14 EQ 0069 61 PUSH2 0x01c9 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c9, if 0x6bc344bc == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x6bc344bc == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x70a08231 0073 14 EQ 0074 61 PUSH2 0x0226 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0226, if 0x70a08231 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x70a08231 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x8da5cb5b 007E 14 EQ 007F 61 PUSH2 0x0273 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0273, if 0x8da5cb5b == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0xa6f9dae1 0089 14 EQ 008A 61 PUSH2 0x02c8 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c8, if 0xa6f9dae1 == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0xa6f9dae1 == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0xdd62ed3e 0094 14 EQ 0095 61 PUSH2 0x0301 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0301, if 0xdd62ed3e == stack[-1] label_0099: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0098, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @009D memory[0x00:0x00] } 0099 5B JUMPDEST 009A 60 PUSH1 0x00 009C 80 DUP1 009D FD *REVERT // Stack delta = +0 // Outputs[1] { @009D revert(memory[0x00:0x00]); } // Block terminates label_009E: // Incoming jump from 0x0040, if 0x095ea7b3 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @009F msg.value } 009E 5B JUMPDEST 009F 34 CALLVALUE 00A0 15 ISZERO 00A1 61 PUSH2 0x00a9 00A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a9, if !msg.value label_00A5: // Incoming jump from 0x00A4, if not !msg.value // Inputs[1] { @00A8 memory[0x00:0x00] } 00A5 60 PUSH1 0x00 00A7 80 DUP1 00A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A8 revert(memory[0x00:0x00]); } // Block terminates label_00A9: // Incoming jump from 0x00A4, if !msg.value // Inputs[2] // { // @00B1 msg.data[0x04:0x24] // @00D0 msg.data[0x24:0x44] // } 00A9 5B JUMPDEST 00AA 61 PUSH2 0x00de 00AD 60 PUSH1 0x04 00AF 80 DUP1 00B0 80 DUP1 00B1 35 CALLDATALOAD 00B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00C7 16 AND 00C8 90 SWAP1 00C9 60 PUSH1 0x20 00CB 01 ADD 00CC 90 SWAP1 00CD 91 SWAP2 00CE 90 SWAP1 00CF 80 DUP1 00D0 35 CALLDATALOAD 00D1 90 SWAP1 00D2 60 PUSH1 0x20 00D4 01 ADD 00D5 90 SWAP1 00D6 91 SWAP2 00D7 90 SWAP1 00D8 50 POP 00D9 50 POP 00DA 61 PUSH2 0x036d 00DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @00AA stack[0] = 0x00de // @00CD stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @00D6 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x036d, returns to 0x00DE label_00DE: // Incoming return from call to 0x036D at 0x00DD // Inputs[4] // { // @00E1 memory[0x40:0x60] // @00E3 stack[-1] // @00F2 memory[0x40:0x60] // @00F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00DE 5B JUMPDEST 00DF 60 PUSH1 0x40 00E1 51 MLOAD 00E2 80 DUP1 00E3 82 DUP3 00E4 15 ISZERO 00E5 15 ISZERO 00E6 15 ISZERO 00E7 15 ISZERO 00E8 81 DUP2 00E9 52 MSTORE 00EA 60 PUSH1 0x20 00EC 01 ADD 00ED 91 SWAP2 00EE 50 POP 00EF 50 POP 00F0 60 PUSH1 0x40 00F2 51 MLOAD 00F3 80 DUP1 00F4 91 SWAP2 00F5 03 SUB 00F6 90 SWAP1 00F7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @00F7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00F8: // Incoming jump from 0x004B, if 0x18160ddd == stack[-1] // Inputs[1] { @00F9 msg.value } 00F8 5B JUMPDEST 00F9 34 CALLVALUE 00FA 15 ISZERO 00FB 61 PUSH2 0x0103 00FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0103, if !msg.value label_00FF: // Incoming jump from 0x00FE, if not !msg.value // Inputs[1] { @0102 memory[0x00:0x00] } 00FF 60 PUSH1 0x00 0101 80 DUP1 0102 FD *REVERT // Stack delta = +0 // Outputs[1] { @0102 revert(memory[0x00:0x00]); } // Block terminates label_0103: // Incoming jump from 0x00FE, if !msg.value 0103 5B JUMPDEST 0104 61 PUSH2 0x010b 0107 61 PUSH2 0x03fa 010A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0104 stack[0] = 0x010b } // Block ends with call to 0x03fa, returns to 0x010B label_010B: // Incoming return from call to 0x03FA at 0x010A // Inputs[4] // { // @010E memory[0x40:0x60] // @0110 stack[-1] // @011B memory[0x40:0x60] // @0120 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 010B 5B JUMPDEST 010C 60 PUSH1 0x40 010E 51 MLOAD 010F 80 DUP1 0110 82 DUP3 0111 81 DUP2 0112 52 MSTORE 0113 60 PUSH1 0x20 0115 01 ADD 0116 91 SWAP2 0117 50 POP 0118 50 POP 0119 60 PUSH1 0x40 011B 51 MLOAD 011C 80 DUP1 011D 91 SWAP2 011E 03 SUB 011F 90 SWAP1 0120 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0112 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0120 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0121: // Incoming jump from 0x0056, if 0x23b872dd == stack[-1] // Inputs[1] { @0122 msg.value } 0121 5B JUMPDEST 0122 34 CALLVALUE 0123 15 ISZERO 0124 61 PUSH2 0x012c 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012c, if !msg.value label_0128: // Incoming jump from 0x0127, if not !msg.value // Inputs[1] { @012B memory[0x00:0x00] } 0128 60 PUSH1 0x00 012A 80 DUP1 012B FD *REVERT // Stack delta = +0 // Outputs[1] { @012B revert(memory[0x00:0x00]); } // Block terminates label_012C: // Incoming jump from 0x0127, if !msg.value // Inputs[3] // { // @0134 msg.data[0x04:0x24] // @0153 msg.data[0x24:0x44] // @0172 msg.data[0x44:0x64] // } 012C 5B JUMPDEST 012D 61 PUSH2 0x0180 0130 60 PUSH1 0x04 0132 80 DUP1 0133 80 DUP1 0134 35 CALLDATALOAD 0135 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 014A 16 AND 014B 90 SWAP1 014C 60 PUSH1 0x20 014E 01 ADD 014F 90 SWAP1 0150 91 SWAP2 0151 90 SWAP1 0152 80 DUP1 0153 35 CALLDATALOAD 0154 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0169 16 AND 016A 90 SWAP1 016B 60 PUSH1 0x20 016D 01 ADD 016E 90 SWAP1 016F 91 SWAP2 0170 90 SWAP1 0171 80 DUP1 0172 35 CALLDATALOAD 0173 90 SWAP1 0174 60 PUSH1 0x20 0176 01 ADD 0177 90 SWAP1 0178 91 SWAP2 0179 90 SWAP1 017A 50 POP 017B 50 POP 017C 61 PUSH2 0x0400 017F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @012D stack[0] = 0x0180 // @0150 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @016F stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @0178 stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x0400, returns to 0x0180 label_0180: // Incoming return from call to 0x0400 at 0x017F // Inputs[4] // { // @0183 memory[0x40:0x60] // @0185 stack[-1] // @0194 memory[0x40:0x60] // @0199 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0180 5B JUMPDEST 0181 60 PUSH1 0x40 0183 51 MLOAD 0184 80 DUP1 0185 82 DUP3 0186 15 ISZERO 0187 15 ISZERO 0188 15 ISZERO 0189 15 ISZERO 018A 81 DUP2 018B 52 MSTORE 018C 60 PUSH1 0x20 018E 01 ADD 018F 91 SWAP2 0190 50 POP 0191 50 POP 0192 60 PUSH1 0x40 0194 51 MLOAD 0195 80 DUP1 0196 91 SWAP2 0197 03 SUB 0198 90 SWAP1 0199 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @018B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0199 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_019A: // Incoming jump from 0x0061, if 0x313ce567 == stack[-1] // Inputs[1] { @019B msg.value } 019A 5B JUMPDEST 019B 34 CALLVALUE 019C 15 ISZERO 019D 61 PUSH2 0x01a5 01A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a5, if !msg.value label_01A1: // Incoming jump from 0x01A0, if not !msg.value // Inputs[1] { @01A4 memory[0x00:0x00] } 01A1 60 PUSH1 0x00 01A3 80 DUP1 01A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A4 revert(memory[0x00:0x00]); } // Block terminates label_01A5: // Incoming jump from 0x01A0, if !msg.value 01A5 5B JUMPDEST 01A6 61 PUSH2 0x01ad 01A9 61 PUSH2 0x0743 01AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @01A6 stack[0] = 0x01ad } // Block ends with call to 0x0743, returns to 0x01AD label_01AD: // Incoming return from call to 0x0743 at 0x01AC // Inputs[4] // { // @01B0 memory[0x40:0x60] // @01B2 stack[-1] // @01C3 memory[0x40:0x60] // @01C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01AD 5B JUMPDEST 01AE 60 PUSH1 0x40 01B0 51 MLOAD 01B1 80 DUP1 01B2 82 DUP3 01B3 60 PUSH1 0xff 01B5 16 AND 01B6 60 PUSH1 0xff 01B8 16 AND 01B9 81 DUP2 01BA 52 MSTORE 01BB 60 PUSH1 0x20 01BD 01 ADD 01BE 91 SWAP2 01BF 50 POP 01C0 50 POP 01C1 60 PUSH1 0x40 01C3 51 MLOAD 01C4 80 DUP1 01C5 91 SWAP2 01C6 03 SUB 01C7 90 SWAP1 01C8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @01C8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01C9: // Incoming jump from 0x006C, if 0x6bc344bc == stack[-1] // Inputs[1] { @01CA msg.value } 01C9 5B JUMPDEST 01CA 34 CALLVALUE 01CB 15 ISZERO 01CC 61 PUSH2 0x01d4 01CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d4, if !msg.value label_01D0: // Incoming jump from 0x01CF, if not !msg.value // Inputs[1] { @01D3 memory[0x00:0x00] } 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming jump from 0x01CF, if !msg.value // Inputs[4] // { // @01DC msg.data[0x04:0x24] // @01E5 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @01FB memory[0x40:0x60] // @0212 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 01D4 5B JUMPDEST 01D5 61 PUSH2 0x0224 01D8 60 PUSH1 0x04 01DA 80 DUP1 01DB 80 DUP1 01DC 35 CALLDATALOAD 01DD 90 SWAP1 01DE 60 PUSH1 0x20 01E0 01 ADD 01E1 90 SWAP1 01E2 82 DUP3 01E3 01 ADD 01E4 80 DUP1 01E5 35 CALLDATALOAD 01E6 90 SWAP1 01E7 60 PUSH1 0x20 01E9 01 ADD 01EA 90 SWAP1 01EB 80 DUP1 01EC 80 DUP1 01ED 60 PUSH1 0x1f 01EF 01 ADD 01F0 60 PUSH1 0x20 01F2 80 DUP1 01F3 91 SWAP2 01F4 04 DIV 01F5 02 MUL 01F6 60 PUSH1 0x20 01F8 01 ADD 01F9 60 PUSH1 0x40 01FB 51 MLOAD 01FC 90 SWAP1 01FD 81 DUP2 01FE 01 ADD 01FF 60 PUSH1 0x40 0201 52 MSTORE 0202 80 DUP1 0203 93 SWAP4 0204 92 SWAP3 0205 91 SWAP2 0206 90 SWAP1 0207 81 DUP2 0208 81 DUP2 0209 52 MSTORE 020A 60 PUSH1 0x20 020C 01 ADD 020D 83 DUP4 020E 83 DUP4 020F 80 DUP1 0210 82 DUP3 0211 84 DUP5 0212 37 CALLDATACOPY 0213 82 DUP3 0214 01 ADD 0215 91 SWAP2 0216 50 POP 0217 50 POP 0218 50 POP 0219 50 POP 021A 50 POP 021B 50 POP 021C 91 SWAP2 021D 90 SWAP1 021E 50 POP 021F 50 POP 0220 61 PUSH2 0x0755 0223 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @01D5 stack[0] = 0x0224 // @0201 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @0209 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0212 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @021C stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x0755, returns to 0x0224 label_0224: // Incoming return from call to 0x0755 at 0x0223 0224 5B JUMPDEST 0225 00 *STOP // Stack delta = +0 // Outputs[1] { @0225 stop(); } // Block terminates label_0226: // Incoming jump from 0x0077, if 0x70a08231 == stack[-1] // Inputs[1] { @0227 msg.value } 0226 5B JUMPDEST 0227 34 CALLVALUE 0228 15 ISZERO 0229 61 PUSH2 0x0231 022C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0231, if !msg.value label_022D: // Incoming jump from 0x022C, if not !msg.value // Inputs[1] { @0230 memory[0x00:0x00] } 022D 60 PUSH1 0x00 022F 80 DUP1 0230 FD *REVERT // Stack delta = +0 // Outputs[1] { @0230 revert(memory[0x00:0x00]); } // Block terminates label_0231: // Incoming jump from 0x022C, if !msg.value // Inputs[1] { @0239 msg.data[0x04:0x24] } 0231 5B JUMPDEST 0232 61 PUSH2 0x025d 0235 60 PUSH1 0x04 0237 80 DUP1 0238 80 DUP1 0239 35 CALLDATALOAD 023A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 024F 16 AND 0250 90 SWAP1 0251 60 PUSH1 0x20 0253 01 ADD 0254 90 SWAP1 0255 91 SWAP2 0256 90 SWAP1 0257 50 POP 0258 50 POP 0259 61 PUSH2 0x08a2 025C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0232 stack[0] = 0x025d // @0255 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x08a2, returns to 0x025D label_025D: // Incoming return from call to 0x08A2 at 0x025C // Inputs[4] // { // @0260 memory[0x40:0x60] // @0262 stack[-1] // @026D memory[0x40:0x60] // @0272 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 025D 5B JUMPDEST 025E 60 PUSH1 0x40 0260 51 MLOAD 0261 80 DUP1 0262 82 DUP3 0263 81 DUP2 0264 52 MSTORE 0265 60 PUSH1 0x20 0267 01 ADD 0268 91 SWAP2 0269 50 POP 026A 50 POP 026B 60 PUSH1 0x40 026D 51 MLOAD 026E 80 DUP1 026F 91 SWAP2 0270 03 SUB 0271 90 SWAP1 0272 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0264 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0272 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0273: // Incoming jump from 0x0082, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0274 msg.value } 0273 5B JUMPDEST 0274 34 CALLVALUE 0275 15 ISZERO 0276 61 PUSH2 0x027e 0279 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if !msg.value label_027A: // Incoming jump from 0x0279, if not !msg.value // Inputs[1] { @027D memory[0x00:0x00] } 027A 60 PUSH1 0x00 027C 80 DUP1 027D FD *REVERT // Stack delta = +0 // Outputs[1] { @027D revert(memory[0x00:0x00]); } // Block terminates label_027E: // Incoming jump from 0x0279, if !msg.value 027E 5B JUMPDEST 027F 61 PUSH2 0x0286 0282 61 PUSH2 0x08eb 0285 56 *JUMP // Stack delta = +1 // Outputs[1] { @027F stack[0] = 0x0286 } // Block ends with call to 0x08eb, returns to 0x0286 label_0286: // Incoming return from call to 0x08EB at 0x0285 // Inputs[4] // { // @0289 memory[0x40:0x60] // @028B stack[-1] // @02C2 memory[0x40:0x60] // @02C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0286 5B JUMPDEST 0287 60 PUSH1 0x40 0289 51 MLOAD 028A 80 DUP1 028B 82 DUP3 028C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02A1 16 AND 02A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02B7 16 AND 02B8 81 DUP2 02B9 52 MSTORE 02BA 60 PUSH1 0x20 02BC 01 ADD 02BD 91 SWAP2 02BE 50 POP 02BF 50 POP 02C0 60 PUSH1 0x40 02C2 51 MLOAD 02C3 80 DUP1 02C4 91 SWAP2 02C5 03 SUB 02C6 90 SWAP1 02C7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @02C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02C8: // Incoming jump from 0x008D, if 0xa6f9dae1 == stack[-1] // Inputs[1] { @02C9 msg.value } 02C8 5B JUMPDEST 02C9 34 CALLVALUE 02CA 15 ISZERO 02CB 61 PUSH2 0x02d3 02CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d3, if !msg.value label_02CF: // Incoming jump from 0x02CE, if not !msg.value // Inputs[1] { @02D2 memory[0x00:0x00] } 02CF 60 PUSH1 0x00 02D1 80 DUP1 02D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D2 revert(memory[0x00:0x00]); } // Block terminates label_02D3: // Incoming jump from 0x02CE, if !msg.value // Inputs[1] { @02DB msg.data[0x04:0x24] } 02D3 5B JUMPDEST 02D4 61 PUSH2 0x02ff 02D7 60 PUSH1 0x04 02D9 80 DUP1 02DA 80 DUP1 02DB 35 CALLDATALOAD 02DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02F1 16 AND 02F2 90 SWAP1 02F3 60 PUSH1 0x20 02F5 01 ADD 02F6 90 SWAP1 02F7 91 SWAP2 02F8 90 SWAP1 02F9 50 POP 02FA 50 POP 02FB 61 PUSH2 0x0911 02FE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02D4 stack[0] = 0x02ff // @02F7 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0911, returns to 0x02FF label_02FF: // Incoming return from call to 0x0911 at 0x02FE 02FF 5B JUMPDEST 0300 00 *STOP // Stack delta = +0 // Outputs[1] { @0300 stop(); } // Block terminates label_0301: // Incoming jump from 0x0098, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0302 msg.value } 0301 5B JUMPDEST 0302 34 CALLVALUE 0303 15 ISZERO 0304 61 PUSH2 0x030c 0307 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030c, if !msg.value label_0308: // Incoming jump from 0x0307, if not !msg.value // Inputs[1] { @030B memory[0x00:0x00] } 0308 60 PUSH1 0x00 030A 80 DUP1 030B FD *REVERT // Stack delta = +0 // Outputs[1] { @030B revert(memory[0x00:0x00]); } // Block terminates label_030C: // Incoming jump from 0x0307, if !msg.value // Inputs[2] // { // @0314 msg.data[0x04:0x24] // @0333 msg.data[0x24:0x44] // } 030C 5B JUMPDEST 030D 61 PUSH2 0x0357 0310 60 PUSH1 0x04 0312 80 DUP1 0313 80 DUP1 0314 35 CALLDATALOAD 0315 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 032A 16 AND 032B 90 SWAP1 032C 60 PUSH1 0x20 032E 01 ADD 032F 90 SWAP1 0330 91 SWAP2 0331 90 SWAP1 0332 80 DUP1 0333 35 CALLDATALOAD 0334 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0349 16 AND 034A 90 SWAP1 034B 60 PUSH1 0x20 034D 01 ADD 034E 90 SWAP1 034F 91 SWAP2 0350 90 SWAP1 0351 50 POP 0352 50 POP 0353 61 PUSH2 0x098b 0356 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @030D stack[0] = 0x0357 // @0330 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @034F stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x098b, returns to 0x0357 label_0357: // Incoming return from call to 0x098B at 0x0356 // Inputs[4] // { // @035A memory[0x40:0x60] // @035C stack[-1] // @0367 memory[0x40:0x60] // @036C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0357 5B JUMPDEST 0358 60 PUSH1 0x40 035A 51 MLOAD 035B 80 DUP1 035C 82 DUP3 035D 81 DUP2 035E 52 MSTORE 035F 60 PUSH1 0x20 0361 01 ADD 0362 91 SWAP2 0363 50 POP 0364 50 POP 0365 60 PUSH1 0x40 0367 51 MLOAD 0368 80 DUP1 0369 91 SWAP2 036A 03 SUB 036B 90 SWAP1 036C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @035E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @036C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_036D: // Incoming call from 0x00DD, returns to 0x00DE // Inputs[6] // { // @0370 stack[-1] // @0375 msg.sender // @03AF memory[0x00:0x40] // @03B2 stack[-2] // @03EC memory[0x00:0x40] // @03F5 stack[-3] // } 036D 5B JUMPDEST 036E 60 PUSH1 0x00 0370 81 DUP2 0371 60 PUSH1 0x04 0373 60 PUSH1 0x00 0375 33 CALLER 0376 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 038B 16 AND 038C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03A1 16 AND 03A2 81 DUP2 03A3 52 MSTORE 03A4 60 PUSH1 0x20 03A6 01 ADD 03A7 90 SWAP1 03A8 81 DUP2 03A9 52 MSTORE 03AA 60 PUSH1 0x20 03AC 01 ADD 03AD 60 PUSH1 0x00 03AF 20 SHA3 03B0 60 PUSH1 0x00 03B2 85 DUP6 03B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C8 16 AND 03C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03DE 16 AND 03DF 81 DUP2 03E0 52 MSTORE 03E1 60 PUSH1 0x20 03E3 01 ADD 03E4 90 SWAP1 03E5 81 DUP2 03E6 52 MSTORE 03E7 60 PUSH1 0x20 03E9 01 ADD 03EA 60 PUSH1 0x00 03EC 20 SHA3 03ED 81 DUP2 03EE 90 SWAP1 03EF 55 SSTORE 03F0 50 POP 03F1 60 PUSH1 0x01 03F3 90 SWAP1 03F4 50 POP 03F5 92 SWAP3 03F6 91 SWAP2 03F7 50 POP 03F8 50 POP 03F9 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @03A3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @03A9 memory[0x20:0x40] = 0x04 // @03E0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @03E6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03EF storage[keccak256(memory[0x00:0x40])] = stack[-1] // @03F5 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_03FA: // Incoming call from 0x010A, returns to 0x010B // Inputs[2] // { // @03FD storage[0x01] // @03FE stack[-1] // } 03FA 5B JUMPDEST 03FB 60 PUSH1 0x01 03FD 54 SLOAD 03FE 81 DUP2 03FF 56 *JUMP // Stack delta = +1 // Outputs[1] { @03FD stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0400: // Incoming call from 0x017F, returns to 0x0180 // Inputs[1] { @0406 stack[-2] } 0400 5B JUMPDEST 0401 60 PUSH1 0x00 0403 80 DUP1 0404 60 PUSH1 0x00 0406 84 DUP5 0407 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041C 16 AND 041D 14 EQ 041E 15 ISZERO 041F 15 ISZERO 0420 15 ISZERO 0421 61 PUSH2 0x0429 0424 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0401 stack[0] = 0x00 // @0403 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0429, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0x00) label_0425: // Incoming jump from 0x0424, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0x00) // Inputs[1] { @0428 memory[0x00:0x00] } 0425 60 PUSH1 0x00 0427 80 DUP1 0428 FD *REVERT // Stack delta = +0 // Outputs[1] { @0428 revert(memory[0x00:0x00]); } // Block terminates label_0429: // Incoming jump from 0x0424, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0x00) // Inputs[4] // { // @042A stack[-3] // @042F stack[-5] // @0469 memory[0x00:0x40] // @046A storage[keccak256(memory[0x00:0x40])] // } 0429 5B JUMPDEST 042A 82 DUP3 042B 60 PUSH1 0x03 042D 60 PUSH1 0x00 042F 87 DUP8 0430 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0445 16 AND 0446 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 045B 16 AND 045C 81 DUP2 045D 52 MSTORE 045E 60 PUSH1 0x20 0460 01 ADD 0461 90 SWAP1 0462 81 DUP2 0463 52 MSTORE 0464 60 PUSH1 0x20 0466 01 ADD 0467 60 PUSH1 0x00 0469 20 SHA3 046A 54 SLOAD 046B 10 LT 046C 15 ISZERO 046D 15 ISZERO 046E 15 ISZERO 046F 61 PUSH2 0x0477 0472 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @045D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0463 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0477, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_0473: // Incoming jump from 0x0472, if not !!!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[1] { @0476 memory[0x00:0x00] } 0473 60 PUSH1 0x00 0475 80 DUP1 0476 FD *REVERT // Stack delta = +0 // Outputs[1] { @0476 revert(memory[0x00:0x00]); } // Block terminates label_0477: // Incoming jump from 0x0472, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[6] // { // @047C stack[-4] // @04B6 memory[0x00:0x40] // @04B7 storage[keccak256(memory[0x00:0x40])] // @04B8 stack[-3] // @04F7 memory[0x00:0x40] // @04F8 storage[keccak256(memory[0x00:0x40])] // } 0477 5B JUMPDEST 0478 60 PUSH1 0x03 047A 60 PUSH1 0x00 047C 85 DUP6 047D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0492 16 AND 0493 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04A8 16 AND 04A9 81 DUP2 04AA 52 MSTORE 04AB 60 PUSH1 0x20 04AD 01 ADD 04AE 90 SWAP1 04AF 81 DUP2 04B0 52 MSTORE 04B1 60 PUSH1 0x20 04B3 01 ADD 04B4 60 PUSH1 0x00 04B6 20 SHA3 04B7 54 SLOAD 04B8 83 DUP4 04B9 60 PUSH1 0x03 04BB 60 PUSH1 0x00 04BD 87 DUP8 04BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04D3 16 AND 04D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04E9 16 AND 04EA 81 DUP2 04EB 52 MSTORE 04EC 60 PUSH1 0x20 04EE 01 ADD 04EF 90 SWAP1 04F0 81 DUP2 04F1 52 MSTORE 04F2 60 PUSH1 0x20 04F4 01 ADD 04F5 60 PUSH1 0x00 04F7 20 SHA3 04F8 54 SLOAD 04F9 01 ADD 04FA 11 GT 04FB 15 ISZERO 04FC 15 ISZERO 04FD 61 PUSH2 0x0505 0500 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @04AA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @04B0 memory[0x20:0x40] = 0x03 // @04EB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @04F1 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0505, if !!(storage[keccak256(memory[0x00:0x40])] + stack[-3] > storage[keccak256(memory[0x00:0x40])]) label_0501: // Incoming jump from 0x0500, if not !!(storage[keccak256(memory[0x00:0x40])] + stack[-3] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0504 memory[0x00:0x00] } 0501 60 PUSH1 0x00 0503 80 DUP1 0504 FD *REVERT // Stack delta = +0 // Outputs[1] { @0504 revert(memory[0x00:0x00]); } // Block terminates label_0505: // Incoming jump from 0x0500, if !!(storage[keccak256(memory[0x00:0x40])] + stack[-3] > storage[keccak256(memory[0x00:0x40])]) // Inputs[20] // { // @050A stack[-4] // @0544 memory[0x00:0x40] // @0545 storage[keccak256(memory[0x00:0x40])] // @054A stack[-5] // @0584 memory[0x00:0x40] // @0585 storage[keccak256(memory[0x00:0x40])] // @0587 stack[-1] // @0589 stack[-3] // @05C8 memory[0x00:0x40] // @05CD storage[keccak256(memory[0x00:0x40])] // @0615 memory[0x00:0x40] // @061A storage[keccak256(memory[0x00:0x40])] // @0662 memory[0x00:0x40] // @0665 msg.sender // @069F memory[0x00:0x40] // @06A4 storage[keccak256(memory[0x00:0x40])] // @06EC memory[0x00:0x40] // @06ED storage[keccak256(memory[0x00:0x40])] // @072C memory[0x00:0x40] // @072D storage[keccak256(memory[0x00:0x40])] // } 0505 5B JUMPDEST 0506 60 PUSH1 0x03 0508 60 PUSH1 0x00 050A 85 DUP6 050B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0520 16 AND 0521 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0536 16 AND 0537 81 DUP2 0538 52 MSTORE 0539 60 PUSH1 0x20 053B 01 ADD 053C 90 SWAP1 053D 81 DUP2 053E 52 MSTORE 053F 60 PUSH1 0x20 0541 01 ADD 0542 60 PUSH1 0x00 0544 20 SHA3 0545 54 SLOAD 0546 60 PUSH1 0x03 0548 60 PUSH1 0x00 054A 87 DUP8 054B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0560 16 AND 0561 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0576 16 AND 0577 81 DUP2 0578 52 MSTORE 0579 60 PUSH1 0x20 057B 01 ADD 057C 90 SWAP1 057D 81 DUP2 057E 52 MSTORE 057F 60 PUSH1 0x20 0581 01 ADD 0582 60 PUSH1 0x00 0584 20 SHA3 0585 54 SLOAD 0586 01 ADD 0587 90 SWAP1 0588 50 POP 0589 82 DUP3 058A 60 PUSH1 0x03 058C 60 PUSH1 0x00 058E 87 DUP8 058F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05A4 16 AND 05A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05BA 16 AND 05BB 81 DUP2 05BC 52 MSTORE 05BD 60 PUSH1 0x20 05BF 01 ADD 05C0 90 SWAP1 05C1 81 DUP2 05C2 52 MSTORE 05C3 60 PUSH1 0x20 05C5 01 ADD 05C6 60 PUSH1 0x00 05C8 20 SHA3 05C9 60 PUSH1 0x00 05CB 82 DUP3 05CC 82 DUP3 05CD 54 SLOAD 05CE 03 SUB 05CF 92 SWAP3 05D0 50 POP 05D1 50 POP 05D2 81 DUP2 05D3 90 SWAP1 05D4 55 SSTORE 05D5 50 POP 05D6 82 DUP3 05D7 60 PUSH1 0x03 05D9 60 PUSH1 0x00 05DB 86 DUP7 05DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F1 16 AND 05F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0607 16 AND 0608 81 DUP2 0609 52 MSTORE 060A 60 PUSH1 0x20 060C 01 ADD 060D 90 SWAP1 060E 81 DUP2 060F 52 MSTORE 0610 60 PUSH1 0x20 0612 01 ADD 0613 60 PUSH1 0x00 0615 20 SHA3 0616 60 PUSH1 0x00 0618 82 DUP3 0619 82 DUP3 061A 54 SLOAD 061B 01 ADD 061C 92 SWAP3 061D 50 POP 061E 50 POP 061F 81 DUP2 0620 90 SWAP1 0621 55 SSTORE 0622 50 POP 0623 82 DUP3 0624 60 PUSH1 0x04 0626 60 PUSH1 0x00 0628 87 DUP8 0629 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 063E 16 AND 063F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0654 16 AND 0655 81 DUP2 0656 52 MSTORE 0657 60 PUSH1 0x20 0659 01 ADD 065A 90 SWAP1 065B 81 DUP2 065C 52 MSTORE 065D 60 PUSH1 0x20 065F 01 ADD 0660 60 PUSH1 0x00 0662 20 SHA3 0663 60 PUSH1 0x00 0665 33 CALLER 0666 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 067B 16 AND 067C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0691 16 AND 0692 81 DUP2 0693 52 MSTORE 0694 60 PUSH1 0x20 0696 01 ADD 0697 90 SWAP1 0698 81 DUP2 0699 52 MSTORE 069A 60 PUSH1 0x20 069C 01 ADD 069D 60 PUSH1 0x00 069F 20 SHA3 06A0 60 PUSH1 0x00 06A2 82 DUP3 06A3 82 DUP3 06A4 54 SLOAD 06A5 03 SUB 06A6 92 SWAP3 06A7 50 POP 06A8 50 POP 06A9 81 DUP2 06AA 90 SWAP1 06AB 55 SSTORE 06AC 50 POP 06AD 80 DUP1 06AE 60 PUSH1 0x03 06B0 60 PUSH1 0x00 06B2 86 DUP7 06B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C8 16 AND 06C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06DE 16 AND 06DF 81 DUP2 06E0 52 MSTORE 06E1 60 PUSH1 0x20 06E3 01 ADD 06E4 90 SWAP1 06E5 81 DUP2 06E6 52 MSTORE 06E7 60 PUSH1 0x20 06E9 01 ADD 06EA 60 PUSH1 0x00 06EC 20 SHA3 06ED 54 SLOAD 06EE 60 PUSH1 0x03 06F0 60 PUSH1 0x00 06F2 88 DUP9 06F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0708 16 AND 0709 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 071E 16 AND 071F 81 DUP2 0720 52 MSTORE 0721 60 PUSH1 0x20 0723 01 ADD 0724 90 SWAP1 0725 81 DUP2 0726 52 MSTORE 0727 60 PUSH1 0x20 0729 01 ADD 072A 60 PUSH1 0x00 072C 20 SHA3 072D 54 SLOAD 072E 01 ADD 072F 14 EQ 0730 15 ISZERO 0731 15 ISZERO 0732 61 PUSH2 0x0737 0735 57 *JUMPI // Stack delta = +0 // Outputs[20] // { // @0538 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @053E memory[0x20:0x40] = 0x03 // @0578 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @057E memory[0x20:0x40] = 0x03 // @0587 stack[-1] = storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])] // @05BC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @05C2 memory[0x20:0x40] = 0x03 // @05D4 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-3] // @0609 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @060F memory[0x20:0x40] = 0x03 // @0621 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-3] // @0656 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @065C memory[0x20:0x40] = 0x04 // @0693 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0699 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06AB storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-3] // @06E0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @06E6 memory[0x20:0x40] = 0x03 // @0720 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0726 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0737, if !!(storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])]) label_0736: // Incoming jump from 0x0735, if not !!(storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])]) 0736 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0736 assert(); } // Block terminates label_0737: // Incoming jump from 0x0735, if !!(storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])] == storage[keccak256(memory[0x00:0x40])] + storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @073A stack[-2] // @073D stack[-6] // @073E stack[-5] // } 0737 5B JUMPDEST 0738 60 PUSH1 0x01 073A 91 SWAP2 073B 50 POP 073C 50 POP 073D 93 SWAP4 073E 92 SWAP3 073F 50 POP 0740 50 POP 0741 50 POP 0742 56 *JUMP // Stack delta = -5 // Outputs[1] { @073D stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0743: // Incoming call from 0x01AC, returns to 0x01AD // Inputs[2] // { // @0748 storage[0x00] // @0753 stack[-1] // } 0743 5B JUMPDEST 0744 60 PUSH1 0x00 0746 80 DUP1 0747 90 SWAP1 0748 54 SLOAD 0749 90 SWAP1 074A 61 PUSH2 0x0100 074D 0A EXP 074E 90 SWAP1 074F 04 DIV 0750 60 PUSH1 0xff 0752 16 AND 0753 81 DUP2 0754 56 *JUMP // Stack delta = +1 // Outputs[1] { @0752 stack[0] = 0xff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0755: // Incoming call from 0x0223, returns to 0x0224 // Inputs[1] { @075C msg.sender } 0755 5B JUMPDEST 0756 61 PUSH2 0x2710 0759 61 PUSH2 0x0761 075C 33 CALLER 075D 61 PUSH2 0x08a2 0760 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0756 stack[0] = 0x2710 // @0759 stack[1] = 0x0761 // @075C stack[2] = msg.sender // } // Block ends with call to 0x08a2, returns to 0x0761 label_0761: // Incoming return from call to 0x08A2 at 0x0760 // Inputs[2] // { // @0762 stack[-1] // @0762 stack[-2] // } 0761 5B JUMPDEST 0762 10 LT 0763 15 ISZERO 0764 15 ISZERO 0765 15 ISZERO 0766 61 PUSH2 0x076e 0769 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x076e, if !!!(stack[-1] < stack[-2]) label_076A: // Incoming jump from 0x0769, if not !!!(stack[-1] < stack[-2]) // Inputs[1] { @076D memory[0x00:0x00] } 076A 60 PUSH1 0x00 076C 80 DUP1 076D FD *REVERT // Stack delta = +0 // Outputs[1] { @076D revert(memory[0x00:0x00]); } // Block terminates label_076E: // Incoming jump from 0x0769, if !!!(stack[-1] < stack[-2]) // Inputs[2] // { // @076F msg.sender // @078B storage[0x02] // } 076E 5B JUMPDEST 076F 33 CALLER 0770 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0785 16 AND 0786 60 PUSH1 0x02 0788 60 PUSH1 0x00 078A 90 SWAP1 078B 54 SLOAD 078C 90 SWAP1 078D 61 PUSH2 0x0100 0790 0A EXP 0791 90 SWAP1 0792 04 DIV 0793 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07A8 16 AND 07A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07BE 16 AND 07BF 14 EQ 07C0 15 ISZERO 07C1 15 ISZERO 07C2 61 PUSH2 0x07ca 07C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ca, if !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_07C6: // Incoming jump from 0x07C5, if not !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[1] { @07C9 memory[0x00:0x00] } 07C6 60 PUSH1 0x00 07C8 80 DUP1 07C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C9 revert(memory[0x00:0x00]); } // Block terminates label_07CA: // Incoming jump from 0x07C5, if !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[4] // { // @07EC stack[-1] // @07EF memory[0x40:0x60] // @0801 memory[stack[-1]:stack[-1] + 0x20] // @080A memory[stack[-1]:stack[-1] + 0x20] // } 07CA 5B JUMPDEST 07CB 7F PUSH32 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10 07EC 81 DUP2 07ED 60 PUSH1 0x40 07EF 51 MLOAD 07F0 80 DUP1 07F1 80 DUP1 07F2 60 PUSH1 0x20 07F4 01 ADD 07F5 80 DUP1 07F6 60 PUSH1 0x20 07F8 01 ADD 07F9 83 DUP4 07FA 81 DUP2 07FB 03 SUB 07FC 83 DUP4 07FD 52 MSTORE 07FE 84 DUP5 07FF 81 DUP2 0800 81 DUP2 0801 51 MLOAD 0802 81 DUP2 0803 52 MSTORE 0804 60 PUSH1 0x20 0806 01 ADD 0807 91 SWAP2 0808 50 POP 0809 80 DUP1 080A 51 MLOAD 080B 90 SWAP1 080C 60 PUSH1 0x20 080E 01 ADD 080F 90 SWAP1 0810 80 DUP1 0811 83 DUP4 0812 83 DUP4 0813 60 PUSH1 0x00 0815 5B JUMPDEST 0816 83 DUP4 0817 81 DUP2 0818 10 LT 0819 15 ISZERO 081A 61 PUSH2 0x0830 081D 57 *JUMPI // Stack delta = +12 // Outputs[14] // { // @07CB stack[0] = 0xc18473380ae2e7a279934bea5ae7294969b074d8c2040ddc4a26a40b5c7c9a10 // @07EC stack[1] = stack[-1] // @07EF stack[2] = memory[0x40:0x60] // @07F0 stack[3] = memory[0x40:0x60] // @07F4 stack[4] = 0x20 + memory[0x40:0x60] // @07FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0803 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0807 stack[5] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @080F stack[7] = memory[stack[-1]:stack[-1] + 0x20] // @080F stack[6] = 0x20 + stack[-1] // @0810 stack[8] = memory[stack[-1]:stack[-1] + 0x20] // @0811 stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0812 stack[10] = 0x20 + stack[-1] // @0813 stack[11] = 0x00 // } // Block ends with conditional jump to 0x0830, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_081E: // Incoming jump from 0x081D, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x081D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @081E stack[-1] // @081F stack[-2] // @0821 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0823 stack[-3] // } 081E 80 DUP1 081F 82 DUP3 0820 01 ADD 0821 51 MLOAD 0822 81 DUP2 0823 84 DUP5 0824 01 ADD 0825 52 MSTORE 0826 60 PUSH1 0x20 0828 81 DUP2 0829 01 ADD 082A 90 SWAP1 082B 50 POP 082C 61 PUSH2 0x0815 082F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0825 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @082A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0815 label_0830: // Incoming jump from 0x081D, if !(stack[-1] < stack[-4]) // Incoming jump from 0x081D, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0835 stack[-6] // @0835 stack[-5] // @0837 stack[-7] // } 0830 5B JUMPDEST 0831 50 POP 0832 50 POP 0833 50 POP 0834 50 POP 0835 90 SWAP1 0836 50 POP 0837 90 SWAP1 0838 81 DUP2 0839 01 ADD 083A 90 SWAP1 083B 60 PUSH1 0x1f 083D 16 AND 083E 80 DUP1 083F 15 ISZERO 0840 61 PUSH2 0x085d 0843 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @083A stack[-7] = stack[-5] + stack[-7] // @083D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x085d, if !(0x1f & stack[-5]) label_0844: // Incoming jump from 0x0843, if not !(0x1f & stack[-5]) // Inputs[10] // { // @0844 stack[-1] // @0845 stack[-2] // @0848 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @085F stack[-5] // @0862 stack[-3] // @0893 stack[-6] // @089A memory[0x40:0x60] // @089F stack[-7] // @089F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @08A1 stack[-9] // } 0844 80 DUP1 0845 82 DUP3 0846 03 SUB 0847 80 DUP1 0848 51 MLOAD 0849 60 PUSH1 0x01 084B 83 DUP4 084C 60 PUSH1 0x20 084E 03 SUB 084F 61 PUSH2 0x0100 0852 0A EXP 0853 03 SUB 0854 19 NOT 0855 16 AND 0856 81 DUP2 0857 52 MSTORE 0858 60 PUSH1 0x20 085A 01 ADD 085B 91 SWAP2 085C 50 POP 085D 5B JUMPDEST 085E 50 POP 085F 83 DUP4 0860 81 DUP2 0861 03 SUB 0862 82 DUP3 0863 52 MSTORE 0864 60 PUSH1 0x06 0866 81 DUP2 0867 52 MSTORE 0868 60 PUSH1 0x20 086A 01 ADD 086B 80 DUP1 086C 7F PUSH32 0x627261766f210000000000000000000000000000000000000000000000000000 088D 81 DUP2 088E 52 MSTORE 088F 50 POP 0890 60 PUSH1 0x20 0892 01 ADD 0893 93 SWAP4 0894 50 POP 0895 50 POP 0896 50 POP 0897 50 POP 0898 60 PUSH1 0x40 089A 51 MLOAD 089B 80 DUP1 089C 91 SWAP2 089D 03 SUB 089E 90 SWAP1 089F A1 LOG1 08A0 50 POP 08A1 56 *JUMP // Stack delta = -9 // Outputs[5] // { // @0857 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] // @0863 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @0867 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x06 // @088E memory[0x20 + 0x20 + (stack[-2] - stack[-1]):0x20 + 0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x627261766f210000000000000000000000000000000000000000000000000000 // @089F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-7]]); // } // Block ends with unconditional jump to stack[-9] label_08A2: // Incoming call from 0x025C, returns to 0x025D // Incoming call from 0x0760, returns to 0x0761 // Inputs[4] // { // @08A9 stack[-1] // @08E3 memory[0x00:0x40] // @08E4 storage[keccak256(memory[0x00:0x40])] // @08E7 stack[-2] // } 08A2 5B JUMPDEST 08A3 60 PUSH1 0x00 08A5 60 PUSH1 0x03 08A7 60 PUSH1 0x00 08A9 83 DUP4 08AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BF 16 AND 08C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D5 16 AND 08D6 81 DUP2 08D7 52 MSTORE 08D8 60 PUSH1 0x20 08DA 01 ADD 08DB 90 SWAP1 08DC 81 DUP2 08DD 52 MSTORE 08DE 60 PUSH1 0x20 08E0 01 ADD 08E1 60 PUSH1 0x00 08E3 20 SHA3 08E4 54 SLOAD 08E5 90 SWAP1 08E6 50 POP 08E7 91 SWAP2 08E8 90 SWAP1 08E9 50 POP 08EA 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @08D7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @08DD memory[0x20:0x40] = 0x03 // @08E7 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_08EB: // Incoming call from 0x0285, returns to 0x0286 // Inputs[2] // { // @08F1 storage[0x02] // @090F stack[-1] // } 08EB 5B JUMPDEST 08EC 60 PUSH1 0x02 08EE 60 PUSH1 0x00 08F0 90 SWAP1 08F1 54 SLOAD 08F2 90 SWAP1 08F3 61 PUSH2 0x0100 08F6 0A EXP 08F7 90 SWAP1 08F8 04 DIV 08F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 090E 16 AND 090F 81 DUP2 0910 56 *JUMP // Stack delta = +1 // Outputs[1] { @090E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0911: // Incoming call from 0x02FE, returns to 0x02FF // Inputs[2] // { // @0912 msg.sender // @0929 tx.origin // } 0911 5B JUMPDEST 0912 33 CALLER 0913 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0928 16 AND 0929 32 ORIGIN 092A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 093F 16 AND 0940 14 EQ 0941 15 ISZERO 0942 15 ISZERO 0943 61 PUSH2 0x0988 0946 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0988, if !!(0xffffffffffffffffffffffffffffffffffffffff & tx.origin == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_0947: // Incoming jump from 0x0946, if not !!(0xffffffffffffffffffffffffffffffffffffffff & tx.origin == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[3] // { // @0947 stack[-1] // @0951 storage[0x02] // @098A stack[-2] // } 0947 80 DUP1 0948 60 PUSH1 0x02 094A 60 PUSH1 0x00 094C 61 PUSH2 0x0100 094F 0A EXP 0950 81 DUP2 0951 54 SLOAD 0952 81 DUP2 0953 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0968 02 MUL 0969 19 NOT 096A 16 AND 096B 90 SWAP1 096C 83 DUP4 096D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0982 16 AND 0983 02 MUL 0984 17 OR 0985 90 SWAP1 0986 55 SSTORE 0987 50 POP 0988 5B JUMPDEST 0989 50 POP 098A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0986 storage[0x02] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x02]) } // Block ends with unconditional jump to stack[-2] label_098B: // Incoming call from 0x0356, returns to 0x0357 // Inputs[6] // { // @0992 stack[-2] // @09CC memory[0x00:0x40] // @09CF stack[-1] // @0A09 memory[0x00:0x40] // @0A0A storage[keccak256(memory[0x00:0x40])] // @0A0D stack[-3] // } 098B 5B JUMPDEST 098C 60 PUSH1 0x00 098E 60 PUSH1 0x04 0990 60 PUSH1 0x00 0992 84 DUP5 0993 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09A8 16 AND 09A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09BE 16 AND 09BF 81 DUP2 09C0 52 MSTORE 09C1 60 PUSH1 0x20 09C3 01 ADD 09C4 90 SWAP1 09C5 81 DUP2 09C6 52 MSTORE 09C7 60 PUSH1 0x20 09C9 01 ADD 09CA 60 PUSH1 0x00 09CC 20 SHA3 09CD 60 PUSH1 0x00 09CF 83 DUP4 09D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E5 16 AND 09E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09FB 16 AND 09FC 81 DUP2 09FD 52 MSTORE 09FE 60 PUSH1 0x20 0A00 01 ADD 0A01 90 SWAP1 0A02 81 DUP2 0A03 52 MSTORE 0A04 60 PUSH1 0x20 0A06 01 ADD 0A07 60 PUSH1 0x00 0A09 20 SHA3 0A0A 54 SLOAD 0A0B 90 SWAP1 0A0C 50 POP 0A0D 92 SWAP3 0A0E 91 SWAP2 0A0F 50 POP 0A10 50 POP 0A11 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @09C0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @09C6 memory[0x20:0x40] = 0x04 // @09FD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A03 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0A0D stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 0A12 00 *STOP 0A13 A1 LOG1 0A14 65 PUSH6 0x627a7a723058 0A1B 20 SHA3 0A1C 18 XOR 0A1D 8B DUP12 0A1E 9F SWAP16 0A1F F5 CREATE2 0A20 20 SHA3 0A21 FC FC 0A22 47 SELFBALANCE 0A23 1D SAR 0A24 5B JUMPDEST 0A25 5B JUMPDEST 0A26 96 SWAP7 0A27 48 BASEFEE 0A28 C4 C4 0A29 31 BALANCE 0A2A E5 E5 0A2B 1C SHR 0A2C 0A EXP 0A2D 83 DUP4 0A2E AE AE 0A2F F0 CREATE 0A30 69 PUSH10 0x838e01a63cea6ab56b1d 0A3B AB AB 0A3C 00 *STOP 0A3D 29 29
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]