Online Solidity Decompiler

« Decompile another contract

Address

0x7138d2d87807c5e6db7fa82669c32ae398f85eb3 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x06fdde03 name()

0x095ea7b3 approve(address,uint256)

0x18160ddd totalSupply()

0x23b872dd transferFrom(address,address,uint256)

0x313ce567 decimals()

0x39509351 increaseAllowance(address,uint256)

0x54fd4d50 version()

0x70a08231 balanceOf(address)

0x7afa1eed generator()

0x95d89b41 symbol()

0xa457c2d7 decreaseAllowance(address,uint256)

0xa9059cbb transfer(address,uint256)

0xdd62ed3e allowance(address,address)

Internal Methods

approve(arg0, arg1) returns (r0)

balanceOf(arg0, arg1) returns (r0)

allowance(arg0, arg1) returns (r0)

name() returns (r0)

func_0392(arg0, arg1, arg3)

totalSupply() returns (r0)

func_03FF(arg0, arg1, arg2, arg3, arg4) returns (r0)

decimals() returns (r0)

func_0445(arg0, arg1, arg3)

func_0456(arg0, arg1, arg2, arg3, arg10) returns (r0)

version() returns (r0)

generator() returns (r0)

symbol() returns (r0)

func_054F(arg0, arg1, arg3)

func_0579(arg0, arg1, arg2, arg3, arg4, arg11) returns (r0)

func_05B7(arg0, arg1, arg3)

func_05E9(arg0, arg1) returns (r0)

func_064A() returns (r0)

func_073A(arg0, arg1, arg2)

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

