Online Solidity Decompiler

« Decompile another contract

Address

0xef279c2ab14960aa319008cbea384b9f8ac35fc6 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x48d3c273 Unknown

0xe11fbb75 Unknown

Internal Methods

func_005C(arg0, arg1)

func_00CA(arg0, arg1)

func_0102(arg0, arg1)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
        var var0 = msg.value;
    
        if (var0) { revert(memory[0x00:0x00]); }
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (var0 == 0x2d8a122e) {
            // Dispatch table entry for 0x2d8a122e (unknown)
            var var1 = 0x00b2;
            var var2 = 0x04;
            var var3 = msg.data.length - var2;
        
            if (var3 < 0x60) { revert(memory[0x00:0x00]); }
        
            func_005C(var2, var3);
            stop();
        } else if (var0 == 0x48d3c273) {
            // Dispatch table entry for 0x48d3c273 (unknown)
            var1 = 0x00ea;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            func_00CA(var2, var3);
            stop();
        } else if (var0 == 0xe11fbb75) {
            // Dispatch table entry for 0xe11fbb75 (unknown)
            var1 = 0x0138;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            func_0102(var2, var3);
            stop();
        } else { revert(memory[0x00:0x00]); }
    }
    
    function func_005C(var arg0, var arg1) {
        var temp0 = arg0;
        var temp1 = temp0 + 0x20;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp1:temp1 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20];
    
        if (msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066) {
            var var1 = arg0;
        
            if (var0 != 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
            label_02C1:
                var var2 = var0;
                var var3 = var1 & 0xffffffffffffffffffffffffffffffffffffffff;
                var var4 = 0x70a08231;
                var temp2 = memory[0x40:0x60];
                memory[temp2:temp2 + 0x20] = (var4 & 0xffffffff) << 0xe0;
                var temp3 = temp2 + 0x04;
                memory[temp3:temp3 + 0x20] = address(this);
                var var5 = temp3 + 0x20;
                var var6 = 0x20;
                var var7 = memory[0x40:0x60];
                var var8 = var5 - var7;
                var var9 = var7;
                var var10 = var3;
                var var11 = !address(var10).code.length;
            
                if (var11) { revert(memory[0x00:0x00]); }
            
                var temp4;
                temp4, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]);
                var6 = !temp4;
            
                if (!var6) {
                    var3 = memory[0x40:0x60];
                    var4 = returndata.length;
                
                    if (var4 < 0x20) { revert(memory[0x00:0x00]); }
                
                    if (memory[var3:var3 + 0x20] >= var2) {
                        var2 = 0x00;
                        var3 = var2;
                        var4 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
                        var5 = 0x00;
                        var temp5 = memory[0x40:0x60] + 0x24;
                        memory[temp5:temp5 + 0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff;
                        var temp6 = temp5 + 0x20;
                        memory[temp6:temp6 + 0x20] = var0;
                        var temp7 = temp6 + 0x20;
                        var temp8 = memory[0x40:0x60];
                        memory[temp8:temp8 + 0x20] = temp7 - temp8 - 0x20;
                        memory[0x40:0x60] = temp7;
                        var6 = temp8;
                        var temp9 = var6 + 0x20;
                        memory[temp9:temp9 + 0x20] = (memory[temp9:temp9 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xa9059cbb << 0xe0));
                        var7 = memory[0x40:0x60];
                        var8 = var7;
                        var10 = memory[var6:var6 + 0x20];
                        var9 = var6 + 0x20;
                        var11 = var10;
                        var var12 = var8;
                        var var13 = var9;
                    
                        if (var11 < 0x20) {
                        label_04BB:
                            var temp10 = 0x0100 ** (0x20 - var11) - 0x01;
                            var temp11 = var12;
                            memory[temp11:temp11 + 0x20] = (memory[var13:var13 + 0x20] & ~temp10) | (memory[temp11:temp11 + 0x20] & temp10);
                            var temp12 = memory[0x40:0x60];
                            var temp13;
                            temp13, memory[temp12:temp12 + 0x00] = address(var4).call.gas(msg.gas).value(var5)(memory[temp12:temp12 + (var10 + var8) - temp12]);
                            var5 = returndata.length;
                            var6 = var5;
                        
                            if (var6 == 0x00) {
                                var3 = 0x60;
                                var2 = var4;
                            
                                if (var2) {
                                label_059A:
                                    return;
                                } else {
                                label_052D:
                                    var temp14 = memory[0x40:0x60];
                                    memory[temp14:temp14 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                                    var temp15 = temp14 + 0x04;
                                    var temp16 = temp15 + 0x20;
                                    memory[temp15:temp15 + 0x20] = temp16 - temp15;
                                    memory[temp16:temp16 + 0x20] = 0x15;
                                    var temp17 = temp16 + 0x20;
                                    memory[temp17:temp17 + 0x20] = 0x546f6b656e207472616e73666572206661696c65640000000000000000000000;
                                    var temp18 = memory[0x40:0x60];
                                    revert(memory[temp18:temp18 + (temp17 + 0x20) - temp18]);
                                }
                            } else {
                                var temp19 = memory[0x40:0x60];
                                var5 = temp19;
                                memory[0x40:0x60] = var5 + (returndata.length + 0x3f & ~0x1f);
                                memory[var5:var5 + 0x20] = returndata.length;
                                var temp20 = returndata.length;
                                memory[var5 + 0x20:var5 + 0x20 + temp20] = returndata[0x00:0x00 + temp20];
                                var3 = var5;
                                var2 = var4;
                            
                                if (var2) { goto label_059A; }
                                else { goto label_052D; }
                            }
                        } else {
                        label_04A1:
                            var temp21 = var13;
                            var temp22 = var12;
                            memory[temp22:temp22 + 0x20] = memory[temp21:temp21 + 0x20];
                            var12 = temp22 + 0x20;
                            var13 = temp21 + 0x20;
                            var11 = var11 - 0x20;
                        
                            if (var11 < 0x20) { goto label_04BB; }
                            else { goto label_04A1; }
                        }
                    } else {
                        var temp23 = memory[0x40:0x60];
                        memory[temp23:temp23 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                        var temp24 = temp23 + 0x04;
                        var temp25 = temp24 + 0x20;
                        memory[temp24:temp24 + 0x20] = temp25 - temp24;
                        memory[temp25:temp25 + 0x20] = 0x1a;
                        var temp26 = temp25 + 0x20;
                        memory[temp26:temp26 + 0x20] = 0x496e73756666696369656e7420746f6b656e2062616c616e6365000000000000;
                        var temp27 = memory[0x40:0x60];
                        revert(memory[temp27:temp27 + (temp26 + 0x20) - temp27]);
                    }
                } else {
                    var temp28 = returndata.length;
                    memory[0x00:0x00 + temp28] = returndata[0x00:0x00 + temp28];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            } else {
                var2 = var1 & 0xffffffffffffffffffffffffffffffffffffffff;
                var3 = 0x70a08231;
                var temp29 = memory[0x40:0x60];
                memory[temp29:temp29 + 0x20] = (var3 & 0xffffffff) << 0xe0;
                var temp30 = temp29 + 0x04;
                memory[temp30:temp30 + 0x20] = address(this);
                var4 = temp30 + 0x20;
                var5 = 0x20;
                var6 = memory[0x40:0x60];
                var7 = var4 - var6;
                var8 = var6;
                var9 = var2;
                var10 = !address(var9).code.length;
            
                if (var10) { revert(memory[0x00:0x00]); }
            
                var temp31;
                temp31, memory[var6:var6 + var5] = address(var9).staticcall.gas(msg.gas)(memory[var8:var8 + var7]);
                var5 = !temp31;
            
                if (!var5) {
                    var2 = memory[0x40:0x60];
                    var3 = returndata.length;
                
                    if (var3 < 0x20) { revert(memory[0x00:0x00]); }
                
                    var0 = memory[var2:var2 + 0x20];
                    goto label_02C1;
                } else {
                    var temp32 = returndata.length;
                    memory[0x00:0x00 + temp32] = returndata[0x00:0x00 + temp32];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            }
        } else {
            var temp33 = memory[0x40:0x60];
            memory[temp33:temp33 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp34 = temp33 + 0x04;
            var temp35 = temp34 + 0x20;
            memory[temp34:temp34 + 0x20] = temp35 - temp34;
            memory[temp35:temp35 + 0x20] = 0x20;
            var temp36 = temp35 + 0x20;
            memory[temp36:temp36 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp37 = memory[0x40:0x60];
            revert(memory[temp37:temp37 + (temp36 + 0x20) - temp37]);
        }
    }
    
    function func_00CA(var arg0, var arg1) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20];
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
    
        if (msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066) {
            storage[arg0] = arg1;
            return;
        } else {
            var temp1 = memory[0x40:0x60];
            memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp2 = temp1 + 0x04;
            var temp3 = temp2 + 0x20;
            memory[temp2:temp2 + 0x20] = temp3 - temp2;
            memory[temp3:temp3 + 0x20] = 0x20;
            var temp4 = temp3 + 0x20;
            memory[temp4:temp4 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp5 = memory[0x40:0x60];
            revert(memory[temp5:temp5 + (temp4 + 0x20) - temp5]);
        }
    }
    
    function func_0102(var arg0, var arg1) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
    
        if (msg.sender != 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066) {
            var temp10 = memory[0x40:0x60];
            memory[temp10:temp10 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp11 = temp10 + 0x04;
            var temp12 = temp11 + 0x20;
            memory[temp11:temp11 + 0x20] = temp12 - temp11;
            memory[temp12:temp12 + 0x20] = 0x20;
            var temp13 = temp12 + 0x20;
            memory[temp13:temp13 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp14 = memory[0x40:0x60];
            revert(memory[temp14:temp14 + (temp13 + 0x20) - temp14]);
        } else if (arg1 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
            arg1 = address(this).balance;
        
            if (address(this).balance >= arg1) { goto label_07B5; }
            else { goto label_0748; }
        } else if (address(this).balance >= arg1) {
        label_07B5:
            var temp1 = arg1;
            var temp2 = memory[0x40:0x60];
            var temp3;
            temp3, memory[temp2:temp2 + 0x00] = address(arg0 & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp1 * 0x08fc).value(temp1)(memory[temp2:temp2 + memory[0x40:0x60] - temp2]);
            var var0 = !temp3;
        
            if (!var0) { return; }
        
            var temp4 = returndata.length;
            memory[0x00:0x00 + temp4] = returndata[0x00:0x00 + temp4];
            revert(memory[0x00:0x00 + returndata.length]);
        } else {
        label_0748:
            var temp5 = memory[0x40:0x60];
            memory[temp5:temp5 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp6 = temp5 + 0x04;
            var temp7 = temp6 + 0x20;
            memory[temp6:temp6 + 0x20] = temp7 - temp6;
            memory[temp7:temp7 + 0x20] = 0x14;
            var temp8 = temp7 + 0x20;
            memory[temp8:temp8 + 0x20] = 0x496e73756666696369656e742062616c616e6365000000000000000000000000;
            var temp9 = memory[0x40:0x60];
            revert(memory[temp9:temp9 + (temp8 + 0x20) - temp9]);
        }
    }
}

Disassembly

label_0000:
	// Inputs[1] { @0005  msg.value }
	0000    60  PUSH1 0x80
	0002    60  PUSH1 0x40
	0004    52  MSTORE
	0005    34  CALLVALUE
	0006    80  DUP1
	0007    15  ISZERO
	0008    61  PUSH2 0x0010
	000B    57  *JUMPI
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @0004  memory[0x40:0x60] = 0x80
	//     @0005  stack[0] = msg.value
	// }
	// Block ends with conditional jump to 0x0010, if !msg.value

label_000C:
	// Incoming jump from 0x000B, if not !msg.value
	// Inputs[1] { @000F  memory[0x00:0x00] }
	000C    60  PUSH1 0x00
	000E    80  DUP1
	000F    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @000F  revert(memory[0x00:0x00]); }
	// Block terminates

label_0010:
	// Incoming jump from 0x000B, if !msg.value
	// Inputs[1] { @0014  msg.data.length }
	0010    5B  JUMPDEST
	0011    50  POP
	0012    60  PUSH1 0x04
	0014    36  CALLDATASIZE
	0015    10  LT
	0016    61  PUSH2 0x0041
	0019    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0041, if msg.data.length < 0x04

label_001A:
	// Incoming jump from 0x0019, if not msg.data.length < 0x04
	// Inputs[1] { @001C  msg.data[0x00:0x20] }
	001A    60  PUSH1 0x00
	001C    35  CALLDATALOAD
	001D    60  PUSH1 0xe0
	001F    1C  SHR
	0020    80  DUP1
	0021    63  PUSH4 0x2d8a122e
	0026    14  EQ
	0027    61  PUSH2 0x0046
	002A    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @001F  stack[0] = msg.data[0x00:0x20] >> 0xe0 }
	// Block ends with conditional jump to 0x0046, if 0x2d8a122e == msg.data[0x00:0x20] >> 0xe0

label_002B:
	// Incoming jump from 0x002A, if not 0x2d8a122e == msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @002B  stack[-1] }
	002B    80  DUP1
	002C    63  PUSH4 0x48d3c273
	0031    14  EQ
	0032    61  PUSH2 0x00b4
	0035    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00b4, if 0x48d3c273 == stack[-1]

label_0036:
	// Incoming jump from 0x0035, if not 0x48d3c273 == stack[-1]
	// Inputs[1] { @0036  stack[-1] }
	0036    80  DUP1
	0037    63  PUSH4 0xe11fbb75
	003C    14  EQ
	003D    61  PUSH2 0x00ec
	0040    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00ec, if 0xe11fbb75 == stack[-1]

label_0041:
	// Incoming jump from 0x0040, if not 0xe11fbb75 == stack[-1]
	// Incoming jump from 0x0019, if msg.data.length < 0x04
	// Inputs[1] { @0045  memory[0x00:0x00] }
	0041    5B  JUMPDEST
	0042    60  PUSH1 0x00
	0044    80  DUP1
	0045    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0045  revert(memory[0x00:0x00]); }
	// Block terminates

label_0046:
	// Incoming jump from 0x002A, if 0x2d8a122e == msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @004D  msg.data.length }
	0046    5B  JUMPDEST
	0047    61  PUSH2 0x00b2
	004A    60  PUSH1 0x04
	004C    80  DUP1
	004D    36  CALLDATASIZE
	004E    03  SUB
	004F    60  PUSH1 0x60
	0051    81  DUP2
	0052    10  LT
	0053    15  ISZERO
	0054    61  PUSH2 0x005c
	0057    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0047  stack[0] = 0x00b2
	//     @004A  stack[1] = 0x04
	//     @004E  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x005c, returns to 0x00B2, if !(msg.data.length - 0x04 < 0x60)

label_0058:
	// Incoming jump from 0x0057, if not !(msg.data.length - 0x04 < 0x60)
	// Inputs[1] { @005B  memory[0x00:0x00] }
	0058    60  PUSH1 0x00
	005A    80  DUP1
	005B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @005B  revert(memory[0x00:0x00]); }
	// Block terminates

