Online Solidity Decompiler

« Decompile another contract

Address

0x5cc5b05a8a13e3fbdb0bb9fccd98d38e50f90c38 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x3659cfe6 upgradeTo(address)

0x4f1ef286 upgradeToAndCall(address,bytes)

0x5c60da1b implementation()

0x8f283970 changeAdmin(address)

0xf851a440 admin()

Internal Methods

upgradeToAndCall(arg0, arg1)

changeAdmin(arg0, arg1)

func_01ED()

implementation() returns (r0)

func_0476() returns (r0)

func_04BB(arg0) returns (r0)

func_058B() returns (r0)

func_05D4() returns (r0)

func_05F9(arg0)

func_0646(arg0)

func_066A(arg0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
    
        if (msg.data.length >= 0x04) {
            var0 = msg.data[0x00:0x20] >> 0xe0;
        
            if (0x5c60da1b > var0) {
                if (var0 == 0x3659cfe6) {
                    // Dispatch table entry for upgradeTo(address)
                    var1 = msg.value;
                
                    if (var1) { revert(memory[0x00:0x00]); }
                
                    var1 = 0x006b;
                    var2 = 0x04;
                    var var3 = msg.data.length - var2;
                
                    if (var3 < 0x20) { revert(memory[0x00:0x00]); }
                
                    var2 = msg.data[var2:var2 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
                    var3 = 0x01f7;
                    var3 = func_05D4();
                
                    if (msg.sender != var3 & 0xffffffffffffffffffffffffffffffffffffffff) {
                        var3 = 0x0240;
                        goto label_01D5;
                    } else {
                        var3 = 0x0233;
                        var var4 = var2;
                        func_05F9(var4);
                        // Error: Could not resolve jump destination!
                    }
                } else if (var0 == 0x4f1ef286) {
                    // Dispatch table entry for upgradeToAndCall(address,bytes)
                    var1 = 0x006b;
                    var2 = 0x04;
                    var3 = msg.data.length - var2;
                
                    if (var3 < 0x40) { revert(memory[0x00:0x00]); }
                
                    upgradeToAndCall(var2, var3);
                    stop();
                } else { goto label_006D; }
            } else if (var0 == 0x5c60da1b) {
                // Dispatch table entry for implementation()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0157;
                var1 = implementation();
            
            label_0157:
                var temp5 = memory[0x40:0x60];
                memory[temp5:temp5 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff;
                var temp6 = memory[0x40:0x60];
                return memory[temp6:temp6 + temp5 - temp6 + 0x20];
            } else if (var0 == 0x8f283970) {
                // Dispatch table entry for changeAdmin(address)
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x006b;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                changeAdmin(var2, var3);
                stop();
            } else if (var0 == 0xf851a440) {
                // Dispatch table entry for admin()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0157;
                var1 = func_0476();
                goto label_0157;
            } else { goto label_006D; }
        } else if (msg.data.length) {
        label_006D:
            var var0 = 0x006b;
        
        label_01D5:
            var var1 = 0x01dd;
            var var2 = 0x04ff;
            var2 = func_05D4();
        
            if (msg.sender != var2 & 0xffffffffffffffffffffffffffffffffffffffff) {
                var2 = 0x01ed;
                func_01ED();
                func_01ED();
                // Error: Could not resolve method call return address!
            } else {
                var temp0 = memory[0x40:0x60];
                memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                var temp1 = temp0 + 0x04;
                var temp2 = temp1 + 0x20;
                memory[temp1:temp1 + 0x20] = temp2 - temp1;
                memory[temp2:temp2 + 0x20] = 0x42;
                var temp3 = temp2 + 0x20;
                memory[temp3:temp3 + 0x42] = code[0x075d:0x079f];
                var temp4 = memory[0x40:0x60];
                revert(memory[temp4:temp4 + (temp3 + 0x60) - temp4]);
            }
        } else {
            var0 = 0x006b;
            goto label_01D5;
        }
    }
    
    function upgradeToAndCall(var arg0, var arg1) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        var var0 = temp0;
        arg1 = var0 + arg1;
        var var1 = var0 + 0x40;
        var var2 = msg.data[var0 + 0x20:var0 + 0x20 + 0x20];
    
        if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); }
    
        var temp1 = var0 + var2;
        var2 = temp1;
    
        if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); }
    
        var temp2 = var2;
        var temp3 = msg.data[temp2:temp2 + 0x20];
        var2 = temp3;
        var var3 = var1;
        var1 = temp2 + 0x20;
    
        if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); }
    
        arg1 = var1;
        var0 = var2;
        var1 = 0x024b;
        var1 = func_05D4();
    
        if (msg.sender != var1 & 0xffffffffffffffffffffffffffffffffffffffff) {
            var1 = 0x0312;
            var2 = 0x01dd;
            var3 = 0x04ff;
            var3 = func_05D4();
        
            if (msg.sender != var3 & 0xffffffffffffffffffffffffffffffffffffffff) {
                var3 = 0x01ed;
                func_01ED();
                func_01ED();
                // Error: Could not resolve method call return address!
            } else {
                var temp4 = memory[0x40:0x60];
                memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                var temp5 = temp4 + 0x04;
                var temp6 = temp5 + 0x20;
                memory[temp5:temp5 + 0x20] = temp6 - temp5;
                memory[temp6:temp6 + 0x20] = 0x42;
                var temp7 = temp6 + 0x20;
                memory[temp7:temp7 + 0x42] = code[0x075d:0x079f];
                var temp8 = memory[0x40:0x60];
                revert(memory[temp8:temp8 + (temp7 + 0x60) - temp8]);
            }
        } else {
            var1 = 0x0287;
            var2 = arg0;
            func_05F9(var2);
            var1 = 0x00;
            var temp9 = var0;
            var temp10 = memory[0x40:0x60];
            memory[temp10:temp10 + temp9] = msg.data[arg1:arg1 + temp9];
            var temp11 = memory[0x40:0x60];
            var temp12;
            temp12, memory[temp11:temp11 + 0x00] = address(arg0 & 0xffffffffffffffffffffffffffffffffffffffff).delegatecall.gas(msg.gas)(memory[temp11:temp11 + (temp10 + temp9) - temp11]);
            var3 = returndata.length;
            var var4 = var3;
        
            if (var4 == 0x00) {
                var1 = var2;
            
                if (!var1) { revert(memory[0x00:0x00]); }
            
            label_0304:
                return;
            } else {
                var temp13 = memory[0x40:0x60];
                var3 = temp13;
                memory[0x40:0x60] = var3 + (returndata.length + 0x3f & ~0x1f);
                memory[var3:var3 + 0x20] = returndata.length;
                var temp14 = returndata.length;
                memory[var3 + 0x20:var3 + 0x20 + temp14] = returndata[0x00:0x00 + temp14];
                var1 = var2;
            
                if (var1) { goto label_0304; }
                else { revert(memory[0x00:0x00]); }
            }
        }
    }
    
    function changeAdmin(var arg0, var arg1) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = 0x0376;
        arg1 = func_05D4();
    
        if (msg.sender != arg1 & 0xffffffffffffffffffffffffffffffffffffffff) {
            arg1 = 0x0240;
            var var0 = 0x01dd;
            var var1 = 0x04ff;
            var1 = func_05D4();
        
            if (msg.sender != var1 & 0xffffffffffffffffffffffffffffffffffffffff) {
                var1 = 0x01ed;
                func_01ED();
                func_01ED();
                // Error: Could not resolve method call return address!
            } else {
                var temp0 = memory[0x40:0x60];
                memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                var temp1 = temp0 + 0x04;
                var temp2 = temp1 + 0x20;
                memory[temp1:temp1 + 0x20] = temp2 - temp1;
                memory[temp2:temp2 + 0x20] = 0x42;
                var temp3 = temp2 + 0x20;
                memory[temp3:temp3 + 0x42] = code[0x075d:0x079f];
                var temp4 = memory[0x40:0x60];
                revert(memory[temp4:temp4 + (temp3 + 0x60) - temp4]);
            }
        } else if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) {
            arg1 = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f;
            var0 = 0x043e;
            var0 = func_05D4();
            var temp5 = memory[0x40:0x60];
            memory[temp5:temp5 + 0x20] = var0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[temp5 + 0x20:temp5 + 0x20 + 0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            var temp6 = memory[0x40:0x60];
            log(memory[temp6:temp6 + temp5 - temp6 + 0x40], [stack[-2]]);
            arg1 = 0x0233;
            var0 = arg0;
            func_0646(var0);
            return;
        } else {
            var temp7 = memory[0x40:0x60];
            memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp8 = temp7 + 0x04;
            var temp9 = temp8 + 0x20;
            memory[temp8:temp8 + 0x20] = temp9 - temp8;
            memory[temp9:temp9 + 0x20] = 0x3a;
            var temp10 = temp9 + 0x20;
            memory[temp10:temp10 + 0x3a] = code[0x06ed:0x0727];
            var temp11 = memory[0x40:0x60];
            revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]);
        }
    }
    
    function func_01ED() {}
    
    function implementation() returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x0321;
        var1 = func_05D4();
    
        if (msg.sender != var1 & 0xffffffffffffffffffffffffffffffffffffffff) {
            var1 = 0x036b;
            var var2 = 0x01dd;
            var var3 = 0x04ff;
            var3 = func_05D4();
        
            if (msg.sender != var3 & 0xffffffffffffffffffffffffffffffffffffffff) {
                var3 = 0x01ed;
                func_01ED();
                func_01ED();
                // Error: Could not resolve method call return address!
            } else {
                var temp0 = memory[0x40:0x60];
                memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                var temp1 = temp0 + 0x04;
                var temp2 = temp1 + 0x20;
                memory[temp1:temp1 + 0x20] = temp2 - temp1;
                memory[temp2:temp2 + 0x20] = 0x42;
                var temp3 = temp2 + 0x20;
                memory[temp3:temp3 + 0x42] = code[0x075d:0x079f];
                var temp4 = memory[0x40:0x60];
                revert(memory[temp4:temp4 + (temp3 + 0x60) - temp4]);
            }
        } else {
            var1 = 0x035c;
            return func_058B();
        }
    }
    
    function func_0476() returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x0480;
        var1 = func_05D4();
    
        if (msg.sender != var1 & 0xffffffffffffffffffffffffffffffffffffffff) {
            var1 = 0x036b;
            var var2 = 0x01dd;
            var var3 = 0x04ff;
            var3 = func_05D4();
        
            if (msg.sender != var3 & 0xffffffffffffffffffffffffffffffffffffffff) {
                var3 = 0x01ed;
                func_01ED();
                func_01ED();
                // Error: Could not resolve method call return address!
            } else {
                var temp0 = memory[0x40:0x60];
                memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
                var temp1 = temp0 + 0x04;
                var temp2 = temp1 + 0x20;
                memory[temp1:temp1 + 0x20] = temp2 - temp1;
                memory[temp2:temp2 + 0x20] = 0x42;
                var temp3 = temp2 + 0x20;
                memory[temp3:temp3 + 0x42] = code[0x075d:0x079f];
                var temp4 = memory[0x40:0x60];
                revert(memory[temp4:temp4 + (temp3 + 0x60) - temp4]);
            }
        } else {
            var1 = 0x035c;
            return func_05D4();
        }
    }
    
    function func_04BB(var arg0) returns (var r0) {
        var var0 = 0x00;
        var var1 = keccak256(address(arg0).code);
        var var2 = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        var var3 = var2 != var1;
    
        if (var2 != var1) { return var3; }
        else { return !!var1; }
    }
    
    function func_058B() returns (var r0) { return storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]; }
    
    function func_05D4() returns (var r0) { return storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103]; }
    
    function func_05F9(var arg0) {
        var var0 = 0x0602;
        var var1 = arg0;
        func_066A(var1);
        log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]);
    }
    
    function func_0646(var arg0) {
        storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] = arg0;
    }
    
    function func_066A(var arg0) {
        var var0 = 0x0673;
        var var1 = arg0;
        var0 = func_04BB(var1);
    
        if (var0) {
            storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] = arg0;
            return;
        } else {
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp1 = temp0 + 0x04;
            var temp2 = temp1 + 0x20;
            memory[temp1:temp1 + 0x20] = temp2 - temp1;
            memory[temp2:temp2 + 0x20] = 0x36;
            var temp3 = temp2 + 0x20;
            memory[temp3:temp3 + 0x36] = code[0x0727:0x075d];
            var temp4 = memory[0x40:0x60];
            revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]);
        }
    }
}

