Online Solidity Decompiler

« Decompile another contract

Address

0xd85d542b541069fcfcd27b55b13b9553b9c79cd3 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x06fdde03 name()

0x095ea7b3 approve(address,uint256)

0x109b1ee6 _mints(address,uint256)

0x18160ddd totalSupply()

0x21a9cf34 setTradeAddress(address)

0x23b872dd transferFrom(address,address,uint256)

0x313ce567 decimals()

0x70a08231 balanceOf(address)

0x8cd8db8a init(uint256,uint256,uint256)

0x95d89b41 symbol()

0xa9059cbb transfer(address,uint256)

0xaa2f5220 batchSend(address[],uint256)

0xd6d2b6ba delegate(address,bytes)

0xdd62ed3e allowance(address,address)

Internal Methods

approve(arg0, arg1) returns (r0)

_mints(arg0, arg1) returns (r0)

setTradeAddress(arg0, arg1) returns (r0)

transferFrom(arg0, arg1) returns (r0)

balanceOf(arg0, arg2) returns (r0)

init(arg0, arg1) returns (r0)

transfer(arg0, arg1) returns (r0)

batchSend(arg0, arg1) returns (r0)

delegate(arg0, arg1)

allowance(arg0, arg2) returns (r0)

name(arg0) returns (r0)

totalSupply(arg0) returns (r0)

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

decimals(arg0) returns (r0)

symbol(arg0) returns (r0)

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

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

func_166F(arg0, arg1) returns (r0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (0x70a08231 > var0) {
            if (0x18160ddd > var0) {
                if (var0 == 0x06fdde03) {
                    // Dispatch table entry for name()
                    var var1 = msg.value;
                
                    if (var1) { revert(memory[0x00:0x00]); }
                
                    var1 = 0x00f7;
                    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_0137:
                        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_0125:
                        var temp8 = var11;
                        memory[var9 + temp8:var9 + temp8 + 0x20] = memory[var10 + temp8:var10 + temp8 + 0x20];
                        var11 = temp8 + 0x20;
                    
                        if (var11 >= var8) { goto label_0137; }
                        else { goto label_0125; }
                    }
                } else if (var0 == 0x095ea7b3) {
                    // Dispatch table entry for approve(address,uint256)
                    var1 = 0x01be;
                    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 == 0x109b1ee6) {
                    // Dispatch table entry for _mints(address,uint256)
                    var1 = msg.value;
                
                    if (var1) { revert(memory[0x00:0x00]); }
                
                    var1 = 0x0231;
                    var2 = 0x04;
                    var3 = msg.data.length - var2;
                
                    if (var3 < 0x40) { revert(memory[0x00:0x00]); }
                
                    var1 = _mints(var2, var3);
                    var temp11 = memory[0x40:0x60];
                    memory[temp11:temp11 + 0x20] = !!var1;
                    var temp12 = memory[0x40:0x60];
                    return memory[temp12:temp12 + (temp11 + 0x20) - temp12];
                } else { revert(memory[0x00:0x00]); }
            } else if (var0 == 0x18160ddd) {
                // Dispatch table entry for totalSupply()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0260;
                var2 = totalSupply();
                var temp13 = memory[0x40:0x60];
                memory[temp13:temp13 + 0x20] = var2;
                var temp14 = memory[0x40:0x60];
                return memory[temp14:temp14 + (temp13 + 0x20) - temp14];
            } else if (var0 == 0x21a9cf34) {
                // Dispatch table entry for setTradeAddress(address)
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x02c5;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var1 = setTradeAddress(var2, var3);
                var temp15 = memory[0x40:0x60];
                memory[temp15:temp15 + 0x20] = !!var1;
                var temp16 = memory[0x40:0x60];
                return memory[temp16:temp16 + (temp15 + 0x20) - temp16];
            } else if (var0 == 0x23b872dd) {
                // Dispatch table entry for transferFrom(address,address,uint256)
                var1 = 0x034b;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x60) { revert(memory[0x00:0x00]); }
            
                var1 = transferFrom(var2, var3);
                var temp17 = memory[0x40:0x60];
                memory[temp17:temp17 + 0x20] = !!var1;
                var temp18 = memory[0x40:0x60];
                return memory[temp18:temp18 + (temp17 + 0x20) - temp18];
            } else if (var0 == 0x313ce567) {
                // Dispatch table entry for decimals()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x037a;
                var2 = decimals();
                var temp19 = memory[0x40:0x60];
                memory[temp19:temp19 + 0x20] = var2;
                var temp20 = memory[0x40:0x60];
                return memory[temp20:temp20 + (temp19 + 0x20) - temp20];
            } else { revert(memory[0x00:0x00]); }
        } else if (0xa9059cbb > var0) {
            if (var0 == 0x70a08231) {
                // Dispatch table entry for balanceOf(address)
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x03df;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var2 = balanceOf(var2, var3);
                var temp21 = memory[0x40:0x60];
                memory[temp21:temp21 + 0x20] = var2;
                var temp22 = memory[0x40:0x60];
                return memory[temp22:temp22 + (temp21 + 0x20) - temp22];
            } else if (var0 == 0x8cd8db8a) {
                // Dispatch table entry for init(uint256,uint256,uint256)
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0442;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x60) { revert(memory[0x00:0x00]); }
            
                var1 = init(var2, var3);
                var temp23 = memory[0x40:0x60];
                memory[temp23:temp23 + 0x20] = !!var1;
                var temp24 = memory[0x40:0x60];
                return memory[temp24:temp24 + (temp23 + 0x20) - temp24];
            } else if (var0 == 0x95d89b41) {
                // Dispatch table entry for symbol()
                var1 = msg.value;
            
                if (var1) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0471;
                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;
                var6 = temp27 + 0x20;
                var7 = memory[temp27:temp27 + 0x20];
                var8 = var7;
                var9 = var5;
                var10 = var6;
                var11 = 0x00;
            
                if (var11 >= var8) {
                label_04B1:
                    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_049F:
                    var temp33 = var11;
                    memory[var9 + temp33:var9 + temp33 + 0x20] = memory[var10 + temp33:var10 + temp33 + 0x20];
                    var11 = temp33 + 0x20;
                
                    if (var11 >= var8) { goto label_04B1; }
                    else { goto label_049F; }
                }
            } else { revert(memory[0x00:0x00]); }
        } else if (var0 == 0xa9059cbb) {
            // Dispatch table entry for transfer(address,uint256)
            var1 = 0x0538;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var1 = transfer(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 if (var0 == 0xaa2f5220) {
            // Dispatch table entry for batchSend(address[],uint256)
            var1 = 0x0612;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var1 = batchSend(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 == 0xd6d2b6ba) {
            // Dispatch table entry for delegate(address,bytes)
            var1 = 0x0705;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            delegate(var2, var3);
            stop();
        } else if (var0 == 0xdd62ed3e) {
            // Dispatch table entry for allowance(address,address)
            var1 = msg.value;
        
            if (var1) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0776;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var2 = allowance(var2, var3);
            var temp38 = memory[0x40:0x60];
            memory[temp38:temp38 + 0x20] = var2;
            var temp39 = memory[0x40:0x60];
            return memory[temp39:temp39 + (temp38 + 0x20) - temp39];
        } 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] = 0x07;
        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 _mints(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 (msg.sender != storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        if (arg1 <= 0x00) {
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x01;
            var temp1 = keccak256(memory[0x00:0x40]);
            storage[temp1] = (storage[temp1] & ~0xff) | 0x01;
            return 0x01;
        } else {
            var temp2 = arg0;
            memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x06;
            storage[keccak256(memory[0x00:0x40])] = arg1 * 0x0a ** 0x12;
            memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x01;
            var temp3 = keccak256(memory[0x00:0x40]);
            storage[temp3] = (storage[temp3] & ~0xff) | 0x01;
            return 0x01;
        }
    }
    
    function setTradeAddress(var arg0, var arg1) returns (var r0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        storage[0x05] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x05] & ~0xffffffffffffffffffffffffffffffffffffffff);
        return 0x01;
    }
    
    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];
        r0 = func_0A7F(arg0, arg1, var0);
        // Error: Could not resolve method call return address!
    }
    
    function balanceOf(var arg0, var arg1) returns (var arg0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        memory[0x20:0x40] = 0x06;
        memory[0x00:0x20] = arg0;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function init(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        var temp1 = temp0 + 0x20;
        arg0 = msg.data[temp0:temp0 + 0x20];
        arg1 = msg.data[temp1:temp1 + 0x20];
        var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20];
        var var1 = 0x00;
    
        if (msg.sender != storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        if (arg1 > 0x00) {
            storage[0x02] = arg1 * 0x0a ** 0x12;
        
            if (var0 > 0x00) {
            label_0E37:
                storage[0x03] = var0 * 0x0a ** 0x12;
                storage[0x04] = arg0;
                return var1;
            } else {
            label_0E31:
                var var2 = 0x00;
                storage[0x03] = var2;
                storage[0x04] = arg0;
                return var1;
            }
        } else {
            var2 = 0x00;
            storage[0x02] = var2;
        
            if (var0 > 0x00) { goto label_0E37; }
            else { goto label_0E31; }
        }
    }
    
    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;
        var var1 = 0x0efe;
        var var2 = msg.sender;
        var var3 = arg0;
        var var4 = arg1;
        return func_0A7F(var2, var3, var4);
    }
    
    function batchSend(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        var temp1 = temp0 + arg1;
        arg1 = temp0;
        arg0 = temp1;
        var var0 = arg1 + 0x20;
        var var1 = msg.data[arg1:arg1 + 0x20];
    
        if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); }
    
        var temp2 = arg1 + var1;
        var1 = temp2;
    
        if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); }
    
        var temp3 = var1;
        var temp4 = msg.data[temp3:temp3 + 0x20];
        var1 = temp4;
        var temp5 = var0;
        var0 = temp3 + 0x20;
        var var2 = temp5;
    
        if ((var1 > 0x0100000000) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); }
    
        var temp6 = var1;
        var temp7 = memory[0x40:0x60];
        memory[0x40:0x60] = temp7 + temp6 * 0x20 + 0x20;
        memory[temp7:temp7 + 0x20] = temp6;
        var temp8 = temp7 + 0x20;
        var temp9 = temp6 * 0x20;
        memory[temp8:temp8 + temp9] = msg.data[var0:var0 + temp9];
        memory[temp8 + temp9:temp8 + temp9 + 0x20] = 0x00;
        arg0 = temp7;
        arg1 = msg.data[var2:var2 + 0x20];
        var0 = 0x00;
    
        if (msg.sender != storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        var temp10 = arg1 * memory[arg0:arg0 + 0x20];
        var1 = temp10;
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x06;
    
        if (storage[keccak256(memory[0x00:0x40])] < var1) { revert(memory[0x00:0x00]); }
    
        memory[0x00:0x20] = msg.sender;
        memory[0x20:0x40] = 0x06;
        var temp11 = keccak256(memory[0x00:0x40]);
        storage[temp11] = storage[temp11] - var1;
        var2 = 0x00;
    
        if (var2 >= memory[arg0:arg0 + 0x20]) {
        label_1163:
            return 0x01;
        } else {
        label_1013:
            var var3 = 0x00;
            var var4 = arg0;
            var var5 = var2;
        
            if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
        
            var temp12 = memory[var5 * 0x20 + 0x20 + var4:var5 * 0x20 + 0x20 + var4 + 0x20];
            var3 = temp12;
            memory[0x00:0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x06;
            var temp13 = keccak256(memory[0x00:0x40]);
            storage[temp13] = storage[temp13] + arg1;
            var4 = var3 & 0xffffffffffffffffffffffffffffffffffffffff;
            var5 = msg.sender;
            var var6 = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
            var var7 = 0x02;
            var var8 = arg1;
        
            if (!var7) { assert(); }
        
            var temp14 = memory[0x40:0x60];
            memory[temp14:temp14 + 0x20] = var8 / var7;
            var temp15 = memory[0x40:0x60];
            log(memory[temp15:temp15 + (temp14 + 0x20) - temp15], [stack[-3], stack[-4], stack[-5]]);
            var4 = var3 & 0xffffffffffffffffffffffffffffffffffffffff;
            var5 = msg.sender;
            var6 = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
            var7 = 0x02;
            var8 = arg1;
        
            if (!var7) { assert(); }
        
            var temp16 = memory[0x40:0x60];
            memory[temp16:temp16 + 0x20] = var8 / var7;
            var temp17 = memory[0x40:0x60];
            log(memory[temp17:temp17 + (temp16 + 0x20) - temp17], [stack[-3], stack[-4], stack[-5]]);
            var2 = var2 + 0x01;
        
            if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_1163; }
            else { goto label_1013; }
        }
    }
    
    function delegate(var arg0, var arg1) {
        var temp0 = arg0;
        var temp1 = temp0 + 0x20;
        arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff;
        arg1 = temp0 + arg1;
        var var0 = temp0;
        var var2 = msg.data[temp1:temp1 + 0x20];
        var var1 = temp1 + 0x20;
    
        if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); }
    
        var temp2 = var0 + var2;
        var2 = temp2;
    
        if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); }
    
        var temp3 = var2;
        var temp4 = msg.data[temp3:temp3 + 0x20];
        var2 = temp4;
        var temp5 = var1;
        var1 = temp3 + 0x20;
        var var3 = temp5;
    
        if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); }
    
        var temp6 = var2;
        var temp7 = memory[0x40:0x60];
        memory[0x40:0x60] = temp7 + (temp6 + 0x1f) / 0x20 * 0x20 + 0x20;
        memory[temp7:temp7 + 0x20] = temp6;
        var temp8 = temp7 + 0x20;
        memory[temp8:temp8 + temp6] = msg.data[var1:var1 + temp6];
        memory[temp8 + temp6:temp8 + temp6 + 0x20] = 0x00;
        arg1 = temp7;
    
        if (msg.sender != storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
        var temp9 = arg1;
        var1 = temp9;
        var2 = memory[0x40:0x60];
        var3 = var2;
        var var4 = var1 + 0x20;
        var var5 = memory[var1:var1 + 0x20];
        var var6 = var5;
        var var7 = var3;
        var var8 = var4;
    
        if (var6 < 0x20) {
        label_1214:
            var temp10 = 0x0100 ** (0x20 - var6) - 0x01;
            var temp11 = var7;
            memory[temp11:temp11 + 0x20] = (memory[var8:var8 + 0x20] & ~temp10) | (memory[temp11:temp11 + 0x20] & temp10);
            var temp12 = memory[0x40:0x60];
            var temp13;
            temp13, memory[temp12:temp12 + 0x00] = address(var0).delegatecall.gas(msg.gas)(memory[temp12:temp12 + (var5 + var3) - temp12]);
            var1 = returndata.length;
            var2 = var1;
        
            if (var2 == 0x00) { return; }
        
            var temp14 = memory[0x40:0x60];
            var1 = temp14;
            memory[0x40:0x60] = var1 + (returndata.length + 0x3f & ~0x1f);
            memory[var1:var1 + 0x20] = returndata.length;
            var temp15 = returndata.length;
            memory[var1 + 0x20:var1 + 0x20 + temp15] = returndata[0x00:0x00 + temp15];
            return;
        } else {
        label_11FA:
            var temp16 = var8;
            var temp17 = var7;
            memory[temp17:temp17 + 0x20] = memory[temp16:temp16 + 0x20];
            var7 = temp17 + 0x20;
            var8 = temp16 + 0x20;
            var6 = var6 - 0x20;
        
            if (var6 < 0x20) { goto label_1214; }
            else { goto label_11FA; }
        }
    }
    
    function allowance(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] = 0x07;
        memory[0x00:0x20] = arg0;
        memory[0x20:0x40] = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = arg1;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function name() returns (var r0) {
        var temp0 = storage[0x09];
        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 = 0x09;
        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_0822:
            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_0819; }
        
        label_0805:
            var temp7 = var4;
            var temp8 = var5;
            memory[temp8:temp8 + 0x20] = storage[temp7];
            var4 = temp7 + 0x01;
            var5 = temp8 + 0x20;
        
            if (var3 > var5) { goto label_0805; }
        
        label_0819:
            var temp9 = var3;
            var temp10 = temp9 + (var5 - temp9 & 0x1f);
            var5 = temp9;
            var3 = temp10;
            goto label_0822;
        } else {
            var temp11 = var3;
            memory[temp11:temp11 + 0x20] = storage[var4] / 0x0100 * 0x0100;
            var5 = var5;
            var3 = temp11 + 0x20;
            goto label_0822;
        }
    }
    
    function totalSupply() returns (var r0) { return storage[0x08]; }
    
    function func_0A7F(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
    
        if (arg2 == var0) {
            var0 = 0x01;
            goto label_0D8B;
        } else if (msg.sender == arg0 & 0xffffffffffffffffffffffffffffffffffffffff) {
        label_0BD9:
            var var1 = 0x0be4;
            var var2 = arg0;
            var var3 = arg1;
            var var4 = arg2;
            var1 = func_12A5(var2, var3, var4);
        
            if (!var1) { revert(memory[0x00:0x00]); }
        
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x06;
        
            if (storage[keccak256(memory[0x00:0x40])] < arg2) { revert(memory[0x00:0x00]); }
        
            var temp0 = arg2;
            var temp1 = arg0;
            memory[0x00:0x20] = temp1 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x06;
            var temp2 = keccak256(memory[0x00:0x40]);
            storage[temp2] = storage[temp2] - temp0;
            var temp3 = arg1;
            memory[0x00:0x20] = temp3 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x06;
            var temp4 = keccak256(memory[0x00:0x40]);
            storage[temp4] = storage[temp4] + temp0;
            memory[0x00:0x20] = temp1 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x00;
            var temp5 = keccak256(memory[0x00:0x40]);
            storage[temp5] = storage[temp5] + 0x01;
            var temp6 = memory[0x40:0x60];
            memory[temp6:temp6 + 0x20] = temp0;
            var temp7 = memory[0x40:0x60];
            log(memory[temp7:temp7 + (temp6 + 0x20) - temp7], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]);
            var0 = 0x01;
        
        label_0D8B:
            return var0;
        } else {
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x07;
            var temp8 = keccak256(memory[0x00:0x40]);
            memory[0x00:0x20] = msg.sender;
            memory[0x20:0x40] = temp8;
        
            if (storage[keccak256(memory[0x00:0x40])] < arg2) { revert(memory[0x00:0x00]); }
        
            memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
            memory[0x20:0x40] = 0x07;
            var temp9 = keccak256(memory[0x00:0x40]);
            memory[0x00:0x20] = msg.sender;
            memory[0x20:0x40] = temp9;
            var temp10 = keccak256(memory[0x00:0x40]);
            storage[temp10] = storage[temp10] - arg2;
            goto label_0BD9;
        }
    }
    
    function decimals() returns (var r0) { return 0x12; }
    
    function symbol() returns (var r0) {
        var temp0 = storage[0x0a];
        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 = 0x0a;
        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_0EE9:
            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_0EE0; }
        
        label_0ECC:
            var temp7 = var4;
            var temp8 = var5;
            memory[temp8:temp8 + 0x20] = storage[temp7];
            var4 = temp7 + 0x01;
            var5 = temp8 + 0x20;
        
            if (var3 > var5) { goto label_0ECC; }
        
        label_0EE0:
            var temp9 = var3;
            var temp10 = temp9 + (var5 - temp9 & 0x1f);
            var5 = temp9;
            var3 = temp10;
            goto label_0EE9;
        } else {
            var temp11 = var3;
            memory[temp11:temp11 + 0x20] = storage[var4] / 0x0100 * 0x0100;
            var3 = temp11 + 0x20;
            var5 = var5;
            goto label_0EE9;
        }
    }
    
    function func_12A5(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = var0;
        var var2 = 0x12db;
        var var3 = 0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f;
        var var4 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2;
        var var5 = address(this);
        var2 = func_14E1(var3, var4, var5);
        var1 = var2;
        var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff;
    
        if (!var2) {
            var2 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff == storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff;
        
            if (var2) { goto label_13D0; }
            else { goto label_138C; }
        } else if (var2) {
        label_13D0:
        
            if (var2) {
            label_1406:
            
                if (var2) {
                label_145E:
                
                    if (var2) {
                    label_14B2:
                    
                        if (!var2) {
                        label_14C1:
                            var2 = 0x14cb;
                            var3 = arg0;
                            var4 = arg2;
                            var2 = func_166F(var3, var4);
                        
                            if (!var2) { revert(memory[0x00:0x00]); }
                        
                            var0 = 0x01;
                        
                        label_14DA:
                            return var0;
                        } else {
                        label_14B8:
                            var0 = 0x01;
                            goto label_14DA;
                        }
                    } else {
                    label_1464:
                        memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
                        memory[0x20:0x40] = 0x01;
                    
                        if (!(storage[keccak256(memory[0x00:0x40])] & 0xff)) { goto label_14C1; }
                        else { goto label_14B8; }
                    }
                } else {
                label_140C:
                    var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff;
                
                    if (var2) { goto label_14B2; }
                    else { goto label_1464; }
                }
            } else {
            label_13D6:
                var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == var1 & 0xffffffffffffffffffffffffffffffffffffffff;
            
                if (var2) { goto label_145E; }
                else { goto label_140C; }
            }
        } else {
        label_138C:
            var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d;
        
            if (var2) { goto label_1406; }
            else { goto label_13D6; }
        }
    }
    
    function func_14E1(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = var0;
        var var2 = 0x00;
    
        if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff < arg2 & 0xffffffffffffffffffffffffffffffffffffffff) {
            var temp0 = memory[0x40:0x60] + 0x20;
            memory[temp0:temp0 + 0x20] = (arg1 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp1 = temp0 + 0x14;
            memory[temp1:temp1 + 0x20] = (arg2 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp2 = temp1 + 0x14;
            var temp3 = memory[0x40:0x60];
            memory[temp3:temp3 + 0x20] = temp2 - temp3 - 0x20;
            memory[0x40:0x60] = temp2;
            var temp4 = keccak256(memory[temp3 + 0x20:temp3 + 0x20 + memory[temp3:temp3 + 0x20]]);
            var temp5 = memory[0x40:0x60] + 0x20;
            memory[temp5:temp5 + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000;
            var temp6 = temp5 + 0x01;
            memory[temp6:temp6 + 0x20] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp7 = temp6 + 0x14;
            memory[temp7:temp7 + 0x20] = temp4;
            var temp8 = temp7 + 0x20;
            memory[temp8:temp8 + 0x20] = 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f;
            var temp9 = temp8 + 0x20;
            var temp10 = memory[0x40:0x60];
            memory[temp10:temp10 + 0x20] = temp9 - temp10 - 0x20;
            memory[0x40:0x60] = temp9;
            return keccak256(memory[temp10 + 0x20:temp10 + 0x20 + memory[temp10:temp10 + 0x20]]) >> 0x00;
        } else {
            var var3 = arg2;
            var var4 = arg1;
            var temp11 = memory[0x40:0x60] + 0x20;
            memory[temp11:temp11 + 0x20] = (var3 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp12 = temp11 + 0x14;
            memory[temp12:temp12 + 0x20] = (var4 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp13 = temp12 + 0x14;
            var temp14 = memory[0x40:0x60];
            memory[temp14:temp14 + 0x20] = temp13 - temp14 - 0x20;
            memory[0x40:0x60] = temp13;
            var temp15 = keccak256(memory[temp14 + 0x20:temp14 + 0x20 + memory[temp14:temp14 + 0x20]]);
            var temp16 = memory[0x40:0x60] + 0x20;
            memory[temp16:temp16 + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000;
            var temp17 = temp16 + 0x01;
            memory[temp17:temp17 + 0x20] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60;
            var temp18 = temp17 + 0x14;
            memory[temp18:temp18 + 0x20] = temp15;
            var temp19 = temp18 + 0x20;
            memory[temp19:temp19 + 0x20] = 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f;
            var temp20 = temp19 + 0x20;
            var temp21 = memory[0x40:0x60];
            memory[temp21:temp21 + 0x20] = temp20 - temp21 - 0x20;
            memory[0x40:0x60] = temp20;
            return keccak256(memory[temp21 + 0x20:temp21 + 0x20 + memory[temp21:temp21 + 0x20]]) >> 0x00;
        }
    }
    
    function func_166F(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var var1 = storage[0x04] == var0;
    
        if (var1) {
            var1 = storage[0x02] == 0x00;
        
            if (!var1) { goto label_1692; }
            else { goto label_168B; }
        } else if (!var1) {
        label_1692:
        
            if (!var1) {
            label_16A0:
            
                if (storage[0x04] <= 0x00) {
                label_16FD:
                
                    if (storage[0x02] <= 0x00) {
                    label_171C:
                    
                        if (storage[0x03] <= 0x00) {
                        label_173B:
                            var0 = 0x01;
                        
                        label_1740:
                            return var0;
                        } else if (arg1 <= storage[0x03]) { goto label_173B; }
                        else {
                            var0 = 0x00;
                            goto label_1740;
                        }
                    } else if (storage[0x02] <= arg1) { goto label_171C; }
                    else {
                        var0 = 0x00;
                        goto label_1740;
                    }
                } else {
                    memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
                    memory[0x20:0x40] = 0x00;
                
                    if (storage[keccak256(memory[0x00:0x40])] <= storage[0x04]) { goto label_16FD; }
                
                    var0 = 0x00;
                    goto label_1740;
                }
            } else {
            label_1698:
                var0 = 0x00;
                goto label_1740;
            }
        } else {
        label_168B:
        
            if (storage[0x03] != 0x00) { goto label_16A0; }
            else { goto label_1698; }
        }
    }
}

Disassembly

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

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

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

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

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

label_003F:
	// Incoming jump from 0x003E, if not 0xaa2f5220 == stack[-1]
	// Inputs[1] { @003F  stack[-1] }
	003F    80  DUP1
	0040    63  PUSH4 0xd6d2b6ba
	0045    14  EQ
	0046    61  PUSH2 0x062c
	0049    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x062c, if 0xd6d2b6ba == stack[-1]

label_004A:
	// Incoming jump from 0x0049, if not 0xd6d2b6ba == stack[-1]
	// Inputs[1] { @004A  stack[-1] }
	004A    80  DUP1
	004B    63  PUSH4 0xdd62ed3e
	0050    14  EQ
	0051    61  PUSH2 0x0707
	0054    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0707, if 0xdd62ed3e == stack[-1]

label_0055:
	// Incoming jump from 0x0054, if not 0xdd62ed3e == stack[-1]
	0055    61  PUSH2 0x00dd
	0058    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x00dd

label_0059:
	// Incoming jump from 0x0028, if 0xa9059cbb > stack[-1]
	// Inputs[1] { @005A  stack[-1] }
	0059    5B  JUMPDEST
	005A    80  DUP1
	005B    63  PUSH4 0x70a08231
	0060    14  EQ
	0061    61  PUSH2 0x0390
	0064    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0390, if 0x70a08231 == stack[-1]

label_0065:
	// Incoming jump from 0x0064, if not 0x70a08231 == stack[-1]
	// Inputs[1] { @0065  stack[-1] }
	0065    80  DUP1
	0066    63  PUSH4 0x8cd8db8a
	006B    14  EQ
	006C    61  PUSH2 0x03f5
	006F    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x03f5, if 0x8cd8db8a == stack[-1]

label_0070:
	// Incoming jump from 0x006F, if not 0x8cd8db8a == stack[-1]
	// Inputs[1] { @0070  stack[-1] }
	0070    80  DUP1
	0071    63  PUSH4 0x95d89b41
	0076    14  EQ
	0077    61  PUSH2 0x045c
	007A    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x045c, if 0x95d89b41 == stack[-1]

label_007B:
	// Incoming jump from 0x007A, if not 0x95d89b41 == stack[-1]
	007B    61  PUSH2 0x00dd
	007E    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x00dd

label_007F:
	// Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @0080  stack[-1] }
	007F    5B  JUMPDEST
	0080    80  DUP1
	0081    63  PUSH4 0x18160ddd
	0086    11  GT
	0087    61  PUSH2 0x00bb
	008A    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00bb, if 0x18160ddd > stack[-1]

label_008B:
	// Incoming jump from 0x008A, if not 0x18160ddd > stack[-1]
	// Inputs[1] { @008B  stack[-1] }
	008B    80  DUP1
	008C    63  PUSH4 0x18160ddd
	0091    14  EQ
	0092    61  PUSH2 0x024b
	0095    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x024b, if 0x18160ddd == stack[-1]

label_0096:
	// Incoming jump from 0x0095, if not 0x18160ddd == stack[-1]
	// Inputs[1] { @0096  stack[-1] }
	0096    80  DUP1
	0097    63  PUSH4 0x21a9cf34
	009C    14  EQ
	009D    61  PUSH2 0x0276
	00A0    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0276, if 0x21a9cf34 == stack[-1]

label_00A1:
	// Incoming jump from 0x00A0, if not 0x21a9cf34 == stack[-1]
	// Inputs[1] { @00A1  stack[-1] }
	00A1    80  DUP1
	00A2    63  PUSH4 0x23b872dd
	00A7    14  EQ
	00A8    61  PUSH2 0x02df
	00AB    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x02df, if 0x23b872dd == stack[-1]

label_00AC:
	// Incoming jump from 0x00AB, if not 0x23b872dd == stack[-1]
	// Inputs[1] { @00AC  stack[-1] }
	00AC    80  DUP1
	00AD    63  PUSH4 0x313ce567
	00B2    14  EQ
	00B3    61  PUSH2 0x0365
	00B6    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0365, if 0x313ce567 == stack[-1]

label_00B7:
	// Incoming jump from 0x00B6, if not 0x313ce567 == stack[-1]
	00B7    61  PUSH2 0x00dd
	00BA    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x00dd

label_00BB:
	// Incoming jump from 0x008A, if 0x18160ddd > stack[-1]
	// Inputs[1] { @00BC  stack[-1] }
	00BB    5B  JUMPDEST
	00BC    80  DUP1
	00BD    63  PUSH4 0x06fdde03
	00C2    14  EQ
	00C3    61  PUSH2 0x00e2
	00C6    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00e2, if 0x06fdde03 == stack[-1]

label_00C7:
	// Incoming jump from 0x00C6, if not 0x06fdde03 == stack[-1]
	// Inputs[1] { @00C7  stack[-1] }
	00C7    80  DUP1
	00C8    63  PUSH4 0x095ea7b3
	00CD    14  EQ
	00CE    61  PUSH2 0x0172
	00D1    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0172, if 0x095ea7b3 == stack[-1]

label_00D2:
	// Incoming jump from 0x00D1, if not 0x095ea7b3 == stack[-1]
	// Inputs[1] { @00D2  stack[-1] }
	00D2    80  DUP1
	00D3    63  PUSH4 0x109b1ee6
	00D8    14  EQ
	00D9    61  PUSH2 0x01d8
	00DC    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01d8, if 0x109b1ee6 == stack[-1]

label_00DD:
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Incoming jump from 0x0058
	// Incoming jump from 0x007E
	// Incoming jump from 0x00BA
	// Incoming jump from 0x00DC, if not 0x109b1ee6 == stack[-1]
	// Inputs[1] { @00E1  memory[0x00:0x00] }
	00DD    5B  JUMPDEST
	00DE    60  PUSH1 0x00
	00E0    80  DUP1
	00E1    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00E1  revert(memory[0x00:0x00]); }
	// Block terminates

label_00E2:
	// Incoming jump from 0x00C6, if 0x06fdde03 == stack[-1]
	// Inputs[1] { @00E3  msg.value }
	00E2    5B  JUMPDEST
	00E3    34  CALLVALUE
	00E4    80  DUP1
	00E5    15  ISZERO
	00E6    61  PUSH2 0x00ee
	00E9    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @00E3  stack[0] = msg.value }
	// Block ends with conditional jump to 0x00ee, if !msg.value

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

label_00EE:
	// Incoming jump from 0x00E9, if !msg.value
	00EE    5B  JUMPDEST
	00EF    50  POP
	00F0    61  PUSH2 0x00f7
	00F3    61  PUSH2 0x078c
	00F6    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @00F0  stack[-1] = 0x00f7 }
	// Block ends with call to 0x078c, returns to 0x00F7

label_00F7:
	// Incoming return from call to 0x078C at 0x00F6
	// Inputs[4]
	// {
	//     @00FA  memory[0x40:0x60]
	//     @0105  stack[-1]
	//     @0108  memory[stack[-1]:stack[-1] + 0x20]
	//     @0111  memory[stack[-1]:stack[-1] + 0x20]
	// }
	00F7    5B  JUMPDEST
	00F8    60  PUSH1 0x40
	00FA    51  MLOAD
	00FB    80  DUP1
	00FC    80  DUP1
	00FD    60  PUSH1 0x20
	00FF    01  ADD
	0100    82  DUP3
	0101    81  DUP2
	0102    03  SUB
	0103    82  DUP3
	0104    52  MSTORE
	0105    83  DUP4
	0106    81  DUP2
	0107    81  DUP2
	0108    51  MLOAD
	0109    81  DUP2
	010A    52  MSTORE
	010B    60  PUSH1 0x20
	010D    01  ADD
	010E    91  SWAP2
	010F    50  POP
	0110    80  DUP1
	0111    51  MLOAD
	0112    90  SWAP1
	0113    60  PUSH1 0x20
	0115    01  ADD
	0116    90  SWAP1
	0117    80  DUP1
	0118    83  DUP4
	0119    83  DUP4
	011A    60  PUSH1 0x00
	011C    5B  JUMPDEST
	011D    83  DUP4
	011E    81  DUP2
	011F    10  LT
	0120    15  ISZERO
	0121    61  PUSH2 0x0137
	0124    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @00FA  stack[0] = memory[0x40:0x60]
	//     @00FB  stack[1] = memory[0x40:0x60]
	//     @0104  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @010A  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @010E  stack[2] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0116  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0116  stack[3] = 0x20 + stack[-1]
	//     @0117  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0118  stack[6] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0119  stack[7] = 0x20 + stack[-1]
	//     @011A  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x0137, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0125:
	// Incoming jump from 0x0124, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x0124, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0125  stack[-1]
	//     @0126  stack[-2]
	//     @0128  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @012A  stack[-3]
	// }
	0125    80  DUP1
	0126    82  DUP3
	0127    01  ADD
	0128    51  MLOAD
	0129    81  DUP2
	012A    84  DUP5
	012B    01  ADD
	012C    52  MSTORE
	012D    60  PUSH1 0x20
	012F    81  DUP2
	0130    01  ADD
	0131    90  SWAP1
	0132    50  POP
	0133    61  PUSH2 0x011c
	0136    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @012C  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0131  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x011c

label_0137:
	// Incoming jump from 0x0124, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x0124, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @013C  stack[-6]
	//     @013C  stack[-5]
	//     @013E  stack[-7]
	// }
	0137    5B  JUMPDEST
	0138    50  POP
	0139    50  POP
	013A    50  POP
	013B    50  POP
	013C    90  SWAP1
	013D    50  POP
	013E    90  SWAP1
	013F    81  DUP2
	0140    01  ADD
	0141    90  SWAP1
	0142    60  PUSH1 0x1f
	0144    16  AND
	0145    80  DUP1
	0146    15  ISZERO
	0147    61  PUSH2 0x0164
	014A    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0141  stack[-7] = stack[-5] + stack[-7]
	//     @0144  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0164, if !(0x1f & stack[-5])

label_014B:
	// Incoming jump from 0x014A, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @014B  stack[-1]
	//     @014C  stack[-2]
	//     @014F  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0166  stack[-5]
	//     @016C  memory[0x40:0x60]
	//     @0171  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	014B    80  DUP1
	014C    82  DUP3
	014D    03  SUB
	014E    80  DUP1
	014F    51  MLOAD
	0150    60  PUSH1 0x01
	0152    83  DUP4
	0153    60  PUSH1 0x20
	0155    03  SUB
	0156    61  PUSH2 0x0100
	0159    0A  EXP
	015A    03  SUB
	015B    19  NOT
	015C    16  AND
	015D    81  DUP2
	015E    52  MSTORE
	015F    60  PUSH1 0x20
	0161    01  ADD
	0162    91  SWAP2
	0163    50  POP
	0164    5B  JUMPDEST
	0165    50  POP
	0166    92  SWAP3
	0167    50  POP
	0168    50  POP
	0169    50  POP
	016A    60  PUSH1 0x40
	016C    51  MLOAD
	016D    80  DUP1
	016E    91  SWAP2
	016F    03  SUB
	0170    90  SWAP1
	0171    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @015E  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]
	//     @0171  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0172:
	// Incoming jump from 0x00D1, if 0x095ea7b3 == stack[-1]
	// Inputs[1] { @0179  msg.data.length }
	0172    5B  JUMPDEST
	0173    61  PUSH2 0x01be
	0176    60  PUSH1 0x04
	0178    80  DUP1
	0179    36  CALLDATASIZE
	017A    03  SUB
	017B    60  PUSH1 0x40
	017D    81  DUP2
	017E    10  LT
	017F    15  ISZERO
	0180    61  PUSH2 0x0188
	0183    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0173  stack[0] = 0x01be
	//     @0176  stack[1] = 0x04
	//     @017A  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0188, returns to 0x01BE, if !(msg.data.length - 0x04 < 0x40)

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