func_092C(arg0, arg1, arg2)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
        var var0 = msg.value;
    
        if (var0) { revert(memory[0x00:0x00]); }
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (0x54fd4d50 > var0) {
            if (var0 == 0x06fdde03) {
                // Dispatch table entry for name()
                var var1 = 0x00dc;
                var1 = name();
            
            label_00DC:
                var temp0 = memory[0x40:0x60];
                memory[temp0:temp0 + 0x20] = 0x20;
                var temp1 = var1;
                memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = memory[temp1:temp1 + 0x20];
                var var2 = temp0;
                var var3 = var2;
                var var4 = var3 + 0x40;
                var var6 = memory[temp1:temp1 + 0x20];
                var var5 = temp1 + 0x20;
                var var7 = var6;
                var var8 = var4;
                var var9 = var5;
                var var10 = 0x00;
            
                if (var10 >= var7) {
                label_0116:
                    var temp2 = var6;
                    var4 = temp2 + var4;
                    var5 = temp2 & 0x1f;
                
                    if (!var5) {
                        var temp3 = memory[0x40:0x60];
                        return memory[temp3:temp3 + var4 - temp3];
                    } else {
                        var temp4 = var5;
                        var temp5 = var4 - temp4;
                        memory[temp5:temp5 + 0x20] = ~(0x0100 ** (0x20 - temp4) - 0x01) & memory[temp5:temp5 + 0x20];
                        var temp6 = memory[0x40:0x60];
                        return memory[temp6:temp6 + (temp5 + 0x20) - temp6];
                    }
                } else {
                label_0107:
                    var temp7 = var10;
                    memory[temp7 + var8:temp7 + var8 + 0x20] = memory[temp7 + var9:temp7 + var9 + 0x20];
                    var10 = temp7 + 0x20;
                
                    if (var10 >= var7) { goto label_0116; }
                    else { goto label_0107; }
                }
            } else if (var0 == 0x095ea7b3) {
                // Dispatch table entry for approve(address,uint256)
                var1 = 0x017d;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x40) { revert(memory[0x00:0x00]); }
            
                var1 = approve(var2, var3);
                var temp8 = memory[0x40:0x60];
                memory[temp8:temp8 + 0x20] = !!var1;
                var temp9 = memory[0x40:0x60];
                return memory[temp9:temp9 + temp8 - temp9 + 0x20];
            } else if (var0 == 0x18160ddd) {
                // Dispatch table entry for totalSupply()
                var1 = 0x0199;
                var1 = totalSupply();
            
            label_0199:
                var temp10 = memory[0x40:0x60];
                memory[temp10:temp10 + 0x20] = var1;
                var temp11 = memory[0x40:0x60];
                return memory[temp11:temp11 + temp10 - temp11 + 0x20];
            } else if (var0 == 0x23b872dd) {
                // Dispatch table entry for transferFrom(address,address,uint256)
                var1 = 0x017d;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x60) { revert(memory[0x00:0x00]); }
            
                var temp12 = (0x01 << 0xa0) - 0x01;
                var temp13 = var2;
                var2 = temp12 & msg.data[temp13:temp13 + 0x20];
                var3 = temp12 & msg.data[temp13 + 0x20:temp13 + 0x20 + 0x20];
                var4 = msg.data[temp13 + 0x40:temp13 + 0x40 + 0x20];
                var5 = 0x00;
                var6 = 0x03b5;
                var7 = var2;
                var8 = var3;
                var9 = var4;
                func_073A(var7, var8, var9);
                var6 = 0x0425;
                var7 = var2;
                var8 = 0x03c1;
                var8 = func_064A();
                var9 = 0x0420;
                var10 = var4;
                var temp14 = memory[0x40:0x60];
                var var11 = temp14;
                memory[0x40:0x60] = var11 + 0x60;
                memory[var11:var11 + 0x20] = 0x28;
                memory[var11 + 0x20:var11 + 0x20 + 0x28] = code[0x099d:0x09c5];
                memory[0x00:0x20] = var2 & (0x01 << 0xa0) - 0x01;
                memory[0x20:0x40] = 0x01;
                var var13 = 0x00;
                var var12 = keccak256(memory[var13:var13 + 0x40]);
                var var14 = 0x03ff;
                var14 = func_064A();
                var9 = func_03FF(var10, var11, var12, var13, var14);
            
                if (!(var7 & (0x01 << 0xa0) - 0x01)) {
                    var temp27 = memory[0x40:0x60];
                    memory[temp27:temp27 + 0x20] = 0x461bcd << 0xe5;
                    var temp28 = temp27 + 0x04;
                    var temp29 = temp28 + 0x20;
                    memory[temp28:temp28 + 0x20] = temp29 - temp28;
                    memory[temp29:temp29 + 0x20] = 0x24;
                    var temp30 = temp29 + 0x20;
                    memory[temp30:temp30 + 0x24] = code[0x09ea:0x0a0e];
                    var temp31 = memory[0x40:0x60];
                    revert(memory[temp31:temp31 + (temp30 + 0x40) - temp31]);
                } else if (var8 & (0x01 << 0xa0) - 0x01) {
                    var temp15 = (0x01 << 0xa0) - 0x01;
                    var temp16 = var7 & temp15;
                    memory[0x00:0x20] = temp16;
                    memory[0x20:0x40] = 0x01;
                    var temp17 = keccak256(memory[0x00:0x40]);
                    var temp18 = var8 & temp15;
                    memory[0x00:0x20] = temp18;
                    memory[0x20:0x40] = temp17;
                    var temp19 = var9;
                    storage[keccak256(memory[0x00:0x40])] = temp19;
                    var temp20 = memory[0x40:0x60];
                    memory[temp20:temp20 + 0x20] = temp19;
                    var temp21 = memory[0x40:0x60];
                    log(memory[temp21:temp21 + temp20 - temp21 + 0x20], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]);
                    // Error: Could not resolve jump destination!
                } else {
                    var temp22 = memory[0x40:0x60];
                    memory[temp22:temp22 + 0x20] = 0x461bcd << 0xe5;
                    var temp23 = temp22 + 0x04;
                    var temp24 = temp23 + 0x20;
                    memory[temp23:temp23 + 0x20] = temp24 - temp23;
                    memory[temp24:temp24 + 0x20] = 0x22;
                    var temp25 = temp24 + 0x20;
                    memory[temp25:temp25 + 0x22] = code[0x0955:0x0977];
                    var temp26 = memory[0x40:0x60];
                    revert(memory[temp26:temp26 + (temp25 + 0x40) - temp26]);
                }
            } else if (var0 == 0x313ce567) {
                // Dispatch table entry for decimals()
                var1 = 0x01e9;
                var1 = decimals();
                var temp32 = memory[0x40:0x60];
                memory[temp32:temp32 + 0x20] = var1 & 0xff;
                var temp33 = memory[0x40:0x60];
                return memory[temp33:temp33 + temp32 - temp33 + 0x20];
            } else if (var0 == 0x39509351) {
                // Dispatch table entry for increaseAllowance(address,uint256)
                var1 = 0x017d;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x40) { revert(memory[0x00:0x00]); }
            
                var temp34 = var2;
                var2 = msg.data[temp34:temp34 + 0x20] & (0x01 << 0xa0) - 0x01;
                var3 = msg.data[temp34 + 0x20:temp34 + 0x20 + 0x20];
                var4 = 0x00;
                var5 = 0x0399;
                var6 = 0x0445;
                var6 = func_064A();
                func_0445(var2, var3, var6);
            
            label_0399:
                var1 = 0x01;
                // Error: Could not resolve jump destination!
            } else { revert(memory[0x00:0x00]); }
        } else if (0x95d89b41 > var0) {
            if (var0 == 0x54fd4d50) {
                // Dispatch table entry for version()
                var1 = 0x00dc;
                var1 = version();
                goto label_00DC;
            } else if (var0 == 0x70a08231) {
                // Dispatch table entry for balanceOf(address)
                var1 = 0x0199;
                var2 = 0x04;
                var3 = msg.data.length - var2;
            
                if (var3 < 0x20) { revert(memory[0x00:0x00]); }
            
                var1 = balanceOf(var2, var3);
                goto label_0199;
            } else if (var0 == 0x7afa1eed) {
                // Dispatch table entry for generator()
                var1 = 0x00dc;
                var1 = generator();
                goto label_00DC;
            } else { revert(memory[0x00:0x00]); }
        } else if (var0 == 0x95d89b41) {
            // Dispatch table entry for symbol()
            var1 = 0x00dc;
            var1 = symbol();
            goto label_00DC;
        } else if (var0 == 0xa457c2d7) {
            // Dispatch table entry for decreaseAllowance(address,uint256)
            var1 = 0x017d;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var temp35 = var2;
            var2 = msg.data[temp35:temp35 + 0x20] & (0x01 << 0xa0) - 0x01;
            var3 = msg.data[temp35 + 0x20:temp35 + 0x20 + 0x20];
            var4 = 0x00;
            var5 = 0x0399;
            var6 = 0x054f;
            var6 = func_064A();
            func_054F(var2, var3, var6);
            goto label_0399;
        } else if (var0 == 0xa9059cbb) {
            // Dispatch table entry for transfer(address,uint256)
            var1 = 0x017d;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var temp36 = var2;
            var2 = msg.data[temp36:temp36 + 0x20] & (0x01 << 0xa0) - 0x01;
            var3 = msg.data[temp36 + 0x20:temp36 + 0x20 + 0x20];
            var4 = 0x00;
            var5 = 0x0399;
            var6 = 0x05b7;
            var6 = func_064A();
            func_05B7(var2, var3, var6);
            goto label_0399;
        } else if (var0 == 0xdd62ed3e) {
            // Dispatch table entry for allowance(address,address)
            var1 = 0x0199;
            var2 = 0x04;
            var3 = msg.data.length - var2;
        
            if (var3 < 0x40) { revert(memory[0x00:0x00]); }
        
            var1 = allowance(var2, var3);
            goto label_0199;
        } else { revert(memory[0x00:0x00]); }
    }
    
    function approve(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        arg0 = msg.data[temp0:temp0 + 0x20] & (0x01 << 0xa0) - 0x01;
        arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20];
        var var0 = 0x00;
        var var1 = 0x0399;
        var var2 = 0x0392;
        var2 = func_064A();
        func_0392(arg0, arg1, var2);
        return 0x01;
    }
    
    function balanceOf(var arg0, var arg1) returns (var r0) {
        arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01;
        memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01;
        memory[0x20:0x40] = 0x00;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function allowance(var arg0, var arg1) returns (var r0) {
        var temp0 = (0x01 << 0xa0) - 0x01;
        var temp1 = arg0;
        arg0 = temp0 & msg.data[temp1:temp1 + 0x20];
        arg1 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20] & temp0;
        var temp2 = (0x01 << 0xa0) - 0x01;
        memory[0x00:0x20] = temp2 & arg0;
        memory[0x20:0x40] = 0x01;
        var temp3 = keccak256(memory[0x00:0x40]);
        memory[0x00:0x20] = temp2 & arg1;
        memory[0x20:0x40] = temp3;
        return storage[keccak256(memory[0x00:0x40])];
    }
    
    function name() returns (var r0) {
        var temp0 = storage[0x03];
        var temp1 = memory[0x40:0x60];
        var temp2 = (temp0 & !(temp0 & 0x01) * 0x0100 + ~0x00) / 0x02;
        memory[0x40:0x60] = temp1 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20;
        memory[temp1:temp1 + 0x20] = temp2;
        var var0 = 0x60;
        var var1 = temp1;
        var var3 = temp2;
        var var2 = 0x03;
        var var4 = var1 + 0x20;
        var var5 = var2;
        var var6 = var3;
    
        if (!var6) {
        label_037B:
            return var1;
        } else if (0x1f < var6) {
            var temp3 = var4;
            var temp4 = temp3 + var6;
            var4 = temp4;
            memory[0x00:0x20] = var5;
            var temp5 = keccak256(memory[0x00:0x20]);
            memory[temp3:temp3 + 0x20] = storage[temp5];
            var5 = temp5 + 0x01;
            var6 = temp3 + 0x20;
        
            if (var4 <= var6) { goto label_0372; }
        
        label_035E:
            var temp6 = var5;
            var temp7 = var6;
            memory[temp7:temp7 + 0x20] = storage[temp6];
            var5 = temp6 + 0x01;
            var6 = temp7 + 0x20;
        
            if (var4 > var6) { goto label_035E; }
        
        label_0372:
            var temp8 = var4;
            var temp9 = temp8 + (var6 - temp8 & 0x1f);
            var6 = temp8;
            var4 = temp9;
            goto label_037B;
        } else {
            var temp10 = var4;
            memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100;
            var4 = temp10 + 0x20;
            var6 = var6;
            goto label_037B;
        }
    }
    
    function func_0392(var arg0, var arg1, var arg2) {
        var var0 = arg0;
        var var1 = arg1;
    
        if (!(arg2 & (0x01 << 0xa0) - 0x01)) {
            var temp12 = memory[0x40:0x60];
            memory[temp12:temp12 + 0x20] = 0x461bcd << 0xe5;
            var temp13 = temp12 + 0x04;
            var temp14 = temp13 + 0x20;
            memory[temp13:temp13 + 0x20] = temp14 - temp13;
            memory[temp14:temp14 + 0x20] = 0x24;
            var temp15 = temp14 + 0x20;
            memory[temp15:temp15 + 0x24] = code[0x09ea:0x0a0e];
            var temp16 = memory[0x40:0x60];
            revert(memory[temp16:temp16 + (temp15 + 0x40) - temp16]);
        } else if (var0 & (0x01 << 0xa0) - 0x01) {
            var temp0 = (0x01 << 0xa0) - 0x01;
            var temp1 = arg2 & temp0;
            memory[0x00:0x20] = temp1;
            memory[0x20:0x40] = 0x01;
            var temp2 = keccak256(memory[0x00:0x40]);
            var temp3 = var0 & temp0;
            memory[0x00:0x20] = temp3;
            memory[0x20:0x40] = temp2;
            var temp4 = var1;
            storage[keccak256(memory[0x00:0x40])] = temp4;
            var temp5 = memory[0x40:0x60];
            memory[temp5:temp5 + 0x20] = temp4;
            var temp6 = memory[0x40:0x60];
            log(memory[temp6:temp6 + temp5 - temp6 + 0x20], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]);
            return;
        } else {
            var temp7 = memory[0x40:0x60];
            memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5;
            var temp8 = temp7 + 0x04;
            var temp9 = temp8 + 0x20;
            memory[temp8:temp8 + 0x20] = temp9 - temp8;
            memory[temp9:temp9 + 0x20] = 0x22;
            var temp10 = temp9 + 0x20;
            memory[temp10:temp10 + 0x22] = code[0x0955:0x0977];
            var temp11 = memory[0x40:0x60];
            revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]);
        }
    }
    
    function totalSupply() returns (var r0) { return storage[0x02]; }
    
    function func_03FF(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) {
        var temp0 = arg3;
        memory[temp0:temp0 + 0x20] = arg4 & (0x01 << 0xa0) - 0x01;
        memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = arg2;
        var temp1 = arg0;
        arg0 = storage[keccak256(memory[0x00:0x00 + temp0 + 0x40])];
        arg2 = arg1;
        arg1 = temp1;
        r0 = func_0895(arg0, arg1, arg2);
        // Error: Could not resolve method call return address!
    }
    
    function decimals() returns (var r0) { return storage[0x05] & 0xff; }
    
    function func_0445(var arg0, var arg1, var arg2) {
        var var0 = arg0;
        var var1 = 0x0420;
        var var2 = arg1;
        var var3 = 0x01;
        var var4 = 0x00;
        var var5 = 0x0456;
        var5 = func_064A();
        var1 = func_0456(arg0, var2, var3, var4, var5);
    
        if (!(arg2 & (0x01 << 0xa0) - 0x01)) {
            var temp12 = memory[0x40:0x60];
            memory[temp12:temp12 + 0x20] = 0x461bcd << 0xe5;
            var temp13 = temp12 + 0x04;
            var temp14 = temp13 + 0x20;
            memory[temp13:temp13 + 0x20] = temp14 - temp13;
            memory[temp14:temp14 + 0x20] = 0x24;
            var temp15 = temp14 + 0x20;
            memory[temp15:temp15 + 0x24] = code[0x09ea:0x0a0e];
            var temp16 = memory[0x40:0x60];
            revert(memory[temp16:temp16 + (temp15 + 0x40) - temp16]);
        } else if (var0 & (0x01 << 0xa0) - 0x01) {
            var temp0 = (0x01 << 0xa0) - 0x01;
            var temp1 = arg2 & temp0;
            memory[0x00:0x20] = temp1;
            memory[0x20:0x40] = 0x01;
            var temp2 = keccak256(memory[0x00:0x40]);
            var temp3 = var0 & temp0;
            memory[0x00:0x20] = temp3;
            memory[0x20:0x40] = temp2;
            var temp4 = var1;
            storage[keccak256(memory[0x00:0x40])] = temp4;
            var temp5 = memory[0x40:0x60];
            memory[temp5:temp5 + 0x20] = temp4;
            var temp6 = memory[0x40:0x60];
            log(memory[temp6:temp6 + temp5 - temp6 + 0x20], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]);
            return;
        } else {
            var temp7 = memory[0x40:0x60];
            memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5;
            var temp8 = temp7 + 0x04;
            var temp9 = temp8 + 0x20;
            memory[temp8:temp8 + 0x20] = temp9 - temp8;
            memory[temp9:temp9 + 0x20] = 0x22;
            var temp10 = temp9 + 0x20;
            memory[temp10:temp10 + 0x22] = code[0x0955:0x0977];
            var temp11 = memory[0x40:0x60];
            revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]);
        }
    }
    
    function func_0456(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) {
        var temp0 = (0x01 << 0xa0) - 0x01;
        var temp1 = arg3;
        memory[temp1:temp1 + 0x20] = temp0 & arg4;
        memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = arg2;
        var temp2 = keccak256(memory[0x00:0x00 + temp1 + 0x40]);
        memory[0x00:0x20] = arg0 & temp0;
        memory[0x20:0x40] = temp2;
        var temp3 = arg1;
        arg1 = storage[keccak256(memory[0x00:0x40])];
        arg2 = temp3;
        r0 = func_05E9(arg1, arg2);
        // Error: Could not resolve method call return address!
    }
    
    function version() returns (var r0) {
        var temp0 = memory[0x40:0x60];
        memory[0x40:0x60] = temp0 + 0x40;
        memory[temp0:temp0 + 0x20] = 0x06;
        memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x076342e302e3 << 0xd4;
        return temp0;
    }
    
    function generator() returns (var r0) {
        var temp0 = memory[0x40:0x60];
        memory[0x40:0x60] = temp0 + 0x60;
        memory[temp0:temp0 + 0x20] = 0x2f;
        memory[temp0 + 0x20:temp0 + 0x20 + 0x2f] = code[0x0a0e:0x0a3d];
        return temp0;
    }
    
    function symbol() returns (var r0) {
        var temp0 = storage[0x04];
        var temp1 = memory[0x40:0x60];
        var temp2 = (temp0 & !(temp0 & 0x01) * 0x0100 + ~0x00) / 0x02;
        memory[0x40:0x60] = temp1 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20;
        memory[temp1:temp1 + 0x20] = temp2;
        var var0 = 0x60;
        var var1 = temp1;
        var var3 = temp2;
        var var2 = 0x04;
        var var4 = var1 + 0x20;
        var var5 = var2;
        var var6 = var3;
    
        if (!var6) {
        label_037B:
            return var1;
        } else if (0x1f < var6) {
            var temp3 = var4;
            var temp4 = temp3 + var6;
            var4 = temp4;
            memory[0x00:0x20] = var5;
            var temp5 = keccak256(memory[0x00:0x20]);
            memory[temp3:temp3 + 0x20] = storage[temp5];
            var5 = temp5 + 0x01;
            var6 = temp3 + 0x20;
        
            if (var4 <= var6) { goto label_0372; }
        
        label_035E:
            var temp6 = var5;
            var temp7 = var6;
            memory[temp7:temp7 + 0x20] = storage[temp6];
            var5 = temp6 + 0x01;
            var6 = temp7 + 0x20;
        
            if (var4 > var6) { goto label_035E; }
        
        label_0372:
            var temp8 = var4;
            var temp9 = temp8 + (var6 - temp8 & 0x1f);
            var6 = temp8;
            var4 = temp9;
            goto label_037B;
        } else {
            var temp10 = var4;
            memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100;
            var4 = temp10 + 0x20;
            var6 = var6;
            goto label_037B;
        }
    }
    
    function func_054F(var arg0, var arg1, var arg2) {
        var var0 = arg0;
        var var1 = 0x0420;
        var var2 = arg1;
        var temp0 = memory[0x40:0x60];
        var var3 = temp0;
        memory[0x40:0x60] = var3 + 0x60;
        memory[var3:var3 + 0x20] = 0x25;
        memory[var3 + 0x20:var3 + 0x20 + 0x25] = code[0x0a3d:0x0a62];
        var var4 = 0x01;
        var var5 = 0x00;
        var var6 = 0x0579;
        var6 = func_064A();
        var1 = func_0579(arg0, var2, var3, var4, var5, var6);
    
        if (!(arg2 & (0x01 << 0xa0) - 0x01)) {
            var temp13 = memory[0x40:0x60];
            memory[temp13:temp13 + 0x20] = 0x461bcd << 0xe5;
            var temp14 = temp13 + 0x04;
            var temp15 = temp14 + 0x20;
            memory[temp14:temp14 + 0x20] = temp15 - temp14;
            memory[temp15:temp15 + 0x20] = 0x24;
            var temp16 = temp15 + 0x20;
            memory[temp16:temp16 + 0x24] = code[0x09ea:0x0a0e];
            var temp17 = memory[0x40:0x60];
            revert(memory[temp17:temp17 + (temp16 + 0x40) - temp17]);
        } else if (var0 & (0x01 << 0xa0) - 0x01) {
            var temp1 = (0x01 << 0xa0) - 0x01;
            var temp2 = arg2 & temp1;
            memory[0x00:0x20] = temp2;
            memory[0x20:0x40] = 0x01;
            var temp3 = keccak256(memory[0x00:0x40]);
            var temp4 = var0 & temp1;
            memory[0x00:0x20] = temp4;
            memory[0x20:0x40] = temp3;
            var temp5 = var1;
            storage[keccak256(memory[0x00:0x40])] = temp5;
            var temp6 = memory[0x40:0x60];
            memory[temp6:temp6 + 0x20] = temp5;
            var temp7 = memory[0x40:0x60];
            log(memory[temp7:temp7 + temp6 - temp7 + 0x20], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]);
            return;
        } else {
            var temp8 = memory[0x40:0x60];
            memory[temp8:temp8 + 0x20] = 0x461bcd << 0xe5;
            var temp9 = temp8 + 0x04;
            var temp10 = temp9 + 0x20;
            memory[temp9:temp9 + 0x20] = temp10 - temp9;
            memory[temp10:temp10 + 0x20] = 0x22;
            var temp11 = temp10 + 0x20;
            memory[temp11:temp11 + 0x22] = code[0x0955:0x0977];
            var temp12 = memory[0x40:0x60];
            revert(memory[temp12:temp12 + (temp11 + 0x40) - temp12]);
        }
    }
    
    function func_0579(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) {
        var temp0 = (0x01 << 0xa0) - 0x01;
        var temp1 = arg4;
        memory[temp1:temp1 + 0x20] = temp0 & arg5;
        memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = arg3;
        var temp2 = keccak256(memory[0x00:0x00 + temp1 + 0x40]);
        memory[0x00:0x20] = arg0 & temp0;
        memory[0x20:0x40] = temp2;
        var temp3 = arg1;
        arg1 = storage[keccak256(memory[0x00:0x40])];
        var temp4 = arg2;
        arg2 = temp3;
        arg3 = temp4;
        r0 = func_0895(arg1, arg2, arg3);
        // Error: Could not resolve method call return address!
    }
    
    function func_05B7(var arg0, var arg1, var arg2) {
        var var0 = arg0;
        var var1 = arg1;
        func_073A(arg2, var0, var1);
        // Error: Could not resolve method call return address!
    }
    
    function func_05E9(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var temp0 = arg0;
        var var1 = arg1 + temp0;
    
        if (var1 >= temp0) { return var1; }
    
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5;
        memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x20;
        memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = 0x1b;
        memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000;
        var temp2 = memory[0x40:0x60];
        revert(memory[temp2:temp2 + temp1 - temp2 + 0x64]);
    }
    
    function func_064A() returns (var r0) { return msg.sender; }
    
    function func_073A(var arg0, var arg1, var arg2) {
        if (!(arg0 & (0x01 << 0xa0) - 0x01)) {
            var temp11 = memory[0x40:0x60];
            memory[temp11:temp11 + 0x20] = 0x461bcd << 0xe5;
            var temp12 = temp11 + 0x04;
            var temp13 = temp12 + 0x20;
            memory[temp12:temp12 + 0x20] = temp13 - temp12;
            memory[temp13:temp13 + 0x20] = 0x25;
            var temp14 = temp13 + 0x20;
            memory[temp14:temp14 + 0x25] = code[0x09c5:0x09ea];
            var temp15 = memory[0x40:0x60];
            revert(memory[temp15:temp15 + (temp14 + 0x40) - temp15]);
        } else if (arg1 & (0x01 << 0xa0) - 0x01) {
            var var0 = 0x07cf;
            var var1 = arg0;
            var var2 = arg1;
            var var3 = arg2;
            func_092C(var1, var2, var3);
            var0 = 0x080c;
            var temp0 = memory[0x40:0x60];
            memory[0x40:0x60] = temp0 + 0x60;
            memory[temp0:temp0 + 0x20] = 0x26;
            memory[temp0 + 0x20:temp0 + 0x20 + 0x26] = code[0x0977:0x099d];
            memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01;
            memory[0x20:0x40] = 0x00;
            var1 = storage[keccak256(memory[0x00:0x40])];
            var3 = temp0;
            var2 = arg2;
            var0 = func_0895(var1, var2, var3);
            var temp1 = (0x01 << 0xa0) - 0x01;
            memory[0x00:0x20] = arg0 & temp1;
            memory[0x20:0x40] = 0x00;
            storage[keccak256(memory[0x00:0x40])] = var0;
            memory[0x00:0x20] = arg1 & temp1;
            var1 = storage[keccak256(memory[0x00:0x40])];
            var0 = 0x083b;
            var2 = arg2;
            var0 = func_05E9(var1, var2);
            var temp2 = (0x01 << 0xa0) - 0x01;
            var temp3 = arg1 & temp2;
            memory[0x00:0x20] = temp3;
            memory[0x20:0x40] = 0x00;
            storage[keccak256(memory[0x00:0x40])] = var0;
            var temp4 = memory[0x40:0x60];
            memory[temp4:temp4 + 0x20] = arg2;
            var temp5 = memory[0x40:0x60];
            log(memory[temp5:temp5 + temp4 - temp5 + 0x20], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01]);
            return;
        } else {
            var temp6 = memory[0x40:0x60];
            memory[temp6:temp6 + 0x20] = 0x461bcd << 0xe5;
            var temp7 = temp6 + 0x04;
            var temp8 = temp7 + 0x20;
            memory[temp7:temp7 + 0x20] = temp8 - temp7;
            memory[temp8:temp8 + 0x20] = 0x23;
            var temp9 = temp8 + 0x20;
            memory[temp9:temp9 + 0x23] = code[0x0932:0x0955];
            var temp10 = memory[0x40:0x60];
            revert(memory[temp10:temp10 + (temp9 + 0x40) - temp10]);
        }
    }
    
    function func_0895(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = arg2;
    
        if (arg1 <= arg0) { return arg0 - arg1; }
    
        var temp0 = memory[0x40:0x60];
        memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5;
        var temp1 = temp0 + 0x04;
        var var2 = temp1;
        var var3 = var2;
        var temp2 = var3 + 0x20;
        memory[var3:var3 + 0x20] = temp2 - var3;
        var temp3 = var1;
        memory[temp2:temp2 + 0x20] = memory[temp3:temp3 + 0x20];
        var var4 = temp2 + 0x20;
        var var5 = temp3 + 0x20;
        var var6 = memory[temp3:temp3 + 0x20];
        var var7 = var6;
        var var8 = var4;
        var var9 = var5;
        var var10 = 0x00;
    
        if (var10 >= var7) {
        label_08E9:
            var temp4 = var6;
            var4 = temp4 + var4;
            var5 = temp4 & 0x1f;
        
            if (!var5) {
                var temp5 = memory[0x40:0x60];
                revert(memory[temp5:temp5 + var4 - temp5]);
            } else {
                var temp6 = var5;
                var temp7 = var4 - temp6;
                memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
                var temp8 = memory[0x40:0x60];
                revert(memory[temp8:temp8 + (temp7 + 0x20) - temp8]);
            }
        } else {
        label_08DA:
            var temp9 = var10;
            memory[temp9 + var8:temp9 + var8 + 0x20] = memory[temp9 + var9:temp9 + var9 + 0x20];
            var10 = temp9 + 0x20;
        
            if (var10 >= var7) { goto label_08E9; }
            else { goto label_08DA; }
        }
    }
    
    function func_092C(var arg0, var arg1, var arg2) {}
}

