Online Solidity Decompiler

« Decompile another contract

Address

0xdef1ce6fd45d565ca099bd9f641ca70765896773 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x06fdde03 name()

0x095ea7b3 approve(address,uint256)

0x124d91e5 burnFrom(address,uint256,uint256)

0x18160ddd totalSupply()

0x23b872dd transferFrom(address,address,uint256)

0x27e235e3 balances(address)

0x313ce567 decimals()

0x5c658165 allowed(address,address)

0x66b627bd changeBurnPercentage(uint8)

0x70a08231 balanceOf(address)

0x715018a6 renounceOwnership()

0x8da5cb5b owner()

0x95d89b41 symbol()

0x9d799ff1 findPercentage(uint256)

0xa9059cbb transfer(address,uint256)

0xb242e534 transferOwnership(address,bool)

0xdd62ed3e allowance(address,address)

0xf01f20df burnPercentage()

0xff9913e8 allow(address)

Internal Methods

approve(arg0, arg1) returns (r0)

burnFrom(arg0, arg1)

transferFrom(arg0, arg1) returns (r0)

balances(arg0, arg2) returns (r0)

allowed(arg0, arg2) returns (r0)

changeBurnPercentage(arg0, arg1)

balanceOf(arg0, arg1) returns (r0)

findPercentage(arg0, arg1) returns (r0)

transfer(arg0, arg1) returns (r0)

transferOwnership(arg0, arg1)

allowance(arg0, arg1) returns (r0)

allow(arg0, arg2) returns (r0)

name(arg0) returns (r0)

totalSupply(arg0) returns (r0)

decimals(arg0) returns (r0)

renounceOwnership()

owner(arg0) returns (r0)

symbol(arg0) returns (r0)

func_1294(arg0, arg1) returns (r0)

burnPercentage(arg0) returns (r0)

func_1697(arg0, arg1, arg2) returns (r0)

func_1757(arg0, arg1) returns (r0)

func_17A1(arg0, arg1) returns (r0)

func_1829(arg0, arg1) returns (r0)

func_18F9(arg0, arg1, arg2) returns (r0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
        var var0 = msg.value;
    
        if (var0) { revert(memory[0x00:0x00]); }
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (0x70a08231 > var0) {
            if (0x23b872dd > var0) {
                if (var0 == 0x06fdde03) {
                    // Dispatch table entry for name()
                    var var1 = 0x012e;
                    var var2 = name();
                    var temp0 = memory[0x40:0x60];
                    var var3 = temp0;
                    var var4 = var3;
                    var temp1 = var4 + 0x20;
                    memory[var4:var4 + 0x20] = temp1 - var4;
                    var temp2 = var2;
                    memory[temp1:temp1 + 0x20] = memory[temp2:temp2 + 0x20];
                    var var5 = temp1 + 0x20;
                    var var6 = temp2 + 0x20;
                    var var7 = memory[temp2:temp2 + 0x20];
                    var var8 = var7;
                    var var9 = var5;
                    var var10 = var6;
                    var var11 = 0x00;
                
                    if (var11 >= var8) {
                    label_016E:
                        var temp3 = var7;
                        var5 = temp3 + var5;
                        var6 = temp3 & 0x1f;
                    
                        if (!var6) {
                            var temp4 = memory[0x40:0x60];
                            return memory[temp4:temp4 + var5 - temp4];
                        } else {
                            var temp5 = var6;
                            var temp6 = var5 - temp5;
                            memory[temp6:temp6 + 0x20] = ~(0x0100 ** (0x20 - temp5) - 0x01) & memory[temp6:temp6 + 0x20];
                            var temp7 = memory[0x40:0x60];
                            return memory[temp7:temp7 + (temp6 + 0x20) - temp7];
                        }
                    } else {
                    label_015C:
                        var temp8 = var11;
                        memory[var9 + temp8:var9 + temp8 + 0x20] = memory[var10 + temp8:var10 + temp8 + 0x20];
                        var11 = temp8 + 0x20;
                    
                        if (var11 >= var8) { goto label_016E; }
                        else { goto label_015C; }
                    }
                } else if (var0 == 0x095ea7b3) {
                    // Dispatch table entry for approve(address,uint256)
                    var1 = 0x01f5;
                    var2 = 0x04;
                    var3 = msg.data.length - var2;
                
                    if (var3 < 0x40) { revert(memory[0x00:0x00]); }
                
                    var1 = approve(var2, var3);
                    var temp9 = memory[0x40:0x60];
                    memory[temp9:temp9 + 0x20] = !!var1;
                    var temp10 = memory[0x40:0x60];
                    return memory[temp10:temp10 + (temp9 + 0x20) - temp10];
                } else if (var0 == 0x124d91e5) {
                    // Dispatch table entry for burnFrom(address,uint256,uint256)
                    var1 = 0x0265;
                    var2 = 0x04;
                    var3 = msg.data.length - var2;
                
                    if (var3 < 0x60) { revert(memory[0x00:0x00]); }
                
                    burnFrom(var2, var3);
                    stop();
                } else if (var0 == 0x18160ddd) {
                    // Dispatch table entry for totalSupply()
                    var1 = 0x026f;
                    var2 = totalSupply();
                    var temp11 = memory[0x40:0x60];
                    memory[temp11:temp11 + 0x20] = var2;
                    var temp12 = memory[0x40:0x60];
                    return memory[temp12:temp12 + (temp11 + 0x20) - temp12];
                } else { revert(memory[0x00:0x00]); }
            } else if (var0 == 0x23b872dd) {
                // Dispatch table entry for transferFrom(address,address,uint256)
                var1 = 0x02f1;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x60) { revert(memory[0x00:0x00]); }
            
                var1 = transferFrom(var2, var3);
                var temp13 = memory[0x40:0x60];
                memory[temp13:temp13 + 0x20] = !!var1;
                var temp14 = memory[0x40:0x60];
                return memory[temp14:temp14 + (temp13 + 0x20) - temp14];
            } else if (var0 == 0x27e235e3) {
                // Dispatch table entry for balances(address)
                var1 = 0x034d;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var2 = balances(var2, var3);
                var temp15 = memory[0x40:0x60];
                memory[temp15:temp15 + 0x20] = var2;
                var temp16 = memory[0x40:0x60];
                return memory[temp16:temp16 + (temp15 + 0x20) - temp16];
            } else if (var0 == 0x313ce567) {
                // Dispatch table entry for decimals()
                var1 = 0x036b;
                var2 = decimals();
                var temp17 = memory[0x40:0x60];
                memory[temp17:temp17 + 0x20] = var2 & 0xff;
                var temp18 = memory[0x40:0x60];
                return memory[temp18:temp18 + (temp17 + 0x20) - temp18];
            } else if (var0 == 0x5c658165) {
                // Dispatch table entry for allowed(address,address)
                var1 = 0x03e9;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x40) { revert(memory[0x00:0x00]); }
            
                var2 = allowed(var2, var3);
                var temp19 = memory[0x40:0x60];
                memory[temp19:temp19 + 0x20] = var2;
                var temp20 = memory[0x40:0x60];
                return memory[temp20:temp20 + (temp19 + 0x20) - temp20];
            } else if (var0 == 0x66b627bd) {
                // Dispatch table entry for changeBurnPercentage(uint8)
                var1 = 0x042e;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                changeBurnPercentage(var2, var3);
                stop();
            } else { revert(memory[0x00:0x00]); }
        } else if (0xa9059cbb > var0) {
            if (var0 == 0x70a08231) {
                // Dispatch table entry for balanceOf(address)
                var1 = 0x0472;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var1 = balanceOf(var2, var3);
                var temp21 = memory[0x40:0x60];
                memory[temp21:temp21 + 0x20] = var1;
                var temp22 = memory[0x40:0x60];
                return memory[temp22:temp22 + (temp21 + 0x20) - temp22];
            } else if (var0 == 0x715018a6) {
                // Dispatch table entry for renounceOwnership()
                var1 = 0x0490;
                renounceOwnership();
                stop();
            } else if (var0 == 0x8da5cb5b) {
                // Dispatch table entry for owner()
                var1 = 0x049a;
                var2 = owner();
                var temp23 = memory[0x40:0x60];
                memory[temp23:temp23 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff;
                var temp24 = memory[0x40:0x60];
                return memory[temp24:temp24 + (temp23 + 0x20) - temp24];
            } else if (var0 == 0x95d89b41) {
                // Dispatch table entry for symbol()
                var1 = 0x04e4;
                var2 = symbol();
                var temp25 = memory[0x40:0x60];
                var3 = temp25;
                var4 = var3;
                var temp26 = var4 + 0x20;
                memory[var4:var4 + 0x20] = temp26 - var4;
                var temp27 = var2;
                memory[temp26:temp26 + 0x20] = memory[temp27:temp27 + 0x20];
                var5 = temp26 + 0x20;
                var7 = memory[temp27:temp27 + 0x20];
                var6 = temp27 + 0x20;
                var8 = var7;
                var9 = var5;
                var10 = var6;
                var11 = 0x00;
            
                if (var11 >= var8) {
                label_0524:
                    var temp28 = var7;
                    var5 = temp28 + var5;
                    var6 = temp28 & 0x1f;
                
                    if (!var6) {
                        var temp29 = memory[0x40:0x60];
                        return memory[temp29:temp29 + var5 - temp29];
                    } else {
                        var temp30 = var6;
                        var temp31 = var5 - temp30;
                        memory[temp31:temp31 + 0x20] = ~(0x0100 ** (0x20 - temp30) - 0x01) & memory[temp31:temp31 + 0x20];
                        var temp32 = memory[0x40:0x60];
                        return memory[temp32:temp32 + (temp31 + 0x20) - temp32];
                    }
                } else {
                label_0512:
                    var temp33 = var11;
                    memory[var9 + temp33:var9 + temp33 + 0x20] = memory[var10 + temp33:var10 + temp33 + 0x20];
                    var11 = temp33 + 0x20;
                
                    if (var11 >= var8) { goto label_0524; }
                    else { goto label_0512; }
                }
            } else if (var0 == 0x9d799ff1) {
                // Dispatch table entry for findPercentage(uint256)
                var1 = 0x058b;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var1 = findPercentage(var2, var3);
                var temp34 = memory[0x40:0x60];
                memory[temp34:temp34 + 0x20] = var1;
                var temp35 = memory[0x40:0x60];
                return memory[temp35:temp35 + (temp34 + 0x20) - temp35];
            } else { revert(memory[0x00:0x00]); }
        } else if (var0 == 0xa9059cbb) {
            // Dispatch table entry for transfer(address,uint256)
            var1 = 0x05ed;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var1 = transfer(var2, var3);
            var temp36 = memory[0x40:0x60];
            memory[temp36:temp36 + 0x20] = !!var1;
            var temp37 = memory[0x40:0x60];
            return memory[temp37:temp37 + (temp36 + 0x20) - temp37];
        } else if (var0 == 0xb242e534) {
            // Dispatch table entry for transferOwnership(address,bool)
            var1 = 0x0655;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            transferOwnership(var2, var3);
            stop();
        } else if (var0 == 0xdd62ed3e) {
            // Dispatch table entry for allowance(address,address)
            var1 = 0x06b9;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var1 = allowance(var2, var3);
            var temp38 = memory[0x40:0x60];
            memory[temp38:temp38 + 0x20] = var1;
            var temp39 = memory[0x40:0x60];
            return memory[temp39:temp39 + (temp38 + 0x20) - temp39];
        } else if (var0 == 0xf01f20df) {
            // Dispatch table entry for burnPercentage()
            var1 = 0x06d7;
            var2 = burnPercentage();
            var temp40 = memory[0x40:0x60];
            memory[temp40:temp40 + 0x20] = var2;
            var temp41 = memory[0x40:0x60];
            return memory[temp41:temp41 + (temp40 + 0x20) - temp41];
        } else if (var0 == 0xff9913e8) {
            // Dispatch table entry for allow(address)
            var1 = 0x072f;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x20) { revert(memory[0x00:0x00]); }
        
            var2 = allow(var2, var3);
            var temp42 = memory[0x40:0x60];
            memory[temp42:temp42 + 0x20] = !!var2;
            var temp43 = memory[0x40:0x60];
            return memory[temp43:temp43 + (temp42 + 0x20) - temp43];
        } else { revert(memory[0x00:0x00]); }
    }
    
    function approve(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
        var temp1 = arg1;
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x09;
        var temp2 = keccak256(memory[0x00:0x40]);
        var temp3 = arg0;
        memory[0x00:0x20] = temp3 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = temp2;
        storage[keccak256(memory[0x00:0x40])] = temp1;
        var temp4 = memory[0x40:0x60];
        memory[temp4:temp4 + 0x20] = temp1;
        var temp5 = memory[0x40:0x60];
        log(memory[temp5:temp5 + (temp4 + 0x20) - temp5], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]);
        return 0x01;
    }
    
    function burnFrom(var arg0, var arg1) {
        var temp0 = arg0;
        var temp1 = temp0 + 0x20;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp1:temp1 + 0x20];
        var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20];
    
        if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff != msg.sender) {
            var temp8 = memory[0x40:0x60];
            memory[temp8:temp8 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp9 = temp8 + 0x04;
            var temp10 = temp9 + 0x20;
            memory[temp9:temp9 + 0x20] = temp10 - temp9;
            memory[temp10:temp10 + 0x20] = 0x20;
            var temp11 = temp10 + 0x20;
            memory[temp11:temp11 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp12 = memory[0x40:0x60];
            revert(memory[temp12:temp12 + (temp11 + 0x20) - temp12]);
        } else if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) {
            var var1 = 0x0a4e;
            var temp2 = memory[0x40:0x60];
            memory[0x40:0x60] = temp2 + 0x60;
            memory[temp2:temp2 + 0x20] = 0x22;
            memory[temp2 + 0x20:temp2 + 0x20 + 0x22] = code[0x19c0:0x19e2];
            var var2 = arg1;
            var var3 = var0;
            var var4 = temp2;
            var1 = func_1697(var2, var3, var4);
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x07;
            storage[keccak256(memory[0x00:0x40])] = var1;
            var1 = 0x0aa4;
            var2 = arg1;
            var3 = var0;
            var1 = func_1757(var2, var3);
            storage[0x04] = var1;
            return;
        } else {
            var temp3 = memory[0x40:0x60];
            memory[temp3:temp3 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp4 = temp3 + 0x04;
            var temp5 = temp4 + 0x20;
            memory[temp4:temp4 + 0x20] = temp5 - temp4;
            memory[temp5:temp5 + 0x20] = 0x2c;
            var temp6 = temp5 + 0x20;
            memory[temp6:temp6 + 0x2c] = code[0x19e2:0x1a0e];
            var temp7 = memory[0x40:0x60];
            revert(memory[temp7:temp7 + (temp6 + 0x40) - temp7]);
        }
    }
    
    function transferFrom(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        var temp1 = temp0 + 0x20;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp1:temp1 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20];
        var var1 = 0x00;
    
        if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff == var1 & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
    
        if (var0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
    
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x09;
        var temp2 = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = temp2;
    
        if (var0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
    
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x08;
    
        if (!!(storage[keccak256(memory[0x00:0x40])] & 0xff) != !!0x01) { revert(memory[0x00:0x00]); }
    
        var var2 = 0x0c74;
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        var var3 = storage[keccak256(memory[0x00:0x40])];
        var var4 = var0;
        var2 = func_1757(var3, var4);
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        storage[keccak256(memory[0x00:0x40])] = var2;
        var2 = 0x0d09;
        memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        var3 = storage[keccak256(memory[0x00:0x40])];
        var4 = var0;
        var2 = func_17A1(var3, var4);
        memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        storage[keccak256(memory[0x00:0x40])] = var2;
        var2 = 0x0ddb;
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x09;
        var temp3 = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = temp3;
        var3 = storage[keccak256(memory[0x00:0x40])];
        var4 = var0;
        var2 = func_1757(var3, var4);
        var temp4 = arg0;
        memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x09;
        var temp5 = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = temp5;
        storage[keccak256(memory[0x00:0x40])] = var2;
        var temp6 = memory[0x40:0x60];
        memory[temp6:temp6 + 0x20] = var0;
        var temp7 = memory[0x40:0x60];
        log(memory[temp7:temp7 + (temp6 + 0x20) - temp7], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]);
        return 0x01;
    }
    
    function balances(var arg0, var arg1) returns (var arg0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        memory[0x00:0x20] = arg0;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function allowed(var arg0, var arg1) returns (var arg0) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x09;
        memory[0x00:0x20] = arg0;
        memory[0x20:0x40] = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = arg1;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function changeBurnPercentage(var arg0, var arg1) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xff;
    
        if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) {
            storage[0x0a] = arg0 & 0xff;
            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] = 0x20;
            var temp3 = temp2 + 0x20;
            memory[temp3:temp3 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp4 = memory[0x40:0x60];
            revert(memory[temp4:temp4 + (temp3 + 0x20) - temp4]);
        }
    }
    
    function balanceOf(var arg0, var arg1) returns (var r0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function findPercentage(var arg0, var arg1) returns (var r0) {
        arg0 = msg.data[arg0:arg0 + 0x20];
        arg1 = 0x00;
        var var0 = arg1;
        var var1 = 0x12a2;
        var var2 = 0x64;
        var var3 = 0x1294;
        var var4 = arg0;
        var var5 = storage[0x0a];
        var3 = func_1829(var4, var5);
        return func_1294(var2, var3);
    }
    
    function transfer(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
        var var0 = 0x00;
    
        if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff == var0 & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x07;
    
        if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
    
        var var1 = 0x1386;
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x07;
        var var2 = storage[keccak256(memory[0x00:0x40])];
        var var3 = arg1;
        var1 = func_1757(var2, var3);
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x07;
        storage[keccak256(memory[0x00:0x40])] = var1;
        var1 = 0x141b;
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        var2 = storage[keccak256(memory[0x00:0x40])];
        var3 = arg1;
        var1 = func_17A1(var2, var3);
        var temp1 = arg0;
        memory[0x00:0x20] = temp1 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x07;
        storage[keccak256(memory[0x00:0x40])] = var1;
        var temp2 = memory[0x40:0x60];
        memory[temp2:temp2 + 0x20] = arg1;
        var temp3 = memory[0x40:0x60];
        log(memory[temp3:temp3 + (temp2 + 0x20) - temp3], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]);
        return 0x01;
    }
    
    function transferOwnership(var arg0, var arg1) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = !!msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
    
        if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) {
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x08;
            var temp1 = keccak256(memory[0x00:0x40]);
            storage[temp1] = !!arg1 | (storage[temp1] & ~0xff);
            return;
        } else {
            var temp2 = memory[0x40:0x60];
            memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp3 = temp2 + 0x04;
            var temp4 = temp3 + 0x20;
            memory[temp3:temp3 + 0x20] = temp4 - temp3;
            memory[temp4:temp4 + 0x20] = 0x20;
            var temp5 = temp4 + 0x20;
            memory[temp5:temp5 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp6 = memory[0x40:0x60];
            revert(memory[temp6:temp6 + (temp5 + 0x20) - temp6]);
        }
    }
    
    function allowance(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x09;
        var temp1 = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = temp1;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function allow(var arg0, var arg1) returns (var arg0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x08;
        memory[0x00:0x20] = arg0;
        return storage[keccak256(memory[0x00:0x40])] & 0xff;
    }
    
    function name() returns (var r0) {
        var temp0 = storage[0x01];
        var temp1 = (!(temp0 & 0x01) * 0x0100 - 0x01 & temp0) / 0x02;
        var temp2 = memory[0x40:0x60];
        memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20;
        r0 = temp2;
        var var1 = 0x01;
        var var2 = temp1;
        memory[r0:r0 + 0x20] = var2;
        var var3 = r0 + 0x20;
        var var4 = var1;
        var temp3 = storage[var4];
        var var5 = (!(temp3 & 0x01) * 0x0100 - 0x01 & temp3) / 0x02;
    
        if (!var5) {
        label_07DF:
            return r0;
        } else if (0x1f < var5) {
            var temp4 = var3;
            var temp5 = temp4 + var5;
            var3 = temp5;
            memory[0x00:0x20] = var4;
            var temp6 = keccak256(memory[0x00:0x20]);
            memory[temp4:temp4 + 0x20] = storage[temp6];
            var4 = temp6 + 0x01;
            var5 = temp4 + 0x20;
        
            if (var3 <= var5) { goto label_07D6; }
        
        label_07C2:
            var temp7 = var4;
            var temp8 = var5;
            memory[temp8:temp8 + 0x20] = storage[temp7];
            var4 = temp7 + 0x01;
            var5 = temp8 + 0x20;
        
            if (var3 > var5) { goto label_07C2; }
        
        label_07D6:
            var temp9 = var3;
            var temp10 = temp9 + (var5 - temp9 & 0x1f);
            var5 = temp9;
            var3 = temp10;
            goto label_07DF;
        } else {
            var temp11 = var3;
            memory[temp11:temp11 + 0x20] = storage[var4] / 0x0100 * 0x0100;
            var3 = temp11 + 0x20;
            var5 = var5;
            goto label_07DF;
        }
    }
    
    function totalSupply() returns (var r0) { return storage[0x04]; }
    
    function decimals() returns (var r0) { return storage[0x03] & 0xff; }
    
    function renounceOwnership() {
        if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) {
            var temp0 = memory[0x40:0x60];
            log(memory[temp0:temp0 + memory[0x40:0x60] - temp0], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]);
            storage[0x00] = (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff) | 0x00;
            return;
        } else {
            var temp1 = memory[0x40:0x60];
            memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp2 = temp1 + 0x04;
            var temp3 = temp2 + 0x20;
            memory[temp2:temp2 + 0x20] = temp3 - temp2;
            memory[temp3:temp3 + 0x20] = 0x20;
            var temp4 = temp3 + 0x20;
            memory[temp4:temp4 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572;
            var temp5 = memory[0x40:0x60];
            revert(memory[temp5:temp5 + (temp4 + 0x20) - temp5]);
        }
    }
    
    function owner() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; }
    
    function symbol() returns (var r0) {
        var temp0 = storage[0x02];
        var temp1 = (!(temp0 & 0x01) * 0x0100 - 0x01 & temp0) / 0x02;
        var temp2 = memory[0x40:0x60];
        memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20;
        r0 = temp2;
        var var1 = 0x02;
        var var2 = temp1;
        memory[r0:r0 + 0x20] = var2;
        var var3 = r0 + 0x20;
        var var4 = var1;
        var temp3 = storage[var4];
        var var5 = (!(temp3 & 0x01) * 0x0100 - 0x01 & temp3) / 0x02;
    
        if (!var5) {
        label_126F:
            return r0;
        } else if (0x1f < var5) {
            var temp4 = var3;
            var temp5 = temp4 + var5;
            var3 = temp5;
            memory[0x00:0x20] = var4;
            var temp6 = keccak256(memory[0x00:0x20]);
            memory[temp4:temp4 + 0x20] = storage[temp6];
            var4 = temp6 + 0x01;
            var5 = temp4 + 0x20;
        
            if (var3 <= var5) { goto label_1266; }
        
        label_1252:
            var temp7 = var4;
            var temp8 = var5;
            memory[temp8:temp8 + 0x20] = storage[temp7];
            var4 = temp7 + 0x01;
            var5 = temp8 + 0x20;
        
            if (var3 > var5) { goto label_1252; }
        
        label_1266:
            var temp9 = var3;
            var temp10 = temp9 + (var5 - temp9 & 0x1f);
            var5 = temp9;
            var3 = temp10;
            goto label_126F;
        } else {
            var temp11 = var3;
            memory[temp11:temp11 + 0x20] = storage[var4] / 0x0100 * 0x0100;
            var5 = var5;
            var3 = temp11 + 0x20;
            goto label_126F;
        }
    }
    
    function func_1294(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        arg0 = arg1;
        arg1 = temp0;
        var var0 = 0x00;
        var var1 = 0x18f1;
        var var2 = arg0;
        var var3 = arg1;
        var temp1 = memory[0x40:0x60];
        var var4 = temp1;
        memory[0x40:0x60] = var4 + 0x40;
        memory[var4:var4 + 0x20] = 0x1a;
        memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000;
        return func_18F9(var2, var3, var4);
    }
    
    function burnPercentage() returns (var r0) { return storage[0x0a]; }
    
    function func_1697(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = arg2;
    
        if (arg1 <= arg0) { return arg0 - arg1; }
    
        var temp0 = memory[0x40:0x60];
        memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
        var temp1 = temp0 + 0x04;
        var var2 = temp1;
        var var3 = var2;
        var temp2 = var3 + 0x20;
        memory[var3:var3 + 0x20] = temp2 - var3;
        var temp3 = var1;
        memory[temp2:temp2 + 0x20] = memory[temp3:temp3 + 0x20];
        var var4 = temp2 + 0x20;
        var var5 = temp3 + 0x20;
        var var6 = memory[temp3:temp3 + 0x20];
        var var7 = var6;
        var var8 = var4;
        var var9 = var5;
        var var10 = 0x00;
    
        if (var10 >= var7) {
        label_1709:
            var temp4 = var6;
            var4 = temp4 + var4;
            var5 = temp4 & 0x1f;
        
            if (!var5) {
                var temp5 = memory[0x40:0x60];
                revert(memory[temp5:temp5 + var4 - temp5]);
            } else {
                var temp6 = var5;
                var temp7 = var4 - temp6;
                memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
                var temp8 = memory[0x40:0x60];
                revert(memory[temp8:temp8 + (temp7 + 0x20) - temp8]);
            }
        } else {
        label_16F7:
            var temp9 = var10;
            memory[var8 + temp9:var8 + temp9 + 0x20] = memory[var9 + temp9:var9 + temp9 + 0x20];
            var10 = temp9 + 0x20;
        
            if (var10 >= var7) { goto label_1709; }
            else { goto label_16F7; }
        }
    }
    
    function func_1757(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x1799;
        var var2 = arg0;
        var var3 = arg1;
        var temp0 = memory[0x40:0x60];
        var var4 = temp0;
        memory[0x40:0x60] = var4 + 0x40;
        memory[var4:var4 + 0x20] = 0x1e;
        memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000;
        return func_1697(var2, var3, var4);
    }
    
    function func_17A1(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var temp0 = arg0;
        var var1 = temp0 + arg1;
    
        if (var1 >= temp0) { return var1; }
    
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
        var temp2 = temp1 + 0x04;
        var temp3 = temp2 + 0x20;
        memory[temp2:temp2 + 0x20] = temp3 - temp2;
        memory[temp3:temp3 + 0x20] = 0x1b;
        var temp4 = temp3 + 0x20;
        memory[temp4:temp4 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000;
        var temp5 = memory[0x40:0x60];
        revert(memory[temp5:temp5 + (temp4 + 0x20) - temp5]);
    }
    
    function func_1829(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 != var0) {
            var var1 = arg0 * arg1;
            var var2 = arg1;
            var var3 = arg0;
            var var4 = var1;
        
            if (!var3) { assert(); }
        
            if (var4 / var3 == var2) {
                var0 = var1;
            
            label_18A9:
                return var0;
            } 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] = 0x21;
                var temp3 = temp2 + 0x20;
                memory[temp3:temp3 + 0x21] = code[0x1a0e:0x1a2f];
                var temp4 = memory[0x40:0x60];
                revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]);
            }
        } else {
            var0 = 0x00;
            goto label_18A9;
        }
    }
    
    function func_18F9(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = arg2;
    
        if (arg1 > var0) {
            var1 = 0x00;
            var var2 = arg1;
            var var3 = arg0;
        
            if (var2) { return var3 / var2; }
            else { assert(); }
        } else {
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000;
            var temp1 = temp0 + 0x04;
            var2 = temp1;
            var3 = var2;
            var temp2 = var3 + 0x20;
            memory[var3:var3 + 0x20] = temp2 - var3;
            var temp3 = var1;
            memory[temp2:temp2 + 0x20] = memory[temp3:temp3 + 0x20];
            var var4 = temp2 + 0x20;
            var var5 = temp3 + 0x20;
            var var6 = memory[temp3:temp3 + 0x20];
            var var7 = var6;
            var var8 = var4;
            var var9 = var5;
            var var10 = 0x00;
        
            if (var10 >= var7) {
            label_196A:
                var temp4 = var6;
                var4 = temp4 + var4;
                var5 = temp4 & 0x1f;
            
                if (!var5) {
                    var temp5 = memory[0x40:0x60];
                    revert(memory[temp5:temp5 + var4 - temp5]);
                } else {
                    var temp6 = var5;
                    var temp7 = var4 - temp6;
                    memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
                    var temp8 = memory[0x40:0x60];
                    revert(memory[temp8:temp8 + (temp7 + 0x20) - temp8]);
                }
            } else {
            label_1958:
                var temp9 = var10;
                memory[var8 + temp9:var8 + temp9 + 0x20] = memory[var9 + temp9:var9 + temp9 + 0x20];
                var10 = temp9 + 0x20;
            
                if (var10 >= var7) { goto label_196A; }
                else { goto label_1958; }
            }
        }
    }
}