label_0188:
	// Incoming call from 0x0183, returns to 0x01BE, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @0189  stack[-2]
	//     @018A  stack[-1]
	//     @018E  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01AE  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0188    5B  JUMPDEST
	0189    81  DUP2
	018A    01  ADD
	018B    90  SWAP1
	018C    80  DUP1
	018D    80  DUP1
	018E    35  CALLDATALOAD
	018F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01A4    16  AND
	01A5    90  SWAP1
	01A6    60  PUSH1 0x20
	01A8    01  ADD
	01A9    90  SWAP1
	01AA    92  SWAP3
	01AB    91  SWAP2
	01AC    90  SWAP1
	01AD    80  DUP1
	01AE    35  CALLDATALOAD
	01AF    90  SWAP1
	01B0    60  PUSH1 0x20
	01B2    01  ADD
	01B3    90  SWAP1
	01B4    92  SWAP3
	01B5    91  SWAP2
	01B6    90  SWAP1
	01B7    50  POP
	01B8    50  POP
	01B9    50  POP
	01BA    61  PUSH2 0x082a
	01BD    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @01AA  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01B4  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x082a

label_01BE:
	// Incoming return from call to 0x0188 at 0x0183
	// Inputs[4]
	// {
	//     @01C1  memory[0x40:0x60]
	//     @01C3  stack[-1]
	//     @01D2  memory[0x40:0x60]
	//     @01D7  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	01BE    5B  JUMPDEST
	01BF    60  PUSH1 0x40
	01C1    51  MLOAD
	01C2    80  DUP1
	01C3    82  DUP3
	01C4    15  ISZERO
	01C5    15  ISZERO
	01C6    15  ISZERO
	01C7    15  ISZERO
	01C8    81  DUP2
	01C9    52  MSTORE
	01CA    60  PUSH1 0x20
	01CC    01  ADD
	01CD    91  SWAP2
	01CE    50  POP
	01CF    50  POP
	01D0    60  PUSH1 0x40
	01D2    51  MLOAD
	01D3    80  DUP1
	01D4    91  SWAP2
	01D5    03  SUB
	01D6    90  SWAP1
	01D7    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @01C9  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @01D7  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_01D8:
	// Incoming jump from 0x00DC, if 0x109b1ee6 == stack[-1]
	// Inputs[1] { @01D9  msg.value }
	01D8    5B  JUMPDEST
	01D9    34  CALLVALUE
	01DA    80  DUP1
	01DB    15  ISZERO
	01DC    61  PUSH2 0x01e4
	01DF    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @01D9  stack[0] = msg.value }
	// Block ends with conditional jump to 0x01e4, if !msg.value

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

label_01E4:
	// Incoming jump from 0x01DF, if !msg.value
	// Inputs[1] { @01EC  msg.data.length }
	01E4    5B  JUMPDEST
	01E5    50  POP
	01E6    61  PUSH2 0x0231
	01E9    60  PUSH1 0x04
	01EB    80  DUP1
	01EC    36  CALLDATASIZE
	01ED    03  SUB
	01EE    60  PUSH1 0x40
	01F0    81  DUP2
	01F1    10  LT
	01F2    15  ISZERO
	01F3    61  PUSH2 0x01fb
	01F6    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @01E6  stack[-1] = 0x0231
	//     @01E9  stack[0] = 0x04
	//     @01ED  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x01fb, returns to 0x0231, if !(msg.data.length - 0x04 < 0x40)

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

label_01FB:
	// Incoming call from 0x01F6, returns to 0x0231, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @01FC  stack[-2]
	//     @01FD  stack[-1]
	//     @0201  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0221  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	01FB    5B  JUMPDEST
	01FC    81  DUP2
	01FD    01  ADD
	01FE    90  SWAP1
	01FF    80  DUP1
	0200    80  DUP1
	0201    35  CALLDATALOAD
	0202    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0217    16  AND
	0218    90  SWAP1
	0219    60  PUSH1 0x20
	021B    01  ADD
	021C    90  SWAP1
	021D    92  SWAP3
	021E    91  SWAP2
	021F    90  SWAP1
	0220    80  DUP1
	0221    35  CALLDATALOAD
	0222    90  SWAP1
	0223    60  PUSH1 0x20
	0225    01  ADD
	0226    90  SWAP1
	0227    92  SWAP3
	0228    91  SWAP2
	0229    90  SWAP1
	022A    50  POP
	022B    50  POP
	022C    50  POP
	022D    61  PUSH2 0x091c
	0230    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @021D  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0227  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x091c

label_0231:
	// Incoming return from call to 0x01FB at 0x01F6
	// Inputs[4]
	// {
	//     @0234  memory[0x40:0x60]
	//     @0236  stack[-1]
	//     @0245  memory[0x40:0x60]
	//     @024A  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0231    5B  JUMPDEST
	0232    60  PUSH1 0x40
	0234    51  MLOAD
	0235    80  DUP1
	0236    82  DUP3
	0237    15  ISZERO
	0238    15  ISZERO
	0239    15  ISZERO
	023A    15  ISZERO
	023B    81  DUP2
	023C    52  MSTORE
	023D    60  PUSH1 0x20
	023F    01  ADD
	0240    91  SWAP2
	0241    50  POP
	0242    50  POP
	0243    60  PUSH1 0x40
	0245    51  MLOAD
	0246    80  DUP1
	0247    91  SWAP2
	0248    03  SUB
	0249    90  SWAP1
	024A    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @023C  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @024A  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_024B:
	// Incoming jump from 0x0095, if 0x18160ddd == stack[-1]
	// Inputs[1] { @024C  msg.value }
	024B    5B  JUMPDEST
	024C    34  CALLVALUE
	024D    80  DUP1
	024E    15  ISZERO
	024F    61  PUSH2 0x0257
	0252    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @024C  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0257, if !msg.value

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

label_0257:
	// Incoming jump from 0x0252, if !msg.value
	0257    5B  JUMPDEST
	0258    50  POP
	0259    61  PUSH2 0x0260
	025C    61  PUSH2 0x0a2d
	025F    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0259  stack[-1] = 0x0260 }
	// Block ends with call to 0x0a2d, returns to 0x0260