Disassembly

label_0000:
	// Inputs[1] { @0007  msg.data.length }
	0000    60  PUSH1 0x80
	0002    60  PUSH1 0x40
	0004    52  MSTORE
	0005    60  PUSH1 0x04
	0007    36  CALLDATASIZE
	0008    10  LT
	0009    61  PUSH2 0x005e
	000C    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0004  memory[0x40:0x60] = 0x80 }
	// Block ends with conditional jump to 0x005e, if msg.data.length < 0x04

label_000D:
	// Incoming jump from 0x000C, if not msg.data.length < 0x04
	// Inputs[1] { @000F  msg.data[0x00:0x20] }
	000D    60  PUSH1 0x00
	000F    35  CALLDATALOAD
	0010    60  PUSH1 0xe0
	0012    1C  SHR
	0013    80  DUP1
	0014    63  PUSH4 0x5c60da1b
	0019    11  GT
	001A    61  PUSH2 0x0043
	001D    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0012  stack[0] = msg.data[0x00:0x20] >> 0xe0 }
	// Block ends with conditional jump to 0x0043, if 0x5c60da1b > msg.data[0x00:0x20] >> 0xe0

label_001E:
	// Incoming jump from 0x001D, if not 0x5c60da1b > msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @001E  stack[-1] }
	001E    80  DUP1
	001F    63  PUSH4 0x5c60da1b
	0024    14  EQ
	0025    61  PUSH2 0x0142
	0028    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0142, if 0x5c60da1b == stack[-1]

label_0029:
	// Incoming jump from 0x0028, if not 0x5c60da1b == stack[-1]
	// Inputs[1] { @0029  stack[-1] }
	0029    80  DUP1
	002A    63  PUSH4 0x8f283970
	002F    14  EQ
	0030    61  PUSH2 0x0180
	0033    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0180, if 0x8f283970 == stack[-1]

label_0034:
	// Incoming jump from 0x0033, if not 0x8f283970 == stack[-1]
	// Inputs[1] { @0034  stack[-1] }
	0034    80  DUP1
	0035    63  PUSH4 0xf851a440
	003A    14  EQ
	003B    61  PUSH2 0x01c0
	003E    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01c0, if 0xf851a440 == stack[-1]