Disassembly

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

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

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

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

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

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

label_0041:
	// Incoming jump from 0x0040, if not 0xa9059cbb == stack[-1]
	// Inputs[1] { @0041  stack[-1] }
	0041    80  DUP1
	0042    63  PUSH4 0xb242e534
	0047    14  EQ
	0048    61  PUSH2 0x0607
	004B    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0607, if 0xb242e534 == stack[-1]

label_004C:
	// Incoming jump from 0x004B, if not 0xb242e534 == stack[-1]
	// Inputs[1] { @004C  stack[-1] }
	004C    80  DUP1
	004D    63  PUSH4 0xdd62ed3e
	0052    14  EQ
	0053    61  PUSH2 0x0657
	0056    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0657, if 0xdd62ed3e == stack[-1]

label_0057:
	// Incoming jump from 0x0056, if not 0xdd62ed3e == stack[-1]
	// Inputs[1] { @0057  stack[-1] }
	0057    80  DUP1
	0058    63  PUSH4 0xf01f20df
	005D    14  EQ
	005E    61  PUSH2 0x06cf
	0061    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x06cf, if 0xf01f20df == stack[-1]

label_0062:
	// Incoming jump from 0x0061, if not 0xf01f20df == stack[-1]
	// Inputs[1] { @0062  stack[-1] }
	0062    80  DUP1
	0063    63  PUSH4 0xff9913e8
	0068    14  EQ
	0069    61  PUSH2 0x06ed
	006C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x06ed, if 0xff9913e8 == stack[-1]

label_006D:
	// Incoming jump from 0x006C, if not 0xff9913e8 == stack[-1]
	006D    61  PUSH2 0x0121
	0070    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0121

label_0071:
	// Incoming jump from 0x0035, if 0xa9059cbb > stack[-1]
	// Inputs[1] { @0072  stack[-1] }
	0071    5B  JUMPDEST
	0072    80  DUP1
	0073    63  PUSH4 0x70a08231
	0078    14  EQ
	0079    61  PUSH2 0x0430
	007C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0430, if 0x70a08231 == stack[-1]

label_007D:
	// Incoming jump from 0x007C, if not 0x70a08231 == stack[-1]
	// Inputs[1] { @007D  stack[-1] }
	007D    80  DUP1
	007E    63  PUSH4 0x715018a6
	0083    14  EQ
	0084    61  PUSH2 0x0488
	0087    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0488, if 0x715018a6 == stack[-1]

label_0088:
	// Incoming jump from 0x0087, if not 0x715018a6 == stack[-1]
	// Inputs[1] { @0088  stack[-1] }
	0088    80  DUP1
	0089    63  PUSH4 0x8da5cb5b
	008E    14  EQ
	008F    61  PUSH2 0x0492
	0092    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0492, if 0x8da5cb5b == stack[-1]

label_0093:
	// Incoming jump from 0x0092, if not 0x8da5cb5b == stack[-1]
	// Inputs[1] { @0093  stack[-1] }
	0093    80  DUP1
	0094    63  PUSH4 0x95d89b41
	0099    14  EQ
	009A    61  PUSH2 0x04dc
	009D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x04dc, if 0x95d89b41 == stack[-1]

label_009E:
	// Incoming jump from 0x009D, if not 0x95d89b41 == stack[-1]
	// Inputs[1] { @009E  stack[-1] }
	009E    80  DUP1
	009F    63  PUSH4 0x9d799ff1
	00A4    14  EQ
	00A5    61  PUSH2 0x055f
	00A8    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x055f, if 0x9d799ff1 == stack[-1]

label_00A9:
	// Incoming jump from 0x00A8, if not 0x9d799ff1 == stack[-1]
	00A9    61  PUSH2 0x0121
	00AC    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0121

label_00AD:
	// Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @00AE  stack[-1] }
	00AD    5B  JUMPDEST
	00AE    80  DUP1
	00AF    63  PUSH4 0x23b872dd
	00B4    11  GT
	00B5    61  PUSH2 0x00f4
	00B8    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00f4, if 0x23b872dd > stack[-1]

label_00B9:
	// Incoming jump from 0x00B8, if not 0x23b872dd > stack[-1]
	// Inputs[1] { @00B9  stack[-1] }
	00B9    80  DUP1
	00BA    63  PUSH4 0x23b872dd
	00BF    14  EQ
	00C0    61  PUSH2 0x0285
	00C3    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0285, if 0x23b872dd == stack[-1]

label_00C4:
	// Incoming jump from 0x00C3, if not 0x23b872dd == stack[-1]
	// Inputs[1] { @00C4  stack[-1] }
	00C4    80  DUP1
	00C5    63  PUSH4 0x27e235e3
	00CA    14  EQ
	00CB    61  PUSH2 0x030b
	00CE    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x030b, if 0x27e235e3 == stack[-1]

label_00CF:
	// Incoming jump from 0x00CE, if not 0x27e235e3 == stack[-1]
	// Inputs[1] { @00CF  stack[-1] }
	00CF    80  DUP1
	00D0    63  PUSH4 0x313ce567
	00D5    14  EQ
	00D6    61  PUSH2 0x0363
	00D9    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0363, if 0x313ce567 == stack[-1]

label_00DA:
	// Incoming jump from 0x00D9, if not 0x313ce567 == stack[-1]
	// Inputs[1] { @00DA  stack[-1] }
	00DA    80  DUP1
	00DB    63  PUSH4 0x5c658165
	00E0    14  EQ
	00E1    61  PUSH2 0x0387
	00E4    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0387, if 0x5c658165 == stack[-1]

label_00E5:
	// Incoming jump from 0x00E4, if not 0x5c658165 == stack[-1]
	// Inputs[1] { @00E5  stack[-1] }
	00E5    80  DUP1
	00E6    63  PUSH4 0x66b627bd
	00EB    14  EQ
	00EC    61  PUSH2 0x03ff
	00EF    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x03ff, if 0x66b627bd == stack[-1]

label_00F0:
	// Incoming jump from 0x00EF, if not 0x66b627bd == stack[-1]
	00F0    61  PUSH2 0x0121
	00F3    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0121

label_00F4:
	// Incoming jump from 0x00B8, if 0x23b872dd > stack[-1]
	// Inputs[1] { @00F5  stack[-1] }
	00F4    5B  JUMPDEST
	00F5    80  DUP1
	00F6    63  PUSH4 0x06fdde03
	00FB    14  EQ
	00FC    61  PUSH2 0x0126
	00FF    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0126, if 0x06fdde03 == stack[-1]

label_0100:
	// Incoming jump from 0x00FF, if not 0x06fdde03 == stack[-1]
	// Inputs[1] { @0100  stack[-1] }
	0100    80  DUP1
	0101    63  PUSH4 0x095ea7b3
	0106    14  EQ
	0107    61  PUSH2 0x01a9
	010A    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01a9, if 0x095ea7b3 == stack[-1]

label_010B:
	// Incoming jump from 0x010A, if not 0x095ea7b3 == stack[-1]
	// Inputs[1] { @010B  stack[-1] }
	010B    80  DUP1
	010C    63  PUSH4 0x124d91e5
	0111    14  EQ
	0112    61  PUSH2 0x020f
	0115    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x020f, if 0x124d91e5 == stack[-1]

label_0116:
	// Incoming jump from 0x0115, if not 0x124d91e5 == stack[-1]
	// Inputs[1] { @0116  stack[-1] }
	0116    80  DUP1
	0117    63  PUSH4 0x18160ddd
	011C    14  EQ
	011D    61  PUSH2 0x0267
	0120    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0267, if 0x18160ddd == stack[-1]

label_0121:
	// Incoming jump from 0x00AC
	// Incoming jump from 0x00F3
	// Incoming jump from 0x0019, if msg.data.length < 0x04
	// Incoming jump from 0x0070
	// Incoming jump from 0x0120, if not 0x18160ddd == stack[-1]
	// Inputs[1] { @0125  memory[0x00:0x00] }
	0121    5B  JUMPDEST
	0122    60  PUSH1 0x00
	0124    80  DUP1
	0125    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0125  revert(memory[0x00:0x00]); }
	// Block terminates

label_0126:
	// Incoming jump from 0x00FF, if 0x06fdde03 == stack[-1]
	0126    5B  JUMPDEST
	0127    61  PUSH2 0x012e
	012A    61  PUSH2 0x0749
	012D    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0127  stack[0] = 0x012e }
	// Block ends with call to 0x0749, returns to 0x012E

label_012E:
	// Incoming return from call to 0x0749 at 0x012D
	// Inputs[4]
	// {
	//     @0131  memory[0x40:0x60]
	//     @013C  stack[-1]
	//     @013F  memory[stack[-1]:stack[-1] + 0x20]
	//     @0148  memory[stack[-1]:stack[-1] + 0x20]
	// }
	012E    5B  JUMPDEST
	012F    60  PUSH1 0x40
	0131    51  MLOAD
	0132    80  DUP1
	0133    80  DUP1
	0134    60  PUSH1 0x20
	0136    01  ADD
	0137    82  DUP3
	0138    81  DUP2
	0139    03  SUB
	013A    82  DUP3
	013B    52  MSTORE
	013C    83  DUP4
	013D    81  DUP2
	013E    81  DUP2
	013F    51  MLOAD
	0140    81  DUP2
	0141    52  MSTORE
	0142    60  PUSH1 0x20
	0144    01  ADD
	0145    91  SWAP2
	0146    50  POP
	0147    80  DUP1
	0148    51  MLOAD
	0149    90  SWAP1
	014A    60  PUSH1 0x20
	014C    01  ADD
	014D    90  SWAP1
	014E    80  DUP1
	014F    83  DUP4
	0150    83  DUP4
	0151    60  PUSH1 0x00
	0153    5B  JUMPDEST
	0154    83  DUP4
	0155    81  DUP2
	0156    10  LT
	0157    15  ISZERO
	0158    61  PUSH2 0x016e
	015B    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @0131  stack[0] = memory[0x40:0x60]
	//     @0132  stack[1] = memory[0x40:0x60]
	//     @013B  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0141  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0145  stack[2] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @014D  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @014D  stack[3] = 0x20 + stack[-1]
	//     @014E  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @014F  stack[6] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0150  stack[7] = 0x20 + stack[-1]
	//     @0151  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x016e, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_015C:
	// Incoming jump from 0x015B, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x015B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @015C  stack[-1]
	//     @015D  stack[-2]
	//     @015F  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0161  stack[-3]
	// }
	015C    80  DUP1
	015D    82  DUP3
	015E    01  ADD
	015F    51  MLOAD
	0160    81  DUP2
	0161    84  DUP5
	0162    01  ADD
	0163    52  MSTORE
	0164    60  PUSH1 0x20
	0166    81  DUP2
	0167    01  ADD
	0168    90  SWAP1
	0169    50  POP
	016A    61  PUSH2 0x0153
	016D    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0163  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0168  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x0153

label_016E:
	// Incoming jump from 0x015B, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x015B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @0173  stack[-6]
	//     @0173  stack[-5]
	//     @0175  stack[-7]
	// }
	016E    5B  JUMPDEST
	016F    50  POP
	0170    50  POP
	0171    50  POP
	0172    50  POP
	0173    90  SWAP1
	0174    50  POP
	0175    90  SWAP1
	0176    81  DUP2
	0177    01  ADD
	0178    90  SWAP1
	0179    60  PUSH1 0x1f
	017B    16  AND
	017C    80  DUP1
	017D    15  ISZERO
	017E    61  PUSH2 0x019b
	0181    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0178  stack[-7] = stack[-5] + stack[-7]
	//     @017B  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x019b, if !(0x1f & stack[-5])

label_0182:
	// Incoming jump from 0x0181, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @0182  stack[-1]
	//     @0183  stack[-2]
	//     @0186  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @019D  stack[-5]
	//     @01A3  memory[0x40:0x60]
	//     @01A8  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	0182    80  DUP1
	0183    82  DUP3
	0184    03  SUB
	0185    80  DUP1
	0186    51  MLOAD
	0187    60  PUSH1 0x01
	0189    83  DUP4
	018A    60  PUSH1 0x20
	018C    03  SUB
	018D    61  PUSH2 0x0100
	0190    0A  EXP
	0191    03  SUB
	0192    19  NOT
	0193    16  AND
	0194    81  DUP2
	0195    52  MSTORE
	0196    60  PUSH1 0x20
	0198    01  ADD
	0199    91  SWAP2
	019A    50  POP
	019B    5B  JUMPDEST
	019C    50  POP
	019D    92  SWAP3
	019E    50  POP
	019F    50  POP
	01A0    50  POP
	01A1    60  PUSH1 0x40
	01A3    51  MLOAD
	01A4    80  DUP1
	01A5    91  SWAP2
	01A6    03  SUB
	01A7    90  SWAP1
	01A8    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0195  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @01A8  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

label_01A9:
	// Incoming jump from 0x010A, if 0x095ea7b3 == stack[-1]
	// Inputs[1] { @01B0  msg.data.length }
	01A9    5B  JUMPDEST
	01AA    61  PUSH2 0x01f5
	01AD    60  PUSH1 0x04
	01AF    80  DUP1
	01B0    36  CALLDATASIZE
	01B1    03  SUB
	01B2    60  PUSH1 0x40
	01B4    81  DUP2
	01B5    10  LT
	01B6    15  ISZERO
	01B7    61  PUSH2 0x01bf
	01BA    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @01AA  stack[0] = 0x01f5
	//     @01AD  stack[1] = 0x04
	//     @01B1  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x01bf, returns to 0x01F5, if !(msg.data.length - 0x04 < 0x40)

label_01BB:
	// Incoming jump from 0x01BA, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @01BE  memory[0x00:0x00] }
	01BB    60  PUSH1 0x00
	01BD    80  DUP1
	01BE    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @01BE  revert(memory[0x00:0x00]); }
	// Block terminates

label_01BF:
	// Incoming call from 0x01BA, returns to 0x01F5, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @01C0  stack[-2]
	//     @01C1  stack[-1]
	//     @01C5  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01E5  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	01BF    5B  JUMPDEST
	01C0    81  DUP2
	01C1    01  ADD
	01C2    90  SWAP1
	01C3    80  DUP1
	01C4    80  DUP1
	01C5    35  CALLDATALOAD
	01C6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01DB    16  AND
	01DC    90  SWAP1
	01DD    60  PUSH1 0x20
	01DF    01  ADD
	01E0    90  SWAP1
	01E1    92  SWAP3
	01E2    91  SWAP2
	01E3    90  SWAP1
	01E4    80  DUP1
	01E5    35  CALLDATALOAD
	01E6    90  SWAP1
	01E7    60  PUSH1 0x20
	01E9    01  ADD
	01EA    90  SWAP1
	01EB    92  SWAP3
	01EC    91  SWAP2
	01ED    90  SWAP1
	01EE    50  POP
	01EF    50  POP
	01F0    50  POP
	01F1    61  PUSH2 0x07e7
	01F4    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @01E1  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01EB  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x07e7

label_01F5:
	// Incoming return from call to 0x01BF at 0x01BA
	// Inputs[4]
	// {
	//     @01F8  memory[0x40:0x60]
	//     @01FA  stack[-1]
	//     @0209  memory[0x40:0x60]
	//     @020E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	01F5    5B  JUMPDEST
	01F6    60  PUSH1 0x40
	01F8    51  MLOAD
	01F9    80  DUP1
	01FA    82  DUP3
	01FB    15  ISZERO
	01FC    15  ISZERO
	01FD    15  ISZERO
	01FE    15  ISZERO
	01FF    81  DUP2
	0200    52  MSTORE
	0201    60  PUSH1 0x20
	0203    01  ADD
	0204    91  SWAP2
	0205    50  POP
	0206    50  POP
	0207    60  PUSH1 0x40
	0209    51  MLOAD
	020A    80  DUP1
	020B    91  SWAP2
	020C    03  SUB
	020D    90  SWAP1
	020E    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0200  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @020E  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_020F:
	// Incoming jump from 0x0115, if 0x124d91e5 == stack[-1]
	// Inputs[1] { @0216  msg.data.length }
	020F    5B  JUMPDEST
	0210    61  PUSH2 0x0265
	0213    60  PUSH1 0x04
	0215    80  DUP1
	0216    36  CALLDATASIZE
	0217    03  SUB
	0218    60  PUSH1 0x60
	021A    81  DUP2
	021B    10  LT
	021C    15  ISZERO
	021D    61  PUSH2 0x0225
	0220    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0210  stack[0] = 0x0265
	//     @0213  stack[1] = 0x04
	//     @0217  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0225, returns to 0x0265, if !(msg.data.length - 0x04 < 0x60)

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

