Online Solidity Decompiler

« Decompile another contract

Address

0xf13119f5b866ffc019e64aa8a94e0dae16a80bf1 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x715018a6 renounceOwnership()

0x8da5cb5b owner()

0xf2fde38b transferOwnership(address)

Internal Methods

func_00EB(arg0)

func_010C() returns (r0)

renounceOwnership()

func_01A3() returns (r0)

func_02C3(arg0) returns (r0)

func_02FA()

func_02FC() returns (r0)

func_0379() returns (r0)

func_0381(arg0)

func_059C(arg0) returns (r0)

func_05BC(arg0) returns (r0)

func_05CE(arg0, arg1)

func_05DD(arg0, arg1) returns (r0)

func_05FD(arg0)

func_0614(arg0, arg1) returns (r0)

func_0629(arg0, arg1) returns (r0)

func_0656(arg0, arg1) returns (r0)

func_0667(arg0)

func_0690(arg0) returns (r0)

func_06B3(arg0) returns (r0)

func_06D3(arg0)

func_0722(arg0) returns (r0)

func_0745(arg0) returns (r0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
    
        if (msg.data.length >= 0x04) {
            var0 = msg.data[0x00:0x20] >> 0xe0;
        
            if (var0 == 0x5c60da1b) {
                // Dispatch table entry for implementation()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0071;
                var1 = func_010C();
                var temp3 = var1;
                var1 = 0x007e;
                var2 = temp3;
                var var3 = memory[0x40:0x60];
                var1 = func_05DD(var2, var3);
                var temp4 = memory[0x40:0x60];
                return memory[temp4:temp4 + var1 - temp4];
            } else if (var0 == 0x715018a6) {
                // Dispatch table entry for renounceOwnership()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x009c;
                renounceOwnership();
                stop();
            } else if (var0 == 0x8da5cb5b) {
                // Dispatch table entry for owner()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x00b3;
                var1 = func_01A3();
                var temp5 = var1;
                var1 = 0x00c0;
                var2 = temp5;
                var3 = memory[0x40:0x60];
                var1 = func_05DD(var2, var3);
                var temp6 = memory[0x40:0x60];
                return memory[temp6:temp6 + var1 - temp6];
            } else if (var0 == 0xf2fde38b) {
                // Dispatch table entry for transferOwnership(address)
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x00f0;
                var2 = 0x00eb;
                var3 = msg.data.length - 0x04 + 0x04;
                var var4 = 0x04;
                var2 = func_0629(var3, var4);
                func_00EB(var2);
                stop();
            } else { goto label_0052; }
        } else if (msg.data.length) {
        label_0052:
            var var0 = 0x005a;
        
        label_00F2:
            var var1 = 0x00fa;
            func_02FA();
            var1 = 0x010a;
            var var2 = 0x0105;
            var2 = func_02FC();
            var temp0 = msg.data.length;
            memory[0x00:0x00 + temp0] = msg.data[0x00:0x00 + temp0];
            var temp1;
            temp1, memory[0x00:0x00] = address(var2).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]);
            var temp2 = returndata.length;
            memory[0x00:0x00 + temp2] = returndata[0x00:0x00 + temp2];
        
            if (temp1 == 0x00) { revert(memory[0x00:0x00 + returndata.length]); }
            else { return memory[0x00:0x00 + returndata.length]; }
        } else {
            var0 = 0x0050;
            goto label_00F2;
        }
    }
    
    function func_00EB(var arg0) {
        var var0 = 0x01d4;
        var0 = func_0379();
        var0 = var0 & 0xffffffffffffffffffffffffffffffffffffffff;
        var var1 = 0x01f2;
        var1 = func_01A3();
    
        if (var1 & 0xffffffffffffffffffffffffffffffffffffffff != var0) {
            var temp2 = memory[0x40:0x60];
            memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var1 = temp2 + 0x04;
            var0 = 0x023f;
            var0 = func_06B3(var1);
            var temp3 = memory[0x40:0x60];
            revert(memory[temp3:temp3 + var0 - temp3]);
        } else if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) {
            var0 = 0x02c0;
            var1 = arg0;
            func_0381(var1);
            return;
        } else {
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var1 = temp0 + 0x04;
            var0 = 0x02ae;
            var0 = func_0745(var1);
            var temp1 = memory[0x40:0x60];
            revert(memory[temp1:temp1 + var0 - temp1]);
        }
    }
    
    function func_010C() returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x0116;
        return func_02FC();
    }
    
    function renounceOwnership() {
        var var0 = 0x0123;
        var0 = func_0379();
        var0 = var0 & 0xffffffffffffffffffffffffffffffffffffffff;
        var var1 = 0x0141;
        var1 = func_01A3();
    
        if (var1 & 0xffffffffffffffffffffffffffffffffffffffff == var0) {
            var0 = 0x01a1;
            var1 = 0x00;
            func_0381(var1);
            return;
        } else {
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var1 = temp0 + 0x04;
            var0 = 0x018e;
            var0 = func_06B3(var1);
            var temp1 = memory[0x40:0x60];
            revert(memory[temp1:temp1 + var0 - temp1]);
        }
    }
    
    function func_01A3() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; }
    
    function func_02C3(var arg0) returns (var r0) { return arg0; }
    
    function func_02FA() {}
    
    function func_02FC() returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x032a;
        var var2 = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc << 0x00;
        var1 = func_02C3(var2);
        return storage[var1] & 0xffffffffffffffffffffffffffffffffffffffff;
    }
    
    function func_0379() returns (var r0) { return msg.sender; }
    
    function func_0381(var arg0) {
        var temp0 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff;
        var temp1 = arg0;
        storage[0x00] = (temp1 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff);
        var temp2 = memory[0x40:0x60];
        log(memory[temp2:temp2 + memory[0x40:0x60] - temp2], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]);
    }
    
    function func_059C(var arg0) returns (var r0) { return arg0 & 0xffffffffffffffffffffffffffffffffffffffff; }
    
    function func_05BC(var arg0) returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x05c7;
        var var2 = arg0;
        return func_059C(var2);
    }
    
    function func_05CE(var arg0, var arg1) {
        var var0 = 0x05d7;
        var var1 = arg1;
        var0 = func_05BC(var1);
        memory[arg0:arg0 + 0x20] = var0;
    }
    
    function func_05DD(var arg0, var arg1) returns (var r0) {
        var temp0 = arg1;
        var var0 = temp0 + 0x20;
        var var1 = 0x05f2;
        var var2 = temp0;
        var var3 = arg0;
        func_05CE(var2, var3);
        return var0;
    }
    
    function func_05FD(var arg0) {
        var var0 = 0x0606;
        var var1 = arg0;
        var0 = func_05BC(var1);
    
        if (arg0 == var0) { return; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_0614(var arg0, var arg1) returns (var r0) {
        var var0 = msg.data[arg1:arg1 + 0x20];
        var var1 = 0x0623;
        var var2 = var0;
        func_05FD(var2);
        return var0;
    }
    
    function func_0629(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 - arg1 i>= 0x20) {
            var var1 = 0x00;
            var var2 = 0x064d;
            var var3 = arg0;
            var var4 = arg1 + var1;
            return func_0614(var3, var4);
        } else {
            var1 = 0x063e;
            revert(memory[0x00:0x00]);
        }
    }
    
    function func_0656(var arg0, var arg1) returns (var r0) {
        var temp0 = arg1;
        memory[temp0:temp0 + 0x20] = arg0;
        return temp0 + 0x20;
    }
    
    function func_0667(var arg0) {
        memory[arg0:arg0 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
    }
    
    function func_0690(var arg0) returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x069d;
        var var2 = 0x20;
        var var3 = arg0;
        var1 = func_0656(var2, var3);
        var temp0 = var1;
        arg0 = temp0;
        var1 = 0x06a8;
        var2 = arg0;
        func_0667(var2);
        return arg0 + 0x20;
    }
    
    function func_06B3(var arg0) returns (var r0) {
        var temp0 = arg0;
        var var0 = temp0 + 0x20;
        memory[temp0:temp0 + 0x20] = var0 - temp0;
        var var1 = 0x06cc;
        var var2 = var0;
        return func_0690(var2);
    }
    
    function func_06D3(var arg0) {
        var temp0 = arg0;
        memory[temp0:temp0 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061;
        memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000;
    }
    
    function func_0722(var arg0) returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x072f;
        var var2 = 0x26;
        var var3 = arg0;
        var1 = func_0656(var2, var3);
        var temp0 = var1;
        arg0 = temp0;
        var1 = 0x073a;
        var2 = arg0;
        func_06D3(var2);
        return arg0 + 0x40;
    }
    
    function func_0745(var arg0) returns (var r0) {
        var temp0 = arg0;
        var var0 = temp0 + 0x20;
        memory[temp0:temp0 + 0x20] = var0 - temp0;
        var var1 = 0x075e;
        var var2 = var0;
        return func_0722(var2);
    }
}

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 0x0043
	000C    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0004  memory[0x40:0x60] = 0x80 }
	// Block ends with conditional jump to 0x0043, 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    14  EQ
	001A    61  PUSH2 0x005c
	001D    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0012  stack[0] = msg.data[0x00:0x20] >> 0xe0 }
	// Block ends with conditional jump to 0x005c, 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 0x715018a6
	0024    14  EQ
	0025    61  PUSH2 0x0087
	0028    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0087, if 0x715018a6 == stack[-1]

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

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

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