label_005C:
	// Incoming call from 0x0057, returns to 0x00B2, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[5]
	// {
	//     @005D  stack[-2]
	//     @005E  stack[-1]
	//     @0062  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0082  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @00A2  msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	005C    5B  JUMPDEST
	005D    81  DUP2
	005E    01  ADD
	005F    90  SWAP1
	0060    80  DUP1
	0061    80  DUP1
	0062    35  CALLDATALOAD
	0063    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0078    16  AND
	0079    90  SWAP1
	007A    60  PUSH1 0x20
	007C    01  ADD
	007D    90  SWAP1
	007E    92  SWAP3
	007F    91  SWAP2
	0080    90  SWAP1
	0081    80  DUP1
	0082    35  CALLDATALOAD
	0083    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0098    16  AND
	0099    90  SWAP1
	009A    60  PUSH1 0x20
	009C    01  ADD
	009D    90  SWAP1
	009E    92  SWAP3
	009F    91  SWAP2
	00A0    90  SWAP1
	00A1    80  DUP1
	00A2    35  CALLDATALOAD
	00A3    90  SWAP1
	00A4    60  PUSH1 0x20
	00A6    01  ADD
	00A7    90  SWAP1
	00A8    92  SWAP3
	00A9    91  SWAP2
	00AA    90  SWAP1
	00AB    50  POP
	00AC    50  POP
	00AD    50  POP
	00AE    61  PUSH2 0x013a
	00B1    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @007E  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @009E  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @00A8  stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x013a