Disassembly

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

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

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

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

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

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

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

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

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

label_0062:
	// Incoming jump from 0x0061, if not 0xdd62ed3e == stack[-1]
	0062    61  PUSH2 0x00cf
	0065    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x00cf

label_0066:
	// Incoming jump from 0x0035, if 0x95d89b41 > stack[-1]
	// Inputs[1] { @0067  stack[-1] }
	0066    5B  JUMPDEST
	0067    80  DUP1
	0068    63  PUSH4 0x54fd4d50
	006D    14  EQ
	006E    61  PUSH2 0x022b
	0071    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x022b, if 0x54fd4d50 == stack[-1]

label_0072:
	// Incoming jump from 0x0071, if not 0x54fd4d50 == stack[-1]
	// Inputs[1] { @0072  stack[-1] }
	0072    80  DUP1
	0073    63  PUSH4 0x70a08231
	0078    14  EQ
	0079    61  PUSH2 0x0233
	007C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0233, if 0x70a08231 == stack[-1]

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

label_0088:
	// Incoming jump from 0x0087, if not 0x7afa1eed == stack[-1]
	0088    61  PUSH2 0x00cf
	008B    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x00cf

label_008C:
	// Incoming jump from 0x002A, if 0x54fd4d50 > msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @008D  stack[-1] }
	008C    5B  JUMPDEST
	008D    80  DUP1
	008E    63  PUSH4 0x06fdde03
	0093    14  EQ
	0094    61  PUSH2 0x00d4
	0097    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00d4, if 0x06fdde03 == stack[-1]

label_0098:
	// Incoming jump from 0x0097, if not 0x06fdde03 == stack[-1]
	// Inputs[1] { @0098  stack[-1] }
	0098    80  DUP1
	0099    63  PUSH4 0x095ea7b3
	009E    14  EQ
	009F    61  PUSH2 0x0151
	00A2    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0151, if 0x095ea7b3 == stack[-1]

label_00A3:
	// Incoming jump from 0x00A2, if not 0x095ea7b3 == stack[-1]
	// Inputs[1] { @00A3  stack[-1] }
	00A3    80  DUP1
	00A4    63  PUSH4 0x18160ddd
	00A9    14  EQ
	00AA    61  PUSH2 0x0191
	00AD    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0191, if 0x18160ddd == stack[-1]

label_00AE:
	// Incoming jump from 0x00AD, if not 0x18160ddd == stack[-1]
	// Inputs[1] { @00AE  stack[-1] }
	00AE    80  DUP1
	00AF    63  PUSH4 0x23b872dd
	00B4    14  EQ
	00B5    61  PUSH2 0x01ab
	00B8    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01ab, if 0x23b872dd == stack[-1]

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

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

label_00CF:
	// Incoming jump from 0x0019, if msg.data.length < 0x04
	// Incoming jump from 0x008B
	// Incoming jump from 0x00CE, if not 0x39509351 == stack[-1]
	// Incoming jump from 0x0065
	// Inputs[1] { @00D3  memory[0x00:0x00] }
	00CF    5B  JUMPDEST
	00D0    60  PUSH1 0x00
	00D2    80  DUP1
	00D3    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @00D3  revert(memory[0x00:0x00]); }
	// Block terminates

label_00D4:
	// Incoming jump from 0x0097, if 0x06fdde03 == stack[-1]
	00D4    5B  JUMPDEST
	00D5    61  PUSH2 0x00dc
	00D8    61  PUSH2 0x02ef
	00DB    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @00D5  stack[0] = 0x00dc }
	// Block ends with call to 0x02ef, returns to 0x00DC

label_00DC:
	// Incoming return from call to 0x04C1 at 0x0260
	// Incoming return from call to 0x04E1 at 0x0268
	// Incoming return from call to 0x0486 at 0x0232
	// Incoming return from call to 0x02EF at 0x00DB
	// Inputs[4]
	// {
	//     @00E0  memory[0x40:0x60]
	//     @00E6  stack[-1]
	//     @00E7  memory[stack[-1]:stack[-1] + 0x20]
	//     @00ED  memory[stack[-1]:stack[-1] + 0x20]
	// }
	00DC    5B  JUMPDEST
	00DD    60  PUSH1 0x40
	00DF    80  DUP1
	00E0    51  MLOAD
	00E1    60  PUSH1 0x20
	00E3    80  DUP1
	00E4    82  DUP3
	00E5    52  MSTORE
	00E6    83  DUP4
	00E7    51  MLOAD
	00E8    81  DUP2
	00E9    83  DUP4
	00EA    01  ADD
	00EB    52  MSTORE
	00EC    83  DUP4
	00ED    51  MLOAD
	00EE    91  SWAP2
	00EF    92  SWAP3
	00F0    83  DUP4
	00F1    92  SWAP3
	00F2    90  SWAP1
	00F3    83  DUP4
	00F4    01  ADD
	00F5    91  SWAP2
	00F6    85  DUP6
	00F7    01  ADD
	00F8    90  SWAP1
	00F9    80  DUP1
	00FA    83  DUP4
	00FB    83  DUP4
	00FC    60  PUSH1 0x00
	00FE    5B  JUMPDEST
	00FF    83  DUP4
	0100    81  DUP2
	0101    10  LT
	0102    15  ISZERO
	0103    61  PUSH2 0x0116
	0106    57  *JUMPI
	// Stack delta = +9
	// Outputs[11]
	// {
	//     @00E5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20
	//     @00EB  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @00EF  stack[0] = memory[0x40:0x60]
	//     @00F1  stack[1] = memory[0x40:0x60]
	//     @00F5  stack[2] = memory[0x40:0x60] + 0x40
	//     @00F8  stack[3] = stack[-1] + 0x20
	//     @00F8  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @00F9  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @00FA  stack[6] = memory[0x40:0x60] + 0x40
	//     @00FB  stack[7] = stack[-1] + 0x20
	//     @00FC  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x0116, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0107:
	// Incoming jump from 0x0106, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x0106, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0107  stack[-2]
	//     @0108  stack[-1]
	//     @010A  memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20]
	//     @010B  stack[-3]
	// }
	0107    81  DUP2
	0108    81  DUP2
	0109    01  ADD
	010A    51  MLOAD
	010B    83  DUP4
	010C    82  DUP3
	010D    01  ADD
	010E    52  MSTORE
	010F    60  PUSH1 0x20
	0111    01  ADD
	0112    61  PUSH2 0x00fe
	0115    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @010E  memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20]
	//     @0111  stack[-1] = 0x20 + stack[-1]
	// }
	// Block ends with unconditional jump to 0x00fe

label_0116:
	// Incoming jump from 0x0106, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x0106, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @011B  stack[-5]
	//     @011B  stack[-6]
	//     @011D  stack[-7]
	// }
	0116    5B  JUMPDEST
	0117    50  POP
	0118    50  POP
	0119    50  POP
	011A    50  POP
	011B    90  SWAP1
	011C    50  POP
	011D    90  SWAP1
	011E    81  DUP2
	011F    01  ADD
	0120    90  SWAP1
	0121    60  PUSH1 0x1f
	0123    16  AND
	0124    80  DUP1
	0125    15  ISZERO
	0126    61  PUSH2 0x0143
	0129    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0120  stack[-7] = stack[-5] + stack[-7]
	//     @0123  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0143, if !(0x1f & stack[-5])

label_012A:
	// Incoming jump from 0x0129, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @012A  stack[-1]
	//     @012B  stack[-2]
	//     @012E  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0145  stack[-5]
	//     @014B  memory[0x40:0x60]
	//     @0150  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	012A    80  DUP1
	012B    82  DUP3
	012C    03  SUB
	012D    80  DUP1
	012E    51  MLOAD
	012F    60  PUSH1 0x01
	0131    83  DUP4
	0132    60  PUSH1 0x20
	0134    03  SUB
	0135    61  PUSH2 0x0100
	0138    0A  EXP
	0139    03  SUB
	013A    19  NOT
	013B    16  AND
	013C    81  DUP2
	013D    52  MSTORE
	013E    60  PUSH1 0x20
	0140    01  ADD
	0141    91  SWAP2
	0142    50  POP
	0143    5B  JUMPDEST
	0144    50  POP
	0145    92  SWAP3
	0146    50  POP
	0147    50  POP
	0148    50  POP
	0149    60  PUSH1 0x40
	014B    51  MLOAD
	014C    80  DUP1
	014D    91  SWAP2
	014E    03  SUB
	014F    90  SWAP1
	0150    F3  *RETURN
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @013D  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]
	//     @0150  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0151:
	// Incoming jump from 0x00A2, if 0x095ea7b3 == stack[-1]
	// Inputs[1] { @0158  msg.data.length }
	0151    5B  JUMPDEST
	0152    61  PUSH2 0x017d
	0155    60  PUSH1 0x04
	0157    80  DUP1
	0158    36  CALLDATASIZE
	0159    03  SUB
	015A    60  PUSH1 0x40
	015C    81  DUP2
	015D    10  LT
	015E    15  ISZERO
	015F    61  PUSH2 0x0167
	0162    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0152  stack[0] = 0x017d
	//     @0155  stack[1] = 0x04
	//     @0159  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0167, returns to 0x017D, if !(msg.data.length - 0x04 < 0x40)

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

label_0167:
	// Incoming call from 0x0162, returns to 0x017D, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @0171  stack[-2]
	//     @0172  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0178  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0167    5B  JUMPDEST
	0168    50  POP
	0169    60  PUSH1 0x01
	016B    60  PUSH1 0x01
	016D    60  PUSH1 0xa0
	016F    1B  SHL
	0170    03  SUB
	0171    81  DUP2
	0172    35  CALLDATALOAD
	0173    16  AND
	0174    90  SWAP1
	0175    60  PUSH1 0x20
	0177    01  ADD
	0178    35  CALLDATALOAD
	0179    61  PUSH2 0x0385
	017C    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0174  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01
	//     @0178  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0385

label_017D:
	// Incoming return from call to 0x0167 at 0x0162
	// Inputs[4]
	// {
	//     @0181  memory[0x40:0x60]
	//     @0182  stack[-1]
	//     @0187  memory[0x40:0x60]
	//     @0190  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]
	// }
	017D    5B  JUMPDEST
	017E    60  PUSH1 0x40
	0180    80  DUP1
	0181    51  MLOAD
	0182    91  SWAP2
	0183    15  ISZERO
	0184    15  ISZERO
	0185    82  DUP3
	0186    52  MSTORE
	0187    51  MLOAD
	0188    90  SWAP1
	0189    81  DUP2
	018A    90  SWAP1
	018B    03  SUB
	018C    60  PUSH1 0x20
	018E    01  ADD
	018F    90  SWAP1
	0190    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0186  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1]
	//     @0190  return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])];
	// }
	// Block terminates

label_0191:
	// Incoming jump from 0x00AD, if 0x18160ddd == stack[-1]
	0191    5B  JUMPDEST
	0192    61  PUSH2 0x0199
	0195    61  PUSH2 0x03a2
	0198    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0192  stack[0] = 0x0199 }
	// Block ends with call to 0x03a2, returns to 0x0199

label_0199:
	// Incoming return from call to 0x02D7 at 0x02D2
	// Incoming return from call to 0x03A2 at 0x0198
	// Incoming return from call to 0x0249 at 0x0244
	// Inputs[4]
	// {
	//     @019D  memory[0x40:0x60]
	//     @019E  stack[-1]
	//     @01A1  memory[0x40:0x60]
	//     @01AA  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]
	// }
	0199    5B  JUMPDEST
	019A    60  PUSH1 0x40
	019C    80  DUP1
	019D    51  MLOAD
	019E    91  SWAP2
	019F    82  DUP3
	01A0    52  MSTORE
	01A1    51  MLOAD
	01A2    90  SWAP1
	01A3    81  DUP2
	01A4    90  SWAP1
	01A5    03  SUB
	01A6    60  PUSH1 0x20
	01A8    01  ADD
	01A9    90  SWAP1
	01AA    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @01A0  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @01AA  return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])];
	// }
	// Block terminates

label_01AB:
	// Incoming jump from 0x00B8, if 0x23b872dd == stack[-1]
	// Inputs[1] { @01B2  msg.data.length }
	01AB    5B  JUMPDEST
	01AC    61  PUSH2 0x017d
	01AF    60  PUSH1 0x04
	01B1    80  DUP1
	01B2    36  CALLDATASIZE
	01B3    03  SUB
	01B4    60  PUSH1 0x60
	01B6    81  DUP2
	01B7    10  LT
	01B8    15  ISZERO
	01B9    61  PUSH2 0x01c1
	01BC    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @01AC  stack[0] = 0x017d
	//     @01AF  stack[1] = 0x04
	//     @01B3  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional jump to 0x01c1, if !(msg.data.length - 0x04 < 0x60)

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

label_01C1:
	// Incoming jump from 0x01BC, if !(msg.data.length - 0x04 < 0x60)
	// Inputs[4]
	// {
	//     @01CB  stack[-2]
	//     @01CC  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01D4  msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	//     @01DC  msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20]
	// }
	01C1    5B  JUMPDEST
	01C2    50  POP
	01C3    60  PUSH1 0x01
	01C5    60  PUSH1 0x01
	01C7    60  PUSH1 0xa0
	01C9    1B  SHL
	01CA    03  SUB
	01CB    81  DUP2
	01CC    35  CALLDATALOAD
	01CD    81  DUP2
	01CE    16  AND
	01CF    91  SWAP2
	01D0    60  PUSH1 0x20
	01D2    81  DUP2
	01D3    01  ADD
	01D4    35  CALLDATALOAD
	01D5    90  SWAP1
	01D6    91  SWAP2
	01D7    16  AND
	01D8    90  SWAP1
	01D9    60  PUSH1 0x40
	01DB    01  ADD
	01DC    35  CALLDATALOAD
	01DD    61  PUSH2 0x03a8
	01E0    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @01CF  stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @01D8  stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	//     @01DC  stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x03a8