label_0225:
	// Incoming call from 0x0220, returns to 0x0265, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[5]
	// {
	//     @0226  stack[-2]
	//     @0227  stack[-1]
	//     @022B  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @024B  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @0255  msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	0225    5B  JUMPDEST
	0226    81  DUP2
	0227    01  ADD
	0228    90  SWAP1
	0229    80  DUP1
	022A    80  DUP1
	022B    35  CALLDATALOAD
	022C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0241    16  AND
	0242    90  SWAP1
	0243    60  PUSH1 0x20
	0245    01  ADD
	0246    90  SWAP1
	0247    92  SWAP3
	0248    91  SWAP2
	0249    90  SWAP1
	024A    80  DUP1
	024B    35  CALLDATALOAD
	024C    90  SWAP1
	024D    60  PUSH1 0x20
	024F    01  ADD
	0250    90  SWAP1
	0251    92  SWAP3
	0252    91  SWAP2
	0253    90  SWAP1
	0254    80  DUP1
	0255    35  CALLDATALOAD
	0256    90  SWAP1
	0257    60  PUSH1 0x20
	0259    01  ADD
	025A    90  SWAP1
	025B    92  SWAP3
	025C    91  SWAP2
	025D    90  SWAP1
	025E    50  POP
	025F    50  POP
	0260    50  POP
	0261    61  PUSH2 0x08d9
	0264    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0247  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0251  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @025B  stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x08d9

label_0265:
	// Incoming return from call to 0x0225 at 0x0220
	0265    5B  JUMPDEST
	0266    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0266  stop(); }
	// Block terminates

label_0267:
	// Incoming jump from 0x0120, if 0x18160ddd == stack[-1]
	0267    5B  JUMPDEST
	0268    61  PUSH2 0x026f
	026B    61  PUSH2 0x0aaf
	026E    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0268  stack[0] = 0x026f }
	// Block ends with call to 0x0aaf, returns to 0x026F

label_026F:
	// Incoming return from call to 0x0AAF at 0x026E
	// Inputs[4]
	// {
	//     @0272  memory[0x40:0x60]
	//     @0274  stack[-1]
	//     @027F  memory[0x40:0x60]
	//     @0284  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	026F    5B  JUMPDEST
	0270    60  PUSH1 0x40
	0272    51  MLOAD
	0273    80  DUP1
	0274    82  DUP3
	0275    81  DUP2
	0276    52  MSTORE
	0277    60  PUSH1 0x20
	0279    01  ADD
	027A    91  SWAP2
	027B    50  POP
	027C    50  POP
	027D    60  PUSH1 0x40
	027F    51  MLOAD
	0280    80  DUP1
	0281    91  SWAP2
	0282    03  SUB
	0283    90  SWAP1
	0284    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0276  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0284  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0285:
	// Incoming jump from 0x00C3, if 0x23b872dd == stack[-1]
	// Inputs[1] { @028C  msg.data.length }
	0285    5B  JUMPDEST
	0286    61  PUSH2 0x02f1
	0289    60  PUSH1 0x04
	028B    80  DUP1
	028C    36  CALLDATASIZE
	028D    03  SUB
	028E    60  PUSH1 0x60
	0290    81  DUP2
	0291    10  LT
	0292    15  ISZERO
	0293    61  PUSH2 0x029b
	0296    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0286  stack[0] = 0x02f1
	//     @0289  stack[1] = 0x04
	//     @028D  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x029b, returns to 0x02F1, if !(msg.data.length - 0x04 < 0x60)

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

label_029B:
	// Incoming call from 0x0296, returns to 0x02F1, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[5]
	// {
	//     @029C  stack[-2]
	//     @029D  stack[-1]
	//     @02A1  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @02C1  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @02E1  msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	029B    5B  JUMPDEST
	029C    81  DUP2
	029D    01  ADD
	029E    90  SWAP1
	029F    80  DUP1
	02A0    80  DUP1
	02A1    35  CALLDATALOAD
	02A2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02B7    16  AND
	02B8    90  SWAP1
	02B9    60  PUSH1 0x20
	02BB    01  ADD
	02BC    90  SWAP1
	02BD    92  SWAP3
	02BE    91  SWAP2
	02BF    90  SWAP1
	02C0    80  DUP1
	02C1    35  CALLDATALOAD
	02C2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02D7    16  AND
	02D8    90  SWAP1
	02D9    60  PUSH1 0x20
	02DB    01  ADD
	02DC    90  SWAP1
	02DD    92  SWAP3
	02DE    91  SWAP2
	02DF    90  SWAP1
	02E0    80  DUP1
	02E1    35  CALLDATALOAD
	02E2    90  SWAP1
	02E3    60  PUSH1 0x20
	02E5    01  ADD
	02E6    90  SWAP1
	02E7    92  SWAP3
	02E8    91  SWAP2
	02E9    90  SWAP1
	02EA    50  POP
	02EB    50  POP
	02EC    50  POP
	02ED    61  PUSH2 0x0ab5
	02F0    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @02BD  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @02DD  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @02E7  stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0ab5

label_02F1:
	// Incoming return from call to 0x029B at 0x0296
	// Inputs[4]
	// {
	//     @02F4  memory[0x40:0x60]
	//     @02F6  stack[-1]
	//     @0305  memory[0x40:0x60]
	//     @030A  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	02F1    5B  JUMPDEST
	02F2    60  PUSH1 0x40
	02F4    51  MLOAD
	02F5    80  DUP1
	02F6    82  DUP3
	02F7    15  ISZERO
	02F8    15  ISZERO
	02F9    15  ISZERO
	02FA    15  ISZERO
	02FB    81  DUP2
	02FC    52  MSTORE
	02FD    60  PUSH1 0x20
	02FF    01  ADD
	0300    91  SWAP2
	0301    50  POP
	0302    50  POP
	0303    60  PUSH1 0x40
	0305    51  MLOAD
	0306    80  DUP1
	0307    91  SWAP2
	0308    03  SUB
	0309    90  SWAP1
	030A    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @02FC  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @030A  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_030B:
	// Incoming jump from 0x00CE, if 0x27e235e3 == stack[-1]
	// Inputs[1] { @0312  msg.data.length }
	030B    5B  JUMPDEST
	030C    61  PUSH2 0x034d
	030F    60  PUSH1 0x04
	0311    80  DUP1
	0312    36  CALLDATASIZE
	0313    03  SUB
	0314    60  PUSH1 0x20
	0316    81  DUP2
	0317    10  LT
	0318    15  ISZERO
	0319    61  PUSH2 0x0321
	031C    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @030C  stack[0] = 0x034d
	//     @030F  stack[1] = 0x04
	//     @0313  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0321, returns to 0x034D, if !(msg.data.length - 0x04 < 0x20)

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

label_0321:
	// Incoming call from 0x031C, returns to 0x034D, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @0322  stack[-2]
	//     @0323  stack[-1]
	//     @0327  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0321    5B  JUMPDEST
	0322    81  DUP2
	0323    01  ADD
	0324    90  SWAP1
	0325    80  DUP1
	0326    80  DUP1
	0327    35  CALLDATALOAD
	0328    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	033D    16  AND
	033E    90  SWAP1
	033F    60  PUSH1 0x20
	0341    01  ADD
	0342    90  SWAP1
	0343    92  SWAP3
	0344    91  SWAP2
	0345    90  SWAP1
	0346    50  POP
	0347    50  POP
	0348    50  POP
	0349    61  PUSH2 0x0ecb
	034C    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0343  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x0ecb

label_034D:
	// Incoming return from call to 0x0321 at 0x031C
	// Inputs[4]
	// {
	//     @0350  memory[0x40:0x60]
	//     @0352  stack[-1]
	//     @035D  memory[0x40:0x60]
	//     @0362  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	034D    5B  JUMPDEST
	034E    60  PUSH1 0x40
	0350    51  MLOAD
	0351    80  DUP1
	0352    82  DUP3
	0353    81  DUP2
	0354    52  MSTORE
	0355    60  PUSH1 0x20
	0357    01  ADD
	0358    91  SWAP2
	0359    50  POP
	035A    50  POP
	035B    60  PUSH1 0x40
	035D    51  MLOAD
	035E    80  DUP1
	035F    91  SWAP2
	0360    03  SUB
	0361    90  SWAP1
	0362    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0354  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0362  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0363:
	// Incoming jump from 0x00D9, if 0x313ce567 == stack[-1]
	0363    5B  JUMPDEST
	0364    61  PUSH2 0x036b
	0367    61  PUSH2 0x0ee3
	036A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0364  stack[0] = 0x036b }
	// Block ends with call to 0x0ee3, returns to 0x036B

label_036B:
	// Incoming return from call to 0x0EE3 at 0x036A
	// Inputs[4]
	// {
	//     @036E  memory[0x40:0x60]
	//     @0370  stack[-1]
	//     @0381  memory[0x40:0x60]
	//     @0386  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	036B    5B  JUMPDEST
	036C    60  PUSH1 0x40
	036E    51  MLOAD
	036F    80  DUP1
	0370    82  DUP3
	0371    60  PUSH1 0xff
	0373    16  AND
	0374    60  PUSH1 0xff
	0376    16  AND
	0377    81  DUP2
	0378    52  MSTORE
	0379    60  PUSH1 0x20
	037B    01  ADD
	037C    91  SWAP2
	037D    50  POP
	037E    50  POP
	037F    60  PUSH1 0x40
	0381    51  MLOAD
	0382    80  DUP1
	0383    91  SWAP2
	0384    03  SUB
	0385    90  SWAP1
	0386    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0378  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1]
	//     @0386  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0387:
	// Incoming jump from 0x00E4, if 0x5c658165 == stack[-1]
	// Inputs[1] { @038E  msg.data.length }
	0387    5B  JUMPDEST
	0388    61  PUSH2 0x03e9
	038B    60  PUSH1 0x04
	038D    80  DUP1
	038E    36  CALLDATASIZE
	038F    03  SUB
	0390    60  PUSH1 0x40
	0392    81  DUP2
	0393    10  LT
	0394    15  ISZERO
	0395    61  PUSH2 0x039d
	0398    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0388  stack[0] = 0x03e9
	//     @038B  stack[1] = 0x04
	//     @038F  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x039d, returns to 0x03E9, if !(msg.data.length - 0x04 < 0x40)

label_0399:
	// Incoming jump from 0x0398, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @039C  memory[0x00:0x00] }
	0399    60  PUSH1 0x00
	039B    80  DUP1
	039C    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @039C  revert(memory[0x00:0x00]); }
	// Block terminates

label_039D:
	// Incoming call from 0x0398, returns to 0x03E9, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @039E  stack[-2]
	//     @039F  stack[-1]
	//     @03A3  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @03C3  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	039D    5B  JUMPDEST
	039E    81  DUP2
	039F    01  ADD
	03A0    90  SWAP1
	03A1    80  DUP1
	03A2    80  DUP1
	03A3    35  CALLDATALOAD
	03A4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03B9    16  AND
	03BA    90  SWAP1
	03BB    60  PUSH1 0x20
	03BD    01  ADD
	03BE    90  SWAP1
	03BF    92  SWAP3
	03C0    91  SWAP2
	03C1    90  SWAP1
	03C2    80  DUP1
	03C3    35  CALLDATALOAD
	03C4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03D9    16  AND
	03DA    90  SWAP1
	03DB    60  PUSH1 0x20
	03DD    01  ADD
	03DE    90  SWAP1
	03DF    92  SWAP3
	03E0    91  SWAP2
	03E1    90  SWAP1
	03E2    50  POP
	03E3    50  POP
	03E4    50  POP
	03E5    61  PUSH2 0x0ef6
	03E8    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @03BF  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @03DF  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0ef6

label_03E9:
	// Incoming return from call to 0x039D at 0x0398
	// Inputs[4]
	// {
	//     @03EC  memory[0x40:0x60]
	//     @03EE  stack[-1]
	//     @03F9  memory[0x40:0x60]
	//     @03FE  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	03E9    5B  JUMPDEST
	03EA    60  PUSH1 0x40
	03EC    51  MLOAD
	03ED    80  DUP1
	03EE    82  DUP3
	03EF    81  DUP2
	03F0    52  MSTORE
	03F1    60  PUSH1 0x20
	03F3    01  ADD
	03F4    91  SWAP2
	03F5    50  POP
	03F6    50  POP
	03F7    60  PUSH1 0x40
	03F9    51  MLOAD
	03FA    80  DUP1
	03FB    91  SWAP2
	03FC    03  SUB
	03FD    90  SWAP1
	03FE    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @03F0  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @03FE  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_03FF:
	// Incoming jump from 0x00EF, if 0x66b627bd == stack[-1]
	// Inputs[1] { @0406  msg.data.length }
	03FF    5B  JUMPDEST
	0400    61  PUSH2 0x042e
	0403    60  PUSH1 0x04
	0405    80  DUP1
	0406    36  CALLDATASIZE
	0407    03  SUB
	0408    60  PUSH1 0x20
	040A    81  DUP2
	040B    10  LT
	040C    15  ISZERO
	040D    61  PUSH2 0x0415
	0410    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0400  stack[0] = 0x042e
	//     @0403  stack[1] = 0x04
	//     @0407  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0415, returns to 0x042E, if !(msg.data.length - 0x04 < 0x20)

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

label_0415:
	// Incoming call from 0x0410, returns to 0x042E, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @0416  stack[-2]
	//     @0417  stack[-1]
	//     @041B  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0415    5B  JUMPDEST
	0416    81  DUP2
	0417    01  ADD
	0418    90  SWAP1
	0419    80  DUP1
	041A    80  DUP1
	041B    35  CALLDATALOAD
	041C    60  PUSH1 0xff
	041E    16  AND
	041F    90  SWAP1
	0420    60  PUSH1 0x20
	0422    01  ADD
	0423    90  SWAP1
	0424    92  SWAP3
	0425    91  SWAP2
	0426    90  SWAP1
	0427    50  POP
	0428    50  POP
	0429    50  POP
	042A    61  PUSH2 0x0f1b
	042D    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0424  stack[-2] = 0xff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x0f1b

label_042E:
	// Incoming return from call to 0x0415 at 0x0410
	042E    5B  JUMPDEST
	042F    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @042F  stop(); }
	// Block terminates

label_0430:
	// Incoming jump from 0x007C, if 0x70a08231 == stack[-1]
	// Inputs[1] { @0437  msg.data.length }
	0430    5B  JUMPDEST
	0431    61  PUSH2 0x0472
	0434    60  PUSH1 0x04
	0436    80  DUP1
	0437    36  CALLDATASIZE
	0438    03  SUB
	0439    60  PUSH1 0x20
	043B    81  DUP2
	043C    10  LT
	043D    15  ISZERO
	043E    61  PUSH2 0x0446
	0441    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0431  stack[0] = 0x0472
	//     @0434  stack[1] = 0x04
	//     @0438  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0446, returns to 0x0472, if !(msg.data.length - 0x04 < 0x20)

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

label_0446:
	// Incoming call from 0x0441, returns to 0x0472, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @0447  stack[-2]
	//     @0448  stack[-1]
	//     @044C  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0446    5B  JUMPDEST
	0447    81  DUP2
	0448    01  ADD
	0449    90  SWAP1
	044A    80  DUP1
	044B    80  DUP1
	044C    35  CALLDATALOAD
	044D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0462    16  AND
	0463    90  SWAP1
	0464    60  PUSH1 0x20
	0466    01  ADD
	0467    90  SWAP1
	0468    92  SWAP3
	0469    91  SWAP2
	046A    90  SWAP1
	046B    50  POP
	046C    50  POP
	046D    50  POP
	046E    61  PUSH2 0x0fea
	0471    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0468  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x0fea

label_0472:
	// Incoming return from call to 0x0446 at 0x0441
	// Inputs[4]
	// {
	//     @0475  memory[0x40:0x60]
	//     @0477  stack[-1]
	//     @0482  memory[0x40:0x60]
	//     @0487  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0472    5B  JUMPDEST
	0473    60  PUSH1 0x40
	0475    51  MLOAD
	0476    80  DUP1
	0477    82  DUP3
	0478    81  DUP2
	0479    52  MSTORE
	047A    60  PUSH1 0x20
	047C    01  ADD
	047D    91  SWAP2
	047E    50  POP
	047F    50  POP
	0480    60  PUSH1 0x40
	0482    51  MLOAD
	0483    80  DUP1
	0484    91  SWAP2
	0485    03  SUB
	0486    90  SWAP1
	0487    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0479  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0487  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0488:
	// Incoming jump from 0x0087, if 0x715018a6 == stack[-1]
	0488    5B  JUMPDEST
	0489    61  PUSH2 0x0490
	048C    61  PUSH2 0x1033
	048F    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0489  stack[0] = 0x0490 }
	// Block ends with call to 0x1033, returns to 0x0490

label_0490:
	// Incoming return from call to 0x1033 at 0x048F
	0490    5B  JUMPDEST
	0491    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0491  stop(); }
	// Block terminates

label_0492:
	// Incoming jump from 0x0092, if 0x8da5cb5b == stack[-1]
	0492    5B  JUMPDEST
	0493    61  PUSH2 0x049a
	0496    61  PUSH2 0x11b4
	0499    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0493  stack[0] = 0x049a }
	// Block ends with call to 0x11b4, returns to 0x049A

label_049A:
	// Incoming return from call to 0x11B4 at 0x0499
	// Inputs[4]
	// {
	//     @049D  memory[0x40:0x60]
	//     @049F  stack[-1]
	//     @04D6  memory[0x40:0x60]
	//     @04DB  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	049A    5B  JUMPDEST
	049B    60  PUSH1 0x40
	049D    51  MLOAD
	049E    80  DUP1
	049F    82  DUP3
	04A0    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04B5    16  AND
	04B6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04CB    16  AND
	04CC    81  DUP2
	04CD    52  MSTORE
	04CE    60  PUSH1 0x20
	04D0    01  ADD
	04D1    91  SWAP2
	04D2    50  POP
	04D3    50  POP
	04D4    60  PUSH1 0x40
	04D6    51  MLOAD
	04D7    80  DUP1
	04D8    91  SWAP2
	04D9    03  SUB
	04DA    90  SWAP1
	04DB    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @04CD  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @04DB  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_04DC:
	// Incoming jump from 0x009D, if 0x95d89b41 == stack[-1]
	04DC    5B  JUMPDEST
	04DD    61  PUSH2 0x04e4
	04E0    61  PUSH2 0x11d9
	04E3    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @04DD  stack[0] = 0x04e4 }
	// Block ends with call to 0x11d9, returns to 0x04E4

label_04E4:
	// Incoming return from call to 0x11D9 at 0x04E3
	// Inputs[4]
	// {
	//     @04E7  memory[0x40:0x60]
	//     @04F2  stack[-1]
	//     @04F5  memory[stack[-1]:stack[-1] + 0x20]
	//     @04FE  memory[stack[-1]:stack[-1] + 0x20]
	// }
	04E4    5B  JUMPDEST
	04E5    60  PUSH1 0x40
	04E7    51  MLOAD
	04E8    80  DUP1
	04E9    80  DUP1
	04EA    60  PUSH1 0x20
	04EC    01  ADD
	04ED    82  DUP3
	04EE    81  DUP2
	04EF    03  SUB
	04F0    82  DUP3
	04F1    52  MSTORE
	04F2    83  DUP4
	04F3    81  DUP2
	04F4    81  DUP2
	04F5    51  MLOAD
	04F6    81  DUP2
	04F7    52  MSTORE
	04F8    60  PUSH1 0x20
	04FA    01  ADD
	04FB    91  SWAP2
	04FC    50  POP
	04FD    80  DUP1
	04FE    51  MLOAD
	04FF    90  SWAP1
	0500    60  PUSH1 0x20
	0502    01  ADD
	0503    90  SWAP1
	0504    80  DUP1
	0505    83  DUP4
	0506    83  DUP4
	0507    60  PUSH1 0x00
	0509    5B  JUMPDEST
	050A    83  DUP4
	050B    81  DUP2
	050C    10  LT
	050D    15  ISZERO
	050E    61  PUSH2 0x0524
	0511    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @04E7  stack[0] = memory[0x40:0x60]
	//     @04E8  stack[1] = memory[0x40:0x60]
	//     @04F1  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @04F7  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @04FB  stack[2] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0503  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0503  stack[3] = 0x20 + stack[-1]
	//     @0504  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0505  stack[6] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0506  stack[7] = 0x20 + stack[-1]
	//     @0507  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x0524, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0512:
	// Incoming jump from 0x0511, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0511, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @0512  stack[-1]
	//     @0513  stack[-2]
	//     @0515  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0517  stack[-3]
	// }
	0512    80  DUP1
	0513    82  DUP3
	0514    01  ADD
	0515    51  MLOAD
	0516    81  DUP2
	0517    84  DUP5
	0518    01  ADD
	0519    52  MSTORE
	051A    60  PUSH1 0x20
	051C    81  DUP2
	051D    01  ADD
	051E    90  SWAP1
	051F    50  POP
	0520    61  PUSH2 0x0509
	0523    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0519  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @051E  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x0509

label_0524:
	// Incoming jump from 0x0511, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0511, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @0529  stack[-5]
	//     @0529  stack[-6]
	//     @052B  stack[-7]
	// }
	0524    5B  JUMPDEST
	0525    50  POP
	0526    50  POP
	0527    50  POP
	0528    50  POP
	0529    90  SWAP1
	052A    50  POP
	052B    90  SWAP1
	052C    81  DUP2
	052D    01  ADD
	052E    90  SWAP1
	052F    60  PUSH1 0x1f
	0531    16  AND
	0532    80  DUP1
	0533    15  ISZERO
	0534    61  PUSH2 0x0551
	0537    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @052E  stack[-7] = stack[-5] + stack[-7]
	//     @0531  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0551, if !(0x1f & stack[-5])

label_0538:
	// Incoming jump from 0x0537, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @0538  stack[-1]
	//     @0539  stack[-2]
	//     @053C  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0553  stack[-5]
	//     @0559  memory[0x40:0x60]
	//     @055E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	0538    80  DUP1
	0539    82  DUP3
	053A    03  SUB
	053B    80  DUP1
	053C    51  MLOAD
	053D    60  PUSH1 0x01
	053F    83  DUP4
	0540    60  PUSH1 0x20
	0542    03  SUB
	0543    61  PUSH2 0x0100
	0546    0A  EXP
	0547    03  SUB
	0548    19  NOT
	0549    16  AND
	054A    81  DUP2
	054B    52  MSTORE
	054C    60  PUSH1 0x20
	054E    01  ADD
	054F    91  SWAP2
	0550    50  POP
	0551    5B  JUMPDEST
	0552    50  POP
	0553    92  SWAP3
	0554    50  POP
	0555    50  POP
	0556    50  POP
	0557    60  PUSH1 0x40
	0559    51  MLOAD
	055A    80  DUP1
	055B    91  SWAP2
	055C    03  SUB
	055D    90  SWAP1
	055E    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @054B  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @055E  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