label_00B2:
	// Incoming return from call to 0x005C at 0x0057
	00B2    5B  JUMPDEST
	00B3    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @00B3  stop(); }
	// Block terminates

label_00B4:
	// Incoming jump from 0x0035, if 0x48d3c273 == stack[-1]
	// Inputs[1] { @00BB  msg.data.length }
	00B4    5B  JUMPDEST
	00B5    61  PUSH2 0x00ea
	00B8    60  PUSH1 0x04
	00BA    80  DUP1
	00BB    36  CALLDATASIZE
	00BC    03  SUB
	00BD    60  PUSH1 0x40
	00BF    81  DUP2
	00C0    10  LT
	00C1    15  ISZERO
	00C2    61  PUSH2 0x00ca
	00C5    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @00B5  stack[0] = 0x00ea
	//     @00B8  stack[1] = 0x04
	//     @00BC  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x00ca, returns to 0x00EA, if !(msg.data.length - 0x04 < 0x40)

label_00C6:
	// Incoming jump from 0x00C5, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @00C9  memory[0x00:0x00] }
	00C6    60  PUSH1 0x00
	00C8    80  DUP1
	00C9    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00C9  revert(memory[0x00:0x00]); }
	// Block terminates

label_00CA:
	// Incoming call from 0x00C5, returns to 0x00EA, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @00CB  stack[-2]
	//     @00CC  stack[-1]
	//     @00D0  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @00DA  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	00CA    5B  JUMPDEST
	00CB    81  DUP2
	00CC    01  ADD
	00CD    90  SWAP1
	00CE    80  DUP1
	00CF    80  DUP1
	00D0    35  CALLDATALOAD
	00D1    90  SWAP1
	00D2    60  PUSH1 0x20
	00D4    01  ADD
	00D5    90  SWAP1
	00D6    92  SWAP3
	00D7    91  SWAP2
	00D8    90  SWAP1
	00D9    80  DUP1
	00DA    35  CALLDATALOAD
	00DB    90  SWAP1
	00DC    60  PUSH1 0x20
	00DE    01  ADD
	00DF    90  SWAP1
	00E0    92  SWAP3
	00E1    91  SWAP2
	00E2    90  SWAP1
	00E3    50  POP
	00E4    50  POP
	00E5    50  POP
	00E6    61  PUSH2 0x05a2
	00E9    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @00D6  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20]
	//     @00E0  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x05a2

label_00EA:
	// Incoming return from call to 0x00CA at 0x00C5
	00EA    5B  JUMPDEST
	00EB    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @00EB  stop(); }
	// Block terminates

label_00EC:
	// Incoming jump from 0x0040, if 0xe11fbb75 == stack[-1]
	// Inputs[1] { @00F3  msg.data.length }
	00EC    5B  JUMPDEST
	00ED    61  PUSH2 0x0138
	00F0    60  PUSH1 0x04
	00F2    80  DUP1
	00F3    36  CALLDATASIZE
	00F4    03  SUB
	00F5    60  PUSH1 0x40
	00F7    81  DUP2
	00F8    10  LT
	00F9    15  ISZERO
	00FA    61  PUSH2 0x0102
	00FD    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @00ED  stack[0] = 0x0138
	//     @00F0  stack[1] = 0x04
	//     @00F4  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0102, returns to 0x0138, if !(msg.data.length - 0x04 < 0x40)

label_00FE:
	// Incoming jump from 0x00FD, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @0101  memory[0x00:0x00] }
	00FE    60  PUSH1 0x00
	0100    80  DUP1
	0101    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0101  revert(memory[0x00:0x00]); }
	// Block terminates

label_0102:
	// Incoming call from 0x00FD, returns to 0x0138, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @0103  stack[-2]
	//     @0104  stack[-1]
	//     @0108  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0128  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0102    5B  JUMPDEST
	0103    81  DUP2
	0104    01  ADD
	0105    90  SWAP1
	0106    80  DUP1
	0107    80  DUP1
	0108    35  CALLDATALOAD
	0109    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	011E    16  AND
	011F    90  SWAP1
	0120    60  PUSH1 0x20
	0122    01  ADD
	0123    90  SWAP1
	0124    92  SWAP3
	0125    91  SWAP2
	0126    90  SWAP1
	0127    80  DUP1
	0128    35  CALLDATALOAD
	0129    90  SWAP1
	012A    60  PUSH1 0x20
	012C    01  ADD
	012D    90  SWAP1
	012E    92  SWAP3
	012F    91  SWAP2
	0130    90  SWAP1
	0131    50  POP
	0132    50  POP
	0133    50  POP
	0134    61  PUSH2 0x065e
	0137    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0124  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @012E  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x065e

label_0138:
	// Incoming return from call to 0x0102 at 0x00FD
	0138    5B  JUMPDEST
	0139    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0139  stop(); }
	// Block terminates

label_013A:
	// Incoming jump from 0x00B1
	// Inputs[1] { @0166  msg.sender }
	013A    5B  JUMPDEST
	013B    73  PUSH20 0x6eedf92fb92dd68a270c3205e96dccc527728066
	0150    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0165    16  AND
	0166    33  CALLER
	0167    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	017C    16  AND
	017D    14  EQ
	017E    61  PUSH2 0x01ef
	0181    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01ef, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066