label_01E1:
	// Incoming jump from 0x00C3, if 0x313ce567 == stack[-1]
	01E1    5B  JUMPDEST
	01E2    61  PUSH2 0x01e9
	01E5    61  PUSH2 0x042f
	01E8    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01E2  stack[0] = 0x01e9 }
	// Block ends with call to 0x042f, returns to 0x01E9

label_01E9:
	// Incoming return from call to 0x042F at 0x01E8
	// Inputs[4]
	// {
	//     @01ED  memory[0x40:0x60]
	//     @01F1  stack[-1]
	//     @01F5  memory[0x40:0x60]
	//     @01FE  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]
	// }
	01E9    5B  JUMPDEST
	01EA    60  PUSH1 0x40
	01EC    80  DUP1
	01ED    51  MLOAD
	01EE    60  PUSH1 0xff
	01F0    90  SWAP1
	01F1    92  SWAP3
	01F2    16  AND
	01F3    82  DUP3
	01F4    52  MSTORE
	01F5    51  MLOAD
	01F6    90  SWAP1
	01F7    81  DUP2
	01F8    90  SWAP1
	01F9    03  SUB
	01FA    60  PUSH1 0x20
	01FC    01  ADD
	01FD    90  SWAP1
	01FE    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @01F4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff
	//     @01FE  return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])];
	// }
	// Block terminates

label_01FF:
	// Incoming jump from 0x00CE, if 0x39509351 == stack[-1]
	// Inputs[1] { @0206  msg.data.length }
	01FF    5B  JUMPDEST
	0200    61  PUSH2 0x017d
	0203    60  PUSH1 0x04
	0205    80  DUP1
	0206    36  CALLDATASIZE
	0207    03  SUB
	0208    60  PUSH1 0x40
	020A    81  DUP2
	020B    10  LT
	020C    15  ISZERO
	020D    61  PUSH2 0x0215
	0210    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0200  stack[0] = 0x017d
	//     @0203  stack[1] = 0x04
	//     @0207  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional jump to 0x0215, if !(msg.data.length - 0x04 < 0x40)

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

label_0215:
	// Incoming jump from 0x0210, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @021F  stack[-2]
	//     @0220  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0226  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	0215    5B  JUMPDEST
	0216    50  POP
	0217    60  PUSH1 0x01
	0219    60  PUSH1 0x01
	021B    60  PUSH1 0xa0
	021D    1B  SHL
	021E    03  SUB
	021F    81  DUP2
	0220    35  CALLDATALOAD
	0221    16  AND
	0222    90  SWAP1
	0223    60  PUSH1 0x20
	0225    01  ADD
	0226    35  CALLDATALOAD
	0227    61  PUSH2 0x0438
	022A    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0222  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01
	//     @0226  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0438

label_022B:
	// Incoming jump from 0x0071, if 0x54fd4d50 == stack[-1]
	022B    5B  JUMPDEST
	022C    61  PUSH2 0x00dc
	022F    61  PUSH2 0x0486
	0232    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @022C  stack[0] = 0x00dc }
	// Block ends with call to 0x0486, returns to 0x00DC

label_0233:
	// Incoming jump from 0x007C, if 0x70a08231 == stack[-1]
	// Inputs[1] { @023A  msg.data.length }
	0233    5B  JUMPDEST
	0234    61  PUSH2 0x0199
	0237    60  PUSH1 0x04
	0239    80  DUP1
	023A    36  CALLDATASIZE
	023B    03  SUB
	023C    60  PUSH1 0x20
	023E    81  DUP2
	023F    10  LT
	0240    15  ISZERO
	0241    61  PUSH2 0x0249
	0244    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0234  stack[0] = 0x0199
	//     @0237  stack[1] = 0x04
	//     @023B  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x0249, returns to 0x0199, if !(msg.data.length - 0x04 < 0x20)

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

label_0249:
	// Incoming call from 0x0244, returns to 0x0199, if !(msg.data.length - 0x04 < 0x20)
	// Inputs[2]
	// {
	//     @024B  stack[-2]
	//     @024B  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	0249    5B  JUMPDEST
	024A    50  POP
	024B    35  CALLDATALOAD
	024C    60  PUSH1 0x01
	024E    60  PUSH1 0x01
	0250    60  PUSH1 0xa0
	0252    1B  SHL
	0253    03  SUB
	0254    16  AND
	0255    61  PUSH2 0x04a6
	0258    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @0254  stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with unconditional jump to 0x04a6

label_0259:
	// Incoming jump from 0x0087, if 0x7afa1eed == stack[-1]
	0259    5B  JUMPDEST
	025A    61  PUSH2 0x00dc
	025D    61  PUSH2 0x04c1
	0260    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @025A  stack[0] = 0x00dc }
	// Block ends with call to 0x04c1, returns to 0x00DC

label_0261:
	// Incoming jump from 0x0040, if 0x95d89b41 == stack[-1]
	0261    5B  JUMPDEST
	0262    61  PUSH2 0x00dc
	0265    61  PUSH2 0x04e1
	0268    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0262  stack[0] = 0x00dc }
	// Block ends with call to 0x04e1, returns to 0x00DC

label_0269:
	// Incoming jump from 0x004B, if 0xa457c2d7 == stack[-1]
	// Inputs[1] { @0270  msg.data.length }
	0269    5B  JUMPDEST
	026A    61  PUSH2 0x017d
	026D    60  PUSH1 0x04
	026F    80  DUP1
	0270    36  CALLDATASIZE
	0271    03  SUB
	0272    60  PUSH1 0x40
	0274    81  DUP2
	0275    10  LT
	0276    15  ISZERO
	0277    61  PUSH2 0x027f
	027A    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @026A  stack[0] = 0x017d
	//     @026D  stack[1] = 0x04
	//     @0271  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional jump to 0x027f, if !(msg.data.length - 0x04 < 0x40)

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

label_027F:
	// Incoming jump from 0x027A, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @0289  stack[-2]
	//     @028A  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @0290  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	027F    5B  JUMPDEST
	0280    50  POP
	0281    60  PUSH1 0x01
	0283    60  PUSH1 0x01
	0285    60  PUSH1 0xa0
	0287    1B  SHL
	0288    03  SUB
	0289    81  DUP2
	028A    35  CALLDATALOAD
	028B    16  AND
	028C    90  SWAP1
	028D    60  PUSH1 0x20
	028F    01  ADD
	0290    35  CALLDATALOAD
	0291    61  PUSH2 0x0542
	0294    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @028C  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01
	//     @0290  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x0542

label_0295:
	// Incoming jump from 0x0056, if 0xa9059cbb == stack[-1]
	// Inputs[1] { @029C  msg.data.length }
	0295    5B  JUMPDEST
	0296    61  PUSH2 0x017d
	0299    60  PUSH1 0x04
	029B    80  DUP1
	029C    36  CALLDATASIZE
	029D    03  SUB
	029E    60  PUSH1 0x40
	02A0    81  DUP2
	02A1    10  LT
	02A2    15  ISZERO
	02A3    61  PUSH2 0x02ab
	02A6    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0296  stack[0] = 0x017d
	//     @0299  stack[1] = 0x04
	//     @029D  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional jump to 0x02ab, if !(msg.data.length - 0x04 < 0x40)

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

label_02AB:
	// Incoming jump from 0x02A6, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @02B5  stack[-2]
	//     @02B6  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @02BC  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	02AB    5B  JUMPDEST
	02AC    50  POP
	02AD    60  PUSH1 0x01
	02AF    60  PUSH1 0x01
	02B1    60  PUSH1 0xa0
	02B3    1B  SHL
	02B4    03  SUB
	02B5    81  DUP2
	02B6    35  CALLDATALOAD
	02B7    16  AND
	02B8    90  SWAP1
	02B9    60  PUSH1 0x20
	02BB    01  ADD
	02BC    35  CALLDATALOAD
	02BD    61  PUSH2 0x05aa
	02C0    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @02B8  stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01
	//     @02BC  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	// Block ends with unconditional jump to 0x05aa

label_02C1:
	// Incoming jump from 0x0061, if 0xdd62ed3e == stack[-1]
	// Inputs[1] { @02C8  msg.data.length }
	02C1    5B  JUMPDEST
	02C2    61  PUSH2 0x0199
	02C5    60  PUSH1 0x04
	02C7    80  DUP1
	02C8    36  CALLDATASIZE
	02C9    03  SUB
	02CA    60  PUSH1 0x40
	02CC    81  DUP2
	02CD    10  LT
	02CE    15  ISZERO
	02CF    61  PUSH2 0x02d7
	02D2    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @02C2  stack[0] = 0x0199
	//     @02C5  stack[1] = 0x04
	//     @02C9  stack[2] = msg.data.length - 0x04
	// }
	// Block ends with conditional call to 0x02d7, returns to 0x0199, if !(msg.data.length - 0x04 < 0x40)

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

label_02D7:
	// Incoming call from 0x02D2, returns to 0x0199, if !(msg.data.length - 0x04 < 0x40)
	// Inputs[3]
	// {
	//     @02E1  stack[-2]
	//     @02E2  msg.data[stack[-2]:stack[-2] + 0x20]
	//     @02E9  msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20]
	// }
	02D7    5B  JUMPDEST
	02D8    50  POP
	02D9    60  PUSH1 0x01
	02DB    60  PUSH1 0x01
	02DD    60  PUSH1 0xa0
	02DF    1B  SHL
	02E0    03  SUB
	02E1    81  DUP2
	02E2    35  CALLDATALOAD
	02E3    81  DUP2
	02E4    16  AND
	02E5    91  SWAP2
	02E6    60  PUSH1 0x20
	02E8    01  ADD
	02E9    35  CALLDATALOAD
	02EA    16  AND
	02EB    61  PUSH2 0x05be
	02EE    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @02E5  stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20]
	//     @02EA  stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01
	// }
	// Block ends with unconditional jump to 0x05be

label_02EF:
	// Incoming call from 0x00DB, returns to 0x00DC
	// Inputs[2]
	// {
	//     @02F3  storage[0x03]
	//     @02F7  memory[0x40:0x60]
	// }
	02EF    5B  JUMPDEST
	02F0    60  PUSH1 0x03
	02F2    80  DUP1
	02F3    54  SLOAD
	02F4    60  PUSH1 0x40
	02F6    80  DUP1
	02F7    51  MLOAD
	02F8    60  PUSH1 0x20
	02FA    60  PUSH1 0x1f
	02FC    60  PUSH1 0x02
	02FE    60  PUSH1 0x00
	0300    19  NOT
	0301    61  PUSH2 0x0100
	0304    60  PUSH1 0x01
	0306    88  DUP9
	0307    16  AND
	0308    15  ISZERO
	0309    02  MUL
	030A    01  ADD
	030B    90  SWAP1
	030C    95  SWAP6
	030D    16  AND
	030E    94  SWAP5
	030F    90  SWAP1
	0310    94  SWAP5
	0311    04  DIV
	0312    93  SWAP4
	0313    84  DUP5
	0314    01  ADD
	0315    81  DUP2
	0316    90  SWAP1
	0317    04  DIV
	0318    81  DUP2
	0319    02  MUL
	031A    82  DUP3
	031B    01  ADD
	031C    81  DUP2
	031D    01  ADD
	031E    90  SWAP1
	031F    92  SWAP3
	0320    52  MSTORE
	0321    82  DUP3
	0322    81  DUP2
	0323    52  MSTORE
	0324    60  PUSH1 0x60
	0326    93  SWAP4
	0327    90  SWAP1
	0328    92  SWAP3
	0329    90  SWAP1
	032A    91  SWAP2
	032B    83  DUP4
	032C    01  ADD
	032D    82  DUP3
	032E    82  DUP3
	032F    80  DUP1
	0330    15  ISZERO
	0331    61  PUSH2 0x037b
	0334    57  *JUMPI
	// Stack delta = +7
	// Outputs[9]
	// {
	//     @0320  memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20)
	//     @0323  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02
	//     @0326  stack[0] = 0x60
	//     @0328  stack[1] = memory[0x40:0x60]
	//     @0329  stack[3] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02
	//     @032A  stack[2] = 0x03
	//     @032C  stack[4] = memory[0x40:0x60] + 0x20
	//     @032D  stack[5] = 0x03
	//     @032E  stack[6] = (storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02
	// }
	// Block ends with conditional jump to 0x037b, if !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02)

label_0335:
	// Incoming jump from 0x0334, if not !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02)
	// Inputs[1] { @0335  stack[-1] }
	0335    80  DUP1
	0336    60  PUSH1 0x1f
	0338    10  LT
	0339    61  PUSH2 0x0350
	033C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0350, if 0x1f < stack[-1]

label_033D:
	// Incoming jump from 0x033C, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @0341  stack[-2]
	//     @0342  storage[stack[-2]]
	//     @0345  stack[-3]
	//     @0347  stack[-1]
	// }
	033D    61  PUSH2 0x0100
	0340    80  DUP1
	0341    83  DUP4
	0342    54  SLOAD
	0343    04  DIV
	0344    02  MUL
	0345    83  DUP4
	0346    52  MSTORE
	0347    91  SWAP2
	0348    60  PUSH1 0x20
	034A    01  ADD
	034B    91  SWAP2
	034C    61  PUSH2 0x037b
	034F    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0346  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @034B  stack[-1] = stack[-1]
	//     @034B  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x037b

label_0350:
	// Incoming jump from 0x033C, if 0x1f < stack[-1]
	// Incoming jump from 0x052E, if 0x1f < stack[-1]
	// Inputs[5]
	// {
	//     @0351  stack[-3]
	//     @0352  stack[-1]
	//     @0354  stack[-2]
	//     @035C  memory[0x00:0x20]
	//     @0360  storage[keccak256(memory[0x00:0x20])]
	// }
	0350    5B  JUMPDEST
	0351    82  DUP3
	0352    01  ADD
	0353    91  SWAP2
	0354    90  SWAP1
	0355    60  PUSH1 0x00
	0357    52  MSTORE
	0358    60  PUSH1 0x20
	035A    60  PUSH1 0x00
	035C    20  SHA3
	035D    90  SWAP1
	035E    5B  JUMPDEST
	035F    81  DUP2
	0360    54  SLOAD
	0361    81  DUP2
	0362    52  MSTORE
	0363    90  SWAP1
	0364    60  PUSH1 0x01
	0366    01  ADD
	0367    90  SWAP1
	0368    60  PUSH1 0x20
	036A    01  ADD
	036B    80  DUP1
	036C    83  DUP4
	036D    11  GT
	036E    61  PUSH2 0x035e
	0371    57  *JUMPI
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0353  stack[-3] = stack[-3] + stack[-1]
	//     @0357  memory[0x00:0x20] = stack[-2]
	//     @0362  memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])]
	//     @0367  stack[-2] = 0x01 + keccak256(memory[0x00:0x20])
	//     @036A  stack[-1] = 0x20 + stack[-3]
	// }
	// Block ends with conditional jump to 0x035e, if stack[-3] + stack[-1] > 0x20 + stack[-3]