label_0043:
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Inputs[1] { @0044  msg.data.length }
	0043    5B  JUMPDEST
	0044    36  CALLDATASIZE
	0045    61  PUSH2 0x0052
	0048    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0052, if msg.data.length

label_0049:
	// Incoming jump from 0x0048, if not msg.data.length
	0049    61  PUSH2 0x0050
	004C    61  PUSH2 0x00f2
	004F    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0049  stack[0] = 0x0050 }
	// Block ends with unconditional jump to 0x00f2

	0050    5B    JUMPDEST
	0051    00    *STOP
label_0052:
	// Incoming jump from 0x0042
	// Incoming jump from 0x0048, if msg.data.length
	0052    5B  JUMPDEST
	0053    61  PUSH2 0x005a
	0056    61  PUSH2 0x00f2
	0059    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0053  stack[0] = 0x005a }
	// Block ends with unconditional jump to 0x00f2

	005A    5B    JUMPDEST
	005B    00    *STOP
label_005C:
	// Incoming jump from 0x001D, if 0x5c60da1b == msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @005D  msg.value }
	005C    5B  JUMPDEST
	005D    34  CALLVALUE
	005E    80  DUP1
	005F    15  ISZERO
	0060    61  PUSH2 0x0068
	0063    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @005D  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0068, if !msg.value

label_0064:
	// Incoming jump from 0x0063, if not !msg.value
	// Inputs[1] { @0067  memory[0x00:0x00] }
	0064    60  PUSH1 0x00
	0066    80  DUP1
	0067    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0067  revert(memory[0x00:0x00]); }
	// Block terminates

label_0068:
	// Incoming jump from 0x0063, if !msg.value
	0068    5B  JUMPDEST
	0069    50  POP
	006A    61  PUSH2 0x0071
	006D    61  PUSH2 0x010c
	0070    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @006A  stack[-1] = 0x0071 }
	// Block ends with call to 0x010c, returns to 0x0071

label_0071:
	// Incoming return from call to 0x010C at 0x0070
	// Inputs[2]
	// {
	//     @0074  memory[0x40:0x60]
	//     @0078  stack[-1]
	// }
	0071    5B  JUMPDEST
	0072    60  PUSH1 0x40
	0074    51  MLOAD
	0075    61  PUSH2 0x007e
	0078    91  SWAP2
	0079    90  SWAP1
	007A    61  PUSH2 0x05dd
	007D    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0078  stack[-1] = 0x007e
	//     @0079  stack[1] = memory[0x40:0x60]
	//     @0079  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x05dd, returns to 0x007E

label_007E:
	// Incoming return from call to 0x05DD at 0x007D
	// Inputs[3]
	// {
	//     @0081  memory[0x40:0x60]
	//     @0083  stack[-1]
	//     @0086  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]
	// }
	007E    5B  JUMPDEST
	007F    60  PUSH1 0x40
	0081    51  MLOAD
	0082    80  DUP1
	0083    91  SWAP2
	0084    03  SUB
	0085    90  SWAP1
	0086    F3  *RETURN
	// Stack delta = -1
	// Outputs[1] { @0086  return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; }
	// Block terminates

label_0087:
	// Incoming jump from 0x0028, if 0x715018a6 == stack[-1]
	// Inputs[1] { @0088  msg.value }
	0087    5B  JUMPDEST
	0088    34  CALLVALUE
	0089    80  DUP1
	008A    15  ISZERO
	008B    61  PUSH2 0x0093
	008E    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0088  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0093, if !msg.value

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

label_0093:
	// Incoming jump from 0x008E, if !msg.value
	0093    5B  JUMPDEST
	0094    50  POP
	0095    61  PUSH2 0x009c
	0098    61  PUSH2 0x011b
	009B    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0095  stack[-1] = 0x009c }
	// Block ends with call to 0x011b, returns to 0x009C

label_009C:
	// Incoming return from call to 0x011B at 0x009B
	009C    5B  JUMPDEST
	009D    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @009D  stop(); }
	// Block terminates

label_009E:
	// Incoming jump from 0x0033, if 0x8da5cb5b == stack[-1]
	// Inputs[1] { @009F  msg.value }
	009E    5B  JUMPDEST
	009F    34  CALLVALUE
	00A0    80  DUP1
	00A1    15  ISZERO
	00A2    61  PUSH2 0x00aa
	00A5    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @009F  stack[0] = msg.value }
	// Block ends with conditional jump to 0x00aa, if !msg.value

label_00A6:
	// Incoming jump from 0x00A5, if not !msg.value
	// Inputs[1] { @00A9  memory[0x00:0x00] }
	00A6    60  PUSH1 0x00
	00A8    80  DUP1
	00A9    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00A9  revert(memory[0x00:0x00]); }
	// Block terminates

label_00AA:
	// Incoming jump from 0x00A5, if !msg.value
	00AA    5B  JUMPDEST
	00AB    50  POP
	00AC    61  PUSH2 0x00b3
	00AF    61  PUSH2 0x01a3
	00B2    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @00AC  stack[-1] = 0x00b3 }
	// Block ends with call to 0x01a3, returns to 0x00B3

label_00B3:
	// Incoming return from call to 0x01A3 at 0x00B2
	// Inputs[2]
	// {
	//     @00B6  memory[0x40:0x60]
	//     @00BA  stack[-1]
	// }
	00B3    5B  JUMPDEST
	00B4    60  PUSH1 0x40
	00B6    51  MLOAD
	00B7    61  PUSH2 0x00c0
	00BA    91  SWAP2
	00BB    90  SWAP1
	00BC    61  PUSH2 0x05dd
	00BF    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @00BA  stack[-1] = 0x00c0
	//     @00BB  stack[1] = memory[0x40:0x60]
	//     @00BB  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x05dd, returns to 0x00C0

label_00C0:
	// Incoming return from call to 0x05DD at 0x00BF
	// Inputs[3]
	// {
	//     @00C3  memory[0x40:0x60]
	//     @00C5  stack[-1]
	//     @00C8  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]
	// }
	00C0    5B  JUMPDEST
	00C1    60  PUSH1 0x40
	00C3    51  MLOAD
	00C4    80  DUP1
	00C5    91  SWAP2
	00C6    03  SUB
	00C7    90  SWAP1
	00C8    F3  *RETURN
	// Stack delta = -1
	// Outputs[1] { @00C8  return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; }
	// Block terminates

label_00C9:
	// Incoming jump from 0x003E, if 0xf2fde38b == stack[-1]
	// Inputs[1] { @00CA  msg.value }
	00C9    5B  JUMPDEST
	00CA    34  CALLVALUE
	00CB    80  DUP1
	00CC    15  ISZERO
	00CD    61  PUSH2 0x00d5
	00D0    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @00CA  stack[0] = msg.value }
	// Block ends with conditional jump to 0x00d5, if !msg.value

label_00D1:
	// Incoming jump from 0x00D0, if not !msg.value
	// Inputs[1] { @00D4  memory[0x00:0x00] }
	00D1    60  PUSH1 0x00
	00D3    80  DUP1
	00D4    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00D4  revert(memory[0x00:0x00]); }
	// Block terminates

label_00D5:
	// Incoming jump from 0x00D0, if !msg.value
	// Inputs[1] { @00DD  msg.data.length }
	00D5    5B  JUMPDEST
	00D6    50  POP
	00D7    61  PUSH2 0x00f0
	00DA    60  PUSH1 0x04
	00DC    80  DUP1
	00DD    36  CALLDATASIZE
	00DE    03  SUB
	00DF    81  DUP2
	00E0    01  ADD
	00E1    90  SWAP1
	00E2    61  PUSH2 0x00eb
	00E5    91  SWAP2
	00E6    90  SWAP1
	00E7    61  PUSH2 0x0629
	00EA    56  *JUMP
	// Stack delta = +3
	// Outputs[4]
	// {
	//     @00D7  stack[-1] = 0x00f0
	//     @00E5  stack[0] = 0x00eb
	//     @00E6  stack[2] = 0x04
	//     @00E6  stack[1] = 0x04 + (msg.data.length - 0x04)
	// }
	// Block ends with call to 0x0629, returns to 0x00EB