label_0182:
	// Incoming jump from 0x0181, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[3]
	// {
	//     @0184  memory[0x40:0x60]
	//     @01E9  memory[0x40:0x60]
	//     @01EE  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0182    60  PUSH1 0x40
	0184    51  MLOAD
	0185    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	01A6    81  DUP2
	01A7    52  MSTORE
	01A8    60  PUSH1 0x04
	01AA    01  ADD
	01AB    80  DUP1
	01AC    80  DUP1
	01AD    60  PUSH1 0x20
	01AF    01  ADD
	01B0    82  DUP3
	01B1    81  DUP2
	01B2    03  SUB
	01B3    82  DUP3
	01B4    52  MSTORE
	01B5    60  PUSH1 0x20
	01B7    81  DUP2
	01B8    52  MSTORE
	01B9    60  PUSH1 0x20
	01BB    01  ADD
	01BC    80  DUP1
	01BD    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	01DE    81  DUP2
	01DF    52  MSTORE
	01E0    50  POP
	01E1    60  PUSH1 0x20
	01E3    01  ADD
	01E4    91  SWAP2
	01E5    50  POP
	01E6    50  POP
	01E7    60  PUSH1 0x40
	01E9    51  MLOAD
	01EA    80  DUP1
	01EB    91  SWAP2
	01EC    03  SUB
	01ED    90  SWAP1
	01EE    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @01A7  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @01B4  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @01B8  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @01DF  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @01EE  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_01EF:
	// Incoming jump from 0x0181, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[2]
	// {
	//     @01F2  stack[-3]
	//     @0216  stack[-1]
	// }
	01EF    5B  JUMPDEST
	01F0    60  PUSH1 0x00
	01F2    83  DUP4
	01F3    90  SWAP1
	01F4    50  POP
	01F5    7F  PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0216    82  DUP3
	0217    14  EQ
	0218    15  ISZERO
	0219    61  PUSH2 0x02c1
	021C    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @01F3  stack[0] = stack[-3] }
	// Block ends with conditional jump to 0x02c1, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)

label_021D:
	// Incoming jump from 0x021C, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
	// Inputs[5]
	// {
	//     @021D  stack[-1]
	//     @0239  address(this)
	//     @023C  memory[0x40:0x60]
	//     @0270  memory[0x40:0x60]
	//     @0277  address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// }
	021D    80  DUP1
	021E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0233    16  AND
	0234    63  PUSH4 0x70a08231
	0239    30  ADDRESS
	023A    60  PUSH1 0x40
	023C    51  MLOAD
	023D    82  DUP3
	023E    63  PUSH4 0xffffffff
	0243    16  AND
	0244    60  PUSH1 0xe0
	0246    1B  SHL
	0247    81  DUP2
	0248    52  MSTORE
	0249    60  PUSH1 0x04
	024B    01  ADD
	024C    80  DUP1
	024D    82  DUP3
	024E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0263    16  AND
	0264    81  DUP2
	0265    52  MSTORE
	0266    60  PUSH1 0x20
	0268    01  ADD
	0269    91  SWAP2
	026A    50  POP
	026B    50  POP
	026C    60  PUSH1 0x20
	026E    60  PUSH1 0x40
	0270    51  MLOAD
	0271    80  DUP1
	0272    83  DUP4
	0273    03  SUB
	0274    81  DUP2
	0275    86  DUP7
	0276    80  DUP1
	0277    3B  EXTCODESIZE
	0278    15  ISZERO
	0279    80  DUP1
	027A    15  ISZERO
	027B    61  PUSH2 0x0283
	027E    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @0233  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @0234  stack[1] = 0x70a08231
	//     @0248  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0
	//     @0265  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @0269  stack[2] = 0x20 + 0x04 + memory[0x40:0x60]
	//     @026C  stack[3] = 0x20
	//     @0270  stack[4] = memory[0x40:0x60]
	//     @0273  stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0274  stack[6] = memory[0x40:0x60]
	//     @0275  stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @0278  stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// }
	// Block ends with conditional jump to 0x0283, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length

label_027F:
	// Incoming jump from 0x027E, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// Inputs[1] { @0282  memory[0x00:0x00] }
	027F    60  PUSH1 0x00
	0281    80  DUP1
	0282    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0282  revert(memory[0x00:0x00]); }
	// Block terminates

label_0283:
	// Incoming jump from 0x027E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// Inputs[8]
	// {
	//     @0285  msg.gas
	//     @0286  stack[-6]
	//     @0286  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @0286  stack[-5]
	//     @0286  stack[-4]
	//     @0286  stack[-2]
	//     @0286  stack[-3]
	//     @0286  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	0283    5B  JUMPDEST
	0284    50  POP
	0285    5A  GAS
	0286    FA  STATICCALL
	0287    15  ISZERO
	0288    80  DUP1
	0289    15  ISZERO
	028A    61  PUSH2 0x0297
	028D    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0286  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0287  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x0297, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_028E:
	// Incoming jump from 0x028D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @028E  returndata.length
	//     @0292  returndata[0x00:0x00 + returndata.length]
	//     @0293  returndata.length
	//     @0296  memory[0x00:0x00 + returndata.length]
	// }
	028E    3D  RETURNDATASIZE
	028F    60  PUSH1 0x00
	0291    80  DUP1
	0292    3E  RETURNDATACOPY
	0293    3D  RETURNDATASIZE
	0294    60  PUSH1 0x00
	0296    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0292  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0296  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0297:
	// Incoming jump from 0x028D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @029E  memory[0x40:0x60]
	//     @029F  returndata.length
	// }
	0297    5B  JUMPDEST
	0298    50  POP
	0299    50  POP
	029A    50  POP
	029B    50  POP
	029C    60  PUSH1 0x40
	029E    51  MLOAD
	029F    3D  RETURNDATASIZE
	02A0    60  PUSH1 0x20
	02A2    81  DUP2
	02A3    10  LT
	02A4    15  ISZERO
	02A5    61  PUSH2 0x02ad
	02A8    57  *JUMPI
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @029E  stack[-4] = memory[0x40:0x60]
	//     @029F  stack[-3] = returndata.length
	// }
	// Block ends with conditional jump to 0x02ad, if !(returndata.length < 0x20)

label_02A9:
	// Incoming jump from 0x02A8, if not !(returndata.length < 0x20)
	// Inputs[1] { @02AC  memory[0x00:0x00] }
	02A9    60  PUSH1 0x00
	02AB    80  DUP1
	02AC    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @02AC  revert(memory[0x00:0x00]); }
	// Block terminates

label_02AD:
	// Incoming jump from 0x02A8, if !(returndata.length < 0x20)
	// Inputs[4]
	// {
	//     @02AE  stack[-2]
	//     @02AF  stack[-1]
	//     @02B3  memory[stack[-2]:stack[-2] + 0x20]
	//     @02BF  stack[-4]
	// }
	02AD    5B  JUMPDEST
	02AE    81  DUP2
	02AF    01  ADD
	02B0    90  SWAP1
	02B1    80  DUP1
	02B2    80  DUP1
	02B3    51  MLOAD
	02B4    90  SWAP1
	02B5    60  PUSH1 0x20
	02B7    01  ADD
	02B8    90  SWAP1
	02B9    92  SWAP3
	02BA    91  SWAP2
	02BB    90  SWAP1
	02BC    50  POP
	02BD    50  POP
	02BE    50  POP
	02BF    91  SWAP2
	02C0    50  POP
	// Stack delta = -2
	// Outputs[1] { @02BF  stack[-4] = memory[stack[-2]:stack[-2] + 0x20] }
	// Block continues