label_0372:
	// Incoming jump from 0x0371, if not stack[-3] + stack[-1] > 0x20 + stack[-3]
	// Incoming jump from 0x0371, if not stack[-3] > 0x20 + stack[-1]
	// Inputs[2]
	// {
	//     @0372  stack[-3]
	//     @0373  stack[-1]
	// }
	0372    82  DUP3
	0373    90  SWAP1
	0374    03  SUB
	0375    60  PUSH1 0x1f
	0377    16  AND
	0378    82  DUP3
	0379    01  ADD
	037A    91  SWAP2
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @037A  stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3])
	//     @037A  stack[-1] = stack[-3]
	// }
	// Block continues

label_037B:
	// Incoming jump from 0x034F
	// Incoming jump from 0x0526, if !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02)
	// Incoming jump from 0x0334, if !((storage[0x03] & !(storage[0x03] & 0x01) * 0x0100 + ~0x00) / 0x02)
	// Incoming jump from 0x0541
	// Incoming jump from 0x037A
	// Inputs[3]
	// {
	//     @0381  stack[-7]
	//     @0381  stack[-6]
	//     @0383  stack[-8]
	// }
	037B    5B  JUMPDEST
	037C    50  POP
	037D    50  POP
	037E    50  POP
	037F    50  POP
	0380    50  POP
	0381    90  SWAP1
	0382    50  POP
	0383    90  SWAP1
	0384    56  *JUMP
	// Stack delta = -7
	// Outputs[1] { @0383  stack[-8] = stack[-6] }
	// Block ends with unconditional jump to stack[-8]

label_0385:
	// Incoming jump from 0x017C
	0385    5B  JUMPDEST
	0386    60  PUSH1 0x00
	0388    61  PUSH2 0x0399
	038B    61  PUSH2 0x0392
	038E    61  PUSH2 0x064a
	0391    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0386  stack[0] = 0x00
	//     @0388  stack[1] = 0x0399
	//     @038B  stack[2] = 0x0392
	// }
	// Block ends with call to 0x064a, returns to 0x0392

label_0392:
	// Incoming return from call to 0x064A at 0x0391
	// Inputs[2]
	// {
	//     @0393  stack[-5]
	//     @0394  stack[-4]
	// }
	0392    5B  JUMPDEST
	0393    84  DUP5
	0394    84  DUP5
	0395    61  PUSH2 0x064e
	0398    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0393  stack[0] = stack[-5]
	//     @0394  stack[1] = stack[-4]
	// }
	// Block ends with unconditional jump to 0x064e

label_0399:
	// Incoming return from call to 0x054F at 0x054E
	// Incoming return from call to 0x0392 at 0x0391
	// Incoming return from call to 0x05B7 at 0x05B6
	// Incoming return from call to 0x0445 at 0x0444
	// Inputs[2]
	// {
	//     @039D  stack[-4]
	//     @039E  stack[-3]
	// }
	0399    5B  JUMPDEST
	039A    50  POP
	039B    60  PUSH1 0x01
	039D    92  SWAP3
	039E    91  SWAP2
	039F    50  POP
	03A0    50  POP
	03A1    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @039D  stack[-4] = 0x01 }
	// Block ends with unconditional jump to stack[-4]

label_03A2:
	// Incoming call from 0x0198, returns to 0x0199
	// Inputs[2]
	// {
	//     @03A5  storage[0x02]
	//     @03A6  stack[-1]
	// }
	03A2    5B  JUMPDEST
	03A3    60  PUSH1 0x02
	03A5    54  SLOAD
	03A6    90  SWAP1
	03A7    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @03A6  stack[-1] = storage[0x02] }
	// Block ends with unconditional jump to stack[-1]

label_03A8:
	// Incoming jump from 0x01E0
	// Inputs[3]
	// {
	//     @03AE  stack[-3]
	//     @03AF  stack[-2]
	//     @03B0  stack[-1]
	// }
	03A8    5B  JUMPDEST
	03A9    60  PUSH1 0x00
	03AB    61  PUSH2 0x03b5
	03AE    84  DUP5
	03AF    84  DUP5
	03B0    84  DUP5
	03B1    61  PUSH2 0x073a
	03B4    56  *JUMP
	// Stack delta = +5
	// Outputs[5]
	// {
	//     @03A9  stack[0] = 0x00
	//     @03AB  stack[1] = 0x03b5
	//     @03AE  stack[2] = stack[-3]
	//     @03AF  stack[3] = stack[-2]
	//     @03B0  stack[4] = stack[-1]
	// }
	// Block ends with call to 0x073a, returns to 0x03B5

label_03B5:
	// Incoming return from call to 0x073A at 0x03B4
	// Inputs[1] { @03B9  stack[-4] }
	03B5    5B  JUMPDEST
	03B6    61  PUSH2 0x0425
	03B9    84  DUP5
	03BA    61  PUSH2 0x03c1
	03BD    61  PUSH2 0x064a
	03C0    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @03B6  stack[0] = 0x0425
	//     @03B9  stack[1] = stack[-4]
	//     @03BA  stack[2] = 0x03c1
	// }
	// Block ends with call to 0x064a, returns to 0x03C1

label_03C1:
	// Incoming return from call to 0x064A at 0x03C0
	// Inputs[4]
	// {
	//     @03C5  stack[-5]
	//     @03C8  memory[0x40:0x60]
	//     @03E7  stack[-7]
	//     @03F6  memory[0x00:0x40]
	// }
	03C1    5B  JUMPDEST
	03C2    61  PUSH2 0x0420
	03C5    85  DUP6
	03C6    60  PUSH1 0x40
	03C8    51  MLOAD
	03C9    80  DUP1
	03CA    60  PUSH1 0x60
	03CC    01  ADD
	03CD    60  PUSH1 0x40
	03CF    52  MSTORE
	03D0    80  DUP1
	03D1    60  PUSH1 0x28
	03D3    81  DUP2
	03D4    52  MSTORE
	03D5    60  PUSH1 0x20
	03D7    01  ADD
	03D8    61  PUSH2 0x099d
	03DB    60  PUSH1 0x28
	03DD    91  SWAP2
	03DE    39  CODECOPY
	03DF    60  PUSH1 0x01
	03E1    60  PUSH1 0x01
	03E3    60  PUSH1 0xa0
	03E5    1B  SHL
	03E6    03  SUB
	03E7    8A  DUP11
	03E8    16  AND
	03E9    60  PUSH1 0x00
	03EB    90  SWAP1
	03EC    81  DUP2
	03ED    52  MSTORE
	03EE    60  PUSH1 0x01
	03F0    60  PUSH1 0x20
	03F2    52  MSTORE
	03F3    60  PUSH1 0x40
	03F5    81  DUP2
	03F6    20  SHA3
	03F7    90  SWAP1
	03F8    61  PUSH2 0x03ff
	03FB    61  PUSH2 0x064a
	03FE    56  *JUMP
	// Stack delta = +6
	// Outputs[11]
	// {
	//     @03C2  stack[0] = 0x0420
	//     @03C5  stack[1] = stack[-5]
	//     @03C8  stack[2] = memory[0x40:0x60]
	//     @03CF  memory[0x40:0x60] = 0x60 + memory[0x40:0x60]
	//     @03D4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28
	//     @03DE  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x28] = code[0x099d:0x09c5]
	//     @03ED  memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01
	//     @03F2  memory[0x20:0x40] = 0x01
	//     @03F7  stack[3] = keccak256(memory[0x00:0x40])
	//     @03F7  stack[4] = 0x00
	//     @03F8  stack[5] = 0x03ff
	// }
	// Block ends with call to 0x064a, returns to 0x03FF

label_03FF:
	// Incoming return from call to 0x064A at 0x03FE
	// Inputs[7]
	// {
	//     @0408  stack[-1]
	//     @0409  stack[-2]
	//     @040F  stack[-3]
	//     @0418  memory[0x00:0x00 + 0x40 + stack[-2]]
	//     @0419  storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])]
	//     @041A  stack[-5]
	//     @041B  stack[-4]
	// }
	03FF    5B  JUMPDEST
	0400    60  PUSH1 0x01
	0402    60  PUSH1 0x01
	0404    60  PUSH1 0xa0
	0406    1B  SHL
	0407    03  SUB
	0408    16  AND
	0409    81  DUP2
	040A    52  MSTORE
	040B    60  PUSH1 0x20
	040D    81  DUP2
	040E    01  ADD
	040F    91  SWAP2
	0410    90  SWAP1
	0411    91  SWAP2
	0412    52  MSTORE
	0413    60  PUSH1 0x40
	0415    01  ADD
	0416    60  PUSH1 0x00
	0418    20  SHA3
	0419    54  SLOAD
	041A    91  SWAP2
	041B    90  SWAP1
	041C    61  PUSH2 0x0895
	041F    56  *JUMP
	// Stack delta = -2
	// Outputs[5]
	// {
	//     @040A  memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @0412  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3]
	//     @041A  stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])]
	//     @041B  stack[-4] = stack[-5]
	//     @041B  stack[-3] = stack[-4]
	// }
	// Block ends with unconditional jump to 0x0895

label_0420:
	// Incoming return from call to 0x0456 at 0x0455
	// Incoming return from call to 0x0579 at 0x0578
	// Incoming return from call to 0x03FF at 0x03FE
	0420    5B  JUMPDEST
	0421    61  PUSH2 0x064e
	0424    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x064e

	0425    5B    JUMPDEST
	0426    50    POP
	0427    60    PUSH1 0x01
	0429    93    SWAP4
	042A    92    SWAP3
	042B    50    POP
	042C    50    POP
	042D    50    POP
	042E    56    *JUMP
label_042F:
	// Incoming call from 0x01E8, returns to 0x01E9
	// Inputs[2]
	// {
	//     @0432  storage[0x05]
	//     @0436  stack[-1]
	// }
	042F    5B  JUMPDEST
	0430    60  PUSH1 0x05
	0432    54  SLOAD
	0433    60  PUSH1 0xff
	0435    16  AND
	0436    90  SWAP1
	0437    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @0436  stack[-1] = 0xff & storage[0x05] }
	// Block ends with unconditional jump to stack[-1]

label_0438:
	// Incoming jump from 0x022A
	0438    5B  JUMPDEST
	0439    60  PUSH1 0x00
	043B    61  PUSH2 0x0399
	043E    61  PUSH2 0x0445
	0441    61  PUSH2 0x064a
	0444    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0439  stack[0] = 0x00
	//     @043B  stack[1] = 0x0399
	//     @043E  stack[2] = 0x0445
	// }
	// Block ends with call to 0x064a, returns to 0x0445

label_0445:
	// Incoming return from call to 0x064A at 0x0444
	// Inputs[2]
	// {
	//     @0446  stack[-5]
	//     @044A  stack[-4]
	// }
	0445    5B  JUMPDEST
	0446    84  DUP5
	0447    61  PUSH2 0x0420
	044A    85  DUP6
	044B    60  PUSH1 0x01
	044D    60  PUSH1 0x00
	044F    61  PUSH2 0x0456
	0452    61  PUSH2 0x064a
	0455    56  *JUMP
	// Stack delta = +6
	// Outputs[6]
	// {
	//     @0446  stack[0] = stack[-5]
	//     @0447  stack[1] = 0x0420
	//     @044A  stack[2] = stack[-4]
	//     @044B  stack[3] = 0x01
	//     @044D  stack[4] = 0x00
	//     @044F  stack[5] = 0x0456
	// }
	// Block ends with call to 0x064a, returns to 0x0456

label_0456:
	// Incoming return from call to 0x064A at 0x0455
	// Inputs[8]
	// {
	//     @045F  stack[-1]
	//     @0462  stack[-2]
	//     @0469  stack[-3]
	//     @0476  memory[0x00:0x00 + 0x40 + stack[-2]]
	//     @0478  stack[-11]
	//     @047F  memory[0x00:0x40]
	//     @0480  storage[keccak256(memory[0x00:0x40])]
	//     @0481  stack[-4]
	// }
	0456    5B  JUMPDEST
	0457    60  PUSH1 0x01
	0459    60  PUSH1 0x01
	045B    60  PUSH1 0xa0
	045D    1B  SHL
	045E    03  SUB
	045F    90  SWAP1
	0460    81  DUP2
	0461    16  AND
	0462    82  DUP3
	0463    52  MSTORE
	0464    60  PUSH1 0x20
	0466    80  DUP1
	0467    83  DUP4
	0468    01  ADD
	0469    93  SWAP4
	046A    90  SWAP1
	046B    93  SWAP4
	046C    52  MSTORE
	046D    60  PUSH1 0x40
	046F    91  SWAP2
	0470    82  DUP3
	0471    01  ADD
	0472    60  PUSH1 0x00
	0474    90  SWAP1
	0475    81  DUP2
	0476    20  SHA3
	0477    91  SWAP2
	0478    8C  DUP13
	0479    16  AND
	047A    81  DUP2
	047B    52  MSTORE
	047C    92  SWAP3
	047D    52  MSTORE
	047E    90  SWAP1
	047F    20  SHA3
	0480    54  SLOAD
	0481    90  SWAP1
	0482    61  PUSH2 0x05e9
	0485    56  *JUMP
	// Stack delta = -2
	// Outputs[6]
	// {
	//     @0463  memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @046C  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3]
	//     @047B  memory[0x00:0x20] = stack[-11] & (0x01 << 0xa0) - 0x01
	//     @047D  memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])
	//     @0481  stack[-4] = storage[keccak256(memory[0x00:0x40])]
	//     @0481  stack[-3] = stack[-4]
	// }
	// Block ends with unconditional jump to 0x05e9

label_0486:
	// Incoming call from 0x0232, returns to 0x00DC
	// Inputs[2]
	// {
	//     @048A  memory[0x40:0x60]
	//     @04A4  stack[-1]
	// }
	0486    5B  JUMPDEST
	0487    60  PUSH1 0x40
	0489    80  DUP1
	048A    51  MLOAD
	048B    80  DUP1
	048C    82  DUP3
	048D    01  ADD
	048E    90  SWAP1
	048F    91  SWAP2
	0490    52  MSTORE
	0491    60  PUSH1 0x06
	0493    81  DUP2
	0494    52  MSTORE
	0495    65  PUSH6 0x076342e302e3
	049C    60  PUSH1 0xd4
	049E    1B  SHL
	049F    60  PUSH1 0x20
	04A1    82  DUP3
	04A2    01  ADD
	04A3    52  MSTORE
	04A4    90  SWAP1
	04A5    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @0490  memory[0x40:0x60] = 0x40 + memory[0x40:0x60]
	//     @0494  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x06
	//     @04A3  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x076342e302e3 << 0xd4
	//     @04A4  stack[-1] = memory[0x40:0x60]
	// }
	// Block ends with unconditional jump to stack[-1]