label_003F:
	// Incoming jump from 0x003E, if not 0xf851a440 == stack[-1]
	003F    61  PUSH2 0x006d
	0042    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x006d

label_0043:
	// Incoming jump from 0x001D, if 0x5c60da1b > msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @0044  stack[-1] }
	0043    5B  JUMPDEST
	0044    80  DUP1
	0045    63  PUSH4 0x3659cfe6
	004A    14  EQ
	004B    61  PUSH2 0x0075
	004E    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0075, if 0x3659cfe6 == stack[-1]

label_004F:
	// Incoming jump from 0x004E, if not 0x3659cfe6 == stack[-1]
	// Inputs[1] { @004F  stack[-1] }
	004F    80  DUP1
	0050    63  PUSH4 0x4f1ef286
	0055    14  EQ
	0056    61  PUSH2 0x00b5
	0059    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00b5, if 0x4f1ef286 == stack[-1]

label_005A:
	// Incoming jump from 0x0059, if not 0x4f1ef286 == stack[-1]
	005A    61  PUSH2 0x006d
	005D    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x006d

label_005E:
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Inputs[1] { @005F  msg.data.length }
	005E    5B  JUMPDEST
	005F    36  CALLDATASIZE
	0060    61  PUSH2 0x006d
	0063    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x006d, if msg.data.length

label_0064:
	// Incoming jump from 0x0063, if not msg.data.length
	0064    61  PUSH2 0x006b
	0067    61  PUSH2 0x01d5
	006A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0064  stack[0] = 0x006b }
	// Block ends with unconditional jump to 0x01d5

label_006B:
	// Incoming return from call to 0x00CB at 0x00C6
	// Incoming return from call to 0x01A3 at 0x019E
	006B    5B  JUMPDEST
	006C    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @006C  stop(); }
	// Block terminates

label_006D:
	// Incoming jump from 0x0063, if msg.data.length
	// Incoming jump from 0x005D
	// Incoming jump from 0x0042
	006D    5B  JUMPDEST
	006E    61  PUSH2 0x006b
	0071    61  PUSH2 0x01d5
	0074    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @006E  stack[0] = 0x006b }
	// Block ends with unconditional jump to 0x01d5

label_0075:
	// Incoming jump from 0x004E, if 0x3659cfe6 == stack[-1]
	// Inputs[1] { @0076  msg.value }
	0075    5B  JUMPDEST
	0076    34  CALLVALUE
	0077    80  DUP1
	0078    15  ISZERO
	0079    61  PUSH2 0x0081
	007C    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0076  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0081, if !msg.value

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

label_0081:
	// Incoming jump from 0x007C, if !msg.value
	// Inputs[1] { @0089  msg.data.length }
	0081    5B  JUMPDEST
	0082    50  POP
	0083    61  PUSH2 0x006b
	0086    60  PUSH1 0x04
	0088    80  DUP1
	0089    36  CALLDATASIZE
	008A    03  SUB
	008B    60  PUSH1 0x20
	008D    81  DUP2
	008E    10  LT
	008F    15  ISZERO
	0090    61  PUSH2 0x0098
	0093    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0083  stack[-1] = 0x006b
	//     @0086  stack[0] = 0x04
	//     @008A  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional jump to 0x0098, if !(msg.data.length - 0x04 < 0x20)

label_0094:
	// Incoming jump from 0x0093, if not !(msg.data.length - 0x04 < 0x20)
	// Inputs[1] { @0097  memory[0x00:0x00] }
	0094    60  PUSH1 0x00
	0096    80  DUP1
	0097    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0097  revert(memory[0x00:0x00]); }
	// Block terminates

label_0098:
	// Incoming jump from 0x0093, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[2]
	// {
	//     @009A  stack[-2]
	//     @009A  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0098    5B  JUMPDEST
	0099    50  POP
	009A    35  CALLDATALOAD
	009B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	00B0    16  AND
	00B1    61  PUSH2 0x01ef
	00B4    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @00B0  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x01ef

label_00B5:
	// Incoming jump from 0x0059, if 0x4f1ef286 == stack[-1]
	// Inputs[1] { @00BC  msg.data.length }
	00B5    5B  JUMPDEST
	00B6    61  PUSH2 0x006b
	00B9    60  PUSH1 0x04
	00BB    80  DUP1
	00BC    36  CALLDATASIZE
	00BD    03  SUB
	00BE    60  PUSH1 0x40
	00C0    81  DUP2
	00C1    10  LT
	00C2    15  ISZERO
	00C3    61  PUSH2 0x00cb
	00C6    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @00B6  stack[0] = 0x006b
	//     @00B9  stack[1] = 0x04
	//     @00BD  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x00cb, returns to 0x006B, if !(msg.data.length - 0x04 < 0x40)

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

label_00CB:
	// Incoming call from 0x00C6, returns to 0x006B, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @00E1  stack[-2]
	//     @00E2  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @00E5  stack[-1]
	//     @00F1  msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	// }
	00CB    5B  JUMPDEST
	00CC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	00E1    82  DUP3
	00E2    35  CALLDATALOAD
	00E3    16  AND
	00E4    91  SWAP2
	00E5    90  SWAP1
	00E6    81  DUP2
	00E7    01  ADD
	00E8    90  SWAP1
	00E9    60  PUSH1 0x40
	00EB    81  DUP2
	00EC    01  ADD
	00ED    60  PUSH1 0x20
	00EF    82  DUP3
	00F0    01  ADD
	00F1    35  CALLDATALOAD
	00F2    64  PUSH5 0x0100000000
	00F8    81  DUP2
	00F9    11  GT
	00FA    15  ISZERO
	00FB    61  PUSH2 0x0103
	00FE    57  *JUMPI
	// Stack delta = +3
	// Outputs[5]
	// {
	//     @00E4  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff
	//     @00E8  stack[0] = stack[-2]
	//     @00E8  stack[-1] = stack[-2] + stack[-1]
	//     @00EC  stack[1] = stack[-2] + 0x40
	//     @00F1  stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	// }
	// Block ends with conditional jump to 0x0103, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000)

label_00FF:
	// Incoming jump from 0x00FE, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000)
	// 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.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000)
	// Inputs[3]
	// {
	//     @0104  stack[-3]
	//     @0105  stack[-1]
	//     @0106  stack[-4]
	// }
	0103    5B  JUMPDEST
	0104    82  DUP3
	0105    01  ADD
	0106    83  DUP4
	0107    60  PUSH1 0x20
	0109    82  DUP3
	010A    01  ADD
	010B    11  GT
	010C    15  ISZERO
	010D    61  PUSH2 0x0115
	0110    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0105  stack[-1] = stack[-3] + stack[-1] }
	// Block ends with conditional jump to 0x0115, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])

label_0111:
	// Incoming jump from 0x0110, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4])
	// Inputs[1] { @0114  memory[0x00:0x00] }
	0111    60  PUSH1 0x00
	0113    80  DUP1
	0114    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0114  revert(memory[0x00:0x00]); }
	// Block terminates