label_055F:
	// Incoming jump from 0x00A8, if 0x9d799ff1 == stack[-1]
	// Inputs[1] { @0566  msg.data.length }
	055F    5B  JUMPDEST
	0560    61  PUSH2 0x058b
	0563    60  PUSH1 0x04
	0565    80  DUP1
	0566    36  CALLDATASIZE
	0567    03  SUB
	0568    60  PUSH1 0x20
	056A    81  DUP2
	056B    10  LT
	056C    15  ISZERO
	056D    61  PUSH2 0x0575
	0570    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0560  stack[0] = 0x058b
	//     @0563  stack[1] = 0x04
	//     @0567  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0575, returns to 0x058B, if !(msg.data.length - 0x04 < 0x20)

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

label_0575:
	// Incoming call from 0x0570, returns to 0x058B, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @0576  stack[-2]
	//     @0577  stack[-1]
	//     @057B  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0575    5B  JUMPDEST
	0576    81  DUP2
	0577    01  ADD
	0578    90  SWAP1
	0579    80  DUP1
	057A    80  DUP1
	057B    35  CALLDATALOAD
	057C    90  SWAP1
	057D    60  PUSH1 0x20
	057F    01  ADD
	0580    90  SWAP1
	0581    92  SWAP3
	0582    91  SWAP2
	0583    90  SWAP1
	0584    50  POP
	0585    50  POP
	0586    50  POP
	0587    61  PUSH2 0x1277
	058A    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0581  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x1277

label_058B:
	// Incoming return from call to 0x0575 at 0x0570
	// Inputs[4]
	// {
	//     @058E  memory[0x40:0x60]
	//     @0590  stack[-1]
	//     @059B  memory[0x40:0x60]
	//     @05A0  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	058B    5B  JUMPDEST
	058C    60  PUSH1 0x40
	058E    51  MLOAD
	058F    80  DUP1
	0590    82  DUP3
	0591    81  DUP2
	0592    52  MSTORE
	0593    60  PUSH1 0x20
	0595    01  ADD
	0596    91  SWAP2
	0597    50  POP
	0598    50  POP
	0599    60  PUSH1 0x40
	059B    51  MLOAD
	059C    80  DUP1
	059D    91  SWAP2
	059E    03  SUB
	059F    90  SWAP1
	05A0    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0592  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @05A0  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_05A1:
	// Incoming jump from 0x0040, if 0xa9059cbb == stack[-1]
	// Inputs[1] { @05A8  msg.data.length }
	05A1    5B  JUMPDEST
	05A2    61  PUSH2 0x05ed
	05A5    60  PUSH1 0x04
	05A7    80  DUP1
	05A8    36  CALLDATASIZE
	05A9    03  SUB
	05AA    60  PUSH1 0x40
	05AC    81  DUP2
	05AD    10  LT
	05AE    15  ISZERO
	05AF    61  PUSH2 0x05b7
	05B2    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @05A2  stack[0] = 0x05ed
	//     @05A5  stack[1] = 0x04
	//     @05A9  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x05b7, returns to 0x05ED, if !(msg.data.length - 0x04 < 0x40)

label_05B3:
	// Incoming jump from 0x05B2, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @05B6  memory[0x00:0x00] }
	05B3    60  PUSH1 0x00
	05B5    80  DUP1
	05B6    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @05B6  revert(memory[0x00:0x00]); }
	// Block terminates

label_05B7:
	// Incoming call from 0x05B2, returns to 0x05ED, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @05B8  stack[-2]
	//     @05B9  stack[-1]
	//     @05BD  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @05DD  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	05B7    5B  JUMPDEST
	05B8    81  DUP2
	05B9    01  ADD
	05BA    90  SWAP1
	05BB    80  DUP1
	05BC    80  DUP1
	05BD    35  CALLDATALOAD
	05BE    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	05D3    16  AND
	05D4    90  SWAP1
	05D5    60  PUSH1 0x20
	05D7    01  ADD
	05D8    90  SWAP1
	05D9    92  SWAP3
	05DA    91  SWAP2
	05DB    90  SWAP1
	05DC    80  DUP1
	05DD    35  CALLDATALOAD
	05DE    90  SWAP1
	05DF    60  PUSH1 0x20
	05E1    01  ADD
	05E2    90  SWAP1
	05E3    92  SWAP3
	05E4    91  SWAP2
	05E5    90  SWAP1
	05E6    50  POP
	05E7    50  POP
	05E8    50  POP
	05E9    61  PUSH2 0x12ad
	05EC    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @05D9  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @05E3  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x12ad

label_05ED:
	// Incoming return from call to 0x05B7 at 0x05B2
	// Inputs[4]
	// {
	//     @05F0  memory[0x40:0x60]
	//     @05F2  stack[-1]
	//     @0601  memory[0x40:0x60]
	//     @0606  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	05ED    5B  JUMPDEST
	05EE    60  PUSH1 0x40
	05F0    51  MLOAD
	05F1    80  DUP1
	05F2    82  DUP3
	05F3    15  ISZERO
	05F4    15  ISZERO
	05F5    15  ISZERO
	05F6    15  ISZERO
	05F7    81  DUP2
	05F8    52  MSTORE
	05F9    60  PUSH1 0x20
	05FB    01  ADD
	05FC    91  SWAP2
	05FD    50  POP
	05FE    50  POP
	05FF    60  PUSH1 0x40
	0601    51  MLOAD
	0602    80  DUP1
	0603    91  SWAP2
	0604    03  SUB
	0605    90  SWAP1
	0606    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @05F8  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @0606  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0607:
	// Incoming jump from 0x004B, if 0xb242e534 == stack[-1]
	// Inputs[1] { @060E  msg.data.length }
	0607    5B  JUMPDEST
	0608    61  PUSH2 0x0655
	060B    60  PUSH1 0x04
	060D    80  DUP1
	060E    36  CALLDATASIZE
	060F    03  SUB
	0610    60  PUSH1 0x40
	0612    81  DUP2
	0613    10  LT
	0614    15  ISZERO
	0615    61  PUSH2 0x061d
	0618    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0608  stack[0] = 0x0655
	//     @060B  stack[1] = 0x04
	//     @060F  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x061d, returns to 0x0655, if !(msg.data.length - 0x04 < 0x40)

label_0619:
	// Incoming jump from 0x0618, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @061C  memory[0x00:0x00] }
	0619    60  PUSH1 0x00
	061B    80  DUP1
	061C    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @061C  revert(memory[0x00:0x00]); }
	// Block terminates

label_061D:
	// Incoming call from 0x0618, returns to 0x0655, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @061E  stack[-2]
	//     @061F  stack[-1]
	//     @0623  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0643  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	061D    5B  JUMPDEST
	061E    81  DUP2
	061F    01  ADD
	0620    90  SWAP1
	0621    80  DUP1
	0622    80  DUP1
	0623    35  CALLDATALOAD
	0624    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0639    16  AND
	063A    90  SWAP1
	063B    60  PUSH1 0x20
	063D    01  ADD
	063E    90  SWAP1
	063F    92  SWAP3
	0640    91  SWAP2
	0641    90  SWAP1
	0642    80  DUP1
	0643    35  CALLDATALOAD
	0644    15  ISZERO
	0645    15  ISZERO
	0646    90  SWAP1
	0647    60  PUSH1 0x20
	0649    01  ADD
	064A    90  SWAP1
	064B    92  SWAP3
	064C    91  SWAP2
	064D    90  SWAP1
	064E    50  POP
	064F    50  POP
	0650    50  POP
	0651    61  PUSH2 0x14cd
	0654    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @063F  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @064B  stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x14cd

label_0655:
	// Incoming return from call to 0x061D at 0x0618
	0655    5B  JUMPDEST
	0656    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0656  stop(); }
	// Block terminates

label_0657:
	// Incoming jump from 0x0056, if 0xdd62ed3e == stack[-1]
	// Inputs[1] { @065E  msg.data.length }
	0657    5B  JUMPDEST
	0658    61  PUSH2 0x06b9
	065B    60  PUSH1 0x04
	065D    80  DUP1
	065E    36  CALLDATASIZE
	065F    03  SUB
	0660    60  PUSH1 0x40
	0662    81  DUP2
	0663    10  LT
	0664    15  ISZERO
	0665    61  PUSH2 0x066d
	0668    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0658  stack[0] = 0x06b9
	//     @065B  stack[1] = 0x04
	//     @065F  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x066d, returns to 0x06B9, if !(msg.data.length - 0x04 < 0x40)

label_0669:
	// Incoming jump from 0x0668, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @066C  memory[0x00:0x00] }
	0669    60  PUSH1 0x00
	066B    80  DUP1
	066C    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @066C  revert(memory[0x00:0x00]); }
	// Block terminates

label_066D:
	// Incoming call from 0x0668, returns to 0x06B9, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @066E  stack[-2]
	//     @066F  stack[-1]
	//     @0673  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0693  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	066D    5B  JUMPDEST
	066E    81  DUP2
	066F    01  ADD
	0670    90  SWAP1
	0671    80  DUP1
	0672    80  DUP1
	0673    35  CALLDATALOAD
	0674    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0689    16  AND
	068A    90  SWAP1
	068B    60  PUSH1 0x20
	068D    01  ADD
	068E    90  SWAP1
	068F    92  SWAP3
	0690    91  SWAP2
	0691    90  SWAP1
	0692    80  DUP1
	0693    35  CALLDATALOAD
	0694    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	06A9    16  AND
	06AA    90  SWAP1
	06AB    60  PUSH1 0x20
	06AD    01  ADD
	06AE    90  SWAP1
	06AF    92  SWAP3
	06B0    91  SWAP2
	06B1    90  SWAP1
	06B2    50  POP
	06B3    50  POP
	06B4    50  POP
	06B5    61  PUSH2 0x15ea
	06B8    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @068F  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @06AF  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x15ea

label_06B9:
	// Incoming return from call to 0x066D at 0x0668
	// Inputs[4]
	// {
	//     @06BC  memory[0x40:0x60]
	//     @06BE  stack[-1]
	//     @06C9  memory[0x40:0x60]
	//     @06CE  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	06B9    5B  JUMPDEST
	06BA    60  PUSH1 0x40
	06BC    51  MLOAD
	06BD    80  DUP1
	06BE    82  DUP3
	06BF    81  DUP2
	06C0    52  MSTORE
	06C1    60  PUSH1 0x20
	06C3    01  ADD
	06C4    91  SWAP2
	06C5    50  POP
	06C6    50  POP
	06C7    60  PUSH1 0x40
	06C9    51  MLOAD
	06CA    80  DUP1
	06CB    91  SWAP2
	06CC    03  SUB
	06CD    90  SWAP1
	06CE    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @06C0  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @06CE  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_06CF:
	// Incoming jump from 0x0061, if 0xf01f20df == stack[-1]
	06CF    5B  JUMPDEST
	06D0    61  PUSH2 0x06d7
	06D3    61  PUSH2 0x1671
	06D6    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @06D0  stack[0] = 0x06d7 }
	// Block ends with call to 0x1671, returns to 0x06D7

label_06D7:
	// Incoming return from call to 0x1671 at 0x06D6
	// Inputs[4]
	// {
	//     @06DA  memory[0x40:0x60]
	//     @06DC  stack[-1]
	//     @06E7  memory[0x40:0x60]
	//     @06EC  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	06D7    5B  JUMPDEST
	06D8    60  PUSH1 0x40
	06DA    51  MLOAD
	06DB    80  DUP1
	06DC    82  DUP3
	06DD    81  DUP2
	06DE    52  MSTORE
	06DF    60  PUSH1 0x20
	06E1    01  ADD
	06E2    91  SWAP2
	06E3    50  POP
	06E4    50  POP
	06E5    60  PUSH1 0x40
	06E7    51  MLOAD
	06E8    80  DUP1
	06E9    91  SWAP2
	06EA    03  SUB
	06EB    90  SWAP1
	06EC    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @06DE  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @06EC  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_06ED:
	// Incoming jump from 0x006C, if 0xff9913e8 == stack[-1]
	// Inputs[1] { @06F4  msg.data.length }
	06ED    5B  JUMPDEST
	06EE    61  PUSH2 0x072f
	06F1    60  PUSH1 0x04
	06F3    80  DUP1
	06F4    36  CALLDATASIZE
	06F5    03  SUB
	06F6    60  PUSH1 0x20
	06F8    81  DUP2
	06F9    10  LT
	06FA    15  ISZERO
	06FB    61  PUSH2 0x0703
	06FE    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @06EE  stack[0] = 0x072f
	//     @06F1  stack[1] = 0x04
	//     @06F5  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0703, returns to 0x072F, if !(msg.data.length - 0x04 < 0x20)

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

label_0703:
	// Incoming call from 0x06FE, returns to 0x072F, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @0704  stack[-2]
	//     @0705  stack[-1]
	//     @0709  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0703    5B  JUMPDEST
	0704    81  DUP2
	0705    01  ADD
	0706    90  SWAP1
	0707    80  DUP1
	0708    80  DUP1
	0709    35  CALLDATALOAD
	070A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	071F    16  AND
	0720    90  SWAP1
	0721    60  PUSH1 0x20
	0723    01  ADD
	0724    90  SWAP1
	0725    92  SWAP3
	0726    91  SWAP2
	0727    90  SWAP1
	0728    50  POP
	0729    50  POP
	072A    50  POP
	072B    61  PUSH2 0x1677
	072E    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0725  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x1677

label_072F:
	// Incoming return from call to 0x0703 at 0x06FE
	// Inputs[4]
	// {
	//     @0732  memory[0x40:0x60]
	//     @0734  stack[-1]
	//     @0743  memory[0x40:0x60]
	//     @0748  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	072F    5B  JUMPDEST
	0730    60  PUSH1 0x40
	0732    51  MLOAD
	0733    80  DUP1
	0734    82  DUP3
	0735    15  ISZERO
	0736    15  ISZERO
	0737    15  ISZERO
	0738    15  ISZERO
	0739    81  DUP2
	073A    52  MSTORE
	073B    60  PUSH1 0x20
	073D    01  ADD
	073E    91  SWAP2
	073F    50  POP
	0740    50  POP
	0741    60  PUSH1 0x40
	0743    51  MLOAD
	0744    80  DUP1
	0745    91  SWAP2
	0746    03  SUB
	0747    90  SWAP1
	0748    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @073A  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @0748  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0749:
	// Incoming call from 0x012D, returns to 0x012E
	// Inputs[3]
	// {
	//     @074D  storage[0x01]
	//     @076E  memory[0x40:0x60]
	//     @0781  storage[0x01]
	// }
	0749    5B  JUMPDEST
	074A    60  PUSH1 0x01
	074C    80  DUP1
	074D    54  SLOAD
	074E    60  PUSH1 0x01
	0750    81  DUP2
	0751    60  PUSH1 0x01
	0753    16  AND
	0754    15  ISZERO
	0755    61  PUSH2 0x0100
	0758    02  MUL
	0759    03  SUB
	075A    16  AND
	075B    60  PUSH1 0x02
	075D    90  SWAP1
	075E    04  DIV
	075F    80  DUP1
	0760    60  PUSH1 0x1f
	0762    01  ADD
	0763    60  PUSH1 0x20
	0765    80  DUP1
	0766    91  SWAP2
	0767    04  DIV
	0768    02  MUL
	0769    60  PUSH1 0x20
	076B    01  ADD
	076C    60  PUSH1 0x40
	076E    51  MLOAD
	076F    90  SWAP1
	0770    81  DUP2
	0771    01  ADD
	0772    60  PUSH1 0x40
	0774    52  MSTORE
	0775    80  DUP1
	0776    92  SWAP3
	0777    91  SWAP2
	0778    90  SWAP1
	0779    81  DUP2
	077A    81  DUP2
	077B    52  MSTORE
	077C    60  PUSH1 0x20
	077E    01  ADD
	077F    82  DUP3
	0780    80  DUP1
	0781    54  SLOAD
	0782    60  PUSH1 0x01
	0784    81  DUP2
	0785    60  PUSH1 0x01
	0787    16  AND
	0788    15  ISZERO
	0789    61  PUSH2 0x0100
	078C    02  MUL
	078D    03  SUB
	078E    16  AND
	078F    60  PUSH1 0x02
	0791    90  SWAP1
	0792    04  DIV
	0793    80  DUP1
	0794    15  ISZERO
	0795    61  PUSH2 0x07df
	0798    57  *JUMPI
	// Stack delta = +6
	// Outputs[8]
	// {
	//     @0774  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20
	//     @0776  stack[0] = memory[0x40:0x60]
	//     @0777  stack[1] = 0x01
	//     @0778  stack[2] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02
	//     @077B  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02
	//     @077E  stack[3] = 0x20 + memory[0x40:0x60]
	//     @077F  stack[4] = 0x01
	//     @0792  stack[5] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02
	// }
	// Block ends with conditional jump to 0x07df, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02)

label_0799:
	// Incoming jump from 0x0798, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02)
	// Inputs[1] { @0799  stack[-1] }
	0799    80  DUP1
	079A    60  PUSH1 0x1f
	079C    10  LT
	079D    61  PUSH2 0x07b4
	07A0    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x07b4, if 0x1f < stack[-1]

label_07A1:
	// Incoming jump from 0x07A0, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @07A5  stack[-2]
	//     @07A6  storage[stack[-2]]
	//     @07A9  stack[-3]
	//     @07AB  stack[-1]
	// }
	07A1    61  PUSH2 0x0100
	07A4    80  DUP1
	07A5    83  DUP4
	07A6    54  SLOAD
	07A7    04  DIV
	07A8    02  MUL
	07A9    83  DUP4
	07AA    52  MSTORE
	07AB    91  SWAP2
	07AC    60  PUSH1 0x20
	07AE    01  ADD
	07AF    91  SWAP2
	07B0    61  PUSH2 0x07df
	07B3    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @07AA  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @07AF  stack[-1] = stack[-1]
	//     @07AF  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x07df

label_07B4:
	// Incoming jump from 0x07A0, if 0x1f < stack[-1]
	// Inputs[5]
	// {
	//     @07B5  stack[-3]
	//     @07B6  stack[-1]
	//     @07B8  stack[-2]
	//     @07C0  memory[0x00:0x20]
	//     @07C4  storage[keccak256(memory[0x00:0x20])]
	// }
	07B4    5B  JUMPDEST
	07B5    82  DUP3
	07B6    01  ADD
	07B7    91  SWAP2
	07B8    90  SWAP1
	07B9    60  PUSH1 0x00
	07BB    52  MSTORE
	07BC    60  PUSH1 0x20
	07BE    60  PUSH1 0x00
	07C0    20  SHA3
	07C1    90  SWAP1
	07C2    5B  JUMPDEST
	07C3    81  DUP2
	07C4    54  SLOAD
	07C5    81  DUP2
	07C6    52  MSTORE
	07C7    90  SWAP1
	07C8    60  PUSH1 0x01
	07CA    01  ADD
	07CB    90  SWAP1
	07CC    60  PUSH1 0x20
	07CE    01  ADD
	07CF    80  DUP1
	07D0    83  DUP4
	07D1    11  GT
	07D2    61  PUSH2 0x07c2
	07D5    57  *JUMPI
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @07B7  stack[-3] = stack[-3] + stack[-1]
	//     @07BB  memory[0x00:0x20] = stack[-2]
	//     @07C6  memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])]
	//     @07CB  stack[-2] = 0x01 + keccak256(memory[0x00:0x20])
	//     @07CE  stack[-1] = 0x20 + stack[-3]
	// }
	// Block ends with conditional jump to 0x07c2, if stack[-3] + stack[-1] > 0x20 + stack[-3]

label_07D6:
	// Incoming jump from 0x07D5, if not stack[-3] + stack[-1] > 0x20 + stack[-3]
	// Incoming jump from 0x07D5, if not stack[-3] > 0x20 + stack[-1]
	// Inputs[2]
	// {
	//     @07D6  stack[-3]
	//     @07D7  stack[-1]
	// }
	07D6    82  DUP3
	07D7    90  SWAP1
	07D8    03  SUB
	07D9    60  PUSH1 0x1f
	07DB    16  AND
	07DC    82  DUP3
	07DD    01  ADD
	07DE    91  SWAP2
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @07DE  stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3])
	//     @07DE  stack[-1] = stack[-3]
	// }
	// Block continues

label_07DF:
	// Incoming jump from 0x07DE
	// Incoming jump from 0x07B3
	// Incoming jump from 0x0798, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02)
	// Inputs[1] { @07E5  stack[-7] }
	07DF    5B  JUMPDEST
	07E0    50  POP
	07E1    50  POP
	07E2    50  POP
	07E3    50  POP
	07E4    50  POP
	07E5    81  DUP2
	07E6    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-7]

label_07E7:
	// Incoming jump from 0x01F4
	// Inputs[10]
	// {
	//     @07EA  stack[-1]
	//     @07EF  msg.sender
	//     @0829  memory[0x00:0x40]
	//     @082C  stack[-2]
	//     @0866  memory[0x00:0x40]
	//     @0882  msg.sender
	//     @08BD  memory[0x40:0x60]
	//     @08CA  memory[0x40:0x60]
	//     @08CF  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @08D4  stack[-3]
	// }
	07E7    5B  JUMPDEST
	07E8    60  PUSH1 0x00
	07EA    81  DUP2
	07EB    60  PUSH1 0x09
	07ED    60  PUSH1 0x00
	07EF    33  CALLER
	07F0    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0805    16  AND
	0806    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	081B    16  AND
	081C    81  DUP2
	081D    52  MSTORE
	081E    60  PUSH1 0x20
	0820    01  ADD
	0821    90  SWAP1
	0822    81  DUP2
	0823    52  MSTORE
	0824    60  PUSH1 0x20
	0826    01  ADD
	0827    60  PUSH1 0x00
	0829    20  SHA3
	082A    60  PUSH1 0x00
	082C    85  DUP6
	082D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0842    16  AND
	0843    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0858    16  AND
	0859    81  DUP2
	085A    52  MSTORE
	085B    60  PUSH1 0x20
	085D    01  ADD
	085E    90  SWAP1
	085F    81  DUP2
	0860    52  MSTORE
	0861    60  PUSH1 0x20
	0863    01  ADD
	0864    60  PUSH1 0x00
	0866    20  SHA3
	0867    81  DUP2
	0868    90  SWAP1
	0869    55  SSTORE
	086A    50  POP
	086B    82  DUP3
	086C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0881    16  AND
	0882    33  CALLER
	0883    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0898    16  AND
	0899    7F  PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925
	08BA    84  DUP5
	08BB    60  PUSH1 0x40
	08BD    51  MLOAD
	08BE    80  DUP1
	08BF    82  DUP3
	08C0    81  DUP2
	08C1    52  MSTORE
	08C2    60  PUSH1 0x20
	08C4    01  ADD
	08C5    91  SWAP2
	08C6    50  POP
	08C7    50  POP
	08C8    60  PUSH1 0x40
	08CA    51  MLOAD
	08CB    80  DUP1
	08CC    91  SWAP2
	08CD    03  SUB
	08CE    90  SWAP1
	08CF    A3  LOG3
	08D0    60  PUSH1 0x01
	08D2    90  SWAP1
	08D3    50  POP
	08D4    92  SWAP3
	08D5    91  SWAP2
	08D6    50  POP
	08D7    50  POP
	08D8    56  *JUMP
	// Stack delta = -2
	// Outputs[8]
	// {
	//     @081D  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0823  memory[0x20:0x40] = 0x09
	//     @085A  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @0860  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0869  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @08C1  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @08CF  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]);
	//     @08D4  stack[-3] = 0x01
	// }
	// Block ends with unconditional jump to stack[-3]