label_04A6:
	// Incoming jump from 0x0258
	// Inputs[4]
	// {
	//     @04AF  stack[-1]
	//     @04BD  memory[0x00:0x40]
	//     @04BE  storage[keccak256(memory[0x00:0x40])]
	//     @04BF  stack[-2]
	// }
	04A6    5B  JUMPDEST
	04A7    60  PUSH1 0x01
	04A9    60  PUSH1 0x01
	04AB    60  PUSH1 0xa0
	04AD    1B  SHL
	04AE    03  SUB
	04AF    16  AND
	04B0    60  PUSH1 0x00
	04B2    90  SWAP1
	04B3    81  DUP2
	04B4    52  MSTORE
	04B5    60  PUSH1 0x20
	04B7    81  DUP2
	04B8    90  SWAP1
	04B9    52  MSTORE
	04BA    60  PUSH1 0x40
	04BC    90  SWAP1
	04BD    20  SHA3
	04BE    54  SLOAD
	04BF    90  SWAP1
	04C0    56  *JUMP
	// Stack delta = -1
	// Outputs[3]
	// {
	//     @04B4  memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @04B9  memory[0x20:0x40] = 0x00
	//     @04BF  stack[-2] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-2]

label_04C1:
	// Incoming call from 0x0260, returns to 0x00DC
	// Inputs[2]
	// {
	//     @04C6  memory[0x40:0x60]
	//     @04DF  stack[-1]
	// }
	04C1    5B  JUMPDEST
	04C2    60  PUSH1 0x60
	04C4    60  PUSH1 0x40
	04C6    51  MLOAD
	04C7    80  DUP1
	04C8    60  PUSH1 0x60
	04CA    01  ADD
	04CB    60  PUSH1 0x40
	04CD    52  MSTORE
	04CE    80  DUP1
	04CF    60  PUSH1 0x2f
	04D1    81  DUP2
	04D2    52  MSTORE
	04D3    60  PUSH1 0x20
	04D5    01  ADD
	04D6    61  PUSH2 0x0a0e
	04D9    60  PUSH1 0x2f
	04DB    91  SWAP2
	04DC    39  CODECOPY
	04DD    90  SWAP1
	04DE    50  POP
	04DF    90  SWAP1
	04E0    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @04CD  memory[0x40:0x60] = 0x60 + memory[0x40:0x60]
	//     @04D2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2f
	//     @04DC  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x2f] = code[0x0a0e:0x0a3d]
	//     @04DF  stack[-1] = memory[0x40:0x60]
	// }
	// Block ends with unconditional jump to stack[-1]

label_04E1:
	// Incoming call from 0x0268, returns to 0x00DC
	// Inputs[2]
	// {
	//     @04E5  storage[0x04]
	//     @04E9  memory[0x40:0x60]
	// }
	04E1    5B  JUMPDEST
	04E2    60  PUSH1 0x04
	04E4    80  DUP1
	04E5    54  SLOAD
	04E6    60  PUSH1 0x40
	04E8    80  DUP1
	04E9    51  MLOAD
	04EA    60  PUSH1 0x20
	04EC    60  PUSH1 0x1f
	04EE    60  PUSH1 0x02
	04F0    60  PUSH1 0x00
	04F2    19  NOT
	04F3    61  PUSH2 0x0100
	04F6    60  PUSH1 0x01
	04F8    88  DUP9
	04F9    16  AND
	04FA    15  ISZERO
	04FB    02  MUL
	04FC    01  ADD
	04FD    90  SWAP1
	04FE    95  SWAP6
	04FF    16  AND
	0500    94  SWAP5
	0501    90  SWAP1
	0502    94  SWAP5
	0503    04  DIV
	0504    93  SWAP4
	0505    84  DUP5
	0506    01  ADD
	0507    81  DUP2
	0508    90  SWAP1
	0509    04  DIV
	050A    81  DUP2
	050B    02  MUL
	050C    82  DUP3
	050D    01  ADD
	050E    81  DUP2
	050F    01  ADD
	0510    90  SWAP1
	0511    92  SWAP3
	0512    52  MSTORE
	0513    82  DUP3
	0514    81  DUP2
	0515    52  MSTORE
	0516    60  PUSH1 0x60
	0518    93  SWAP4
	0519    90  SWAP1
	051A    92  SWAP3
	051B    90  SWAP1
	051C    91  SWAP2
	051D    83  DUP4
	051E    01  ADD
	051F    82  DUP3
	0520    82  DUP3
	0521    80  DUP1
	0522    15  ISZERO
	0523    61  PUSH2 0x037b
	0526    57  *JUMPI
	// Stack delta = +7
	// Outputs[9]
	// {
	//     @0512  memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20)
	//     @0515  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02
	//     @0518  stack[0] = 0x60
	//     @051A  stack[1] = memory[0x40:0x60]
	//     @051B  stack[3] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02
	//     @051C  stack[2] = 0x04
	//     @051E  stack[4] = memory[0x40:0x60] + 0x20
	//     @051F  stack[5] = 0x04
	//     @0520  stack[6] = (storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02
	// }
	// Block ends with conditional jump to 0x037b, if !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02)

label_0527:
	// Incoming jump from 0x0526, if not !((storage[0x04] & !(storage[0x04] & 0x01) * 0x0100 + ~0x00) / 0x02)
	// Inputs[1] { @0527  stack[-1] }
	0527    80  DUP1
	0528    60  PUSH1 0x1f
	052A    10  LT
	052B    61  PUSH2 0x0350
	052E    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0350, if 0x1f < stack[-1]

label_052F:
	// Incoming jump from 0x052E, if not 0x1f < stack[-1]
	// Inputs[4]
	// {
	//     @0533  stack[-2]
	//     @0534  storage[stack[-2]]
	//     @0537  stack[-3]
	//     @0539  stack[-1]
	// }
	052F    61  PUSH2 0x0100
	0532    80  DUP1
	0533    83  DUP4
	0534    54  SLOAD
	0535    04  DIV
	0536    02  MUL
	0537    83  DUP4
	0538    52  MSTORE
	0539    91  SWAP2
	053A    60  PUSH1 0x20
	053C    01  ADD
	053D    91  SWAP2
	053E    61  PUSH2 0x037b
	0541    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0538  memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100
	//     @053D  stack[-1] = stack[-1]
	//     @053D  stack[-3] = 0x20 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x037b

label_0542:
	// Incoming jump from 0x0294
	0542    5B  JUMPDEST
	0543    60  PUSH1 0x00
	0545    61  PUSH2 0x0399
	0548    61  PUSH2 0x054f
	054B    61  PUSH2 0x064a
	054E    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0543  stack[0] = 0x00
	//     @0545  stack[1] = 0x0399
	//     @0548  stack[2] = 0x054f
	// }
	// Block ends with call to 0x064a, returns to 0x054F

label_054F:
	// Incoming return from call to 0x064A at 0x054E
	// Inputs[3]
	// {
	//     @0550  stack[-5]
	//     @0554  stack[-4]
	//     @0557  memory[0x40:0x60]
	// }
	054F    5B  JUMPDEST
	0550    84  DUP5
	0551    61  PUSH2 0x0420
	0554    85  DUP6
	0555    60  PUSH1 0x40
	0557    51  MLOAD
	0558    80  DUP1
	0559    60  PUSH1 0x60
	055B    01  ADD
	055C    60  PUSH1 0x40
	055E    52  MSTORE
	055F    80  DUP1
	0560    60  PUSH1 0x25
	0562    81  DUP2
	0563    52  MSTORE
	0564    60  PUSH1 0x20
	0566    01  ADD
	0567    61  PUSH2 0x0a3d
	056A    60  PUSH1 0x25
	056C    91  SWAP2
	056D    39  CODECOPY
	056E    60  PUSH1 0x01
	0570    60  PUSH1 0x00
	0572    61  PUSH2 0x0579
	0575    61  PUSH2 0x064a
	0578    56  *JUMP
	// Stack delta = +7
	// Outputs[10]
	// {
	//     @0550  stack[0] = stack[-5]
	//     @0551  stack[1] = 0x0420
	//     @0554  stack[2] = stack[-4]
	//     @0557  stack[3] = memory[0x40:0x60]
	//     @055E  memory[0x40:0x60] = 0x60 + memory[0x40:0x60]
	//     @0563  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x25
	//     @056D  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x25] = code[0x0a3d:0x0a62]
	//     @056E  stack[4] = 0x01
	//     @0570  stack[5] = 0x00
	//     @0572  stack[6] = 0x0579
	// }
	// Block ends with call to 0x064a, returns to 0x0579

label_0579:
	// Incoming return from call to 0x064A at 0x0578
	// Inputs[9]
	// {
	//     @0582  stack[-1]
	//     @0585  stack[-2]
	//     @058C  stack[-3]
	//     @0599  memory[0x00:0x00 + 0x40 + stack[-2]]
	//     @059B  stack[-12]
	//     @05A2  memory[0x00:0x40]
	//     @05A3  storage[keccak256(memory[0x00:0x40])]
	//     @05A4  stack[-5]
	//     @05A5  stack[-4]
	// }
	0579    5B  JUMPDEST
	057A    60  PUSH1 0x01
	057C    60  PUSH1 0x01
	057E    60  PUSH1 0xa0
	0580    1B  SHL
	0581    03  SUB
	0582    90  SWAP1
	0583    81  DUP2
	0584    16  AND
	0585    82  DUP3
	0586    52  MSTORE
	0587    60  PUSH1 0x20
	0589    80  DUP1
	058A    83  DUP4
	058B    01  ADD
	058C    93  SWAP4
	058D    90  SWAP1
	058E    93  SWAP4
	058F    52  MSTORE
	0590    60  PUSH1 0x40
	0592    91  SWAP2
	0593    82  DUP3
	0594    01  ADD
	0595    60  PUSH1 0x00
	0597    90  SWAP1
	0598    81  DUP2
	0599    20  SHA3
	059A    91  SWAP2
	059B    8D  DUP14
	059C    16  AND
	059D    81  DUP2
	059E    52  MSTORE
	059F    92  SWAP3
	05A0    52  MSTORE
	05A1    90  SWAP1
	05A2    20  SHA3
	05A3    54  SLOAD
	05A4    91  SWAP2
	05A5    90  SWAP1
	05A6    61  PUSH2 0x0895
	05A9    56  *JUMP
	// Stack delta = -2
	// Outputs[7]
	// {
	//     @0586  memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @058F  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3]
	//     @059E  memory[0x00:0x20] = stack[-12] & (0x01 << 0xa0) - 0x01
	//     @05A0  memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])
	//     @05A4  stack[-5] = storage[keccak256(memory[0x00:0x40])]
	//     @05A5  stack[-4] = stack[-5]
	//     @05A5  stack[-3] = stack[-4]
	// }
	// Block ends with unconditional jump to 0x0895

label_05AA:
	// Incoming jump from 0x02C0
	05AA    5B  JUMPDEST
	05AB    60  PUSH1 0x00
	05AD    61  PUSH2 0x0399
	05B0    61  PUSH2 0x05b7
	05B3    61  PUSH2 0x064a
	05B6    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @05AB  stack[0] = 0x00
	//     @05AD  stack[1] = 0x0399
	//     @05B0  stack[2] = 0x05b7
	// }
	// Block ends with call to 0x064a, returns to 0x05B7

label_05B7:
	// Incoming return from call to 0x064A at 0x05B6
	// Inputs[2]
	// {
	//     @05B8  stack[-5]
	//     @05B9  stack[-4]
	// }
	05B7    5B  JUMPDEST
	05B8    84  DUP5
	05B9    84  DUP5
	05BA    61  PUSH2 0x073a
	05BD    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05B8  stack[0] = stack[-5]
	//     @05B9  stack[1] = stack[-4]
	// }
	// Block ends with unconditional jump to 0x073a

label_05BE:
	// Incoming jump from 0x02EE
	// Inputs[6]
	// {
	//     @05C7  stack[-2]
	//     @05DA  memory[0x00:0x40]
	//     @05DB  stack[-1]
	//     @05E5  memory[0x00:0x40]
	//     @05E6  storage[keccak256(memory[0x00:0x40])]
	//     @05E7  stack[-3]
	// }
	05BE    5B  JUMPDEST
	05BF    60  PUSH1 0x01
	05C1    60  PUSH1 0x01
	05C3    60  PUSH1 0xa0
	05C5    1B  SHL
	05C6    03  SUB
	05C7    91  SWAP2
	05C8    82  DUP3
	05C9    16  AND
	05CA    60  PUSH1 0x00
	05CC    90  SWAP1
	05CD    81  DUP2
	05CE    52  MSTORE
	05CF    60  PUSH1 0x01
	05D1    60  PUSH1 0x20
	05D3    90  SWAP1
	05D4    81  DUP2
	05D5    52  MSTORE
	05D6    60  PUSH1 0x40
	05D8    80  DUP1
	05D9    83  DUP4
	05DA    20  SHA3
	05DB    93  SWAP4
	05DC    90  SWAP1
	05DD    94  SWAP5
	05DE    16  AND
	05DF    82  DUP3
	05E0    52  MSTORE
	05E1    91  SWAP2
	05E2    90  SWAP1
	05E3    91  SWAP2
	05E4    52  MSTORE
	05E5    20  SHA3
	05E6    54  SLOAD
	05E7    90  SWAP1
	05E8    56  *JUMP
	// Stack delta = -2
	// Outputs[5]
	// {
	//     @05CE  memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2]
	//     @05D5  memory[0x20:0x40] = 0x01
	//     @05E0  memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @05E4  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @05E7  stack[-3] = storage[keccak256(memory[0x00:0x40])]
	// }
	// Block ends with unconditional jump to stack[-3]

label_05E9:
	// Incoming call from 0x083A, returns to 0x083B
	// Incoming jump from 0x0485
	// Inputs[2]
	// {
	//     @05EC  stack[-2]
	//     @05ED  stack[-1]
	// }
	05E9    5B  JUMPDEST
	05EA    60  PUSH1 0x00
	05EC    82  DUP3
	05ED    82  DUP3
	05EE    01  ADD
	05EF    83  DUP4
	05F0    81  DUP2
	05F1    10  LT
	05F2    15  ISZERO
	05F3    61  PUSH2 0x0643
	05F6    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05EA  stack[0] = 0x00
	//     @05EE  stack[1] = stack[-1] + stack[-2]
	// }
	// Block ends with conditional jump to 0x0643, if !(stack[-1] + stack[-2] < stack[-2])

label_05F7:
	// Incoming jump from 0x05F6, if not !(stack[-1] + stack[-2] < stack[-2])
	// Inputs[3]
	// {
	//     @05FA  memory[0x40:0x60]
	//     @0639  memory[0x40:0x60]
	//     @0642  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]
	// }
	05F7    60  PUSH1 0x40
	05F9    80  DUP1
	05FA    51  MLOAD
	05FB    62  PUSH3 0x461bcd
	05FF    60  PUSH1 0xe5
	0601    1B  SHL
	0602    81  DUP2
	0603    52  MSTORE
	0604    60  PUSH1 0x20
	0606    60  PUSH1 0x04
	0608    82  DUP3
	0609    01  ADD
	060A    52  MSTORE
	060B    60  PUSH1 0x1b
	060D    60  PUSH1 0x24
	060F    82  DUP3
	0610    01  ADD
	0611    52  MSTORE
	0612    7F  PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000
	0633    60  PUSH1 0x44
	0635    82  DUP3
	0636    01  ADD
	0637    52  MSTORE
	0638    90  SWAP1
	0639    51  MLOAD
	063A    90  SWAP1
	063B    81  DUP2
	063C    90  SWAP1
	063D    03  SUB
	063E    60  PUSH1 0x64
	0640    01  ADD
	0641    90  SWAP1
	0642    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0603  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @060A  memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20
	//     @0611  memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b
	//     @0637  memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000
	//     @0642  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]);
	// }
	// Block terminates