label_00EB:
	// Incoming return from call to 0x0629 at 0x00EA
	00EB    5B  JUMPDEST
	00EC    61  PUSH2 0x01cc
	00EF    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x01cc

label_00F0:
	// Incoming return from call to 0x00EB at 0x00EA
	00F0    5B  JUMPDEST
	00F1    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @00F1  stop(); }
	// Block terminates

label_00F2:
	// Incoming jump from 0x0059
	// Incoming jump from 0x004F
	00F2    5B  JUMPDEST
	00F3    61  PUSH2 0x00fa
	00F6    61  PUSH2 0x02fa
	00F9    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @00F3  stack[0] = 0x00fa }
	// Block ends with call to 0x02fa, returns to 0x00FA

label_00FA:
	// Incoming return from call to 0x02FA at 0x00F9
	00FA    5B  JUMPDEST
	00FB    61  PUSH2 0x010a
	00FE    61  PUSH2 0x0105
	0101    61  PUSH2 0x02fc
	0104    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @00FB  stack[0] = 0x010a
	//     @00FE  stack[1] = 0x0105
	// }
	// Block ends with call to 0x02fc, returns to 0x0105

label_0105:
	// Incoming return from call to 0x02FC at 0x0104
	0105    5B  JUMPDEST
	0106    61  PUSH2 0x0353
	0109    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0353

	010A    5B    JUMPDEST
	010B    56    *JUMP
label_010C:
	// Incoming call from 0x0070, returns to 0x0071
	010C    5B  JUMPDEST
	010D    60  PUSH1 0x00
	010F    61  PUSH2 0x0116
	0112    61  PUSH2 0x02fc
	0115    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @010D  stack[0] = 0x00
	//     @010F  stack[1] = 0x0116
	// }
	// Block ends with call to 0x02fc, returns to 0x0116

label_0116:
	// Incoming return from call to 0x02FC at 0x0115
	// Inputs[3]
	// {
	//     @0117  stack[-2]
	//     @0117  stack[-1]
	//     @0119  stack[-3]
	// }
	0116    5B  JUMPDEST
	0117    90  SWAP1
	0118    50  POP
	0119    90  SWAP1
	011A    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0119  stack[-3] = stack[-1] }
	// Block ends with unconditional jump to stack[-3]

label_011B:
	// Incoming call from 0x009B, returns to 0x009C
	011B    5B  JUMPDEST
	011C    61  PUSH2 0x0123
	011F    61  PUSH2 0x0379
	0122    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @011C  stack[0] = 0x0123 }
	// Block ends with call to 0x0379, returns to 0x0123

label_0123:
	// Incoming return from call to 0x0379 at 0x0122
	// Inputs[1] { @0139  stack[-1] }
	0123    5B  JUMPDEST
	0124    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0139    16  AND
	013A    61  PUSH2 0x0141
	013D    61  PUSH2 0x01a3
	0140    56  *JUMP
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @0139  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @013A  stack[0] = 0x0141
	// }
	// Block ends with call to 0x01a3, returns to 0x0141

label_0141:
	// Incoming return from call to 0x01A3 at 0x0140
	// Inputs[2]
	// {
	//     @0157  stack[-1]
	//     @0158  stack[-2]
	// }
	0141    5B  JUMPDEST
	0142    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0157    16  AND
	0158    14  EQ
	0159    61  PUSH2 0x0197
	015C    57  *JUMPI
	// Stack delta = -2
	// Block ends with conditional jump to 0x0197, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]

label_015D:
	// Incoming jump from 0x015C, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]
	// Inputs[1] { @015F  memory[0x40:0x60] }
	015D    60  PUSH1 0x40
	015F    51  MLOAD
	0160    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0181    81  DUP2
	0182    52  MSTORE
	0183    60  PUSH1 0x04
	0185    01  ADD
	0186    61  PUSH2 0x018e
	0189    90  SWAP1
	018A    61  PUSH2 0x06b3
	018D    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0182  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @0189  stack[0] = 0x018e
	//     @0189  stack[1] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x06b3, returns to 0x018E

label_018E:
	// Incoming return from call to 0x06B3 at 0x018D
	// Inputs[3]
	// {
	//     @0191  memory[0x40:0x60]
	//     @0193  stack[-1]
	//     @0196  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]
	// }
	018E    5B  JUMPDEST
	018F    60  PUSH1 0x40
	0191    51  MLOAD
	0192    80  DUP1
	0193    91  SWAP2
	0194    03  SUB
	0195    90  SWAP1
	0196    FD  *REVERT
	// Stack delta = -1
	// Outputs[1] { @0196  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); }
	// Block terminates

label_0197:
	// Incoming jump from 0x015C, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]
	0197    5B  JUMPDEST
	0198    61  PUSH2 0x01a1
	019B    60  PUSH1 0x00
	019D    61  PUSH2 0x0381
	01A0    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0198  stack[0] = 0x01a1
	//     @019B  stack[1] = 0x00
	// }
	// Block ends with call to 0x0381, returns to 0x01A1

label_01A1:
	// Incoming return from call to 0x0381 at 0x01A0
	// Inputs[1] { @01A2  stack[-1] }
	01A1    5B  JUMPDEST
	01A2    56  *JUMP
	// Stack delta = -1
	// Block ends with unconditional jump to stack[-1]

label_01A3:
	// Incoming call from 0x01F1, returns to 0x01F2
	// Incoming call from 0x00B2, returns to 0x00B3
	// Incoming call from 0x0140, returns to 0x0141
	// Inputs[2]
	// {
	//     @01AA  storage[0x00]
	//     @01CA  stack[-1]
	// }
	01A3    5B  JUMPDEST
	01A4    60  PUSH1 0x00
	01A6    80  DUP1
	01A7    60  PUSH1 0x00
	01A9    90  SWAP1
	01AA    54  SLOAD
	01AB    90  SWAP1
	01AC    61  PUSH2 0x0100
	01AF    0A  EXP
	01B0    90  SWAP1
	01B1    04  DIV
	01B2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01C7    16  AND
	01C8    90  SWAP1
	01C9    50  POP
	01CA    90  SWAP1
	01CB    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @01CA  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 }
	// Block ends with unconditional jump to stack[-1]

label_01CC:
	// Incoming jump from 0x00EF
	01CC    5B  JUMPDEST
	01CD    61  PUSH2 0x01d4
	01D0    61  PUSH2 0x0379
	01D3    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01CD  stack[0] = 0x01d4 }
	// Block ends with call to 0x0379, returns to 0x01D4

label_01D4:
	// Incoming return from call to 0x0379 at 0x01D3
	// Inputs[1] { @01EA  stack[-1] }
	01D4    5B  JUMPDEST
	01D5    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01EA    16  AND
	01EB    61  PUSH2 0x01f2
	01EE    61  PUSH2 0x01a3
	01F1    56  *JUMP
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @01EA  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @01EB  stack[0] = 0x01f2
	// }
	// Block ends with call to 0x01a3, returns to 0x01F2

label_01F2:
	// Incoming return from call to 0x01A3 at 0x01F1
	// Inputs[2]
	// {
	//     @0208  stack[-1]
	//     @0209  stack[-2]
	// }
	01F2    5B  JUMPDEST
	01F3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0208    16  AND
	0209    14  EQ
	020A    61  PUSH2 0x0248
	020D    57  *JUMPI
	// Stack delta = -2
	// Block ends with conditional jump to 0x0248, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]

label_020E:
	// Incoming jump from 0x020D, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]
	// Inputs[1] { @0210  memory[0x40:0x60] }
	020E    60  PUSH1 0x40
	0210    51  MLOAD
	0211    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0232    81  DUP2
	0233    52  MSTORE
	0234    60  PUSH1 0x04
	0236    01  ADD
	0237    61  PUSH2 0x023f
	023A    90  SWAP1
	023B    61  PUSH2 0x06b3
	023E    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0233  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @023A  stack[0] = 0x023f
	//     @023A  stack[1] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x06b3, returns to 0x023F

label_023F:
	// Incoming return from call to 0x06B3 at 0x023E
	// Inputs[3]
	// {
	//     @0242  memory[0x40:0x60]
	//     @0244  stack[-1]
	//     @0247  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]
	// }
	023F    5B  JUMPDEST
	0240    60  PUSH1 0x40
	0242    51  MLOAD
	0243    80  DUP1
	0244    91  SWAP2
	0245    03  SUB
	0246    90  SWAP1
	0247    FD  *REVERT
	// Stack delta = -1
	// Outputs[1] { @0247  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); }
	// Block terminates

label_0248:
	// Incoming jump from 0x020D, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]
	// Inputs[1] { @0261  stack[-1] }
	0248    5B  JUMPDEST
	0249    60  PUSH1 0x00
	024B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0260    16  AND
	0261    81  DUP2
	0262    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0277    16  AND
	0278    03  SUB
	0279    61  PUSH2 0x02b7
	027C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x02b7, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00)