label_0260:
	// Incoming return from call to 0x0A2D at 0x025F
	// Inputs[4]
	// {
	//     @0263  memory[0x40:0x60]
	//     @0265  stack[-1]
	//     @0270  memory[0x40:0x60]
	//     @0275  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0260    5B  JUMPDEST
	0261    60  PUSH1 0x40
	0263    51  MLOAD
	0264    80  DUP1
	0265    82  DUP3
	0266    81  DUP2
	0267    52  MSTORE
	0268    60  PUSH1 0x20
	026A    01  ADD
	026B    91  SWAP2
	026C    50  POP
	026D    50  POP
	026E    60  PUSH1 0x40
	0270    51  MLOAD
	0271    80  DUP1
	0272    91  SWAP2
	0273    03  SUB
	0274    90  SWAP1
	0275    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0267  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0275  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0276:
	// Incoming jump from 0x00A0, if 0x21a9cf34 == stack[-1]
	// Inputs[1] { @0277  msg.value }
	0276    5B  JUMPDEST
	0277    34  CALLVALUE
	0278    80  DUP1
	0279    15  ISZERO
	027A    61  PUSH2 0x0282
	027D    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0277  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0282, if !msg.value

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

label_0282:
	// Incoming jump from 0x027D, if !msg.value
	// Inputs[1] { @028A  msg.data.length }
	0282    5B  JUMPDEST
	0283    50  POP
	0284    61  PUSH2 0x02c5
	0287    60  PUSH1 0x04
	0289    80  DUP1
	028A    36  CALLDATASIZE
	028B    03  SUB
	028C    60  PUSH1 0x20
	028E    81  DUP2
	028F    10  LT
	0290    15  ISZERO
	0291    61  PUSH2 0x0299
	0294    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0284  stack[-1] = 0x02c5
	//     @0287  stack[0] = 0x04
	//     @028B  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0299, returns to 0x02C5, if !(msg.data.length - 0x04 < 0x20)

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

label_0299:
	// Incoming call from 0x0294, returns to 0x02C5, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @029A  stack[-2]
	//     @029B  stack[-1]
	//     @029F  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0299    5B  JUMPDEST
	029A    81  DUP2
	029B    01  ADD
	029C    90  SWAP1
	029D    80  DUP1
	029E    80  DUP1
	029F    35  CALLDATALOAD
	02A0    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02B5    16  AND
	02B6    90  SWAP1
	02B7    60  PUSH1 0x20
	02B9    01  ADD
	02BA    90  SWAP1
	02BB    92  SWAP3
	02BC    91  SWAP2
	02BD    90  SWAP1
	02BE    50  POP
	02BF    50  POP
	02C0    50  POP
	02C1    61  PUSH2 0x0a33
	02C4    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @02BB  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x0a33

label_02C5:
	// Incoming return from call to 0x0299 at 0x0294
	// Inputs[4]
	// {
	//     @02C8  memory[0x40:0x60]
	//     @02CA  stack[-1]
	//     @02D9  memory[0x40:0x60]
	//     @02DE  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	02C5    5B  JUMPDEST
	02C6    60  PUSH1 0x40
	02C8    51  MLOAD
	02C9    80  DUP1
	02CA    82  DUP3
	02CB    15  ISZERO
	02CC    15  ISZERO
	02CD    15  ISZERO
	02CE    15  ISZERO
	02CF    81  DUP2
	02D0    52  MSTORE
	02D1    60  PUSH1 0x20
	02D3    01  ADD
	02D4    91  SWAP2
	02D5    50  POP
	02D6    50  POP
	02D7    60  PUSH1 0x40
	02D9    51  MLOAD
	02DA    80  DUP1
	02DB    91  SWAP2
	02DC    03  SUB
	02DD    90  SWAP1
	02DE    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @02D0  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @02DE  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_02DF:
	// Incoming jump from 0x00AB, if 0x23b872dd == stack[-1]
	// Inputs[1] { @02E6  msg.data.length }
	02DF    5B  JUMPDEST
	02E0    61  PUSH2 0x034b
	02E3    60  PUSH1 0x04
	02E5    80  DUP1
	02E6    36  CALLDATASIZE
	02E7    03  SUB
	02E8    60  PUSH1 0x60
	02EA    81  DUP2
	02EB    10  LT
	02EC    15  ISZERO
	02ED    61  PUSH2 0x02f5
	02F0    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @02E0  stack[0] = 0x034b
	//     @02E3  stack[1] = 0x04
	//     @02E7  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x02f5, returns to 0x034B, if !(msg.data.length - 0x04 < 0x60)

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

label_02F5:
	// Incoming call from 0x02F0, returns to 0x034B, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[5]
	// {
	//     @02F6  stack[-2]
	//     @02F7  stack[-1]
	//     @02FB  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @031B  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @033B  msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	02F5    5B  JUMPDEST
	02F6    81  DUP2
	02F7    01  ADD
	02F8    90  SWAP1
	02F9    80  DUP1
	02FA    80  DUP1
	02FB    35  CALLDATALOAD
	02FC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0311    16  AND
	0312    90  SWAP1
	0313    60  PUSH1 0x20
	0315    01  ADD
	0316    90  SWAP1
	0317    92  SWAP3
	0318    91  SWAP2
	0319    90  SWAP1
	031A    80  DUP1
	031B    35  CALLDATALOAD
	031C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0331    16  AND
	0332    90  SWAP1
	0333    60  PUSH1 0x20
	0335    01  ADD
	0336    90  SWAP1
	0337    92  SWAP3
	0338    91  SWAP2
	0339    90  SWAP1
	033A    80  DUP1
	033B    35  CALLDATALOAD
	033C    90  SWAP1
	033D    60  PUSH1 0x20
	033F    01  ADD
	0340    90  SWAP1
	0341    92  SWAP3
	0342    91  SWAP2
	0343    90  SWAP1
	0344    50  POP
	0345    50  POP
	0346    50  POP
	0347    61  PUSH2 0x0a7f
	034A    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0317  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0337  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @0341  stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0a7f

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

label_0365:
	// Incoming jump from 0x00B6, if 0x313ce567 == stack[-1]
	// Inputs[1] { @0366  msg.value }
	0365    5B  JUMPDEST
	0366    34  CALLVALUE
	0367    80  DUP1
	0368    15  ISZERO
	0369    61  PUSH2 0x0371
	036C    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0366  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0371, if !msg.value

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

label_0371:
	// Incoming jump from 0x036C, if !msg.value
	0371    5B  JUMPDEST
	0372    50  POP
	0373    61  PUSH2 0x037a
	0376    61  PUSH2 0x0d92
	0379    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0373  stack[-1] = 0x037a }
	// Block ends with call to 0x0d92, returns to 0x037A

label_037A:
	// Incoming return from call to 0x0D92 at 0x0379
	// Inputs[4]
	// {
	//     @037D  memory[0x40:0x60]
	//     @037F  stack[-1]
	//     @038A  memory[0x40:0x60]
	//     @038F  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	037A    5B  JUMPDEST
	037B    60  PUSH1 0x40
	037D    51  MLOAD
	037E    80  DUP1
	037F    82  DUP3
	0380    81  DUP2
	0381    52  MSTORE
	0382    60  PUSH1 0x20
	0384    01  ADD
	0385    91  SWAP2
	0386    50  POP
	0387    50  POP
	0388    60  PUSH1 0x40
	038A    51  MLOAD
	038B    80  DUP1
	038C    91  SWAP2
	038D    03  SUB
	038E    90  SWAP1
	038F    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0381  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @038F  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0390:
	// Incoming jump from 0x0064, if 0x70a08231 == stack[-1]
	// Inputs[1] { @0391  msg.value }
	0390    5B  JUMPDEST
	0391    34  CALLVALUE
	0392    80  DUP1
	0393    15  ISZERO
	0394    61  PUSH2 0x039c
	0397    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0391  stack[0] = msg.value }
	// Block ends with conditional jump to 0x039c, if !msg.value

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

label_039C:
	// Incoming jump from 0x0397, if !msg.value
	// Inputs[1] { @03A4  msg.data.length }
	039C    5B  JUMPDEST
	039D    50  POP
	039E    61  PUSH2 0x03df
	03A1    60  PUSH1 0x04
	03A3    80  DUP1
	03A4    36  CALLDATASIZE
	03A5    03  SUB
	03A6    60  PUSH1 0x20
	03A8    81  DUP2
	03A9    10  LT
	03AA    15  ISZERO
	03AB    61  PUSH2 0x03b3
	03AE    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @039E  stack[-1] = 0x03df
	//     @03A1  stack[0] = 0x04
	//     @03A5  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x03b3, returns to 0x03DF, if !(msg.data.length - 0x04 < 0x20)

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

label_03B3:
	// Incoming call from 0x03AE, returns to 0x03DF, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[3]
	// {
	//     @03B4  stack[-2]
	//     @03B5  stack[-1]
	//     @03B9  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	03B3    5B  JUMPDEST
	03B4    81  DUP2
	03B5    01  ADD
	03B6    90  SWAP1
	03B7    80  DUP1
	03B8    80  DUP1
	03B9    35  CALLDATALOAD
	03BA    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	03CF    16  AND
	03D0    90  SWAP1
	03D1    60  PUSH1 0x20
	03D3    01  ADD
	03D4    90  SWAP1
	03D5    92  SWAP3
	03D6    91  SWAP2
	03D7    90  SWAP1
	03D8    50  POP
	03D9    50  POP
	03DA    50  POP
	03DB    61  PUSH2 0x0d97
	03DE    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @03D5  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x0d97

label_03DF:
	// Incoming return from call to 0x03B3 at 0x03AE
	// Inputs[4]
	// {
	//     @03E2  memory[0x40:0x60]
	//     @03E4  stack[-1]
	//     @03EF  memory[0x40:0x60]
	//     @03F4  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	03DF    5B  JUMPDEST
	03E0    60  PUSH1 0x40
	03E2    51  MLOAD
	03E3    80  DUP1
	03E4    82  DUP3
	03E5    81  DUP2
	03E6    52  MSTORE
	03E7    60  PUSH1 0x20
	03E9    01  ADD
	03EA    91  SWAP2
	03EB    50  POP
	03EC    50  POP
	03ED    60  PUSH1 0x40
	03EF    51  MLOAD
	03F0    80  DUP1
	03F1    91  SWAP2
	03F2    03  SUB
	03F3    90  SWAP1
	03F4    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @03E6  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @03F4  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_03F5:
	// Incoming jump from 0x006F, if 0x8cd8db8a == stack[-1]
	// Inputs[1] { @03F6  msg.value }
	03F5    5B  JUMPDEST
	03F6    34  CALLVALUE
	03F7    80  DUP1
	03F8    15  ISZERO
	03F9    61  PUSH2 0x0401
	03FC    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @03F6  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0401, if !msg.value

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

label_0401:
	// Incoming jump from 0x03FC, if !msg.value
	// Inputs[1] { @0409  msg.data.length }
	0401    5B  JUMPDEST
	0402    50  POP
	0403    61  PUSH2 0x0442
	0406    60  PUSH1 0x04
	0408    80  DUP1
	0409    36  CALLDATASIZE
	040A    03  SUB
	040B    60  PUSH1 0x60
	040D    81  DUP2
	040E    10  LT
	040F    15  ISZERO
	0410    61  PUSH2 0x0418
	0413    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0403  stack[-1] = 0x0442
	//     @0406  stack[0] = 0x04
	//     @040A  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0418, returns to 0x0442, if !(msg.data.length - 0x04 < 0x60)

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

label_0418:
	// Incoming call from 0x0413, returns to 0x0442, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[5]
	// {
	//     @0419  stack[-2]
	//     @041A  stack[-1]
	//     @041E  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0428  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @0432  msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	0418    5B  JUMPDEST
	0419    81  DUP2
	041A    01  ADD
	041B    90  SWAP1
	041C    80  DUP1
	041D    80  DUP1
	041E    35  CALLDATALOAD
	041F    90  SWAP1
	0420    60  PUSH1 0x20
	0422    01  ADD
	0423    90  SWAP1
	0424    92  SWAP3
	0425    91  SWAP2
	0426    90  SWAP1
	0427    80  DUP1
	0428    35  CALLDATALOAD
	0429    90  SWAP1
	042A    60  PUSH1 0x20
	042C    01  ADD
	042D    90  SWAP1
	042E    92  SWAP3
	042F    91  SWAP2
	0430    90  SWAP1
	0431    80  DUP1
	0432    35  CALLDATALOAD
	0433    90  SWAP1
	0434    60  PUSH1 0x20
	0436    01  ADD
	0437    90  SWAP1
	0438    92  SWAP3
	0439    91  SWAP2
	043A    90  SWAP1
	043B    50  POP
	043C    50  POP
	043D    50  POP
	043E    61  PUSH2 0x0daf
	0441    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0424  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20]
	//     @042E  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	//     @0438  stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0daf

label_0442:
	// Incoming return from call to 0x0418 at 0x0413
	// Inputs[4]
	// {
	//     @0445  memory[0x40:0x60]
	//     @0447  stack[-1]
	//     @0456  memory[0x40:0x60]
	//     @045B  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0442    5B  JUMPDEST
	0443    60  PUSH1 0x40
	0445    51  MLOAD
	0446    80  DUP1
	0447    82  DUP3
	0448    15  ISZERO
	0449    15  ISZERO
	044A    15  ISZERO
	044B    15  ISZERO
	044C    81  DUP2
	044D    52  MSTORE
	044E    60  PUSH1 0x20
	0450    01  ADD
	0451    91  SWAP2
	0452    50  POP
	0453    50  POP
	0454    60  PUSH1 0x40
	0456    51  MLOAD
	0457    80  DUP1
	0458    91  SWAP2
	0459    03  SUB
	045A    90  SWAP1
	045B    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @044D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @045B  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_045C:
	// Incoming jump from 0x007A, if 0x95d89b41 == stack[-1]
	// Inputs[1] { @045D  msg.value }
	045C    5B  JUMPDEST
	045D    34  CALLVALUE
	045E    80  DUP1
	045F    15  ISZERO
	0460    61  PUSH2 0x0468
	0463    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @045D  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0468, if !msg.value

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

label_0468:
	// Incoming jump from 0x0463, if !msg.value
	0468    5B  JUMPDEST
	0469    50  POP
	046A    61  PUSH2 0x0471
	046D    61  PUSH2 0x0e53
	0470    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @046A  stack[-1] = 0x0471 }
	// Block ends with call to 0x0e53, returns to 0x0471

label_0471:
	// Incoming return from call to 0x0E53 at 0x0470
	// Inputs[4]
	// {
	//     @0474  memory[0x40:0x60]
	//     @047F  stack[-1]
	//     @0482  memory[stack[-1]:stack[-1] + 0x20]
	//     @048B  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0471    5B  JUMPDEST
	0472    60  PUSH1 0x40
	0474    51  MLOAD
	0475    80  DUP1
	0476    80  DUP1
	0477    60  PUSH1 0x20
	0479    01  ADD
	047A    82  DUP3
	047B    81  DUP2
	047C    03  SUB
	047D    82  DUP3
	047E    52  MSTORE
	047F    83  DUP4
	0480    81  DUP2
	0481    81  DUP2
	0482    51  MLOAD
	0483    81  DUP2
	0484    52  MSTORE
	0485    60  PUSH1 0x20
	0487    01  ADD
	0488    91  SWAP2
	0489    50  POP
	048A    80  DUP1
	048B    51  MLOAD
	048C    90  SWAP1
	048D    60  PUSH1 0x20
	048F    01  ADD
	0490    90  SWAP1
	0491    80  DUP1
	0492    83  DUP4
	0493    83  DUP4
	0494    60  PUSH1 0x00
	0496    5B  JUMPDEST
	0497    83  DUP4
	0498    81  DUP2
	0499    10  LT
	049A    15  ISZERO
	049B    61  PUSH2 0x04b1
	049E    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @0474  stack[0] = memory[0x40:0x60]
	//     @0475  stack[1] = memory[0x40:0x60]
	//     @047E  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0484  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0488  stack[2] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0490  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0490  stack[3] = 0x20 + stack[-1]
	//     @0491  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0492  stack[6] = 0x20 + 0x20 + memory[0x40:0x60]
	//     @0493  stack[7] = 0x20 + stack[-1]
	//     @0494  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x04b1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_049F:
	// Incoming jump from 0x049E, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x049E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @049F  stack[-1]
	//     @04A0  stack[-2]
	//     @04A2  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @04A4  stack[-3]
	// }
	049F    80  DUP1
	04A0    82  DUP3
	04A1    01  ADD
	04A2    51  MLOAD
	04A3    81  DUP2
	04A4    84  DUP5
	04A5    01  ADD
	04A6    52  MSTORE
	04A7    60  PUSH1 0x20
	04A9    81  DUP2
	04AA    01  ADD
	04AB    90  SWAP1
	04AC    50  POP
	04AD    61  PUSH2 0x0496
	04B0    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @04A6  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @04AB  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x0496

label_04B1:
	// Incoming jump from 0x049E, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x049E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @04B6  stack[-5]
	//     @04B6  stack[-6]
	//     @04B8  stack[-7]
	// }
	04B1    5B  JUMPDEST
	04B2    50  POP
	04B3    50  POP
	04B4    50  POP
	04B5    50  POP
	04B6    90  SWAP1
	04B7    50  POP
	04B8    90  SWAP1
	04B9    81  DUP2
	04BA    01  ADD
	04BB    90  SWAP1
	04BC    60  PUSH1 0x1f
	04BE    16  AND
	04BF    80  DUP1
	04C0    15  ISZERO
	04C1    61  PUSH2 0x04de
	04C4    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @04BB  stack[-7] = stack[-5] + stack[-7]
	//     @04BE  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x04de, if !(0x1f & stack[-5])

label_04C5:
	// Incoming jump from 0x04C4, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @04C5  stack[-1]
	//     @04C6  stack[-2]
	//     @04C9  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @04E0  stack[-5]
	//     @04E6  memory[0x40:0x60]
	//     @04EB  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	04C5    80  DUP1
	04C6    82  DUP3
	04C7    03  SUB
	04C8    80  DUP1
	04C9    51  MLOAD
	04CA    60  PUSH1 0x01
	04CC    83  DUP4
	04CD    60  PUSH1 0x20
	04CF    03  SUB
	04D0    61  PUSH2 0x0100
	04D3    0A  EXP
	04D4    03  SUB
	04D5    19  NOT
	04D6    16  AND
	04D7    81  DUP2
	04D8    52  MSTORE
	04D9    60  PUSH1 0x20
	04DB    01  ADD
	04DC    91  SWAP2
	04DD    50  POP
	04DE    5B  JUMPDEST
	04DF    50  POP
	04E0    92  SWAP3
	04E1    50  POP
	04E2    50  POP
	04E3    50  POP
	04E4    60  PUSH1 0x40
	04E6    51  MLOAD
	04E7    80  DUP1
	04E8    91  SWAP2
	04E9    03  SUB
	04EA    90  SWAP1
	04EB    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @04D8  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]
	//     @04EB  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

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

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

label_0502:
	// Incoming call from 0x04FD, returns to 0x0538, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @0503  stack[-2]
	//     @0504  stack[-1]
	//     @0508  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0528  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0502    5B  JUMPDEST
	0503    81  DUP2
	0504    01  ADD
	0505    90  SWAP1
	0506    80  DUP1
	0507    80  DUP1
	0508    35  CALLDATALOAD
	0509    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	051E    16  AND
	051F    90  SWAP1
	0520    60  PUSH1 0x20
	0522    01  ADD
	0523    90  SWAP1
	0524    92  SWAP3
	0525    91  SWAP2
	0526    90  SWAP1
	0527    80  DUP1
	0528    35  CALLDATALOAD
	0529    90  SWAP1
	052A    60  PUSH1 0x20
	052C    01  ADD
	052D    90  SWAP1
	052E    92  SWAP3
	052F    91  SWAP2
	0530    90  SWAP1
	0531    50  POP
	0532    50  POP
	0533    50  POP
	0534    61  PUSH2 0x0ef1
	0537    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0524  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @052E  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0ef1

label_0538:
	// Incoming return from call to 0x0502 at 0x04FD
	// Inputs[4]
	// {
	//     @053B  memory[0x40:0x60]
	//     @053D  stack[-1]
	//     @054C  memory[0x40:0x60]
	//     @0551  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0538    5B  JUMPDEST
	0539    60  PUSH1 0x40
	053B    51  MLOAD
	053C    80  DUP1
	053D    82  DUP3
	053E    15  ISZERO
	053F    15  ISZERO
	0540    15  ISZERO
	0541    15  ISZERO
	0542    81  DUP2
	0543    52  MSTORE
	0544    60  PUSH1 0x20
	0546    01  ADD
	0547    91  SWAP2
	0548    50  POP
	0549    50  POP
	054A    60  PUSH1 0x40
	054C    51  MLOAD
	054D    80  DUP1
	054E    91  SWAP2
	054F    03  SUB
	0550    90  SWAP1
	0551    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0543  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @0551  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0552:
	// Incoming jump from 0x003E, if 0xaa2f5220 == stack[-1]
	// Inputs[1] { @0559  msg.data.length }
	0552    5B  JUMPDEST
	0553    61  PUSH2 0x0612
	0556    60  PUSH1 0x04
	0558    80  DUP1
	0559    36  CALLDATASIZE
	055A    03  SUB
	055B    60  PUSH1 0x40
	055D    81  DUP2
	055E    10  LT
	055F    15  ISZERO
	0560    61  PUSH2 0x0568
	0563    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0553  stack[0] = 0x0612
	//     @0556  stack[1] = 0x04
	//     @055A  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0568, returns to 0x0612, if !(msg.data.length - 0x04 < 0x40)

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

label_0568:
	// Incoming call from 0x0563, returns to 0x0612, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @0569  stack[-2]
	//     @056A  stack[-1]
	//     @056E  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0568    5B  JUMPDEST
	0569    81  DUP2
	056A    01  ADD
	056B    90  SWAP1
	056C    80  DUP1
	056D    80  DUP1
	056E    35  CALLDATALOAD
	056F    90  SWAP1
	0570    60  PUSH1 0x20
	0572    01  ADD
	0573    90  SWAP1
	0574    64  PUSH5 0x0100000000
	057A    81  DUP2
	057B    11  GT
	057C    15  ISZERO
	057D    61  PUSH2 0x0585
	0580    57  *JUMPI
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @056B  stack[-1] = stack[-2]
	//     @056B  stack[-2] = stack[-2] + stack[-1]
	//     @0573  stack[1] = msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0573  stack[0] = 0x20 + stack[-2]
	// }
	// Block ends with conditional jump to 0x0585, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000)