label_08D9:
	// Incoming jump from 0x0264
	// Inputs[2]
	// {
	//     @08DA  msg.sender
	//     @08F5  storage[0x00]
	// }
	08D9    5B  JUMPDEST
	08DA    33  CALLER
	08DB    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	08F0    16  AND
	08F1    60  PUSH1 0x00
	08F3    80  DUP1
	08F4    90  SWAP1
	08F5    54  SLOAD
	08F6    90  SWAP1
	08F7    61  PUSH2 0x0100
	08FA    0A  EXP
	08FB    90  SWAP1
	08FC    04  DIV
	08FD    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0912    16  AND
	0913    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0928    16  AND
	0929    14  EQ
	092A    61  PUSH2 0x099b
	092D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x099b, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender

label_092E:
	// Incoming jump from 0x092D, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[3]
	// {
	//     @0930  memory[0x40:0x60]
	//     @0995  memory[0x40:0x60]
	//     @099A  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	092E    60  PUSH1 0x40
	0930    51  MLOAD
	0931    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0952    81  DUP2
	0953    52  MSTORE
	0954    60  PUSH1 0x04
	0956    01  ADD
	0957    80  DUP1
	0958    80  DUP1
	0959    60  PUSH1 0x20
	095B    01  ADD
	095C    82  DUP3
	095D    81  DUP2
	095E    03  SUB
	095F    82  DUP3
	0960    52  MSTORE
	0961    60  PUSH1 0x20
	0963    81  DUP2
	0964    52  MSTORE
	0965    60  PUSH1 0x20
	0967    01  ADD
	0968    80  DUP1
	0969    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	098A    81  DUP2
	098B    52  MSTORE
	098C    50  POP
	098D    60  PUSH1 0x20
	098F    01  ADD
	0990    91  SWAP2
	0991    50  POP
	0992    50  POP
	0993    60  PUSH1 0x40
	0995    51  MLOAD
	0996    80  DUP1
	0997    91  SWAP2
	0998    03  SUB
	0999    90  SWAP1
	099A    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0953  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @0960  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0964  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @098B  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @099A  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_099B:
	// Incoming jump from 0x092D, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[1] { @09B4  stack[-3] }
	099B    5B  JUMPDEST
	099C    60  PUSH1 0x00
	099E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09B3    16  AND
	09B4    83  DUP4
	09B5    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09CA    16  AND
	09CB    14  EQ
	09CC    15  ISZERO
	09CD    61  PUSH2 0x0a21
	09D0    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0a21, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)

label_09D1:
	// Incoming jump from 0x09D0, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[3]
	// {
	//     @09D3  memory[0x40:0x60]
	//     @0A1B  memory[0x40:0x60]
	//     @0A20  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	09D1    60  PUSH1 0x40
	09D3    51  MLOAD
	09D4    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	09F5    81  DUP2
	09F6    52  MSTORE
	09F7    60  PUSH1 0x04
	09F9    01  ADD
	09FA    80  DUP1
	09FB    80  DUP1
	09FC    60  PUSH1 0x20
	09FE    01  ADD
	09FF    82  DUP3
	0A00    81  DUP2
	0A01    03  SUB
	0A02    82  DUP3
	0A03    52  MSTORE
	0A04    60  PUSH1 0x2c
	0A06    81  DUP2
	0A07    52  MSTORE
	0A08    60  PUSH1 0x20
	0A0A    01  ADD
	0A0B    80  DUP1
	0A0C    61  PUSH2 0x19e2
	0A0F    60  PUSH1 0x2c
	0A11    91  SWAP2
	0A12    39  CODECOPY
	0A13    60  PUSH1 0x40
	0A15    01  ADD
	0A16    91  SWAP2
	0A17    50  POP
	0A18    50  POP
	0A19    60  PUSH1 0x40
	0A1B    51  MLOAD
	0A1C    80  DUP1
	0A1D    91  SWAP2
	0A1E    03  SUB
	0A1F    90  SWAP1
	0A20    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @09F6  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @0A03  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0A07  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c
	//     @0A12  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x19e2:0x1a0e]
	//     @0A20  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0A21:
	// Incoming jump from 0x09D0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[3]
	// {
	//     @0A25  stack[-1]
	//     @0A28  memory[0x40:0x60]
	//     @0A3F  stack[-2]
	// }
	0A21    5B  JUMPDEST
	0A22    61  PUSH2 0x0a4e
	0A25    81  DUP2
	0A26    60  PUSH1 0x40
	0A28    51  MLOAD
	0A29    80  DUP1
	0A2A    60  PUSH1 0x60
	0A2C    01  ADD
	0A2D    60  PUSH1 0x40
	0A2F    52  MSTORE
	0A30    80  DUP1
	0A31    60  PUSH1 0x22
	0A33    81  DUP2
	0A34    52  MSTORE
	0A35    60  PUSH1 0x20
	0A37    01  ADD
	0A38    61  PUSH2 0x19c0
	0A3B    60  PUSH1 0x22
	0A3D    91  SWAP2
	0A3E    39  CODECOPY
	0A3F    84  DUP5
	0A40    61  PUSH2 0x1697
	0A43    90  SWAP1
	0A44    92  SWAP3
	0A45    91  SWAP2
	0A46    90  SWAP1
	0A47    63  PUSH4 0xffffffff
	0A4C    16  AND
	0A4D    56  *JUMP
	// Stack delta = +4
	// Outputs[7]
	// {
	//     @0A22  stack[0] = 0x0a4e
	//     @0A2F  memory[0x40:0x60] = 0x60 + memory[0x40:0x60]
	//     @0A34  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x22
	//     @0A3E  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x22] = code[0x19c0:0x19e2]
	//     @0A44  stack[1] = stack[-2]
	//     @0A45  stack[2] = stack[-1]
	//     @0A46  stack[3] = memory[0x40:0x60]
	// }
	// Block ends with call to 0xffffffff & 0x1697, returns to 0x0A4E

label_0A4E:
	// Incoming return from call to 0x1697 at 0x0A4D
	// Inputs[5]
	// {
	//     @0A53  stack[-4]
	//     @0A8D  memory[0x00:0x40]
	//     @0A8E  stack[-1]
	//     @0A95  stack[-2]
	//     @0A96  stack[-3]
	// }
	0A4E    5B  JUMPDEST
	0A4F    60  PUSH1 0x07
	0A51    60  PUSH1 0x00
	0A53    85  DUP6
	0A54    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0A69    16  AND
	0A6A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0A7F    16  AND
	0A80    81  DUP2
	0A81    52  MSTORE
	0A82    60  PUSH1 0x20
	0A84    01  ADD
	0A85    90  SWAP1
	0A86    81  DUP2
	0A87    52  MSTORE
	0A88    60  PUSH1 0x20
	0A8A    01  ADD
	0A8B    60  PUSH1 0x00
	0A8D    20  SHA3
	0A8E    81  DUP2
	0A8F    90  SWAP1
	0A90    55  SSTORE
	0A91    50  POP
	0A92    61  PUSH2 0x0aa4
	0A95    81  DUP2
	0A96    83  DUP4
	0A97    61  PUSH2 0x1757
	0A9A    90  SWAP1
	0A9B    91  SWAP2
	0A9C    90  SWAP1
	0A9D    63  PUSH4 0xffffffff
	0AA2    16  AND
	0AA3    56  *JUMP
	// Stack delta = +2
	// Outputs[6]
	// {
	//     @0A81  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0A87  memory[0x20:0x40] = 0x07
	//     @0A90  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0A92  stack[-1] = 0x0aa4
	//     @0A9B  stack[0] = stack[-3]
	//     @0A9C  stack[1] = stack[-2]
	// }
	// Block ends with call to 0xffffffff & 0x1757, returns to 0x0AA4

label_0AA4:
	// Incoming return from call to 0x1757 at 0x0AA3
	// Inputs[2]
	// {
	//     @0AA7  stack[-1]
	//     @0AAE  stack[-5]
	// }
	0AA4    5B  JUMPDEST
	0AA5    60  PUSH1 0x04
	0AA7    81  DUP2
	0AA8    90  SWAP1
	0AA9    55  SSTORE
	0AAA    50  POP
	0AAB    50  POP
	0AAC    50  POP
	0AAD    50  POP
	0AAE    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @0AA9  storage[0x04] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_0AAF:
	// Incoming call from 0x026E, returns to 0x026F
	// Inputs[2]
	// {
	//     @0AB2  storage[0x04]
	//     @0AB3  stack[-1]
	// }
	0AAF    5B  JUMPDEST
	0AB0    60  PUSH1 0x04
	0AB2    54  SLOAD
	0AB3    81  DUP2
	0AB4    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0AB2  stack[0] = storage[0x04] }
	// Block ends with unconditional jump to stack[-1]

label_0AB5:
	// Incoming jump from 0x02F0
	// Inputs[1] { @0ACF  stack[-2] }
	0AB5    5B  JUMPDEST
	0AB6    60  PUSH1 0x00
	0AB8    80  DUP1
	0AB9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0ACE    16  AND
	0ACF    83  DUP4
	0AD0    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AE5    16  AND
	0AE6    14  EQ
	0AE7    15  ISZERO
	0AE8    61  PUSH2 0x0af0
	0AEB    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0AB6  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0af0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)

label_0AEC:
	// Incoming jump from 0x0AEB, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[1] { @0AEF  memory[0x00:0x00] }
	0AEC    60  PUSH1 0x00
	0AEE    80  DUP1
	0AEF    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0AEF  revert(memory[0x00:0x00]); }
	// Block terminates

label_0AF0:
	// Incoming jump from 0x0AEB, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[4]
	// {
	//     @0AF5  stack[-4]
	//     @0B2F  memory[0x00:0x40]
	//     @0B30  storage[keccak256(memory[0x00:0x40])]
	//     @0B31  stack[-2]
	// }
	0AF0    5B  JUMPDEST
	0AF1    60  PUSH1 0x07
	0AF3    60  PUSH1 0x00
	0AF5    85  DUP6
	0AF6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B0B    16  AND
	0B0C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B21    16  AND
	0B22    81  DUP2
	0B23    52  MSTORE
	0B24    60  PUSH1 0x20
	0B26    01  ADD
	0B27    90  SWAP1
	0B28    81  DUP2
	0B29    52  MSTORE
	0B2A    60  PUSH1 0x20
	0B2C    01  ADD
	0B2D    60  PUSH1 0x00
	0B2F    20  SHA3
	0B30    54  SLOAD
	0B31    82  DUP3
	0B32    11  GT
	0B33    15  ISZERO
	0B34    61  PUSH2 0x0b3c
	0B37    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0B23  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0B29  memory[0x20:0x40] = 0x07
	// }
	// Block ends with conditional jump to 0x0b3c, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])

label_0B38:
	// Incoming jump from 0x0B37, if not !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[1] { @0B3B  memory[0x00:0x00] }
	0B38    60  PUSH1 0x00
	0B3A    80  DUP1
	0B3B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0B3B  revert(memory[0x00:0x00]); }
	// Block terminates

label_0B3C:
	// Incoming jump from 0x0B37, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[6]
	// {
	//     @0B41  stack[-4]
	//     @0B7B  memory[0x00:0x40]
	//     @0B7E  msg.sender
	//     @0BB8  memory[0x00:0x40]
	//     @0BB9  storage[keccak256(memory[0x00:0x40])]
	//     @0BBA  stack[-2]
	// }
	0B3C    5B  JUMPDEST
	0B3D    60  PUSH1 0x09
	0B3F    60  PUSH1 0x00
	0B41    85  DUP6
	0B42    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B57    16  AND
	0B58    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B6D    16  AND
	0B6E    81  DUP2
	0B6F    52  MSTORE
	0B70    60  PUSH1 0x20
	0B72    01  ADD
	0B73    90  SWAP1
	0B74    81  DUP2
	0B75    52  MSTORE
	0B76    60  PUSH1 0x20
	0B78    01  ADD
	0B79    60  PUSH1 0x00
	0B7B    20  SHA3
	0B7C    60  PUSH1 0x00
	0B7E    33  CALLER
	0B7F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B94    16  AND
	0B95    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0BAA    16  AND
	0BAB    81  DUP2
	0BAC    52  MSTORE
	0BAD    60  PUSH1 0x20
	0BAF    01  ADD
	0BB0    90  SWAP1
	0BB1    81  DUP2
	0BB2    52  MSTORE
	0BB3    60  PUSH1 0x20
	0BB5    01  ADD
	0BB6    60  PUSH1 0x00
	0BB8    20  SHA3
	0BB9    54  SLOAD
	0BBA    82  DUP3
	0BBB    11  GT
	0BBC    15  ISZERO
	0BBD    61  PUSH2 0x0bc5
	0BC0    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @0B6F  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0B75  memory[0x20:0x40] = 0x09
	//     @0BAC  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0BB2  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	// }
	// Block ends with conditional jump to 0x0bc5, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])

label_0BC1:
	// Incoming jump from 0x0BC0, if not !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[1] { @0BC4  memory[0x00:0x00] }
	0BC1    60  PUSH1 0x00
	0BC3    80  DUP1
	0BC4    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0BC4  revert(memory[0x00:0x00]); }
	// Block terminates

label_0BC5:
	// Incoming jump from 0x0BC0, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[3]
	// {
	//     @0BCE  stack[-4]
	//     @0C08  memory[0x00:0x40]
	//     @0C0C  storage[keccak256(memory[0x00:0x40])]
	// }
	0BC5    5B  JUMPDEST
	0BC6    60  PUSH1 0x01
	0BC8    15  ISZERO
	0BC9    15  ISZERO
	0BCA    60  PUSH1 0x08
	0BCC    60  PUSH1 0x00
	0BCE    86  DUP7
	0BCF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0BE4    16  AND
	0BE5    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0BFA    16  AND
	0BFB    81  DUP2
	0BFC    52  MSTORE
	0BFD    60  PUSH1 0x20
	0BFF    01  ADD
	0C00    90  SWAP1
	0C01    81  DUP2
	0C02    52  MSTORE
	0C03    60  PUSH1 0x20
	0C05    01  ADD
	0C06    60  PUSH1 0x00
	0C08    20  SHA3
	0C09    60  PUSH1 0x00
	0C0B    90  SWAP1
	0C0C    54  SLOAD
	0C0D    90  SWAP1
	0C0E    61  PUSH2 0x0100
	0C11    0A  EXP
	0C12    90  SWAP1
	0C13    04  DIV
	0C14    60  PUSH1 0xff
	0C16    16  AND
	0C17    15  ISZERO
	0C18    15  ISZERO
	0C19    14  EQ
	0C1A    61  PUSH2 0x0c22
	0C1D    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0BFC  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0C02  memory[0x20:0x40] = 0x08
	// }
	// Block ends with conditional jump to 0x0c22, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01

label_0C1E:
	// Incoming jump from 0x0C1D, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01
	// Inputs[1] { @0C21  memory[0x00:0x00] }
	0C1E    60  PUSH1 0x00
	0C20    80  DUP1
	0C21    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0C21  revert(memory[0x00:0x00]); }
	// Block terminates

label_0C22:
	// Incoming jump from 0x0C1D, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01
	// Inputs[4]
	// {
	//     @0C26  stack[-2]
	//     @0C2B  stack[-4]
	//     @0C65  memory[0x00:0x40]
	//     @0C66  storage[keccak256(memory[0x00:0x40])]
	// }
	0C22    5B  JUMPDEST
	0C23    61  PUSH2 0x0c74
	0C26    82  DUP3
	0C27    60  PUSH1 0x07
	0C29    60  PUSH1 0x00
	0C2B    87  DUP8
	0C2C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C41    16  AND
	0C42    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C57    16  AND
	0C58    81  DUP2
	0C59    52  MSTORE
	0C5A    60  PUSH1 0x20
	0C5C    01  ADD
	0C5D    90  SWAP1
	0C5E    81  DUP2
	0C5F    52  MSTORE
	0C60    60  PUSH1 0x20
	0C62    01  ADD
	0C63    60  PUSH1 0x00
	0C65    20  SHA3
	0C66    54  SLOAD
	0C67    61  PUSH2 0x1757
	0C6A    90  SWAP1
	0C6B    91  SWAP2
	0C6C    90  SWAP1
	0C6D    63  PUSH4 0xffffffff
	0C72    16  AND
	0C73    56  *JUMP
	// Stack delta = +3
	// Outputs[5]
	// {
	//     @0C23  stack[0] = 0x0c74
	//     @0C59  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0C5F  memory[0x20:0x40] = 0x07
	//     @0C6B  stack[1] = storage[keccak256(memory[0x00:0x40])]
	//     @0C6C  stack[2] = stack[-2]
	// }
	// Block ends with call to 0xffffffff & 0x1757, returns to 0x0C74

label_0C74:
	// Incoming return from call to 0x1757 at 0x0C73
	// Inputs[7]
	// {
	//     @0C79  stack[-5]
	//     @0CB3  memory[0x00:0x40]
	//     @0CB4  stack[-1]
	//     @0CBB  stack[-3]
	//     @0CC0  stack[-4]
	//     @0CFA  memory[0x00:0x40]
	//     @0CFB  storage[keccak256(memory[0x00:0x40])]
	// }
	0C74    5B  JUMPDEST
	0C75    60  PUSH1 0x07
	0C77    60  PUSH1 0x00
	0C79    86  DUP7
	0C7A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C8F    16  AND
	0C90    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CA5    16  AND
	0CA6    81  DUP2
	0CA7    52  MSTORE
	0CA8    60  PUSH1 0x20
	0CAA    01  ADD
	0CAB    90  SWAP1
	0CAC    81  DUP2
	0CAD    52  MSTORE
	0CAE    60  PUSH1 0x20
	0CB0    01  ADD
	0CB1    60  PUSH1 0x00
	0CB3    20  SHA3
	0CB4    81  DUP2
	0CB5    90  SWAP1
	0CB6    55  SSTORE
	0CB7    50  POP
	0CB8    61  PUSH2 0x0d09
	0CBB    82  DUP3
	0CBC    60  PUSH1 0x07
	0CBE    60  PUSH1 0x00
	0CC0    86  DUP7
	0CC1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CD6    16  AND
	0CD7    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CEC    16  AND
	0CED    81  DUP2
	0CEE    52  MSTORE
	0CEF    60  PUSH1 0x20
	0CF1    01  ADD
	0CF2    90  SWAP1
	0CF3    81  DUP2
	0CF4    52  MSTORE
	0CF5    60  PUSH1 0x20
	0CF7    01  ADD
	0CF8    60  PUSH1 0x00
	0CFA    20  SHA3
	0CFB    54  SLOAD
	0CFC    61  PUSH2 0x17a1
	0CFF    90  SWAP1
	0D00    91  SWAP2
	0D01    90  SWAP1
	0D02    63  PUSH4 0xffffffff
	0D07    16  AND
	0D08    56  *JUMP
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @0CA7  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @0CAD  memory[0x20:0x40] = 0x07
	//     @0CB6  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0CB8  stack[-1] = 0x0d09
	//     @0CEE  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0CF4  memory[0x20:0x40] = 0x07
	//     @0D00  stack[0] = storage[keccak256(memory[0x00:0x40])]
	//     @0D01  stack[1] = stack[-3]
	// }
	// Block ends with call to 0xffffffff & 0x17a1, returns to 0x0D09

label_0D09:
	// Incoming return from call to 0x17A1 at 0x0D08
	// Inputs[9]
	// {
	//     @0D0E  stack[-4]
	//     @0D48  memory[0x00:0x40]
	//     @0D49  stack[-1]
	//     @0D50  stack[-3]
	//     @0D55  stack[-5]
	//     @0D8F  memory[0x00:0x40]
	//     @0D92  msg.sender
	//     @0DCC  memory[0x00:0x40]
	//     @0DCD  storage[keccak256(memory[0x00:0x40])]
	// }
	0D09    5B  JUMPDEST
	0D0A    60  PUSH1 0x07
	0D0C    60  PUSH1 0x00
	0D0E    85  DUP6
	0D0F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D24    16  AND
	0D25    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D3A    16  AND
	0D3B    81  DUP2
	0D3C    52  MSTORE
	0D3D    60  PUSH1 0x20
	0D3F    01  ADD
	0D40    90  SWAP1
	0D41    81  DUP2
	0D42    52  MSTORE
	0D43    60  PUSH1 0x20
	0D45    01  ADD
	0D46    60  PUSH1 0x00
	0D48    20  SHA3
	0D49    81  DUP2
	0D4A    90  SWAP1
	0D4B    55  SSTORE
	0D4C    50  POP
	0D4D    61  PUSH2 0x0ddb
	0D50    82  DUP3
	0D51    60  PUSH1 0x09
	0D53    60  PUSH1 0x00
	0D55    87  DUP8
	0D56    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D6B    16  AND
	0D6C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D81    16  AND
	0D82    81  DUP2
	0D83    52  MSTORE
	0D84    60  PUSH1 0x20
	0D86    01  ADD
	0D87    90  SWAP1
	0D88    81  DUP2
	0D89    52  MSTORE
	0D8A    60  PUSH1 0x20
	0D8C    01  ADD
	0D8D    60  PUSH1 0x00
	0D8F    20  SHA3
	0D90    60  PUSH1 0x00
	0D92    33  CALLER
	0D93    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0DA8    16  AND
	0DA9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0DBE    16  AND
	0DBF    81  DUP2
	0DC0    52  MSTORE
	0DC1    60  PUSH1 0x20
	0DC3    01  ADD
	0DC4    90  SWAP1
	0DC5    81  DUP2
	0DC6    52  MSTORE
	0DC7    60  PUSH1 0x20
	0DC9    01  ADD
	0DCA    60  PUSH1 0x00
	0DCC    20  SHA3
	0DCD    54  SLOAD
	0DCE    61  PUSH2 0x1757
	0DD1    90  SWAP1
	0DD2    91  SWAP2
	0DD3    90  SWAP1
	0DD4    63  PUSH4 0xffffffff
	0DD9    16  AND
	0DDA    56  *JUMP
	// Stack delta = +2
	// Outputs[10]
	// {
	//     @0D3C  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0D42  memory[0x20:0x40] = 0x07
	//     @0D4B  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0D4D  stack[-1] = 0x0ddb
	//     @0D83  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @0D89  memory[0x20:0x40] = 0x09
	//     @0DC0  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0DC6  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0DD2  stack[0] = storage[keccak256(memory[0x00:0x40])]
	//     @0DD3  stack[1] = stack[-3]
	// }
	// Block ends with call to 0xffffffff & 0x1757, returns to 0x0DDB