label_027D:
	// Incoming jump from 0x027C, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[1] { @027F  memory[0x40:0x60] }
	027D    60  PUSH1 0x40
	027F    51  MLOAD
	0280    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	02A1    81  DUP2
	02A2    52  MSTORE
	02A3    60  PUSH1 0x04
	02A5    01  ADD
	02A6    61  PUSH2 0x02ae
	02A9    90  SWAP1
	02AA    61  PUSH2 0x0745
	02AD    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @02A2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @02A9  stack[0] = 0x02ae
	//     @02A9  stack[1] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x0745, returns to 0x02AE

label_02AE:
	// Incoming return from call to 0x0745 at 0x02AD
	// Inputs[3]
	// {
	//     @02B1  memory[0x40:0x60]
	//     @02B3  stack[-1]
	//     @02B6  memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]
	// }
	02AE    5B  JUMPDEST
	02AF    60  PUSH1 0x40
	02B1    51  MLOAD
	02B2    80  DUP1
	02B3    91  SWAP2
	02B4    03  SUB
	02B5    90  SWAP1
	02B6    FD  *REVERT
	// Stack delta = -1
	// Outputs[1] { @02B6  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); }
	// Block terminates

label_02B7:
	// Incoming jump from 0x027C, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[1] { @02BB  stack[-1] }
	02B7    5B  JUMPDEST
	02B8    61  PUSH2 0x02c0
	02BB    81  DUP2
	02BC    61  PUSH2 0x0381
	02BF    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @02B8  stack[0] = 0x02c0
	//     @02BB  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x0381, returns to 0x02C0

label_02C0:
	// Incoming return from call to 0x0381 at 0x02BF
	// Inputs[1] { @02C2  stack[-2] }
	02C0    5B  JUMPDEST
	02C1    50  POP
	02C2    56  *JUMP
	// Stack delta = -2
	// Block ends with unconditional jump to stack[-2]

label_02C3:
	// Incoming call from 0x0329, returns to 0x032A
	// Inputs[2]
	// {
	//     @02C6  stack[-1]
	//     @02C9  stack[-2]
	// }
	02C3    5B  JUMPDEST
	02C4    60  PUSH1 0x00
	02C6    81  DUP2
	02C7    90  SWAP1
	02C8    50  POP
	02C9    91  SWAP2
	02CA    90  SWAP1
	02CB    50  POP
	02CC    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @02C9  stack[-2] = stack[-1] }
	// Block ends with unconditional jump to stack[-2]

	02CD    5B    JUMPDEST
	02CE    60    PUSH1 0x60
	02D0    61    PUSH2 0x02f2
	02D3    83    DUP4
	02D4    83    DUP4
	02D5    60    PUSH1 0x40
	02D7    51    MLOAD
	02D8    80    DUP1
	02D9    60    PUSH1 0x60
	02DB    01    ADD
	02DC    60    PUSH1 0x40
	02DE    52    MSTORE
	02DF    80    DUP1
	02E0    60    PUSH1 0x27
	02E2    81    DUP2
	02E3    52    MSTORE
	02E4    60    PUSH1 0x20
	02E6    01    ADD
	02E7    61    PUSH2 0x08f7
	02EA    60    PUSH1 0x27
	02EC    91    SWAP2
	02ED    39    CODECOPY
	02EE    61    PUSH2 0x0445
	02F1    56    *JUMP
	02F2    5B    JUMPDEST
	02F3    90    SWAP1
	02F4    50    POP
	02F5    92    SWAP3
	02F6    91    SWAP2
	02F7    50    POP
	02F8    50    POP
	02F9    56    *JUMP
label_02FA:
	// Incoming call from 0x00F9, returns to 0x00FA
	// Inputs[1] { @02FB  stack[-1] }
	02FA    5B  JUMPDEST
	02FB    56  *JUMP
	// Stack delta = -1
	// Block ends with unconditional jump to stack[-1]

label_02FC:
	// Incoming call from 0x0115, returns to 0x0116
	// Incoming call from 0x0104, returns to 0x0105
	02FC    5B  JUMPDEST
	02FD    60  PUSH1 0x00
	02FF    61  PUSH2 0x032a
	0302    7F  PUSH32 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
	0323    60  PUSH1 0x00
	0325    1B  SHL
	0326    61  PUSH2 0x02c3
	0329    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @02FD  stack[0] = 0x00
	//     @02FF  stack[1] = 0x032a
	//     @0325  stack[2] = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc << 0x00
	// }
	// Block ends with call to 0x02c3, returns to 0x032A

label_032A:
	// Incoming return from call to 0x02C3 at 0x0329
	// Inputs[4]
	// {
	//     @032D  stack[-1]
	//     @0331  storage[0x00 + stack[-1]]
	//     @034F  stack[-2]
	//     @0351  stack[-3]
	// }
	032A    5B  JUMPDEST
	032B    60  PUSH1 0x00
	032D    01  ADD
	032E    60  PUSH1 0x00
	0330    90  SWAP1
	0331    54  SLOAD
	0332    90  SWAP1
	0333    61  PUSH2 0x0100
	0336    0A  EXP
	0337    90  SWAP1
	0338    04  DIV
	0339    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	034E    16  AND
	034F    90  SWAP1
	0350    50  POP
	0351    90  SWAP1
	0352    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0351  stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + stack[-1]] / 0x0100 ** 0x00 }
	// Block ends with unconditional jump to stack[-3]

label_0353:
	// Incoming jump from 0x0109
	// Inputs[9]
	// {
	//     @0354  msg.data.length
	//     @0358  msg.data[0x00:0x00 + msg.data.length]
	//     @035C  msg.data.length
	//     @035F  stack[-1]
	//     @0360  msg.gas
	//     @0361  address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length])
	//     @0361  memory[0x00:0x00 + msg.data.length]
	//     @0362  returndata.length
	//     @0366  returndata[0x00:0x00 + returndata.length]
	// }
	0353    5B  JUMPDEST
	0354    36  CALLDATASIZE
	0355    60  PUSH1 0x00
	0357    80  DUP1
	0358    37  CALLDATACOPY
	0359    60  PUSH1 0x00
	035B    80  DUP1
	035C    36  CALLDATASIZE
	035D    60  PUSH1 0x00
	035F    84  DUP5
	0360    5A  GAS
	0361    F4  DELEGATECALL
	0362    3D  RETURNDATASIZE
	0363    60  PUSH1 0x00
	0365    80  DUP1
	0366    3E  RETURNDATACOPY
	0367    80  DUP1
	0368    60  PUSH1 0x00
	036A    81  DUP2
	036B    14  EQ
	036C    61  PUSH2 0x0374
	036F    57  *JUMPI
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @0358  memory[0x00:0x00 + msg.data.length] = msg.data[0x00:0x00 + msg.data.length]
	//     @0361  memory[0x00:0x00] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length])
	//     @0361  stack[0] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length])
	//     @0366  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0367  stack[1] = address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length])
	// }
	// Block ends with conditional jump to 0x0374, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00

label_0370:
	// Incoming jump from 0x036F, if not address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00
	// Inputs[2]
	// {
	//     @0370  returndata.length
	//     @0373  memory[0x00:0x00 + returndata.length]
	// }
	0370    3D  RETURNDATASIZE
	0371    60  PUSH1 0x00
	0373    F3  *RETURN
	// Stack delta = +0
	// Outputs[1] { @0373  return memory[0x00:0x00 + returndata.length]; }
	// Block terminates

label_0374:
	// Incoming jump from 0x036F, if address(stack[-1]).delegatecall.gas(msg.gas)(memory[0x00:0x00 + msg.data.length]) == 0x00
	// Inputs[2]
	// {
	//     @0375  returndata.length
	//     @0378  memory[0x00:0x00 + returndata.length]
	// }
	0374    5B  JUMPDEST
	0375    3D  RETURNDATASIZE
	0376    60  PUSH1 0x00
	0378    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0378  revert(memory[0x00:0x00 + returndata.length]); }
	// Block terminates

label_0379:
	// Incoming call from 0x0122, returns to 0x0123
	// Incoming call from 0x01D3, returns to 0x01D4
	// Inputs[2]
	// {
	//     @037C  msg.sender
	//     @037F  stack[-1]
	// }
	0379    5B  JUMPDEST
	037A    60  PUSH1 0x00
	037C    33  CALLER
	037D    90  SWAP1
	037E    50  POP
	037F    90  SWAP1
	0380    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @037F  stack[-1] = msg.sender }
	// Block ends with unconditional jump to stack[-1]