label_02C1:
	// Incoming jump from 0x021C, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
	// Incoming jump from 0x02C0
	// Inputs[6]
	// {
	//     @02C2  stack[-2]
	//     @02C3  stack[-1]
	//     @02DF  address(this)
	//     @02E2  memory[0x40:0x60]
	//     @0316  memory[0x40:0x60]
	//     @031D  address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// }
	02C1    5B  JUMPDEST
	02C2    81  DUP2
	02C3    81  DUP2
	02C4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02D9    16  AND
	02DA    63  PUSH4 0x70a08231
	02DF    30  ADDRESS
	02E0    60  PUSH1 0x40
	02E2    51  MLOAD
	02E3    82  DUP3
	02E4    63  PUSH4 0xffffffff
	02E9    16  AND
	02EA    60  PUSH1 0xe0
	02EC    1B  SHL
	02ED    81  DUP2
	02EE    52  MSTORE
	02EF    60  PUSH1 0x04
	02F1    01  ADD
	02F2    80  DUP1
	02F3    82  DUP3
	02F4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0309    16  AND
	030A    81  DUP2
	030B    52  MSTORE
	030C    60  PUSH1 0x20
	030E    01  ADD
	030F    91  SWAP2
	0310    50  POP
	0311    50  POP
	0312    60  PUSH1 0x20
	0314    60  PUSH1 0x40
	0316    51  MLOAD
	0317    80  DUP1
	0318    83  DUP4
	0319    03  SUB
	031A    81  DUP2
	031B    86  DUP7
	031C    80  DUP1
	031D    3B  EXTCODESIZE
	031E    15  ISZERO
	031F    80  DUP1
	0320    15  ISZERO
	0321    61  PUSH2 0x0329
	0324    57  *JUMPI
	// Stack delta = +10
	// Outputs[12]
	// {
	//     @02C2  stack[0] = stack[-2]
	//     @02D9  stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @02DA  stack[2] = 0x70a08231
	//     @02EE  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0
	//     @030B  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @030F  stack[3] = 0x20 + 0x04 + memory[0x40:0x60]
	//     @0312  stack[4] = 0x20
	//     @0316  stack[5] = memory[0x40:0x60]
	//     @0319  stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @031A  stack[7] = memory[0x40:0x60]
	//     @031B  stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @031E  stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// }
	// Block ends with conditional jump to 0x0329, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length

label_0325:
	// Incoming jump from 0x0324, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// Inputs[1] { @0328  memory[0x00:0x00] }
	0325    60  PUSH1 0x00
	0327    80  DUP1
	0328    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0328  revert(memory[0x00:0x00]); }
	// Block terminates

label_0329:
	// Incoming jump from 0x0324, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length
	// Inputs[8]
	// {
	//     @032B  msg.gas
	//     @032C  stack[-4]
	//     @032C  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @032C  stack[-2]
	//     @032C  stack[-3]
	//     @032C  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @032C  stack[-6]
	//     @032C  stack[-5]
	// }
	0329    5B  JUMPDEST
	032A    50  POP
	032B    5A  GAS
	032C    FA  STATICCALL
	032D    15  ISZERO
	032E    80  DUP1
	032F    15  ISZERO
	0330    61  PUSH2 0x033d
	0333    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @032C  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @032D  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x033d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_0334:
	// Incoming jump from 0x0333, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @0334  returndata.length
	//     @0338  returndata[0x00:0x00 + returndata.length]
	//     @0339  returndata.length
	//     @033C  memory[0x00:0x00 + returndata.length]
	// }
	0334    3D  RETURNDATASIZE
	0335    60  PUSH1 0x00
	0337    80  DUP1
	0338    3E  RETURNDATACOPY
	0339    3D  RETURNDATASIZE
	033A    60  PUSH1 0x00
	033C    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0338  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @033C  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_033D:
	// Incoming jump from 0x0333, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @0344  memory[0x40:0x60]
	//     @0345  returndata.length
	// }
	033D    5B  JUMPDEST
	033E    50  POP
	033F    50  POP
	0340    50  POP
	0341    50  POP
	0342    60  PUSH1 0x40
	0344    51  MLOAD
	0345    3D  RETURNDATASIZE
	0346    60  PUSH1 0x20
	0348    81  DUP2
	0349    10  LT
	034A    15  ISZERO
	034B    61  PUSH2 0x0353
	034E    57  *JUMPI
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @0344  stack[-4] = memory[0x40:0x60]
	//     @0345  stack[-3] = returndata.length
	// }
	// Block ends with conditional jump to 0x0353, if !(returndata.length < 0x20)

label_034F:
	// Incoming jump from 0x034E, if not !(returndata.length < 0x20)
	// Inputs[1] { @0352  memory[0x00:0x00] }
	034F    60  PUSH1 0x00
	0351    80  DUP1
	0352    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0352  revert(memory[0x00:0x00]); }
	// Block terminates

label_0353:
	// Incoming jump from 0x034E, if !(returndata.length < 0x20)
	// Inputs[4]
	// {
	//     @0354  stack[-2]
	//     @0355  stack[-1]
	//     @0359  memory[stack[-2]:stack[-2] + 0x20]
	//     @0365  stack[-3]
	// }
	0353    5B  JUMPDEST
	0354    81  DUP2
	0355    01  ADD
	0356    90  SWAP1
	0357    80  DUP1
	0358    80  DUP1
	0359    51  MLOAD
	035A    90  SWAP1
	035B    60  PUSH1 0x20
	035D    01  ADD
	035E    90  SWAP1
	035F    92  SWAP3
	0360    91  SWAP2
	0361    90  SWAP1
	0362    50  POP
	0363    50  POP
	0364    50  POP
	0365    10  LT
	0366    15  ISZERO
	0367    61  PUSH2 0x03d8
	036A    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x03d8, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3])