label_0115:
	// Incoming jump from 0x0110, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])
	// Inputs[4]
	// {
	//     @0116  stack[-1]
	//     @0117  msg.data[stack[-1]:stack[-1] + 0x20]
	//     @011C  stack[-2]
	//     @011D  stack[-4]
	// }
	0115    5B  JUMPDEST
	0116    80  DUP1
	0117    35  CALLDATALOAD
	0118    90  SWAP1
	0119    60  PUSH1 0x20
	011B    01  ADD
	011C    91  SWAP2
	011D    84  DUP5
	011E    60  PUSH1 0x01
	0120    83  DUP4
	0121    02  MUL
	0122    84  DUP5
	0123    01  ADD
	0124    11  GT
	0125    64  PUSH5 0x0100000000
	012B    83  DUP4
	012C    11  GT
	012D    17  OR
	012E    15  ISZERO
	012F    61  PUSH2 0x0137
	0132    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0118  stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20]
	//     @011C  stack[0] = stack[-2]
	//     @011C  stack[-2] = 0x20 + stack[-1]
	// }
	// Block ends with conditional jump to 0x0137, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4]))

label_0133:
	// Incoming jump from 0x0132, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4]))
	// Inputs[1] { @0136  memory[0x00:0x00] }
	0133    60  PUSH1 0x00
	0135    80  DUP1
	0136    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0136  revert(memory[0x00:0x00]); }
	// Block terminates

label_0137:
	// Incoming jump from 0x0132, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4]))
	// Inputs[4]
	// {
	//     @0139  stack[-2]
	//     @0139  stack[-3]
	//     @013A  stack[-5]
	//     @013C  stack[-4]
	// }
	0137    5B  JUMPDEST
	0138    50  POP
	0139    90  SWAP1
	013A    92  SWAP3
	013B    50  POP
	013C    90  SWAP1
	013D    50  POP
	013E    61  PUSH2 0x0243
	0141    56  *JUMP
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @013A  stack[-5] = stack[-3]
	//     @013C  stack[-4] = stack[-2]
	// }
	// Block ends with unconditional jump to 0x0243

label_0142:
	// Incoming jump from 0x0028, if 0x5c60da1b == stack[-1]
	// Inputs[1] { @0143  msg.value }
	0142    5B  JUMPDEST
	0143    34  CALLVALUE
	0144    80  DUP1
	0145    15  ISZERO
	0146    61  PUSH2 0x014e
	0149    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0143  stack[0] = msg.value }
	// Block ends with conditional jump to 0x014e, if !msg.value

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

label_014E:
	// Incoming jump from 0x0149, if !msg.value
	014E    5B  JUMPDEST
	014F    50  POP
	0150    61  PUSH2 0x0157
	0153    61  PUSH2 0x0317
	0156    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0150  stack[-1] = 0x0157 }
	// Block ends with call to 0x0317, returns to 0x0157

label_0157:
	// Incoming return from call to 0x0476 at 0x01D4
	// Incoming return from call to 0x0317 at 0x0156
	// Inputs[4]
	// {
	//     @015B  memory[0x40:0x60]
	//     @0172  stack[-1]
	//     @0176  memory[0x40:0x60]
	//     @017F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]
	// }
	0157    5B  JUMPDEST
	0158    60  PUSH1 0x40
	015A    80  DUP1
	015B    51  MLOAD
	015C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0171    90  SWAP1
	0172    92  SWAP3
	0173    16  AND
	0174    82  DUP3
	0175    52  MSTORE
	0176    51  MLOAD
	0177    90  SWAP1
	0178    81  DUP2
	0179    90  SWAP1
	017A    03  SUB
	017B    60  PUSH1 0x20
	017D    01  ADD
	017E    90  SWAP1
	017F    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0175  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff
	//     @017F  return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])];
	// }
	// Block terminates

label_0180:
	// Incoming jump from 0x0033, if 0x8f283970 == stack[-1]
	// Inputs[1] { @0181  msg.value }
	0180    5B  JUMPDEST
	0181    34  CALLVALUE
	0182    80  DUP1
	0183    15  ISZERO
	0184    61  PUSH2 0x018c
	0187    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0181  stack[0] = msg.value }
	// Block ends with conditional jump to 0x018c, if !msg.value

label_0188:
	// Incoming jump from 0x0187, if not !msg.value
	// Inputs[1] { @018B  memory[0x00:0x00] }
	0188    60  PUSH1 0x00
	018A    80  DUP1
	018B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @018B  revert(memory[0x00:0x00]); }
	// Block terminates

label_018C:
	// Incoming jump from 0x0187, if !msg.value
	// Inputs[1] { @0194  msg.data.length }
	018C    5B  JUMPDEST
	018D    50  POP
	018E    61  PUSH2 0x006b
	0191    60  PUSH1 0x04
	0193    80  DUP1
	0194    36  CALLDATASIZE
	0195    03  SUB
	0196    60  PUSH1 0x20
	0198    81  DUP2
	0199    10  LT
	019A    15  ISZERO
	019B    61  PUSH2 0x01a3
	019E    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @018E  stack[-1] = 0x006b
	//     @0191  stack[0] = 0x04
	//     @0195  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x01a3, returns to 0x006B, if !(msg.data.length - 0x04 < 0x20)

label_019F:
	// Incoming jump from 0x019E, if not !(msg.data.length - 0x04 < 0x20)
	// Inputs[1] { @01A2  memory[0x00:0x00] }
	019F    60  PUSH1 0x00
	01A1    80  DUP1
	01A2    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @01A2  revert(memory[0x00:0x00]); }
	// Block terminates

label_01A3:
	// Incoming call from 0x019E, returns to 0x006B, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[2]
	// {
	//     @01A5  stack[-2]
	//     @01A5  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	01A3    5B  JUMPDEST
	01A4    50  POP
	01A5    35  CALLDATALOAD
	01A6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01BB    16  AND
	01BC    61  PUSH2 0x036e
	01BF    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @01BB  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x036e

label_01C0:
	// Incoming jump from 0x003E, if 0xf851a440 == stack[-1]
	// Inputs[1] { @01C1  msg.value }
	01C0    5B  JUMPDEST
	01C1    34  CALLVALUE
	01C2    80  DUP1
	01C3    15  ISZERO
	01C4    61  PUSH2 0x01cc
	01C7    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @01C1  stack[0] = msg.value }
	// Block ends with conditional jump to 0x01cc, if !msg.value

label_01C8:
	// Incoming jump from 0x01C7, if not !msg.value
	// Inputs[1] { @01CB  memory[0x00:0x00] }
	01C8    60  PUSH1 0x00
	01CA    80  DUP1
	01CB    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @01CB  revert(memory[0x00:0x00]); }
	// Block terminates

label_01CC:
	// Incoming jump from 0x01C7, if !msg.value
	01CC    5B  JUMPDEST
	01CD    50  POP
	01CE    61  PUSH2 0x0157
	01D1    61  PUSH2 0x0476
	01D4    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @01CE  stack[-1] = 0x0157 }
	// Block ends with call to 0x0476, returns to 0x0157

label_01D5:
	// Incoming jump from 0x0311
	// Incoming jump from 0x006A
	// Incoming jump from 0x036A
	// Incoming jump from 0x0074
	// Incoming jump from 0x023F
	01D5    5B  JUMPDEST
	01D6    61  PUSH2 0x01dd
	01D9    61  PUSH2 0x04f7
	01DC    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01D6  stack[0] = 0x01dd }
	// Block ends with unconditional jump to 0x04f7

	01DD    5B    JUMPDEST
	01DE    61    PUSH2 0x01ed
	01E1    61    PUSH2 0x01e8
	01E4    61    PUSH2 0x058b
	01E7    56    *JUMP
	01E8    5B    JUMPDEST
	01E9    61    PUSH2 0x05b0
	01EC    56    *JUMP