label_0381:
	// Incoming call from 0x01A0, returns to 0x01A1
	// Incoming call from 0x02BF, returns to 0x02C0
	// Inputs[7]
	// {
	//     @0388  storage[0x00]
	//     @03A8  stack[-1]
	//     @03B1  storage[0x00]
	//     @0439  memory[0x40:0x60]
	//     @043C  memory[0x40:0x60]
	//     @0441  memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]
	//     @0444  stack[-2]
	// }
	0381    5B  JUMPDEST
	0382    60  PUSH1 0x00
	0384    80  DUP1
	0385    60  PUSH1 0x00
	0387    90  SWAP1
	0388    54  SLOAD
	0389    90  SWAP1
	038A    61  PUSH2 0x0100
	038D    0A  EXP
	038E    90  SWAP1
	038F    04  DIV
	0390    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03A5    16  AND
	03A6    90  SWAP1
	03A7    50  POP
	03A8    81  DUP2
	03A9    60  PUSH1 0x00
	03AB    80  DUP1
	03AC    61  PUSH2 0x0100
	03AF    0A  EXP
	03B0    81  DUP2
	03B1    54  SLOAD
	03B2    81  DUP2
	03B3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03C8    02  MUL
	03C9    19  NOT
	03CA    16  AND
	03CB    90  SWAP1
	03CC    83  DUP4
	03CD    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03E2    16  AND
	03E3    02  MUL
	03E4    17  OR
	03E5    90  SWAP1
	03E6    55  SSTORE
	03E7    50  POP
	03E8    81  DUP2
	03E9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03FE    16  AND
	03FF    81  DUP2
	0400    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0415    16  AND
	0416    7F  PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0
	0437    60  PUSH1 0x40
	0439    51  MLOAD
	043A    60  PUSH1 0x40
	043C    51  MLOAD
	043D    80  DUP1
	043E    91  SWAP2
	043F    03  SUB
	0440    90  SWAP1
	0441    A3  LOG3
	0442    50  POP
	0443    50  POP
	0444    56  *JUMP
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @03E6  storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00])
	//     @0441  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]);
	// }
	// Block ends with unconditional jump to stack[-2]

	0445    5B    JUMPDEST
	0446    60    PUSH1 0x60
	0448    61    PUSH2 0x0450
	044B    84    DUP5
	044C    61    PUSH2 0x0512
	044F    56    *JUMP
	0450    5B    JUMPDEST
	0451    61    PUSH2 0x048f
	0454    57    *JUMPI
	0455    60    PUSH1 0x40
	0457    51    MLOAD
	0458    7F    PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0479    81    DUP2
	047A    52    MSTORE
	047B    60    PUSH1 0x04
	047D    01    ADD
	047E    61    PUSH2 0x0486
	0481    90    SWAP1
	0482    61    PUSH2 0x07d7
	0485    56    *JUMP
	0486    5B    JUMPDEST
	0487    60    PUSH1 0x40
	0489    51    MLOAD
	048A    80    DUP1
	048B    91    SWAP2
	048C    03    SUB
	048D    90    SWAP1
	048E    FD    *REVERT
	048F    5B    JUMPDEST
	0490    60    PUSH1 0x00
	0492    80    DUP1
	0493    85    DUP6
	0494    73    PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04A9    16    AND
	04AA    85    DUP6
	04AB    60    PUSH1 0x40
	04AD    51    MLOAD
	04AE    61    PUSH2 0x04b7
	04B1    91    SWAP2
	04B2    90    SWAP1
	04B3    61    PUSH2 0x0868
	04B6    56    *JUMP
	04B7    5B    JUMPDEST
	04B8    60    PUSH1 0x00
	04BA    60    PUSH1 0x40
	04BC    51    MLOAD
	04BD    80    DUP1
	04BE    83    DUP4
	04BF    03    SUB
	04C0    81    DUP2
	04C1    85    DUP6
	04C2    5A    GAS
	04C3    F4    DELEGATECALL
	04C4    91    SWAP2
	04C5    50    POP
	04C6    50    POP
	04C7    3D    RETURNDATASIZE
	04C8    80    DUP1
	04C9    60    PUSH1 0x00
	04CB    81    DUP2
	04CC    14    EQ
	04CD    61    PUSH2 0x04f2
	04D0    57    *JUMPI
	04D1    60    PUSH1 0x40
	04D3    51    MLOAD
	04D4    91    SWAP2
	04D5    50    POP
	04D6    60    PUSH1 0x1f
	04D8    19    NOT
	04D9    60    PUSH1 0x3f
	04DB    3D    RETURNDATASIZE
	04DC    01    ADD
	04DD    16    AND
	04DE    82    DUP3
	04DF    01    ADD
	04E0    60    PUSH1 0x40
	04E2    52    MSTORE
	04E3    3D    RETURNDATASIZE
	04E4    82    DUP3
	04E5    52    MSTORE
	04E6    3D    RETURNDATASIZE
	04E7    60    PUSH1 0x00
	04E9    60    PUSH1 0x20
	04EB    84    DUP5
	04EC    01    ADD
	04ED    3E    RETURNDATACOPY
	04EE    61    PUSH2 0x04f7
	04F1    56    *JUMP
	04F2    5B    JUMPDEST
	04F3    60    PUSH1 0x60
	04F5    91    SWAP2
	04F6    50    POP
	04F7    5B    JUMPDEST
	04F8    50    POP
	04F9    91    SWAP2
	04FA    50    POP
	04FB    91    SWAP2
	04FC    50    POP
	04FD    61    PUSH2 0x0507
	0500    82    DUP3
	0501    82    DUP3
	0502    86    DUP7
	0503    61    PUSH2 0x0535
	0506    56    *JUMP
	0507    5B    JUMPDEST
	0508    92    SWAP3
	0509    50    POP
	050A    50    POP
	050B    50    POP
	050C    93    SWAP4
	050D    92    SWAP3
	050E    50    POP
	050F    50    POP
	0510    50    POP
	0511    56    *JUMP
	0512    5B    JUMPDEST
	0513    60    PUSH1 0x00
	0515    80    DUP1
	0516    82    DUP3
	0517    73    PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	052C    16    AND
	052D    3B    EXTCODESIZE
	052E    11    GT
	052F    90    SWAP1
	0530    50    POP
	0531    91    SWAP2
	0532    90    SWAP1
	0533    50    POP
	0534    56    *JUMP
	0535    5B    JUMPDEST
	0536    60    PUSH1 0x60
	0538    83    DUP4
	0539    15    ISZERO
	053A    61    PUSH2 0x0545
	053D    57    *JUMPI
	053E    82    DUP3
	053F    90    SWAP1
	0540    50    POP
	0541    61    PUSH2 0x0595
	0544    56    *JUMP
	0545    5B    JUMPDEST
	0546    60    PUSH1 0x00
	0548    83    DUP4
	0549    51    MLOAD
	054A    11    GT
	054B    15    ISZERO
	054C    61    PUSH2 0x0558
	054F    57    *JUMPI
	0550    82    DUP3
	0551    51    MLOAD
	0552    80    DUP1
	0553    84    DUP5
	0554    60    PUSH1 0x20
	0556    01    ADD
	0557    FD    *REVERT
	0558    5B    JUMPDEST
	0559    81    DUP2
	055A    60    PUSH1 0x40
	055C    51    MLOAD
	055D    7F    PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	057E    81    DUP2
	057F    52    MSTORE
	0580    60    PUSH1 0x04
	0582    01    ADD
	0583    61    PUSH2 0x058c
	0586    91    SWAP2
	0587    90    SWAP1
	0588    61    PUSH2 0x08d4
	058B    56    *JUMP
	058C    5B    JUMPDEST
	058D    60    PUSH1 0x40
	058F    51    MLOAD
	0590    80    DUP1
	0591    91    SWAP2
	0592    03    SUB
	0593    90    SWAP1
	0594    FD    *REVERT
	0595    5B    JUMPDEST
	0596    93    SWAP4
	0597    92    SWAP3
	0598    50    POP
	0599    50    POP
	059A    50    POP
	059B    56    *JUMP
label_059C:
	// Incoming call from 0x05C6, returns to 0x05C7
	// Inputs[2]
	// {
	//     @05B4  stack[-1]
	//     @05B8  stack[-2]
	// }
	059C    5B  JUMPDEST
	059D    60  PUSH1 0x00
	059F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	05B4    82  DUP3
	05B5    16  AND
	05B6    90  SWAP1
	05B7    50  POP
	05B8    91  SWAP2
	05B9    90  SWAP1
	05BA    50  POP
	05BB    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @05B8  stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff }
	// Block ends with unconditional jump to stack[-2]

label_05BC:
	// Incoming call from 0x0605, returns to 0x0606
	// Incoming call from 0x05D6, returns to 0x05D7
	// Inputs[1] { @05C2  stack[-1] }
	05BC    5B  JUMPDEST
	05BD    60  PUSH1 0x00
	05BF    61  PUSH2 0x05c7
	05C2    82  DUP3
	05C3    61  PUSH2 0x059c
	05C6    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @05BD  stack[0] = 0x00
	//     @05BF  stack[1] = 0x05c7
	//     @05C2  stack[2] = stack[-1]
	// }
	// Block ends with call to 0x059c, returns to 0x05C7