label_0581:
	// Incoming jump from 0x0580, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000)
	// Inputs[1] { @0584  memory[0x00:0x00] }
	0581    60  PUSH1 0x00
	0583    80  DUP1
	0584    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0584  revert(memory[0x00:0x00]); }
	// Block terminates

label_0585:
	// Incoming jump from 0x0580, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000)
	// Inputs[3]
	// {
	//     @0586  stack[-3]
	//     @0587  stack[-1]
	//     @0588  stack[-4]
	// }
	0585    5B  JUMPDEST
	0586    82  DUP3
	0587    01  ADD
	0588    83  DUP4
	0589    60  PUSH1 0x20
	058B    82  DUP3
	058C    01  ADD
	058D    11  GT
	058E    15  ISZERO
	058F    61  PUSH2 0x0597
	0592    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0587  stack[-1] = stack[-3] + stack[-1] }
	// Block ends with conditional jump to 0x0597, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])

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

label_0597:
	// Incoming jump from 0x0592, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])
	// Inputs[4]
	// {
	//     @0598  stack[-1]
	//     @0599  msg.data[stack[-1]:stack[-1] + 0x20]
	//     @059E  stack[-2]
	//     @059F  stack[-4]
	// }
	0597    5B  JUMPDEST
	0598    80  DUP1
	0599    35  CALLDATALOAD
	059A    90  SWAP1
	059B    60  PUSH1 0x20
	059D    01  ADD
	059E    91  SWAP2
	059F    84  DUP5
	05A0    60  PUSH1 0x20
	05A2    83  DUP4
	05A3    02  MUL
	05A4    84  DUP5
	05A5    01  ADD
	05A6    11  GT
	05A7    64  PUSH5 0x0100000000
	05AD    83  DUP4
	05AE    11  GT
	05AF    17  OR
	05B0    15  ISZERO
	05B1    61  PUSH2 0x05b9
	05B4    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @059A  stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20]
	//     @059E  stack[0] = stack[-2]
	//     @059E  stack[-2] = 0x20 + stack[-1]
	// }
	// Block ends with conditional jump to 0x05b9, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4]))

label_05B5:
	// Incoming jump from 0x05B4, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4]))
	// Inputs[1] { @05B8  memory[0x00:0x00] }
	05B5    60  PUSH1 0x00
	05B7    80  DUP1
	05B8    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @05B8  revert(memory[0x00:0x00]); }
	// Block terminates

label_05B9:
	// Incoming jump from 0x05B4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4]))
	// Inputs[8]
	// {
	//     @05BA  stack[-3]
	//     @05BA  stack[-1]
	//     @05BB  stack[-2]
	//     @05C6  memory[0x40:0x60]
	//     @05E0  msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]]
	//     @05FC  stack[-4]
	//     @05FD  stack[-5]
	//     @0602  msg.data[stack[-1]:stack[-1] + 0x20]
	// }
	05B9    5B  JUMPDEST
	05BA    91  SWAP2
	05BB    90  SWAP1
	05BC    80  DUP1
	05BD    80  DUP1
	05BE    60  PUSH1 0x20
	05C0    02  MUL
	05C1    60  PUSH1 0x20
	05C3    01  ADD
	05C4    60  PUSH1 0x40
	05C6    51  MLOAD
	05C7    90  SWAP1
	05C8    81  DUP2
	05C9    01  ADD
	05CA    60  PUSH1 0x40
	05CC    52  MSTORE
	05CD    80  DUP1
	05CE    93  SWAP4
	05CF    92  SWAP3
	05D0    91  SWAP2
	05D1    90  SWAP1
	05D2    81  DUP2
	05D3    81  DUP2
	05D4    52  MSTORE
	05D5    60  PUSH1 0x20
	05D7    01  ADD
	05D8    83  DUP4
	05D9    83  DUP4
	05DA    60  PUSH1 0x20
	05DC    02  MUL
	05DD    80  DUP1
	05DE    82  DUP3
	05DF    84  DUP5
	05E0    37  CALLDATACOPY
	05E1    60  PUSH1 0x00
	05E3    81  DUP2
	05E4    84  DUP5
	05E5    01  ADD
	05E6    52  MSTORE
	05E7    60  PUSH1 0x1f
	05E9    19  NOT
	05EA    60  PUSH1 0x1f
	05EC    82  DUP3
	05ED    01  ADD
	05EE    16  AND
	05EF    90  SWAP1
	05F0    50  POP
	05F1    80  DUP1
	05F2    83  DUP4
	05F3    01  ADD
	05F4    92  SWAP3
	05F5    50  POP
	05F6    50  POP
	05F7    50  POP
	05F8    50  POP
	05F9    50  POP
	05FA    50  POP
	05FB    50  POP
	05FC    91  SWAP2
	05FD    92  SWAP3
	05FE    91  SWAP2
	05FF    92  SWAP3
	0600    90  SWAP1
	0601    80  DUP1
	0602    35  CALLDATALOAD
	0603    90  SWAP1
	0604    60  PUSH1 0x20
	0606    01  ADD
	0607    90  SWAP1
	0608    92  SWAP3
	0609    91  SWAP2
	060A    90  SWAP1
	060B    50  POP
	060C    50  POP
	060D    50  POP
	060E    61  PUSH2 0x0f06
	0611    56  *JUMP
	// Stack delta = -3
	// Outputs[6]
	// {
	//     @05CC  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2]
	//     @05D4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @05E0  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]]
	//     @05E6  memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00
	//     @05FF  stack[-5] = memory[0x40:0x60]
	//     @0608  stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0f06

label_0612:
	// Incoming return from call to 0x0568 at 0x0563
	// Inputs[4]
	// {
	//     @0615  memory[0x40:0x60]
	//     @0617  stack[-1]
	//     @0626  memory[0x40:0x60]
	//     @062B  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0612    5B  JUMPDEST
	0613    60  PUSH1 0x40
	0615    51  MLOAD
	0616    80  DUP1
	0617    82  DUP3
	0618    15  ISZERO
	0619    15  ISZERO
	061A    15  ISZERO
	061B    15  ISZERO
	061C    81  DUP2
	061D    52  MSTORE
	061E    60  PUSH1 0x20
	0620    01  ADD
	0621    91  SWAP2
	0622    50  POP
	0623    50  POP
	0624    60  PUSH1 0x40
	0626    51  MLOAD
	0627    80  DUP1
	0628    91  SWAP2
	0629    03  SUB
	062A    90  SWAP1
	062B    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @061D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @062B  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_062C:
	// Incoming jump from 0x0049, if 0xd6d2b6ba == stack[-1]
	// Inputs[1] { @0633  msg.data.length }
	062C    5B  JUMPDEST
	062D    61  PUSH2 0x0705
	0630    60  PUSH1 0x04
	0632    80  DUP1
	0633    36  CALLDATASIZE
	0634    03  SUB
	0635    60  PUSH1 0x40
	0637    81  DUP2
	0638    10  LT
	0639    15  ISZERO
	063A    61  PUSH2 0x0642
	063D    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @062D  stack[0] = 0x0705
	//     @0630  stack[1] = 0x04
	//     @0634  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0642, returns to 0x0705, if !(msg.data.length - 0x04 < 0x40)

label_063E:
	// Incoming jump from 0x063D, if not !(msg.data.length - 0x04 < 0x40)
	// Inputs[1] { @0641  memory[0x00:0x00] }
	063E    60  PUSH1 0x00
	0640    80  DUP1
	0641    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0641  revert(memory[0x00:0x00]); }
	// Block terminates

label_0642:
	// Incoming call from 0x063D, returns to 0x0705, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @0643  stack[-2]
	//     @0644  stack[-1]
	//     @0648  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0668  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0642    5B  JUMPDEST
	0643    81  DUP2
	0644    01  ADD
	0645    90  SWAP1
	0646    80  DUP1
	0647    80  DUP1
	0648    35  CALLDATALOAD
	0649    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	065E    16  AND
	065F    90  SWAP1
	0660    60  PUSH1 0x20
	0662    01  ADD
	0663    90  SWAP1
	0664    92  SWAP3
	0665    91  SWAP2
	0666    90  SWAP1
	0667    80  DUP1
	0668    35  CALLDATALOAD
	0669    90  SWAP1
	066A    60  PUSH1 0x20
	066C    01  ADD
	066D    90  SWAP1
	066E    64  PUSH5 0x0100000000
	0674    81  DUP2
	0675    11  GT
	0676    15  ISZERO
	0677    61  PUSH2 0x067f
	067A    57  *JUMPI
	// Stack delta = +3
	// Outputs[5]
	// {
	//     @0664  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0665  stack[-1] = stack[-2] + stack[-1]
	//     @0666  stack[0] = stack[-2]
	//     @066D  stack[1] = 0x20 + 0x20 + stack[-2]
	//     @066D  stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with conditional jump to 0x067f, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000)

label_067B:
	// Incoming jump from 0x067A, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000)
	// Inputs[1] { @067E  memory[0x00:0x00] }
	067B    60  PUSH1 0x00
	067D    80  DUP1
	067E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @067E  revert(memory[0x00:0x00]); }
	// Block terminates

label_067F:
	// Incoming jump from 0x067A, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000)
	// Inputs[3]
	// {
	//     @0680  stack[-3]
	//     @0681  stack[-1]
	//     @0682  stack[-4]
	// }
	067F    5B  JUMPDEST
	0680    82  DUP3
	0681    01  ADD
	0682    83  DUP4
	0683    60  PUSH1 0x20
	0685    82  DUP3
	0686    01  ADD
	0687    11  GT
	0688    15  ISZERO
	0689    61  PUSH2 0x0691
	068C    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0681  stack[-1] = stack[-3] + stack[-1] }
	// Block ends with conditional jump to 0x0691, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])

label_068D:
	// Incoming jump from 0x068C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4])
	// Inputs[1] { @0690  memory[0x00:0x00] }
	068D    60  PUSH1 0x00
	068F    80  DUP1
	0690    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0690  revert(memory[0x00:0x00]); }
	// Block terminates

label_0691:
	// Incoming jump from 0x068C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4])
	// Inputs[4]
	// {
	//     @0692  stack[-1]
	//     @0693  msg.data[stack[-1]:stack[-1] + 0x20]
	//     @0698  stack[-2]
	//     @0699  stack[-4]
	// }
	0691    5B  JUMPDEST
	0692    80  DUP1
	0693    35  CALLDATALOAD
	0694    90  SWAP1
	0695    60  PUSH1 0x20
	0697    01  ADD
	0698    91  SWAP2
	0699    84  DUP5
	069A    60  PUSH1 0x01
	069C    83  DUP4
	069D    02  MUL
	069E    84  DUP5
	069F    01  ADD
	06A0    11  GT
	06A1    64  PUSH5 0x0100000000
	06A7    83  DUP4
	06A8    11  GT
	06A9    17  OR
	06AA    15  ISZERO
	06AB    61  PUSH2 0x06b3
	06AE    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0694  stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20]
	//     @0698  stack[0] = stack[-2]
	//     @0698  stack[-2] = 0x20 + stack[-1]
	// }
	// Block ends with conditional jump to 0x06b3, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4]))

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

label_06B3:
	// Incoming jump from 0x06AE, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4]))
	// Inputs[7]
	// {
	//     @06B4  stack[-1]
	//     @06B4  stack[-3]
	//     @06B5  stack[-2]
	//     @06C6  memory[0x40:0x60]
	//     @06DD  msg.data[stack[-3]:stack[-3] + stack[-2]]
	//     @06F9  stack[-4]
	//     @06FA  stack[-5]
	// }
	06B3    5B  JUMPDEST
	06B4    91  SWAP2
	06B5    90  SWAP1
	06B6    80  DUP1
	06B7    80  DUP1
	06B8    60  PUSH1 0x1f
	06BA    01  ADD
	06BB    60  PUSH1 0x20
	06BD    80  DUP1
	06BE    91  SWAP2
	06BF    04  DIV
	06C0    02  MUL
	06C1    60  PUSH1 0x20
	06C3    01  ADD
	06C4    60  PUSH1 0x40
	06C6    51  MLOAD
	06C7    90  SWAP1
	06C8    81  DUP2
	06C9    01  ADD
	06CA    60  PUSH1 0x40
	06CC    52  MSTORE
	06CD    80  DUP1
	06CE    93  SWAP4
	06CF    92  SWAP3
	06D0    91  SWAP2
	06D1    90  SWAP1
	06D2    81  DUP2
	06D3    81  DUP2
	06D4    52  MSTORE
	06D5    60  PUSH1 0x20
	06D7    01  ADD
	06D8    83  DUP4
	06D9    83  DUP4
	06DA    80  DUP1
	06DB    82  DUP3
	06DC    84  DUP5
	06DD    37  CALLDATACOPY
	06DE    60  PUSH1 0x00
	06E0    81  DUP2
	06E1    84  DUP5
	06E2    01  ADD
	06E3    52  MSTORE
	06E4    60  PUSH1 0x1f
	06E6    19  NOT
	06E7    60  PUSH1 0x1f
	06E9    82  DUP3
	06EA    01  ADD
	06EB    16  AND
	06EC    90  SWAP1
	06ED    50  POP
	06EE    80  DUP1
	06EF    83  DUP4
	06F0    01  ADD
	06F1    92  SWAP3
	06F2    50  POP
	06F3    50  POP
	06F4    50  POP
	06F5    50  POP
	06F6    50  POP
	06F7    50  POP
	06F8    50  POP
	06F9    91  SWAP2
	06FA    92  SWAP3
	06FB    91  SWAP2
	06FC    92  SWAP3
	06FD    90  SWAP1
	06FE    50  POP
	06FF    50  POP
	0700    50  POP
	0701    61  PUSH2 0x116f
	0704    56  *JUMP
	// Stack delta = -4
	// Outputs[5]
	// {
	//     @06CC  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20
	//     @06D4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @06DD  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]]
	//     @06E3  memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00
	//     @06FC  stack[-5] = memory[0x40:0x60]
	// }
	// Block ends with unconditional jump to 0x116f

label_0705:
	// Incoming return from call to 0x0642 at 0x063D
	0705    5B  JUMPDEST
	0706    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0706  stop(); }
	// Block terminates

label_0707:
	// Incoming jump from 0x0054, if 0xdd62ed3e == stack[-1]
	// Inputs[1] { @0708  msg.value }
	0707    5B  JUMPDEST
	0708    34  CALLVALUE
	0709    80  DUP1
	070A    15  ISZERO
	070B    61  PUSH2 0x0713
	070E    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0708  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0713, if !msg.value

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

label_0713:
	// Incoming jump from 0x070E, if !msg.value
	// Inputs[1] { @071B  msg.data.length }
	0713    5B  JUMPDEST
	0714    50  POP
	0715    61  PUSH2 0x0776
	0718    60  PUSH1 0x04
	071A    80  DUP1
	071B    36  CALLDATASIZE
	071C    03  SUB
	071D    60  PUSH1 0x40
	071F    81  DUP2
	0720    10  LT
	0721    15  ISZERO
	0722    61  PUSH2 0x072a
	0725    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @0715  stack[-1] = 0x0776
	//     @0718  stack[0] = 0x04
	//     @071C  stack[1] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x072a, returns to 0x0776, if !(msg.data.length - 0x04 < 0x40)

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

label_072A:
	// Incoming call from 0x0725, returns to 0x0776, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[4]
	// {
	//     @072B  stack[-2]
	//     @072C  stack[-1]
	//     @0730  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0750  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	072A    5B  JUMPDEST
	072B    81  DUP2
	072C    01  ADD
	072D    90  SWAP1
	072E    80  DUP1
	072F    80  DUP1
	0730    35  CALLDATALOAD
	0731    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0746    16  AND
	0747    90  SWAP1
	0748    60  PUSH1 0x20
	074A    01  ADD
	074B    90  SWAP1
	074C    92  SWAP3
	074D    91  SWAP2
	074E    90  SWAP1
	074F    80  DUP1
	0750    35  CALLDATALOAD
	0751    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0766    16  AND
	0767    90  SWAP1
	0768    60  PUSH1 0x20
	076A    01  ADD
	076B    90  SWAP1
	076C    92  SWAP3
	076D    91  SWAP2
	076E    90  SWAP1
	076F    50  POP
	0770    50  POP
	0771    50  POP
	0772    61  PUSH2 0x1280
	0775    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @074C  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @076C  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x1280

label_0776:
	// Incoming return from call to 0x072A at 0x0725
	// Inputs[4]
	// {
	//     @0779  memory[0x40:0x60]
	//     @077B  stack[-1]
	//     @0786  memory[0x40:0x60]
	//     @078B  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0776    5B  JUMPDEST
	0777    60  PUSH1 0x40
	0779    51  MLOAD
	077A    80  DUP1
	077B    82  DUP3
	077C    81  DUP2
	077D    52  MSTORE
	077E    60  PUSH1 0x20
	0780    01  ADD
	0781    91  SWAP2
	0782    50  POP
	0783    50  POP
	0784    60  PUSH1 0x40
	0786    51  MLOAD
	0787    80  DUP1
	0788    91  SWAP2
	0789    03  SUB
	078A    90  SWAP1
	078B    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @077D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @078B  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_078C:
	// Incoming call from 0x00F6, returns to 0x00F7
	// Inputs[3]
	// {
	//     @0790  storage[0x09]
	//     @07B1  memory[0x40:0x60]
	//     @07C4  storage[0x09]
	// }
	078C    5B  JUMPDEST
	078D    60  PUSH1 0x09
	078F    80  DUP1
	0790    54  SLOAD
	0791    60  PUSH1 0x01
	0793    81  DUP2
	0794    60  PUSH1 0x01
	0796    16  AND
	0797    15  ISZERO
	0798    61  PUSH2 0x0100
	079B    02  MUL
	079C    03  SUB
	079D    16  AND
	079E    60  PUSH1 0x02
	07A0    90  SWAP1
	07A1    04  DIV
	07A2    80  DUP1
	07A3    60  PUSH1 0x1f
	07A5    01  ADD
	07A6    60  PUSH1 0x20
	07A8    80  DUP1
	07A9    91  SWAP2
	07AA    04  DIV
	07AB    02  MUL
	07AC    60  PUSH1 0x20
	07AE    01  ADD
	07AF    60  PUSH1 0x40
	07B1    51  MLOAD
	07B2    90  SWAP1
	07B3    81  DUP2
	07B4    01  ADD
	07B5    60  PUSH1 0x40
	07B7    52  MSTORE
	07B8    80  DUP1
	07B9    92  SWAP3
	07BA    91  SWAP2
	07BB    90  SWAP1
	07BC    81  DUP2
	07BD    81  DUP2
	07BE    52  MSTORE
	07BF    60  PUSH1 0x20
	07C1    01  ADD
	07C2    82  DUP3
	07C3    80  DUP1
	07C4    54  SLOAD
	07C5    60  PUSH1 0x01
	07C7    81  DUP2
	07C8    60  PUSH1 0x01
	07CA    16  AND
	07CB    15  ISZERO
	07CC    61  PUSH2 0x0100
	07CF    02  MUL
	07D0    03  SUB
	07D1    16  AND
	07D2    60  PUSH1 0x02
	07D4    90  SWAP1
	07D5    04  DIV
	07D6    80  DUP1
	07D7    15  ISZERO
	07D8    61  PUSH2 0x0822
	07DB    57  *JUMPI
	// Stack delta = +6
	// Outputs[8]
	// {
	//     @07B7  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) / 0x20 * 0x20
	//     @07B9  stack[0] = memory[0x40:0x60]
	//     @07BA  stack[1] = 0x09
	//     @07BB  stack[2] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02
	//     @07BE  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02
	//     @07C1  stack[3] = 0x20 + memory[0x40:0x60]
	//     @07C2  stack[4] = 0x09
	//     @07D5  stack[5] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02
	// }
	// Block ends with conditional jump to 0x0822, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02)

label_07DC:
	// Incoming jump from 0x07DB, if not !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02)
	// Inputs[1] { @07DC  stack[-1] }
	07DC    80  DUP1
	07DD    60  PUSH1 0x1f
	07DF    10  LT
	07E0    61  PUSH2 0x07f7
	07E3    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x07f7, if 0x1f < stack[-1]

label_07E4:
	// Incoming jump from 0x07E3, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @07E8  stack[-2]
	//     @07E9  storage[stack[-2]]
	//     @07EC  stack[-3]
	//     @07EE  stack[-1]
	// }
	07E4    61  PUSH2 0x0100
	07E7    80  DUP1
	07E8    83  DUP4
	07E9    54  SLOAD
	07EA    04  DIV
	07EB    02  MUL
	07EC    83  DUP4
	07ED    52  MSTORE
	07EE    91  SWAP2
	07EF    60  PUSH1 0x20
	07F1    01  ADD
	07F2    91  SWAP2
	07F3    61  PUSH2 0x0822
	07F6    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @07ED  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @07F2  stack[-1] = stack[-1]
	//     @07F2  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x0822