label_01ED:
	// Incoming call from 0x058A, returns to 0x01ED
	// Incoming return from call to 0x01ED at 0x058A
	// Inputs[1] { @01EE  stack[-1] }
	01ED    5B  JUMPDEST
	01EE    56  *JUMP
	// Stack delta = -1
	// Block ends with unconditional jump to stack[-1]

label_01EF:
	// Incoming jump from 0x00B4
	01EF    5B  JUMPDEST
	01F0    61  PUSH2 0x01f7
	01F3    61  PUSH2 0x05d4
	01F6    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01F0  stack[0] = 0x01f7 }
	// Block ends with call to 0x05d4, returns to 0x01F7

label_01F7:
	// Incoming return from call to 0x05D4 at 0x01F6
	// Inputs[2]
	// {
	//     @020D  stack[-1]
	//     @020E  msg.sender
	// }
	01F7    5B  JUMPDEST
	01F8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	020D    16  AND
	020E    33  CALLER
	020F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0224    16  AND
	0225    14  EQ
	0226    15  ISZERO
	0227    61  PUSH2 0x0238
	022A    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0238, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_022B:
	// Incoming jump from 0x022A, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Inputs[1] { @022E  stack[-1] }
	022B    61  PUSH2 0x0233
	022E    81  DUP2
	022F    61  PUSH2 0x05f9
	0232    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @022B  stack[0] = 0x0233
	//     @022E  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x05f9, returns to 0x0233

label_0233:
	// Incoming return from call to 0x05F9 at 0x0232
	// Incoming return from call to 0x0646 at 0x0475
	0233    5B  JUMPDEST
	0234    61  PUSH2 0x0240
	0237    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0240

label_0238:
	// Incoming jump from 0x022A, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Incoming jump from 0x03A9, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	0238    5B  JUMPDEST
	0239    61  PUSH2 0x0240
	023C    61  PUSH2 0x01d5
	023F    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0239  stack[0] = 0x0240 }
	// Block ends with unconditional jump to 0x01d5

label_0240:
	// Incoming jump from 0x0237
	// Inputs[1] { @0242  stack[-2] }
	0240    5B  JUMPDEST
	0241    50  POP
	0242    56  *JUMP
	// Stack delta = -2
	// Block ends with unconditional jump to stack[-2]

label_0243:
	// Incoming jump from 0x0141
	0243    5B  JUMPDEST
	0244    61  PUSH2 0x024b
	0247    61  PUSH2 0x05d4
	024A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0244  stack[0] = 0x024b }
	// Block ends with call to 0x05d4, returns to 0x024B

label_024B:
	// Incoming return from call to 0x05D4 at 0x024A
	// Inputs[2]
	// {
	//     @0261  stack[-1]
	//     @0262  msg.sender
	// }
	024B    5B  JUMPDEST
	024C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0261    16  AND
	0262    33  CALLER
	0263    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0278    16  AND
	0279    14  EQ
	027A    15  ISZERO
	027B    61  PUSH2 0x030a
	027E    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x030a, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_027F:
	// Incoming jump from 0x027E, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Inputs[1] { @0282  stack[-3] }
	027F    61  PUSH2 0x0287
	0282    83  DUP4
	0283    61  PUSH2 0x05f9
	0286    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @027F  stack[0] = 0x0287
	//     @0282  stack[1] = stack[-3]
	// }
	// Block ends with call to 0x05f9, returns to 0x0287

label_0287:
	// Incoming return from call to 0x05F9 at 0x0286
	// Inputs[10]
	// {
	//     @028A  stack[-3]
	//     @02A1  stack[-2]
	//     @02A2  stack[-1]
	//     @02A5  memory[0x40:0x60]
	//     @02AC  msg.data[stack[-2]:stack[-2] + stack[-1]]
	//     @02AF  memory[0x40:0x60]
	//     @02C1  msg.gas
	//     @02C2  address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]])
	//     @02C2  memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]]
	//     @02C6  returndata.length
	// }
	0287    5B  JUMPDEST
	0288    60  PUSH1 0x00
	028A    83  DUP4
	028B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02A0    16  AND
	02A1    83  DUP4
	02A2    83  DUP4
	02A3    60  PUSH1 0x40
	02A5    51  MLOAD
	02A6    80  DUP1
	02A7    83  DUP4
	02A8    83  DUP4
	02A9    80  DUP1
	02AA    82  DUP3
	02AB    84  DUP5
	02AC    37  CALLDATACOPY
	02AD    60  PUSH1 0x40
	02AF    51  MLOAD
	02B0    92  SWAP3
	02B1    01  ADD
	02B2    94  SWAP5
	02B3    50  POP
	02B4    60  PUSH1 0x00
	02B6    93  SWAP4
	02B7    50  POP
	02B8    90  SWAP1
	02B9    91  SWAP2
	02BA    50  POP
	02BB    50  POP
	02BC    80  DUP1
	02BD    83  DUP4
	02BE    03  SUB
	02BF    81  DUP2
	02C0    85  DUP6
	02C1    5A  GAS
	02C2    F4  DELEGATECALL
	02C3    91  SWAP2
	02C4    50  POP
	02C5    50  POP
	02C6    3D  RETURNDATASIZE
	02C7    80  DUP1
	02C8    60  PUSH1 0x00
	02CA    81  DUP2
	02CB    14  EQ
	02CC    61  PUSH2 0x02f1
	02CF    57  *JUMPI
	// Stack delta = +4
	// Outputs[6]
	// {
	//     @0288  stack[0] = 0x00
	//     @02AC  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]]
	//     @02C2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]])
	//     @02C3  stack[1] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-1]) - memory[0x40:0x60]])
	//     @02C6  stack[2] = returndata.length
	//     @02C7  stack[3] = returndata.length
	// }
	// Block ends with conditional jump to 0x02f1, if returndata.length == 0x00

label_02D0:
	// Incoming jump from 0x02CF, if not returndata.length == 0x00
	// Inputs[6]
	// {
	//     @02D2  memory[0x40:0x60]
	//     @02D3  stack[-2]
	//     @02DA  returndata.length
	//     @02E2  returndata.length
	//     @02E5  returndata.length
	//     @02EC  returndata[0x00:0x00 + returndata.length]
	// }
	02D0    60  PUSH1 0x40
	02D2    51  MLOAD
	02D3    91  SWAP2
	02D4    50  POP
	02D5    60  PUSH1 0x1f
	02D7    19  NOT
	02D8    60  PUSH1 0x3f
	02DA    3D  RETURNDATASIZE
	02DB    01  ADD
	02DC    16  AND
	02DD    82  DUP3
	02DE    01  ADD
	02DF    60  PUSH1 0x40
	02E1    52  MSTORE
	02E2    3D  RETURNDATASIZE
	02E3    82  DUP3
	02E4    52  MSTORE
	02E5    3D  RETURNDATASIZE
	02E6    60  PUSH1 0x00
	02E8    60  PUSH1 0x20
	02EA    84  DUP5
	02EB    01  ADD
	02EC    3E  RETURNDATACOPY
	02ED    61  PUSH2 0x02f6
	02F0    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @02D3  stack[-2] = memory[0x40:0x60]
	//     @02E1  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f)
	//     @02E4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length
	//     @02EC  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	// }
	// Block ends with unconditional jump to 0x02f6