label_0DDB:
	// Incoming return from call to 0x1757 at 0x0DDA
	// Inputs[12]
	// {
	//     @0DE0  stack[-5]
	//     @0E1A  memory[0x00:0x40]
	//     @0E1D  msg.sender
	//     @0E57  memory[0x00:0x40]
	//     @0E58  stack[-1]
	//     @0E5C  stack[-4]
	//     @0EAB  stack[-3]
	//     @0EAE  memory[0x40:0x60]
	//     @0EBB  memory[0x40:0x60]
	//     @0EC0  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @0EC3  stack[-2]
	//     @0EC5  stack[-6]
	// }
	0DDB    5B  JUMPDEST
	0DDC    60  PUSH1 0x09
	0DDE    60  PUSH1 0x00
	0DE0    86  DUP7
	0DE1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0DF6    16  AND
	0DF7    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E0C    16  AND
	0E0D    81  DUP2
	0E0E    52  MSTORE
	0E0F    60  PUSH1 0x20
	0E11    01  ADD
	0E12    90  SWAP1
	0E13    81  DUP2
	0E14    52  MSTORE
	0E15    60  PUSH1 0x20
	0E17    01  ADD
	0E18    60  PUSH1 0x00
	0E1A    20  SHA3
	0E1B    60  PUSH1 0x00
	0E1D    33  CALLER
	0E1E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E33    16  AND
	0E34    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E49    16  AND
	0E4A    81  DUP2
	0E4B    52  MSTORE
	0E4C    60  PUSH1 0x20
	0E4E    01  ADD
	0E4F    90  SWAP1
	0E50    81  DUP2
	0E51    52  MSTORE
	0E52    60  PUSH1 0x20
	0E54    01  ADD
	0E55    60  PUSH1 0x00
	0E57    20  SHA3
	0E58    81  DUP2
	0E59    90  SWAP1
	0E5A    55  SSTORE
	0E5B    50  POP
	0E5C    82  DUP3
	0E5D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E72    16  AND
	0E73    84  DUP5
	0E74    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E89    16  AND
	0E8A    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	0EAB    84  DUP5
	0EAC    60  PUSH1 0x40
	0EAE    51  MLOAD
	0EAF    80  DUP1
	0EB0    82  DUP3
	0EB1    81  DUP2
	0EB2    52  MSTORE
	0EB3    60  PUSH1 0x20
	0EB5    01  ADD
	0EB6    91  SWAP2
	0EB7    50  POP
	0EB8    50  POP
	0EB9    60  PUSH1 0x40
	0EBB    51  MLOAD
	0EBC    80  DUP1
	0EBD    91  SWAP2
	0EBE    03  SUB
	0EBF    90  SWAP1
	0EC0    A3  LOG3
	0EC1    60  PUSH1 0x01
	0EC3    90  SWAP1
	0EC4    50  POP
	0EC5    93  SWAP4
	0EC6    92  SWAP3
	0EC7    50  POP
	0EC8    50  POP
	0EC9    50  POP
	0ECA    56  *JUMP
	// Stack delta = -5
	// Outputs[8]
	// {
	//     @0E0E  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @0E14  memory[0x20:0x40] = 0x09
	//     @0E4B  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0E51  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0E5A  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0EB2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3]
	//     @0EC0  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]);
	//     @0EC5  stack[-6] = 0x01
	// }
	// Block ends with unconditional jump to stack[-6]

label_0ECB:
	// Incoming jump from 0x034C
	// Inputs[4]
	// {
	//     @0ED1  stack[-1]
	//     @0ED9  memory[0x00:0x40]
	//     @0EE0  storage[keccak256(memory[0x00:0x40])]
	//     @0EE1  stack[-2]
	// }
	0ECB    5B  JUMPDEST
	0ECC    60  PUSH1 0x07
	0ECE    60  PUSH1 0x20
	0ED0    52  MSTORE
	0ED1    80  DUP1
	0ED2    60  PUSH1 0x00
	0ED4    52  MSTORE
	0ED5    60  PUSH1 0x40
	0ED7    60  PUSH1 0x00
	0ED9    20  SHA3
	0EDA    60  PUSH1 0x00
	0EDC    91  SWAP2
	0EDD    50  POP
	0EDE    90  SWAP1
	0EDF    50  POP
	0EE0    54  SLOAD
	0EE1    81  DUP2
	0EE2    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0ED0  memory[0x20:0x40] = 0x07
	//     @0ED4  memory[0x00:0x20] = stack[-1]
	//     @0EE0  stack[-1] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-2]

label_0EE3:
	// Incoming call from 0x036A, returns to 0x036B
	// Inputs[2]
	// {
	//     @0EE9  storage[0x03]
	//     @0EF4  stack[-1]
	// }
	0EE3    5B  JUMPDEST
	0EE4    60  PUSH1 0x03
	0EE6    60  PUSH1 0x00
	0EE8    90  SWAP1
	0EE9    54  SLOAD
	0EEA    90  SWAP1
	0EEB    61  PUSH2 0x0100
	0EEE    0A  EXP
	0EEF    90  SWAP1
	0EF0    04  DIV
	0EF1    60  PUSH1 0xff
	0EF3    16  AND
	0EF4    81  DUP2
	0EF5    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0EF3  stack[0] = 0xff & storage[0x03] / 0x0100 ** 0x00 }
	// Block ends with unconditional jump to stack[-1]

label_0EF6:
	// Incoming jump from 0x03E8
	// Inputs[6]
	// {
	//     @0EFC  stack[-2]
	//     @0F04  memory[0x00:0x40]
	//     @0F08  stack[-1]
	//     @0F10  memory[0x00:0x40]
	//     @0F18  storage[keccak256(memory[0x00:0x40])]
	//     @0F19  stack[-3]
	// }
	0EF6    5B  JUMPDEST
	0EF7    60  PUSH1 0x09
	0EF9    60  PUSH1 0x20
	0EFB    52  MSTORE
	0EFC    81  DUP2
	0EFD    60  PUSH1 0x00
	0EFF    52  MSTORE
	0F00    60  PUSH1 0x40
	0F02    60  PUSH1 0x00
	0F04    20  SHA3
	0F05    60  PUSH1 0x20
	0F07    52  MSTORE
	0F08    80  DUP1
	0F09    60  PUSH1 0x00
	0F0B    52  MSTORE
	0F0C    60  PUSH1 0x40
	0F0E    60  PUSH1 0x00
	0F10    20  SHA3
	0F11    60  PUSH1 0x00
	0F13    91  SWAP2
	0F14    50  POP
	0F15    91  SWAP2
	0F16    50  POP
	0F17    50  POP
	0F18    54  SLOAD
	0F19    81  DUP2
	0F1A    56  *JUMP
	// Stack delta = -1
	// Outputs[5]
	// {
	//     @0EFB  memory[0x20:0x40] = 0x09
	//     @0EFF  memory[0x00:0x20] = stack[-2]
	//     @0F07  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0F0B  memory[0x00:0x20] = stack[-1]
	//     @0F18  stack[-2] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-3]

label_0F1B:
	// Incoming jump from 0x042D
	// Inputs[2]
	// {
	//     @0F1C  msg.sender
	//     @0F37  storage[0x00]
	// }
	0F1B    5B  JUMPDEST
	0F1C    33  CALLER
	0F1D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F32    16  AND
	0F33    60  PUSH1 0x00
	0F35    80  DUP1
	0F36    90  SWAP1
	0F37    54  SLOAD
	0F38    90  SWAP1
	0F39    61  PUSH2 0x0100
	0F3C    0A  EXP
	0F3D    90  SWAP1
	0F3E    04  DIV
	0F3F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F54    16  AND
	0F55    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F6A    16  AND
	0F6B    14  EQ
	0F6C    61  PUSH2 0x0fdd
	0F6F    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0fdd, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender

label_0F70:
	// Incoming jump from 0x0F6F, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[3]
	// {
	//     @0F72  memory[0x40:0x60]
	//     @0FD7  memory[0x40:0x60]
	//     @0FDC  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0F70    60  PUSH1 0x40
	0F72    51  MLOAD
	0F73    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	0F94    81  DUP2
	0F95    52  MSTORE
	0F96    60  PUSH1 0x04
	0F98    01  ADD
	0F99    80  DUP1
	0F9A    80  DUP1
	0F9B    60  PUSH1 0x20
	0F9D    01  ADD
	0F9E    82  DUP3
	0F9F    81  DUP2
	0FA0    03  SUB
	0FA1    82  DUP3
	0FA2    52  MSTORE
	0FA3    60  PUSH1 0x20
	0FA5    81  DUP2
	0FA6    52  MSTORE
	0FA7    60  PUSH1 0x20
	0FA9    01  ADD
	0FAA    80  DUP1
	0FAB    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	0FCC    81  DUP2
	0FCD    52  MSTORE
	0FCE    50  POP
	0FCF    60  PUSH1 0x20
	0FD1    01  ADD
	0FD2    91  SWAP2
	0FD3    50  POP
	0FD4    50  POP
	0FD5    60  PUSH1 0x40
	0FD7    51  MLOAD
	0FD8    80  DUP1
	0FD9    91  SWAP2
	0FDA    03  SUB
	0FDB    90  SWAP1
	0FDC    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0F95  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @0FA2  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0FA6  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @0FCD  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @0FDC  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0FDD:
	// Incoming jump from 0x0F6F, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[2]
	// {
	//     @0FDE  stack[-1]
	//     @0FE9  stack[-2]
	// }
	0FDD    5B  JUMPDEST
	0FDE    80  DUP1
	0FDF    60  PUSH1 0xff
	0FE1    16  AND
	0FE2    60  PUSH1 0x0a
	0FE4    81  DUP2
	0FE5    90  SWAP1
	0FE6    55  SSTORE
	0FE7    50  POP
	0FE8    50  POP
	0FE9    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @0FE6  storage[0x0a] = 0xff & stack[-1] }
	// Block ends with unconditional jump to stack[-2]

label_0FEA:
	// Incoming jump from 0x0471
	// Inputs[4]
	// {
	//     @0FF1  stack[-1]
	//     @102B  memory[0x00:0x40]
	//     @102C  storage[keccak256(memory[0x00:0x40])]
	//     @102F  stack[-2]
	// }
	0FEA    5B  JUMPDEST
	0FEB    60  PUSH1 0x00
	0FED    60  PUSH1 0x07
	0FEF    60  PUSH1 0x00
	0FF1    83  DUP4
	0FF2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1007    16  AND
	1008    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	101D    16  AND
	101E    81  DUP2
	101F    52  MSTORE
	1020    60  PUSH1 0x20
	1022    01  ADD
	1023    90  SWAP1
	1024    81  DUP2
	1025    52  MSTORE
	1026    60  PUSH1 0x20
	1028    01  ADD
	1029    60  PUSH1 0x00
	102B    20  SHA3
	102C    54  SLOAD
	102D    90  SWAP1
	102E    50  POP
	102F    91  SWAP2
	1030    90  SWAP1
	1031    50  POP
	1032    56  *JUMP
	// Stack delta = -1
	// Outputs[3]
	// {
	//     @101F  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @1025  memory[0x20:0x40] = 0x07
	//     @102F  stack[-2] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-2]

label_1033:
	// Incoming call from 0x048F, returns to 0x0490
	// Inputs[2]
	// {
	//     @1034  msg.sender
	//     @104F  storage[0x00]
	// }
	1033    5B  JUMPDEST
	1034    33  CALLER
	1035    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	104A    16  AND
	104B    60  PUSH1 0x00
	104D    80  DUP1
	104E    90  SWAP1
	104F    54  SLOAD
	1050    90  SWAP1
	1051    61  PUSH2 0x0100
	1054    0A  EXP
	1055    90  SWAP1
	1056    04  DIV
	1057    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	106C    16  AND
	106D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1082    16  AND
	1083    14  EQ
	1084    61  PUSH2 0x10f5
	1087    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x10f5, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender

label_1088:
	// Incoming jump from 0x1087, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[3]
	// {
	//     @108A  memory[0x40:0x60]
	//     @10EF  memory[0x40:0x60]
	//     @10F4  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	1088    60  PUSH1 0x40
	108A    51  MLOAD
	108B    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	10AC    81  DUP2
	10AD    52  MSTORE
	10AE    60  PUSH1 0x04
	10B0    01  ADD
	10B1    80  DUP1
	10B2    80  DUP1
	10B3    60  PUSH1 0x20
	10B5    01  ADD
	10B6    82  DUP3
	10B7    81  DUP2
	10B8    03  SUB
	10B9    82  DUP3
	10BA    52  MSTORE
	10BB    60  PUSH1 0x20
	10BD    81  DUP2
	10BE    52  MSTORE
	10BF    60  PUSH1 0x20
	10C1    01  ADD
	10C2    80  DUP1
	10C3    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	10E4    81  DUP2
	10E5    52  MSTORE
	10E6    50  POP
	10E7    60  PUSH1 0x20
	10E9    01  ADD
	10EA    91  SWAP2
	10EB    50  POP
	10EC    50  POP
	10ED    60  PUSH1 0x40
	10EF    51  MLOAD
	10F0    80  DUP1
	10F1    91  SWAP2
	10F2    03  SUB
	10F3    90  SWAP1
	10F4    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @10AD  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @10BA  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @10BE  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @10E5  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @10F4  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_10F5:
	// Incoming jump from 0x1087, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[6]
	// {
	//     @1112  storage[0x00]
	//     @1169  memory[0x40:0x60]
	//     @116C  memory[0x40:0x60]
	//     @1171  memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]
	//     @117C  storage[0x00]
	//     @11B3  stack[-1]
	// }
	10F5    5B  JUMPDEST
	10F6    60  PUSH1 0x00
	10F8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	110D    16  AND
	110E    60  PUSH1 0x00
	1110    80  DUP1
	1111    90  SWAP1
	1112    54  SLOAD
	1113    90  SWAP1
	1114    61  PUSH2 0x0100
	1117    0A  EXP
	1118    90  SWAP1
	1119    04  DIV
	111A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	112F    16  AND
	1130    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1145    16  AND
	1146    7F  PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0
	1167    60  PUSH1 0x40
	1169    51  MLOAD
	116A    60  PUSH1 0x40
	116C    51  MLOAD
	116D    80  DUP1
	116E    91  SWAP2
	116F    03  SUB
	1170    90  SWAP1
	1171    A3  LOG3
	1172    60  PUSH1 0x00
	1174    80  DUP1
	1175    60  PUSH1 0x00
	1177    61  PUSH2 0x0100
	117A    0A  EXP
	117B    81  DUP2
	117C    54  SLOAD
	117D    81  DUP2
	117E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1193    02  MUL
	1194    19  NOT
	1195    16  AND
	1196    90  SWAP1
	1197    83  DUP4
	1198    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	11AD    16  AND
	11AE    02  MUL
	11AF    17  OR
	11B0    90  SWAP1
	11B1    55  SSTORE
	11B2    50  POP
	11B3    56  *JUMP
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @1171  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]);
	//     @11B1  storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00])
	// }
	// Block ends with unconditional jump to stack[-1]

label_11B4:
	// Incoming call from 0x0499, returns to 0x049A
	// Inputs[2]
	// {
	//     @11B9  storage[0x00]
	//     @11D7  stack[-1]
	// }
	11B4    5B  JUMPDEST
	11B5    60  PUSH1 0x00
	11B7    80  DUP1
	11B8    90  SWAP1
	11B9    54  SLOAD
	11BA    90  SWAP1
	11BB    61  PUSH2 0x0100
	11BE    0A  EXP
	11BF    90  SWAP1
	11C0    04  DIV
	11C1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	11D6    16  AND
	11D7    81  DUP2
	11D8    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @11D6  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 }
	// Block ends with unconditional jump to stack[-1]

label_11D9:
	// Incoming call from 0x04E3, returns to 0x04E4
	// Inputs[3]
	// {
	//     @11DD  storage[0x02]
	//     @11FE  memory[0x40:0x60]
	//     @1211  storage[0x02]
	// }
	11D9    5B  JUMPDEST
	11DA    60  PUSH1 0x02
	11DC    80  DUP1
	11DD    54  SLOAD
	11DE    60  PUSH1 0x01
	11E0    81  DUP2
	11E1    60  PUSH1 0x01
	11E3    16  AND
	11E4    15  ISZERO
	11E5    61  PUSH2 0x0100
	11E8    02  MUL
	11E9    03  SUB
	11EA    16  AND
	11EB    60  PUSH1 0x02
	11ED    90  SWAP1
	11EE    04  DIV
	11EF    80  DUP1
	11F0    60  PUSH1 0x1f
	11F2    01  ADD
	11F3    60  PUSH1 0x20
	11F5    80  DUP1
	11F6    91  SWAP2
	11F7    04  DIV
	11F8    02  MUL
	11F9    60  PUSH1 0x20
	11FB    01  ADD
	11FC    60  PUSH1 0x40
	11FE    51  MLOAD
	11FF    90  SWAP1
	1200    81  DUP2
	1201    01  ADD
	1202    60  PUSH1 0x40
	1204    52  MSTORE
	1205    80  DUP1
	1206    92  SWAP3
	1207    91  SWAP2
	1208    90  SWAP1
	1209    81  DUP2
	120A    81  DUP2
	120B    52  MSTORE
	120C    60  PUSH1 0x20
	120E    01  ADD
	120F    82  DUP3
	1210    80  DUP1
	1211    54  SLOAD
	1212    60  PUSH1 0x01
	1214    81  DUP2
	1215    60  PUSH1 0x01
	1217    16  AND
	1218    15  ISZERO
	1219    61  PUSH2 0x0100
	121C    02  MUL
	121D    03  SUB
	121E    16  AND
	121F    60  PUSH1 0x02
	1221    90  SWAP1
	1222    04  DIV
	1223    80  DUP1
	1224    15  ISZERO
	1225    61  PUSH2 0x126f
	1228    57  *JUMPI
	// Stack delta = +6
	// Outputs[8]
	// {
	//     @1204  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02) / 0x20 * 0x20
	//     @1206  stack[0] = memory[0x40:0x60]
	//     @1207  stack[1] = 0x02
	//     @1208  stack[2] = (0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02
	//     @120B  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02
	//     @120E  stack[3] = 0x20 + memory[0x40:0x60]
	//     @120F  stack[4] = 0x02
	//     @1222  stack[5] = (0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02
	// }
	// Block ends with conditional jump to 0x126f, if !((0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02)

label_1229:
	// Incoming jump from 0x1228, if not !((0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02)
	// Inputs[1] { @1229  stack[-1] }
	1229    80  DUP1
	122A    60  PUSH1 0x1f
	122C    10  LT
	122D    61  PUSH2 0x1244
	1230    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x1244, if 0x1f < stack[-1]

label_1231:
	// Incoming jump from 0x1230, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @1235  stack[-2]
	//     @1236  storage[stack[-2]]
	//     @1239  stack[-3]
	//     @123B  stack[-1]
	// }
	1231    61  PUSH2 0x0100
	1234    80  DUP1
	1235    83  DUP4
	1236    54  SLOAD
	1237    04  DIV
	1238    02  MUL
	1239    83  DUP4
	123A    52  MSTORE
	123B    91  SWAP2
	123C    60  PUSH1 0x20
	123E    01  ADD
	123F    91  SWAP2
	1240    61  PUSH2 0x126f
	1243    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @123A  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @123F  stack[-1] = stack[-1]
	//     @123F  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x126f

label_1244:
	// Incoming jump from 0x1230, if 0x1f < stack[-1]
	// Inputs[5]
	// {
	//     @1245  stack[-3]
	//     @1246  stack[-1]
	//     @1248  stack[-2]
	//     @1250  memory[0x00:0x20]
	//     @1254  storage[keccak256(memory[0x00:0x20])]
	// }
	1244    5B  JUMPDEST
	1245    82  DUP3
	1246    01  ADD
	1247    91  SWAP2
	1248    90  SWAP1
	1249    60  PUSH1 0x00
	124B    52  MSTORE
	124C    60  PUSH1 0x20
	124E    60  PUSH1 0x00
	1250    20  SHA3
	1251    90  SWAP1
	1252    5B  JUMPDEST
	1253    81  DUP2
	1254    54  SLOAD
	1255    81  DUP2
	1256    52  MSTORE
	1257    90  SWAP1
	1258    60  PUSH1 0x01
	125A    01  ADD
	125B    90  SWAP1
	125C    60  PUSH1 0x20
	125E    01  ADD
	125F    80  DUP1
	1260    83  DUP4
	1261    11  GT
	1262    61  PUSH2 0x1252
	1265    57  *JUMPI
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @1247  stack[-3] = stack[-3] + stack[-1]
	//     @124B  memory[0x00:0x20] = stack[-2]
	//     @1256  memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])]
	//     @125B  stack[-2] = 0x01 + keccak256(memory[0x00:0x20])
	//     @125E  stack[-1] = 0x20 + stack[-3]
	// }
	// Block ends with conditional jump to 0x1252, if stack[-3] + stack[-1] > 0x20 + stack[-3]

label_1266:
	// Incoming jump from 0x1265, if not stack[-3] + stack[-1] > 0x20 + stack[-3]
	// Incoming jump from 0x1265, if not stack[-3] > 0x20 + stack[-1]
	// Inputs[2]
	// {
	//     @1266  stack[-3]
	//     @1267  stack[-1]
	// }
	1266    82  DUP3
	1267    90  SWAP1
	1268    03  SUB
	1269    60  PUSH1 0x1f
	126B    16  AND
	126C    82  DUP3
	126D    01  ADD
	126E    91  SWAP2
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @126E  stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3])
	//     @126E  stack[-1] = stack[-3]
	// }
	// Block continues

label_126F:
	// Incoming jump from 0x1243
	// Incoming jump from 0x1228, if !((0x0100 * !(0x01 & storage[0x02]) - 0x01 & storage[0x02]) / 0x02)
	// Incoming jump from 0x126E
	// Inputs[1] { @1275  stack[-7] }
	126F    5B  JUMPDEST
	1270    50  POP
	1271    50  POP
	1272    50  POP
	1273    50  POP
	1274    50  POP
	1275    81  DUP2
	1276    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-7]