label_07F7:
	// Incoming jump from 0x07E3, if 0x1f < stack[-1]
	// Inputs[5]
	// {
	//     @07F8  stack[-3]
	//     @07F9  stack[-1]
	//     @07FB  stack[-2]
	//     @0803  memory[0x00:0x20]
	//     @0807  storage[keccak256(memory[0x00:0x20])]
	// }
	07F7    5B  JUMPDEST
	07F8    82  DUP3
	07F9    01  ADD
	07FA    91  SWAP2
	07FB    90  SWAP1
	07FC    60  PUSH1 0x00
	07FE    52  MSTORE
	07FF    60  PUSH1 0x20
	0801    60  PUSH1 0x00
	0803    20  SHA3
	0804    90  SWAP1
	0805    5B  JUMPDEST
	0806    81  DUP2
	0807    54  SLOAD
	0808    81  DUP2
	0809    52  MSTORE
	080A    90  SWAP1
	080B    60  PUSH1 0x01
	080D    01  ADD
	080E    90  SWAP1
	080F    60  PUSH1 0x20
	0811    01  ADD
	0812    80  DUP1
	0813    83  DUP4
	0814    11  GT
	0815    61  PUSH2 0x0805
	0818    57  *JUMPI
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @07FA  stack[-3] = stack[-3] + stack[-1]
	//     @07FE  memory[0x00:0x20] = stack[-2]
	//     @0809  memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])]
	//     @080E  stack[-2] = 0x01 + keccak256(memory[0x00:0x20])
	//     @0811  stack[-1] = 0x20 + stack[-3]
	// }
	// Block ends with conditional jump to 0x0805, if stack[-3] + stack[-1] > 0x20 + stack[-3]

label_0819:
	// Incoming jump from 0x0818, if not stack[-3] + stack[-1] > 0x20 + stack[-3]
	// Incoming jump from 0x0818, if not stack[-3] > 0x20 + stack[-1]
	// Inputs[2]
	// {
	//     @0819  stack[-3]
	//     @081A  stack[-1]
	// }
	0819    82  DUP3
	081A    90  SWAP1
	081B    03  SUB
	081C    60  PUSH1 0x1f
	081E    16  AND
	081F    82  DUP3
	0820    01  ADD
	0821    91  SWAP2
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0821  stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3])
	//     @0821  stack[-1] = stack[-3]
	// }
	// Block continues

label_0822:
	// Incoming jump from 0x07DB, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02)
	// Incoming jump from 0x0821
	// Incoming jump from 0x07F6
	// Inputs[1] { @0828  stack[-7] }
	0822    5B  JUMPDEST
	0823    50  POP
	0824    50  POP
	0825    50  POP
	0826    50  POP
	0827    50  POP
	0828    81  DUP2
	0829    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-7]

label_082A:
	// Incoming jump from 0x01BD
	// Inputs[10]
	// {
	//     @082D  stack[-1]
	//     @0832  msg.sender
	//     @086C  memory[0x00:0x40]
	//     @086F  stack[-2]
	//     @08A9  memory[0x00:0x40]
	//     @08C5  msg.sender
	//     @0900  memory[0x40:0x60]
	//     @090D  memory[0x40:0x60]
	//     @0912  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @0917  stack[-3]
	// }
	082A    5B  JUMPDEST
	082B    60  PUSH1 0x00
	082D    81  DUP2
	082E    60  PUSH1 0x07
	0830    60  PUSH1 0x00
	0832    33  CALLER
	0833    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0848    16  AND
	0849    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	085E    16  AND
	085F    81  DUP2
	0860    52  MSTORE
	0861    60  PUSH1 0x20
	0863    01  ADD
	0864    90  SWAP1
	0865    81  DUP2
	0866    52  MSTORE
	0867    60  PUSH1 0x20
	0869    01  ADD
	086A    60  PUSH1 0x00
	086C    20  SHA3
	086D    60  PUSH1 0x00
	086F    85  DUP6
	0870    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0885    16  AND
	0886    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	089B    16  AND
	089C    81  DUP2
	089D    52  MSTORE
	089E    60  PUSH1 0x20
	08A0    01  ADD
	08A1    90  SWAP1
	08A2    81  DUP2
	08A3    52  MSTORE
	08A4    60  PUSH1 0x20
	08A6    01  ADD
	08A7    60  PUSH1 0x00
	08A9    20  SHA3
	08AA    81  DUP2
	08AB    90  SWAP1
	08AC    55  SSTORE
	08AD    50  POP
	08AE    82  DUP3
	08AF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	08C4    16  AND
	08C5    33  CALLER
	08C6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	08DB    16  AND
	08DC    7F  PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925
	08FD    84  DUP5
	08FE    60  PUSH1 0x40
	0900    51  MLOAD
	0901    80  DUP1
	0902    82  DUP3
	0903    81  DUP2
	0904    52  MSTORE
	0905    60  PUSH1 0x20
	0907    01  ADD
	0908    91  SWAP2
	0909    50  POP
	090A    50  POP
	090B    60  PUSH1 0x40
	090D    51  MLOAD
	090E    80  DUP1
	090F    91  SWAP2
	0910    03  SUB
	0911    90  SWAP1
	0912    A3  LOG3
	0913    60  PUSH1 0x01
	0915    90  SWAP1
	0916    50  POP
	0917    92  SWAP3
	0918    91  SWAP2
	0919    50  POP
	091A    50  POP
	091B    56  *JUMP
	// Stack delta = -2
	// Outputs[8]
	// {
	//     @0860  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0866  memory[0x20:0x40] = 0x07
	//     @089D  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @08A3  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @08AC  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0904  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0912  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]);
	//     @0917  stack[-3] = 0x01
	// }
	// Block ends with unconditional jump to stack[-3]

label_091C:
	// Incoming jump from 0x0230
	// Inputs[2]
	// {
	//     @0924  storage[0x0b]
	//     @0958  msg.sender
	// }
	091C    5B  JUMPDEST
	091D    60  PUSH1 0x00
	091F    60  PUSH1 0x0b
	0921    60  PUSH1 0x00
	0923    90  SWAP1
	0924    54  SLOAD
	0925    90  SWAP1
	0926    61  PUSH2 0x0100
	0929    0A  EXP
	092A    90  SWAP1
	092B    04  DIV
	092C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0941    16  AND
	0942    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0957    16  AND
	0958    33  CALLER
	0959    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	096E    16  AND
	096F    14  EQ
	0970    61  PUSH2 0x0978
	0973    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @091D  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0978, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_0974:
	// Incoming jump from 0x0973, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @0977  memory[0x00:0x00] }
	0974    60  PUSH1 0x00
	0976    80  DUP1
	0977    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0977  revert(memory[0x00:0x00]); }
	// Block terminates

label_0978:
	// Incoming jump from 0x0973, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @097B  stack[-2] }
	0978    5B  JUMPDEST
	0979    60  PUSH1 0x00
	097B    82  DUP3
	097C    11  GT
	097D    15  ISZERO
	097E    61  PUSH2 0x09cc
	0981    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x09cc, if !(stack[-2] > 0x00)

label_0982:
	// Incoming jump from 0x0981, if not !(stack[-2] > 0x00)
	// Inputs[7]
	// {
	//     @0987  stack[-2]
	//     @098D  stack[-3]
	//     @09C7  memory[0x00:0x40]
	//     @0A0C  memory[0x00:0x40]
	//     @0A14  storage[keccak256(memory[0x00:0x40])]
	//     @0A26  stack[-1]
	//     @0A28  stack[-4]
	// }
	0982    60  PUSH1 0x12
	0984    60  PUSH1 0x0a
	0986    0A  EXP
	0987    82  DUP3
	0988    02  MUL
	0989    60  PUSH1 0x06
	098B    60  PUSH1 0x00
	098D    85  DUP6
	098E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09A3    16  AND
	09A4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09B9    16  AND
	09BA    81  DUP2
	09BB    52  MSTORE
	09BC    60  PUSH1 0x20
	09BE    01  ADD
	09BF    90  SWAP1
	09C0    81  DUP2
	09C1    52  MSTORE
	09C2    60  PUSH1 0x20
	09C4    01  ADD
	09C5    60  PUSH1 0x00
	09C7    20  SHA3
	09C8    81  DUP2
	09C9    90  SWAP1
	09CA    55  SSTORE
	09CB    50  POP
	09CC    5B  JUMPDEST
	09CD    60  PUSH1 0x01
	09CF    80  DUP1
	09D0    60  PUSH1 0x00
	09D2    85  DUP6
	09D3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09E8    16  AND
	09E9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	09FE    16  AND
	09FF    81  DUP2
	0A00    52  MSTORE
	0A01    60  PUSH1 0x20
	0A03    01  ADD
	0A04    90  SWAP1
	0A05    81  DUP2
	0A06    52  MSTORE
	0A07    60  PUSH1 0x20
	0A09    01  ADD
	0A0A    60  PUSH1 0x00
	0A0C    20  SHA3
	0A0D    60  PUSH1 0x00
	0A0F    61  PUSH2 0x0100
	0A12    0A  EXP
	0A13    81  DUP2
	0A14    54  SLOAD
	0A15    81  DUP2
	0A16    60  PUSH1 0xff
	0A18    02  MUL
	0A19    19  NOT
	0A1A    16  AND
	0A1B    90  SWAP1
	0A1C    83  DUP4
	0A1D    15  ISZERO
	0A1E    15  ISZERO
	0A1F    02  MUL
	0A20    17  OR
	0A21    90  SWAP1
	0A22    55  SSTORE
	0A23    50  POP
	0A24    60  PUSH1 0x01
	0A26    90  SWAP1
	0A27    50  POP
	0A28    92  SWAP3
	0A29    91  SWAP2
	0A2A    50  POP
	0A2B    50  POP
	0A2C    56  *JUMP
	// Stack delta = -3
	// Outputs[7]
	// {
	//     @09BB  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @09C1  memory[0x20:0x40] = 0x06
	//     @09CA  storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x0a ** 0x12
	//     @0A00  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @0A06  memory[0x20:0x40] = 0x01
	//     @0A22  storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])])
	//     @0A28  stack[-4] = 0x01
	// }
	// Block ends with unconditional jump to stack[-4]

label_0A2D:
	// Incoming call from 0x025F, returns to 0x0260
	// Inputs[2]
	// {
	//     @0A30  storage[0x08]
	//     @0A31  stack[-1]
	// }
	0A2D    5B  JUMPDEST
	0A2E    60  PUSH1 0x08
	0A30    54  SLOAD
	0A31    81  DUP2
	0A32    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0A30  stack[0] = storage[0x08] }
	// Block ends with unconditional jump to stack[-1]

label_0A33:
	// Incoming jump from 0x02C4
	// Inputs[3]
	// {
	//     @0A36  stack[-1]
	//     @0A40  storage[0x05]
	//     @0A7B  stack[-2]
	// }
	0A33    5B  JUMPDEST
	0A34    60  PUSH1 0x00
	0A36    81  DUP2
	0A37    60  PUSH1 0x05
	0A39    60  PUSH1 0x00
	0A3B    61  PUSH2 0x0100
	0A3E    0A  EXP
	0A3F    81  DUP2
	0A40    54  SLOAD
	0A41    81  DUP2
	0A42    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0A57    02  MUL
	0A58    19  NOT
	0A59    16  AND
	0A5A    90  SWAP1
	0A5B    83  DUP4
	0A5C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0A71    16  AND
	0A72    02  MUL
	0A73    17  OR
	0A74    90  SWAP1
	0A75    55  SSTORE
	0A76    50  POP
	0A77    60  PUSH1 0x01
	0A79    90  SWAP1
	0A7A    50  POP
	0A7B    91  SWAP2
	0A7C    90  SWAP1
	0A7D    50  POP
	0A7E    56  *JUMP
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0A75  storage[0x05] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x05])
	//     @0A7B  stack[-2] = 0x01
	// }
	// Block ends with unconditional jump to stack[-2]

label_0A7F:
	// Incoming call from 0x0EFD, returns to 0x0EFE
	// Incoming jump from 0x034A
	// Inputs[1] { @0A83  stack[-1] }
	0A7F    5B  JUMPDEST
	0A80    60  PUSH1 0x00
	0A82    80  DUP1
	0A83    82  DUP3
	0A84    14  EQ
	0A85    15  ISZERO
	0A86    61  PUSH2 0x0a92
	0A89    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0A80  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0a92, if !(stack[-1] == 0x00)

label_0A8A:
	// Incoming jump from 0x0A89, if not !(stack[-1] == 0x00)
	// Inputs[1] { @0A8C  stack[-1] }
	0A8A    60  PUSH1 0x01
	0A8C    90  SWAP1
	0A8D    50  POP
	0A8E    61  PUSH2 0x0d8b
	0A91    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0A8C  stack[-1] = 0x01 }
	// Block ends with unconditional jump to 0x0d8b

label_0A92:
	// Incoming jump from 0x0A89, if !(stack[-1] == 0x00)
	// Inputs[2]
	// {
	//     @0A93  stack[-4]
	//     @0AAA  msg.sender
	// }
	0A92    5B  JUMPDEST
	0A93    83  DUP4
	0A94    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AA9    16  AND
	0AAA    33  CALLER
	0AAB    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AC0    16  AND
	0AC1    14  EQ
	0AC2    61  PUSH2 0x0bd9
	0AC5    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0bd9, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]

label_0AC6:
	// Incoming jump from 0x0AC5, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	// Inputs[6]
	// {
	//     @0AC6  stack[-2]
	//     @0ACB  stack[-4]
	//     @0B05  memory[0x00:0x40]
	//     @0B08  msg.sender
	//     @0B42  memory[0x00:0x40]
	//     @0B43  storage[keccak256(memory[0x00:0x40])]
	// }
	0AC6    81  DUP2
	0AC7    60  PUSH1 0x07
	0AC9    60  PUSH1 0x00
	0ACB    86  DUP7
	0ACC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AE1    16  AND
	0AE2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AF7    16  AND
	0AF8    81  DUP2
	0AF9    52  MSTORE
	0AFA    60  PUSH1 0x20
	0AFC    01  ADD
	0AFD    90  SWAP1
	0AFE    81  DUP2
	0AFF    52  MSTORE
	0B00    60  PUSH1 0x20
	0B02    01  ADD
	0B03    60  PUSH1 0x00
	0B05    20  SHA3
	0B06    60  PUSH1 0x00
	0B08    33  CALLER
	0B09    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B1E    16  AND
	0B1F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B34    16  AND
	0B35    81  DUP2
	0B36    52  MSTORE
	0B37    60  PUSH1 0x20
	0B39    01  ADD
	0B3A    90  SWAP1
	0B3B    81  DUP2
	0B3C    52  MSTORE
	0B3D    60  PUSH1 0x20
	0B3F    01  ADD
	0B40    60  PUSH1 0x00
	0B42    20  SHA3
	0B43    54  SLOAD
	0B44    10  LT
	0B45    15  ISZERO
	0B46    61  PUSH2 0x0b4e
	0B49    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @0AF9  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0AFF  memory[0x20:0x40] = 0x07
	//     @0B36  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0B3C  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	// }
	// Block ends with conditional jump to 0x0b4e, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2])

label_0B4A:
	// Incoming jump from 0x0B49, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2])
	// Inputs[1] { @0B4D  memory[0x00:0x00] }
	0B4A    60  PUSH1 0x00
	0B4C    80  DUP1
	0B4D    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0B4D  revert(memory[0x00:0x00]); }
	// Block terminates

label_0B4E:
	// Incoming jump from 0x0B49, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2])
	// Inputs[6]
	// {
	//     @0B4F  stack[-2]
	//     @0B54  stack[-4]
	//     @0B8E  memory[0x00:0x40]
	//     @0B91  msg.sender
	//     @0BCB  memory[0x00:0x40]
	//     @0BD0  storage[keccak256(memory[0x00:0x40])]
	// }
	0B4E    5B  JUMPDEST
	0B4F    81  DUP2
	0B50    60  PUSH1 0x07
	0B52    60  PUSH1 0x00
	0B54    86  DUP7
	0B55    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B6A    16  AND
	0B6B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0B80    16  AND
	0B81    81  DUP2
	0B82    52  MSTORE
	0B83    60  PUSH1 0x20
	0B85    01  ADD
	0B86    90  SWAP1
	0B87    81  DUP2
	0B88    52  MSTORE
	0B89    60  PUSH1 0x20
	0B8B    01  ADD
	0B8C    60  PUSH1 0x00
	0B8E    20  SHA3
	0B8F    60  PUSH1 0x00
	0B91    33  CALLER
	0B92    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0BA7    16  AND
	0BA8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0BBD    16  AND
	0BBE    81  DUP2
	0BBF    52  MSTORE
	0BC0    60  PUSH1 0x20
	0BC2    01  ADD
	0BC3    90  SWAP1
	0BC4    81  DUP2
	0BC5    52  MSTORE
	0BC6    60  PUSH1 0x20
	0BC8    01  ADD
	0BC9    60  PUSH1 0x00
	0BCB    20  SHA3
	0BCC    60  PUSH1 0x00
	0BCE    82  DUP3
	0BCF    82  DUP3
	0BD0    54  SLOAD
	0BD1    03  SUB
	0BD2    92  SWAP3
	0BD3    50  POP
	0BD4    50  POP
	0BD5    81  DUP2
	0BD6    90  SWAP1
	0BD7    55  SSTORE
	0BD8    50  POP
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0B82  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0B88  memory[0x20:0x40] = 0x07
	//     @0BBF  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0BC5  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0BD7  storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2]
	// }
	// Block continues

label_0BD9:
	// Incoming jump from 0x0AC5, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	// Incoming jump from 0x0BD8
	// Inputs[3]
	// {
	//     @0BDD  stack[-4]
	//     @0BDE  stack[-3]
	//     @0BDF  stack[-2]
	// }
	0BD9    5B  JUMPDEST
	0BDA    61  PUSH2 0x0be4
	0BDD    84  DUP5
	0BDE    84  DUP5
	0BDF    84  DUP5
	0BE0    61  PUSH2 0x12a5
	0BE3    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0BDA  stack[0] = 0x0be4
	//     @0BDD  stack[1] = stack[-4]
	//     @0BDE  stack[2] = stack[-3]
	//     @0BDF  stack[3] = stack[-2]
	// }
	// Block ends with call to 0x12a5, returns to 0x0BE4

label_0BE4:
	// Incoming return from call to 0x12A5 at 0x0BE3
	// Inputs[1] { @0BE8  stack[-1] }
	0BE4    5B  JUMPDEST
	0BE5    61  PUSH2 0x0bed
	0BE8    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0bed, if stack[-1]

label_0BE9:
	// Incoming jump from 0x0BE8, if not stack[-1]
	// Inputs[1] { @0BEC  memory[0x00:0x00] }
	0BE9    60  PUSH1 0x00
	0BEB    80  DUP1
	0BEC    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0BEC  revert(memory[0x00:0x00]); }
	// Block terminates

label_0BED:
	// Incoming jump from 0x0BE8, if stack[-1]
	// Inputs[4]
	// {
	//     @0BEE  stack[-2]
	//     @0BF3  stack[-4]
	//     @0C2D  memory[0x00:0x40]
	//     @0C2E  storage[keccak256(memory[0x00:0x40])]
	// }
	0BED    5B  JUMPDEST
	0BEE    81  DUP2
	0BEF    60  PUSH1 0x06
	0BF1    60  PUSH1 0x00
	0BF3    86  DUP7
	0BF4    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C09    16  AND
	0C0A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C1F    16  AND
	0C20    81  DUP2
	0C21    52  MSTORE
	0C22    60  PUSH1 0x20
	0C24    01  ADD
	0C25    90  SWAP1
	0C26    81  DUP2
	0C27    52  MSTORE
	0C28    60  PUSH1 0x20
	0C2A    01  ADD
	0C2B    60  PUSH1 0x00
	0C2D    20  SHA3
	0C2E    54  SLOAD
	0C2F    10  LT
	0C30    15  ISZERO
	0C31    61  PUSH2 0x0c39
	0C34    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0C21  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0C27  memory[0x20:0x40] = 0x06
	// }
	// Block ends with conditional jump to 0x0c39, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2])

label_0C35:
	// Incoming jump from 0x0C34, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2])
	// Inputs[1] { @0C38  memory[0x00:0x00] }
	0C35    60  PUSH1 0x00
	0C37    80  DUP1
	0C38    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0C38  revert(memory[0x00:0x00]); }
	// Block terminates