label_02F1:
	// Incoming jump from 0x02CF, if returndata.length == 0x00
	// Inputs[3]
	// {
	//     @02F4  stack[-2]
	//     @02F9  stack[-4]
	//     @02F9  stack[-3]
	// }
	02F1    5B  JUMPDEST
	02F2    60  PUSH1 0x60
	02F4    91  SWAP2
	02F5    50  POP
	02F6    5B  JUMPDEST
	02F7    50  POP
	02F8    50  POP
	02F9    90  SWAP1
	02FA    50  POP
	02FB    80  DUP1
	02FC    61  PUSH2 0x0304
	02FF    57  *JUMPI
	// Stack delta = -3
	// Outputs[1] { @02F9  stack[-4] = stack[-3] }
	// Block ends with conditional jump to 0x0304, if stack[-3]

label_0300:
	// Incoming jump from 0x02FF, if not stack[-3]
	// Incoming jump from 0x02FF, if not stack[-3]
	// Inputs[1] { @0303  memory[0x00:0x00] }
	0300    60  PUSH1 0x00
	0302    80  DUP1
	0303    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0303  revert(memory[0x00:0x00]); }
	// Block terminates

label_0304:
	// Incoming jump from 0x02FF, if stack[-3]
	// Incoming jump from 0x02FF, if stack[-3]
	0304    5B  JUMPDEST
	0305    50  POP
	0306    61  PUSH2 0x0312
	0309    56  *JUMP
	// Stack delta = -1
	// Block ends with unconditional jump to 0x0312

label_030A:
	// Incoming jump from 0x027E, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	030A    5B  JUMPDEST
	030B    61  PUSH2 0x0312
	030E    61  PUSH2 0x01d5
	0311    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @030B  stack[0] = 0x0312 }
	// Block ends with unconditional jump to 0x01d5

label_0312:
	// Incoming jump from 0x0309
	// Inputs[1] { @0316  stack[-4] }
	0312    5B  JUMPDEST
	0313    50  POP
	0314    50  POP
	0315    50  POP
	0316    56  *JUMP
	// Stack delta = -4
	// Block ends with unconditional jump to stack[-4]

label_0317:
	// Incoming call from 0x0156, returns to 0x0157
	0317    5B  JUMPDEST
	0318    60  PUSH1 0x00
	031A    61  PUSH2 0x0321
	031D    61  PUSH2 0x05d4
	0320    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0318  stack[0] = 0x00
	//     @031A  stack[1] = 0x0321
	// }
	// Block ends with call to 0x05d4, returns to 0x0321

label_0321:
	// Incoming return from call to 0x05D4 at 0x0320
	// Inputs[2]
	// {
	//     @0337  stack[-1]
	//     @0338  msg.sender
	// }
	0321    5B  JUMPDEST
	0322    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0337    16  AND
	0338    33  CALLER
	0339    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	034E    16  AND
	034F    14  EQ
	0350    15  ISZERO
	0351    61  PUSH2 0x0363
	0354    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0363, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_0355:
	// Incoming jump from 0x0354, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	0355    61  PUSH2 0x035c
	0358    61  PUSH2 0x058b
	035B    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0355  stack[0] = 0x035c }
	// Block ends with call to 0x058b, returns to 0x035C

label_035C:
	// Incoming return from call to 0x05D4 at 0x04BA
	// Incoming return from call to 0x058B at 0x035B
	// Inputs[2]
	// {
	//     @035D  stack[-2]
	//     @035D  stack[-1]
	// }
	035C    5B  JUMPDEST
	035D    90  SWAP1
	035E    50  POP
	035F    61  PUSH2 0x036b
	0362    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @035D  stack[-2] = stack[-1] }
	// Block ends with unconditional jump to 0x036b

label_0363:
	// Incoming jump from 0x04B3, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Incoming jump from 0x0354, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	0363    5B  JUMPDEST
	0364    61  PUSH2 0x036b
	0367    61  PUSH2 0x01d5
	036A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0364  stack[0] = 0x036b }
	// Block ends with unconditional jump to 0x01d5

label_036B:
	// Incoming jump from 0x0362
	// Inputs[2]
	// {
	//     @036C  stack[-2]
	//     @036C  stack[-1]
	// }
	036B    5B  JUMPDEST
	036C    90  SWAP1
	036D    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @036C  stack[-2] = stack[-1] }
	// Block ends with unconditional jump to stack[-2]

label_036E:
	// Incoming jump from 0x01BF
	036E    5B  JUMPDEST
	036F    61  PUSH2 0x0376
	0372    61  PUSH2 0x05d4
	0375    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @036F  stack[0] = 0x0376 }
	// Block ends with call to 0x05d4, returns to 0x0376

label_0376:
	// Incoming return from call to 0x05D4 at 0x0375
	// Inputs[2]
	// {
	//     @038C  stack[-1]
	//     @038D  msg.sender
	// }
	0376    5B  JUMPDEST
	0377    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	038C    16  AND
	038D    33  CALLER
	038E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03A3    16  AND
	03A4    14  EQ
	03A5    15  ISZERO
	03A6    61  PUSH2 0x0238
	03A9    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0238, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_03AA:
	// Incoming jump from 0x03A9, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Inputs[1] { @03BF  stack[-1] }
	03AA    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03BF    81  DUP2
	03C0    16  AND
	03C1    61  PUSH2 0x0415
	03C4    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0415, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff

label_03C5:
	// Incoming jump from 0x03C4, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff
	// Inputs[3]
	// {
	//     @03C7  memory[0x40:0x60]
	//     @040F  memory[0x40:0x60]
	//     @0414  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	03C5    60  PUSH1 0x40
	03C7    51  MLOAD
	03C8    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	03E9    81  DUP2
	03EA    52  MSTORE
	03EB    60  PUSH1 0x04
	03ED    01  ADD
	03EE    80  DUP1
	03EF    80  DUP1
	03F0    60  PUSH1 0x20
	03F2    01  ADD
	03F3    82  DUP3
	03F4    81  DUP2
	03F5    03  SUB
	03F6    82  DUP3
	03F7    52  MSTORE
	03F8    60  PUSH1 0x3a
	03FA    81  DUP2
	03FB    52  MSTORE
	03FC    60  PUSH1 0x20
	03FE    01  ADD
	03FF    80  DUP1
	0400    61  PUSH2 0x06ed
	0403    60  PUSH1 0x3a
	0405    91  SWAP2
	0406    39  CODECOPY
	0407    60  PUSH1 0x40
	0409    01  ADD
	040A    91  SWAP2
	040B    50  POP
	040C    50  POP
	040D    60  PUSH1 0x40
	040F    51  MLOAD
	0410    80  DUP1
	0411    91  SWAP2
	0412    03  SUB
	0413    90  SWAP1
	0414    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @03EA  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @03F7  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @03FB  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x3a
	//     @0406  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x3a] = code[0x06ed:0x0727]
	//     @0414  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0415:
	// Incoming jump from 0x03C4, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff
	0415    5B  JUMPDEST
	0416    7F  PUSH32 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f
	0437    61  PUSH2 0x043e
	043A    61  PUSH2 0x05d4
	043D    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0416  stack[0] = 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f
	//     @0437  stack[1] = 0x043e
	// }
	// Block ends with call to 0x05d4, returns to 0x043E