label_036B:
	// Incoming jump from 0x036A, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3])
	// Inputs[3]
	// {
	//     @036D  memory[0x40:0x60]
	//     @03D2  memory[0x40:0x60]
	//     @03D7  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	036B    60  PUSH1 0x40
	036D    51  MLOAD
	036E    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	038F    81  DUP2
	0390    52  MSTORE
	0391    60  PUSH1 0x04
	0393    01  ADD
	0394    80  DUP1
	0395    80  DUP1
	0396    60  PUSH1 0x20
	0398    01  ADD
	0399    82  DUP3
	039A    81  DUP2
	039B    03  SUB
	039C    82  DUP3
	039D    52  MSTORE
	039E    60  PUSH1 0x1a
	03A0    81  DUP2
	03A1    52  MSTORE
	03A2    60  PUSH1 0x20
	03A4    01  ADD
	03A5    80  DUP1
	03A6    7F  PUSH32 0x496e73756666696369656e7420746f6b656e2062616c616e6365000000000000
	03C7    81  DUP2
	03C8    52  MSTORE
	03C9    50  POP
	03CA    60  PUSH1 0x20
	03CC    01  ADD
	03CD    91  SWAP2
	03CE    50  POP
	03CF    50  POP
	03D0    60  PUSH1 0x40
	03D2    51  MLOAD
	03D3    80  DUP1
	03D4    91  SWAP2
	03D5    03  SUB
	03D6    90  SWAP1
	03D7    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0390  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @039D  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @03A1  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1a
	//     @03C8  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x496e73756666696369656e7420746f6b656e2062616c616e6365000000000000
	//     @03D7  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_03D8:
	// Incoming jump from 0x036A, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3])
	// Inputs[8]
	// {
	//     @03DC  stack[-4]
	//     @03FD  stack[-3]
	//     @03FE  stack[-2]
	//     @0401  memory[0x40:0x60]
	//     @042E  memory[0x40:0x60]
	//     @0460  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]
	//     @048B  memory[0x40:0x60]
	//     @048F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	// }
	03D8    5B  JUMPDEST
	03D9    60  PUSH1 0x00
	03DB    80  DUP1
	03DC    85  DUP6
	03DD    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03F2    16  AND
	03F3    60  PUSH1 0x00
	03F5    63  PUSH4 0xa9059cbb
	03FA    60  PUSH1 0xe0
	03FC    1B  SHL
	03FD    87  DUP8
	03FE    87  DUP8
	03FF    60  PUSH1 0x40
	0401    51  MLOAD
	0402    60  PUSH1 0x24
	0404    01  ADD
	0405    80  DUP1
	0406    83  DUP4
	0407    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	041C    16  AND
	041D    81  DUP2
	041E    52  MSTORE
	041F    60  PUSH1 0x20
	0421    01  ADD
	0422    82  DUP3
	0423    81  DUP2
	0424    52  MSTORE
	0425    60  PUSH1 0x20
	0427    01  ADD
	0428    92  SWAP3
	0429    50  POP
	042A    50  POP
	042B    50  POP
	042C    60  PUSH1 0x40
	042E    51  MLOAD
	042F    60  PUSH1 0x20
	0431    81  DUP2
	0432    83  DUP4
	0433    03  SUB
	0434    03  SUB
	0435    81  DUP2
	0436    52  MSTORE
	0437    90  SWAP1
	0438    60  PUSH1 0x40
	043A    52  MSTORE
	043B    90  SWAP1
	043C    7B  PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0459    19  NOT
	045A    16  AND
	045B    60  PUSH1 0x20
	045D    82  DUP3
	045E    01  ADD
	045F    80  DUP1
	0460    51  MLOAD
	0461    7B  PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	047E    83  DUP4
	047F    81  DUP2
	0480    83  DUP4
	0481    16  AND
	0482    17  OR
	0483    83  DUP4
	0484    52  MSTORE
	0485    50  POP
	0486    50  POP
	0487    50  POP
	0488    50  POP
	0489    60  PUSH1 0x40
	048B    51  MLOAD
	048C    80  DUP1
	048D    82  DUP3
	048E    80  DUP1
	048F    51  MLOAD
	0490    90  SWAP1
	0491    60  PUSH1 0x20
	0493    01  ADD
	0494    90  SWAP1
	0495    80  DUP1
	0496    83  DUP4
	0497    83  DUP4
	0498    5B  JUMPDEST
	0499    60  PUSH1 0x20
	049B    83  DUP4
	049C    10  LT
	049D    61  PUSH2 0x04bb
	04A0    57  *JUMPI
	// Stack delta = +12
	// Outputs[17]
	// {
	//     @03D9  stack[0] = 0x00
	//     @03DB  stack[1] = 0x00
	//     @03F2  stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @03F3  stack[3] = 0x00
	//     @041E  memory[0x24 + memory[0x40:0x60]:0x24 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @0424  memory[0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x24 + memory[0x40:0x60] + 0x20] = stack[-2]
	//     @0436  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x24 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20
	//     @043A  memory[0x40:0x60] = 0x20 + 0x20 + 0x24 + memory[0x40:0x60]
	//     @043B  stack[4] = memory[0x40:0x60]
	//     @0484  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xa9059cbb << 0xe0))
	//     @048B  stack[5] = memory[0x40:0x60]
	//     @048C  stack[6] = memory[0x40:0x60]
	//     @0494  stack[7] = 0x20 + memory[0x40:0x60]
	//     @0494  stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	//     @0495  stack[9] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	//     @0496  stack[10] = memory[0x40:0x60]
	//     @0497  stack[11] = 0x20 + memory[0x40:0x60]
	// }
	// Block ends with conditional jump to 0x04bb, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20

label_04A1:
	// Incoming jump from 0x04A0, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20
	// Incoming jump from 0x04A0, if not stack[-3] < 0x20
	// Inputs[4]
	// {
	//     @04A1  stack[-1]
	//     @04A2  memory[stack[-1]:stack[-1] + 0x20]
	//     @04A3  stack[-2]
	//     @04B3  stack[-3]
	// }
	04A1    80  DUP1
	04A2    51  MLOAD
	04A3    82  DUP3
	04A4    52  MSTORE
	04A5    60  PUSH1 0x20
	04A7    82  DUP3
	04A8    01  ADD
	04A9    91  SWAP2
	04AA    50  POP
	04AB    60  PUSH1 0x20
	04AD    81  DUP2
	04AE    01  ADD
	04AF    90  SWAP1
	04B0    50  POP
	04B1    60  PUSH1 0x20
	04B3    83  DUP4
	04B4    03  SUB
	04B5    92  SWAP3
	04B6    50  POP
	04B7    61  PUSH2 0x0498
	04BA    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @04A4  memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @04A9  stack[-2] = stack[-2] + 0x20
	//     @04AF  stack[-1] = stack[-1] + 0x20
	//     @04B5  stack[-3] = stack[-3] - 0x20
	// }
	// Block ends with unconditional jump to 0x0498

label_04BB:
	// Incoming jump from 0x04A0, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20
	// Incoming jump from 0x04A0, if stack[-3] < 0x20
	// Inputs[16]
	// {
	//     @04BE  stack[-3]
	//     @04C9  stack[-1]
	//     @04CA  memory[stack[-1]:stack[-1] + 0x20]
	//     @04CD  stack[-2]
	//     @04CE  memory[stack[-2]:stack[-2] + 0x20]
	//     @04DB  stack[-4]
	//     @04DB  stack[-5]
	//     @04DD  stack[-6]
	//     @04DE  stack[-8]
	//     @04E5  memory[0x40:0x60]
	//     @04EA  stack[-9]
	//     @04EB  stack[-10]
	//     @04EC  msg.gas
	//     @04ED  memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]
	//     @04ED  address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @04F2  returndata.length
	// }
	04BB    5B  JUMPDEST
	04BC    60  PUSH1 0x01
	04BE    83  DUP4
	04BF    60  PUSH1 0x20
	04C1    03  SUB
	04C2    61  PUSH2 0x0100
	04C5    0A  EXP
	04C6    03  SUB
	04C7    80  DUP1
	04C8    19  NOT
	04C9    82  DUP3
	04CA    51  MLOAD
	04CB    16  AND
	04CC    81  DUP2
	04CD    84  DUP5
	04CE    51  MLOAD
	04CF    16  AND
	04D0    80  DUP1
	04D1    82  DUP3
	04D2    17  OR
	04D3    85  DUP6
	04D4    52  MSTORE
	04D5    50  POP
	04D6    50  POP
	04D7    50  POP
	04D8    50  POP
	04D9    50  POP
	04DA    50  POP
	04DB    90  SWAP1
	04DC    50  POP
	04DD    01  ADD
	04DE    91  SWAP2
	04DF    50  POP
	04E0    50  POP
	04E1    60  PUSH1 0x00
	04E3    60  PUSH1 0x40
	04E5    51  MLOAD
	04E6    80  DUP1
	04E7    83  DUP4
	04E8    03  SUB
	04E9    81  DUP2
	04EA    85  DUP6
	04EB    87  DUP8
	04EC    5A  GAS
	04ED    F1  CALL
	04EE    92  SWAP3
	04EF    50  POP
	04F0    50  POP
	04F1    50  POP
	04F2    3D  RETURNDATASIZE
	04F3    80  DUP1
	04F4    60  PUSH1 0x00
	04F6    81  DUP2
	04F7    14  EQ
	04F8    61  PUSH2 0x051d
	04FB    57  *JUMPI
	// Stack delta = -7
	// Outputs[5]
	// {
	//     @04D4  memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01)
	//     @04ED  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @04EE  stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @04F2  stack[-9] = returndata.length
	//     @04F3  stack[-8] = returndata.length
	// }
	// Block ends with conditional jump to 0x051d, if returndata.length == 0x00