label_0C39:
	// Incoming jump from 0x0C34, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2])
	// Inputs[13]
	// {
	//     @0C3A  stack[-2]
	//     @0C3F  stack[-4]
	//     @0C79  memory[0x00:0x40]
	//     @0C7E  storage[keccak256(memory[0x00:0x40])]
	//     @0C8C  stack[-3]
	//     @0CC6  memory[0x00:0x40]
	//     @0CCB  storage[keccak256(memory[0x00:0x40])]
	//     @0D11  memory[0x00:0x40]
	//     @0D15  storage[keccak256(memory[0x00:0x40])]
	//     @0D74  memory[0x40:0x60]
	//     @0D81  memory[0x40:0x60]
	//     @0D86  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @0D89  stack[-1]
	// }
	0C39    5B  JUMPDEST
	0C3A    81  DUP2
	0C3B    60  PUSH1 0x06
	0C3D    60  PUSH1 0x00
	0C3F    86  DUP7
	0C40    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C55    16  AND
	0C56    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0C6B    16  AND
	0C6C    81  DUP2
	0C6D    52  MSTORE
	0C6E    60  PUSH1 0x20
	0C70    01  ADD
	0C71    90  SWAP1
	0C72    81  DUP2
	0C73    52  MSTORE
	0C74    60  PUSH1 0x20
	0C76    01  ADD
	0C77    60  PUSH1 0x00
	0C79    20  SHA3
	0C7A    60  PUSH1 0x00
	0C7C    82  DUP3
	0C7D    82  DUP3
	0C7E    54  SLOAD
	0C7F    03  SUB
	0C80    92  SWAP3
	0C81    50  POP
	0C82    50  POP
	0C83    81  DUP2
	0C84    90  SWAP1
	0C85    55  SSTORE
	0C86    50  POP
	0C87    81  DUP2
	0C88    60  PUSH1 0x06
	0C8A    60  PUSH1 0x00
	0C8C    85  DUP6
	0C8D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CA2    16  AND
	0CA3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CB8    16  AND
	0CB9    81  DUP2
	0CBA    52  MSTORE
	0CBB    60  PUSH1 0x20
	0CBD    01  ADD
	0CBE    90  SWAP1
	0CBF    81  DUP2
	0CC0    52  MSTORE
	0CC1    60  PUSH1 0x20
	0CC3    01  ADD
	0CC4    60  PUSH1 0x00
	0CC6    20  SHA3
	0CC7    60  PUSH1 0x00
	0CC9    82  DUP3
	0CCA    82  DUP3
	0CCB    54  SLOAD
	0CCC    01  ADD
	0CCD    92  SWAP3
	0CCE    50  POP
	0CCF    50  POP
	0CD0    81  DUP2
	0CD1    90  SWAP1
	0CD2    55  SSTORE
	0CD3    50  POP
	0CD4    60  PUSH1 0x00
	0CD6    80  DUP1
	0CD7    85  DUP6
	0CD8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0CED    16  AND
	0CEE    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D03    16  AND
	0D04    81  DUP2
	0D05    52  MSTORE
	0D06    60  PUSH1 0x20
	0D08    01  ADD
	0D09    90  SWAP1
	0D0A    81  DUP2
	0D0B    52  MSTORE
	0D0C    60  PUSH1 0x20
	0D0E    01  ADD
	0D0F    60  PUSH1 0x00
	0D11    20  SHA3
	0D12    60  PUSH1 0x00
	0D14    81  DUP2
	0D15    54  SLOAD
	0D16    80  DUP1
	0D17    92  SWAP3
	0D18    91  SWAP2
	0D19    90  SWAP1
	0D1A    60  PUSH1 0x01
	0D1C    01  ADD
	0D1D    91  SWAP2
	0D1E    90  SWAP1
	0D1F    50  POP
	0D20    55  SSTORE
	0D21    50  POP
	0D22    82  DUP3
	0D23    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D38    16  AND
	0D39    84  DUP5
	0D3A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0D4F    16  AND
	0D50    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	0D71    84  DUP5
	0D72    60  PUSH1 0x40
	0D74    51  MLOAD
	0D75    80  DUP1
	0D76    82  DUP3
	0D77    81  DUP2
	0D78    52  MSTORE
	0D79    60  PUSH1 0x20
	0D7B    01  ADD
	0D7C    91  SWAP2
	0D7D    50  POP
	0D7E    50  POP
	0D7F    60  PUSH1 0x40
	0D81    51  MLOAD
	0D82    80  DUP1
	0D83    91  SWAP2
	0D84    03  SUB
	0D85    90  SWAP1
	0D86    A3  LOG3
	0D87    60  PUSH1 0x01
	0D89    90  SWAP1
	0D8A    50  POP
	// Stack delta = +0
	// Outputs[12]
	// {
	//     @0C6D  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0C73  memory[0x20:0x40] = 0x06
	//     @0C85  storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2]
	//     @0CBA  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @0CC0  memory[0x20:0x40] = 0x06
	//     @0CD2  storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-2]
	//     @0D05  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0D0B  memory[0x20:0x40] = 0x00
	//     @0D20  storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])]
	//     @0D78  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @0D86  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]);
	//     @0D89  stack[-1] = 0x01
	// }
	// Block continues

label_0D8B:
	// Incoming jump from 0x0D8A
	// Incoming jump from 0x0A91
	// Inputs[3]
	// {
	//     @0D8C  stack[-1]
	//     @0D8C  stack[-5]
	//     @0D8D  stack[-4]
	// }
	0D8B    5B  JUMPDEST
	0D8C    93  SWAP4
	0D8D    92  SWAP3
	0D8E    50  POP
	0D8F    50  POP
	0D90    50  POP
	0D91    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @0D8C  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_0D92:
	// Incoming call from 0x0379, returns to 0x037A
	// Inputs[1] { @0D95  stack[-1] }
	0D92    5B  JUMPDEST
	0D93    60  PUSH1 0x12
	0D95    81  DUP2
	0D96    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0D93  stack[0] = 0x12 }
	// Block ends with unconditional jump to stack[-1]

label_0D97:
	// Incoming jump from 0x03DE
	// Inputs[4]
	// {
	//     @0D9D  stack[-1]
	//     @0DA5  memory[0x00:0x40]
	//     @0DAC  storage[keccak256(memory[0x00:0x40])]
	//     @0DAD  stack[-2]
	// }
	0D97    5B  JUMPDEST
	0D98    60  PUSH1 0x06
	0D9A    60  PUSH1 0x20
	0D9C    52  MSTORE
	0D9D    80  DUP1
	0D9E    60  PUSH1 0x00
	0DA0    52  MSTORE
	0DA1    60  PUSH1 0x40
	0DA3    60  PUSH1 0x00
	0DA5    20  SHA3
	0DA6    60  PUSH1 0x00
	0DA8    91  SWAP2
	0DA9    50  POP
	0DAA    90  SWAP1
	0DAB    50  POP
	0DAC    54  SLOAD
	0DAD    81  DUP2
	0DAE    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0D9C  memory[0x20:0x40] = 0x06
	//     @0DA0  memory[0x00:0x20] = stack[-1]
	//     @0DAC  stack[-1] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-2]

label_0DAF:
	// Incoming jump from 0x0441
	// Inputs[2]
	// {
	//     @0DB7  storage[0x0b]
	//     @0DEB  msg.sender
	// }
	0DAF    5B  JUMPDEST
	0DB0    60  PUSH1 0x00
	0DB2    60  PUSH1 0x0b
	0DB4    60  PUSH1 0x00
	0DB6    90  SWAP1
	0DB7    54  SLOAD
	0DB8    90  SWAP1
	0DB9    61  PUSH2 0x0100
	0DBC    0A  EXP
	0DBD    90  SWAP1
	0DBE    04  DIV
	0DBF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0DD4    16  AND
	0DD5    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0DEA    16  AND
	0DEB    33  CALLER
	0DEC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0E01    16  AND
	0E02    14  EQ
	0E03    61  PUSH2 0x0e0b
	0E06    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0DB0  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0e0b, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_0E07:
	// Incoming jump from 0x0E06, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @0E0A  memory[0x00:0x00] }
	0E07    60  PUSH1 0x00
	0E09    80  DUP1
	0E0A    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0E0A  revert(memory[0x00:0x00]); }
	// Block terminates

label_0E0B:
	// Incoming jump from 0x0E06, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @0E0E  stack[-3] }
	0E0B    5B  JUMPDEST
	0E0C    60  PUSH1 0x00
	0E0E    83  DUP4
	0E0F    11  GT
	0E10    61  PUSH2 0x0e1a
	0E13    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0e1a, if stack[-3] > 0x00

label_0E14:
	// Incoming jump from 0x0E13, if not stack[-3] > 0x00
	0E14    60  PUSH1 0x00
	0E16    61  PUSH2 0x0e22
	0E19    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0E14  stack[0] = 0x00 }
	// Block ends with unconditional jump to 0x0e22

label_0E1A:
	// Incoming jump from 0x0E13, if stack[-3] > 0x00
	// Inputs[2]
	// {
	//     @0E20  stack[-3]
	//     @0E2B  stack[-2]
	// }
	0E1A    5B  JUMPDEST
	0E1B    60  PUSH1 0x12
	0E1D    60  PUSH1 0x0a
	0E1F    0A  EXP
	0E20    83  DUP4
	0E21    02  MUL
	0E22    5B  JUMPDEST
	0E23    60  PUSH1 0x02
	0E25    81  DUP2
	0E26    90  SWAP1
	0E27    55  SSTORE
	0E28    50  POP
	0E29    60  PUSH1 0x00
	0E2B    82  DUP3
	0E2C    11  GT
	0E2D    61  PUSH2 0x0e37
	0E30    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0E27  storage[0x02] = stack[-3] * 0x0a ** 0x12 }
	// Block ends with conditional jump to 0x0e37, if stack[-2] > 0x00

label_0E31:
	// Incoming jump from 0x0E30, if not stack[-3] > 0x00
	// Incoming jump from 0x0E30, if not stack[-2] > 0x00
	0E31    60  PUSH1 0x00
	0E33    61  PUSH2 0x0e3f
	0E36    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0E31  stack[0] = 0x00 }
	// Block ends with unconditional jump to 0x0e3f

label_0E37:
	// Incoming jump from 0x0E30, if stack[-3] > 0x00
	// Incoming jump from 0x0E30, if stack[-2] > 0x00
	// Inputs[4]
	// {
	//     @0E3D  stack[-2]
	//     @0E46  stack[-4]
	//     @0E4D  stack[-1]
	//     @0E4D  stack[-5]
	// }
	0E37    5B  JUMPDEST
	0E38    60  PUSH1 0x12
	0E3A    60  PUSH1 0x0a
	0E3C    0A  EXP
	0E3D    82  DUP3
	0E3E    02  MUL
	0E3F    5B  JUMPDEST
	0E40    60  PUSH1 0x03
	0E42    81  DUP2
	0E43    90  SWAP1
	0E44    55  SSTORE
	0E45    50  POP
	0E46    83  DUP4
	0E47    60  PUSH1 0x04
	0E49    81  DUP2
	0E4A    90  SWAP1
	0E4B    55  SSTORE
	0E4C    50  POP
	0E4D    93  SWAP4
	0E4E    92  SWAP3
	0E4F    50  POP
	0E50    50  POP
	0E51    50  POP
	0E52    56  *JUMP
	// Stack delta = -4
	// Outputs[3]
	// {
	//     @0E44  storage[0x03] = stack[-2] * 0x0a ** 0x12
	//     @0E4B  storage[0x04] = stack[-4]
	//     @0E4D  stack[-5] = stack[-1]
	// }
	// Block ends with unconditional jump to stack[-5]

label_0E53:
	// Incoming call from 0x0470, returns to 0x0471
	// Inputs[3]
	// {
	//     @0E57  storage[0x0a]
	//     @0E78  memory[0x40:0x60]
	//     @0E8B  storage[0x0a]
	// }
	0E53    5B  JUMPDEST
	0E54    60  PUSH1 0x0a
	0E56    80  DUP1
	0E57    54  SLOAD
	0E58    60  PUSH1 0x01
	0E5A    81  DUP2
	0E5B    60  PUSH1 0x01
	0E5D    16  AND
	0E5E    15  ISZERO
	0E5F    61  PUSH2 0x0100
	0E62    02  MUL
	0E63    03  SUB
	0E64    16  AND
	0E65    60  PUSH1 0x02
	0E67    90  SWAP1
	0E68    04  DIV
	0E69    80  DUP1
	0E6A    60  PUSH1 0x1f
	0E6C    01  ADD
	0E6D    60  PUSH1 0x20
	0E6F    80  DUP1
	0E70    91  SWAP2
	0E71    04  DIV
	0E72    02  MUL
	0E73    60  PUSH1 0x20
	0E75    01  ADD
	0E76    60  PUSH1 0x40
	0E78    51  MLOAD
	0E79    90  SWAP1
	0E7A    81  DUP2
	0E7B    01  ADD
	0E7C    60  PUSH1 0x40
	0E7E    52  MSTORE
	0E7F    80  DUP1
	0E80    92  SWAP3
	0E81    91  SWAP2
	0E82    90  SWAP1
	0E83    81  DUP2
	0E84    81  DUP2
	0E85    52  MSTORE
	0E86    60  PUSH1 0x20
	0E88    01  ADD
	0E89    82  DUP3
	0E8A    80  DUP1
	0E8B    54  SLOAD
	0E8C    60  PUSH1 0x01
	0E8E    81  DUP2
	0E8F    60  PUSH1 0x01
	0E91    16  AND
	0E92    15  ISZERO
	0E93    61  PUSH2 0x0100
	0E96    02  MUL
	0E97    03  SUB
	0E98    16  AND
	0E99    60  PUSH1 0x02
	0E9B    90  SWAP1
	0E9C    04  DIV
	0E9D    80  DUP1
	0E9E    15  ISZERO
	0E9F    61  PUSH2 0x0ee9
	0EA2    57  *JUMPI
	// Stack delta = +6
	// Outputs[8]
	// {
	//     @0E7E  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) / 0x20 * 0x20
	//     @0E80  stack[0] = memory[0x40:0x60]
	//     @0E81  stack[1] = 0x0a
	//     @0E82  stack[2] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02
	//     @0E85  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02
	//     @0E88  stack[3] = 0x20 + memory[0x40:0x60]
	//     @0E89  stack[4] = 0x0a
	//     @0E9C  stack[5] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02
	// }
	// Block ends with conditional jump to 0x0ee9, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02)

label_0EA3:
	// Incoming jump from 0x0EA2, if not !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02)
	// Inputs[1] { @0EA3  stack[-1] }
	0EA3    80  DUP1
	0EA4    60  PUSH1 0x1f
	0EA6    10  LT
	0EA7    61  PUSH2 0x0ebe
	0EAA    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0ebe, if 0x1f < stack[-1]

label_0EAB:
	// Incoming jump from 0x0EAA, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @0EAF  stack[-2]
	//     @0EB0  storage[stack[-2]]
	//     @0EB3  stack[-3]
	//     @0EB5  stack[-1]
	// }
	0EAB    61  PUSH2 0x0100
	0EAE    80  DUP1
	0EAF    83  DUP4
	0EB0    54  SLOAD
	0EB1    04  DIV
	0EB2    02  MUL
	0EB3    83  DUP4
	0EB4    52  MSTORE
	0EB5    91  SWAP2
	0EB6    60  PUSH1 0x20
	0EB8    01  ADD
	0EB9    91  SWAP2
	0EBA    61  PUSH2 0x0ee9
	0EBD    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0EB4  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @0EB9  stack[-1] = stack[-1]
	//     @0EB9  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x0ee9

label_0EBE:
	// Incoming jump from 0x0EAA, if 0x1f < stack[-1]
	// Inputs[5]
	// {
	//     @0EBF  stack[-3]
	//     @0EC0  stack[-1]
	//     @0EC2  stack[-2]
	//     @0ECA  memory[0x00:0x20]
	//     @0ECE  storage[keccak256(memory[0x00:0x20])]
	// }
	0EBE    5B  JUMPDEST
	0EBF    82  DUP3
	0EC0    01  ADD
	0EC1    91  SWAP2
	0EC2    90  SWAP1
	0EC3    60  PUSH1 0x00
	0EC5    52  MSTORE
	0EC6    60  PUSH1 0x20
	0EC8    60  PUSH1 0x00
	0ECA    20  SHA3
	0ECB    90  SWAP1
	0ECC    5B  JUMPDEST
	0ECD    81  DUP2
	0ECE    54  SLOAD
	0ECF    81  DUP2
	0ED0    52  MSTORE
	0ED1    90  SWAP1
	0ED2    60  PUSH1 0x01
	0ED4    01  ADD
	0ED5    90  SWAP1
	0ED6    60  PUSH1 0x20
	0ED8    01  ADD
	0ED9    80  DUP1
	0EDA    83  DUP4
	0EDB    11  GT
	0EDC    61  PUSH2 0x0ecc
	0EDF    57  *JUMPI
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0EC1  stack[-3] = stack[-3] + stack[-1]
	//     @0EC5  memory[0x00:0x20] = stack[-2]
	//     @0ED0  memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])]
	//     @0ED5  stack[-2] = 0x01 + keccak256(memory[0x00:0x20])
	//     @0ED8  stack[-1] = 0x20 + stack[-3]
	// }
	// Block ends with conditional jump to 0x0ecc, if stack[-3] + stack[-1] > 0x20 + stack[-3]

label_0EE0:
	// Incoming jump from 0x0EDF, if not stack[-3] > 0x20 + stack[-1]
	// Incoming jump from 0x0EDF, if not stack[-3] + stack[-1] > 0x20 + stack[-3]
	// Inputs[2]
	// {
	//     @0EE0  stack[-3]
	//     @0EE1  stack[-1]
	// }
	0EE0    82  DUP3
	0EE1    90  SWAP1
	0EE2    03  SUB
	0EE3    60  PUSH1 0x1f
	0EE5    16  AND
	0EE6    82  DUP3
	0EE7    01  ADD
	0EE8    91  SWAP2
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0EE8  stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3])
	//     @0EE8  stack[-1] = stack[-3]
	// }
	// Block continues

label_0EE9:
	// Incoming jump from 0x0EBD
	// Incoming jump from 0x0EA2, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02)
	// Incoming jump from 0x0EE8
	// Inputs[1] { @0EEF  stack[-7] }
	0EE9    5B  JUMPDEST
	0EEA    50  POP
	0EEB    50  POP
	0EEC    50  POP
	0EED    50  POP
	0EEE    50  POP
	0EEF    81  DUP2
	0EF0    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-7]

label_0EF1:
	// Incoming jump from 0x0537
	// Inputs[3]
	// {
	//     @0EF7  msg.sender
	//     @0EF8  stack[-2]
	//     @0EF9  stack[-1]
	// }
	0EF1    5B  JUMPDEST
	0EF2    60  PUSH1 0x00
	0EF4    61  PUSH2 0x0efe
	0EF7    33  CALLER
	0EF8    84  DUP5
	0EF9    84  DUP5
	0EFA    61  PUSH2 0x0a7f
	0EFD    56  *JUMP
	// Stack delta = +5
	// Outputs[5]
	// {
	//     @0EF2  stack[0] = 0x00
	//     @0EF4  stack[1] = 0x0efe
	//     @0EF7  stack[2] = msg.sender
	//     @0EF8  stack[3] = stack[-2]
	//     @0EF9  stack[4] = stack[-1]
	// }
	// Block ends with call to 0x0a7f, returns to 0x0EFE

label_0EFE:
	// Incoming return from call to 0x0A7F at 0x0EFD
	// Inputs[4]
	// {
	//     @0EFF  stack[-1]
	//     @0EFF  stack[-2]
	//     @0F01  stack[-5]
	//     @0F02  stack[-4]
	// }
	0EFE    5B  JUMPDEST
	0EFF    90  SWAP1
	0F00    50  POP
	0F01    92  SWAP3
	0F02    91  SWAP2
	0F03    50  POP
	0F04    50  POP
	0F05    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @0F01  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_0F06:
	// Incoming jump from 0x0611
	// Inputs[2]
	// {
	//     @0F0E  storage[0x0b]
	//     @0F42  msg.sender
	// }
	0F06    5B  JUMPDEST
	0F07    60  PUSH1 0x00
	0F09    60  PUSH1 0x0b
	0F0B    60  PUSH1 0x00
	0F0D    90  SWAP1
	0F0E    54  SLOAD
	0F0F    90  SWAP1
	0F10    61  PUSH2 0x0100
	0F13    0A  EXP
	0F14    90  SWAP1
	0F15    04  DIV
	0F16    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F2B    16  AND
	0F2C    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F41    16  AND
	0F42    33  CALLER
	0F43    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F58    16  AND
	0F59    14  EQ
	0F5A    61  PUSH2 0x0f62
	0F5D    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0F07  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0f62, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_0F5E:
	// Incoming jump from 0x0F5D, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @0F61  memory[0x00:0x00] }
	0F5E    60  PUSH1 0x00
	0F60    80  DUP1
	0F61    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0F61  revert(memory[0x00:0x00]); }
	// Block terminates

label_0F62:
	// Incoming jump from 0x0F5D, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[6]
	// {
	//     @0F65  stack[-3]
	//     @0F66  memory[stack[-3]:stack[-3] + 0x20]
	//     @0F67  stack[-2]
	//     @0F70  msg.sender
	//     @0FAA  memory[0x00:0x40]
	//     @0FAB  storage[keccak256(memory[0x00:0x40])]
	// }
	0F62    5B  JUMPDEST
	0F63    60  PUSH1 0x00
	0F65    83  DUP4
	0F66    51  MLOAD
	0F67    83  DUP4
	0F68    02  MUL
	0F69    90  SWAP1
	0F6A    50  POP
	0F6B    80  DUP1
	0F6C    60  PUSH1 0x06
	0F6E    60  PUSH1 0x00
	0F70    33  CALLER
	0F71    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F86    16  AND
	0F87    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0F9C    16  AND
	0F9D    81  DUP2
	0F9E    52  MSTORE
	0F9F    60  PUSH1 0x20
	0FA1    01  ADD
	0FA2    90  SWAP1
	0FA3    81  DUP2
	0FA4    52  MSTORE
	0FA5    60  PUSH1 0x20
	0FA7    01  ADD
	0FA8    60  PUSH1 0x00
	0FAA    20  SHA3
	0FAB    54  SLOAD
	0FAC    10  LT
	0FAD    15  ISZERO
	0FAE    61  PUSH2 0x0fb6
	0FB1    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0F69  stack[0] = stack[-2] * memory[stack[-3]:stack[-3] + 0x20]
	//     @0F9E  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0FA4  memory[0x20:0x40] = 0x06
	// }
	// Block ends with conditional jump to 0x0fb6, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2] * memory[stack[-3]:stack[-3] + 0x20])

label_0FB2:
	// Incoming jump from 0x0FB1, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2] * memory[stack[-3]:stack[-3] + 0x20])
	// Inputs[1] { @0FB5  memory[0x00:0x00] }
	0FB2    60  PUSH1 0x00
	0FB4    80  DUP1
	0FB5    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0FB5  revert(memory[0x00:0x00]); }
	// Block terminates