label_043E:
	// Incoming return from call to 0x05D4 at 0x043D
	// Inputs[6]
	// {
	//     @0442  memory[0x40:0x60]
	//     @0458  stack[-1]
	//     @045E  stack[-3]
	//     @0466  memory[0x40:0x60]
	//     @046D  memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40]
	//     @046D  stack[-2]
	// }
	043E    5B  JUMPDEST
	043F    60  PUSH1 0x40
	0441    80  DUP1
	0442    51  MLOAD
	0443    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0458    92  SWAP3
	0459    83  DUP4
	045A    16  AND
	045B    81  DUP2
	045C    52  MSTORE
	045D    91  SWAP2
	045E    84  DUP5
	045F    16  AND
	0460    60  PUSH1 0x20
	0462    83  DUP4
	0463    01  ADD
	0464    52  MSTORE
	0465    80  DUP1
	0466    51  MLOAD
	0467    91  SWAP2
	0468    82  DUP3
	0469    90  SWAP1
	046A    03  SUB
	046B    01  ADD
	046C    90  SWAP1
	046D    A1  LOG1
	046E    61  PUSH2 0x0233
	0471    81  DUP2
	0472    61  PUSH2 0x0646
	0475    56  *JUMP
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @045C  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @0464  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff
	//     @046D  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40], [stack[-2]]);
	//     @046E  stack[-2] = 0x0233
	//     @0471  stack[-1] = stack[-3]
	// }
	// Block ends with call to 0x0646, returns to 0x0233

label_0476:
	// Incoming call from 0x01D4, returns to 0x0157
	0476    5B  JUMPDEST
	0477    60  PUSH1 0x00
	0479    61  PUSH2 0x0480
	047C    61  PUSH2 0x05d4
	047F    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0477  stack[0] = 0x00
	//     @0479  stack[1] = 0x0480
	// }
	// Block ends with call to 0x05d4, returns to 0x0480

label_0480:
	// Incoming return from call to 0x05D4 at 0x047F
	// Inputs[2]
	// {
	//     @0496  stack[-1]
	//     @0497  msg.sender
	// }
	0480    5B  JUMPDEST
	0481    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0496    16  AND
	0497    33  CALLER
	0498    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04AD    16  AND
	04AE    14  EQ
	04AF    15  ISZERO
	04B0    61  PUSH2 0x0363
	04B3    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0363, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_04B4:
	// Incoming jump from 0x04B3, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	04B4    61  PUSH2 0x035c
	04B7    61  PUSH2 0x05d4
	04BA    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @04B4  stack[0] = 0x035c }
	// Block ends with call to 0x05d4, returns to 0x035C

label_04BB:
	// Incoming call from 0x0672, returns to 0x0673
	// Inputs[2]
	// {
	//     @04BE  stack[-1]
	//     @04BF  keccak256(address(stack[-1]).code)
	// }
	04BB    5B  JUMPDEST
	04BC    60  PUSH1 0x00
	04BE    81  DUP2
	04BF    3F  EXTCODEHASH
	04C0    7F  PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
	04E1    81  DUP2
	04E2    81  DUP2
	04E3    14  EQ
	04E4    80  DUP1
	04E5    15  ISZERO
	04E6    90  SWAP1
	04E7    61  PUSH2 0x04ef
	04EA    57  *JUMPI
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @04BC  stack[0] = 0x00
	//     @04BF  stack[1] = keccak256(address(stack[-1]).code)
	//     @04C0  stack[2] = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
	//     @04E6  stack[3] = !(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code))
	// }
	// Block ends with conditional jump to 0x04ef, if 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code)

label_04EB:
	// Incoming jump from 0x04EA, if not 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code)
	// Inputs[3]
	// {
	//     @04EC  stack[-3]
	//     @04F0  stack[-6]
	//     @04F1  stack[-5]
	// }
	04EB    50  POP
	04EC    81  DUP2
	04ED    15  ISZERO
	04EE    15  ISZERO
	04EF    5B  JUMPDEST
	04F0    94  SWAP5
	04F1    93  SWAP4
	04F2    50  POP
	04F3    50  POP
	04F4    50  POP
	04F5    50  POP
	04F6    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @04F0  stack[-6] = !!stack[-3] }
	// Block ends with unconditional jump to stack[-6]

label_04F7:
	// Incoming jump from 0x01DC
	04F7    5B  JUMPDEST
	04F8    61  PUSH2 0x04ff
	04FB    61  PUSH2 0x05d4
	04FE    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @04F8  stack[0] = 0x04ff }
	// Block ends with call to 0x05d4, returns to 0x04FF

label_04FF:
	// Incoming return from call to 0x05D4 at 0x04FE
	// Inputs[2]
	// {
	//     @0515  stack[-1]
	//     @0516  msg.sender
	// }
	04FF    5B  JUMPDEST
	0500    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0515    16  AND
	0516    33  CALLER
	0517    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	052C    16  AND
	052D    14  EQ
	052E    15  ISZERO
	052F    61  PUSH2 0x0583
	0532    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0583, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])

label_0533:
	// Incoming jump from 0x0532, if not !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	// Inputs[3]
	// {
	//     @0535  memory[0x40:0x60]
	//     @057D  memory[0x40:0x60]
	//     @0582  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x60 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0533    60  PUSH1 0x40
	0535    51  MLOAD
	0536    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0557    81  DUP2
	0558    52  MSTORE
	0559    60  PUSH1 0x04
	055B    01  ADD
	055C    80  DUP1
	055D    80  DUP1
	055E    60  PUSH1 0x20
	0560    01  ADD
	0561    82  DUP3
	0562    81  DUP2
	0563    03  SUB
	0564    82  DUP3
	0565    52  MSTORE
	0566    60  PUSH1 0x42
	0568    81  DUP2
	0569    52  MSTORE
	056A    60  PUSH1 0x20
	056C    01  ADD
	056D    80  DUP1
	056E    61  PUSH2 0x075d
	0571    60  PUSH1 0x42
	0573    91  SWAP2
	0574    39  CODECOPY
	0575    60  PUSH1 0x60
	0577    01  ADD
	0578    91  SWAP2
	0579    50  POP
	057A    50  POP
	057B    60  PUSH1 0x40
	057D    51  MLOAD
	057E    80  DUP1
	057F    91  SWAP2
	0580    03  SUB
	0581    90  SWAP1
	0582    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0558  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @0565  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0569  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x42
	//     @0574  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x42] = code[0x075d:0x079f]
	//     @0582  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x60 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0583:
	// Incoming jump from 0x0532, if !(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1])
	0583    5B  JUMPDEST
	0584    61  PUSH2 0x01ed
	0587    61  PUSH2 0x01ed
	058A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0584  stack[0] = 0x01ed }
	// Block ends with call to 0x01ed, returns to 0x01ED

label_058B:
	// Incoming call from 0x035B, returns to 0x035C
	// Inputs[2]
	// {
	//     @05AD  storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc]
	//     @05AE  stack[-1]
	// }
	058B    5B  JUMPDEST
	058C    7F  PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
	05AD    54  SLOAD
	05AE    90  SWAP1
	05AF    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @05AE  stack[-1] = storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] }
	// Block ends with unconditional jump to stack[-1]

	05B0    5B    JUMPDEST
	05B1    36    CALLDATASIZE
	05B2    60    PUSH1 0x00
	05B4    80    DUP1
	05B5    37    CALLDATACOPY
	05B6    60    PUSH1 0x00
	05B8    80    DUP1
	05B9    36    CALLDATASIZE
	05BA    60    PUSH1 0x00
	05BC    84    DUP5
	05BD    5A    GAS
	05BE    F4    DELEGATECALL
	05BF    3D    RETURNDATASIZE
	05C0    60    PUSH1 0x00
	05C2    80    DUP1
	05C3    3E    RETURNDATACOPY
	05C4    80    DUP1
	05C5    80    DUP1
	05C6    15    ISZERO
	05C7    61    PUSH2 0x05cf
	05CA    57    *JUMPI
	05CB    3D    RETURNDATASIZE
	05CC    60    PUSH1 0x00
	05CE    F3    *RETURN
	05CF    5B    JUMPDEST
	05D0    3D    RETURNDATASIZE
	05D1    60    PUSH1 0x00
	05D3    FD    *REVERT