label_1277:
	// Incoming jump from 0x058A
	// Inputs[2]
	// {
	//     @1285  storage[0x0a]
	//     @1286  stack[-1]
	// }
	1277    5B  JUMPDEST
	1278    60  PUSH1 0x00
	127A    80  DUP1
	127B    61  PUSH2 0x12a2
	127E    60  PUSH1 0x64
	1280    61  PUSH2 0x1294
	1283    60  PUSH1 0x0a
	1285    54  SLOAD
	1286    86  DUP7
	1287    61  PUSH2 0x1829
	128A    90  SWAP1
	128B    91  SWAP2
	128C    90  SWAP1
	128D    63  PUSH4 0xffffffff
	1292    16  AND
	1293    56  *JUMP
	// Stack delta = +7
	// Outputs[7]
	// {
	//     @1278  stack[0] = 0x00
	//     @127A  stack[1] = 0x00
	//     @127B  stack[2] = 0x12a2
	//     @127E  stack[3] = 0x64
	//     @1280  stack[4] = 0x1294
	//     @128B  stack[5] = stack[-1]
	//     @128C  stack[6] = storage[0x0a]
	// }
	// Block ends with call to 0xffffffff & 0x1829, returns to 0x1294

label_1294:
	// Incoming return from call to 0x1829 at 0x1293
	// Inputs[2]
	// {
	//     @1298  stack[-1]
	//     @1299  stack[-2]
	// }
	1294    5B  JUMPDEST
	1295    61  PUSH2 0x18af
	1298    90  SWAP1
	1299    91  SWAP2
	129A    90  SWAP1
	129B    63  PUSH4 0xffffffff
	12A0    16  AND
	12A1    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @1299  stack[-2] = stack[-1]
	//     @129A  stack[-1] = stack[-2]
	// }
	// Block ends with unconditional jump to 0xffffffff & 0x18af

label_12A2:
	// Incoming return from call to 0x1294 at 0x1293
	// Inputs[5]
	// {
	//     @12A3  stack[-1]
	//     @12A3  stack[-2]
	//     @12A6  stack[-3]
	//     @12A9  stack[-5]
	//     @12AA  stack[-4]
	// }
	12A2    5B  JUMPDEST
	12A3    90  SWAP1
	12A4    50  POP
	12A5    80  DUP1
	12A6    91  SWAP2
	12A7    50  POP
	12A8    50  POP
	12A9    91  SWAP2
	12AA    90  SWAP1
	12AB    50  POP
	12AC    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @12A9  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_12AD:
	// Incoming jump from 0x05EC
	// Inputs[1] { @12C7  stack[-2] }
	12AD    5B  JUMPDEST
	12AE    60  PUSH1 0x00
	12B0    80  DUP1
	12B1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	12C6    16  AND
	12C7    83  DUP4
	12C8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	12DD    16  AND
	12DE    14  EQ
	12DF    15  ISZERO
	12E0    61  PUSH2 0x12e8
	12E3    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @12AE  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x12e8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)

label_12E4:
	// Incoming jump from 0x12E3, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[1] { @12E7  memory[0x00:0x00] }
	12E4    60  PUSH1 0x00
	12E6    80  DUP1
	12E7    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @12E7  revert(memory[0x00:0x00]); }
	// Block terminates

label_12E8:
	// Incoming jump from 0x12E3, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00)
	// Inputs[4]
	// {
	//     @12ED  msg.sender
	//     @1327  memory[0x00:0x40]
	//     @1328  storage[keccak256(memory[0x00:0x40])]
	//     @1329  stack[-2]
	// }
	12E8    5B  JUMPDEST
	12E9    60  PUSH1 0x07
	12EB    60  PUSH1 0x00
	12ED    33  CALLER
	12EE    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1303    16  AND
	1304    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1319    16  AND
	131A    81  DUP2
	131B    52  MSTORE
	131C    60  PUSH1 0x20
	131E    01  ADD
	131F    90  SWAP1
	1320    81  DUP2
	1321    52  MSTORE
	1322    60  PUSH1 0x20
	1324    01  ADD
	1325    60  PUSH1 0x00
	1327    20  SHA3
	1328    54  SLOAD
	1329    82  DUP3
	132A    11  GT
	132B    15  ISZERO
	132C    61  PUSH2 0x1334
	132F    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @131B  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @1321  memory[0x20:0x40] = 0x07
	// }
	// Block ends with conditional jump to 0x1334, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])

label_1330:
	// Incoming jump from 0x132F, if not !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[1] { @1333  memory[0x00:0x00] }
	1330    60  PUSH1 0x00
	1332    80  DUP1
	1333    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1333  revert(memory[0x00:0x00]); }
	// Block terminates

label_1334:
	// Incoming jump from 0x132F, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])])
	// Inputs[4]
	// {
	//     @1338  stack[-2]
	//     @133D  msg.sender
	//     @1377  memory[0x00:0x40]
	//     @1378  storage[keccak256(memory[0x00:0x40])]
	// }
	1334    5B  JUMPDEST
	1335    61  PUSH2 0x1386
	1338    82  DUP3
	1339    60  PUSH1 0x07
	133B    60  PUSH1 0x00
	133D    33  CALLER
	133E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1353    16  AND
	1354    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1369    16  AND
	136A    81  DUP2
	136B    52  MSTORE
	136C    60  PUSH1 0x20
	136E    01  ADD
	136F    90  SWAP1
	1370    81  DUP2
	1371    52  MSTORE
	1372    60  PUSH1 0x20
	1374    01  ADD
	1375    60  PUSH1 0x00
	1377    20  SHA3
	1378    54  SLOAD
	1379    61  PUSH2 0x1757
	137C    90  SWAP1
	137D    91  SWAP2
	137E    90  SWAP1
	137F    63  PUSH4 0xffffffff
	1384    16  AND
	1385    56  *JUMP
	// Stack delta = +3
	// Outputs[5]
	// {
	//     @1335  stack[0] = 0x1386
	//     @136B  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @1371  memory[0x20:0x40] = 0x07
	//     @137D  stack[1] = storage[keccak256(memory[0x00:0x40])]
	//     @137E  stack[2] = stack[-2]
	// }
	// Block ends with call to 0xffffffff & 0x1757, returns to 0x1386

label_1386:
	// Incoming return from call to 0x1757 at 0x1385
	// Inputs[7]
	// {
	//     @138B  msg.sender
	//     @13C5  memory[0x00:0x40]
	//     @13C6  stack[-1]
	//     @13CD  stack[-3]
	//     @13D2  stack[-4]
	//     @140C  memory[0x00:0x40]
	//     @140D  storage[keccak256(memory[0x00:0x40])]
	// }
	1386    5B  JUMPDEST
	1387    60  PUSH1 0x07
	1389    60  PUSH1 0x00
	138B    33  CALLER
	138C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13A1    16  AND
	13A2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13B7    16  AND
	13B8    81  DUP2
	13B9    52  MSTORE
	13BA    60  PUSH1 0x20
	13BC    01  ADD
	13BD    90  SWAP1
	13BE    81  DUP2
	13BF    52  MSTORE
	13C0    60  PUSH1 0x20
	13C2    01  ADD
	13C3    60  PUSH1 0x00
	13C5    20  SHA3
	13C6    81  DUP2
	13C7    90  SWAP1
	13C8    55  SSTORE
	13C9    50  POP
	13CA    61  PUSH2 0x141b
	13CD    82  DUP3
	13CE    60  PUSH1 0x07
	13D0    60  PUSH1 0x00
	13D2    86  DUP7
	13D3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13E8    16  AND
	13E9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13FE    16  AND
	13FF    81  DUP2
	1400    52  MSTORE
	1401    60  PUSH1 0x20
	1403    01  ADD
	1404    90  SWAP1
	1405    81  DUP2
	1406    52  MSTORE
	1407    60  PUSH1 0x20
	1409    01  ADD
	140A    60  PUSH1 0x00
	140C    20  SHA3
	140D    54  SLOAD
	140E    61  PUSH2 0x17a1
	1411    90  SWAP1
	1412    91  SWAP2
	1413    90  SWAP1
	1414    63  PUSH4 0xffffffff
	1419    16  AND
	141A    56  *JUMP
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @13B9  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @13BF  memory[0x20:0x40] = 0x07
	//     @13C8  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @13CA  stack[-1] = 0x141b
	//     @1400  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @1406  memory[0x20:0x40] = 0x07
	//     @1412  stack[0] = storage[keccak256(memory[0x00:0x40])]
	//     @1413  stack[1] = stack[-3]
	// }
	// Block ends with call to 0xffffffff & 0x17a1, returns to 0x141B

label_141B:
	// Incoming return from call to 0x17A1 at 0x141A
	// Inputs[10]
	// {
	//     @1420  stack[-4]
	//     @145A  memory[0x00:0x40]
	//     @145B  stack[-1]
	//     @1476  msg.sender
	//     @14AE  stack[-3]
	//     @14B1  memory[0x40:0x60]
	//     @14BE  memory[0x40:0x60]
	//     @14C3  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @14C6  stack[-2]
	//     @14C8  stack[-5]
	// }
	141B    5B  JUMPDEST
	141C    60  PUSH1 0x07
	141E    60  PUSH1 0x00
	1420    85  DUP6
	1421    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1436    16  AND
	1437    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	144C    16  AND
	144D    81  DUP2
	144E    52  MSTORE
	144F    60  PUSH1 0x20
	1451    01  ADD
	1452    90  SWAP1
	1453    81  DUP2
	1454    52  MSTORE
	1455    60  PUSH1 0x20
	1457    01  ADD
	1458    60  PUSH1 0x00
	145A    20  SHA3
	145B    81  DUP2
	145C    90  SWAP1
	145D    55  SSTORE
	145E    50  POP
	145F    82  DUP3
	1460    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1475    16  AND
	1476    33  CALLER
	1477    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	148C    16  AND
	148D    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	14AE    84  DUP5
	14AF    60  PUSH1 0x40
	14B1    51  MLOAD
	14B2    80  DUP1
	14B3    82  DUP3
	14B4    81  DUP2
	14B5    52  MSTORE
	14B6    60  PUSH1 0x20
	14B8    01  ADD
	14B9    91  SWAP2
	14BA    50  POP
	14BB    50  POP
	14BC    60  PUSH1 0x40
	14BE    51  MLOAD
	14BF    80  DUP1
	14C0    91  SWAP2
	14C1    03  SUB
	14C2    90  SWAP1
	14C3    A3  LOG3
	14C4    60  PUSH1 0x01
	14C6    90  SWAP1
	14C7    50  POP
	14C8    92  SWAP3
	14C9    91  SWAP2
	14CA    50  POP
	14CB    50  POP
	14CC    56  *JUMP
	// Stack delta = -4
	// Outputs[6]
	// {
	//     @144E  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @1454  memory[0x20:0x40] = 0x07
	//     @145D  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @14B5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3]
	//     @14C3  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]);
	//     @14C8  stack[-5] = 0x01
	// }
	// Block ends with unconditional jump to stack[-5]

label_14CD:
	// Incoming jump from 0x0654
	// Inputs[2]
	// {
	//     @14CE  msg.sender
	//     @14E9  storage[0x00]
	// }
	14CD    5B  JUMPDEST
	14CE    33  CALLER
	14CF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	14E4    16  AND
	14E5    60  PUSH1 0x00
	14E7    80  DUP1
	14E8    90  SWAP1
	14E9    54  SLOAD
	14EA    90  SWAP1
	14EB    61  PUSH2 0x0100
	14EE    0A  EXP
	14EF    90  SWAP1
	14F0    04  DIV
	14F1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1506    16  AND
	1507    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	151C    16  AND
	151D    14  EQ
	151E    61  PUSH2 0x158f
	1521    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x158f, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender

label_1522:
	// Incoming jump from 0x1521, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[3]
	// {
	//     @1524  memory[0x40:0x60]
	//     @1589  memory[0x40:0x60]
	//     @158E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	1522    60  PUSH1 0x40
	1524    51  MLOAD
	1525    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	1546    81  DUP2
	1547    52  MSTORE
	1548    60  PUSH1 0x04
	154A    01  ADD
	154B    80  DUP1
	154C    80  DUP1
	154D    60  PUSH1 0x20
	154F    01  ADD
	1550    82  DUP3
	1551    81  DUP2
	1552    03  SUB
	1553    82  DUP3
	1554    52  MSTORE
	1555    60  PUSH1 0x20
	1557    81  DUP2
	1558    52  MSTORE
	1559    60  PUSH1 0x20
	155B    01  ADD
	155C    80  DUP1
	155D    7F  PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	157E    81  DUP2
	157F    52  MSTORE
	1580    50  POP
	1581    60  PUSH1 0x20
	1583    01  ADD
	1584    91  SWAP2
	1585    50  POP
	1586    50  POP
	1587    60  PUSH1 0x40
	1589    51  MLOAD
	158A    80  DUP1
	158B    91  SWAP2
	158C    03  SUB
	158D    90  SWAP1
	158E    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @1547  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @1554  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @1558  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20
	//     @157F  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572
	//     @158E  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_158F:
	// Incoming jump from 0x1521, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	// Inputs[5]
	// {
	//     @1590  stack[-1]
	//     @1595  stack[-2]
	//     @15CF  memory[0x00:0x40]
	//     @15D7  storage[keccak256(memory[0x00:0x40])]
	//     @15E9  stack[-3]
	// }
	158F    5B  JUMPDEST
	1590    80  DUP1
	1591    60  PUSH1 0x08
	1593    60  PUSH1 0x00
	1595    84  DUP5
	1596    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	15AB    16  AND
	15AC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	15C1    16  AND
	15C2    81  DUP2
	15C3    52  MSTORE
	15C4    60  PUSH1 0x20
	15C6    01  ADD
	15C7    90  SWAP1
	15C8    81  DUP2
	15C9    52  MSTORE
	15CA    60  PUSH1 0x20
	15CC    01  ADD
	15CD    60  PUSH1 0x00
	15CF    20  SHA3
	15D0    60  PUSH1 0x00
	15D2    61  PUSH2 0x0100
	15D5    0A  EXP
	15D6    81  DUP2
	15D7    54  SLOAD
	15D8    81  DUP2
	15D9    60  PUSH1 0xff
	15DB    02  MUL
	15DC    19  NOT
	15DD    16  AND
	15DE    90  SWAP1
	15DF    83  DUP4
	15E0    15  ISZERO
	15E1    15  ISZERO
	15E2    02  MUL
	15E3    17  OR
	15E4    90  SWAP1
	15E5    55  SSTORE
	15E6    50  POP
	15E7    50  POP
	15E8    50  POP
	15E9    56  *JUMP
	// Stack delta = -3
	// Outputs[3]
	// {
	//     @15C3  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @15C9  memory[0x20:0x40] = 0x08
	//     @15E5  storage[keccak256(memory[0x00:0x40])] = !!stack[-1] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])])
	// }
	// Block ends with unconditional jump to stack[-3]

label_15EA:
	// Incoming jump from 0x06B8
	// Inputs[6]
	// {
	//     @15F1  stack[-2]
	//     @162B  memory[0x00:0x40]
	//     @162E  stack[-1]
	//     @1668  memory[0x00:0x40]
	//     @1669  storage[keccak256(memory[0x00:0x40])]
	//     @166C  stack[-3]
	// }
	15EA    5B  JUMPDEST
	15EB    60  PUSH1 0x00
	15ED    60  PUSH1 0x09
	15EF    60  PUSH1 0x00
	15F1    84  DUP5
	15F2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1607    16  AND
	1608    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	161D    16  AND
	161E    81  DUP2
	161F    52  MSTORE
	1620    60  PUSH1 0x20
	1622    01  ADD
	1623    90  SWAP1
	1624    81  DUP2
	1625    52  MSTORE
	1626    60  PUSH1 0x20
	1628    01  ADD
	1629    60  PUSH1 0x00
	162B    20  SHA3
	162C    60  PUSH1 0x00
	162E    83  DUP4
	162F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1644    16  AND
	1645    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	165A    16  AND
	165B    81  DUP2
	165C    52  MSTORE
	165D    60  PUSH1 0x20
	165F    01  ADD
	1660    90  SWAP1
	1661    81  DUP2
	1662    52  MSTORE
	1663    60  PUSH1 0x20
	1665    01  ADD
	1666    60  PUSH1 0x00
	1668    20  SHA3
	1669    54  SLOAD
	166A    90  SWAP1
	166B    50  POP
	166C    92  SWAP3
	166D    91  SWAP2
	166E    50  POP
	166F    50  POP
	1670    56  *JUMP
	// Stack delta = -2
	// Outputs[5]
	// {
	//     @161F  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @1625  memory[0x20:0x40] = 0x09
	//     @165C  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	//     @1662  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @166C  stack[-3] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-3]

label_1671:
	// Incoming call from 0x06D6, returns to 0x06D7
	// Inputs[2]
	// {
	//     @1674  storage[0x0a]
	//     @1675  stack[-1]
	// }
	1671    5B  JUMPDEST
	1672    60  PUSH1 0x0a
	1674    54  SLOAD
	1675    81  DUP2
	1676    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1674  stack[0] = storage[0x0a] }
	// Block ends with unconditional jump to stack[-1]

label_1677:
	// Incoming jump from 0x072E
	// Inputs[4]
	// {
	//     @167D  stack[-1]
	//     @1685  memory[0x00:0x40]
	//     @168A  storage[keccak256(memory[0x00:0x40])]
	//     @1695  stack[-2]
	// }
	1677    5B  JUMPDEST
	1678    60  PUSH1 0x08
	167A    60  PUSH1 0x20
	167C    52  MSTORE
	167D    80  DUP1
	167E    60  PUSH1 0x00
	1680    52  MSTORE
	1681    60  PUSH1 0x40
	1683    60  PUSH1 0x00
	1685    20  SHA3
	1686    60  PUSH1 0x00
	1688    91  SWAP2
	1689    50  POP
	168A    54  SLOAD
	168B    90  SWAP1
	168C    61  PUSH2 0x0100
	168F    0A  EXP
	1690    90  SWAP1
	1691    04  DIV
	1692    60  PUSH1 0xff
	1694    16  AND
	1695    81  DUP2
	1696    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @167C  memory[0x20:0x40] = 0x08
	//     @1680  memory[0x00:0x20] = stack[-1]
	//     @1694  stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00
	// }
	// Block ends with unconditional jump to stack[-2]

label_1697:
	// Incoming call from 0x0A4D, returns to 0x0A4E
	// Incoming call from 0x1798, returns to 0x1799
	// Inputs[3]
	// {
	//     @169A  stack[-3]
	//     @169B  stack[-2]
	//     @169E  stack[-1]
	// }
	1697    5B  JUMPDEST
	1698    60  PUSH1 0x00
	169A    83  DUP4
	169B    83  DUP4
	169C    11  GT
	169D    15  ISZERO
	169E    82  DUP3
	169F    90  SWAP1
	16A0    61  PUSH2 0x1744
	16A3    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @1698  stack[0] = 0x00
	//     @169F  stack[1] = stack[-1]
	// }
	// Block ends with conditional jump to 0x1744, if !(stack[-2] > stack[-3])

label_16A4:
	// Incoming jump from 0x16A3, if not !(stack[-2] > stack[-3])
	// Inputs[4]
	// {
	//     @16A6  memory[0x40:0x60]
	//     @16D7  stack[-1]
	//     @16DA  memory[stack[-1]:stack[-1] + 0x20]
	//     @16E3  memory[stack[-1]:stack[-1] + 0x20]
	// }
	16A4    60  PUSH1 0x40
	16A6    51  MLOAD
	16A7    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	16C8    81  DUP2
	16C9    52  MSTORE
	16CA    60  PUSH1 0x04
	16CC    01  ADD
	16CD    80  DUP1
	16CE    80  DUP1
	16CF    60  PUSH1 0x20
	16D1    01  ADD
	16D2    82  DUP3
	16D3    81  DUP2
	16D4    03  SUB
	16D5    82  DUP3
	16D6    52  MSTORE
	16D7    83  DUP4
	16D8    81  DUP2
	16D9    81  DUP2
	16DA    51  MLOAD
	16DB    81  DUP2
	16DC    52  MSTORE
	16DD    60  PUSH1 0x20
	16DF    01  ADD
	16E0    91  SWAP2
	16E1    50  POP
	16E2    80  DUP1
	16E3    51  MLOAD
	16E4    90  SWAP1
	16E5    60  PUSH1 0x20
	16E7    01  ADD
	16E8    90  SWAP1
	16E9    80  DUP1
	16EA    83  DUP4
	16EB    83  DUP4
	16EC    60  PUSH1 0x00
	16EE    5B  JUMPDEST
	16EF    83  DUP4
	16F0    81  DUP2
	16F1    10  LT
	16F2    15  ISZERO
	16F3    61  PUSH2 0x1709
	16F6    57  *JUMPI
	// Stack delta = +9
	// Outputs[12]
	// {
	//     @16C9  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @16CC  stack[0] = 0x04 + memory[0x40:0x60]
	//     @16CD  stack[1] = 0x04 + memory[0x40:0x60]
	//     @16D6  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @16DC  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @16E0  stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @16E8  stack[3] = 0x20 + stack[-1]
	//     @16E8  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @16E9  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @16EA  stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @16EB  stack[7] = 0x20 + stack[-1]
	//     @16EC  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x1709, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_16F7:
	// Incoming jump from 0x16F6, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x16F6, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @16F7  stack[-1]
	//     @16F8  stack[-2]
	//     @16FA  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @16FC  stack[-3]
	// }
	16F7    80  DUP1
	16F8    82  DUP3
	16F9    01  ADD
	16FA    51  MLOAD
	16FB    81  DUP2
	16FC    84  DUP5
	16FD    01  ADD
	16FE    52  MSTORE
	16FF    60  PUSH1 0x20
	1701    81  DUP2
	1702    01  ADD
	1703    90  SWAP1
	1704    50  POP
	1705    61  PUSH2 0x16ee
	1708    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @16FE  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1703  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x16ee

label_1709:
	// Incoming jump from 0x16F6, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x16F6, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @170E  stack[-6]
	//     @170E  stack[-5]
	//     @1710  stack[-7]
	// }
	1709    5B  JUMPDEST
	170A    50  POP
	170B    50  POP
	170C    50  POP
	170D    50  POP
	170E    90  SWAP1
	170F    50  POP
	1710    90  SWAP1
	1711    81  DUP2
	1712    01  ADD
	1713    90  SWAP1
	1714    60  PUSH1 0x1f
	1716    16  AND
	1717    80  DUP1
	1718    15  ISZERO
	1719    61  PUSH2 0x1736
	171C    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1713  stack[-7] = stack[-5] + stack[-7]
	//     @1716  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x1736, if !(0x1f & stack[-5])