label_04FC:
	// Incoming jump from 0x04FB, if not returndata.length == 0x00
	// Inputs[6]
	// {
	//     @04FE  memory[0x40:0x60]
	//     @04FF  stack[-2]
	//     @0506  returndata.length
	//     @050E  returndata.length
	//     @0511  returndata.length
	//     @0518  returndata[0x00:0x00 + returndata.length]
	// }
	04FC    60  PUSH1 0x40
	04FE    51  MLOAD
	04FF    91  SWAP2
	0500    50  POP
	0501    60  PUSH1 0x1f
	0503    19  NOT
	0504    60  PUSH1 0x3f
	0506    3D  RETURNDATASIZE
	0507    01  ADD
	0508    16  AND
	0509    82  DUP3
	050A    01  ADD
	050B    60  PUSH1 0x40
	050D    52  MSTORE
	050E    3D  RETURNDATASIZE
	050F    82  DUP3
	0510    52  MSTORE
	0511    3D  RETURNDATASIZE
	0512    60  PUSH1 0x00
	0514    60  PUSH1 0x20
	0516    84  DUP5
	0517    01  ADD
	0518    3E  RETURNDATACOPY
	0519    61  PUSH2 0x0522
	051C    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @04FF  stack[-2] = memory[0x40:0x60]
	//     @050D  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f)
	//     @0510  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length
	//     @0518  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	// }
	// Block ends with unconditional jump to 0x0522

label_051D:
	// Incoming jump from 0x04FB, if returndata.length == 0x00
	// Inputs[4]
	// {
	//     @0520  stack[-2]
	//     @0524  stack[-4]
	//     @0526  stack[-5]
	//     @0526  stack[-3]
	// }
	051D    5B  JUMPDEST
	051E    60  PUSH1 0x60
	0520    91  SWAP2
	0521    50  POP
	0522    5B  JUMPDEST
	0523    50  POP
	0524    91  SWAP2
	0525    50  POP
	0526    91  SWAP2
	0527    50  POP
	0528    81  DUP2
	0529    61  PUSH2 0x059a
	052C    57  *JUMPI
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @0524  stack[-4] = 0x60
	//     @0526  stack[-5] = stack[-3]
	// }
	// Block ends with conditional jump to 0x059a, if stack[-3]

label_052D:
	// Incoming jump from 0x052C, if not stack[-3]
	// Incoming jump from 0x052C, if not stack[-3]
	// Inputs[3]
	// {
	//     @052F  memory[0x40:0x60]
	//     @0594  memory[0x40:0x60]
	//     @0599  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	052D    60  PUSH1 0x40
	052F    51  MLOAD
	0530    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0551    81  DUP2
	0552    52  MSTORE
	0553    60  PUSH1 0x04
	0555    01  ADD
	0556    80  DUP1
	0557    80  DUP1
	0558    60  PUSH1 0x20
	055A    01  ADD
	055B    82  DUP3
	055C    81  DUP2
	055D    03  SUB
	055E    82  DUP3
	055F    52  MSTORE
	0560    60  PUSH1 0x15
	0562    81  DUP2
	0563    52  MSTORE
	0564    60  PUSH1 0x20
	0566    01  ADD
	0567    80  DUP1
	0568    7F  PUSH32 0x546f6b656e207472616e73666572206661696c65640000000000000000000000
	0589    81  DUP2
	058A    52  MSTORE
	058B    50  POP
	058C    60  PUSH1 0x20
	058E    01  ADD
	058F    91  SWAP2
	0590    50  POP
	0591    50  POP
	0592    60  PUSH1 0x40
	0594    51  MLOAD
	0595    80  DUP1
	0596    91  SWAP2
	0597    03  SUB
	0598    90  SWAP1
	0599    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0552  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @055F  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0563  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x15
	//     @058A  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x546f6b656e207472616e73666572206661696c65640000000000000000000000
	//     @0599  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_059A:
	// Incoming jump from 0x052C, if stack[-3]
	// Incoming jump from 0x052C, if stack[-3]
	// Inputs[1] { @05A1  stack[-7] }
	059A    5B  JUMPDEST
	059B    50  POP
	059C    50  POP
	059D    50  POP
	059E    50  POP
	059F    50  POP
	05A0    50  POP
	05A1    56  *JUMP
	// Stack delta = -7
	// Block ends with unconditional jump to stack[-7]

label_05A2:
	// Incoming jump from 0x00E9
	// Inputs[1] { @05CE  msg.sender }
	05A2    5B  JUMPDEST
	05A3    73  PUSH20 0x6eedf92fb92dd68a270c3205e96dccc527728066
	05B8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	05CD    16  AND
	05CE    33  CALLER
	05CF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	05E4    16  AND
	05E5    14  EQ
	05E6    61  PUSH2 0x0657
	05E9    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0657, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066

label_05EA:
	// Incoming jump from 0x05E9, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[3]
	// {
	//     @05EC  memory[0x40:0x60]
	//     @0651  memory[0x40:0x60]
	//     @0656  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	05EA    60  PUSH1 0x40
	05EC    51  MLOAD
	05ED    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	060E    81  DUP2
	060F    52  MSTORE
	0610    60  PUSH1 0x04
	0612    01  ADD
	0613    80  DUP1
	0614    80  DUP1
	0615    60  PUSH1 0x20
	0617    01  ADD
	0618    82  DUP3
	0619    81  DUP2
	061A    03  SUB
	061B    82  DUP3
	061C    52  MSTORE
	061D    60  PUSH1 0x20
	061F    81  DUP2
	0620    52  MSTORE
	0621    60  PUSH1 0x20
	0623    01  ADD
	0624    80  DUP1
	0625    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	0646    81  DUP2
	0647    52  MSTORE
	0648    50  POP
	0649    60  PUSH1 0x20
	064B    01  ADD
	064C    91  SWAP2
	064D    50  POP
	064E    50  POP
	064F    60  PUSH1 0x40
	0651    51  MLOAD
	0652    80  DUP1
	0653    91  SWAP2
	0654    03  SUB
	0655    90  SWAP1
	0656    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @060F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @061C  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0620  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @0647  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @0656  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0657:
	// Incoming jump from 0x05E9, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[3]
	// {
	//     @0658  stack[-1]
	//     @0659  stack[-2]
	//     @065D  stack[-3]
	// }
	0657    5B  JUMPDEST
	0658    80  DUP1
	0659    82  DUP3
	065A    55  SSTORE
	065B    50  POP
	065C    50  POP
	065D    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @065A  storage[stack[-2]] = stack[-1] }
	// Block ends with unconditional jump to stack[-3]

label_065E:
	// Incoming jump from 0x0137
	// Inputs[1] { @068A  msg.sender }
	065E    5B  JUMPDEST
	065F    73  PUSH20 0x6eedf92fb92dd68a270c3205e96dccc527728066
	0674    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0689    16  AND
	068A    33  CALLER
	068B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	06A0    16  AND
	06A1    14  EQ
	06A2    61  PUSH2 0x0713
	06A5    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0713, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066