label_0FB6:
	// Incoming jump from 0x0FB1, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2] * memory[stack[-3]:stack[-3] + 0x20])
	// Inputs[6]
	// {
	//     @0FB7  stack[-1]
	//     @0FBC  msg.sender
	//     @0FF6  memory[0x00:0x40]
	//     @0FFB  storage[keccak256(memory[0x00:0x40])]
	//     @100A  stack[-4]
	//     @100B  memory[stack[-4]:stack[-4] + 0x20]
	// }
	0FB6    5B  JUMPDEST
	0FB7    80  DUP1
	0FB8    60  PUSH1 0x06
	0FBA    60  PUSH1 0x00
	0FBC    33  CALLER
	0FBD    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0FD2    16  AND
	0FD3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0FE8    16  AND
	0FE9    81  DUP2
	0FEA    52  MSTORE
	0FEB    60  PUSH1 0x20
	0FED    01  ADD
	0FEE    90  SWAP1
	0FEF    81  DUP2
	0FF0    52  MSTORE
	0FF1    60  PUSH1 0x20
	0FF3    01  ADD
	0FF4    60  PUSH1 0x00
	0FF6    20  SHA3
	0FF7    60  PUSH1 0x00
	0FF9    82  DUP3
	0FFA    82  DUP3
	0FFB    54  SLOAD
	0FFC    03  SUB
	0FFD    92  SWAP3
	0FFE    50  POP
	0FFF    50  POP
	1000    81  DUP2
	1001    90  SWAP1
	1002    55  SSTORE
	1003    50  POP
	1004    60  PUSH1 0x00
	1006    80  DUP1
	1007    90  SWAP1
	1008    50  POP
	1009    5B  JUMPDEST
	100A    84  DUP5
	100B    51  MLOAD
	100C    81  DUP2
	100D    10  LT
	100E    15  ISZERO
	100F    61  PUSH2 0x1163
	1012    57  *JUMPI
	// Stack delta = +1
	// Outputs[4]
	// {
	//     @0FEA  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @0FF0  memory[0x20:0x40] = 0x06
	//     @1002  storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-1]
	//     @1007  stack[0] = 0x00
	// }
	// Block ends with conditional jump to 0x1163, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])

label_1013:
	// Incoming jump from 0x1012, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20])
	// Incoming jump from 0x1012, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[3]
	// {
	//     @1015  stack[-5]
	//     @1016  stack[-1]
	//     @1018  memory[stack[-5]:stack[-5] + 0x20]
	// }
	1013    60  PUSH1 0x00
	1015    85  DUP6
	1016    82  DUP3
	1017    81  DUP2
	1018    51  MLOAD
	1019    81  DUP2
	101A    10  LT
	101B    61  PUSH2 0x1020
	101E    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @1013  stack[0] = 0x00
	//     @1015  stack[1] = stack[-5]
	//     @1016  stack[2] = stack[-1]
	// }
	// Block ends with conditional jump to 0x1020, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20]

label_101F:
	// Incoming jump from 0x101E, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20]
	101F    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @101F  assert(); }
	// Block terminates

label_1020:
	// Incoming jump from 0x101E, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20]
	// Inputs[8]
	// {
	//     @1023  stack[-1]
	//     @1027  stack[-2]
	//     @1028  memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]
	//     @1029  stack[-3]
	//     @102B  stack[-7]
	//     @106A  memory[0x00:0x40]
	//     @106F  storage[keccak256(memory[0x00:0x40])]
	//     @108F  msg.sender
	// }
	1020    5B  JUMPDEST
	1021    60  PUSH1 0x20
	1023    02  MUL
	1024    60  PUSH1 0x20
	1026    01  ADD
	1027    01  ADD
	1028    51  MLOAD
	1029    90  SWAP1
	102A    50  POP
	102B    84  DUP5
	102C    60  PUSH1 0x06
	102E    60  PUSH1 0x00
	1030    83  DUP4
	1031    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1046    16  AND
	1047    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	105C    16  AND
	105D    81  DUP2
	105E    52  MSTORE
	105F    60  PUSH1 0x20
	1061    01  ADD
	1062    90  SWAP1
	1063    81  DUP2
	1064    52  MSTORE
	1065    60  PUSH1 0x20
	1067    01  ADD
	1068    60  PUSH1 0x00
	106A    20  SHA3
	106B    60  PUSH1 0x00
	106D    82  DUP3
	106E    82  DUP3
	106F    54  SLOAD
	1070    01  ADD
	1071    92  SWAP3
	1072    50  POP
	1073    50  POP
	1074    81  DUP2
	1075    90  SWAP1
	1076    55  SSTORE
	1077    50  POP
	1078    80  DUP1
	1079    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	108E    16  AND
	108F    33  CALLER
	1090    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	10A5    16  AND
	10A6    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	10C7    60  PUSH1 0x02
	10C9    88  DUP9
	10CA    81  DUP2
	10CB    61  PUSH2 0x10d0
	10CE    57  *JUMPI
	// Stack delta = +3
	// Outputs[9]
	// {
	//     @1029  stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]
	//     @105E  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]
	//     @1064  memory[0x20:0x40] = 0x06
	//     @1076  storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-7]
	//     @108E  stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]
	//     @10A5  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @10A6  stack[0] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	//     @10C7  stack[1] = 0x02
	//     @10C9  stack[2] = stack[-7]
	// }
	// Block ends with conditional jump to 0x10d0, if 0x02

label_10CF:
	// Incoming jump from 0x10CE, if not 0x02
	10CF    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @10CF  assert(); }
	// Block terminates

label_10D0:
	// Incoming jump from 0x10CE, if 0x02
	// Inputs[11]
	// {
	//     @10D1  stack[-2]
	//     @10D1  stack[-1]
	//     @10D4  memory[0x40:0x60]
	//     @10E1  memory[0x40:0x60]
	//     @10E6  stack[-4]
	//     @10E6  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @10E6  stack[-3]
	//     @10E6  stack[-5]
	//     @10E7  stack[-6]
	//     @10FE  msg.sender
	//     @1138  stack[-10]
	// }
	10D0    5B  JUMPDEST
	10D1    04  DIV
	10D2    60  PUSH1 0x40
	10D4    51  MLOAD
	10D5    80  DUP1
	10D6    82  DUP3
	10D7    81  DUP2
	10D8    52  MSTORE
	10D9    60  PUSH1 0x20
	10DB    01  ADD
	10DC    91  SWAP2
	10DD    50  POP
	10DE    50  POP
	10DF    60  PUSH1 0x40
	10E1    51  MLOAD
	10E2    80  DUP1
	10E3    91  SWAP2
	10E4    03  SUB
	10E5    90  SWAP1
	10E6    A3  LOG3
	10E7    80  DUP1
	10E8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	10FD    16  AND
	10FE    33  CALLER
	10FF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1114    16  AND
	1115    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	1136    60  PUSH1 0x02
	1138    88  DUP9
	1139    81  DUP2
	113A    61  PUSH2 0x113f
	113D    57  *JUMPI
	// Stack delta = +0
	// Outputs[7]
	// {
	//     @10D8  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] / stack[-2]
	//     @10E6  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-3], stack[-4], stack[-5]]);
	//     @10FD  stack[-5] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6]
	//     @1114  stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @1115  stack[-3] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	//     @1136  stack[-2] = 0x02
	//     @1138  stack[-1] = stack[-10]
	// }
	// Block ends with conditional jump to 0x113f, if 0x02

label_113E:
	// Incoming jump from 0x113D, if not 0x02
	113E    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @113E  assert(); }
	// Block terminates

label_113F:
	// Incoming jump from 0x113D, if 0x02
	// Inputs[9]
	// {
	//     @1140  stack[-1]
	//     @1140  stack[-2]
	//     @1143  memory[0x40:0x60]
	//     @1150  memory[0x40:0x60]
	//     @1155  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @1155  stack[-3]
	//     @1155  stack[-5]
	//     @1155  stack[-4]
	//     @1157  stack[-7]
	// }
	113F    5B  JUMPDEST
	1140    04  DIV
	1141    60  PUSH1 0x40
	1143    51  MLOAD
	1144    80  DUP1
	1145    82  DUP3
	1146    81  DUP2
	1147    52  MSTORE
	1148    60  PUSH1 0x20
	114A    01  ADD
	114B    91  SWAP2
	114C    50  POP
	114D    50  POP
	114E    60  PUSH1 0x40
	1150    51  MLOAD
	1151    80  DUP1
	1152    91  SWAP2
	1153    03  SUB
	1154    90  SWAP1
	1155    A3  LOG3
	1156    50  POP
	1157    80  DUP1
	1158    80  DUP1
	1159    60  PUSH1 0x01
	115B    01  ADD
	115C    91  SWAP2
	115D    50  POP
	115E    50  POP
	115F    61  PUSH2 0x1009
	1162    56  *JUMP
	// Stack delta = -6
	// Outputs[3]
	// {
	//     @1147  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] / stack[-2]
	//     @1155  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-3], stack[-4], stack[-5]]);
	//     @115C  stack[-7] = 0x01 + stack[-7]
	// }
	// Block ends with unconditional jump to 0x1009

label_1163:
	// Incoming jump from 0x1012, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20])
	// Incoming jump from 0x1012, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[3]
	// {
	//     @1167  stack[-3]
	//     @116A  stack[-6]
	//     @116B  stack[-5]
	// }
	1163    5B  JUMPDEST
	1164    50  POP
	1165    60  PUSH1 0x01
	1167    91  SWAP2
	1168    50  POP
	1169    50  POP
	116A    92  SWAP3
	116B    91  SWAP2
	116C    50  POP
	116D    50  POP
	116E    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @116A  stack[-6] = 0x01 }
	// Block ends with unconditional jump to stack[-6]

label_116F:
	// Incoming jump from 0x0704
	// Inputs[2]
	// {
	//     @1175  storage[0x0b]
	//     @11A9  msg.sender
	// }
	116F    5B  JUMPDEST
	1170    60  PUSH1 0x0b
	1172    60  PUSH1 0x00
	1174    90  SWAP1
	1175    54  SLOAD
	1176    90  SWAP1
	1177    61  PUSH2 0x0100
	117A    0A  EXP
	117B    90  SWAP1
	117C    04  DIV
	117D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1192    16  AND
	1193    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	11A8    16  AND
	11A9    33  CALLER
	11AA    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	11BF    16  AND
	11C0    14  EQ
	11C1    61  PUSH2 0x11c9
	11C4    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x11c9, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_11C5:
	// Incoming jump from 0x11C4, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @11C8  memory[0x00:0x00] }
	11C5    60  PUSH1 0x00
	11C7    80  DUP1
	11C8    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @11C8  revert(memory[0x00:0x00]); }
	// Block terminates

label_11C9:
	// Incoming jump from 0x11C4, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[4]
	// {
	//     @11CA  stack[-2]
	//     @11E1  stack[-1]
	//     @11E4  memory[0x40:0x60]
	//     @11E8  memory[stack[-1]:stack[-1] + 0x20]
	// }
	11C9    5B  JUMPDEST
	11CA    81  DUP2
	11CB    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	11E0    16  AND
	11E1    81  DUP2
	11E2    60  PUSH1 0x40
	11E4    51  MLOAD
	11E5    80  DUP1
	11E6    82  DUP3
	11E7    80  DUP1
	11E8    51  MLOAD
	11E9    90  SWAP1
	11EA    60  PUSH1 0x20
	11EC    01  ADD
	11ED    90  SWAP1
	11EE    80  DUP1
	11EF    83  DUP4
	11F0    83  DUP4
	11F1    5B  JUMPDEST
	11F2    60  PUSH1 0x20
	11F4    83  DUP4
	11F5    10  LT
	11F6    61  PUSH2 0x1214
	11F9    57  *JUMPI
	// Stack delta = +9
	// Outputs[9]
	// {
	//     @11E0  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @11E1  stack[1] = stack[-1]
	//     @11E4  stack[2] = memory[0x40:0x60]
	//     @11E5  stack[3] = memory[0x40:0x60]
	//     @11ED  stack[4] = 0x20 + stack[-1]
	//     @11ED  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @11EE  stack[6] = memory[stack[-1]:stack[-1] + 0x20]
	//     @11EF  stack[7] = memory[0x40:0x60]
	//     @11F0  stack[8] = 0x20 + stack[-1]
	// }
	// Block ends with conditional jump to 0x1214, if memory[stack[-1]:stack[-1] + 0x20] < 0x20

label_11FA:
	// Incoming jump from 0x11F9, if not memory[stack[-1]:stack[-1] + 0x20] < 0x20
	// Incoming jump from 0x11F9, if not stack[-3] < 0x20
	// Inputs[4]
	// {
	//     @11FA  stack[-1]
	//     @11FB  memory[stack[-1]:stack[-1] + 0x20]
	//     @11FC  stack[-2]
	//     @120C  stack[-3]
	// }
	11FA    80  DUP1
	11FB    51  MLOAD
	11FC    82  DUP3
	11FD    52  MSTORE
	11FE    60  PUSH1 0x20
	1200    82  DUP3
	1201    01  ADD
	1202    91  SWAP2
	1203    50  POP
	1204    60  PUSH1 0x20
	1206    81  DUP2
	1207    01  ADD
	1208    90  SWAP1
	1209    50  POP
	120A    60  PUSH1 0x20
	120C    83  DUP4
	120D    03  SUB
	120E    92  SWAP3
	120F    50  POP
	1210    61  PUSH2 0x11f1
	1213    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @11FD  memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @1202  stack[-2] = stack[-2] + 0x20
	//     @1208  stack[-1] = stack[-1] + 0x20
	//     @120E  stack[-3] = stack[-3] - 0x20
	// }
	// Block ends with unconditional jump to 0x11f1

label_1214:
	// Incoming jump from 0x11F9, if memory[stack[-1]:stack[-1] + 0x20] < 0x20
	// Incoming jump from 0x11F9, if stack[-3] < 0x20
	// Inputs[15]
	// {
	//     @1217  stack[-3]
	//     @1222  stack[-1]
	//     @1223  memory[stack[-1]:stack[-1] + 0x20]
	//     @1226  stack[-2]
	//     @1227  memory[stack[-2]:stack[-2] + 0x20]
	//     @1234  stack[-4]
	//     @1234  stack[-5]
	//     @1236  stack[-6]
	//     @1237  stack[-8]
	//     @123E  memory[0x40:0x60]
	//     @1243  stack[-9]
	//     @1244  msg.gas
	//     @1245  memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]
	//     @1245  address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @1249  returndata.length
	// }
	1214    5B  JUMPDEST
	1215    60  PUSH1 0x01
	1217    83  DUP4
	1218    60  PUSH1 0x20
	121A    03  SUB
	121B    61  PUSH2 0x0100
	121E    0A  EXP
	121F    03  SUB
	1220    80  DUP1
	1221    19  NOT
	1222    82  DUP3
	1223    51  MLOAD
	1224    16  AND
	1225    81  DUP2
	1226    84  DUP5
	1227    51  MLOAD
	1228    16  AND
	1229    80  DUP1
	122A    82  DUP3
	122B    17  OR
	122C    85  DUP6
	122D    52  MSTORE
	122E    50  POP
	122F    50  POP
	1230    50  POP
	1231    50  POP
	1232    50  POP
	1233    50  POP
	1234    90  SWAP1
	1235    50  POP
	1236    01  ADD
	1237    91  SWAP2
	1238    50  POP
	1239    50  POP
	123A    60  PUSH1 0x00
	123C    60  PUSH1 0x40
	123E    51  MLOAD
	123F    80  DUP1
	1240    83  DUP4
	1241    03  SUB
	1242    81  DUP2
	1243    85  DUP6
	1244    5A  GAS
	1245    F4  DELEGATECALL
	1246    91  SWAP2
	1247    50  POP
	1248    50  POP
	1249    3D  RETURNDATASIZE
	124A    80  DUP1
	124B    60  PUSH1 0x00
	124D    81  DUP2
	124E    14  EQ
	124F    61  PUSH2 0x1274
	1252    57  *JUMPI
	// Stack delta = -6
	// Outputs[5]
	// {
	//     @122D  memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01)
	//     @1245  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @1246  stack[-9] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]])
	//     @1249  stack[-8] = returndata.length
	//     @124A  stack[-7] = returndata.length
	// }
	// Block ends with conditional jump to 0x1274, if returndata.length == 0x00

label_1253:
	// Incoming jump from 0x1252, if not returndata.length == 0x00
	// Inputs[6]
	// {
	//     @1255  memory[0x40:0x60]
	//     @1256  stack[-2]
	//     @125D  returndata.length
	//     @1265  returndata.length
	//     @1268  returndata.length
	//     @126F  returndata[0x00:0x00 + returndata.length]
	// }
	1253    60  PUSH1 0x40
	1255    51  MLOAD
	1256    91  SWAP2
	1257    50  POP
	1258    60  PUSH1 0x1f
	125A    19  NOT
	125B    60  PUSH1 0x3f
	125D    3D  RETURNDATASIZE
	125E    01  ADD
	125F    16  AND
	1260    82  DUP3
	1261    01  ADD
	1262    60  PUSH1 0x40
	1264    52  MSTORE
	1265    3D  RETURNDATASIZE
	1266    82  DUP3
	1267    52  MSTORE
	1268    3D  RETURNDATASIZE
	1269    60  PUSH1 0x00
	126B    60  PUSH1 0x20
	126D    84  DUP5
	126E    01  ADD
	126F    3E  RETURNDATACOPY
	1270    61  PUSH2 0x1279
	1273    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @1256  stack[-2] = memory[0x40:0x60]
	//     @1264  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f)
	//     @1267  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length
	//     @126F  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	// }
	// Block ends with unconditional jump to 0x1279

label_1274:
	// Incoming jump from 0x1252, if returndata.length == 0x00
	// Inputs[2]
	// {
	//     @1277  stack[-2]
	//     @127F  stack[-6]
	// }
	1274    5B  JUMPDEST
	1275    60  PUSH1 0x60
	1277    91  SWAP2
	1278    50  POP
	1279    5B  JUMPDEST
	127A    50  POP
	127B    50  POP
	127C    50  POP
	127D    50  POP
	127E    50  POP
	127F    56  *JUMP
	// Stack delta = -6
	// Block ends with unconditional jump to stack[-6]

label_1280:
	// Incoming jump from 0x0775
	// Inputs[6]
	// {
	//     @1286  stack[-2]
	//     @128E  memory[0x00:0x40]
	//     @1292  stack[-1]
	//     @129A  memory[0x00:0x40]
	//     @12A2  storage[keccak256(memory[0x00:0x40])]
	//     @12A3  stack[-3]
	// }
	1280    5B  JUMPDEST
	1281    60  PUSH1 0x07
	1283    60  PUSH1 0x20
	1285    52  MSTORE
	1286    81  DUP2
	1287    60  PUSH1 0x00
	1289    52  MSTORE
	128A    60  PUSH1 0x40
	128C    60  PUSH1 0x00
	128E    20  SHA3
	128F    60  PUSH1 0x20
	1291    52  MSTORE
	1292    80  DUP1
	1293    60  PUSH1 0x00
	1295    52  MSTORE
	1296    60  PUSH1 0x40
	1298    60  PUSH1 0x00
	129A    20  SHA3
	129B    60  PUSH1 0x00
	129D    91  SWAP2
	129E    50  POP
	129F    91  SWAP2
	12A0    50  POP
	12A1    50  POP
	12A2    54  SLOAD
	12A3    81  DUP2
	12A4    56  *JUMP
	// Stack delta = -1
	// Outputs[5]
	// {
	//     @1285  memory[0x20:0x40] = 0x07
	//     @1289  memory[0x00:0x20] = stack[-2]
	//     @1291  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @1295  memory[0x00:0x20] = stack[-1]
	//     @12A2  stack[-2] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-3]

label_12A5:
	// Incoming call from 0x0BE3, returns to 0x0BE4
	// Inputs[1] { @12D6  address(this) }
	12A5    5B  JUMPDEST
	12A6    60  PUSH1 0x00
	12A8    80  DUP1
	12A9    61  PUSH2 0x12db
	12AC    73  PUSH20 0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f
	12C1    73  PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
	12D6    30  ADDRESS
	12D7    61  PUSH2 0x14e1
	12DA    56  *JUMP
	// Stack delta = +6
	// Outputs[6]
	// {
	//     @12A6  stack[0] = 0x00
	//     @12A8  stack[1] = 0x00
	//     @12A9  stack[2] = 0x12db
	//     @12AC  stack[3] = 0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f
	//     @12C1  stack[4] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
	//     @12D6  stack[5] = address(this)
	// }
	// Block ends with call to 0x14e1, returns to 0x12DB

label_12DB:
	// Incoming return from call to 0x14E1 at 0x12DA
	// Inputs[4]
	// {
	//     @12DC  stack[-1]
	//     @12DC  stack[-2]
	//     @12E3  storage[0x0b]
	//     @1317  stack[-6]
	// }
	12DB    5B  JUMPDEST
	12DC    90  SWAP1
	12DD    50  POP
	12DE    60  PUSH1 0x0b
	12E0    60  PUSH1 0x00
	12E2    90  SWAP1
	12E3    54  SLOAD
	12E4    90  SWAP1
	12E5    61  PUSH2 0x0100
	12E8    0A  EXP
	12E9    90  SWAP1
	12EA    04  DIV
	12EB    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1300    16  AND
	1301    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1316    16  AND
	1317    85  DUP6
	1318    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	132D    16  AND
	132E    14  EQ
	132F    80  DUP1
	1330    61  PUSH2 0x1386
	1333    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @12DC  stack[-2] = stack[-1]
	//     @132E  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// }
	// Block ends with conditional jump to 0x1386, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_1334:
	// Incoming jump from 0x1333, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[2]
	// {
	//     @133A  storage[0x0b]
	//     @136E  stack[-5]
	// }
	1334    50  POP
	1335    60  PUSH1 0x0b
	1337    60  PUSH1 0x00
	1339    90  SWAP1
	133A    54  SLOAD
	133B    90  SWAP1
	133C    61  PUSH2 0x0100
	133F    0A  EXP
	1340    90  SWAP1
	1341    04  DIV
	1342    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1357    16  AND
	1358    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	136D    16  AND
	136E    84  DUP5
	136F    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1384    16  AND
	1385    14  EQ
	1386    5B  JUMPDEST
	1387    80  DUP1
	1388    61  PUSH2 0x13d0
	138B    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @1385  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 }
	// Block ends with conditional jump to 0x13d0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00

label_138C:
	// Incoming jump from 0x138B, if not stack[-1]
	// Incoming jump from 0x138B, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00
	// Inputs[1] { @13B8  stack[-6] }
	138C    50  POP
	138D    73  PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d
	13A2    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13B7    16  AND
	13B8    85  DUP6
	13B9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13CE    16  AND
	13CF    14  EQ
	13D0    5B  JUMPDEST
	13D1    80  DUP1
	13D2    61  PUSH2 0x1406
	13D5    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @13CF  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d }
	// Block ends with conditional jump to 0x1406, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d