label_05D4:
	// Incoming call from 0x04FE, returns to 0x04FF
	// Incoming call from 0x01F6, returns to 0x01F7
	// Incoming call from 0x04BA, returns to 0x035C
	// Incoming call from 0x0375, returns to 0x0376
	// Incoming call from 0x0320, returns to 0x0321
	// Incoming call from 0x047F, returns to 0x0480
	// Incoming call from 0x043D, returns to 0x043E
	// Incoming call from 0x024A, returns to 0x024B
	// Inputs[2]
	// {
	//     @05F6  storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103]
	//     @05F7  stack[-1]
	// }
	05D4    5B  JUMPDEST
	05D5    7F  PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103
	05F6    54  SLOAD
	05F7    90  SWAP1
	05F8    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @05F7  stack[-1] = storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] }
	// Block ends with unconditional jump to stack[-1]

label_05F9:
	// Incoming call from 0x0232, returns to 0x0233
	// Incoming call from 0x0286, returns to 0x0287
	// Inputs[1] { @05FD  stack[-1] }
	05F9    5B  JUMPDEST
	05FA    61  PUSH2 0x0602
	05FD    81  DUP2
	05FE    61  PUSH2 0x066a
	0601    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05FA  stack[0] = 0x0602
	//     @05FD  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x066a, returns to 0x0602

label_0602:
	// Incoming return from call to 0x066A at 0x0601
	// Inputs[4]
	// {
	//     @0605  memory[0x40:0x60]
	//     @061B  stack[-1]
	//     @0643  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]
	//     @0645  stack[-2]
	// }
	0602    5B  JUMPDEST
	0603    60  PUSH1 0x40
	0605    51  MLOAD
	0606    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	061B    82  DUP3
	061C    16  AND
	061D    90  SWAP1
	061E    7F  PUSH32 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b
	063F    90  SWAP1
	0640    60  PUSH1 0x00
	0642    90  SWAP1
	0643    A2  LOG2
	0644    50  POP
	0645    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0643  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); }
	// Block ends with unconditional jump to stack[-2]

label_0646:
	// Incoming call from 0x0475, returns to 0x0233
	// Inputs[2]
	// {
	//     @0668  stack[-1]
	//     @0669  stack[-2]
	// }
	0646    5B  JUMPDEST
	0647    7F  PUSH32 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103
	0668    55  SSTORE
	0669    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0668  storage[0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103] = stack[-1] }
	// Block ends with unconditional jump to stack[-2]

label_066A:
	// Incoming call from 0x0601, returns to 0x0602
	// Inputs[1] { @066E  stack[-1] }
	066A    5B  JUMPDEST
	066B    61  PUSH2 0x0673
	066E    81  DUP2
	066F    61  PUSH2 0x04bb
	0672    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @066B  stack[0] = 0x0673
	//     @066E  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x04bb, returns to 0x0673

label_0673:
	// Incoming return from call to 0x04BB at 0x0672
	// Inputs[1] { @0677  stack[-1] }
	0673    5B  JUMPDEST
	0674    61  PUSH2 0x06c8
	0677    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x06c8, if stack[-1]

label_0678:
	// Incoming jump from 0x0677, if not stack[-1]
	// Inputs[3]
	// {
	//     @067A  memory[0x40:0x60]
	//     @06C2  memory[0x40:0x60]
	//     @06C7  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0678    60  PUSH1 0x40
	067A    51  MLOAD
	067B    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	069C    81  DUP2
	069D    52  MSTORE
	069E    60  PUSH1 0x04
	06A0    01  ADD
	06A1    80  DUP1
	06A2    80  DUP1
	06A3    60  PUSH1 0x20
	06A5    01  ADD
	06A6    82  DUP3
	06A7    81  DUP2
	06A8    03  SUB
	06A9    82  DUP3
	06AA    52  MSTORE
	06AB    60  PUSH1 0x36
	06AD    81  DUP2
	06AE    52  MSTORE
	06AF    60  PUSH1 0x20
	06B1    01  ADD
	06B2    80  DUP1
	06B3    61  PUSH2 0x0727
	06B6    60  PUSH1 0x36
	06B8    91  SWAP2
	06B9    39  CODECOPY
	06BA    60  PUSH1 0x40
	06BC    01  ADD
	06BD    91  SWAP2
	06BE    50  POP
	06BF    50  POP
	06C0    60  PUSH1 0x40
	06C2    51  MLOAD
	06C3    80  DUP1
	06C4    91  SWAP2
	06C5    03  SUB
	06C6    90  SWAP1
	06C7    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @069D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @06AA  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @06AE  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x36
	//     @06B9  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x36] = code[0x0727:0x075d]
	//     @06C7  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_06C8:
	// Incoming jump from 0x0677, if stack[-1]
	// Inputs[2]
	// {
	//     @06EA  stack[-1]
	//     @06EB  stack[-2]
	// }
	06C8    5B  JUMPDEST
	06C9    7F  PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
	06EA    55  SSTORE
	06EB    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @06EA  storage[0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc] = stack[-1] }
	// Block ends with unconditional jump to stack[-2]

	06EC    FE    *ASSERT
	06ED    54    SLOAD
	06EE    72    PUSH19 0x616e73706172656e745570677261646561626c
	0702    65    PUSH6 0x50726f78793a
	0709    20    SHA3
	070A    6E    PUSH15 0x65772061646d696e20697320746865
	071A    20    SHA3
	071B    7A    PUSH27 0x65726f20616464726573735570677261646561626c6550726f7879
	0737    3A    GASPRICE
	0738    20    SHA3
	0739    6E    PUSH15 0x657720696d706c656d656e74617469
	0749    6F    PUSH16 0x6e206973206e6f74206120636f6e7472
	075A    61    PUSH2 0x6374
	075D    54    SLOAD
	075E    72    PUSH19 0x616e73706172656e745570677261646561626c
	0772    65    PUSH6 0x50726f78793a
	0779    20    SHA3
	077A    61    PUSH2 0x646d
	077D    69    PUSH10 0x6e2063616e6e6f742066
	0788    61    PUSH2 0x6c6c
	078B    62    PUSH3 0x61636b
	078F    20    SHA3
	0790    74    PUSH21 0x6f2070726f787920746172676574a2646970667358
	07A6    22    22
	07A7    12    SLT
	07A8    20    SHA3
	07A9    B1    DUP
	07AA    41    COINBASE
	07AB    EF    EF
	07AC    72    PUSH19 0xde179b8b56cef31601d40ff2875391088197e7
	07C0    3C    EXTCODECOPY
	07C1    AC    AC
	07C2    39    CODECOPY
	07C3    EB    EB
	07C4    A1    LOG1
	07C5    DD    DD
	07C6    CD    CD
	07C7    0F    0F
	07C8    DD    DD
	07C9    64    PUSH5 0x736f6c6343
	07CF    00    *STOP
	07D0    07    SMOD
	07D1    06    MOD
	07D2    00    *STOP
	07D3    33    CALLER