label_05C7:
	// Incoming return from call to 0x059C at 0x05C6
	// Inputs[4]
	// {
	//     @05C8  stack[-1]
	//     @05C8  stack[-2]
	//     @05CA  stack[-4]
	//     @05CB  stack[-3]
	// }
	05C7    5B  JUMPDEST
	05C8    90  SWAP1
	05C9    50  POP
	05CA    91  SWAP2
	05CB    90  SWAP1
	05CC    50  POP
	05CD    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @05CA  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_05CE:
	// Incoming call from 0x05F1, returns to 0x05F2
	// Inputs[1] { @05D2  stack[-1] }
	05CE    5B  JUMPDEST
	05CF    61  PUSH2 0x05d7
	05D2    81  DUP2
	05D3    61  PUSH2 0x05bc
	05D6    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05CF  stack[0] = 0x05d7
	//     @05D2  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x05bc, returns to 0x05D7

label_05D7:
	// Incoming return from call to 0x05BC at 0x05D6
	// Inputs[3]
	// {
	//     @05D8  stack[-3]
	//     @05D9  stack[-1]
	//     @05DC  stack[-4]
	// }
	05D7    5B  JUMPDEST
	05D8    82  DUP3
	05D9    52  MSTORE
	05DA    50  POP
	05DB    50  POP
	05DC    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @05D9  memory[stack[-3]:stack[-3] + 0x20] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_05DD:
	// Incoming call from 0x00BF, returns to 0x00C0
	// Incoming call from 0x007D, returns to 0x007E
	// Inputs[2]
	// {
	//     @05E2  stack[-1]
	//     @05ED  stack[-2]
	// }
	05DD    5B  JUMPDEST
	05DE    60  PUSH1 0x00
	05E0    60  PUSH1 0x20
	05E2    82  DUP3
	05E3    01  ADD
	05E4    90  SWAP1
	05E5    50  POP
	05E6    61  PUSH2 0x05f2
	05E9    60  PUSH1 0x00
	05EB    83  DUP4
	05EC    01  ADD
	05ED    84  DUP5
	05EE    61  PUSH2 0x05ce
	05F1    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @05E4  stack[0] = stack[-1] + 0x20
	//     @05E6  stack[1] = 0x05f2
	//     @05EC  stack[2] = stack[-1] + 0x00
	//     @05ED  stack[3] = stack[-2]
	// }
	// Block ends with call to 0x05ce, returns to 0x05F2

label_05F2:
	// Incoming return from call to 0x05CE at 0x05F1
	// Inputs[3]
	// {
	//     @05F3  stack[-1]
	//     @05F3  stack[-4]
	//     @05F4  stack[-3]
	// }
	05F2    5B  JUMPDEST
	05F3    92  SWAP3
	05F4    91  SWAP2
	05F5    50  POP
	05F6    50  POP
	05F7    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @05F3  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_05F8:
	// Incoming jump from 0x063D
	// Inputs[1] { @05FC  memory[0x00:0x00] }
	05F8    5B  JUMPDEST
	05F9    60  PUSH1 0x00
	05FB    80  DUP1
	05FC    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @05FC  revert(memory[0x00:0x00]); }
	// Block terminates

label_05FD:
	// Incoming call from 0x0622, returns to 0x0623
	// Inputs[1] { @0601  stack[-1] }
	05FD    5B  JUMPDEST
	05FE    61  PUSH2 0x0606
	0601    81  DUP2
	0602    61  PUSH2 0x05bc
	0605    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05FE  stack[0] = 0x0606
	//     @0601  stack[1] = stack[-1]
	// }
	// Block ends with call to 0x05bc, returns to 0x0606

label_0606:
	// Incoming return from call to 0x05BC at 0x0605
	// Inputs[2]
	// {
	//     @0607  stack[-2]
	//     @0608  stack[-1]
	// }
	0606    5B  JUMPDEST
	0607    81  DUP2
	0608    14  EQ
	0609    61  PUSH2 0x0611
	060C    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0611, if stack[-2] == stack[-1]

label_060D:
	// Incoming jump from 0x060C, if not stack[-2] == stack[-1]
	// Inputs[1] { @0610  memory[0x00:0x00] }
	060D    60  PUSH1 0x00
	060F    80  DUP1
	0610    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0610  revert(memory[0x00:0x00]); }
	// Block terminates

label_0611:
	// Incoming jump from 0x060C, if stack[-2] == stack[-1]
	// Inputs[1] { @0613  stack[-2] }
	0611    5B  JUMPDEST
	0612    50  POP
	0613    56  *JUMP
	// Stack delta = -2
	// Block ends with unconditional jump to stack[-2]

label_0614:
	// Incoming call from 0x064C, returns to 0x064D
	// Inputs[2]
	// {
	//     @0617  stack[-1]
	//     @0618  msg.data[stack[-1]:stack[-1] + 0x20]
	// }
	0614    5B  JUMPDEST
	0615    60  PUSH1 0x00
	0617    81  DUP2
	0618    35  CALLDATALOAD
	0619    90  SWAP1
	061A    50  POP
	061B    61  PUSH2 0x0623
	061E    81  DUP2
	061F    61  PUSH2 0x05fd
	0622    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0619  stack[0] = msg.data[stack[-1]:stack[-1] + 0x20]
	//     @061B  stack[1] = 0x0623
	//     @061E  stack[2] = msg.data[stack[-1]:stack[-1] + 0x20]
	// }
	// Block ends with call to 0x05fd, returns to 0x0623

label_0623:
	// Incoming return from call to 0x05FD at 0x0622
	// Inputs[3]
	// {
	//     @0624  stack[-4]
	//     @0624  stack[-1]
	//     @0625  stack[-3]
	// }
	0623    5B  JUMPDEST
	0624    92  SWAP3
	0625    91  SWAP2
	0626    50  POP
	0627    50  POP
	0628    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @0624  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_0629:
	// Incoming call from 0x00EA, returns to 0x00EB
	// Inputs[2]
	// {
	//     @062E  stack[-1]
	//     @062F  stack[-2]
	// }
	0629    5B  JUMPDEST
	062A    60  PUSH1 0x00
	062C    60  PUSH1 0x20
	062E    82  DUP3
	062F    84  DUP5
	0630    03  SUB
	0631    12  SLT
	0632    15  ISZERO
	0633    61  PUSH2 0x063f
	0636    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @062A  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x063f, if !(stack[-2] - stack[-1] i< 0x20)

label_0637:
	// Incoming jump from 0x0636, if not !(stack[-2] - stack[-1] i< 0x20)
	0637    61  PUSH2 0x063e
	063A    61  PUSH2 0x05f8
	063D    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0637  stack[0] = 0x063e }
	// Block ends with unconditional jump to 0x05f8

	063E    5B    JUMPDEST
label_063F:
	// Incoming jump from 0x0636, if !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[2]
	// {
	//     @0645  stack[-3]
	//     @0647  stack[-2]
	// }
	063F    5B  JUMPDEST
	0640    60  PUSH1 0x00
	0642    61  PUSH2 0x064d
	0645    84  DUP5
	0646    82  DUP3
	0647    85  DUP6
	0648    01  ADD
	0649    61  PUSH2 0x0614
	064C    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0640  stack[0] = 0x00
	//     @0642  stack[1] = 0x064d
	//     @0645  stack[2] = stack[-3]
	//     @0648  stack[3] = stack[-2] + 0x00
	// }
	// Block ends with call to 0x0614, returns to 0x064D

label_064D:
	// Incoming return from call to 0x0614 at 0x064C
	// Inputs[4]
	// {
	//     @064E  stack[-1]
	//     @064E  stack[-3]
	//     @0651  stack[-6]
	//     @0652  stack[-5]
	// }
	064D    5B  JUMPDEST
	064E    91  SWAP2
	064F    50  POP
	0650    50  POP
	0651    92  SWAP3
	0652    91  SWAP2
	0653    50  POP
	0654    50  POP
	0655    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @0651  stack[-6] = stack[-1] }
	// Block ends with unconditional jump to stack[-6]

label_0656:
	// Incoming call from 0x069C, returns to 0x069D
	// Incoming call from 0x072E, returns to 0x072F
	// Inputs[3]
	// {
	//     @0659  stack[-2]
	//     @065A  stack[-1]
	//     @0662  stack[-3]
	// }
	0656    5B  JUMPDEST
	0657    60  PUSH1 0x00
	0659    82  DUP3
	065A    82  DUP3
	065B    52  MSTORE
	065C    60  PUSH1 0x20
	065E    82  DUP3
	065F    01  ADD
	0660    90  SWAP1
	0661    50  POP
	0662    92  SWAP3
	0663    91  SWAP2
	0664    50  POP
	0665    50  POP
	0666    56  *JUMP
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @065B  memory[stack[-1]:stack[-1] + 0x20] = stack[-2]
	//     @0662  stack[-3] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to stack[-3]