label_171D:
	// Incoming jump from 0x171C, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @171D  stack[-1]
	//     @171E  stack[-2]
	//     @1721  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1738  stack[-5]
	//     @173E  memory[0x40:0x60]
	//     @1743  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	171D    80  DUP1
	171E    82  DUP3
	171F    03  SUB
	1720    80  DUP1
	1721    51  MLOAD
	1722    60  PUSH1 0x01
	1724    83  DUP4
	1725    60  PUSH1 0x20
	1727    03  SUB
	1728    61  PUSH2 0x0100
	172B    0A  EXP
	172C    03  SUB
	172D    19  NOT
	172E    16  AND
	172F    81  DUP2
	1730    52  MSTORE
	1731    60  PUSH1 0x20
	1733    01  ADD
	1734    91  SWAP2
	1735    50  POP
	1736    5B  JUMPDEST
	1737    50  POP
	1738    92  SWAP3
	1739    50  POP
	173A    50  POP
	173B    50  POP
	173C    60  PUSH1 0x40
	173E    51  MLOAD
	173F    80  DUP1
	1740    91  SWAP2
	1741    03  SUB
	1742    90  SWAP1
	1743    FD  *REVERT
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1730  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1743  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_1744:
	// Incoming jump from 0x16A3, if !(stack[-2] > stack[-3])
	// Inputs[4]
	// {
	//     @1748  stack[-4]
	//     @1749  stack[-5]
	//     @174E  stack[-2]
	//     @1751  stack[-6]
	// }
	1744    5B  JUMPDEST
	1745    50  POP
	1746    60  PUSH1 0x00
	1748    83  DUP4
	1749    85  DUP6
	174A    03  SUB
	174B    90  SWAP1
	174C    50  POP
	174D    80  DUP1
	174E    91  SWAP2
	174F    50  POP
	1750    50  POP
	1751    93  SWAP4
	1752    92  SWAP3
	1753    50  POP
	1754    50  POP
	1755    50  POP
	1756    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @1751  stack[-6] = stack[-5] - stack[-4] }
	// Block ends with unconditional jump to stack[-6]

label_1757:
	// Incoming call from 0x1385, returns to 0x1386
	// Incoming call from 0x0C73, returns to 0x0C74
	// Incoming call from 0x0AA3, returns to 0x0AA4
	// Incoming call from 0x0DDA, returns to 0x0DDB
	// Inputs[3]
	// {
	//     @175D  stack[-2]
	//     @175E  stack[-1]
	//     @1761  memory[0x40:0x60]
	// }
	1757    5B  JUMPDEST
	1758    60  PUSH1 0x00
	175A    61  PUSH2 0x1799
	175D    83  DUP4
	175E    83  DUP4
	175F    60  PUSH1 0x40
	1761    51  MLOAD
	1762    80  DUP1
	1763    60  PUSH1 0x40
	1765    01  ADD
	1766    60  PUSH1 0x40
	1768    52  MSTORE
	1769    80  DUP1
	176A    60  PUSH1 0x1e
	176C    81  DUP2
	176D    52  MSTORE
	176E    60  PUSH1 0x20
	1770    01  ADD
	1771    7F  PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000
	1792    81  DUP2
	1793    52  MSTORE
	1794    50  POP
	1795    61  PUSH2 0x1697
	1798    56  *JUMP
	// Stack delta = +5
	// Outputs[8]
	// {
	//     @1758  stack[0] = 0x00
	//     @175A  stack[1] = 0x1799
	//     @175D  stack[2] = stack[-2]
	//     @175E  stack[3] = stack[-1]
	//     @1761  stack[4] = memory[0x40:0x60]
	//     @1768  memory[0x40:0x60] = 0x40 + memory[0x40:0x60]
	//     @176D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e
	//     @1793  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000
	// }
	// Block ends with call to 0x1697, returns to 0x1799

label_1799:
	// Incoming return from call to 0x1697 at 0x1798
	// Inputs[4]
	// {
	//     @179A  stack[-1]
	//     @179A  stack[-2]
	//     @179C  stack[-5]
	//     @179D  stack[-4]
	// }
	1799    5B  JUMPDEST
	179A    90  SWAP1
	179B    50  POP
	179C    92  SWAP3
	179D    91  SWAP2
	179E    50  POP
	179F    50  POP
	17A0    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @179C  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_17A1:
	// Incoming call from 0x141A, returns to 0x141B
	// Incoming call from 0x0D08, returns to 0x0D09
	// Inputs[2]
	// {
	//     @17A5  stack[-1]
	//     @17A6  stack[-2]
	// }
	17A1    5B  JUMPDEST
	17A2    60  PUSH1 0x00
	17A4    80  DUP1
	17A5    82  DUP3
	17A6    84  DUP5
	17A7    01  ADD
	17A8    90  SWAP1
	17A9    50  POP
	17AA    83  DUP4
	17AB    81  DUP2
	17AC    10  LT
	17AD    15  ISZERO
	17AE    61  PUSH2 0x181f
	17B1    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @17A2  stack[0] = 0x00
	//     @17A8  stack[1] = stack[-2] + stack[-1]
	// }
	// Block ends with conditional jump to 0x181f, if !(stack[-2] + stack[-1] < stack[-2])

label_17B2:
	// Incoming jump from 0x17B1, if not !(stack[-2] + stack[-1] < stack[-2])
	// Inputs[3]
	// {
	//     @17B4  memory[0x40:0x60]
	//     @1819  memory[0x40:0x60]
	//     @181E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	17B2    60  PUSH1 0x40
	17B4    51  MLOAD
	17B5    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	17D6    81  DUP2
	17D7    52  MSTORE
	17D8    60  PUSH1 0x04
	17DA    01  ADD
	17DB    80  DUP1
	17DC    80  DUP1
	17DD    60  PUSH1 0x20
	17DF    01  ADD
	17E0    82  DUP3
	17E1    81  DUP2
	17E2    03  SUB
	17E3    82  DUP3
	17E4    52  MSTORE
	17E5    60  PUSH1 0x1b
	17E7    81  DUP2
	17E8    52  MSTORE
	17E9    60  PUSH1 0x20
	17EB    01  ADD
	17EC    80  DUP1
	17ED    7F  PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000
	180E    81  DUP2
	180F    52  MSTORE
	1810    50  POP
	1811    60  PUSH1 0x20
	1813    01  ADD
	1814    91  SWAP2
	1815    50  POP
	1816    50  POP
	1817    60  PUSH1 0x40
	1819    51  MLOAD
	181A    80  DUP1
	181B    91  SWAP2
	181C    03  SUB
	181D    90  SWAP1
	181E    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @17D7  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @17E4  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @17E8  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b
	//     @180F  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000
	//     @181E  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_181F:
	// Incoming jump from 0x17B1, if !(stack[-2] + stack[-1] < stack[-2])
	// Inputs[4]
	// {
	//     @1820  stack[-1]
	//     @1821  stack[-2]
	//     @1824  stack[-5]
	//     @1825  stack[-4]
	// }
	181F    5B  JUMPDEST
	1820    80  DUP1
	1821    91  SWAP2
	1822    50  POP
	1823    50  POP
	1824    92  SWAP3
	1825    91  SWAP2
	1826    50  POP
	1827    50  POP
	1828    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @1824  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_1829:
	// Incoming call from 0x1293, returns to 0x1294
	// Inputs[1] { @182D  stack[-2] }
	1829    5B  JUMPDEST
	182A    60  PUSH1 0x00
	182C    80  DUP1
	182D    83  DUP4
	182E    14  EQ
	182F    15  ISZERO
	1830    61  PUSH2 0x183c
	1833    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @182A  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x183c, if !(stack[-2] == 0x00)

label_1834:
	// Incoming jump from 0x1833, if not !(stack[-2] == 0x00)
	// Inputs[1] { @1836  stack[-1] }
	1834    60  PUSH1 0x00
	1836    90  SWAP1
	1837    50  POP
	1838    61  PUSH2 0x18a9
	183B    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @1836  stack[-1] = 0x00 }
	// Block ends with unconditional jump to 0x18a9

label_183C:
	// Incoming jump from 0x1833, if !(stack[-2] == 0x00)
	// Inputs[2]
	// {
	//     @183F  stack[-2]
	//     @1840  stack[-3]
	// }
	183C    5B  JUMPDEST
	183D    60  PUSH1 0x00
	183F    82  DUP3
	1840    84  DUP5
	1841    02  MUL
	1842    90  SWAP1
	1843    50  POP
	1844    82  DUP3
	1845    84  DUP5
	1846    82  DUP3
	1847    81  DUP2
	1848    61  PUSH2 0x184d
	184B    57  *JUMPI
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @1842  stack[0] = stack[-3] * stack[-2]
	//     @1844  stack[1] = stack[-2]
	//     @1845  stack[2] = stack[-3]
	//     @1846  stack[3] = stack[-3] * stack[-2]
	// }
	// Block ends with conditional jump to 0x184d, if stack[-3]

label_184C:
	// Incoming jump from 0x184B, if not stack[-3]
	184C    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @184C  assert(); }
	// Block terminates

label_184D:
	// Incoming jump from 0x184B, if stack[-3]
	// Inputs[3]
	// {
	//     @184E  stack[-2]
	//     @184E  stack[-1]
	//     @184F  stack[-3]
	// }
	184D    5B  JUMPDEST
	184E    04  DIV
	184F    14  EQ
	1850    61  PUSH2 0x18a4
	1853    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x18a4, if stack[-1] / stack[-2] == stack[-3]

label_1854:
	// Incoming jump from 0x1853, if not stack[-1] / stack[-2] == stack[-3]
	// Inputs[3]
	// {
	//     @1856  memory[0x40:0x60]
	//     @189E  memory[0x40:0x60]
	//     @18A3  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	1854    60  PUSH1 0x40
	1856    51  MLOAD
	1857    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	1878    81  DUP2
	1879    52  MSTORE
	187A    60  PUSH1 0x04
	187C    01  ADD
	187D    80  DUP1
	187E    80  DUP1
	187F    60  PUSH1 0x20
	1881    01  ADD
	1882    82  DUP3
	1883    81  DUP2
	1884    03  SUB
	1885    82  DUP3
	1886    52  MSTORE
	1887    60  PUSH1 0x21
	1889    81  DUP2
	188A    52  MSTORE
	188B    60  PUSH1 0x20
	188D    01  ADD
	188E    80  DUP1
	188F    61  PUSH2 0x1a0e
	1892    60  PUSH1 0x21
	1894    91  SWAP2
	1895    39  CODECOPY
	1896    60  PUSH1 0x40
	1898    01  ADD
	1899    91  SWAP2
	189A    50  POP
	189B    50  POP
	189C    60  PUSH1 0x40
	189E    51  MLOAD
	189F    80  DUP1
	18A0    91  SWAP2
	18A1    03  SUB
	18A2    90  SWAP1
	18A3    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @1879  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @1886  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @188A  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21
	//     @1895  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x1a0e:0x1a2f]
	//     @18A3  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_18A4:
	// Incoming jump from 0x1853, if stack[-1] / stack[-2] == stack[-3]
	// Inputs[2]
	// {
	//     @18A5  stack[-1]
	//     @18A6  stack[-2]
	// }
	18A4    5B  JUMPDEST
	18A5    80  DUP1
	18A6    91  SWAP2
	18A7    50  POP
	18A8    50  POP
	// Stack delta = -1
	// Outputs[1] { @18A6  stack[-2] = stack[-1] }
	// Block continues

label_18A9:
	// Incoming jump from 0x183B
	// Incoming jump from 0x18A8
	// Inputs[3]
	// {
	//     @18AA  stack[-1]
	//     @18AA  stack[-4]
	//     @18AB  stack[-3]
	// }
	18A9    5B  JUMPDEST
	18AA    92  SWAP3
	18AB    91  SWAP2
	18AC    50  POP
	18AD    50  POP
	18AE    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @18AA  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_18AF:
	// Incoming jump from 0x12A1
	// Inputs[3]
	// {
	//     @18B5  stack[-2]
	//     @18B6  stack[-1]
	//     @18B9  memory[0x40:0x60]
	// }
	18AF    5B  JUMPDEST
	18B0    60  PUSH1 0x00
	18B2    61  PUSH2 0x18f1
	18B5    83  DUP4
	18B6    83  DUP4
	18B7    60  PUSH1 0x40
	18B9    51  MLOAD
	18BA    80  DUP1
	18BB    60  PUSH1 0x40
	18BD    01  ADD
	18BE    60  PUSH1 0x40
	18C0    52  MSTORE
	18C1    80  DUP1
	18C2    60  PUSH1 0x1a
	18C4    81  DUP2
	18C5    52  MSTORE
	18C6    60  PUSH1 0x20
	18C8    01  ADD
	18C9    7F  PUSH32 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000
	18EA    81  DUP2
	18EB    52  MSTORE
	18EC    50  POP
	18ED    61  PUSH2 0x18f9
	18F0    56  *JUMP
	// Stack delta = +5
	// Outputs[8]
	// {
	//     @18B0  stack[0] = 0x00
	//     @18B2  stack[1] = 0x18f1
	//     @18B5  stack[2] = stack[-2]
	//     @18B6  stack[3] = stack[-1]
	//     @18B9  stack[4] = memory[0x40:0x60]
	//     @18C0  memory[0x40:0x60] = 0x40 + memory[0x40:0x60]
	//     @18C5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1a
	//     @18EB  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000
	// }
	// Block ends with call to 0x18f9, returns to 0x18F1

label_18F1:
	// Incoming return from call to 0x18F9 at 0x18F0
	// Inputs[4]
	// {
	//     @18F2  stack[-2]
	//     @18F2  stack[-1]
	//     @18F4  stack[-5]
	//     @18F5  stack[-4]
	// }
	18F1    5B  JUMPDEST
	18F2    90  SWAP1
	18F3    50  POP
	18F4    92  SWAP3
	18F5    91  SWAP2
	18F6    50  POP
	18F7    50  POP
	18F8    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @18F4  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_18F9:
	// Incoming call from 0x18F0, returns to 0x18F1
	// Inputs[2]
	// {
	//     @18FD  stack[-2]
	//     @18FF  stack[-1]
	// }
	18F9    5B  JUMPDEST
	18FA    60  PUSH1 0x00
	18FC    80  DUP1
	18FD    83  DUP4
	18FE    11  GT
	18FF    82  DUP3
	1900    90  SWAP1
	1901    61  PUSH2 0x19a5
	1904    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @18FA  stack[0] = 0x00
	//     @1900  stack[1] = stack[-1]
	// }
	// Block ends with conditional jump to 0x19a5, if stack[-2] > 0x00

label_1905:
	// Incoming jump from 0x1904, if not stack[-2] > 0x00
	// Inputs[4]
	// {
	//     @1907  memory[0x40:0x60]
	//     @1938  stack[-1]
	//     @193B  memory[stack[-1]:stack[-1] + 0x20]
	//     @1944  memory[stack[-1]:stack[-1] + 0x20]
	// }
	1905    60  PUSH1 0x40
	1907    51  MLOAD
	1908    7F  PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
	1929    81  DUP2
	192A    52  MSTORE
	192B    60  PUSH1 0x04
	192D    01  ADD
	192E    80  DUP1
	192F    80  DUP1
	1930    60  PUSH1 0x20
	1932    01  ADD
	1933    82  DUP3
	1934    81  DUP2
	1935    03  SUB
	1936    82  DUP3
	1937    52  MSTORE
	1938    83  DUP4
	1939    81  DUP2
	193A    81  DUP2
	193B    51  MLOAD
	193C    81  DUP2
	193D    52  MSTORE
	193E    60  PUSH1 0x20
	1940    01  ADD
	1941    91  SWAP2
	1942    50  POP
	1943    80  DUP1
	1944    51  MLOAD
	1945    90  SWAP1
	1946    60  PUSH1 0x20
	1948    01  ADD
	1949    90  SWAP1
	194A    80  DUP1
	194B    83  DUP4
	194C    83  DUP4
	194D    60  PUSH1 0x00
	194F    5B  JUMPDEST
	1950    83  DUP4
	1951    81  DUP2
	1952    10  LT
	1953    15  ISZERO
	1954    61  PUSH2 0x196a
	1957    57  *JUMPI
	// Stack delta = +9
	// Outputs[12]
	// {
	//     @192A  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000
	//     @192D  stack[0] = 0x04 + memory[0x40:0x60]
	//     @192E  stack[1] = 0x04 + memory[0x40:0x60]
	//     @1937  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @193D  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @1941  stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @1949  stack[3] = 0x20 + stack[-1]
	//     @1949  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @194A  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @194B  stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @194C  stack[7] = 0x20 + stack[-1]
	//     @194D  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x196a, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_1958:
	// Incoming jump from 0x1957, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x1957, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @1958  stack[-1]
	//     @1959  stack[-2]
	//     @195B  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @195D  stack[-3]
	// }
	1958    80  DUP1
	1959    82  DUP3
	195A    01  ADD
	195B    51  MLOAD
	195C    81  DUP2
	195D    84  DUP5
	195E    01  ADD
	195F    52  MSTORE
	1960    60  PUSH1 0x20
	1962    81  DUP2
	1963    01  ADD
	1964    90  SWAP1
	1965    50  POP
	1966    61  PUSH2 0x194f
	1969    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @195F  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1964  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x194f

label_196A:
	// Incoming jump from 0x1957, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x1957, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @196F  stack[-6]
	//     @196F  stack[-5]
	//     @1971  stack[-7]
	// }
	196A    5B  JUMPDEST
	196B    50  POP
	196C    50  POP
	196D    50  POP
	196E    50  POP
	196F    90  SWAP1
	1970    50  POP
	1971    90  SWAP1
	1972    81  DUP2
	1973    01  ADD
	1974    90  SWAP1
	1975    60  PUSH1 0x1f
	1977    16  AND
	1978    80  DUP1
	1979    15  ISZERO
	197A    61  PUSH2 0x1997
	197D    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1974  stack[-7] = stack[-5] + stack[-7]
	//     @1977  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x1997, if !(0x1f & stack[-5])

label_197E:
	// Incoming jump from 0x197D, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @197E  stack[-1]
	//     @197F  stack[-2]
	//     @1982  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1999  stack[-5]
	//     @199F  memory[0x40:0x60]
	//     @19A4  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	197E    80  DUP1
	197F    82  DUP3
	1980    03  SUB
	1981    80  DUP1
	1982    51  MLOAD
	1983    60  PUSH1 0x01
	1985    83  DUP4
	1986    60  PUSH1 0x20
	1988    03  SUB
	1989    61  PUSH2 0x0100
	198C    0A  EXP
	198D    03  SUB
	198E    19  NOT
	198F    16  AND
	1990    81  DUP2
	1991    52  MSTORE
	1992    60  PUSH1 0x20
	1994    01  ADD
	1995    91  SWAP2
	1996    50  POP
	1997    5B  JUMPDEST
	1998    50  POP
	1999    92  SWAP3
	199A    50  POP
	199B    50  POP
	199C    50  POP
	199D    60  PUSH1 0x40
	199F    51  MLOAD
	19A0    80  DUP1
	19A1    91  SWAP2
	19A2    03  SUB
	19A3    90  SWAP1
	19A4    FD  *REVERT
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1991  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @19A4  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_19A5:
	// Incoming jump from 0x1904, if stack[-2] > 0x00
	// Inputs[2]
	// {
	//     @19A9  stack[-4]
	//     @19AA  stack[-5]
	// }
	19A5    5B  JUMPDEST
	19A6    50  POP
	19A7    60  PUSH1 0x00
	19A9    83  DUP4
	19AA    85  DUP6
	19AB    81  DUP2
	19AC    61  PUSH2 0x19b1
	19AF    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @19A7  stack[-1] = 0x00
	//     @19A9  stack[0] = stack[-4]
	//     @19AA  stack[1] = stack[-5]
	// }
	// Block ends with conditional jump to 0x19b1, if stack[-4]

label_19B0:
	// Incoming jump from 0x19AF, if not stack[-4]
	19B0    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @19B0  assert(); }
	// Block terminates

label_19B1:
	// Incoming jump from 0x19AF, if stack[-4]
	// Inputs[6]
	// {
	//     @19B2  stack[-2]
	//     @19B2  stack[-1]
	//     @19B3  stack[-3]
	//     @19B6  stack[-4]
	//     @19B9  stack[-8]
	//     @19BA  stack[-7]
	// }
	19B1    5B  JUMPDEST
	19B2    04  DIV
	19B3    90  SWAP1
	19B4    50  POP
	19B5    80  DUP1
	19B6    91  SWAP2
	19B7    50  POP
	19B8    50  POP
	19B9    93  SWAP4
	19BA    92  SWAP3
	19BB    50  POP
	19BC    50  POP
	19BD    50  POP
	19BE    56  *JUMP
	// Stack delta = -7
	// Outputs[1] { @19B9  stack[-8] = stack[-1] / stack[-2] }
	// Block ends with unconditional jump to stack[-8]

	19BF    FE    *ASSERT
	19C0    45    GASLIMIT
	19C1    52    MSTORE
	19C2    43    NUMBER
	19C3    32    ORIGIN
	19C4    30    ADDRESS
	19C5    3A    GASPRICE
	19C6    20    SHA3
	19C7    62    PUSH3 0x75726e
	19CB    20    SHA3
	19CC    61    PUSH2 0x6d6f
	19CF    75    PUSH22 0x6e7420657863656564732062616c616e636545524332
	19E6    30    ADDRESS
	19E7    3A    GASPRICE
	19E8    20    SHA3
	19E9    62    PUSH3 0x75726e
	19ED    20    SHA3
	19EE    66    PUSH7 0x726f6d20746865
	19F6    20    SHA3
	19F7    7A    PUSH27 0x65726f206164647265737320646973616c6c6f776564536166654d
	1A13    61    PUSH2 0x7468
	1A16    3A    GASPRICE
	1A17    20    SHA3
	1A18    6D    PUSH14 0x756c7469706c69636174696f6e20
	1A27    6F    PUSH16 0x766572666c6f77a26469706673582212
	1A38    20    SHA3
	1A39    F9    F9
	1A3A    01    ADD
	1A3B    CC    CC
	1A3C    D6    D6
	1A3D    D9    D9
	1A3E    9C    SWAP13
	1A3F    18    XOR
	1A40    B6    B6
	1A41    D5    D5
	1A42    47    SELFBALANCE
	1A43    8F    DUP16
	1A44    25    25
	1A45    4C    4C
	1A46    98    SWAP9
	1A47    AB    AB
	1A48    8B    DUP12
	1A49    96    SWAP7
	1A4A    05    SDIV
	1A4B    26    26
	1A4C    77    PUSH24 0x4c09ad02b559b7398a6faf7564736f6c63430006000033