label_0643:
	// Incoming jump from 0x05F6, if !(stack[-1] + stack[-2] < stack[-2])
	// Inputs[3]
	// {
	//     @0644  stack[-1]
	//     @0644  stack[-5]
	//     @0645  stack[-4]
	// }
	0643    5B  JUMPDEST
	0644    93  SWAP4
	0645    92  SWAP3
	0646    50  POP
	0647    50  POP
	0648    50  POP
	0649    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @0644  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_064A:
	// Incoming call from 0x054E, returns to 0x054F
	// Incoming call from 0x03FE, returns to 0x03FF
	// Incoming call from 0x05B6, returns to 0x05B7
	// Incoming call from 0x0578, returns to 0x0579
	// Incoming call from 0x0444, returns to 0x0445
	// Incoming call from 0x03C0, returns to 0x03C1
	// Incoming call from 0x0455, returns to 0x0456
	// Incoming call from 0x0391, returns to 0x0392
	// Inputs[2]
	// {
	//     @064B  msg.sender
	//     @064C  stack[-1]
	// }
	064A    5B  JUMPDEST
	064B    33  CALLER
	064C    90  SWAP1
	064D    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @064C  stack[-1] = msg.sender }
	// Block ends with unconditional jump to stack[-1]

label_064E:
	// Incoming jump from 0x0424
	// Incoming jump from 0x0398
	// Inputs[1] { @0657  stack[-3] }
	064E    5B  JUMPDEST
	064F    60  PUSH1 0x01
	0651    60  PUSH1 0x01
	0653    60  PUSH1 0xa0
	0655    1B  SHL
	0656    03  SUB
	0657    83  DUP4
	0658    16  AND
	0659    61  PUSH2 0x0693
	065C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0693, if stack[-3] & (0x01 << 0xa0) - 0x01

label_065D:
	// Incoming jump from 0x065C, if not stack[-3] & (0x01 << 0xa0) - 0x01
	// Inputs[3]
	// {
	//     @065F  memory[0x40:0x60]
	//     @068D  memory[0x40:0x60]
	//     @0692  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	065D    60  PUSH1 0x40
	065F    51  MLOAD
	0660    62  PUSH3 0x461bcd
	0664    60  PUSH1 0xe5
	0666    1B  SHL
	0667    81  DUP2
	0668    52  MSTORE
	0669    60  PUSH1 0x04
	066B    01  ADD
	066C    80  DUP1
	066D    80  DUP1
	066E    60  PUSH1 0x20
	0670    01  ADD
	0671    82  DUP3
	0672    81  DUP2
	0673    03  SUB
	0674    82  DUP3
	0675    52  MSTORE
	0676    60  PUSH1 0x24
	0678    81  DUP2
	0679    52  MSTORE
	067A    60  PUSH1 0x20
	067C    01  ADD
	067D    80  DUP1
	067E    61  PUSH2 0x09ea
	0681    60  PUSH1 0x24
	0683    91  SWAP2
	0684    39  CODECOPY
	0685    60  PUSH1 0x40
	0687    01  ADD
	0688    91  SWAP2
	0689    50  POP
	068A    50  POP
	068B    60  PUSH1 0x40
	068D    51  MLOAD
	068E    80  DUP1
	068F    91  SWAP2
	0690    03  SUB
	0691    90  SWAP1
	0692    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0668  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @0675  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0679  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24
	//     @0684  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x09ea:0x0a0e]
	//     @0692  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0693:
	// Incoming jump from 0x065C, if stack[-3] & (0x01 << 0xa0) - 0x01
	// Inputs[1] { @069C  stack[-2] }
	0693    5B  JUMPDEST
	0694    60  PUSH1 0x01
	0696    60  PUSH1 0x01
	0698    60  PUSH1 0xa0
	069A    1B  SHL
	069B    03  SUB
	069C    82  DUP3
	069D    16  AND
	069E    61  PUSH2 0x06d8
	06A1    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x06d8, if stack[-2] & (0x01 << 0xa0) - 0x01

label_06A2:
	// Incoming jump from 0x06A1, if not stack[-2] & (0x01 << 0xa0) - 0x01
	// Inputs[3]
	// {
	//     @06A4  memory[0x40:0x60]
	//     @06D2  memory[0x40:0x60]
	//     @06D7  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	06A2    60  PUSH1 0x40
	06A4    51  MLOAD
	06A5    62  PUSH3 0x461bcd
	06A9    60  PUSH1 0xe5
	06AB    1B  SHL
	06AC    81  DUP2
	06AD    52  MSTORE
	06AE    60  PUSH1 0x04
	06B0    01  ADD
	06B1    80  DUP1
	06B2    80  DUP1
	06B3    60  PUSH1 0x20
	06B5    01  ADD
	06B6    82  DUP3
	06B7    81  DUP2
	06B8    03  SUB
	06B9    82  DUP3
	06BA    52  MSTORE
	06BB    60  PUSH1 0x22
	06BD    81  DUP2
	06BE    52  MSTORE
	06BF    60  PUSH1 0x20
	06C1    01  ADD
	06C2    80  DUP1
	06C3    61  PUSH2 0x0955
	06C6    60  PUSH1 0x22
	06C8    91  SWAP2
	06C9    39  CODECOPY
	06CA    60  PUSH1 0x40
	06CC    01  ADD
	06CD    91  SWAP2
	06CE    50  POP
	06CF    50  POP
	06D0    60  PUSH1 0x40
	06D2    51  MLOAD
	06D3    80  DUP1
	06D4    91  SWAP2
	06D5    03  SUB
	06D6    90  SWAP1
	06D7    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @06AD  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @06BA  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @06BE  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22
	//     @06C9  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x0955:0x0977]
	//     @06D7  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_06D8:
	// Incoming jump from 0x06A1, if stack[-2] & (0x01 << 0xa0) - 0x01
	// Inputs[9]
	// {
	//     @06E2  stack[-3]
	//     @06F4  memory[0x00:0x40]
	//     @06F6  stack[-2]
	//     @0701  memory[0x00:0x40]
	//     @0702  stack[-1]
	//     @0706  memory[0x40:0x60]
	//     @070B  memory[0x40:0x60]
	//     @0735  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]
	//     @0739  stack[-4]
	// }
	06D8    5B  JUMPDEST
	06D9    60  PUSH1 0x01
	06DB    60  PUSH1 0x01
	06DD    60  PUSH1 0xa0
	06DF    1B  SHL
	06E0    03  SUB
	06E1    80  DUP1
	06E2    84  DUP5
	06E3    16  AND
	06E4    60  PUSH1 0x00
	06E6    81  DUP2
	06E7    81  DUP2
	06E8    52  MSTORE
	06E9    60  PUSH1 0x01
	06EB    60  PUSH1 0x20
	06ED    90  SWAP1
	06EE    81  DUP2
	06EF    52  MSTORE
	06F0    60  PUSH1 0x40
	06F2    80  DUP1
	06F3    83  DUP4
	06F4    20  SHA3
	06F5    94  SWAP5
	06F6    87  DUP8
	06F7    16  AND
	06F8    80  DUP1
	06F9    84  DUP5
	06FA    52  MSTORE
	06FB    94  SWAP5
	06FC    82  DUP3
	06FD    52  MSTORE
	06FE    91  SWAP2
	06FF    82  DUP3
	0700    90  SWAP1
	0701    20  SHA3
	0702    85  DUP6
	0703    90  SWAP1
	0704    55  SSTORE
	0705    81  DUP2
	0706    51  MLOAD
	0707    85  DUP6
	0708    81  DUP2
	0709    52  MSTORE
	070A    91  SWAP2
	070B    51  MLOAD
	070C    7F  PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925
	072D    92  SWAP3
	072E    81  DUP2
	072F    90  SWAP1
	0730    03  SUB
	0731    90  SWAP1
	0732    91  SWAP2
	0733    01  ADD
	0734    90  SWAP1
	0735    A3  LOG3
	0736    50  POP
	0737    50  POP
	0738    50  POP
	0739    56  *JUMP
	// Stack delta = -4
	// Outputs[7]
	// {
	//     @06E8  memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01
	//     @06EF  memory[0x20:0x40] = 0x01
	//     @06FA  memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01
	//     @06FD  memory[0x20:0x40] = keccak256(memory[0x00:0x40])
	//     @0704  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @0709  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0735  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]);
	// }
	// Block ends with unconditional jump to stack[-4]

label_073A:
	// Incoming jump from 0x05BD
	// Incoming call from 0x03B4, returns to 0x03B5
	// Inputs[1] { @0743  stack[-3] }
	073A    5B  JUMPDEST
	073B    60  PUSH1 0x01
	073D    60  PUSH1 0x01
	073F    60  PUSH1 0xa0
	0741    1B  SHL
	0742    03  SUB
	0743    83  DUP4
	0744    16  AND
	0745    61  PUSH2 0x077f
	0748    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x077f, if stack[-3] & (0x01 << 0xa0) - 0x01

label_0749:
	// Incoming jump from 0x0748, if not stack[-3] & (0x01 << 0xa0) - 0x01
	// Inputs[3]
	// {
	//     @074B  memory[0x40:0x60]
	//     @0779  memory[0x40:0x60]
	//     @077E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0749    60  PUSH1 0x40
	074B    51  MLOAD
	074C    62  PUSH3 0x461bcd
	0750    60  PUSH1 0xe5
	0752    1B  SHL
	0753    81  DUP2
	0754    52  MSTORE
	0755    60  PUSH1 0x04
	0757    01  ADD
	0758    80  DUP1
	0759    80  DUP1
	075A    60  PUSH1 0x20
	075C    01  ADD
	075D    82  DUP3
	075E    81  DUP2
	075F    03  SUB
	0760    82  DUP3
	0761    52  MSTORE
	0762    60  PUSH1 0x25
	0764    81  DUP2
	0765    52  MSTORE
	0766    60  PUSH1 0x20
	0768    01  ADD
	0769    80  DUP1
	076A    61  PUSH2 0x09c5
	076D    60  PUSH1 0x25
	076F    91  SWAP2
	0770    39  CODECOPY
	0771    60  PUSH1 0x40
	0773    01  ADD
	0774    91  SWAP2
	0775    50  POP
	0776    50  POP
	0777    60  PUSH1 0x40
	0779    51  MLOAD
	077A    80  DUP1
	077B    91  SWAP2
	077C    03  SUB
	077D    90  SWAP1
	077E    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0754  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @0761  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0765  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25
	//     @0770  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x09c5:0x09ea]
	//     @077E  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_077F:
	// Incoming jump from 0x0748, if stack[-3] & (0x01 << 0xa0) - 0x01
	// Inputs[1] { @0788  stack[-2] }
	077F    5B  JUMPDEST
	0780    60  PUSH1 0x01
	0782    60  PUSH1 0x01
	0784    60  PUSH1 0xa0
	0786    1B  SHL
	0787    03  SUB
	0788    82  DUP3
	0789    16  AND
	078A    61  PUSH2 0x07c4
	078D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x07c4, if stack[-2] & (0x01 << 0xa0) - 0x01

label_078E:
	// Incoming jump from 0x078D, if not stack[-2] & (0x01 << 0xa0) - 0x01
	// Inputs[3]
	// {
	//     @0790  memory[0x40:0x60]
	//     @07BE  memory[0x40:0x60]
	//     @07C3  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	078E    60  PUSH1 0x40
	0790    51  MLOAD
	0791    62  PUSH3 0x461bcd
	0795    60  PUSH1 0xe5
	0797    1B  SHL
	0798    81  DUP2
	0799    52  MSTORE
	079A    60  PUSH1 0x04
	079C    01  ADD
	079D    80  DUP1
	079E    80  DUP1
	079F    60  PUSH1 0x20
	07A1    01  ADD
	07A2    82  DUP3
	07A3    81  DUP2
	07A4    03  SUB
	07A5    82  DUP3
	07A6    52  MSTORE
	07A7    60  PUSH1 0x23
	07A9    81  DUP2
	07AA    52  MSTORE
	07AB    60  PUSH1 0x20
	07AD    01  ADD
	07AE    80  DUP1
	07AF    61  PUSH2 0x0932
	07B2    60  PUSH1 0x23
	07B4    91  SWAP2
	07B5    39  CODECOPY
	07B6    60  PUSH1 0x40
	07B8    01  ADD
	07B9    91  SWAP2
	07BA    50  POP
	07BB    50  POP
	07BC    60  PUSH1 0x40
	07BE    51  MLOAD
	07BF    80  DUP1
	07C0    91  SWAP2
	07C1    03  SUB
	07C2    90  SWAP1
	07C3    FD  *REVERT
	// Stack delta = +0
	// Outputs[5]
	// {
	//     @0799  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @07A6  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @07AA  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23
	//     @07B5  memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x0932:0x0955]
	//     @07C3  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_07C4:
	// Incoming jump from 0x078D, if stack[-2] & (0x01 << 0xa0) - 0x01
	// Inputs[3]
	// {
	//     @07C8  stack[-3]
	//     @07C9  stack[-2]
	//     @07CA  stack[-1]
	// }
	07C4    5B  JUMPDEST
	07C5    61  PUSH2 0x07cf
	07C8    83  DUP4
	07C9    83  DUP4
	07CA    83  DUP4
	07CB    61  PUSH2 0x092c
	07CE    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @07C5  stack[0] = 0x07cf
	//     @07C8  stack[1] = stack[-3]
	//     @07C9  stack[2] = stack[-2]
	//     @07CA  stack[3] = stack[-1]
	// }
	// Block ends with call to 0x092c, returns to 0x07CF

label_07CF:
	// Incoming return from call to 0x092C at 0x07CE
	// Inputs[5]
	// {
	//     @07D3  stack[-1]
	//     @07D6  memory[0x40:0x60]
	//     @07F5  stack[-3]
	//     @0804  memory[0x00:0x40]
	//     @0805  storage[keccak256(memory[0x00:0x40])]
	// }
	07CF    5B  JUMPDEST
	07D0    61  PUSH2 0x080c
	07D3    81  DUP2
	07D4    60  PUSH1 0x40
	07D6    51  MLOAD
	07D7    80  DUP1
	07D8    60  PUSH1 0x60
	07DA    01  ADD
	07DB    60  PUSH1 0x40
	07DD    52  MSTORE
	07DE    80  DUP1
	07DF    60  PUSH1 0x26
	07E1    81  DUP2
	07E2    52  MSTORE
	07E3    60  PUSH1 0x20
	07E5    01  ADD
	07E6    61  PUSH2 0x0977
	07E9    60  PUSH1 0x26
	07EB    91  SWAP2
	07EC    39  CODECOPY
	07ED    60  PUSH1 0x01
	07EF    60  PUSH1 0x01
	07F1    60  PUSH1 0xa0
	07F3    1B  SHL
	07F4    03  SUB
	07F5    86  DUP7
	07F6    16  AND
	07F7    60  PUSH1 0x00
	07F9    90  SWAP1
	07FA    81  DUP2
	07FB    52  MSTORE
	07FC    60  PUSH1 0x20
	07FE    81  DUP2
	07FF    90  SWAP1
	0800    52  MSTORE
	0801    60  PUSH1 0x40
	0803    90  SWAP1
	0804    20  SHA3
	0805    54  SLOAD
	0806    91  SWAP2
	0807    90  SWAP1
	0808    61  PUSH2 0x0895
	080B    56  *JUMP
	// Stack delta = +4
	// Outputs[9]
	// {
	//     @07D0  stack[0] = 0x080c
	//     @07DD  memory[0x40:0x60] = 0x60 + memory[0x40:0x60]
	//     @07E2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26
	//     @07EC  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x0977:0x099d]
	//     @07FB  memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01
	//     @0800  memory[0x20:0x40] = 0x00
	//     @0806  stack[1] = storage[keccak256(memory[0x00:0x40])]
	//     @0807  stack[2] = stack[-1]
	//     @0807  stack[3] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x0895, returns to 0x080C