label_0667:
	// Incoming call from 0x06A7, returns to 0x06A8
	// Inputs[2]
	// {
	//     @068B  stack[-1]
	//     @068F  stack[-2]
	// }
	0667    5B  JUMPDEST
	0668    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	0689    60  PUSH1 0x00
	068B    82  DUP3
	068C    01  ADD
	068D    52  MSTORE
	068E    50  POP
	068F    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @068D  memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 }
	// Block ends with unconditional jump to stack[-2]

label_0690:
	// Incoming call from 0x06CB, returns to 0x06CC
	// Inputs[1] { @0698  stack[-1] }
	0690    5B  JUMPDEST
	0691    60  PUSH1 0x00
	0693    61  PUSH2 0x069d
	0696    60  PUSH1 0x20
	0698    83  DUP4
	0699    61  PUSH2 0x0656
	069C    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0691  stack[0] = 0x00
	//     @0693  stack[1] = 0x069d
	//     @0696  stack[2] = 0x20
	//     @0698  stack[3] = stack[-1]
	// }
	// Block ends with call to 0x0656, returns to 0x069D

label_069D:
	// Incoming return from call to 0x0656 at 0x069C
	// Inputs[2]
	// {
	//     @069E  stack[-3]
	//     @069E  stack[-1]
	// }
	069D    5B  JUMPDEST
	069E    91  SWAP2
	069F    50  POP
	06A0    61  PUSH2 0x06a8
	06A3    82  DUP3
	06A4    61  PUSH2 0x0667
	06A7    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @069E  stack[-3] = stack[-1]
	//     @06A0  stack[-1] = 0x06a8
	//     @06A3  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x0667, returns to 0x06A8

label_06A8:
	// Incoming return from call to 0x0667 at 0x06A7
	// Inputs[3]
	// {
	//     @06AB  stack[-2]
	//     @06AD  stack[-1]
	//     @06AF  stack[-3]
	// }
	06A8    5B  JUMPDEST
	06A9    60  PUSH1 0x20
	06AB    82  DUP3
	06AC    01  ADD
	06AD    90  SWAP1
	06AE    50  POP
	06AF    91  SWAP2
	06B0    90  SWAP1
	06B1    50  POP
	06B2    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @06AF  stack[-3] = stack[-2] + 0x20 }
	// Block ends with unconditional jump to stack[-3]

label_06B3:
	// Incoming call from 0x023E, returns to 0x023F
	// Incoming call from 0x018D, returns to 0x018E
	// Inputs[1] { @06B8  stack[-1] }
	06B3    5B  JUMPDEST
	06B4    60  PUSH1 0x00
	06B6    60  PUSH1 0x20
	06B8    82  DUP3
	06B9    01  ADD
	06BA    90  SWAP1
	06BB    50  POP
	06BC    81  DUP2
	06BD    81  DUP2
	06BE    03  SUB
	06BF    60  PUSH1 0x00
	06C1    83  DUP4
	06C2    01  ADD
	06C3    52  MSTORE
	06C4    61  PUSH2 0x06cc
	06C7    81  DUP2
	06C8    61  PUSH2 0x0690
	06CB    56  *JUMP
	// Stack delta = +3
	// Outputs[4]
	// {
	//     @06BA  stack[0] = stack[-1] + 0x20
	//     @06C3  memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1]
	//     @06C4  stack[1] = 0x06cc
	//     @06C7  stack[2] = stack[-1] + 0x20
	// }
	// Block ends with call to 0x0690, returns to 0x06CC

label_06CC:
	// Incoming return from call to 0x0690 at 0x06CB
	// Inputs[4]
	// {
	//     @06CD  stack[-2]
	//     @06CD  stack[-1]
	//     @06CF  stack[-4]
	//     @06D0  stack[-3]
	// }
	06CC    5B  JUMPDEST
	06CD    90  SWAP1
	06CE    50  POP
	06CF    91  SWAP2
	06D0    90  SWAP1
	06D1    50  POP
	06D2    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @06CF  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_06D3:
	// Incoming call from 0x0739, returns to 0x073A
	// Inputs[2]
	// {
	//     @06F7  stack[-1]
	//     @0721  stack[-2]
	// }
	06D3    5B  JUMPDEST
	06D4    7F  PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061
	06F5    60  PUSH1 0x00
	06F7    82  DUP3
	06F8    01  ADD
	06F9    52  MSTORE
	06FA    7F  PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000
	071B    60  PUSH1 0x20
	071D    82  DUP3
	071E    01  ADD
	071F    52  MSTORE
	0720    50  POP
	0721    56  *JUMP
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @06F9  memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061
	//     @071F  memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000
	// }
	// Block ends with unconditional jump to stack[-2]

label_0722:
	// Incoming call from 0x075D, returns to 0x075E
	// Inputs[1] { @072A  stack[-1] }
	0722    5B  JUMPDEST
	0723    60  PUSH1 0x00
	0725    61  PUSH2 0x072f
	0728    60  PUSH1 0x26
	072A    83  DUP4
	072B    61  PUSH2 0x0656
	072E    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0723  stack[0] = 0x00
	//     @0725  stack[1] = 0x072f
	//     @0728  stack[2] = 0x26
	//     @072A  stack[3] = stack[-1]
	// }
	// Block ends with call to 0x0656, returns to 0x072F

label_072F:
	// Incoming return from call to 0x0656 at 0x072E
	// Inputs[2]
	// {
	//     @0730  stack[-1]
	//     @0730  stack[-3]
	// }
	072F    5B  JUMPDEST
	0730    91  SWAP2
	0731    50  POP
	0732    61  PUSH2 0x073a
	0735    82  DUP3
	0736    61  PUSH2 0x06d3
	0739    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0730  stack[-3] = stack[-1]
	//     @0732  stack[-1] = 0x073a
	//     @0735  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x06d3, returns to 0x073A

label_073A:
	// Incoming return from call to 0x06D3 at 0x0739
	// Inputs[3]
	// {
	//     @073D  stack[-2]
	//     @073F  stack[-1]
	//     @0741  stack[-3]
	// }
	073A    5B  JUMPDEST
	073B    60  PUSH1 0x40
	073D    82  DUP3
	073E    01  ADD
	073F    90  SWAP1
	0740    50  POP
	0741    91  SWAP2
	0742    90  SWAP1
	0743    50  POP
	0744    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0741  stack[-3] = stack[-2] + 0x40 }
	// Block ends with unconditional jump to stack[-3]

label_0745:
	// Incoming call from 0x02AD, returns to 0x02AE
	// Inputs[1] { @074A  stack[-1] }
	0745    5B  JUMPDEST
	0746    60  PUSH1 0x00
	0748    60  PUSH1 0x20
	074A    82  DUP3
	074B    01  ADD
	074C    90  SWAP1
	074D    50  POP
	074E    81  DUP2
	074F    81  DUP2
	0750    03  SUB
	0751    60  PUSH1 0x00
	0753    83  DUP4
	0754    01  ADD
	0755    52  MSTORE
	0756    61  PUSH2 0x075e
	0759    81  DUP2
	075A    61  PUSH2 0x0722
	075D    56  *JUMP
	// Stack delta = +3
	// Outputs[4]
	// {
	//     @074C  stack[0] = stack[-1] + 0x20
	//     @0755  memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1]
	//     @0756  stack[1] = 0x075e
	//     @0759  stack[2] = stack[-1] + 0x20
	// }
	// Block ends with call to 0x0722, returns to 0x075E