label_06A6:
	// Incoming jump from 0x06A5, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[3]
	// {
	//     @06A8  memory[0x40:0x60]
	//     @070D  memory[0x40:0x60]
	//     @0712  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	06A6    60  PUSH1 0x40
	06A8    51  MLOAD
	06A9    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	06CA    81  DUP2
	06CB    52  MSTORE
	06CC    60  PUSH1 0x04
	06CE    01  ADD
	06CF    80  DUP1
	06D0    80  DUP1
	06D1    60  PUSH1 0x20
	06D3    01  ADD
	06D4    82  DUP3
	06D5    81  DUP2
	06D6    03  SUB
	06D7    82  DUP3
	06D8    52  MSTORE
	06D9    60  PUSH1 0x20
	06DB    81  DUP2
	06DC    52  MSTORE
	06DD    60  PUSH1 0x20
	06DF    01  ADD
	06E0    80  DUP1
	06E1    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	0702    81  DUP2
	0703    52  MSTORE
	0704    50  POP
	0705    60  PUSH1 0x20
	0707    01  ADD
	0708    91  SWAP2
	0709    50  POP
	070A    50  POP
	070B    60  PUSH1 0x40
	070D    51  MLOAD
	070E    80  DUP1
	070F    91  SWAP2
	0710    03  SUB
	0711    90  SWAP1
	0712    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @06CB  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @06D8  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @06DC  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @0703  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @0712  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0713:
	// Incoming jump from 0x06A5, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x6eedf92fb92dd68a270c3205e96dccc527728066
	// Inputs[1] { @0735  stack[-1] }
	0713    5B  JUMPDEST
	0714    7F  PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0735    81  DUP2
	0736    14  EQ
	0737    15  ISZERO
	0738    61  PUSH2 0x073f
	073B    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x073f, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)

label_073C:
	// Incoming jump from 0x073B, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
	// Inputs[5]
	// {
	//     @073C  address(this).balance
	//     @073C  address(this)
	//     @073D  stack[-1]
	//     @0741  address(this)
	//     @0741  address(this).balance
	// }
	073C    47  SELFBALANCE
	073D    90  SWAP1
	073E    50  POP
	073F    5B  JUMPDEST
	0740    80  DUP1
	0741    47  SELFBALANCE
	0742    10  LT
	0743    15  ISZERO
	0744    61  PUSH2 0x07b5
	0747    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @073D  stack[-1] = address(this).balance }
	// Block ends with conditional jump to 0x07b5, if !(address(this).balance < address(this).balance)

label_0748:
	// Incoming jump from 0x0747, if not !(address(this).balance < stack[-1])
	// Incoming jump from 0x0747, if not !(address(this).balance < address(this).balance)
	// Inputs[3]
	// {
	//     @074A  memory[0x40:0x60]
	//     @07AF  memory[0x40:0x60]
	//     @07B4  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0748    60  PUSH1 0x40
	074A    51  MLOAD
	074B    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	076C    81  DUP2
	076D    52  MSTORE
	076E    60  PUSH1 0x04
	0770    01  ADD
	0771    80  DUP1
	0772    80  DUP1
	0773    60  PUSH1 0x20
	0775    01  ADD
	0776    82  DUP3
	0777    81  DUP2
	0778    03  SUB
	0779    82  DUP3
	077A    52  MSTORE
	077B    60  PUSH1 0x14
	077D    81  DUP2
	077E    52  MSTORE
	077F    60  PUSH1 0x20
	0781    01  ADD
	0782    80  DUP1
	0783    7F  PUSH32 0x496e73756666696369656e742062616c616e6365000000000000000000000000
	07A4    81  DUP2
	07A5    52  MSTORE
	07A6    50  POP
	07A7    60  PUSH1 0x20
	07A9    01  ADD
	07AA    91  SWAP2
	07AB    50  POP
	07AC    50  POP
	07AD    60  PUSH1 0x40
	07AF    51  MLOAD
	07B0    80  DUP1
	07B1    91  SWAP2
	07B2    03  SUB
	07B3    90  SWAP1
	07B4    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @076D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @077A  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @077E  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x14
	//     @07A5  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x496e73756666696369656e742062616c616e6365000000000000000000000000
	//     @07B4  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_07B5:
	// Incoming jump from 0x0747, if !(address(this).balance < stack[-1])
	// Incoming jump from 0x0747, if !(address(this).balance < address(this).balance)
	// Inputs[6]
	// {
	//     @07B6  stack[-2]
	//     @07D0  stack[-1]
	//     @07D8  memory[0x40:0x60]
	//     @07DD  memory[0x40:0x60]
	//     @07E5  memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]
	//     @07E5  address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]])
	// }
	07B5    5B  JUMPDEST
	07B6    81  DUP2
	07B7    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	07CC    16  AND
	07CD    61  PUSH2 0x08fc
	07D0    82  DUP3
	07D1    90  SWAP1
	07D2    81  DUP2
	07D3    15  ISZERO
	07D4    02  MUL
	07D5    90  SWAP1
	07D6    60  PUSH1 0x40
	07D8    51  MLOAD
	07D9    60  PUSH1 0x00
	07DB    60  PUSH1 0x40
	07DD    51  MLOAD
	07DE    80  DUP1
	07DF    83  DUP4
	07E0    03  SUB
	07E1    81  DUP2
	07E2    85  DUP6
	07E3    88  DUP9
	07E4    88  DUP9
	07E5    F1  CALL
	07E6    93  SWAP4
	07E7    50  POP
	07E8    50  POP
	07E9    50  POP
	07EA    50  POP
	07EB    15  ISZERO
	07EC    80  DUP1
	07ED    15  ISZERO
	07EE    61  PUSH2 0x07fb
	07F1    57  *JUMPI
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @07E5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]])
	//     @07EB  stack[0] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).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 0x07fb, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]])

label_07F2:
	// Incoming jump from 0x07F1, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]])
	// Inputs[4]
	// {
	//     @07F2  returndata.length
	//     @07F6  returndata[0x00:0x00 + returndata.length]
	//     @07F7  returndata.length
	//     @07FA  memory[0x00:0x00 + returndata.length]
	// }
	07F2    3D  RETURNDATASIZE
	07F3    60  PUSH1 0x00
	07F5    80  DUP1
	07F6    3E  RETURNDATACOPY
	07F7    3D  RETURNDATASIZE
	07F8    60  PUSH1 0x00
	07FA    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @07F6  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @07FA  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_07FB:
	// Incoming jump from 0x07F1, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]])
	// Inputs[1] { @07FF  stack[-4] }
	07FB    5B  JUMPDEST
	07FC    50  POP
	07FD    50  POP
	07FE    50  POP
	07FF    56  *JUMP
	// Stack delta = -4
	// Block ends with unconditional jump to stack[-4]

	0800    FE    *ASSERT
	0801    A2    LOG2
	0802    64    PUSH5 0x6970667358
	0808    22    22
	0809    12    SLT
	080A    20    SHA3
	080B    F2    CALLCODE
	080C    03    SUB
	080D    C6    C6
	080E    0C    0C
	080F    02    MUL
	0810    81    DUP2
	0811    99    SWAP10
	0812    D6    D6
	0813    FE    *ASSERT
	0814    B9    B9
	0815    5B    JUMPDEST
	0816    B2    SWAP
	0817    3B    EXTCODESIZE
	0818    61    PUSH2 0x59d3
	081B    44    DIFFICULTY
	081C    FE    *ASSERT
	081D    5B    JUMPDEST
	081E    88    DUP9
	081F    08    ADDMOD
	0820    ED    ED
	0821    88    DUP9
	0822    5F    5F
	0823    A2    LOG2
	0824    00    *STOP
	0825    92    SWAP3
	0826    A6    A6
	0827    D8    D8
	0828    F6    F6
	0829    8E    DUP15
	082A    CE    CE
	082B    64    PUSH5 0x736f6c6343
	0831    00    *STOP
	0832    07    SMOD
	0833    06    MOD
	0834    00    *STOP
	0835    33    CALLER