label_080C:
	// Incoming return from call to 0x0895 at 0x080B
	// Inputs[7]
	// {
	//     @0816  stack[-4]
	//     @0826  memory[0x00:0x40]
	//     @0827  stack[-1]
	//     @082C  stack[-3]
	//     @0830  memory[0x00:0x40]
	//     @0831  storage[keccak256(memory[0x00:0x40])]
	//     @0836  stack[-2]
	// }
	080C    5B  JUMPDEST
	080D    60  PUSH1 0x01
	080F    60  PUSH1 0x01
	0811    60  PUSH1 0xa0
	0813    1B  SHL
	0814    03  SUB
	0815    80  DUP1
	0816    85  DUP6
	0817    16  AND
	0818    60  PUSH1 0x00
	081A    90  SWAP1
	081B    81  DUP2
	081C    52  MSTORE
	081D    60  PUSH1 0x20
	081F    81  DUP2
	0820    90  SWAP1
	0821    52  MSTORE
	0822    60  PUSH1 0x40
	0824    80  DUP1
	0825    82  DUP3
	0826    20  SHA3
	0827    93  SWAP4
	0828    90  SWAP1
	0829    93  SWAP4
	082A    55  SSTORE
	082B    90  SWAP1
	082C    84  DUP5
	082D    16  AND
	082E    81  DUP2
	082F    52  MSTORE
	0830    20  SHA3
	0831    54  SLOAD
	0832    61  PUSH2 0x083b
	0835    90  SWAP1
	0836    82  DUP3
	0837    61  PUSH2 0x05e9
	083A    56  *JUMP
	// Stack delta = +2
	// Outputs[7]
	// {
	//     @081C  memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01
	//     @0821  memory[0x20:0x40] = 0x00
	//     @082A  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @082F  memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01
	//     @0835  stack[0] = storage[keccak256(memory[0x00:0x40])]
	//     @0835  stack[-1] = 0x083b
	//     @0836  stack[1] = stack[-2]
	// }
	// Block ends with call to 0x05e9, returns to 0x083B

label_083B:
	// Incoming return from call to 0x05E9 at 0x083A
	// Inputs[9]
	// {
	//     @0845  stack[-3]
	//     @0856  memory[0x00:0x40]
	//     @0857  stack[-1]
	//     @085C  memory[0x40:0x60]
	//     @085D  stack[-2]
	//     @0861  memory[0x40:0x60]
	//     @0865  stack[-4]
	//     @0890  memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20]
	//     @0894  stack[-5]
	// }
	083B    5B  JUMPDEST
	083C    60  PUSH1 0x01
	083E    60  PUSH1 0x01
	0840    60  PUSH1 0xa0
	0842    1B  SHL
	0843    03  SUB
	0844    80  DUP1
	0845    84  DUP5
	0846    16  AND
	0847    60  PUSH1 0x00
	0849    81  DUP2
	084A    81  DUP2
	084B    52  MSTORE
	084C    60  PUSH1 0x20
	084E    81  DUP2
	084F    81  DUP2
	0850    52  MSTORE
	0851    60  PUSH1 0x40
	0853    91  SWAP2
	0854    82  DUP3
	0855    90  SWAP1
	0856    20  SHA3
	0857    94  SWAP5
	0858    90  SWAP1
	0859    94  SWAP5
	085A    55  SSTORE
	085B    80  DUP1
	085C    51  MLOAD
	085D    85  DUP6
	085E    81  DUP2
	085F    52  MSTORE
	0860    90  SWAP1
	0861    51  MLOAD
	0862    91  SWAP2
	0863    93  SWAP4
	0864    92  SWAP3
	0865    87  DUP8
	0866    16  AND
	0867    92  SWAP3
	0868    7F  PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
	0889    92  SWAP3
	088A    91  SWAP2
	088B    82  DUP3
	088C    90  SWAP1
	088D    03  SUB
	088E    01  ADD
	088F    90  SWAP1
	0890    A3  LOG3
	0891    50  POP
	0892    50  POP
	0893    50  POP
	0894    56  *JUMP
	// Stack delta = -5
	// Outputs[5]
	// {
	//     @084B  memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01
	//     @0850  memory[0x20:0x40] = 0x00
	//     @085A  storage[keccak256(memory[0x00:0x40])] = stack[-1]
	//     @085F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @0890  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01]);
	// }
	// Block ends with unconditional jump to stack[-5]

label_0895:
	// Incoming jump from 0x05A9
	// Incoming call from 0x080B, returns to 0x080C
	// Incoming jump from 0x041F
	// Inputs[3]
	// {
	//     @0898  stack[-1]
	//     @0899  stack[-3]
	//     @089A  stack[-2]
	// }
	0895    5B  JUMPDEST
	0896    60  PUSH1 0x00
	0898    81  DUP2
	0899    84  DUP5
	089A    84  DUP5
	089B    11  GT
	089C    15  ISZERO
	089D    61  PUSH2 0x0924
	08A0    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0896  stack[0] = 0x00
	//     @0898  stack[1] = stack[-1]
	// }
	// Block ends with conditional jump to 0x0924, if !(stack[-2] > stack[-3])

label_08A1:
	// Incoming jump from 0x08A0, if not !(stack[-2] > stack[-3])
	// Inputs[4]
	// {
	//     @08A3  memory[0x40:0x60]
	//     @08BA  stack[-1]
	//     @08BD  memory[stack[-1]:stack[-1] + 0x20]
	//     @08C6  memory[stack[-1]:stack[-1] + 0x20]
	// }
	08A1    60  PUSH1 0x40
	08A3    51  MLOAD
	08A4    62  PUSH3 0x461bcd
	08A8    60  PUSH1 0xe5
	08AA    1B  SHL
	08AB    81  DUP2
	08AC    52  MSTORE
	08AD    60  PUSH1 0x04
	08AF    01  ADD
	08B0    80  DUP1
	08B1    80  DUP1
	08B2    60  PUSH1 0x20
	08B4    01  ADD
	08B5    82  DUP3
	08B6    81  DUP2
	08B7    03  SUB
	08B8    82  DUP3
	08B9    52  MSTORE
	08BA    83  DUP4
	08BB    81  DUP2
	08BC    81  DUP2
	08BD    51  MLOAD
	08BE    81  DUP2
	08BF    52  MSTORE
	08C0    60  PUSH1 0x20
	08C2    01  ADD
	08C3    91  SWAP2
	08C4    50  POP
	08C5    80  DUP1
	08C6    51  MLOAD
	08C7    90  SWAP1
	08C8    60  PUSH1 0x20
	08CA    01  ADD
	08CB    90  SWAP1
	08CC    80  DUP1
	08CD    83  DUP4
	08CE    83  DUP4
	08CF    60  PUSH1 0x00
	08D1    5B  JUMPDEST
	08D2    83  DUP4
	08D3    81  DUP2
	08D4    10  LT
	08D5    15  ISZERO
	08D6    61  PUSH2 0x08e9
	08D9    57  *JUMPI
	// Stack delta = +9
	// Outputs[12]
	// {
	//     @08AC  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5
	//     @08AF  stack[0] = 0x04 + memory[0x40:0x60]
	//     @08B0  stack[1] = 0x04 + memory[0x40:0x60]
	//     @08B9  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @08BF  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @08C3  stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @08CB  stack[3] = 0x20 + stack[-1]
	//     @08CB  stack[4] = memory[stack[-1]:stack[-1] + 0x20]
	//     @08CC  stack[5] = memory[stack[-1]:stack[-1] + 0x20]
	//     @08CD  stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @08CE  stack[7] = 0x20 + stack[-1]
	//     @08CF  stack[8] = 0x00
	// }
	// Block ends with conditional jump to 0x08e9, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_08DA:
	// Incoming jump from 0x08D9, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x08D9, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @08DA  stack[-2]
	//     @08DB  stack[-1]
	//     @08DD  memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20]
	//     @08DE  stack[-3]
	// }
	08DA    81  DUP2
	08DB    81  DUP2
	08DC    01  ADD
	08DD    51  MLOAD
	08DE    83  DUP4
	08DF    82  DUP3
	08E0    01  ADD
	08E1    52  MSTORE
	08E2    60  PUSH1 0x20
	08E4    01  ADD
	08E5    61  PUSH2 0x08d1
	08E8    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @08E1  memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20]
	//     @08E4  stack[-1] = 0x20 + stack[-1]
	// }
	// Block ends with unconditional jump to 0x08d1

label_08E9:
	// Incoming jump from 0x08D9, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x08D9, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[3]
	// {
	//     @08EE  stack[-6]
	//     @08EE  stack[-5]
	//     @08F0  stack[-7]
	// }
	08E9    5B  JUMPDEST
	08EA    50  POP
	08EB    50  POP
	08EC    50  POP
	08ED    50  POP
	08EE    90  SWAP1
	08EF    50  POP
	08F0    90  SWAP1
	08F1    81  DUP2
	08F2    01  ADD
	08F3    90  SWAP1
	08F4    60  PUSH1 0x1f
	08F6    16  AND
	08F7    80  DUP1
	08F8    15  ISZERO
	08F9    61  PUSH2 0x0916
	08FC    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @08F3  stack[-7] = stack[-5] + stack[-7]
	//     @08F6  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0916, if !(0x1f & stack[-5])

label_08FD:
	// Incoming jump from 0x08FC, if not !(0x1f & stack[-5])
	// Inputs[6]
	// {
	//     @08FD  stack[-1]
	//     @08FE  stack[-2]
	//     @0901  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0918  stack[-5]
	//     @091E  memory[0x40:0x60]
	//     @0923  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	// }
	08FD    80  DUP1
	08FE    82  DUP3
	08FF    03  SUB
	0900    80  DUP1
	0901    51  MLOAD
	0902    60  PUSH1 0x01
	0904    83  DUP4
	0905    60  PUSH1 0x20
	0907    03  SUB
	0908    61  PUSH2 0x0100
	090B    0A  EXP
	090C    03  SUB
	090D    19  NOT
	090E    16  AND
	090F    81  DUP2
	0910    52  MSTORE
	0911    60  PUSH1 0x20
	0913    01  ADD
	0914    91  SWAP2
	0915    50  POP
	0916    5B  JUMPDEST
	0917    50  POP
	0918    92  SWAP3
	0919    50  POP
	091A    50  POP
	091B    50  POP
	091C    60  PUSH1 0x40
	091E    51  MLOAD
	091F    80  DUP1
	0920    91  SWAP2
	0921    03  SUB
	0922    90  SWAP1
	0923    FD  *REVERT
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0910  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]
	//     @0923  revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]);
	// }
	// Block terminates

label_0924:
	// Incoming jump from 0x08A0, if !(stack[-2] > stack[-3])
	// Inputs[3]
	// {
	//     @0928  stack[-4]
	//     @0928  stack[-5]
	//     @092A  stack[-6]
	// }
	0924    5B  JUMPDEST
	0925    50  POP
	0926    50  POP
	0927    50  POP
	0928    90  SWAP1
	0929    03  SUB
	092A    90  SWAP1
	092B    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @092A  stack[-6] = stack[-5] - stack[-4] }
	// Block ends with unconditional jump to stack[-6]

label_092C:
	// Incoming call from 0x07CE, returns to 0x07CF
	// Inputs[1] { @0930  stack[-4] }
	092C    5B  JUMPDEST
	092D    50  POP
	092E    50  POP
	092F    50  POP
	0930    56  *JUMP
	// Stack delta = -4
	// Block ends with unconditional jump to stack[-4]

	0931    FE    *ASSERT
	0932    45    GASLIMIT
	0933    52    MSTORE
	0934    43    NUMBER
	0935    32    ORIGIN
	0936    30    ADDRESS
	0937    3A    GASPRICE
	0938    20    SHA3
	0939    74    PUSH21 0x72616e7366657220746f20746865207a65726f2061
	094F    64    PUSH5 0x6472657373
	0955    45    GASLIMIT
	0956    52    MSTORE
	0957    43    NUMBER
	0958    32    ORIGIN
	0959    30    ADDRESS
	095A    3A    GASPRICE
	095B    20    SHA3
	095C    61    PUSH2 0x7070
	095F    72    PUSH19 0x6f766520746f20746865207a65726f20616464
	0973    72    PUSH19 0x65737345524332303a207472616e7366657220
	0987    61    PUSH2 0x6d6f
	098A    75    PUSH22 0x6e7420657863656564732062616c616e636545524332
	09A1    30    ADDRESS
	09A2    3A    GASPRICE
	09A3    20    SHA3
	09A4    74    PUSH21 0x72616e7366657220616d6f756e7420657863656564
	09BA    73    PUSH20 0x20616c6c6f77616e636545524332303a20747261
	09CF    6E    PUSH15 0x736665722066726f6d20746865207a
	09DF    65    PUSH6 0x726f20616464
	09E6    72    PUSH19 0x65737345524332303a20617070726f76652066
	09FA    72    PUSH19 0x6f6d20746865207a65726f2061646472657373
	0A0E    68    PUSH9 0x747470733a2f2f7669
	0A18    74    PUSH21 0x746f6d696e61636f72692e6769746875622e696f2f
	0A2E    65    PUSH6 0x726332302d67
	0A35    65    PUSH6 0x6e657261746f
	0A3C    72    PUSH19 0x45524332303a2064656372656173656420616c
	0A50    6C    PUSH13 0x6f77616e63652062656c6f7720
	0A5E    7A    PUSH27 0x65726fa2646970667358221220d84f2554bbe4134a5e39bc9b4038
	0A7A    33    CALLER
	0A7B    92    SWAP3
	0A7C    47    SELFBALANCE
	0A7D    6D    PUSH14 0x40826d2dd5b5e8e8e7f44a76c1e8
	0A8C    64    PUSH5 0x736f6c6343
	0A92    00    *STOP
	0A93    07    SMOD
	0A94    04    DIV
	0A95    00    *STOP
	0A96    33    CALLER