label_075E:
	// Incoming return from call to 0x0722 at 0x075D
	// Inputs[4]
	// {
	//     @075F  stack[-1]
	//     @075F  stack[-2]
	//     @0761  stack[-4]
	//     @0762  stack[-3]
	// }
	075E    5B  JUMPDEST
	075F    90  SWAP1
	0760    50  POP
	0761    91  SWAP2
	0762    90  SWAP1
	0763    50  POP
	0764    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @0761  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

	0765    5B    JUMPDEST
	0766    7F    PUSH32 0x416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f
	0787    60    PUSH1 0x00
	0789    82    DUP3
	078A    01    ADD
	078B    52    MSTORE
	078C    7F    PUSH32 0x6e74726163740000000000000000000000000000000000000000000000000000
	07AD    60    PUSH1 0x20
	07AF    82    DUP3
	07B0    01    ADD
	07B1    52    MSTORE
	07B2    50    POP
	07B3    56    *JUMP
	07B4    5B    JUMPDEST
	07B5    60    PUSH1 0x00
	07B7    61    PUSH2 0x07c1
	07BA    60    PUSH1 0x26
	07BC    83    DUP4
	07BD    61    PUSH2 0x0656
	07C0    56    *JUMP
	07C1    5B    JUMPDEST
	07C2    91    SWAP2
	07C3    50    POP
	07C4    61    PUSH2 0x07cc
	07C7    82    DUP3
	07C8    61    PUSH2 0x0765
	07CB    56    *JUMP
	07CC    5B    JUMPDEST
	07CD    60    PUSH1 0x40
	07CF    82    DUP3
	07D0    01    ADD
	07D1    90    SWAP1
	07D2    50    POP
	07D3    91    SWAP2
	07D4    90    SWAP1
	07D5    50    POP
	07D6    56    *JUMP
	07D7    5B    JUMPDEST
	07D8    60    PUSH1 0x00
	07DA    60    PUSH1 0x20
	07DC    82    DUP3
	07DD    01    ADD
	07DE    90    SWAP1
	07DF    50    POP
	07E0    81    DUP2
	07E1    81    DUP2
	07E2    03    SUB
	07E3    60    PUSH1 0x00
	07E5    83    DUP4
	07E6    01    ADD
	07E7    52    MSTORE
	07E8    61    PUSH2 0x07f0
	07EB    81    DUP2
	07EC    61    PUSH2 0x07b4
	07EF    56    *JUMP
	07F0    5B    JUMPDEST
	07F1    90    SWAP1
	07F2    50    POP
	07F3    91    SWAP2
	07F4    90    SWAP1
	07F5    50    POP
	07F6    56    *JUMP
	07F7    5B    JUMPDEST
	07F8    60    PUSH1 0x00
	07FA    81    DUP2
	07FB    51    MLOAD
	07FC    90    SWAP1
	07FD    50    POP
	07FE    91    SWAP2
	07FF    90    SWAP1
	0800    50    POP
	0801    56    *JUMP
	0802    5B    JUMPDEST
	0803    60    PUSH1 0x00
	0805    81    DUP2
	0806    90    SWAP1
	0807    50    POP
	0808    92    SWAP3
	0809    91    SWAP2
	080A    50    POP
	080B    50    POP
	080C    56    *JUMP
	080D    5B    JUMPDEST
	080E    60    PUSH1 0x00
	0810    5B    JUMPDEST
	0811    83    DUP4
	0812    81    DUP2
	0813    10    LT
	0814    15    ISZERO
	0815    61    PUSH2 0x082b
	0818    57    *JUMPI
	0819    80    DUP1
	081A    82    DUP3
	081B    01    ADD
	081C    51    MLOAD
	081D    81    DUP2
	081E    84    DUP5
	081F    01    ADD
	0820    52    MSTORE
	0821    60    PUSH1 0x20
	0823    81    DUP2
	0824    01    ADD
	0825    90    SWAP1
	0826    50    POP
	0827    61    PUSH2 0x0810
	082A    56    *JUMP
	082B    5B    JUMPDEST
	082C    60    PUSH1 0x00
	082E    84    DUP5
	082F    84    DUP5
	0830    01    ADD
	0831    52    MSTORE
	0832    50    POP
	0833    50    POP
	0834    50    POP
	0835    50    POP
	0836    56    *JUMP
	0837    5B    JUMPDEST
	0838    60    PUSH1 0x00
	083A    61    PUSH2 0x0842
	083D    82    DUP3
	083E    61    PUSH2 0x07f7
	0841    56    *JUMP
	0842    5B    JUMPDEST
	0843    61    PUSH2 0x084c
	0846    81    DUP2
	0847    85    DUP6
	0848    61    PUSH2 0x0802
	084B    56    *JUMP
	084C    5B    JUMPDEST
	084D    93    SWAP4
	084E    50    POP
	084F    61    PUSH2 0x085c
	0852    81    DUP2
	0853    85    DUP6
	0854    60    PUSH1 0x20
	0856    86    DUP7
	0857    01    ADD
	0858    61    PUSH2 0x080d
	085B    56    *JUMP
	085C    5B    JUMPDEST
	085D    80    DUP1
	085E    84    DUP5
	085F    01    ADD
	0860    91    SWAP2
	0861    50    POP
	0862    50    POP
	0863    92    SWAP3
	0864    91    SWAP2
	0865    50    POP
	0866    50    POP
	0867    56    *JUMP
	0868    5B    JUMPDEST
	0869    60    PUSH1 0x00
	086B    61    PUSH2 0x0874
	086E    82    DUP3
	086F    84    DUP5
	0870    61    PUSH2 0x0837
	0873    56    *JUMP
	0874    5B    JUMPDEST
	0875    91    SWAP2
	0876    50    POP
	0877    81    DUP2
	0878    90    SWAP1
	0879    50    POP
	087A    92    SWAP3
	087B    91    SWAP2
	087C    50    POP
	087D    50    POP
	087E    56    *JUMP
	087F    5B    JUMPDEST
	0880    60    PUSH1 0x00
	0882    81    DUP2
	0883    51    MLOAD
	0884    90    SWAP1
	0885    50    POP
	0886    91    SWAP2
	0887    90    SWAP1
	0888    50    POP
	0889    56    *JUMP
	088A    5B    JUMPDEST
	088B    60    PUSH1 0x00
	088D    60    PUSH1 0x1f
	088F    19    NOT
	0890    60    PUSH1 0x1f
	0892    83    DUP4
	0893    01    ADD
	0894    16    AND
	0895    90    SWAP1
	0896    50    POP
	0897    91    SWAP2
	0898    90    SWAP1
	0899    50    POP
	089A    56    *JUMP
	089B    5B    JUMPDEST
	089C    60    PUSH1 0x00
	089E    61    PUSH2 0x08a6
	08A1    82    DUP3
	08A2    61    PUSH2 0x087f
	08A5    56    *JUMP
	08A6    5B    JUMPDEST
	08A7    61    PUSH2 0x08b0
	08AA    81    DUP2
	08AB    85    DUP6
	08AC    61    PUSH2 0x0656
	08AF    56    *JUMP
	08B0    5B    JUMPDEST
	08B1    93    SWAP4
	08B2    50    POP
	08B3    61    PUSH2 0x08c0
	08B6    81    DUP2
	08B7    85    DUP6
	08B8    60    PUSH1 0x20
	08BA    86    DUP7
	08BB    01    ADD
	08BC    61    PUSH2 0x080d
	08BF    56    *JUMP
	08C0    5B    JUMPDEST
	08C1    61    PUSH2 0x08c9
	08C4    81    DUP2
	08C5    61    PUSH2 0x088a
	08C8    56    *JUMP
	08C9    5B    JUMPDEST
	08CA    84    DUP5
	08CB    01    ADD
	08CC    91    SWAP2
	08CD    50    POP
	08CE    50    POP
	08CF    92    SWAP3
	08D0    91    SWAP2
	08D1    50    POP
	08D2    50    POP
	08D3    56    *JUMP
	08D4    5B    JUMPDEST
	08D5    60    PUSH1 0x00
	08D7    60    PUSH1 0x20
	08D9    82    DUP3
	08DA    01    ADD
	08DB    90    SWAP1
	08DC    50    POP
	08DD    81    DUP2
	08DE    81    DUP2
	08DF    03    SUB
	08E0    60    PUSH1 0x00
	08E2    83    DUP4
	08E3    01    ADD
	08E4    52    MSTORE
	08E5    61    PUSH2 0x08ee
	08E8    81    DUP2
	08E9    84    DUP5
	08EA    61    PUSH2 0x089b
	08ED    56    *JUMP
	08EE    5B    JUMPDEST
	08EF    90    SWAP1
	08F0    50    POP
	08F1    92    SWAP3
	08F2    91    SWAP2
	08F3    50    POP
	08F4    50    POP
	08F5    56    *JUMP
	08F6    FE    *ASSERT
	08F7    41    COINBASE
	08F8    64    PUSH5 0x6472657373
	08FE    3A    GASPRICE
	08FF    20    SHA3
	0900    6C    PUSH13 0x6f772d6c6576656c2064656c65
	090E    67    PUSH8 0x6174652063616c6c
	0917    20    SHA3
	0918    66    PUSH7 0x61696c6564a264
	0920    69    PUSH10 0x70667358221220cf44d4
	092B    95    SWAP6
	092C    DA    DA
	092D    2F    2F
	092E    A0    LOG0
	092F    6C    PUSH13 0x491439baea8293b5bc424d58ec
	093D    38    CODESIZE
	093E    38    CODESIZE
	093F    65    PUSH6 0xfdbca2e5331d
	0946    40    BLOCKHASH
	0947    98    SWAP9
	0948    64    PUSH5 0x736f6c6343
	094E    00    *STOP
	094F    08    ADDMOD
	0950    12    SLT
	0951    00    *STOP
	0952    33    CALLER