label_13D6:
	// Incoming jump from 0x13D5, if not stack[-1]
	// Incoming jump from 0x13D5, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x7a250d5630b4cf539739df2c5dacb4c659f2488d
	// Inputs[2]
	// {
	//     @13D7  stack[-2]
	//     @13EE  stack[-6]
	// }
	13D6    50  POP
	13D7    80  DUP1
	13D8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	13ED    16  AND
	13EE    85  DUP6
	13EF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1404    16  AND
	1405    14  EQ
	1406    5B  JUMPDEST
	1407    80  DUP1
	1408    61  PUSH2 0x145e
	140B    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @1405  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] }
	// Block ends with conditional jump to 0x145e, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]

label_140C:
	// Incoming jump from 0x140B, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	// Incoming jump from 0x140B, if not stack[-1]
	// Inputs[2]
	// {
	//     @1412  storage[0x05]
	//     @1446  stack[-6]
	// }
	140C    50  POP
	140D    60  PUSH1 0x05
	140F    60  PUSH1 0x00
	1411    90  SWAP1
	1412    54  SLOAD
	1413    90  SWAP1
	1414    61  PUSH2 0x0100
	1417    0A  EXP
	1418    90  SWAP1
	1419    04  DIV
	141A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	142F    16  AND
	1430    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1445    16  AND
	1446    85  DUP6
	1447    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	145C    16  AND
	145D    14  EQ
	145E    5B  JUMPDEST
	145F    80  DUP1
	1460    61  PUSH2 0x14b2
	1463    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @145D  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00 }
	// Block ends with conditional jump to 0x14b2, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00

label_1464:
	// Incoming jump from 0x1463, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00
	// Incoming jump from 0x1463, if not stack[-1]
	// Inputs[3]
	// {
	//     @1469  stack[-6]
	//     @14A3  memory[0x00:0x40]
	//     @14A7  storage[keccak256(memory[0x00:0x40])]
	// }
	1464    50  POP
	1465    60  PUSH1 0x01
	1467    60  PUSH1 0x00
	1469    86  DUP7
	146A    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	147F    16  AND
	1480    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1495    16  AND
	1496    81  DUP2
	1497    52  MSTORE
	1498    60  PUSH1 0x20
	149A    01  ADD
	149B    90  SWAP1
	149C    81  DUP2
	149D    52  MSTORE
	149E    60  PUSH1 0x20
	14A0    01  ADD
	14A1    60  PUSH1 0x00
	14A3    20  SHA3
	14A4    60  PUSH1 0x00
	14A6    90  SWAP1
	14A7    54  SLOAD
	14A8    90  SWAP1
	14A9    61  PUSH2 0x0100
	14AC    0A  EXP
	14AD    90  SWAP1
	14AE    04  DIV
	14AF    60  PUSH1 0xff
	14B1    16  AND
	14B2    5B  JUMPDEST
	14B3    15  ISZERO
	14B4    61  PUSH2 0x14c1
	14B7    57  *JUMPI
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @1497  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6]
	//     @149D  memory[0x20:0x40] = 0x01
	// }
	// Block ends with conditional jump to 0x14c1, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00)

label_14B8:
	// Incoming jump from 0x14B7, if not !stack[-1]
	// Incoming jump from 0x14B7, if not !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00)
	// Inputs[1] { @14BA  stack[-2] }
	14B8    60  PUSH1 0x01
	14BA    91  SWAP2
	14BB    50  POP
	14BC    50  POP
	14BD    61  PUSH2 0x14da
	14C0    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @14BA  stack[-2] = 0x01 }
	// Block ends with unconditional jump to 0x14da

label_14C1:
	// Incoming jump from 0x14B7, if !stack[-1]
	// Incoming jump from 0x14B7, if !(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00)
	// Inputs[2]
	// {
	//     @14C5  stack[-5]
	//     @14C6  stack[-3]
	// }
	14C1    5B  JUMPDEST
	14C2    61  PUSH2 0x14cb
	14C5    85  DUP6
	14C6    84  DUP5
	14C7    61  PUSH2 0x166f
	14CA    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @14C2  stack[0] = 0x14cb
	//     @14C5  stack[1] = stack[-5]
	//     @14C6  stack[2] = stack[-3]
	// }
	// Block ends with call to 0x166f, returns to 0x14CB

label_14CB:
	// Incoming return from call to 0x166F at 0x14CA
	// Inputs[1] { @14CF  stack[-1] }
	14CB    5B  JUMPDEST
	14CC    61  PUSH2 0x14d4
	14CF    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x14d4, if stack[-1]

label_14D0:
	// Incoming jump from 0x14CF, if not stack[-1]
	// Inputs[1] { @14D3  memory[0x00:0x00] }
	14D0    60  PUSH1 0x00
	14D2    80  DUP1
	14D3    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @14D3  revert(memory[0x00:0x00]); }
	// Block terminates

label_14D4:
	// Incoming jump from 0x14CF, if stack[-1]
	// Inputs[1] { @14D7  stack[-2] }
	14D4    5B  JUMPDEST
	14D5    60  PUSH1 0x01
	14D7    91  SWAP2
	14D8    50  POP
	14D9    50  POP
	// Stack delta = -1
	// Outputs[1] { @14D7  stack[-2] = 0x01 }
	// Block continues

label_14DA:
	// Incoming jump from 0x14C0
	// Incoming jump from 0x14D9
	// Inputs[3]
	// {
	//     @14DB  stack[-5]
	//     @14DB  stack[-1]
	//     @14DC  stack[-4]
	// }
	14DA    5B  JUMPDEST
	14DB    93  SWAP4
	14DC    92  SWAP3
	14DD    50  POP
	14DE    50  POP
	14DF    50  POP
	14E0    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @14DB  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_14E1:
	// Incoming call from 0x12DA, returns to 0x12DB
	// Inputs[2]
	// {
	//     @14E7  stack[-1]
	//     @14FE  stack[-2]
	// }
	14E1    5B  JUMPDEST
	14E2    60  PUSH1 0x00
	14E4    80  DUP1
	14E5    60  PUSH1 0x00
	14E7    83  DUP4
	14E8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	14FD    16  AND
	14FE    85  DUP6
	14FF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1514    16  AND
	1515    10  LT
	1516    61  PUSH2 0x1520
	1519    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @14E2  stack[0] = 0x00
	//     @14E4  stack[1] = 0x00
	//     @14E5  stack[2] = 0x00
	// }
	// Block ends with conditional jump to 0x1520, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] < 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]

label_151A:
	// Incoming jump from 0x1519, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] < 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	// Inputs[2]
	// {
	//     @151A  stack[-4]
	//     @151B  stack[-5]
	// }
	151A    83  DUP4
	151B    85  DUP6
	151C    61  PUSH2 0x1523
	151F    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @151A  stack[0] = stack[-4]
	//     @151B  stack[1] = stack[-5]
	// }
	// Block ends with unconditional jump to 0x1523

label_1520:
	// Incoming jump from 0x1519, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] < 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]
	// Inputs[15]
	// {
	//     @1521  stack[-5]
	//     @1522  stack[-4]
	//     @1524  stack[-1]
	//     @1526  stack[-2]
	//     @1528  stack[-6]
	//     @152D  memory[0x40:0x60]
	//     @15A2  memory[0x40:0x60]
	//     @15B0  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	//     @15B5  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]
	//     @15B8  memory[0x40:0x60]
	//     @164E  memory[0x40:0x60]
	//     @165C  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	//     @1661  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]
	//     @1665  stack[-3]
	//     @1669  stack[-7]
	// }
	1520    5B  JUMPDEST
	1521    84  DUP5
	1522    84  DUP5
	1523    5B  JUMPDEST
	1524    91  SWAP2
	1525    50  POP
	1526    91  SWAP2
	1527    50  POP
	1528    85  DUP6
	1529    82  DUP3
	152A    82  DUP3
	152B    60  PUSH1 0x40
	152D    51  MLOAD
	152E    60  PUSH1 0x20
	1530    01  ADD
	1531    80  DUP1
	1532    83  DUP4
	1533    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1548    16  AND
	1549    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	155E    16  AND
	155F    60  PUSH1 0x60
	1561    1B  SHL
	1562    81  DUP2
	1563    52  MSTORE
	1564    60  PUSH1 0x14
	1566    01  ADD
	1567    82  DUP3
	1568    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	157D    16  AND
	157E    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1593    16  AND
	1594    60  PUSH1 0x60
	1596    1B  SHL
	1597    81  DUP2
	1598    52  MSTORE
	1599    60  PUSH1 0x14
	159B    01  ADD
	159C    92  SWAP3
	159D    50  POP
	159E    50  POP
	159F    50  POP
	15A0    60  PUSH1 0x40
	15A2    51  MLOAD
	15A3    60  PUSH1 0x20
	15A5    81  DUP2
	15A6    83  DUP4
	15A7    03  SUB
	15A8    03  SUB
	15A9    81  DUP2
	15AA    52  MSTORE
	15AB    90  SWAP1
	15AC    60  PUSH1 0x40
	15AE    52  MSTORE
	15AF    80  DUP1
	15B0    51  MLOAD
	15B1    90  SWAP1
	15B2    60  PUSH1 0x20
	15B4    01  ADD
	15B5    20  SHA3
	15B6    60  PUSH1 0x40
	15B8    51  MLOAD
	15B9    60  PUSH1 0x20
	15BB    01  ADD
	15BC    80  DUP1
	15BD    80  DUP1
	15BE    7F  PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000
	15DF    81  DUP2
	15E0    52  MSTORE
	15E1    50  POP
	15E2    60  PUSH1 0x01
	15E4    01  ADD
	15E5    83  DUP4
	15E6    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	15FB    16  AND
	15FC    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1611    16  AND
	1612    60  PUSH1 0x60
	1614    1B  SHL
	1615    81  DUP2
	1616    52  MSTORE
	1617    60  PUSH1 0x14
	1619    01  ADD
	161A    82  DUP3
	161B    81  DUP2
	161C    52  MSTORE
	161D    60  PUSH1 0x20
	161F    01  ADD
	1620    80  DUP1
	1621    7F  PUSH32 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f
	1642    81  DUP2
	1643    52  MSTORE
	1644    50  POP
	1645    60  PUSH1 0x20
	1647    01  ADD
	1648    92  SWAP3
	1649    50  POP
	164A    50  POP
	164B    50  POP
	164C    60  PUSH1 0x40
	164E    51  MLOAD
	164F    60  PUSH1 0x20
	1651    81  DUP2
	1652    83  DUP4
	1653    03  SUB
	1654    03  SUB
	1655    81  DUP2
	1656    52  MSTORE
	1657    90  SWAP1
	1658    60  PUSH1 0x40
	165A    52  MSTORE
	165B    80  DUP1
	165C    51  MLOAD
	165D    90  SWAP1
	165E    60  PUSH1 0x20
	1660    01  ADD
	1661    20  SHA3
	1662    60  PUSH1 0x00
	1664    1C  SHR
	1665    92  SWAP3
	1666    50  POP
	1667    50  POP
	1668    50  POP
	1669    93  SWAP4
	166A    92  SWAP3
	166B    50  POP
	166C    50  POP
	166D    50  POP
	166E    56  *JUMP
	// Stack delta = -6
	// Outputs[11]
	// {
	//     @1563  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5]) << 0x60
	//     @1598  memory[0x14 + 0x20 + memory[0x40:0x60]:0x14 + 0x20 + memory[0x40:0x60] + 0x20] = (0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) << 0x60
	//     @15AA  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x14 + 0x14 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20
	//     @15AE  memory[0x40:0x60] = 0x14 + 0x14 + 0x20 + memory[0x40:0x60]
	//     @15E0  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000
	//     @1616  memory[0x01 + 0x20 + memory[0x40:0x60]:0x01 + 0x20 + memory[0x40:0x60] + 0x20] = (0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6]) << 0x60
	//     @161C  memory[0x14 + 0x01 + 0x20 + memory[0x40:0x60]:0x14 + 0x01 + 0x20 + memory[0x40:0x60] + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])
	//     @1643  memory[0x20 + 0x14 + 0x01 + 0x20 + memory[0x40:0x60]:0x20 + 0x14 + 0x01 + 0x20 + memory[0x40:0x60] + 0x20] = 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f
	//     @1656  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x14 + 0x01 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20
	//     @165A  memory[0x40:0x60] = 0x20 + 0x20 + 0x14 + 0x01 + 0x20 + memory[0x40:0x60]
	//     @1669  stack[-7] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) >> 0x00
	// }
	// Block ends with unconditional jump to stack[-7]

label_166F:
	// Incoming call from 0x14CA, returns to 0x14CB
	// Inputs[1] { @1675  storage[0x04] }
	166F    5B  JUMPDEST
	1670    60  PUSH1 0x00
	1672    80  DUP1
	1673    60  PUSH1 0x04
	1675    54  SLOAD
	1676    14  EQ
	1677    80  DUP1
	1678    15  ISZERO
	1679    61  PUSH2 0x1684
	167C    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @1670  stack[0] = 0x00
	//     @1676  stack[1] = storage[0x04] == 0x00
	// }
	// Block ends with conditional jump to 0x1684, if !(storage[0x04] == 0x00)

label_167D:
	// Incoming jump from 0x167C, if not !(storage[0x04] == 0x00)
	// Inputs[1] { @1682  storage[0x02] }
	167D    50  POP
	167E    60  PUSH1 0x00
	1680    60  PUSH1 0x02
	1682    54  SLOAD
	1683    14  EQ
	1684    5B  JUMPDEST
	1685    80  DUP1
	1686    15  ISZERO
	1687    61  PUSH2 0x1692
	168A    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @1683  stack[-1] = storage[0x02] == 0x00 }
	// Block ends with conditional jump to 0x1692, if !(storage[0x02] == 0x00)

label_168B:
	// Incoming jump from 0x168A, if not !stack[-1]
	// Incoming jump from 0x168A, if not !(storage[0x02] == 0x00)
	// Inputs[1] { @1690  storage[0x03] }
	168B    50  POP
	168C    60  PUSH1 0x00
	168E    60  PUSH1 0x03
	1690    54  SLOAD
	1691    14  EQ
	1692    5B  JUMPDEST
	1693    15  ISZERO
	1694    61  PUSH2 0x16a0
	1697    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x16a0, if !(storage[0x03] == 0x00)

label_1698:
	// Incoming jump from 0x1697, if not !stack[-1]
	// Incoming jump from 0x1697, if not !(storage[0x03] == 0x00)
	// Inputs[1] { @169A  stack[-1] }
	1698    60  PUSH1 0x00
	169A    90  SWAP1
	169B    50  POP
	169C    61  PUSH2 0x1740
	169F    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @169A  stack[-1] = 0x00 }
	// Block ends with unconditional jump to 0x1740

label_16A0:
	// Incoming jump from 0x1697, if !stack[-1]
	// Incoming jump from 0x1697, if !(storage[0x03] == 0x00)
	// Inputs[1] { @16A5  storage[0x04] }
	16A0    5B  JUMPDEST
	16A1    60  PUSH1 0x00
	16A3    60  PUSH1 0x04
	16A5    54  SLOAD
	16A6    11  GT
	16A7    15  ISZERO
	16A8    61  PUSH2 0x16fd
	16AB    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x16fd, if !(storage[0x04] > 0x00)

label_16AC:
	// Incoming jump from 0x16AB, if not !(storage[0x04] > 0x00)
	// Inputs[4]
	// {
	//     @16AE  storage[0x04]
	//     @16B2  stack[-3]
	//     @16EC  memory[0x00:0x40]
	//     @16ED  storage[keccak256(memory[0x00:0x40])]
	// }
	16AC    60  PUSH1 0x04
	16AE    54  SLOAD
	16AF    60  PUSH1 0x00
	16B1    80  DUP1
	16B2    85  DUP6
	16B3    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	16C8    16  AND
	16C9    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	16DE    16  AND
	16DF    81  DUP2
	16E0    52  MSTORE
	16E1    60  PUSH1 0x20
	16E3    01  ADD
	16E4    90  SWAP1
	16E5    81  DUP2
	16E6    52  MSTORE
	16E7    60  PUSH1 0x20
	16E9    01  ADD
	16EA    60  PUSH1 0x00
	16EC    20  SHA3
	16ED    54  SLOAD
	16EE    11  GT
	16EF    15  ISZERO
	16F0    61  PUSH2 0x16fc
	16F3    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @16E0  memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @16E6  memory[0x20:0x40] = 0x00
	// }
	// Block ends with conditional jump to 0x16fc, if !(storage[keccak256(memory[0x00:0x40])] > storage[0x04])

label_16F4:
	// Incoming jump from 0x16F3, if not !(storage[keccak256(memory[0x00:0x40])] > storage[0x04])
	// Inputs[1] { @16F6  stack[-1] }
	16F4    60  PUSH1 0x00
	16F6    90  SWAP1
	16F7    50  POP
	16F8    61  PUSH2 0x1740
	16FB    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @16F6  stack[-1] = 0x00 }
	// Block ends with unconditional jump to 0x1740

label_16FC:
	// Incoming jump from 0x16F3, if !(storage[keccak256(memory[0x00:0x40])] > storage[0x04])
	16FC    5B  JUMPDEST
	// Stack delta = +0
	// Block continues

label_16FD:
	// Incoming jump from 0x16AB, if !(storage[0x04] > 0x00)
	// Incoming jump from 0x16FC
	// Inputs[1] { @1702  storage[0x02] }
	16FD    5B  JUMPDEST
	16FE    60  PUSH1 0x00
	1700    60  PUSH1 0x02
	1702    54  SLOAD
	1703    11  GT
	1704    15  ISZERO
	1705    61  PUSH2 0x171c
	1708    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x171c, if !(storage[0x02] > 0x00)

label_1709:
	// Incoming jump from 0x1708, if not !(storage[0x02] > 0x00)
	// Inputs[2]
	// {
	//     @1709  stack[-2]
	//     @170C  storage[0x02]
	// }
	1709    81  DUP2
	170A    60  PUSH1 0x02
	170C    54  SLOAD
	170D    11  GT
	170E    15  ISZERO
	170F    61  PUSH2 0x171b
	1712    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x171b, if !(storage[0x02] > stack[-2])

label_1713:
	// Incoming jump from 0x1712, if not !(storage[0x02] > stack[-2])
	// Inputs[1] { @1715  stack[-1] }
	1713    60  PUSH1 0x00
	1715    90  SWAP1
	1716    50  POP
	1717    61  PUSH2 0x1740
	171A    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @1715  stack[-1] = 0x00 }
	// Block ends with unconditional jump to 0x1740

label_171B:
	// Incoming jump from 0x1712, if !(storage[0x02] > stack[-2])
	171B    5B  JUMPDEST
	// Stack delta = +0
	// Block continues

label_171C:
	// Incoming jump from 0x171B
	// Incoming jump from 0x1708, if !(storage[0x02] > 0x00)
	// Inputs[1] { @1721  storage[0x03] }
	171C    5B  JUMPDEST
	171D    60  PUSH1 0x00
	171F    60  PUSH1 0x03
	1721    54  SLOAD
	1722    11  GT
	1723    15  ISZERO
	1724    61  PUSH2 0x173b
	1727    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x173b, if !(storage[0x03] > 0x00)

label_1728:
	// Incoming jump from 0x1727, if not !(storage[0x03] > 0x00)
	// Inputs[2]
	// {
	//     @172A  storage[0x03]
	//     @172B  stack[-2]
	// }
	1728    60  PUSH1 0x03
	172A    54  SLOAD
	172B    82  DUP3
	172C    11  GT
	172D    15  ISZERO
	172E    61  PUSH2 0x173a
	1731    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x173a, if !(stack[-2] > storage[0x03])

label_1732:
	// Incoming jump from 0x1731, if not !(stack[-2] > storage[0x03])
	// Inputs[1] { @1734  stack[-1] }
	1732    60  PUSH1 0x00
	1734    90  SWAP1
	1735    50  POP
	1736    61  PUSH2 0x1740
	1739    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @1734  stack[-1] = 0x00 }
	// Block ends with unconditional jump to 0x1740

label_173A:
	// Incoming jump from 0x1731, if !(stack[-2] > storage[0x03])
	173A    5B  JUMPDEST
	// Stack delta = +0
	// Block continues

label_173B:
	// Incoming jump from 0x1727, if !(storage[0x03] > 0x00)
	// Incoming jump from 0x173A
	// Inputs[1] { @173E  stack[-1] }
	173B    5B  JUMPDEST
	173C    60  PUSH1 0x01
	173E    90  SWAP1
	173F    50  POP
	// Stack delta = +0
	// Outputs[1] { @173E  stack[-1] = 0x01 }
	// Block continues

label_1740:
	// Incoming jump from 0x16FB
	// Incoming jump from 0x171A
	// Incoming jump from 0x169F
	// Incoming jump from 0x1739
	// Incoming jump from 0x173F
	// Inputs[3]
	// {
	//     @1741  stack[-1]
	//     @1741  stack[-4]
	//     @1742  stack[-3]
	// }
	1740    5B  JUMPDEST
	1741    92  SWAP3
	1742    91  SWAP2
	1743    50  POP
	1744    50  POP
	1745    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @1741  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

	1746    FE    *ASSERT
	1747    A2    LOG2
	1748    65    PUSH6 0x627a7a723158
	174F    20    SHA3
	1750    5E    5E
	1751    96    SWAP7
	1752    07    SMOD
	1753    14    EQ
	1754    1B    SHL
	1755    87    DUP8
	1756    6B    PUSH12 0x3dbee774458b770398e43a0b
	1763    2C    2C
	1764    8E    DUP15
	1765    C0    C0
	1766    75    PUSH22 0xc625e49dc5ea8406d364736f6c63430005110032