Online Solidity Decompiler

« Decompile another contract

Address

0x8baae1b64dccfee7b88244b41b9c0c4f587e7345 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.

0x5b61291c aekS()

0x64d98f6e isSolved()

0x6c54fcef Unknown

0x7430306c Unknown

0xb220f73c Unknown

0xb4eff690 checkFlag(bytes)

0xd6385778 Unknown

0xf605fa57 Unknown

Internal Methods

isSolved() returns (r0)

func_02B5(arg0)

func_073D(arg0)

checkFlag(arg0)

func_1195(arg0)

func_1869(arg0)

func_1DBD()

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x60;
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
    
        if (var0 == 0x5b61291c) {
            // Dispatch table entry for aekS()
            var var1 = 0x009b;
            revert(memory[0x00:0x00]);
        } else if (var0 == 0x64d98f6e) {
            // Dispatch table entry for isSolved()
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x00b0;
            var1 = isSolved();
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = !!var1;
            var temp1 = memory[0x40:0x60];
            return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
        } else if (var0 == 0x6c54fcef) {
            // Dispatch table entry for 0x6c54fcef (unknown)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0125;
            var temp2 = msg.data[0x04:0x24] + 0x04;
            var temp3 = msg.data[temp2:temp2 + 0x20];
            var temp4 = memory[0x40:0x60];
            memory[0x40:0x60] = temp4 + (temp3 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp4:temp4 + 0x20] = temp3;
            memory[temp4 + 0x20:temp4 + 0x20 + temp3] = msg.data[temp2 + 0x20:temp2 + 0x20 + temp3];
            var var2 = temp4;
            func_02B5(var2);
            stop();
        } else if (var0 == 0x7430306c) {
            // Dispatch table entry for 0x7430306c (unknown)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x013a;
            selfdestruct(0x00);
        } else if (var0 == 0xb220f73c) {
            // Dispatch table entry for 0xb220f73c (unknown)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0197;
            var temp5 = msg.data[0x04:0x24] + 0x04;
            var temp6 = msg.data[temp5:temp5 + 0x20];
            var temp7 = memory[0x40:0x60];
            memory[0x40:0x60] = temp7 + (temp6 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp7:temp7 + 0x20] = temp6;
            memory[temp7 + 0x20:temp7 + 0x20 + temp6] = msg.data[temp5 + 0x20:temp5 + 0x20 + temp6];
            var2 = temp7;
            func_073D(var2);
            stop();
        } else if (var0 == 0xb4eff690) {
            // Dispatch table entry for checkFlag(bytes)
            var1 = 0x01e9;
            var temp8 = msg.data[0x04:0x24] + 0x04;
            var temp9 = msg.data[temp8:temp8 + 0x20];
            var temp10 = memory[0x40:0x60];
            memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp10:temp10 + 0x20] = temp9;
            memory[temp10 + 0x20:temp10 + 0x20 + temp9] = msg.data[temp8 + 0x20:temp8 + 0x20 + temp9];
            var2 = temp10;
            checkFlag(var2);
            stop();
        } else if (var0 == 0xd6385778) {
            // Dispatch table entry for 0xd6385778 (unknown)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0246;
            var temp11 = msg.data[0x04:0x24] + 0x04;
            var temp12 = msg.data[temp11:temp11 + 0x20];
            var temp13 = memory[0x40:0x60];
            memory[0x40:0x60] = temp13 + (temp12 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp13:temp13 + 0x20] = temp12;
            memory[temp13 + 0x20:temp13 + 0x20 + temp12] = msg.data[temp11 + 0x20:temp11 + 0x20 + temp12];
            var2 = temp13;
            func_1195(var2);
            stop();
        } else if (var0 == 0xf605fa57) {
            // Dispatch table entry for 0xf605fa57 (unknown)
            var1 = 0x0298;
            var temp14 = msg.data[0x04:0x24] + 0x04;
            var temp15 = msg.data[temp14:temp14 + 0x20];
            var temp16 = memory[0x40:0x60];
            memory[0x40:0x60] = temp16 + (temp15 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp16:temp16 + 0x20] = temp15;
            memory[temp16 + 0x20:temp16 + 0x20 + temp15] = msg.data[temp14 + 0x20:temp14 + 0x20 + temp15];
            var2 = temp16;
            func_1869(var2);
            stop();
        } else { revert(memory[0x00:0x00]); }
    }
    
    function isSolved() returns (var r0) { return storage[0x00] & 0xff; }
    
    function func_02B5(var arg0) {
        var var0 = 0x00;
    
        if (block.timestamp != 0x5ad92d80) { goto label_0038; }
    
        var var1 = 0x02d0;
        func_1DBD();
        var1 = arg0;
        var var2 = 0x12;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        var0 = (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000;
        var1 = 0x08;
        var2 = arg0;
        var var3 = 0x13;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x10;
        var2 = arg0;
        var3 = 0x14;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x18;
        var2 = arg0;
        var3 = 0x15;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x20;
        var2 = arg0;
        var3 = 0x16;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x28;
        var2 = arg0;
        var3 = 0x17;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x30;
        var2 = arg0;
        var3 = 0x18;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var1 = 0x38;
        var2 = arg0;
        var3 = 0x19;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var temp0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000);
        var0 = (temp0 + temp0 * msg.gas * msg.value) * tx.gasprice;
        var1 = 0x071d;
        func_1DBD();
    
        if (var0 == 0x02f0c798885c9f2975b114) { return; }
    
    label_0038:
    
        if (var0 == 0x291c) {
            var0 = 0x009b;
            revert(memory[0x00:0x00]);
        } else if (arg0 == 0x64d98f6e) {
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var0 = 0x00b0;
            var0 = isSolved();
            var temp1 = memory[0x40:0x60];
            memory[temp1:temp1 + 0x20] = !!var0;
            var temp2 = memory[0x40:0x60];
            return memory[temp2:temp2 + (temp1 + 0x20) - temp2];
        } else if (arg0 == 0x6c54fcef) {
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var0 = 0x0125;
            var temp3 = msg.data[0x04:0x24] + 0x04;
            var temp4 = msg.data[temp3:temp3 + 0x20];
            var temp5 = memory[0x40:0x60];
            memory[0x40:0x60] = temp5 + (temp4 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp5:temp5 + 0x20] = temp4;
            memory[temp5 + 0x20:temp5 + 0x20 + temp4] = msg.data[temp3 + 0x20:temp3 + 0x20 + temp4];
            var1 = temp5;
            func_02B5(var1);
            stop();
        } else if (arg0 == 0x7430306c) {
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var0 = 0x013a;
            selfdestruct(0x00);
        } else if (arg0 == 0xb220f73c) {
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var0 = 0x0197;
            var temp6 = msg.data[0x04:0x24] + 0x04;
            var temp7 = msg.data[temp6:temp6 + 0x20];
            var temp8 = memory[0x40:0x60];
            memory[0x40:0x60] = temp8 + (temp7 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp8:temp8 + 0x20] = temp7;
            memory[temp8 + 0x20:temp8 + 0x20 + temp7] = msg.data[temp6 + 0x20:temp6 + 0x20 + temp7];
            var1 = temp8;
            func_073D(var1);
            stop();
        } else if (arg0 == 0xb4eff690) {
            var0 = 0x01e9;
            var temp9 = msg.data[0x04:0x24] + 0x04;
            var temp10 = msg.data[temp9:temp9 + 0x20];
            var temp11 = memory[0x40:0x60];
            memory[0x40:0x60] = temp11 + (temp10 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp11:temp11 + 0x20] = temp10;
            memory[temp11 + 0x20:temp11 + 0x20 + temp10] = msg.data[temp9 + 0x20:temp9 + 0x20 + temp10];
            var1 = temp11;
            checkFlag(var1);
            stop();
        } else if (arg0 == 0xd6385778) {
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var0 = 0x0246;
            var temp12 = msg.data[0x04:0x24] + 0x04;
            var temp13 = msg.data[temp12:temp12 + 0x20];
            var temp14 = memory[0x40:0x60];
            memory[0x40:0x60] = temp14 + (temp13 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp14:temp14 + 0x20] = temp13;
            memory[temp14 + 0x20:temp14 + 0x20 + temp13] = msg.data[temp12 + 0x20:temp12 + 0x20 + temp13];
            var1 = temp14;
            func_1195(var1);
            stop();
        } else if (arg0 == 0xf605fa57) {
            var0 = 0x0298;
            var temp15 = msg.data[0x04:0x24] + 0x04;
            var temp16 = msg.data[temp15:temp15 + 0x20];
            var temp17 = memory[0x40:0x60];
            memory[0x40:0x60] = temp17 + (temp16 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp17:temp17 + 0x20] = temp16;
            memory[temp17 + 0x20:temp17 + 0x20 + temp16] = msg.data[temp15 + 0x20:temp15 + 0x20 + temp16];
            var1 = temp17;
            func_1869(var1);
            stop();
        } else { revert(memory[0x00:0x00]); }
    }
    
    function func_073D(var arg0) {
        var var0 = 0x7500000000000000000000000000000000000000000000000000000000000000;
        var var1 = arg0;
        var var2 = 0x0d;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x07ed;
        func_1DBD();
        var0 = 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b;
        var1 = 0x01;
        var2 = 0x02;
        var var3 = arg0;
        var var4 = 0x0e;
    
        if (var4 >= memory[var3:var3 + 0x20]) { assert(); }
    
        var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var4 = arg0;
        var var5 = 0x0f;
    
        if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
    
        var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var5 = arg0;
        var var6 = 0x10;
    
        if (var6 >= memory[var5:var5 + 0x20]) { assert(); }
    
        var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var6 = arg0;
        var var7 = 0x11;
    
        if (var7 >= memory[var6:var6 + 0x20]) { assert(); }
    
        var temp0 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp2 = temp1 + 0x01;
        memory[temp2:temp2 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp3 = temp2 + 0x01;
        memory[temp3:temp3 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp4 = temp3 + 0x01;
        memory[temp4:temp4 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var3 = temp4 + 0x01;
        var temp5 = memory[0x40:0x60];
        var temp6;
        temp6, memory[temp5:temp5 + 0x20] = address(var2).call.gas(msg.gas)(memory[temp5:temp5 + var3 - temp5]);
    
        if (!temp6) { revert(memory[0x00:0x00]); }
    
        if (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + var1 == var0) {
            var0 = 0x0ae6;
            func_1DBD();
            var0 = address(this);
            var1 = 0x6c54fcef;
            var temp7 = arg0;
            var2 = temp7;
            var temp8 = memory[0x40:0x60];
            memory[temp8:temp8 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
            var temp9 = temp8 + 0x04;
            var3 = temp9;
            var4 = var3;
            var temp10 = var4 + 0x20;
            memory[var4:var4 + 0x20] = temp10 - var4;
            memory[temp10:temp10 + 0x20] = memory[var2:var2 + 0x20];
            var5 = temp10 + 0x20;
            var6 = var2 + 0x20;
            var7 = memory[var2:var2 + 0x20];
            var var8 = var7;
            var var9 = var5;
            var var10 = var6;
            var var11 = 0x00;
        
            if (var11 >= var8) {
            label_0B6E:
                var temp11 = var7;
                var5 = temp11 + var5;
                var6 = temp11 & 0x1f;
            
                if (!var6) {
                    var2 = var5;
                    var3 = 0x00;
                    var4 = memory[0x40:0x60];
                    var5 = var2 - var4;
                    var6 = var4;
                    var7 = 0x00;
                    var8 = var0;
                
                    if (!address(var8).code.length) { revert(memory[0x00:0x00]); }
                
                label_0BB9:
                    var temp12;
                    temp12, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]);
                
                    if (temp12) { return; }
                    else { revert(memory[0x00:0x00]); }
                } else {
                    var temp13 = var6;
                    var temp14 = var5 - temp13;
                    memory[temp14:temp14 + 0x20] = ~(0x0100 ** (0x20 - temp13) - 0x01) & memory[temp14:temp14 + 0x20];
                    var2 = temp14 + 0x20;
                    var3 = 0x00;
                    var4 = memory[0x40:0x60];
                    var5 = var2 - var4;
                    var6 = var4;
                    var7 = 0x00;
                    var8 = var0;
                
                    if (address(var8).code.length) { goto label_0BB9; }
                    else { revert(memory[0x00:0x00]); }
                }
            } else {
            label_0B5C:
                var temp15 = var11;
                memory[var9 + temp15:var9 + temp15 + 0x20] = memory[var10 + temp15:var10 + temp15 + 0x20];
                var11 = temp15 + 0x20;
            
                if (var11 >= var8) { goto label_0B6E; }
                else { goto label_0B5C; }
            }
        } else {
        label_0038:
        
            if (arg0 == 0x291c) {
                arg0 = 0x009b;
                revert(memory[0x00:0x00]);
            } else if (returnAddress0 == 0x64d98f6e) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                arg0 = 0x00b0;
                arg0 = isSolved();
                var temp16 = memory[0x40:0x60];
                memory[temp16:temp16 + 0x20] = !!arg0;
                var temp17 = memory[0x40:0x60];
                return memory[temp17:temp17 + (temp16 + 0x20) - temp17];
            } else if (returnAddress0 == 0x6c54fcef) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                arg0 = 0x0125;
                var temp18 = msg.data[0x04:0x24] + 0x04;
                var temp19 = msg.data[temp18:temp18 + 0x20];
                var temp20 = memory[0x40:0x60];
                memory[0x40:0x60] = temp20 + (temp19 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp20:temp20 + 0x20] = temp19;
                memory[temp20 + 0x20:temp20 + 0x20 + temp19] = msg.data[temp18 + 0x20:temp18 + 0x20 + temp19];
                var0 = temp20;
                func_02B5(var0);
                stop();
            } else if (returnAddress0 == 0x7430306c) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                arg0 = 0x013a;
                selfdestruct(0x00);
            } else if (returnAddress0 == 0xb220f73c) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                arg0 = 0x0197;
                var temp21 = msg.data[0x04:0x24] + 0x04;
                var temp22 = msg.data[temp21:temp21 + 0x20];
                var temp23 = memory[0x40:0x60];
                memory[0x40:0x60] = temp23 + (temp22 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp23:temp23 + 0x20] = temp22;
                memory[temp23 + 0x20:temp23 + 0x20 + temp22] = msg.data[temp21 + 0x20:temp21 + 0x20 + temp22];
                var0 = temp23;
                func_073D(var0);
                stop();
            } else if (returnAddress0 == 0xb4eff690) {
                arg0 = 0x01e9;
                var temp24 = msg.data[0x04:0x24] + 0x04;
                var temp25 = msg.data[temp24:temp24 + 0x20];
                var temp26 = memory[0x40:0x60];
                memory[0x40:0x60] = temp26 + (temp25 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp26:temp26 + 0x20] = temp25;
                memory[temp26 + 0x20:temp26 + 0x20 + temp25] = msg.data[temp24 + 0x20:temp24 + 0x20 + temp25];
                var0 = temp26;
                checkFlag(var0);
                stop();
            } else if (returnAddress0 == 0xd6385778) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                arg0 = 0x0246;
                var temp27 = msg.data[0x04:0x24] + 0x04;
                var temp28 = msg.data[temp27:temp27 + 0x20];
                var temp29 = memory[0x40:0x60];
                memory[0x40:0x60] = temp29 + (temp28 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp29:temp29 + 0x20] = temp28;
                memory[temp29 + 0x20:temp29 + 0x20 + temp28] = msg.data[temp27 + 0x20:temp27 + 0x20 + temp28];
                var0 = temp29;
                func_1195(var0);
                stop();
            } else if (returnAddress0 == 0xf605fa57) {
                arg0 = 0x0298;
                var temp30 = msg.data[0x04:0x24] + 0x04;
                var temp31 = msg.data[temp30:temp30 + 0x20];
                var temp32 = memory[0x40:0x60];
                memory[0x40:0x60] = temp32 + (temp31 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp32:temp32 + 0x20] = temp31;
                memory[temp32 + 0x20:temp32 + 0x20 + temp31] = msg.data[temp30 + 0x20:temp30 + 0x20 + temp31];
                var0 = temp32;
                func_1869(var0);
                stop();
            } else { revert(memory[0x00:0x00]); }
        }
    }
    
    function checkFlag(var arg0) {
        var var0 = 0x6600000000000000000000000000000000000000000000000000000000000000;
        var var1 = arg0;
        var var2 = 0x00;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x0c7c;
        func_1DBD();
        var0 = 0x6c00000000000000000000000000000000000000000000000000000000000000;
        var1 = arg0;
        var2 = 0x01;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x6100000000000000000000000000000000000000000000000000000000000000;
        var1 = arg0;
        var2 = 0x02;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x0dd4;
        func_1DBD();
        var0 = 0x6700000000000000000000000000000000000000000000000000000000000000;
        var1 = arg0;
        var2 = 0x03;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x0e84;
        func_1DBD();
        var0 = 0x7b00000000000000000000000000000000000000000000000000000000000000;
        var1 = arg0;
        var2 = 0x04;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; }
    
        var0 = 0x7d00000000000000000000000000000000000000000000000000000000000000;
        var1 = arg0;
        var2 = 0x1f;
    
        if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
    
        if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { selfdestruct(0x00); }
    
        var0 = 0x0fdc;
        func_1DBD();
        var0 = address(this);
        var1 = 0xf605fa57;
        var2 = msg.value;
        var temp0 = arg0;
        var var3 = temp0;
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
        var temp2 = temp1 + 0x04;
        var var4 = temp2;
        var var5 = var4;
        var temp3 = var5 + 0x20;
        memory[var5:var5 + 0x20] = temp3 - var5;
        memory[temp3:temp3 + 0x20] = memory[var3:var3 + 0x20];
        var var6 = temp3 + 0x20;
        var var7 = var3 + 0x20;
        var var8 = memory[var3:var3 + 0x20];
        var var9 = var8;
        var var10 = var6;
        var var11 = var7;
        var var12 = 0x00;
    
        if (var12 >= var9) {
        label_1065:
            var temp4 = var8;
            var6 = temp4 + var6;
            var7 = temp4 & 0x1f;
        
            if (!var7) {
                var3 = var6;
                var4 = 0x00;
                var5 = memory[0x40:0x60];
                var6 = var3 - var5;
                var7 = var5;
                var8 = var2;
                var9 = var0;
            
                if (!address(var9).code.length) { revert(memory[0x00:0x00]); }
            
            label_10AF:
                var temp5;
                temp5, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]);
            
                if (!temp5) { revert(memory[0x00:0x00]); }
            
                var0 = 0x10c8;
                func_1DBD();
                var0 = 0x7300000000000000000000000000000000000000000000000000000000000000;
                var1 = arg0;
                var2 = 0x1e;
            
                if (var2 >= memory[var1:var1 + 0x20]) { assert(); }
            
                if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == var0) {
                    var0 = 0x1178;
                    func_1DBD();
                    storage[0x00] = (storage[0x00] & ~0xff) | 0x01;
                    return;
                } else {
                label_0038:
                
                    if (arg0 == 0x291c) {
                        arg0 = 0x009b;
                        revert(memory[0x00:0x00]);
                    } else if (returnAddress0 == 0x64d98f6e) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        arg0 = 0x00b0;
                        arg0 = isSolved();
                        var temp6 = memory[0x40:0x60];
                        memory[temp6:temp6 + 0x20] = !!arg0;
                        var temp7 = memory[0x40:0x60];
                        return memory[temp7:temp7 + (temp6 + 0x20) - temp7];
                    } else if (returnAddress0 == 0x6c54fcef) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        arg0 = 0x0125;
                        var temp8 = msg.data[0x04:0x24] + 0x04;
                        var temp9 = msg.data[temp8:temp8 + 0x20];
                        var temp10 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp10:temp10 + 0x20] = temp9;
                        memory[temp10 + 0x20:temp10 + 0x20 + temp9] = msg.data[temp8 + 0x20:temp8 + 0x20 + temp9];
                        var0 = temp10;
                        func_02B5(var0);
                        stop();
                    } else if (returnAddress0 == 0x7430306c) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        arg0 = 0x013a;
                        selfdestruct(0x00);
                    } else if (returnAddress0 == 0xb220f73c) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        arg0 = 0x0197;
                        var temp11 = msg.data[0x04:0x24] + 0x04;
                        var temp12 = msg.data[temp11:temp11 + 0x20];
                        var temp13 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp13 + (temp12 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp13:temp13 + 0x20] = temp12;
                        memory[temp13 + 0x20:temp13 + 0x20 + temp12] = msg.data[temp11 + 0x20:temp11 + 0x20 + temp12];
                        var0 = temp13;
                        func_073D(var0);
                        stop();
                    } else if (returnAddress0 == 0xb4eff690) {
                        arg0 = 0x01e9;
                        var temp14 = msg.data[0x04:0x24] + 0x04;
                        var temp15 = msg.data[temp14:temp14 + 0x20];
                        var temp16 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp16 + (temp15 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp16:temp16 + 0x20] = temp15;
                        memory[temp16 + 0x20:temp16 + 0x20 + temp15] = msg.data[temp14 + 0x20:temp14 + 0x20 + temp15];
                        var0 = temp16;
                        checkFlag(var0);
                        stop();
                    } else if (returnAddress0 == 0xd6385778) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        arg0 = 0x0246;
                        var temp17 = msg.data[0x04:0x24] + 0x04;
                        var temp18 = msg.data[temp17:temp17 + 0x20];
                        var temp19 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp19 + (temp18 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp19:temp19 + 0x20] = temp18;
                        memory[temp19 + 0x20:temp19 + 0x20 + temp18] = msg.data[temp17 + 0x20:temp17 + 0x20 + temp18];
                        var0 = temp19;
                        func_1195(var0);
                        stop();
                    } else if (returnAddress0 == 0xf605fa57) {
                        arg0 = 0x0298;
                        var temp20 = msg.data[0x04:0x24] + 0x04;
                        var temp21 = msg.data[temp20:temp20 + 0x20];
                        var temp22 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp22 + (temp21 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp22:temp22 + 0x20] = temp21;
                        memory[temp22 + 0x20:temp22 + 0x20 + temp21] = msg.data[temp20 + 0x20:temp20 + 0x20 + temp21];
                        var0 = temp22;
                        func_1869(var0);
                        stop();
                    } else { revert(memory[0x00:0x00]); }
                }
            } else {
                var temp23 = var7;
                var temp24 = var6 - temp23;
                memory[temp24:temp24 + 0x20] = ~(0x0100 ** (0x20 - temp23) - 0x01) & memory[temp24:temp24 + 0x20];
                var3 = temp24 + 0x20;
                var4 = 0x00;
                var5 = memory[0x40:0x60];
                var6 = var3 - var5;
                var7 = var5;
                var8 = var2;
                var9 = var0;
            
                if (address(var9).code.length) { goto label_10AF; }
                else { revert(memory[0x00:0x00]); }
            }
        } else {
        label_1053:
            var temp25 = var12;
            memory[var10 + temp25:var10 + temp25 + 0x20] = memory[var11 + temp25:var11 + temp25 + 0x20];
            var12 = temp25 + 0x20;
        
            if (var12 >= var9) { goto label_1065; }
            else { goto label_1053; }
        }
    }
    
    function func_1195(var arg0) {
        var var0 = 0x00;
        var var1 = var0;
    
        if (block.number != 0x01a4) { goto label_0038; }
    
        var0 = block.number;
        var var2 = 0x11b2;
        func_1DBD();
        var1 = 0x74f794a249c48cbd04;
        var2 = arg0;
        var var3 = 0x05;
    
        if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
    
        var2 = memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var3 = arg0;
        var var4 = 0x06;
    
        if (var4 >= memory[var3:var3 + 0x20]) { assert(); }
    
        var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var4 = arg0;
        var var5 = 0x07;
    
        if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
    
        var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var5 = arg0;
        var var6 = 0x08;
    
        if (var6 >= memory[var5:var5 + 0x20]) { assert(); }
    
        var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var6 = arg0;
        var var7 = 0x09;
    
        if (var7 >= memory[var6:var6 + 0x20]) { assert(); }
    
        var6 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var7 = arg0;
        var var8 = 0x0a;
    
        if (var8 >= memory[var7:var7 + 0x20]) { assert(); }
    
        var7 = memory[var7 + 0x20 + var8:var7 + 0x20 + var8 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var8 = arg0;
        var var9 = 0x0b;
    
        if (var9 >= memory[var8:var8 + 0x20]) { assert(); }
    
        var8 = memory[var8 + 0x20 + var9:var8 + 0x20 + var9 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var9 = arg0;
        var var10 = 0x0c;
    
        if (var10 >= memory[var9:var9 + 0x20]) { assert(); }
    
        var temp0 = memory[var9 + 0x20 + var10:var9 + 0x20 + var10 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = var2 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp2 = temp1 + 0x01;
        memory[temp2:temp2 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp3 = temp2 + 0x01;
        memory[temp3:temp3 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp4 = temp3 + 0x01;
        memory[temp4:temp4 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp5 = temp4 + 0x01;
        memory[temp5:temp5 + 0x20] = var6 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp6 = temp5 + 0x01;
        memory[temp6:temp6 + 0x20] = var7 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp7 = temp6 + 0x01;
        memory[temp7:temp7 + 0x20] = var8 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp8 = temp7 + 0x01;
        memory[temp8:temp8 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp9 = memory[0x40:0x60];
        var2 = keccak256(memory[temp9:temp9 + (temp8 + 0x01) - temp9]);
        var3 = var0;
        var4 = var1;
    
        if (!var3) { assert(); }
    
        var temp10 = memory[0x40:0x60];
        memory[temp10:temp10 + 0x20] = var4 / var3 * 0x01000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp11 = memory[0x40:0x60];
    
        if (keccak256(memory[temp11:temp11 + (temp10 + 0x08) - temp11]) == var2) {
            var2 = 0x1781;
            func_1DBD();
            var2 = address(this);
            var3 = 0xb220f73c;
            var temp12 = arg0;
            var4 = temp12;
            var temp13 = memory[0x40:0x60];
            memory[temp13:temp13 + 0x20] = (var3 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
            var temp14 = temp13 + 0x04;
            var5 = temp14;
            var6 = var5;
            var temp15 = var6 + 0x20;
            memory[var6:var6 + 0x20] = temp15 - var6;
            memory[temp15:temp15 + 0x20] = memory[var4:var4 + 0x20];
            var7 = temp15 + 0x20;
            var9 = memory[var4:var4 + 0x20];
            var8 = var4 + 0x20;
            var10 = var9;
            var var11 = var7;
            var var12 = var8;
            var var13 = 0x00;
        
            if (var13 >= var10) {
            label_1809:
                var temp16 = var9;
                var7 = temp16 + var7;
                var8 = temp16 & 0x1f;
            
                if (!var8) {
                    var4 = var7;
                    var5 = 0x00;
                    var6 = memory[0x40:0x60];
                    var7 = var4 - var6;
                    var8 = var6;
                    var9 = 0x00;
                    var10 = var2;
                
                    if (!address(var10).code.length) { revert(memory[0x00:0x00]); }
                
                label_1854:
                    var temp17;
                    temp17, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]);
                
                    if (temp17) { return; }
                    else { revert(memory[0x00:0x00]); }
                } else {
                    var temp18 = var8;
                    var temp19 = var7 - temp18;
                    memory[temp19:temp19 + 0x20] = ~(0x0100 ** (0x20 - temp18) - 0x01) & memory[temp19:temp19 + 0x20];
                    var4 = temp19 + 0x20;
                    var5 = 0x00;
                    var6 = memory[0x40:0x60];
                    var7 = var4 - var6;
                    var8 = var6;
                    var9 = 0x00;
                    var10 = var2;
                
                    if (address(var10).code.length) { goto label_1854; }
                    else { revert(memory[0x00:0x00]); }
                }
            } else {
            label_17F7:
                var temp20 = var13;
                memory[var11 + temp20:var11 + temp20 + 0x20] = memory[var12 + temp20:var12 + temp20 + 0x20];
                var13 = temp20 + 0x20;
            
                if (var13 >= var10) { goto label_1809; }
                else { goto label_17F7; }
            }
        } else {
        label_0038:
        
            if (var1 == 0x291c) {
                var1 = 0x009b;
                revert(memory[0x00:0x00]);
            } else if (var0 == 0x64d98f6e) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                var1 = 0x00b0;
                var1 = isSolved();
                var temp21 = memory[0x40:0x60];
                memory[temp21:temp21 + 0x20] = !!var1;
                var temp22 = memory[0x40:0x60];
                return memory[temp22:temp22 + (temp21 + 0x20) - temp22];
            } else if (var0 == 0x6c54fcef) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0125;
                var temp23 = msg.data[0x04:0x24] + 0x04;
                var temp24 = msg.data[temp23:temp23 + 0x20];
                var temp25 = memory[0x40:0x60];
                memory[0x40:0x60] = temp25 + (temp24 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp25:temp25 + 0x20] = temp24;
                memory[temp25 + 0x20:temp25 + 0x20 + temp24] = msg.data[temp23 + 0x20:temp23 + 0x20 + temp24];
                var2 = temp25;
                func_02B5(var2);
                stop();
            } else if (var0 == 0x7430306c) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                var1 = 0x013a;
                selfdestruct(0x00);
            } else if (var0 == 0xb220f73c) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0197;
                var temp26 = msg.data[0x04:0x24] + 0x04;
                var temp27 = msg.data[temp26:temp26 + 0x20];
                var temp28 = memory[0x40:0x60];
                memory[0x40:0x60] = temp28 + (temp27 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp28:temp28 + 0x20] = temp27;
                memory[temp28 + 0x20:temp28 + 0x20 + temp27] = msg.data[temp26 + 0x20:temp26 + 0x20 + temp27];
                var2 = temp28;
                func_073D(var2);
                stop();
            } else if (var0 == 0xb4eff690) {
                var1 = 0x01e9;
                var temp29 = msg.data[0x04:0x24] + 0x04;
                var temp30 = msg.data[temp29:temp29 + 0x20];
                var temp31 = memory[0x40:0x60];
                memory[0x40:0x60] = temp31 + (temp30 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp31:temp31 + 0x20] = temp30;
                memory[temp31 + 0x20:temp31 + 0x20 + temp30] = msg.data[temp29 + 0x20:temp29 + 0x20 + temp30];
                var2 = temp31;
                checkFlag(var2);
                stop();
            } else if (var0 == 0xd6385778) {
                if (msg.value) { revert(memory[0x00:0x00]); }
            
                var1 = 0x0246;
                var temp32 = msg.data[0x04:0x24] + 0x04;
                var temp33 = msg.data[temp32:temp32 + 0x20];
                var temp34 = memory[0x40:0x60];
                memory[0x40:0x60] = temp34 + (temp33 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp34:temp34 + 0x20] = temp33;
                memory[temp34 + 0x20:temp34 + 0x20 + temp33] = msg.data[temp32 + 0x20:temp32 + 0x20 + temp33];
                var2 = temp34;
                func_1195(var2);
                stop();
            } else if (var0 == 0xf605fa57) {
                var1 = 0x0298;
                var temp35 = msg.data[0x04:0x24] + 0x04;
                var temp36 = msg.data[temp35:temp35 + 0x20];
                var temp37 = memory[0x40:0x60];
                memory[0x40:0x60] = temp37 + (temp36 + 0x1f) / 0x20 * 0x20 + 0x20;
                memory[temp37:temp37 + 0x20] = temp36;
                memory[temp37 + 0x20:temp37 + 0x20 + temp36] = msg.data[temp35 + 0x20:temp35 + 0x20 + temp36];
                var2 = temp37;
                func_1869(var2);
                stop();
            } else { revert(memory[0x00:0x00]); }
        }
    }
    
    function func_1869(var arg0) {
        var var0 = 0x00;
        var var1 = var0;
        var var2 = 0x00;
    
        if (msg.value != 0x2a) { selfdestruct(0x00); }
    
        var var3 = 0x1884;
        func_1DBD();
    
        if (tx.gasprice != 0x066a44) { goto label_0038; }
    
        var3 = 0x189c;
        func_1DBD();
        var3 = arg0;
        var var4 = 0x1a;
    
        if (var4 >= memory[var3:var3 + 0x20]) { assert(); }
    
        var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var4 = arg0;
        var var5 = 0x1b;
    
        if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
    
        var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var5 = arg0;
        var var6 = 0x1c;
    
        if (var6 >= memory[var5:var5 + 0x20]) { assert(); }
    
        var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var6 = arg0;
        var var7 = 0x1d;
    
        if (var7 >= memory[var6:var6 + 0x20]) { assert(); }
    
        var temp0 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000;
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp2 = temp1 + 0x01;
        memory[temp2:temp2 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp3 = temp2 + 0x01;
        memory[temp3:temp3 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp4 = temp3 + 0x01;
        memory[temp4:temp4 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        var temp5 = memory[0x40:0x60];
        var0 = keccak256(memory[temp5:temp5 + (temp4 + 0x01) - temp5]);
        var3 = 0x1b48;
        func_1DBD();
        var1 = 0x00;
    
        if (var1 >= memory[arg0:arg0 + 0x20]) {
        label_1C0F:
            var3 = 0x1c17;
            func_1DBD();
            var3 = address(this);
            var4 = 0xd6385778;
            var temp6 = arg0;
            var5 = temp6;
            var temp7 = memory[0x40:0x60];
            memory[temp7:temp7 + 0x20] = (var4 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
            var temp8 = temp7 + 0x04;
            var6 = temp8;
            var7 = var6;
            var temp9 = var7 + 0x20;
            memory[var7:var7 + 0x20] = temp9 - var7;
            memory[temp9:temp9 + 0x20] = memory[var5:var5 + 0x20];
            var var8 = temp9 + 0x20;
            var var10 = memory[var5:var5 + 0x20];
            var var9 = var5 + 0x20;
            var var11 = var10;
            var var12 = var8;
            var var13 = var9;
            var var14 = 0x00;
        
            if (var14 >= var11) {
            label_1C9F:
                var temp10 = var10;
                var8 = temp10 + var8;
                var9 = temp10 & 0x1f;
            
                if (!var9) {
                    var5 = var8;
                    var6 = 0x00;
                    var7 = memory[0x40:0x60];
                    var8 = var5 - var7;
                    var9 = var7;
                    var10 = 0x00;
                    var11 = var3;
                
                    if (!address(var11).code.length) { revert(memory[0x00:0x00]); }
                
                label_1CEA:
                    var temp11;
                    temp11, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]);
                
                    if (!temp11) { revert(memory[0x00:0x00]); }
                
                    var2 = 0x73686974636f696e;
                
                    if (msg.value == var2) { goto label_0038; }
                
                    var3 = 0x1d19;
                    func_1DBD();
                    memory[0x021c:0x0220] = address(msg.sender).code[0x59:0x5d];
                    var2 = memory[0x0200:0x0220];
                    var3 = 0x1d30;
                    func_1DBD();
                    var temp12 = memory[0x40:0x60];
                    memory[temp12:temp12 + 0x20] = var2 * 0x0100000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                    var temp13 = memory[0x40:0x60];
                
                    if (keccak256(memory[temp13:temp13 + (temp12 + 0x04) - temp13]) == var0) { return; }
                
                label_0038:
                
                    if (var2 == 0x291c) {
                        var2 = 0x009b;
                        revert(memory[0x00:0x00]);
                    } else if (var1 == 0x64d98f6e) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        var2 = 0x00b0;
                        var2 = isSolved();
                        var temp14 = memory[0x40:0x60];
                        memory[temp14:temp14 + 0x20] = !!var2;
                        var temp15 = memory[0x40:0x60];
                        return memory[temp15:temp15 + (temp14 + 0x20) - temp15];
                    } else if (var1 == 0x6c54fcef) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        var2 = 0x0125;
                        var temp16 = msg.data[0x04:0x24] + 0x04;
                        var temp17 = msg.data[temp16:temp16 + 0x20];
                        var temp18 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp18 + (temp17 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp18:temp18 + 0x20] = temp17;
                        memory[temp18 + 0x20:temp18 + 0x20 + temp17] = msg.data[temp16 + 0x20:temp16 + 0x20 + temp17];
                        var3 = temp18;
                        func_02B5(var3);
                        stop();
                    } else if (var1 == 0x7430306c) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        var2 = 0x013a;
                        selfdestruct(0x00);
                    } else if (var1 == 0xb220f73c) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        var2 = 0x0197;
                        var temp19 = msg.data[0x04:0x24] + 0x04;
                        var temp20 = msg.data[temp19:temp19 + 0x20];
                        var temp21 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp21 + (temp20 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp21:temp21 + 0x20] = temp20;
                        memory[temp21 + 0x20:temp21 + 0x20 + temp20] = msg.data[temp19 + 0x20:temp19 + 0x20 + temp20];
                        var3 = temp21;
                        func_073D(var3);
                        stop();
                    } else if (var1 == 0xb4eff690) {
                        var2 = 0x01e9;
                        var temp22 = msg.data[0x04:0x24] + 0x04;
                        var temp23 = msg.data[temp22:temp22 + 0x20];
                        var temp24 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp24 + (temp23 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp24:temp24 + 0x20] = temp23;
                        memory[temp24 + 0x20:temp24 + 0x20 + temp23] = msg.data[temp22 + 0x20:temp22 + 0x20 + temp23];
                        var3 = temp24;
                        checkFlag(var3);
                        stop();
                    } else if (var1 == 0xd6385778) {
                        if (msg.value) { revert(memory[0x00:0x00]); }
                    
                        var2 = 0x0246;
                        var temp25 = msg.data[0x04:0x24] + 0x04;
                        var temp26 = msg.data[temp25:temp25 + 0x20];
                        var temp27 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp27 + (temp26 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp27:temp27 + 0x20] = temp26;
                        memory[temp27 + 0x20:temp27 + 0x20 + temp26] = msg.data[temp25 + 0x20:temp25 + 0x20 + temp26];
                        var3 = temp27;
                        func_1195(var3);
                        stop();
                    } else if (var1 == 0xf605fa57) {
                        var2 = 0x0298;
                        var temp28 = msg.data[0x04:0x24] + 0x04;
                        var temp29 = msg.data[temp28:temp28 + 0x20];
                        var temp30 = memory[0x40:0x60];
                        memory[0x40:0x60] = temp30 + (temp29 + 0x1f) / 0x20 * 0x20 + 0x20;
                        memory[temp30:temp30 + 0x20] = temp29;
                        memory[temp30 + 0x20:temp30 + 0x20 + temp29] = msg.data[temp28 + 0x20:temp28 + 0x20 + temp29];
                        var3 = temp30;
                        func_1869(var3);
                        stop();
                    } else { revert(memory[0x00:0x00]); }
                } else {
                    var temp31 = var9;
                    var temp32 = var8 - temp31;
                    memory[temp32:temp32 + 0x20] = ~(0x0100 ** (0x20 - temp31) - 0x01) & memory[temp32:temp32 + 0x20];
                    var5 = temp32 + 0x20;
                    var6 = 0x00;
                    var7 = memory[0x40:0x60];
                    var8 = var5 - var7;
                    var9 = var7;
                    var10 = 0x00;
                    var11 = var3;
                
                    if (address(var11).code.length) { goto label_1CEA; }
                    else { revert(memory[0x00:0x00]); }
                }
            } else {
            label_1C8D:
                var temp33 = var14;
                memory[var12 + temp33:var12 + temp33 + 0x20] = memory[var13 + temp33:var13 + temp33 + 0x20];
                var14 = temp33 + 0x20;
            
                if (var14 >= var11) { goto label_1C9F; }
                else { goto label_1C8D; }
            }
        } else {
        label_1B57:
            var3 = msg.value * 0x0100000000000000000000000000000000000000000000000000000000000000;
            var4 = arg0;
            var5 = var1;
        
            if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
        
            var temp34 = var4 + 0x20 + var5;
            memory[temp34:temp34 + 0x01] = byte((memory[temp34:temp34 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 ~ var3) & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0x00);
            var1 = var1 + 0x01;
        
            if (var1 >= memory[arg0:arg0 + 0x20]) { goto label_1C0F; }
            else { goto label_1B57; }
        }
    }
    
    function func_1DBD() {
        var var0 = 0x1dc6;
    }
}

Disassembly

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

label_000D:
	// Incoming jump from 0x000C, if not msg.data.length < 0x04
	// Inputs[1] { @000F  msg.data[0x00:0x20] }
	000D    60  PUSH1 0x00
	000F    35  CALLDATALOAD
	0010    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	002E    90  SWAP1
	002F    04  DIV
	0030    63  PUSH4 0xffffffff
	0035    16  AND
	0036    80  DUP1
	0037    63  PUSH4 0x5b61291c
	003C    14  EQ
	003D    61  PUSH2 0x0093
	0040    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0035  stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 }
	// Block ends with conditional jump to 0x0093, if 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000

label_0041:
	// Incoming jump from 0x0040, if not 0x291c == stack[-1]
	// Incoming jump from 0x0040, if not 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	// Inputs[1] { @0041  stack[-1] }
	0041    80  DUP1
	0042    63  PUSH4 0x64d98f6e
	0047    14  EQ
	0048    61  PUSH2 0x009d
	004B    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x009d, if 0x64d98f6e == stack[-1]

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

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

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

label_006D:
	// Incoming jump from 0x006C, if not 0xb220f73c == stack[-1]
	// Inputs[1] { @006D  stack[-1] }
	006D    80  DUP1
	006E    63  PUSH4 0xb4eff690
	0073    14  EQ
	0074    61  PUSH2 0x0199
	0077    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0199, if 0xb4eff690 == stack[-1]

label_0078:
	// Incoming jump from 0x0077, if not 0xb4eff690 == stack[-1]
	// Inputs[1] { @0078  stack[-1] }
	0078    80  DUP1
	0079    63  PUSH4 0xd6385778
	007E    14  EQ
	007F    61  PUSH2 0x01eb
	0082    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01eb, if 0xd6385778 == stack[-1]

label_0083:
	// Incoming jump from 0x0082, if not 0xd6385778 == stack[-1]
	// Inputs[1] { @0083  stack[-1] }
	0083    80  DUP1
	0084    63  PUSH4 0xf605fa57
	0089    14  EQ
	008A    61  PUSH2 0x0248
	008D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0248, if 0xf605fa57 == stack[-1]

label_008E:
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Incoming jump from 0x008D, if not 0xf605fa57 == stack[-1]
	// Inputs[1] { @0092  memory[0x00:0x00] }
	008E    5B  JUMPDEST
	008F    60  PUSH1 0x00
	0091    80  DUP1
	0092    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0092  revert(memory[0x00:0x00]); }
	// Block terminates

label_0093:
	// Incoming jump from 0x0040, if 0x291c == stack[-1]
	// Incoming jump from 0x0040, if 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	0093    5B  JUMPDEST
	0094    61  PUSH2 0x009b
	0097    61  PUSH2 0x029a
	009A    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0094  stack[0] = 0x009b }
	// Block ends with unconditional jump to 0x029a

	009B    5B    JUMPDEST
	009C    00    *STOP
label_009D:
	// Incoming jump from 0x004B, if 0x64d98f6e == stack[-1]
	// Inputs[1] { @009E  msg.value }
	009D    5B  JUMPDEST
	009E    34  CALLVALUE
	009F    15  ISZERO
	00A0    61  PUSH2 0x00a8
	00A3    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00a8, if !msg.value

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

label_00A8:
	// Incoming jump from 0x00A3, if !msg.value
	00A8    5B  JUMPDEST
	00A9    61  PUSH2 0x00b0
	00AC    61  PUSH2 0x029f
	00AF    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @00A9  stack[0] = 0x00b0 }
	// Block ends with call to 0x029f, returns to 0x00B0

label_00B0:
	// Incoming return from call to 0x029F at 0x00AF
	// Inputs[4]
	// {
	//     @00B3  memory[0x40:0x60]
	//     @00B5  stack[-1]
	//     @00C4  memory[0x40:0x60]
	//     @00C9  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	00B0    5B  JUMPDEST
	00B1    60  PUSH1 0x40
	00B3    51  MLOAD
	00B4    80  DUP1
	00B5    82  DUP3
	00B6    15  ISZERO
	00B7    15  ISZERO
	00B8    15  ISZERO
	00B9    15  ISZERO
	00BA    81  DUP2
	00BB    52  MSTORE
	00BC    60  PUSH1 0x20
	00BE    01  ADD
	00BF    91  SWAP2
	00C0    50  POP
	00C1    50  POP
	00C2    60  PUSH1 0x40
	00C4    51  MLOAD
	00C5    80  DUP1
	00C6    91  SWAP2
	00C7    03  SUB
	00C8    90  SWAP1
	00C9    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @00BB  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1]
	//     @00C9  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

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

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

label_00D5:
	// Incoming jump from 0x00D0, if !msg.value
	// Inputs[4]
	// {
	//     @00DD  msg.data[0x04:0x24]
	//     @00E6  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @00FC  memory[0x40:0x60]
	//     @0113  msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	00D5    5B  JUMPDEST
	00D6    61  PUSH2 0x0125
	00D9    60  PUSH1 0x04
	00DB    80  DUP1
	00DC    80  DUP1
	00DD    35  CALLDATALOAD
	00DE    90  SWAP1
	00DF    60  PUSH1 0x20
	00E1    01  ADD
	00E2    90  SWAP1
	00E3    82  DUP3
	00E4    01  ADD
	00E5    80  DUP1
	00E6    35  CALLDATALOAD
	00E7    90  SWAP1
	00E8    60  PUSH1 0x20
	00EA    01  ADD
	00EB    90  SWAP1
	00EC    80  DUP1
	00ED    80  DUP1
	00EE    60  PUSH1 0x1f
	00F0    01  ADD
	00F1    60  PUSH1 0x20
	00F3    80  DUP1
	00F4    91  SWAP2
	00F5    04  DIV
	00F6    02  MUL
	00F7    60  PUSH1 0x20
	00F9    01  ADD
	00FA    60  PUSH1 0x40
	00FC    51  MLOAD
	00FD    90  SWAP1
	00FE    81  DUP2
	00FF    01  ADD
	0100    60  PUSH1 0x40
	0102    52  MSTORE
	0103    80  DUP1
	0104    93  SWAP4
	0105    92  SWAP3
	0106    91  SWAP2
	0107    90  SWAP1
	0108    81  DUP2
	0109    81  DUP2
	010A    52  MSTORE
	010B    60  PUSH1 0x20
	010D    01  ADD
	010E    83  DUP4
	010F    83  DUP4
	0110    80  DUP1
	0111    82  DUP3
	0112    84  DUP5
	0113    37  CALLDATACOPY
	0114    82  DUP3
	0115    01  ADD
	0116    91  SWAP2
	0117    50  POP
	0118    50  POP
	0119    50  POP
	011A    50  POP
	011B    50  POP
	011C    50  POP
	011D    91  SWAP2
	011E    90  SWAP1
	011F    50  POP
	0120    50  POP
	0121    61  PUSH2 0x02b5
	0124    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @00D6  stack[0] = 0x0125
	//     @0102  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20
	//     @010A  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @0113  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @011D  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x02b5, returns to 0x0125

label_0125:
	// Incoming return from call to 0x02B5 at 0x0124
	0125    5B  JUMPDEST
	0126    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0126  stop(); }
	// Block terminates

label_0127:
	// Incoming jump from 0x0061, if 0x7430306c == stack[-1]
	// Inputs[1] { @0128  msg.value }
	0127    5B  JUMPDEST
	0128    34  CALLVALUE
	0129    15  ISZERO
	012A    61  PUSH2 0x0132
	012D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0132, if !msg.value

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

label_0132:
	// Incoming jump from 0x012D, if !msg.value
	0132    5B  JUMPDEST
	0133    61  PUSH2 0x013a
	0136    61  PUSH2 0x0739
	0139    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0133  stack[0] = 0x013a }
	// Block ends with unconditional jump to 0x0739

	013A    5B    JUMPDEST
	013B    00    *STOP
label_013C:
	// Incoming jump from 0x006C, if 0xb220f73c == stack[-1]
	// Inputs[1] { @013D  msg.value }
	013C    5B  JUMPDEST
	013D    34  CALLVALUE
	013E    15  ISZERO
	013F    61  PUSH2 0x0147
	0142    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0147, if !msg.value

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

label_0147:
	// Incoming jump from 0x0142, if !msg.value
	// Inputs[4]
	// {
	//     @014F  msg.data[0x04:0x24]
	//     @0158  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @016E  memory[0x40:0x60]
	//     @0185  msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	0147    5B  JUMPDEST
	0148    61  PUSH2 0x0197
	014B    60  PUSH1 0x04
	014D    80  DUP1
	014E    80  DUP1
	014F    35  CALLDATALOAD
	0150    90  SWAP1
	0151    60  PUSH1 0x20
	0153    01  ADD
	0154    90  SWAP1
	0155    82  DUP3
	0156    01  ADD
	0157    80  DUP1
	0158    35  CALLDATALOAD
	0159    90  SWAP1
	015A    60  PUSH1 0x20
	015C    01  ADD
	015D    90  SWAP1
	015E    80  DUP1
	015F    80  DUP1
	0160    60  PUSH1 0x1f
	0162    01  ADD
	0163    60  PUSH1 0x20
	0165    80  DUP1
	0166    91  SWAP2
	0167    04  DIV
	0168    02  MUL
	0169    60  PUSH1 0x20
	016B    01  ADD
	016C    60  PUSH1 0x40
	016E    51  MLOAD
	016F    90  SWAP1
	0170    81  DUP2
	0171    01  ADD
	0172    60  PUSH1 0x40
	0174    52  MSTORE
	0175    80  DUP1
	0176    93  SWAP4
	0177    92  SWAP3
	0178    91  SWAP2
	0179    90  SWAP1
	017A    81  DUP2
	017B    81  DUP2
	017C    52  MSTORE
	017D    60  PUSH1 0x20
	017F    01  ADD
	0180    83  DUP4
	0181    83  DUP4
	0182    80  DUP1
	0183    82  DUP3
	0184    84  DUP5
	0185    37  CALLDATACOPY
	0186    82  DUP3
	0187    01  ADD
	0188    91  SWAP2
	0189    50  POP
	018A    50  POP
	018B    50  POP
	018C    50  POP
	018D    50  POP
	018E    50  POP
	018F    91  SWAP2
	0190    90  SWAP1
	0191    50  POP
	0192    50  POP
	0193    61  PUSH2 0x073d
	0196    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @0148  stack[0] = 0x0197
	//     @0174  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20
	//     @017C  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @0185  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @018F  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x073d, returns to 0x0197

label_0197:
	// Incoming return from call to 0x073D at 0x0196
	0197    5B  JUMPDEST
	0198    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0198  stop(); }
	// Block terminates

label_0199:
	// Incoming jump from 0x0077, if 0xb4eff690 == stack[-1]
	// Inputs[4]
	// {
	//     @01A1  msg.data[0x04:0x24]
	//     @01AA  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @01C0  memory[0x40:0x60]
	//     @01D7  msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	0199    5B  JUMPDEST
	019A    61  PUSH2 0x01e9
	019D    60  PUSH1 0x04
	019F    80  DUP1
	01A0    80  DUP1
	01A1    35  CALLDATALOAD
	01A2    90  SWAP1
	01A3    60  PUSH1 0x20
	01A5    01  ADD
	01A6    90  SWAP1
	01A7    82  DUP3
	01A8    01  ADD
	01A9    80  DUP1
	01AA    35  CALLDATALOAD
	01AB    90  SWAP1
	01AC    60  PUSH1 0x20
	01AE    01  ADD
	01AF    90  SWAP1
	01B0    80  DUP1
	01B1    80  DUP1
	01B2    60  PUSH1 0x1f
	01B4    01  ADD
	01B5    60  PUSH1 0x20
	01B7    80  DUP1
	01B8    91  SWAP2
	01B9    04  DIV
	01BA    02  MUL
	01BB    60  PUSH1 0x20
	01BD    01  ADD
	01BE    60  PUSH1 0x40
	01C0    51  MLOAD
	01C1    90  SWAP1
	01C2    81  DUP2
	01C3    01  ADD
	01C4    60  PUSH1 0x40
	01C6    52  MSTORE
	01C7    80  DUP1
	01C8    93  SWAP4
	01C9    92  SWAP3
	01CA    91  SWAP2
	01CB    90  SWAP1
	01CC    81  DUP2
	01CD    81  DUP2
	01CE    52  MSTORE
	01CF    60  PUSH1 0x20
	01D1    01  ADD
	01D2    83  DUP4
	01D3    83  DUP4
	01D4    80  DUP1
	01D5    82  DUP3
	01D6    84  DUP5
	01D7    37  CALLDATACOPY
	01D8    82  DUP3
	01D9    01  ADD
	01DA    91  SWAP2
	01DB    50  POP
	01DC    50  POP
	01DD    50  POP
	01DE    50  POP
	01DF    50  POP
	01E0    50  POP
	01E1    91  SWAP2
	01E2    90  SWAP1
	01E3    50  POP
	01E4    50  POP
	01E5    61  PUSH2 0x0bcc
	01E8    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @019A  stack[0] = 0x01e9
	//     @01C6  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20
	//     @01CE  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @01D7  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @01E1  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x0bcc, returns to 0x01E9

label_01E9:
	// Incoming return from call to 0x0BCC at 0x01E8
	01E9    5B  JUMPDEST
	01EA    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @01EA  stop(); }
	// Block terminates

label_01EB:
	// Incoming jump from 0x0082, if 0xd6385778 == stack[-1]
	// Inputs[1] { @01EC  msg.value }
	01EB    5B  JUMPDEST
	01EC    34  CALLVALUE
	01ED    15  ISZERO
	01EE    61  PUSH2 0x01f6
	01F1    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x01f6, if !msg.value

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

label_01F6:
	// Incoming jump from 0x01F1, if !msg.value
	// Inputs[4]
	// {
	//     @01FE  msg.data[0x04:0x24]
	//     @0207  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @021D  memory[0x40:0x60]
	//     @0234  msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	01F6    5B  JUMPDEST
	01F7    61  PUSH2 0x0246
	01FA    60  PUSH1 0x04
	01FC    80  DUP1
	01FD    80  DUP1
	01FE    35  CALLDATALOAD
	01FF    90  SWAP1
	0200    60  PUSH1 0x20
	0202    01  ADD
	0203    90  SWAP1
	0204    82  DUP3
	0205    01  ADD
	0206    80  DUP1
	0207    35  CALLDATALOAD
	0208    90  SWAP1
	0209    60  PUSH1 0x20
	020B    01  ADD
	020C    90  SWAP1
	020D    80  DUP1
	020E    80  DUP1
	020F    60  PUSH1 0x1f
	0211    01  ADD
	0212    60  PUSH1 0x20
	0214    80  DUP1
	0215    91  SWAP2
	0216    04  DIV
	0217    02  MUL
	0218    60  PUSH1 0x20
	021A    01  ADD
	021B    60  PUSH1 0x40
	021D    51  MLOAD
	021E    90  SWAP1
	021F    81  DUP2
	0220    01  ADD
	0221    60  PUSH1 0x40
	0223    52  MSTORE
	0224    80  DUP1
	0225    93  SWAP4
	0226    92  SWAP3
	0227    91  SWAP2
	0228    90  SWAP1
	0229    81  DUP2
	022A    81  DUP2
	022B    52  MSTORE
	022C    60  PUSH1 0x20
	022E    01  ADD
	022F    83  DUP4
	0230    83  DUP4
	0231    80  DUP1
	0232    82  DUP3
	0233    84  DUP5
	0234    37  CALLDATACOPY
	0235    82  DUP3
	0236    01  ADD
	0237    91  SWAP2
	0238    50  POP
	0239    50  POP
	023A    50  POP
	023B    50  POP
	023C    50  POP
	023D    50  POP
	023E    91  SWAP2
	023F    90  SWAP1
	0240    50  POP
	0241    50  POP
	0242    61  PUSH2 0x1195
	0245    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @01F7  stack[0] = 0x0246
	//     @0223  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20
	//     @022B  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @0234  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @023E  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x1195, returns to 0x0246

label_0246:
	// Incoming return from call to 0x1195 at 0x0245
	0246    5B  JUMPDEST
	0247    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0247  stop(); }
	// Block terminates

label_0248:
	// Incoming jump from 0x008D, if 0xf605fa57 == stack[-1]
	// Inputs[4]
	// {
	//     @0250  msg.data[0x04:0x24]
	//     @0259  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @026F  memory[0x40:0x60]
	//     @0286  msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	0248    5B  JUMPDEST
	0249    61  PUSH2 0x0298
	024C    60  PUSH1 0x04
	024E    80  DUP1
	024F    80  DUP1
	0250    35  CALLDATALOAD
	0251    90  SWAP1
	0252    60  PUSH1 0x20
	0254    01  ADD
	0255    90  SWAP1
	0256    82  DUP3
	0257    01  ADD
	0258    80  DUP1
	0259    35  CALLDATALOAD
	025A    90  SWAP1
	025B    60  PUSH1 0x20
	025D    01  ADD
	025E    90  SWAP1
	025F    80  DUP1
	0260    80  DUP1
	0261    60  PUSH1 0x1f
	0263    01  ADD
	0264    60  PUSH1 0x20
	0266    80  DUP1
	0267    91  SWAP2
	0268    04  DIV
	0269    02  MUL
	026A    60  PUSH1 0x20
	026C    01  ADD
	026D    60  PUSH1 0x40
	026F    51  MLOAD
	0270    90  SWAP1
	0271    81  DUP2
	0272    01  ADD
	0273    60  PUSH1 0x40
	0275    52  MSTORE
	0276    80  DUP1
	0277    93  SWAP4
	0278    92  SWAP3
	0279    91  SWAP2
	027A    90  SWAP1
	027B    81  DUP2
	027C    81  DUP2
	027D    52  MSTORE
	027E    60  PUSH1 0x20
	0280    01  ADD
	0281    83  DUP4
	0282    83  DUP4
	0283    80  DUP1
	0284    82  DUP3
	0285    84  DUP5
	0286    37  CALLDATACOPY
	0287    82  DUP3
	0288    01  ADD
	0289    91  SWAP2
	028A    50  POP
	028B    50  POP
	028C    50  POP
	028D    50  POP
	028E    50  POP
	028F    50  POP
	0290    91  SWAP2
	0291    90  SWAP1
	0292    50  POP
	0293    50  POP
	0294    61  PUSH2 0x1869
	0297    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @0249  stack[0] = 0x0298
	//     @0275  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20
	//     @027D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @0286  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @0290  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x1869, returns to 0x0298

label_0298:
	// Incoming return from call to 0x1869 at 0x0297
	0298    5B  JUMPDEST
	0299    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0299  stop(); }
	// Block terminates

label_029A:
	// Incoming jump from 0x009A
	// Inputs[1] { @029E  memory[0x00:0x00] }
	029A    5B  JUMPDEST
	029B    60  PUSH1 0x00
	029D    80  DUP1
	029E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @029E  revert(memory[0x00:0x00]); }
	// Block terminates

label_029F:
	// Incoming call from 0x00AF, returns to 0x00B0
	// Inputs[2]
	// {
	//     @02A6  storage[0x00]
	//     @02B3  stack[-1]
	// }
	029F    5B  JUMPDEST
	02A0    60  PUSH1 0x00
	02A2    80  DUP1
	02A3    60  PUSH1 0x00
	02A5    90  SWAP1
	02A6    54  SLOAD
	02A7    90  SWAP1
	02A8    61  PUSH2 0x0100
	02AB    0A  EXP
	02AC    90  SWAP1
	02AD    04  DIV
	02AE    60  PUSH1 0xff
	02B0    16  AND
	02B1    90  SWAP1
	02B2    50  POP
	02B3    90  SWAP1
	02B4    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @02B3  stack[-1] = 0xff & storage[0x00] / 0x0100 ** 0x00 }
	// Block ends with unconditional jump to stack[-1]

label_02B5:
	// Incoming call from 0x0124, returns to 0x0125
	// Inputs[1] { @02BD  block.timestamp }
	02B5    5B  JUMPDEST
	02B6    60  PUSH1 0x00
	02B8    63  PUSH4 0x5ad92d80
	02BD    42  TIMESTAMP
	02BE    14  EQ
	02BF    15  ISZERO
	02C0    15  ISZERO
	02C1    61  PUSH2 0x02c8
	02C4    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @02B6  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x02c8, if !!(block.timestamp == 0x5ad92d80)

label_02C5:
	// Incoming jump from 0x02C4, if not !!(block.timestamp == 0x5ad92d80)
	02C5    60  PUSH1 0x38
	02C7    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_02C8:
	// Incoming jump from 0x02C4, if !!(block.timestamp == 0x5ad92d80)
	02C8    5B  JUMPDEST
	02C9    61  PUSH2 0x02d0
	02CC    61  PUSH2 0x1dbd
	02CF    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @02C9  stack[0] = 0x02d0 }
	// Block ends with call to 0x1dbd, returns to 0x02D0

label_02D0:
	// Incoming return from call to 0x1DBD at 0x02CF
	// Inputs[2]
	// {
	//     @02D1  stack[-2]
	//     @02D5  memory[stack[-2]:stack[-2] + 0x20]
	// }
	02D0    5B  JUMPDEST
	02D1    81  DUP2
	02D2    60  PUSH1 0x12
	02D4    81  DUP2
	02D5    51  MLOAD
	02D6    81  DUP2
	02D7    10  LT
	02D8    15  ISZERO
	02D9    15  ISZERO
	02DA    61  PUSH2 0x02df
	02DD    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @02D1  stack[0] = stack[-2]
	//     @02D2  stack[1] = 0x12
	// }
	// Block ends with conditional jump to 0x02df, if !!(0x12 < memory[stack[-2]:stack[-2] + 0x20])

label_02DE:
	// Incoming jump from 0x02DD, if not !!(0x12 < memory[stack[-2]:stack[-2] + 0x20])
	02DE    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @02DE  assert(); }
	// Block terminates

label_02DF:
	// Incoming jump from 0x02DD, if !!(0x12 < memory[stack[-2]:stack[-2] + 0x20])
	// Inputs[6]
	// {
	//     @02E0  stack[-2]
	//     @02E0  stack[-1]
	//     @02E5  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @034E  stack[-3]
	//     @0352  stack[-4]
	//     @0356  memory[stack[-4]:stack[-4] + 0x20]
	// }
	02DF    5B  JUMPDEST
	02E0    90  SWAP1
	02E1    60  PUSH1 0x20
	02E3    01  ADD
	02E4    01  ADD
	02E5    51  MLOAD
	02E6    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0307    90  SWAP1
	0308    04  DIV
	0309    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	032A    02  MUL
	032B    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	034C    90  SWAP1
	034D    04  DIV
	034E    90  SWAP1
	034F    50  POP
	0350    60  PUSH1 0x08
	0352    82  DUP3
	0353    60  PUSH1 0x13
	0355    81  DUP2
	0356    51  MLOAD
	0357    81  DUP2
	0358    10  LT
	0359    15  ISZERO
	035A    15  ISZERO
	035B    61  PUSH2 0x0360
	035E    57  *JUMPI
	// Stack delta = +1
	// Outputs[4]
	// {
	//     @034E  stack[-3] = (0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000
	//     @0350  stack[-2] = 0x08
	//     @0352  stack[-1] = stack[-4]
	//     @0353  stack[0] = 0x13
	// }
	// Block ends with conditional jump to 0x0360, if !!(0x13 < memory[stack[-4]:stack[-4] + 0x20])

label_035F:
	// Incoming jump from 0x035E, if not !!(0x13 < memory[stack[-4]:stack[-4] + 0x20])
	035F    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @035F  assert(); }
	// Block terminates

label_0360:
	// Incoming jump from 0x035E, if !!(0x13 < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[7]
	// {
	//     @0361  stack[-2]
	//     @0361  stack[-1]
	//     @0366  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @03CF  stack[-3]
	//     @03D4  stack[-4]
	//     @03DA  stack[-5]
	//     @03DE  memory[stack[-5]:stack[-5] + 0x20]
	// }
	0360    5B  JUMPDEST
	0361    90  SWAP1
	0362    60  PUSH1 0x20
	0364    01  ADD
	0365    01  ADD
	0366    51  MLOAD
	0367    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0388    90  SWAP1
	0389    04  DIV
	038A    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	03AB    02  MUL
	03AC    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	03CD    90  SWAP1
	03CE    04  DIV
	03CF    90  SWAP1
	03D0    60  PUSH1 0x02
	03D2    0A  EXP
	03D3    02  MUL
	03D4    81  DUP2
	03D5    01  ADD
	03D6    90  SWAP1
	03D7    50  POP
	03D8    60  PUSH1 0x10
	03DA    82  DUP3
	03DB    60  PUSH1 0x14
	03DD    81  DUP2
	03DE    51  MLOAD
	03DF    81  DUP2
	03E0    10  LT
	03E1    15  ISZERO
	03E2    15  ISZERO
	03E3    61  PUSH2 0x03e8
	03E6    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @03D6  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @03D8  stack[-3] = 0x10
	//     @03DA  stack[-2] = stack[-5]
	//     @03DB  stack[-1] = 0x14
	// }
	// Block ends with conditional jump to 0x03e8, if !!(0x14 < memory[stack[-5]:stack[-5] + 0x20])

label_03E7:
	// Incoming jump from 0x03E6, if not !!(0x14 < memory[stack[-5]:stack[-5] + 0x20])
	03E7    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @03E7  assert(); }
	// Block terminates

label_03E8:
	// Incoming jump from 0x03E6, if !!(0x14 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[7]
	// {
	//     @03E9  stack[-1]
	//     @03E9  stack[-2]
	//     @03EE  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0457  stack[-3]
	//     @045C  stack[-4]
	//     @0462  stack[-5]
	//     @0466  memory[stack[-5]:stack[-5] + 0x20]
	// }
	03E8    5B  JUMPDEST
	03E9    90  SWAP1
	03EA    60  PUSH1 0x20
	03EC    01  ADD
	03ED    01  ADD
	03EE    51  MLOAD
	03EF    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0410    90  SWAP1
	0411    04  DIV
	0412    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0433    02  MUL
	0434    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0455    90  SWAP1
	0456    04  DIV
	0457    90  SWAP1
	0458    60  PUSH1 0x02
	045A    0A  EXP
	045B    02  MUL
	045C    81  DUP2
	045D    01  ADD
	045E    90  SWAP1
	045F    50  POP
	0460    60  PUSH1 0x18
	0462    82  DUP3
	0463    60  PUSH1 0x15
	0465    81  DUP2
	0466    51  MLOAD
	0467    81  DUP2
	0468    10  LT
	0469    15  ISZERO
	046A    15  ISZERO
	046B    61  PUSH2 0x0470
	046E    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @045E  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @0460  stack[-3] = 0x18
	//     @0462  stack[-2] = stack[-5]
	//     @0463  stack[-1] = 0x15
	// }
	// Block ends with conditional jump to 0x0470, if !!(0x15 < memory[stack[-5]:stack[-5] + 0x20])

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

label_0470:
	// Incoming jump from 0x046E, if !!(0x15 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[7]
	// {
	//     @0471  stack[-1]
	//     @0471  stack[-2]
	//     @0476  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @04DF  stack[-3]
	//     @04E4  stack[-4]
	//     @04EA  stack[-5]
	//     @04EE  memory[stack[-5]:stack[-5] + 0x20]
	// }
	0470    5B  JUMPDEST
	0471    90  SWAP1
	0472    60  PUSH1 0x20
	0474    01  ADD
	0475    01  ADD
	0476    51  MLOAD
	0477    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0498    90  SWAP1
	0499    04  DIV
	049A    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	04BB    02  MUL
	04BC    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	04DD    90  SWAP1
	04DE    04  DIV
	04DF    90  SWAP1
	04E0    60  PUSH1 0x02
	04E2    0A  EXP
	04E3    02  MUL
	04E4    81  DUP2
	04E5    01  ADD
	04E6    90  SWAP1
	04E7    50  POP
	04E8    60  PUSH1 0x20
	04EA    82  DUP3
	04EB    60  PUSH1 0x16
	04ED    81  DUP2
	04EE    51  MLOAD
	04EF    81  DUP2
	04F0    10  LT
	04F1    15  ISZERO
	04F2    15  ISZERO
	04F3    61  PUSH2 0x04f8
	04F6    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @04E6  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @04E8  stack[-3] = 0x20
	//     @04EA  stack[-2] = stack[-5]
	//     @04EB  stack[-1] = 0x16
	// }
	// Block ends with conditional jump to 0x04f8, if !!(0x16 < memory[stack[-5]:stack[-5] + 0x20])

label_04F7:
	// Incoming jump from 0x04F6, if not !!(0x16 < memory[stack[-5]:stack[-5] + 0x20])
	04F7    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @04F7  assert(); }
	// Block terminates

label_04F8:
	// Incoming jump from 0x04F6, if !!(0x16 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[7]
	// {
	//     @04F9  stack[-1]
	//     @04F9  stack[-2]
	//     @04FE  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0567  stack[-3]
	//     @056C  stack[-4]
	//     @0572  stack[-5]
	//     @0576  memory[stack[-5]:stack[-5] + 0x20]
	// }
	04F8    5B  JUMPDEST
	04F9    90  SWAP1
	04FA    60  PUSH1 0x20
	04FC    01  ADD
	04FD    01  ADD
	04FE    51  MLOAD
	04FF    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0520    90  SWAP1
	0521    04  DIV
	0522    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0543    02  MUL
	0544    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0565    90  SWAP1
	0566    04  DIV
	0567    90  SWAP1
	0568    60  PUSH1 0x02
	056A    0A  EXP
	056B    02  MUL
	056C    81  DUP2
	056D    01  ADD
	056E    90  SWAP1
	056F    50  POP
	0570    60  PUSH1 0x28
	0572    82  DUP3
	0573    60  PUSH1 0x17
	0575    81  DUP2
	0576    51  MLOAD
	0577    81  DUP2
	0578    10  LT
	0579    15  ISZERO
	057A    15  ISZERO
	057B    61  PUSH2 0x0580
	057E    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @056E  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @0570  stack[-3] = 0x28
	//     @0572  stack[-2] = stack[-5]
	//     @0573  stack[-1] = 0x17
	// }
	// Block ends with conditional jump to 0x0580, if !!(0x17 < memory[stack[-5]:stack[-5] + 0x20])

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

label_0580:
	// Incoming jump from 0x057E, if !!(0x17 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[7]
	// {
	//     @0581  stack[-1]
	//     @0581  stack[-2]
	//     @0586  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @05EF  stack[-3]
	//     @05F4  stack[-4]
	//     @05FA  stack[-5]
	//     @05FE  memory[stack[-5]:stack[-5] + 0x20]
	// }
	0580    5B  JUMPDEST
	0581    90  SWAP1
	0582    60  PUSH1 0x20
	0584    01  ADD
	0585    01  ADD
	0586    51  MLOAD
	0587    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	05A8    90  SWAP1
	05A9    04  DIV
	05AA    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	05CB    02  MUL
	05CC    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	05ED    90  SWAP1
	05EE    04  DIV
	05EF    90  SWAP1
	05F0    60  PUSH1 0x02
	05F2    0A  EXP
	05F3    02  MUL
	05F4    81  DUP2
	05F5    01  ADD
	05F6    90  SWAP1
	05F7    50  POP
	05F8    60  PUSH1 0x30
	05FA    82  DUP3
	05FB    60  PUSH1 0x18
	05FD    81  DUP2
	05FE    51  MLOAD
	05FF    81  DUP2
	0600    10  LT
	0601    15  ISZERO
	0602    15  ISZERO
	0603    61  PUSH2 0x0608
	0606    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @05F6  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @05F8  stack[-3] = 0x30
	//     @05FA  stack[-2] = stack[-5]
	//     @05FB  stack[-1] = 0x18
	// }
	// Block ends with conditional jump to 0x0608, if !!(0x18 < memory[stack[-5]:stack[-5] + 0x20])

label_0607:
	// Incoming jump from 0x0606, if not !!(0x18 < memory[stack[-5]:stack[-5] + 0x20])
	0607    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0607  assert(); }
	// Block terminates

label_0608:
	// Incoming jump from 0x0606, if !!(0x18 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[7]
	// {
	//     @0609  stack[-2]
	//     @0609  stack[-1]
	//     @060E  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0677  stack[-3]
	//     @067C  stack[-4]
	//     @0682  stack[-5]
	//     @0686  memory[stack[-5]:stack[-5] + 0x20]
	// }
	0608    5B  JUMPDEST
	0609    90  SWAP1
	060A    60  PUSH1 0x20
	060C    01  ADD
	060D    01  ADD
	060E    51  MLOAD
	060F    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0630    90  SWAP1
	0631    04  DIV
	0632    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0653    02  MUL
	0654    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0675    90  SWAP1
	0676    04  DIV
	0677    90  SWAP1
	0678    60  PUSH1 0x02
	067A    0A  EXP
	067B    02  MUL
	067C    81  DUP2
	067D    01  ADD
	067E    90  SWAP1
	067F    50  POP
	0680    60  PUSH1 0x38
	0682    82  DUP3
	0683    60  PUSH1 0x19
	0685    81  DUP2
	0686    51  MLOAD
	0687    81  DUP2
	0688    10  LT
	0689    15  ISZERO
	068A    15  ISZERO
	068B    61  PUSH2 0x0690
	068E    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @067E  stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @0680  stack[-3] = 0x38
	//     @0682  stack[-2] = stack[-5]
	//     @0683  stack[-1] = 0x19
	// }
	// Block ends with conditional jump to 0x0690, if !!(0x19 < memory[stack[-5]:stack[-5] + 0x20])

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

label_0690:
	// Incoming jump from 0x068E, if !!(0x19 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[8]
	// {
	//     @0691  stack[-2]
	//     @0691  stack[-1]
	//     @0696  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @06FF  stack[-3]
	//     @0704  stack[-4]
	//     @0708  msg.value
	//     @0709  msg.gas
	//     @0711  tx.gasprice
	// }
	0690    5B  JUMPDEST
	0691    90  SWAP1
	0692    60  PUSH1 0x20
	0694    01  ADD
	0695    01  ADD
	0696    51  MLOAD
	0697    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	06B8    90  SWAP1
	06B9    04  DIV
	06BA    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	06DB    02  MUL
	06DC    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	06FD    90  SWAP1
	06FE    04  DIV
	06FF    90  SWAP1
	0700    60  PUSH1 0x02
	0702    0A  EXP
	0703    02  MUL
	0704    81  DUP2
	0705    01  ADD
	0706    90  SWAP1
	0707    50  POP
	0708    34  CALLVALUE
	0709    5A  GAS
	070A    82  DUP3
	070B    02  MUL
	070C    02  MUL
	070D    81  DUP2
	070E    01  ADD
	070F    90  SWAP1
	0710    50  POP
	0711    3A  GASPRICE
	0712    81  DUP2
	0713    02  MUL
	0714    90  SWAP1
	0715    50  POP
	0716    61  PUSH2 0x071d
	0719    61  PUSH2 0x1dbd
	071C    56  *JUMP
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @0714  stack[-4] = (stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) + (stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)) * msg.gas * msg.value) * tx.gasprice
	//     @0716  stack[-3] = 0x071d
	// }
	// Block ends with call to 0x1dbd, returns to 0x071D

label_071D:
	// Incoming return from call to 0x1DBD at 0x071C
	// Inputs[1] { @071E  stack[-1] }
	071D    5B  JUMPDEST
	071E    80  DUP1
	071F    6A  PUSH11 0x02f0c798885c9f2975b114
	072B    14  EQ
	072C    15  ISZERO
	072D    15  ISZERO
	072E    61  PUSH2 0x0735
	0731    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0735, if !!(0x02f0c798885c9f2975b114 == stack[-1])

label_0732:
	// Incoming jump from 0x0731, if not !!(0x02f0c798885c9f2975b114 == stack[-1])
	0732    60  PUSH1 0x38
	0734    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0735:
	// Incoming jump from 0x0731, if !!(0x02f0c798885c9f2975b114 == stack[-1])
	// Inputs[1] { @0738  stack[-3] }
	0735    5B  JUMPDEST
	0736    50  POP
	0737    50  POP
	0738    56  *JUMP
	// Stack delta = -3
	// Block ends with unconditional jump to stack[-3]

label_0739:
	// Incoming jump from 0x0139
	0739    5B  JUMPDEST
	073A    60  PUSH1 0x00
	073C    FF  *SELFDESTRUCT
	// Stack delta = +0
	// Outputs[1] { @073C  selfdestruct(0x00); }
	// Block terminates

label_073D:
	// Incoming call from 0x0196, returns to 0x0197
	// Inputs[2]
	// {
	//     @075F  stack[-1]
	//     @0763  memory[stack[-1]:stack[-1] + 0x20]
	// }
	073D    5B  JUMPDEST
	073E    7F  PUSH32 0x7500000000000000000000000000000000000000000000000000000000000000
	075F    81  DUP2
	0760    60  PUSH1 0x0d
	0762    81  DUP2
	0763    51  MLOAD
	0764    81  DUP2
	0765    10  LT
	0766    15  ISZERO
	0767    15  ISZERO
	0768    61  PUSH2 0x076d
	076B    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @073E  stack[0] = 0x7500000000000000000000000000000000000000000000000000000000000000
	//     @075F  stack[1] = stack[-1]
	//     @0760  stack[2] = 0x0d
	// }
	// Block ends with conditional jump to 0x076d, if !!(0x0d < memory[stack[-1]:stack[-1] + 0x20])

label_076C:
	// Incoming jump from 0x076B, if not !!(0x0d < memory[stack[-1]:stack[-1] + 0x20])
	076C    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @076C  assert(); }
	// Block terminates

label_076D:
	// Incoming jump from 0x076B, if !!(0x0d < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @076E  stack[-1]
	//     @076E  stack[-2]
	//     @0773  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @07DB  stack[-3]
	// }
	076D    5B  JUMPDEST
	076E    90  SWAP1
	076F    60  PUSH1 0x20
	0771    01  ADD
	0772    01  ADD
	0773    51  MLOAD
	0774    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0795    90  SWAP1
	0796    04  DIV
	0797    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	07B8    02  MUL
	07B9    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	07D9    19  NOT
	07DA    16  AND
	07DB    14  EQ
	07DC    15  ISZERO
	07DD    15  ISZERO
	07DE    61  PUSH2 0x07e5
	07E1    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x07e5, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_07E2:
	// Incoming jump from 0x07E1, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	07E2    60  PUSH1 0x38
	07E4    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_07E5:
	// Incoming jump from 0x07E1, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	07E5    5B  JUMPDEST
	07E6    61  PUSH2 0x07ed
	07E9    61  PUSH2 0x1dbd
	07EC    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @07E6  stack[0] = 0x07ed }
	// Block ends with call to 0x1dbd, returns to 0x07ED

label_07ED:
	// Incoming return from call to 0x1DBD at 0x07EC
	// Inputs[2]
	// {
	//     @0813  stack[-1]
	//     @0817  memory[stack[-1]:stack[-1] + 0x20]
	// }
	07ED    5B  JUMPDEST
	07EE    7F  PUSH32 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b
	080F    60  PUSH1 0x01
	0811    60  PUSH1 0x02
	0813    83  DUP4
	0814    60  PUSH1 0x0e
	0816    81  DUP2
	0817    51  MLOAD
	0818    81  DUP2
	0819    10  LT
	081A    15  ISZERO
	081B    15  ISZERO
	081C    61  PUSH2 0x0821
	081F    57  *JUMPI
	// Stack delta = +5
	// Outputs[5]
	// {
	//     @07EE  stack[0] = 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b
	//     @080F  stack[1] = 0x01
	//     @0811  stack[2] = 0x02
	//     @0813  stack[3] = stack[-1]
	//     @0814  stack[4] = 0x0e
	// }
	// Block ends with conditional jump to 0x0821, if !!(0x0e < memory[stack[-1]:stack[-1] + 0x20])

label_0820:
	// Incoming jump from 0x081F, if not !!(0x0e < memory[stack[-1]:stack[-1] + 0x20])
	0820    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0820  assert(); }
	// Block terminates

label_0821:
	// Incoming jump from 0x081F, if !!(0x0e < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[5]
	// {
	//     @0822  stack[-1]
	//     @0822  stack[-2]
	//     @0827  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @086D  stack[-6]
	//     @0871  memory[stack[-6]:stack[-6] + 0x20]
	// }
	0821    5B  JUMPDEST
	0822    90  SWAP1
	0823    60  PUSH1 0x20
	0825    01  ADD
	0826    01  ADD
	0827    51  MLOAD
	0828    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0849    90  SWAP1
	084A    04  DIV
	084B    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	086C    02  MUL
	086D    84  DUP5
	086E    60  PUSH1 0x0f
	0870    81  DUP2
	0871    51  MLOAD
	0872    81  DUP2
	0873    10  LT
	0874    15  ISZERO
	0875    15  ISZERO
	0876    61  PUSH2 0x087b
	0879    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @086C  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @086D  stack[-1] = stack[-6]
	//     @086E  stack[0] = 0x0f
	// }
	// Block ends with conditional jump to 0x087b, if !!(0x0f < memory[stack[-6]:stack[-6] + 0x20])

label_087A:
	// Incoming jump from 0x0879, if not !!(0x0f < memory[stack[-6]:stack[-6] + 0x20])
	087A    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @087A  assert(); }
	// Block terminates

label_087B:
	// Incoming jump from 0x0879, if !!(0x0f < memory[stack[-6]:stack[-6] + 0x20])
	// Inputs[5]
	// {
	//     @087C  stack[-2]
	//     @087C  stack[-1]
	//     @0881  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @08C7  stack[-7]
	//     @08CB  memory[stack[-7]:stack[-7] + 0x20]
	// }
	087B    5B  JUMPDEST
	087C    90  SWAP1
	087D    60  PUSH1 0x20
	087F    01  ADD
	0880    01  ADD
	0881    51  MLOAD
	0882    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	08A3    90  SWAP1
	08A4    04  DIV
	08A5    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	08C6    02  MUL
	08C7    85  DUP6
	08C8    60  PUSH1 0x10
	08CA    81  DUP2
	08CB    51  MLOAD
	08CC    81  DUP2
	08CD    10  LT
	08CE    15  ISZERO
	08CF    15  ISZERO
	08D0    61  PUSH2 0x08d5
	08D3    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @08C6  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @08C7  stack[-1] = stack[-7]
	//     @08C8  stack[0] = 0x10
	// }
	// Block ends with conditional jump to 0x08d5, if !!(0x10 < memory[stack[-7]:stack[-7] + 0x20])

label_08D4:
	// Incoming jump from 0x08D3, if not !!(0x10 < memory[stack[-7]:stack[-7] + 0x20])
	08D4    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @08D4  assert(); }
	// Block terminates

label_08D5:
	// Incoming jump from 0x08D3, if !!(0x10 < memory[stack[-7]:stack[-7] + 0x20])
	// Inputs[5]
	// {
	//     @08D6  stack[-1]
	//     @08D6  stack[-2]
	//     @08DB  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0921  stack[-8]
	//     @0925  memory[stack[-8]:stack[-8] + 0x20]
	// }
	08D5    5B  JUMPDEST
	08D6    90  SWAP1
	08D7    60  PUSH1 0x20
	08D9    01  ADD
	08DA    01  ADD
	08DB    51  MLOAD
	08DC    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	08FD    90  SWAP1
	08FE    04  DIV
	08FF    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0920    02  MUL
	0921    86  DUP7
	0922    60  PUSH1 0x11
	0924    81  DUP2
	0925    51  MLOAD
	0926    81  DUP2
	0927    10  LT
	0928    15  ISZERO
	0929    15  ISZERO
	092A    61  PUSH2 0x092f
	092D    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0920  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @0921  stack[-1] = stack[-8]
	//     @0922  stack[0] = 0x11
	// }
	// Block ends with conditional jump to 0x092f, if !!(0x11 < memory[stack[-8]:stack[-8] + 0x20])

label_092E:
	// Incoming jump from 0x092D, if not !!(0x11 < memory[stack[-8]:stack[-8] + 0x20])
	092E    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @092E  assert(); }
	// Block terminates

label_092F:
	// Incoming jump from 0x092D, if !!(0x11 < memory[stack[-8]:stack[-8] + 0x20])
	// Inputs[12]
	// {
	//     @0930  stack[-2]
	//     @0930  stack[-1]
	//     @0935  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @097D  memory[0x40:0x60]
	//     @097F  stack[-5]
	//     @09C9  stack[-4]
	//     @0A13  stack[-3]
	//     @0AB1  memory[0x40:0x60]
	//     @0AB8  stack[-6]
	//     @0AB9  msg.gas
	//     @0ABA  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @0ABA  address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// }
	092F    5B  JUMPDEST
	0930    90  SWAP1
	0931    60  PUSH1 0x20
	0933    01  ADD
	0934    01  ADD
	0935    51  MLOAD
	0936    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0957    90  SWAP1
	0958    04  DIV
	0959    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	097A    02  MUL
	097B    60  PUSH1 0x40
	097D    51  MLOAD
	097E    80  DUP1
	097F    85  DUP6
	0980    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	09A0    19  NOT
	09A1    16  AND
	09A2    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	09C2    19  NOT
	09C3    16  AND
	09C4    81  DUP2
	09C5    52  MSTORE
	09C6    60  PUSH1 0x01
	09C8    01  ADD
	09C9    84  DUP5
	09CA    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	09EA    19  NOT
	09EB    16  AND
	09EC    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0A0C    19  NOT
	0A0D    16  AND
	0A0E    81  DUP2
	0A0F    52  MSTORE
	0A10    60  PUSH1 0x01
	0A12    01  ADD
	0A13    83  DUP4
	0A14    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0A34    19  NOT
	0A35    16  AND
	0A36    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0A56    19  NOT
	0A57    16  AND
	0A58    81  DUP2
	0A59    52  MSTORE
	0A5A    60  PUSH1 0x01
	0A5C    01  ADD
	0A5D    82  DUP3
	0A5E    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0A7E    19  NOT
	0A7F    16  AND
	0A80    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0AA0    19  NOT
	0AA1    16  AND
	0AA2    81  DUP2
	0AA3    52  MSTORE
	0AA4    60  PUSH1 0x01
	0AA6    01  ADD
	0AA7    94  SWAP5
	0AA8    50  POP
	0AA9    50  POP
	0AAA    50  POP
	0AAB    50  POP
	0AAC    50  POP
	0AAD    60  PUSH1 0x20
	0AAF    60  PUSH1 0x40
	0AB1    51  MLOAD
	0AB2    80  DUP1
	0AB3    83  DUP4
	0AB4    03  SUB
	0AB5    81  DUP2
	0AB6    60  PUSH1 0x00
	0AB8    86  DUP7
	0AB9    5A  GAS
	0ABA    F1  CALL
	0ABB    15  ISZERO
	0ABC    15  ISZERO
	0ABD    61  PUSH2 0x0ac5
	0AC0    57  *JUMPI
	// Stack delta = -4
	// Outputs[6]
	// {
	//     @09C5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @0A0F  memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @0A59  memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @0AA3  memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @0AA7  stack[-5] = 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]
	//     @0ABA  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// }
	// Block ends with conditional jump to 0x0ac5, if !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])

label_0AC1:
	// Incoming jump from 0x0AC0, if not !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// Inputs[1] { @0AC4  memory[0x00:0x00] }
	0AC1    60  PUSH1 0x00
	0AC3    80  DUP1
	0AC4    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0AC4  revert(memory[0x00:0x00]); }
	// Block terminates

label_0AC5:
	// Incoming jump from 0x0AC0, if !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// Inputs[4]
	// {
	//     @0ACA  memory[0x40:0x60]
	//     @0ACC  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]
	//     @0AD3  stack[-3]
	//     @0AD4  stack[-4]
	// }
	0AC5    5B  JUMPDEST
	0AC6    50  POP
	0AC7    50  POP
	0AC8    60  PUSH1 0x40
	0ACA    51  MLOAD
	0ACB    80  DUP1
	0ACC    51  MLOAD
	0ACD    90  SWAP1
	0ACE    50  POP
	0ACF    60  PUSH1 0x01
	0AD1    90  SWAP1
	0AD2    04  DIV
	0AD3    01  ADD
	0AD4    14  EQ
	0AD5    15  ISZERO
	0AD6    15  ISZERO
	0AD7    61  PUSH2 0x0ade
	0ADA    57  *JUMPI
	// Stack delta = -4
	// Block ends with conditional jump to 0x0ade, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4])

label_0ADB:
	// Incoming jump from 0x0ADA, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4])
	0ADB    60  PUSH1 0x38
	0ADD    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0ADE:
	// Incoming jump from 0x0ADA, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4])
	0ADE    5B  JUMPDEST
	0ADF    61  PUSH2 0x0ae6
	0AE2    61  PUSH2 0x1dbd
	0AE5    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0ADF  stack[0] = 0x0ae6 }
	// Block ends with call to 0x1dbd, returns to 0x0AE6

label_0AE6:
	// Incoming return from call to 0x1DBD at 0x0AE5
	// Inputs[5]
	// {
	//     @0AE7  address(this)
	//     @0B03  stack[-1]
	//     @0B06  memory[0x40:0x60]
	//     @0B3F  memory[stack[-1]:stack[-1] + 0x20]
	//     @0B48  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0AE6    5B  JUMPDEST
	0AE7    30  ADDRESS
	0AE8    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0AFD    16  AND
	0AFE    63  PUSH4 0x6c54fcef
	0B03    82  DUP3
	0B04    60  PUSH1 0x40
	0B06    51  MLOAD
	0B07    82  DUP3
	0B08    63  PUSH4 0xffffffff
	0B0D    16  AND
	0B0E    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	0B2C    02  MUL
	0B2D    81  DUP2
	0B2E    52  MSTORE
	0B2F    60  PUSH1 0x04
	0B31    01  ADD
	0B32    80  DUP1
	0B33    80  DUP1
	0B34    60  PUSH1 0x20
	0B36    01  ADD
	0B37    82  DUP3
	0B38    81  DUP2
	0B39    03  SUB
	0B3A    82  DUP3
	0B3B    52  MSTORE
	0B3C    83  DUP4
	0B3D    81  DUP2
	0B3E    81  DUP2
	0B3F    51  MLOAD
	0B40    81  DUP2
	0B41    52  MSTORE
	0B42    60  PUSH1 0x20
	0B44    01  ADD
	0B45    91  SWAP2
	0B46    50  POP
	0B47    80  DUP1
	0B48    51  MLOAD
	0B49    90  SWAP1
	0B4A    60  PUSH1 0x20
	0B4C    01  ADD
	0B4D    90  SWAP1
	0B4E    80  DUP1
	0B4F    83  DUP4
	0B50    83  DUP4
	0B51    60  PUSH1 0x00
	0B53    5B  JUMPDEST
	0B54    83  DUP4
	0B55    81  DUP2
	0B56    10  LT
	0B57    15  ISZERO
	0B58    61  PUSH2 0x0b6e
	0B5B    57  *JUMPI
	// Stack delta = +12
	// Outputs[15]
	// {
	//     @0AFD  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @0AFE  stack[1] = 0x6c54fcef
	//     @0B03  stack[2] = stack[-1]
	//     @0B2E  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x6c54fcef)
	//     @0B31  stack[3] = 0x04 + memory[0x40:0x60]
	//     @0B32  stack[4] = 0x04 + memory[0x40:0x60]
	//     @0B3B  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @0B41  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0B45  stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @0B4D  stack[6] = 0x20 + stack[-1]
	//     @0B4D  stack[7] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0B4E  stack[8] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0B4F  stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @0B50  stack[10] = 0x20 + stack[-1]
	//     @0B51  stack[11] = 0x00
	// }
	// Block ends with conditional jump to 0x0b6e, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0B5C:
	// Incoming jump from 0x0B5B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0B5B, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @0B5C  stack[-1]
	//     @0B5D  stack[-2]
	//     @0B5F  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0B61  stack[-3]
	// }
	0B5C    80  DUP1
	0B5D    82  DUP3
	0B5E    01  ADD
	0B5F    51  MLOAD
	0B60    81  DUP2
	0B61    84  DUP5
	0B62    01  ADD
	0B63    52  MSTORE
	0B64    60  PUSH1 0x20
	0B66    81  DUP2
	0B67    01  ADD
	0B68    90  SWAP1
	0B69    50  POP
	0B6A    61  PUSH2 0x0b53
	0B6D    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0B63  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0B68  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x0b53

label_0B6E:
	// Incoming jump from 0x0B5B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0B5B, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @0B73  stack[-6]
	//     @0B73  stack[-5]
	//     @0B75  stack[-7]
	// }
	0B6E    5B  JUMPDEST
	0B6F    50  POP
	0B70    50  POP
	0B71    50  POP
	0B72    50  POP
	0B73    90  SWAP1
	0B74    50  POP
	0B75    90  SWAP1
	0B76    81  DUP2
	0B77    01  ADD
	0B78    90  SWAP1
	0B79    60  PUSH1 0x1f
	0B7B    16  AND
	0B7C    80  DUP1
	0B7D    15  ISZERO
	0B7E    61  PUSH2 0x0b9b
	0B81    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0B78  stack[-7] = stack[-5] + stack[-7]
	//     @0B7B  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0b9b, if !(0x1f & stack[-5])

label_0B82:
	// Incoming jump from 0x0B81, if not !(0x1f & stack[-5])
	// Inputs[7]
	// {
	//     @0B82  stack[-1]
	//     @0B83  stack[-2]
	//     @0B86  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0B9D  stack[-5]
	//     @0BA5  memory[0x40:0x60]
	//     @0BAC  stack[-7]
	//     @0BAE  address(stack[-7]).code.length
	// }
	0B82    80  DUP1
	0B83    82  DUP3
	0B84    03  SUB
	0B85    80  DUP1
	0B86    51  MLOAD
	0B87    60  PUSH1 0x01
	0B89    83  DUP4
	0B8A    60  PUSH1 0x20
	0B8C    03  SUB
	0B8D    61  PUSH2 0x0100
	0B90    0A  EXP
	0B91    03  SUB
	0B92    19  NOT
	0B93    16  AND
	0B94    81  DUP2
	0B95    52  MSTORE
	0B96    60  PUSH1 0x20
	0B98    01  ADD
	0B99    91  SWAP2
	0B9A    50  POP
	0B9B    5B  JUMPDEST
	0B9C    50  POP
	0B9D    92  SWAP3
	0B9E    50  POP
	0B9F    50  POP
	0BA0    50  POP
	0BA1    60  PUSH1 0x00
	0BA3    60  PUSH1 0x40
	0BA5    51  MLOAD
	0BA6    80  DUP1
	0BA7    83  DUP4
	0BA8    03  SUB
	0BA9    81  DUP2
	0BAA    60  PUSH1 0x00
	0BAC    87  DUP8
	0BAD    80  DUP1
	0BAE    3B  EXTCODESIZE
	0BAF    15  ISZERO
	0BB0    15  ISZERO
	0BB1    61  PUSH2 0x0bb9
	0BB4    57  *JUMPI
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @0B95  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]
	//     @0B9D  stack[-5] = 0x20 + (stack[-2] - stack[-1])
	//     @0BA1  stack[-4] = 0x00
	//     @0BA5  stack[-3] = memory[0x40:0x60]
	//     @0BA8  stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]
	//     @0BA9  stack[-1] = memory[0x40:0x60]
	//     @0BAA  stack[0] = 0x00
	//     @0BAC  stack[1] = stack[-7]
	// }
	// Block ends with conditional jump to 0x0bb9, if !!address(stack[-7]).code.length

label_0BB5:
	// Incoming jump from 0x0BB4, if not !!address(stack[-7]).code.length
	// Incoming jump from 0x0BB4, if not !!address(stack[-7]).code.length
	// Inputs[1] { @0BB8  memory[0x00:0x00] }
	0BB5    60  PUSH1 0x00
	0BB7    80  DUP1
	0BB8    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0BB8  revert(memory[0x00:0x00]); }
	// Block terminates

label_0BB9:
	// Incoming jump from 0x0BB4, if !!address(stack[-7]).code.length
	// Incoming jump from 0x0BB4, if !!address(stack[-7]).code.length
	// Inputs[9]
	// {
	//     @0BBA  msg.gas
	//     @0BBB  stack[-4]
	//     @0BBB  address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0BBB  stack[-2]
	//     @0BBB  stack[-6]
	//     @0BBB  stack[-3]
	//     @0BBB  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @0BBB  stack[-5]
	//     @0BBB  stack[-1]
	// }
	0BB9    5B  JUMPDEST
	0BBA    5A  GAS
	0BBB    F1  CALL
	0BBC    15  ISZERO
	0BBD    15  ISZERO
	0BBE    61  PUSH2 0x0bc6
	0BC1    57  *JUMPI
	// Stack delta = -6
	// Outputs[1] { @0BBB  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) }
	// Block ends with conditional jump to 0x0bc6, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])

label_0BC2:
	// Incoming jump from 0x0BC1, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @0BC5  memory[0x00:0x00] }
	0BC2    60  PUSH1 0x00
	0BC4    80  DUP1
	0BC5    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0BC5  revert(memory[0x00:0x00]); }
	// Block terminates

label_0BC6:
	// Incoming jump from 0x0BC1, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @0BCB  stack[-5] }
	0BC6    5B  JUMPDEST
	0BC7    50  POP
	0BC8    50  POP
	0BC9    50  POP
	0BCA    50  POP
	0BCB    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-5]

label_0BCC:
	// Incoming call from 0x01E8, returns to 0x01E9
	// Inputs[2]
	// {
	//     @0BEE  stack[-1]
	//     @0BF2  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0BCC    5B  JUMPDEST
	0BCD    7F  PUSH32 0x6600000000000000000000000000000000000000000000000000000000000000
	0BEE    81  DUP2
	0BEF    60  PUSH1 0x00
	0BF1    81  DUP2
	0BF2    51  MLOAD
	0BF3    81  DUP2
	0BF4    10  LT
	0BF5    15  ISZERO
	0BF6    15  ISZERO
	0BF7    61  PUSH2 0x0bfc
	0BFA    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0BCD  stack[0] = 0x6600000000000000000000000000000000000000000000000000000000000000
	//     @0BEE  stack[1] = stack[-1]
	//     @0BEF  stack[2] = 0x00
	// }
	// Block ends with conditional jump to 0x0bfc, if !!(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0BFB:
	// Incoming jump from 0x0BFA, if not !!(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	0BFB    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0BFB  assert(); }
	// Block terminates

label_0BFC:
	// Incoming jump from 0x0BFA, if !!(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0BFD  stack[-1]
	//     @0BFD  stack[-2]
	//     @0C02  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0C6A  stack[-3]
	// }
	0BFC    5B  JUMPDEST
	0BFD    90  SWAP1
	0BFE    60  PUSH1 0x20
	0C00    01  ADD
	0C01    01  ADD
	0C02    51  MLOAD
	0C03    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0C24    90  SWAP1
	0C25    04  DIV
	0C26    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0C47    02  MUL
	0C48    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0C68    19  NOT
	0C69    16  AND
	0C6A    14  EQ
	0C6B    15  ISZERO
	0C6C    15  ISZERO
	0C6D    61  PUSH2 0x0c74
	0C70    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0c74, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0C71:
	// Incoming jump from 0x0C70, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0C71    60  PUSH1 0x38
	0C73    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0C74:
	// Incoming jump from 0x0C70, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0C74    5B  JUMPDEST
	0C75    61  PUSH2 0x0c7c
	0C78    61  PUSH2 0x1dbd
	0C7B    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0C75  stack[0] = 0x0c7c }
	// Block ends with call to 0x1dbd, returns to 0x0C7C

label_0C7C:
	// Incoming return from call to 0x1DBD at 0x0C7B
	// Inputs[2]
	// {
	//     @0C9E  stack[-1]
	//     @0CA2  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0C7C    5B  JUMPDEST
	0C7D    7F  PUSH32 0x6c00000000000000000000000000000000000000000000000000000000000000
	0C9E    81  DUP2
	0C9F    60  PUSH1 0x01
	0CA1    81  DUP2
	0CA2    51  MLOAD
	0CA3    81  DUP2
	0CA4    10  LT
	0CA5    15  ISZERO
	0CA6    15  ISZERO
	0CA7    61  PUSH2 0x0cac
	0CAA    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0C7D  stack[0] = 0x6c00000000000000000000000000000000000000000000000000000000000000
	//     @0C9E  stack[1] = stack[-1]
	//     @0C9F  stack[2] = 0x01
	// }
	// Block ends with conditional jump to 0x0cac, if !!(0x01 < memory[stack[-1]:stack[-1] + 0x20])

label_0CAB:
	// Incoming jump from 0x0CAA, if not !!(0x01 < memory[stack[-1]:stack[-1] + 0x20])
	0CAB    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0CAB  assert(); }
	// Block terminates

label_0CAC:
	// Incoming jump from 0x0CAA, if !!(0x01 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0CAD  stack[-1]
	//     @0CAD  stack[-2]
	//     @0CB2  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0D1A  stack[-3]
	// }
	0CAC    5B  JUMPDEST
	0CAD    90  SWAP1
	0CAE    60  PUSH1 0x20
	0CB0    01  ADD
	0CB1    01  ADD
	0CB2    51  MLOAD
	0CB3    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0CD4    90  SWAP1
	0CD5    04  DIV
	0CD6    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0CF7    02  MUL
	0CF8    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0D18    19  NOT
	0D19    16  AND
	0D1A    14  EQ
	0D1B    15  ISZERO
	0D1C    15  ISZERO
	0D1D    61  PUSH2 0x0d24
	0D20    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0d24, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0D21:
	// Incoming jump from 0x0D20, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0D21    60  PUSH1 0x38
	0D23    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0D24:
	// Incoming jump from 0x0D20, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	// Inputs[2]
	// {
	//     @0D46  stack[-1]
	//     @0D4A  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0D24    5B  JUMPDEST
	0D25    7F  PUSH32 0x6100000000000000000000000000000000000000000000000000000000000000
	0D46    81  DUP2
	0D47    60  PUSH1 0x02
	0D49    81  DUP2
	0D4A    51  MLOAD
	0D4B    81  DUP2
	0D4C    10  LT
	0D4D    15  ISZERO
	0D4E    15  ISZERO
	0D4F    61  PUSH2 0x0d54
	0D52    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0D25  stack[0] = 0x6100000000000000000000000000000000000000000000000000000000000000
	//     @0D46  stack[1] = stack[-1]
	//     @0D47  stack[2] = 0x02
	// }
	// Block ends with conditional jump to 0x0d54, if !!(0x02 < memory[stack[-1]:stack[-1] + 0x20])

label_0D53:
	// Incoming jump from 0x0D52, if not !!(0x02 < memory[stack[-1]:stack[-1] + 0x20])
	0D53    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0D53  assert(); }
	// Block terminates

label_0D54:
	// Incoming jump from 0x0D52, if !!(0x02 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0D55  stack[-2]
	//     @0D55  stack[-1]
	//     @0D5A  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0DC2  stack[-3]
	// }
	0D54    5B  JUMPDEST
	0D55    90  SWAP1
	0D56    60  PUSH1 0x20
	0D58    01  ADD
	0D59    01  ADD
	0D5A    51  MLOAD
	0D5B    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0D7C    90  SWAP1
	0D7D    04  DIV
	0D7E    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0D9F    02  MUL
	0DA0    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0DC0    19  NOT
	0DC1    16  AND
	0DC2    14  EQ
	0DC3    15  ISZERO
	0DC4    15  ISZERO
	0DC5    61  PUSH2 0x0dcc
	0DC8    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0dcc, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0DC9:
	// Incoming jump from 0x0DC8, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0DC9    60  PUSH1 0x38
	0DCB    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0DCC:
	// Incoming jump from 0x0DC8, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0DCC    5B  JUMPDEST
	0DCD    61  PUSH2 0x0dd4
	0DD0    61  PUSH2 0x1dbd
	0DD3    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0DCD  stack[0] = 0x0dd4 }
	// Block ends with call to 0x1dbd, returns to 0x0DD4

label_0DD4:
	// Incoming return from call to 0x1DBD at 0x0DD3
	// Inputs[2]
	// {
	//     @0DF6  stack[-1]
	//     @0DFA  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0DD4    5B  JUMPDEST
	0DD5    7F  PUSH32 0x6700000000000000000000000000000000000000000000000000000000000000
	0DF6    81  DUP2
	0DF7    60  PUSH1 0x03
	0DF9    81  DUP2
	0DFA    51  MLOAD
	0DFB    81  DUP2
	0DFC    10  LT
	0DFD    15  ISZERO
	0DFE    15  ISZERO
	0DFF    61  PUSH2 0x0e04
	0E02    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0DD5  stack[0] = 0x6700000000000000000000000000000000000000000000000000000000000000
	//     @0DF6  stack[1] = stack[-1]
	//     @0DF7  stack[2] = 0x03
	// }
	// Block ends with conditional jump to 0x0e04, if !!(0x03 < memory[stack[-1]:stack[-1] + 0x20])

label_0E03:
	// Incoming jump from 0x0E02, if not !!(0x03 < memory[stack[-1]:stack[-1] + 0x20])
	0E03    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0E03  assert(); }
	// Block terminates

label_0E04:
	// Incoming jump from 0x0E02, if !!(0x03 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0E05  stack[-2]
	//     @0E05  stack[-1]
	//     @0E0A  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0E72  stack[-3]
	// }
	0E04    5B  JUMPDEST
	0E05    90  SWAP1
	0E06    60  PUSH1 0x20
	0E08    01  ADD
	0E09    01  ADD
	0E0A    51  MLOAD
	0E0B    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0E2C    90  SWAP1
	0E2D    04  DIV
	0E2E    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0E4F    02  MUL
	0E50    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0E70    19  NOT
	0E71    16  AND
	0E72    14  EQ
	0E73    15  ISZERO
	0E74    15  ISZERO
	0E75    61  PUSH2 0x0e7c
	0E78    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0e7c, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0E79:
	// Incoming jump from 0x0E78, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0E79    60  PUSH1 0x38
	0E7B    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0E7C:
	// Incoming jump from 0x0E78, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0E7C    5B  JUMPDEST
	0E7D    61  PUSH2 0x0e84
	0E80    61  PUSH2 0x1dbd
	0E83    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0E7D  stack[0] = 0x0e84 }
	// Block ends with call to 0x1dbd, returns to 0x0E84

label_0E84:
	// Incoming return from call to 0x1DBD at 0x0E83
	// Inputs[2]
	// {
	//     @0EA6  stack[-1]
	//     @0EAA  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0E84    5B  JUMPDEST
	0E85    7F  PUSH32 0x7b00000000000000000000000000000000000000000000000000000000000000
	0EA6    81  DUP2
	0EA7    60  PUSH1 0x04
	0EA9    81  DUP2
	0EAA    51  MLOAD
	0EAB    81  DUP2
	0EAC    10  LT
	0EAD    15  ISZERO
	0EAE    15  ISZERO
	0EAF    61  PUSH2 0x0eb4
	0EB2    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0E85  stack[0] = 0x7b00000000000000000000000000000000000000000000000000000000000000
	//     @0EA6  stack[1] = stack[-1]
	//     @0EA7  stack[2] = 0x04
	// }
	// Block ends with conditional jump to 0x0eb4, if !!(0x04 < memory[stack[-1]:stack[-1] + 0x20])

label_0EB3:
	// Incoming jump from 0x0EB2, if not !!(0x04 < memory[stack[-1]:stack[-1] + 0x20])
	0EB3    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0EB3  assert(); }
	// Block terminates

label_0EB4:
	// Incoming jump from 0x0EB2, if !!(0x04 < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0EB5  stack[-2]
	//     @0EB5  stack[-1]
	//     @0EBA  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0F22  stack[-3]
	// }
	0EB4    5B  JUMPDEST
	0EB5    90  SWAP1
	0EB6    60  PUSH1 0x20
	0EB8    01  ADD
	0EB9    01  ADD
	0EBA    51  MLOAD
	0EBB    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0EDC    90  SWAP1
	0EDD    04  DIV
	0EDE    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0EFF    02  MUL
	0F00    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0F20    19  NOT
	0F21    16  AND
	0F22    14  EQ
	0F23    15  ISZERO
	0F24    15  ISZERO
	0F25    61  PUSH2 0x0f2c
	0F28    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0f2c, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0F29:
	// Incoming jump from 0x0F28, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0F29    60  PUSH1 0x38
	0F2B    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_0F2C:
	// Incoming jump from 0x0F28, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	// Inputs[2]
	// {
	//     @0F4E  stack[-1]
	//     @0F52  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0F2C    5B  JUMPDEST
	0F2D    7F  PUSH32 0x7d00000000000000000000000000000000000000000000000000000000000000
	0F4E    81  DUP2
	0F4F    60  PUSH1 0x1f
	0F51    81  DUP2
	0F52    51  MLOAD
	0F53    81  DUP2
	0F54    10  LT
	0F55    15  ISZERO
	0F56    15  ISZERO
	0F57    61  PUSH2 0x0f5c
	0F5A    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0F2D  stack[0] = 0x7d00000000000000000000000000000000000000000000000000000000000000
	//     @0F4E  stack[1] = stack[-1]
	//     @0F4F  stack[2] = 0x1f
	// }
	// Block ends with conditional jump to 0x0f5c, if !!(0x1f < memory[stack[-1]:stack[-1] + 0x20])

label_0F5B:
	// Incoming jump from 0x0F5A, if not !!(0x1f < memory[stack[-1]:stack[-1] + 0x20])
	0F5B    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0F5B  assert(); }
	// Block terminates

label_0F5C:
	// Incoming jump from 0x0F5A, if !!(0x1f < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @0F5D  stack[-1]
	//     @0F5D  stack[-2]
	//     @0F62  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @0FCA  stack[-3]
	// }
	0F5C    5B  JUMPDEST
	0F5D    90  SWAP1
	0F5E    60  PUSH1 0x20
	0F60    01  ADD
	0F61    01  ADD
	0F62    51  MLOAD
	0F63    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0F84    90  SWAP1
	0F85    04  DIV
	0F86    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	0FA7    02  MUL
	0FA8    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	0FC8    19  NOT
	0FC9    16  AND
	0FCA    14  EQ
	0FCB    15  ISZERO
	0FCC    15  ISZERO
	0FCD    61  PUSH2 0x0fd4
	0FD0    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x0fd4, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_0FD1:
	// Incoming jump from 0x0FD0, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0FD1    60  PUSH1 0x00
	0FD3    FF  *SELFDESTRUCT
	// Stack delta = +0
	// Outputs[1] { @0FD3  selfdestruct(0x00); }
	// Block terminates

label_0FD4:
	// Incoming jump from 0x0FD0, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	0FD4    5B  JUMPDEST
	0FD5    61  PUSH2 0x0fdc
	0FD8    61  PUSH2 0x1dbd
	0FDB    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0FD5  stack[0] = 0x0fdc }
	// Block ends with call to 0x1dbd, returns to 0x0FDC

label_0FDC:
	// Incoming return from call to 0x1DBD at 0x0FDB
	// Inputs[6]
	// {
	//     @0FDD  address(this)
	//     @0FF9  msg.value
	//     @0FFA  stack[-1]
	//     @0FFD  memory[0x40:0x60]
	//     @1036  memory[stack[-1]:stack[-1] + 0x20]
	//     @103F  memory[stack[-1]:stack[-1] + 0x20]
	// }
	0FDC    5B  JUMPDEST
	0FDD    30  ADDRESS
	0FDE    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0FF3    16  AND
	0FF4    63  PUSH4 0xf605fa57
	0FF9    34  CALLVALUE
	0FFA    83  DUP4
	0FFB    60  PUSH1 0x40
	0FFD    51  MLOAD
	0FFE    83  DUP4
	0FFF    63  PUSH4 0xffffffff
	1004    16  AND
	1005    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	1023    02  MUL
	1024    81  DUP2
	1025    52  MSTORE
	1026    60  PUSH1 0x04
	1028    01  ADD
	1029    80  DUP1
	102A    80  DUP1
	102B    60  PUSH1 0x20
	102D    01  ADD
	102E    82  DUP3
	102F    81  DUP2
	1030    03  SUB
	1031    82  DUP3
	1032    52  MSTORE
	1033    83  DUP4
	1034    81  DUP2
	1035    81  DUP2
	1036    51  MLOAD
	1037    81  DUP2
	1038    52  MSTORE
	1039    60  PUSH1 0x20
	103B    01  ADD
	103C    91  SWAP2
	103D    50  POP
	103E    80  DUP1
	103F    51  MLOAD
	1040    90  SWAP1
	1041    60  PUSH1 0x20
	1043    01  ADD
	1044    90  SWAP1
	1045    80  DUP1
	1046    83  DUP4
	1047    83  DUP4
	1048    60  PUSH1 0x00
	104A    5B  JUMPDEST
	104B    83  DUP4
	104C    81  DUP2
	104D    10  LT
	104E    15  ISZERO
	104F    61  PUSH2 0x1065
	1052    57  *JUMPI
	// Stack delta = +13
	// Outputs[16]
	// {
	//     @0FF3  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @0FF4  stack[1] = 0xf605fa57
	//     @0FF9  stack[2] = msg.value
	//     @0FFA  stack[3] = stack[-1]
	//     @1025  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xf605fa57)
	//     @1028  stack[4] = 0x04 + memory[0x40:0x60]
	//     @1029  stack[5] = 0x04 + memory[0x40:0x60]
	//     @1032  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @1038  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @103C  stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @1044  stack[8] = memory[stack[-1]:stack[-1] + 0x20]
	//     @1044  stack[7] = 0x20 + stack[-1]
	//     @1045  stack[9] = memory[stack[-1]:stack[-1] + 0x20]
	//     @1046  stack[10] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @1047  stack[11] = 0x20 + stack[-1]
	//     @1048  stack[12] = 0x00
	// }
	// Block ends with conditional jump to 0x1065, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_1053:
	// Incoming jump from 0x1052, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x1052, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @1053  stack[-1]
	//     @1054  stack[-2]
	//     @1056  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1058  stack[-3]
	// }
	1053    80  DUP1
	1054    82  DUP3
	1055    01  ADD
	1056    51  MLOAD
	1057    81  DUP2
	1058    84  DUP5
	1059    01  ADD
	105A    52  MSTORE
	105B    60  PUSH1 0x20
	105D    81  DUP2
	105E    01  ADD
	105F    90  SWAP1
	1060    50  POP
	1061    61  PUSH2 0x104a
	1064    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @105A  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @105F  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x104a

label_1065:
	// Incoming jump from 0x1052, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x1052, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @106A  stack[-6]
	//     @106A  stack[-5]
	//     @106C  stack[-7]
	// }
	1065    5B  JUMPDEST
	1066    50  POP
	1067    50  POP
	1068    50  POP
	1069    50  POP
	106A    90  SWAP1
	106B    50  POP
	106C    90  SWAP1
	106D    81  DUP2
	106E    01  ADD
	106F    90  SWAP1
	1070    60  PUSH1 0x1f
	1072    16  AND
	1073    80  DUP1
	1074    15  ISZERO
	1075    61  PUSH2 0x1092
	1078    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @106F  stack[-7] = stack[-5] + stack[-7]
	//     @1072  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x1092, if !(0x1f & stack[-5])

label_1079:
	// Incoming jump from 0x1078, if not !(0x1f & stack[-5])
	// Inputs[8]
	// {
	//     @1079  stack[-1]
	//     @107A  stack[-2]
	//     @107D  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1094  stack[-5]
	//     @109C  memory[0x40:0x60]
	//     @10A1  stack[-6]
	//     @10A2  stack[-8]
	//     @10A4  address(stack[-8]).code.length
	// }
	1079    80  DUP1
	107A    82  DUP3
	107B    03  SUB
	107C    80  DUP1
	107D    51  MLOAD
	107E    60  PUSH1 0x01
	1080    83  DUP4
	1081    60  PUSH1 0x20
	1083    03  SUB
	1084    61  PUSH2 0x0100
	1087    0A  EXP
	1088    03  SUB
	1089    19  NOT
	108A    16  AND
	108B    81  DUP2
	108C    52  MSTORE
	108D    60  PUSH1 0x20
	108F    01  ADD
	1090    91  SWAP2
	1091    50  POP
	1092    5B  JUMPDEST
	1093    50  POP
	1094    92  SWAP3
	1095    50  POP
	1096    50  POP
	1097    50  POP
	1098    60  PUSH1 0x00
	109A    60  PUSH1 0x40
	109C    51  MLOAD
	109D    80  DUP1
	109E    83  DUP4
	109F    03  SUB
	10A0    81  DUP2
	10A1    85  DUP6
	10A2    88  DUP9
	10A3    80  DUP1
	10A4    3B  EXTCODESIZE
	10A5    15  ISZERO
	10A6    15  ISZERO
	10A7    61  PUSH2 0x10af
	10AA    57  *JUMPI
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @108C  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]
	//     @1094  stack[-5] = 0x20 + (stack[-2] - stack[-1])
	//     @1098  stack[-4] = 0x00
	//     @109C  stack[-3] = memory[0x40:0x60]
	//     @109F  stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]
	//     @10A0  stack[-1] = memory[0x40:0x60]
	//     @10A1  stack[0] = stack[-6]
	//     @10A2  stack[1] = stack[-8]
	// }
	// Block ends with conditional jump to 0x10af, if !!address(stack[-8]).code.length

label_10AB:
	// Incoming jump from 0x10AA, if not !!address(stack[-8]).code.length
	// Incoming jump from 0x10AA, if not !!address(stack[-8]).code.length
	// Inputs[1] { @10AE  memory[0x00:0x00] }
	10AB    60  PUSH1 0x00
	10AD    80  DUP1
	10AE    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @10AE  revert(memory[0x00:0x00]); }
	// Block terminates

label_10AF:
	// Incoming jump from 0x10AA, if !!address(stack[-8]).code.length
	// Incoming jump from 0x10AA, if !!address(stack[-8]).code.length
	// Inputs[9]
	// {
	//     @10B0  msg.gas
	//     @10B1  stack[-6]
	//     @10B1  stack[-1]
	//     @10B1  stack[-4]
	//     @10B1  stack[-2]
	//     @10B1  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @10B1  address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @10B1  stack[-3]
	//     @10B1  stack[-5]
	// }
	10AF    5B  JUMPDEST
	10B0    5A  GAS
	10B1    F1  CALL
	10B2    15  ISZERO
	10B3    15  ISZERO
	10B4    61  PUSH2 0x10bc
	10B7    57  *JUMPI
	// Stack delta = -6
	// Outputs[1] { @10B1  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) }
	// Block ends with conditional jump to 0x10bc, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])

label_10B8:
	// Incoming jump from 0x10B7, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @10BB  memory[0x00:0x00] }
	10B8    60  PUSH1 0x00
	10BA    80  DUP1
	10BB    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @10BB  revert(memory[0x00:0x00]); }
	// Block terminates

label_10BC:
	// Incoming jump from 0x10B7, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	10BC    5B  JUMPDEST
	10BD    50  POP
	10BE    50  POP
	10BF    50  POP
	10C0    50  POP
	10C1    61  PUSH2 0x10c8
	10C4    61  PUSH2 0x1dbd
	10C7    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @10C1  stack[-4] = 0x10c8 }
	// Block ends with call to 0x1dbd, returns to 0x10C8

label_10C8:
	// Incoming return from call to 0x1DBD at 0x10C7
	// Inputs[2]
	// {
	//     @10EA  stack[-1]
	//     @10EE  memory[stack[-1]:stack[-1] + 0x20]
	// }
	10C8    5B  JUMPDEST
	10C9    7F  PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000
	10EA    81  DUP2
	10EB    60  PUSH1 0x1e
	10ED    81  DUP2
	10EE    51  MLOAD
	10EF    81  DUP2
	10F0    10  LT
	10F1    15  ISZERO
	10F2    15  ISZERO
	10F3    61  PUSH2 0x10f8
	10F6    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @10C9  stack[0] = 0x7300000000000000000000000000000000000000000000000000000000000000
	//     @10EA  stack[1] = stack[-1]
	//     @10EB  stack[2] = 0x1e
	// }
	// Block ends with conditional jump to 0x10f8, if !!(0x1e < memory[stack[-1]:stack[-1] + 0x20])

label_10F7:
	// Incoming jump from 0x10F6, if not !!(0x1e < memory[stack[-1]:stack[-1] + 0x20])
	10F7    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @10F7  assert(); }
	// Block terminates

label_10F8:
	// Incoming jump from 0x10F6, if !!(0x1e < memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[4]
	// {
	//     @10F9  stack[-2]
	//     @10F9  stack[-1]
	//     @10FE  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1166  stack[-3]
	// }
	10F8    5B  JUMPDEST
	10F9    90  SWAP1
	10FA    60  PUSH1 0x20
	10FC    01  ADD
	10FD    01  ADD
	10FE    51  MLOAD
	10FF    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1120    90  SWAP1
	1121    04  DIV
	1122    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1143    02  MUL
	1144    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1164    19  NOT
	1165    16  AND
	1166    14  EQ
	1167    15  ISZERO
	1168    15  ISZERO
	1169    61  PUSH2 0x1170
	116C    57  *JUMPI
	// Stack delta = -3
	// Block ends with conditional jump to 0x1170, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])

label_116D:
	// Incoming jump from 0x116C, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	116D    60  PUSH1 0x38
	116F    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_1170:
	// Incoming jump from 0x116C, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3])
	1170    5B  JUMPDEST
	1171    61  PUSH2 0x1178
	1174    61  PUSH2 0x1dbd
	1177    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1171  stack[0] = 0x1178 }
	// Block ends with call to 0x1dbd, returns to 0x1178

label_1178:
	// Incoming return from call to 0x1DBD at 0x1177
	// Inputs[2]
	// {
	//     @1183  storage[0x00]
	//     @1194  stack[-2]
	// }
	1178    5B  JUMPDEST
	1179    60  PUSH1 0x01
	117B    60  PUSH1 0x00
	117D    80  DUP1
	117E    61  PUSH2 0x0100
	1181    0A  EXP
	1182    81  DUP2
	1183    54  SLOAD
	1184    81  DUP2
	1185    60  PUSH1 0xff
	1187    02  MUL
	1188    19  NOT
	1189    16  AND
	118A    90  SWAP1
	118B    83  DUP4
	118C    15  ISZERO
	118D    15  ISZERO
	118E    02  MUL
	118F    17  OR
	1190    90  SWAP1
	1191    55  SSTORE
	1192    50  POP
	1193    50  POP
	1194    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @1191  storage[0x00] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x00]) }
	// Block ends with unconditional jump to stack[-2]

label_1195:
	// Incoming call from 0x0245, returns to 0x0246
	// Inputs[1] { @119C  block.number }
	1195    5B  JUMPDEST
	1196    60  PUSH1 0x00
	1198    80  DUP1
	1199    61  PUSH2 0x01a4
	119C    43  NUMBER
	119D    14  EQ
	119E    15  ISZERO
	119F    15  ISZERO
	11A0    61  PUSH2 0x11a7
	11A3    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @1196  stack[0] = 0x00
	//     @1198  stack[1] = 0x00
	// }
	// Block ends with conditional jump to 0x11a7, if !!(block.number == 0x01a4)

label_11A4:
	// Incoming jump from 0x11A3, if not !!(block.number == 0x01a4)
	11A4    60  PUSH1 0x38
	11A6    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_11A7:
	// Incoming jump from 0x11A3, if !!(block.number == 0x01a4)
	// Inputs[2]
	// {
	//     @11A8  block.number
	//     @11A9  stack[-2]
	// }
	11A7    5B  JUMPDEST
	11A8    43  NUMBER
	11A9    91  SWAP2
	11AA    50  POP
	11AB    61  PUSH2 0x11b2
	11AE    61  PUSH2 0x1dbd
	11B1    56  *JUMP
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @11A9  stack[-2] = block.number
	//     @11AB  stack[0] = 0x11b2
	// }
	// Block ends with call to 0x1dbd, returns to 0x11B2

label_11B2:
	// Incoming return from call to 0x1DBD at 0x11B1
	// Inputs[3]
	// {
	//     @11BD  stack[-1]
	//     @11BF  stack[-3]
	//     @11C3  memory[stack[-3]:stack[-3] + 0x20]
	// }
	11B2    5B  JUMPDEST
	11B3    68  PUSH9 0x74f794a249c48cbd04
	11BD    90  SWAP1
	11BE    50  POP
	11BF    82  DUP3
	11C0    60  PUSH1 0x05
	11C2    81  DUP2
	11C3    51  MLOAD
	11C4    81  DUP2
	11C5    10  LT
	11C6    15  ISZERO
	11C7    15  ISZERO
	11C8    61  PUSH2 0x11cd
	11CB    57  *JUMPI
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @11BD  stack[-1] = 0x74f794a249c48cbd04
	//     @11BF  stack[0] = stack[-3]
	//     @11C0  stack[1] = 0x05
	// }
	// Block ends with conditional jump to 0x11cd, if !!(0x05 < memory[stack[-3]:stack[-3] + 0x20])

label_11CC:
	// Incoming jump from 0x11CB, if not !!(0x05 < memory[stack[-3]:stack[-3] + 0x20])
	11CC    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @11CC  assert(); }
	// Block terminates

label_11CD:
	// Incoming jump from 0x11CB, if !!(0x05 < memory[stack[-3]:stack[-3] + 0x20])
	// Inputs[5]
	// {
	//     @11CE  stack[-1]
	//     @11CE  stack[-2]
	//     @11D3  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1219  stack[-5]
	//     @121D  memory[stack[-5]:stack[-5] + 0x20]
	// }
	11CD    5B  JUMPDEST
	11CE    90  SWAP1
	11CF    60  PUSH1 0x20
	11D1    01  ADD
	11D2    01  ADD
	11D3    51  MLOAD
	11D4    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	11F5    90  SWAP1
	11F6    04  DIV
	11F7    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1218    02  MUL
	1219    83  DUP4
	121A    60  PUSH1 0x06
	121C    81  DUP2
	121D    51  MLOAD
	121E    81  DUP2
	121F    10  LT
	1220    15  ISZERO
	1221    15  ISZERO
	1222    61  PUSH2 0x1227
	1225    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1218  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1219  stack[-1] = stack[-5]
	//     @121A  stack[0] = 0x06
	// }
	// Block ends with conditional jump to 0x1227, if !!(0x06 < memory[stack[-5]:stack[-5] + 0x20])

label_1226:
	// Incoming jump from 0x1225, if not !!(0x06 < memory[stack[-5]:stack[-5] + 0x20])
	1226    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1226  assert(); }
	// Block terminates

label_1227:
	// Incoming jump from 0x1225, if !!(0x06 < memory[stack[-5]:stack[-5] + 0x20])
	// Inputs[5]
	// {
	//     @1228  stack[-2]
	//     @1228  stack[-1]
	//     @122D  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1273  stack[-6]
	//     @1277  memory[stack[-6]:stack[-6] + 0x20]
	// }
	1227    5B  JUMPDEST
	1228    90  SWAP1
	1229    60  PUSH1 0x20
	122B    01  ADD
	122C    01  ADD
	122D    51  MLOAD
	122E    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	124F    90  SWAP1
	1250    04  DIV
	1251    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1272    02  MUL
	1273    84  DUP5
	1274    60  PUSH1 0x07
	1276    81  DUP2
	1277    51  MLOAD
	1278    81  DUP2
	1279    10  LT
	127A    15  ISZERO
	127B    15  ISZERO
	127C    61  PUSH2 0x1281
	127F    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1272  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1273  stack[-1] = stack[-6]
	//     @1274  stack[0] = 0x07
	// }
	// Block ends with conditional jump to 0x1281, if !!(0x07 < memory[stack[-6]:stack[-6] + 0x20])

label_1280:
	// Incoming jump from 0x127F, if not !!(0x07 < memory[stack[-6]:stack[-6] + 0x20])
	1280    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1280  assert(); }
	// Block terminates

label_1281:
	// Incoming jump from 0x127F, if !!(0x07 < memory[stack[-6]:stack[-6] + 0x20])
	// Inputs[5]
	// {
	//     @1282  stack[-2]
	//     @1282  stack[-1]
	//     @1287  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @12CD  stack[-7]
	//     @12D1  memory[stack[-7]:stack[-7] + 0x20]
	// }
	1281    5B  JUMPDEST
	1282    90  SWAP1
	1283    60  PUSH1 0x20
	1285    01  ADD
	1286    01  ADD
	1287    51  MLOAD
	1288    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	12A9    90  SWAP1
	12AA    04  DIV
	12AB    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	12CC    02  MUL
	12CD    85  DUP6
	12CE    60  PUSH1 0x08
	12D0    81  DUP2
	12D1    51  MLOAD
	12D2    81  DUP2
	12D3    10  LT
	12D4    15  ISZERO
	12D5    15  ISZERO
	12D6    61  PUSH2 0x12db
	12D9    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @12CC  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @12CD  stack[-1] = stack[-7]
	//     @12CE  stack[0] = 0x08
	// }
	// Block ends with conditional jump to 0x12db, if !!(0x08 < memory[stack[-7]:stack[-7] + 0x20])

label_12DA:
	// Incoming jump from 0x12D9, if not !!(0x08 < memory[stack[-7]:stack[-7] + 0x20])
	12DA    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @12DA  assert(); }
	// Block terminates

label_12DB:
	// Incoming jump from 0x12D9, if !!(0x08 < memory[stack[-7]:stack[-7] + 0x20])
	// Inputs[5]
	// {
	//     @12DC  stack[-2]
	//     @12DC  stack[-1]
	//     @12E1  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1327  stack[-8]
	//     @132B  memory[stack[-8]:stack[-8] + 0x20]
	// }
	12DB    5B  JUMPDEST
	12DC    90  SWAP1
	12DD    60  PUSH1 0x20
	12DF    01  ADD
	12E0    01  ADD
	12E1    51  MLOAD
	12E2    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1303    90  SWAP1
	1304    04  DIV
	1305    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1326    02  MUL
	1327    86  DUP7
	1328    60  PUSH1 0x09
	132A    81  DUP2
	132B    51  MLOAD
	132C    81  DUP2
	132D    10  LT
	132E    15  ISZERO
	132F    15  ISZERO
	1330    61  PUSH2 0x1335
	1333    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1326  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1327  stack[-1] = stack[-8]
	//     @1328  stack[0] = 0x09
	// }
	// Block ends with conditional jump to 0x1335, if !!(0x09 < memory[stack[-8]:stack[-8] + 0x20])

label_1334:
	// Incoming jump from 0x1333, if not !!(0x09 < memory[stack[-8]:stack[-8] + 0x20])
	1334    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1334  assert(); }
	// Block terminates

label_1335:
	// Incoming jump from 0x1333, if !!(0x09 < memory[stack[-8]:stack[-8] + 0x20])
	// Inputs[5]
	// {
	//     @1336  stack[-2]
	//     @1336  stack[-1]
	//     @133B  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1381  stack[-9]
	//     @1385  memory[stack[-9]:stack[-9] + 0x20]
	// }
	1335    5B  JUMPDEST
	1336    90  SWAP1
	1337    60  PUSH1 0x20
	1339    01  ADD
	133A    01  ADD
	133B    51  MLOAD
	133C    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	135D    90  SWAP1
	135E    04  DIV
	135F    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1380    02  MUL
	1381    87  DUP8
	1382    60  PUSH1 0x0a
	1384    81  DUP2
	1385    51  MLOAD
	1386    81  DUP2
	1387    10  LT
	1388    15  ISZERO
	1389    15  ISZERO
	138A    61  PUSH2 0x138f
	138D    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1380  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1381  stack[-1] = stack[-9]
	//     @1382  stack[0] = 0x0a
	// }
	// Block ends with conditional jump to 0x138f, if !!(0x0a < memory[stack[-9]:stack[-9] + 0x20])

label_138E:
	// Incoming jump from 0x138D, if not !!(0x0a < memory[stack[-9]:stack[-9] + 0x20])
	138E    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @138E  assert(); }
	// Block terminates

label_138F:
	// Incoming jump from 0x138D, if !!(0x0a < memory[stack[-9]:stack[-9] + 0x20])
	// Inputs[5]
	// {
	//     @1390  stack[-1]
	//     @1390  stack[-2]
	//     @1395  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @13DB  stack[-10]
	//     @13DF  memory[stack[-10]:stack[-10] + 0x20]
	// }
	138F    5B  JUMPDEST
	1390    90  SWAP1
	1391    60  PUSH1 0x20
	1393    01  ADD
	1394    01  ADD
	1395    51  MLOAD
	1396    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	13B7    90  SWAP1
	13B8    04  DIV
	13B9    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	13DA    02  MUL
	13DB    88  DUP9
	13DC    60  PUSH1 0x0b
	13DE    81  DUP2
	13DF    51  MLOAD
	13E0    81  DUP2
	13E1    10  LT
	13E2    15  ISZERO
	13E3    15  ISZERO
	13E4    61  PUSH2 0x13e9
	13E7    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @13DA  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @13DB  stack[-1] = stack[-10]
	//     @13DC  stack[0] = 0x0b
	// }
	// Block ends with conditional jump to 0x13e9, if !!(0x0b < memory[stack[-10]:stack[-10] + 0x20])

label_13E8:
	// Incoming jump from 0x13E7, if not !!(0x0b < memory[stack[-10]:stack[-10] + 0x20])
	13E8    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @13E8  assert(); }
	// Block terminates

label_13E9:
	// Incoming jump from 0x13E7, if !!(0x0b < memory[stack[-10]:stack[-10] + 0x20])
	// Inputs[5]
	// {
	//     @13EA  stack[-1]
	//     @13EA  stack[-2]
	//     @13EF  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1435  stack[-11]
	//     @1439  memory[stack[-11]:stack[-11] + 0x20]
	// }
	13E9    5B  JUMPDEST
	13EA    90  SWAP1
	13EB    60  PUSH1 0x20
	13ED    01  ADD
	13EE    01  ADD
	13EF    51  MLOAD
	13F0    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1411    90  SWAP1
	1412    04  DIV
	1413    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1434    02  MUL
	1435    89  DUP10
	1436    60  PUSH1 0x0c
	1438    81  DUP2
	1439    51  MLOAD
	143A    81  DUP2
	143B    10  LT
	143C    15  ISZERO
	143D    15  ISZERO
	143E    61  PUSH2 0x1443
	1441    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1434  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1435  stack[-1] = stack[-11]
	//     @1436  stack[0] = 0x0c
	// }
	// Block ends with conditional jump to 0x1443, if !!(0x0c < memory[stack[-11]:stack[-11] + 0x20])

label_1442:
	// Incoming jump from 0x1441, if not !!(0x0c < memory[stack[-11]:stack[-11] + 0x20])
	1442    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1442  assert(); }
	// Block terminates

label_1443:
	// Incoming jump from 0x1441, if !!(0x0c < memory[stack[-11]:stack[-11] + 0x20])
	// Inputs[15]
	// {
	//     @1444  stack[-1]
	//     @1444  stack[-2]
	//     @1449  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1491  memory[0x40:0x60]
	//     @1493  stack[-9]
	//     @14DD  stack[-8]
	//     @1527  stack[-7]
	//     @1571  stack[-6]
	//     @15BB  stack[-5]
	//     @1605  stack[-4]
	//     @164F  stack[-3]
	//     @16EF  memory[0x40:0x60]
	//     @16F4  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @16F9  stack[-11]
	//     @16FA  stack[-10]
	// }
	1443    5B  JUMPDEST
	1444    90  SWAP1
	1445    60  PUSH1 0x20
	1447    01  ADD
	1448    01  ADD
	1449    51  MLOAD
	144A    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	146B    90  SWAP1
	146C    04  DIV
	146D    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	148E    02  MUL
	148F    60  PUSH1 0x40
	1491    51  MLOAD
	1492    80  DUP1
	1493    89  DUP10
	1494    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	14B4    19  NOT
	14B5    16  AND
	14B6    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	14D6    19  NOT
	14D7    16  AND
	14D8    81  DUP2
	14D9    52  MSTORE
	14DA    60  PUSH1 0x01
	14DC    01  ADD
	14DD    88  DUP9
	14DE    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	14FE    19  NOT
	14FF    16  AND
	1500    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1520    19  NOT
	1521    16  AND
	1522    81  DUP2
	1523    52  MSTORE
	1524    60  PUSH1 0x01
	1526    01  ADD
	1527    87  DUP8
	1528    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1548    19  NOT
	1549    16  AND
	154A    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	156A    19  NOT
	156B    16  AND
	156C    81  DUP2
	156D    52  MSTORE
	156E    60  PUSH1 0x01
	1570    01  ADD
	1571    86  DUP7
	1572    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1592    19  NOT
	1593    16  AND
	1594    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	15B4    19  NOT
	15B5    16  AND
	15B6    81  DUP2
	15B7    52  MSTORE
	15B8    60  PUSH1 0x01
	15BA    01  ADD
	15BB    85  DUP6
	15BC    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	15DC    19  NOT
	15DD    16  AND
	15DE    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	15FE    19  NOT
	15FF    16  AND
	1600    81  DUP2
	1601    52  MSTORE
	1602    60  PUSH1 0x01
	1604    01  ADD
	1605    84  DUP5
	1606    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1626    19  NOT
	1627    16  AND
	1628    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1648    19  NOT
	1649    16  AND
	164A    81  DUP2
	164B    52  MSTORE
	164C    60  PUSH1 0x01
	164E    01  ADD
	164F    83  DUP4
	1650    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1670    19  NOT
	1671    16  AND
	1672    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1692    19  NOT
	1693    16  AND
	1694    81  DUP2
	1695    52  MSTORE
	1696    60  PUSH1 0x01
	1698    01  ADD
	1699    82  DUP3
	169A    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	16BA    19  NOT
	16BB    16  AND
	16BC    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	16DC    19  NOT
	16DD    16  AND
	16DE    81  DUP2
	16DF    52  MSTORE
	16E0    60  PUSH1 0x01
	16E2    01  ADD
	16E3    98  SWAP9
	16E4    50  POP
	16E5    50  POP
	16E6    50  POP
	16E7    50  POP
	16E8    50  POP
	16E9    50  POP
	16EA    50  POP
	16EB    50  POP
	16EC    50  POP
	16ED    60  PUSH1 0x40
	16EF    51  MLOAD
	16F0    80  DUP1
	16F1    91  SWAP2
	16F2    03  SUB
	16F3    90  SWAP1
	16F4    20  SHA3
	16F5    60  PUSH1 0x00
	16F7    19  NOT
	16F8    16  AND
	16F9    82  DUP3
	16FA    82  DUP3
	16FB    81  DUP2
	16FC    15  ISZERO
	16FD    15  ISZERO
	16FE    61  PUSH2 0x1703
	1701    57  *JUMPI
	// Stack delta = -6
	// Outputs[11]
	// {
	//     @14D9  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-9]
	//     @1523  memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-8]
	//     @156D  memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-7]
	//     @15B7  memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-6]
	//     @1601  memory[0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @164B  memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @1695  memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @16DF  memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @16F8  stack[-9] = ~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	//     @16F9  stack[-8] = stack[-11]
	//     @16FA  stack[-7] = stack[-10]
	// }
	// Block ends with conditional jump to 0x1703, if !!stack[-11]

label_1702:
	// Incoming jump from 0x1701, if not !!stack[-11]
	1702    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1702  assert(); }
	// Block terminates

label_1703:
	// Incoming jump from 0x1701, if !!stack[-11]
	// Inputs[6]
	// {
	//     @1704  stack[-1]
	//     @1704  stack[-2]
	//     @1722  memory[0x40:0x60]
	//     @1765  memory[0x40:0x60]
	//     @176A  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @176F  stack[-3]
	// }
	1703    5B  JUMPDEST
	1704    04  DIV
	1705    78  PUSH25 0x01000000000000000000000000000000000000000000000000
	171F    02  MUL
	1720    60  PUSH1 0x40
	1722    51  MLOAD
	1723    80  DUP1
	1724    82  DUP3
	1725    77  PUSH24 0xffffffffffffffffffffffffffffffffffffffffffffffff
	173E    19  NOT
	173F    16  AND
	1740    77  PUSH24 0xffffffffffffffffffffffffffffffffffffffffffffffff
	1759    19  NOT
	175A    16  AND
	175B    81  DUP2
	175C    52  MSTORE
	175D    60  PUSH1 0x08
	175F    01  ADD
	1760    91  SWAP2
	1761    50  POP
	1762    50  POP
	1763    60  PUSH1 0x40
	1765    51  MLOAD
	1766    80  DUP1
	1767    91  SWAP2
	1768    03  SUB
	1769    90  SWAP1
	176A    20  SHA3
	176B    60  PUSH1 0x00
	176D    19  NOT
	176E    16  AND
	176F    14  EQ
	1770    15  ISZERO
	1771    15  ISZERO
	1772    61  PUSH2 0x1779
	1775    57  *JUMPI
	// Stack delta = -3
	// Outputs[1] { @175C  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffff & 0x01000000000000000000000000000000000000000000000000 * (stack[-1] / stack[-2]) }
	// Block ends with conditional jump to 0x1779, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3])

label_1776:
	// Incoming jump from 0x1775, if not !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3])
	1776    60  PUSH1 0x38
	1778    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_1779:
	// Incoming jump from 0x1775, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3])
	1779    5B  JUMPDEST
	177A    61  PUSH2 0x1781
	177D    61  PUSH2 0x1dbd
	1780    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @177A  stack[0] = 0x1781 }
	// Block ends with call to 0x1dbd, returns to 0x1781

label_1781:
	// Incoming return from call to 0x1DBD at 0x1780
	// Inputs[5]
	// {
	//     @1782  address(this)
	//     @179E  stack[-3]
	//     @17A1  memory[0x40:0x60]
	//     @17DA  memory[stack[-3]:stack[-3] + 0x20]
	//     @17E3  memory[stack[-3]:stack[-3] + 0x20]
	// }
	1781    5B  JUMPDEST
	1782    30  ADDRESS
	1783    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1798    16  AND
	1799    63  PUSH4 0xb220f73c
	179E    84  DUP5
	179F    60  PUSH1 0x40
	17A1    51  MLOAD
	17A2    82  DUP3
	17A3    63  PUSH4 0xffffffff
	17A8    16  AND
	17A9    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	17C7    02  MUL
	17C8    81  DUP2
	17C9    52  MSTORE
	17CA    60  PUSH1 0x04
	17CC    01  ADD
	17CD    80  DUP1
	17CE    80  DUP1
	17CF    60  PUSH1 0x20
	17D1    01  ADD
	17D2    82  DUP3
	17D3    81  DUP2
	17D4    03  SUB
	17D5    82  DUP3
	17D6    52  MSTORE
	17D7    83  DUP4
	17D8    81  DUP2
	17D9    81  DUP2
	17DA    51  MLOAD
	17DB    81  DUP2
	17DC    52  MSTORE
	17DD    60  PUSH1 0x20
	17DF    01  ADD
	17E0    91  SWAP2
	17E1    50  POP
	17E2    80  DUP1
	17E3    51  MLOAD
	17E4    90  SWAP1
	17E5    60  PUSH1 0x20
	17E7    01  ADD
	17E8    90  SWAP1
	17E9    80  DUP1
	17EA    83  DUP4
	17EB    83  DUP4
	17EC    60  PUSH1 0x00
	17EE    5B  JUMPDEST
	17EF    83  DUP4
	17F0    81  DUP2
	17F1    10  LT
	17F2    15  ISZERO
	17F3    61  PUSH2 0x1809
	17F6    57  *JUMPI
	// Stack delta = +12
	// Outputs[15]
	// {
	//     @1798  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @1799  stack[1] = 0xb220f73c
	//     @179E  stack[2] = stack[-3]
	//     @17C9  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xb220f73c)
	//     @17CC  stack[3] = 0x04 + memory[0x40:0x60]
	//     @17CD  stack[4] = 0x04 + memory[0x40:0x60]
	//     @17D6  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @17DC  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20]
	//     @17E0  stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @17E8  stack[6] = 0x20 + stack[-3]
	//     @17E8  stack[7] = memory[stack[-3]:stack[-3] + 0x20]
	//     @17E9  stack[8] = memory[stack[-3]:stack[-3] + 0x20]
	//     @17EA  stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @17EB  stack[10] = 0x20 + stack[-3]
	//     @17EC  stack[11] = 0x00
	// }
	// Block ends with conditional jump to 0x1809, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20])

label_17F7:
	// Incoming jump from 0x17F6, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20])
	// Incoming jump from 0x17F6, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @17F7  stack[-1]
	//     @17F8  stack[-2]
	//     @17FA  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @17FC  stack[-3]
	// }
	17F7    80  DUP1
	17F8    82  DUP3
	17F9    01  ADD
	17FA    51  MLOAD
	17FB    81  DUP2
	17FC    84  DUP5
	17FD    01  ADD
	17FE    52  MSTORE
	17FF    60  PUSH1 0x20
	1801    81  DUP2
	1802    01  ADD
	1803    90  SWAP1
	1804    50  POP
	1805    61  PUSH2 0x17ee
	1808    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @17FE  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1803  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x17ee

label_1809:
	// Incoming jump from 0x17F6, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20])
	// Incoming jump from 0x17F6, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @180E  stack[-5]
	//     @180E  stack[-6]
	//     @1810  stack[-7]
	// }
	1809    5B  JUMPDEST
	180A    50  POP
	180B    50  POP
	180C    50  POP
	180D    50  POP
	180E    90  SWAP1
	180F    50  POP
	1810    90  SWAP1
	1811    81  DUP2
	1812    01  ADD
	1813    90  SWAP1
	1814    60  PUSH1 0x1f
	1816    16  AND
	1817    80  DUP1
	1818    15  ISZERO
	1819    61  PUSH2 0x1836
	181C    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1813  stack[-7] = stack[-5] + stack[-7]
	//     @1816  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x1836, if !(0x1f & stack[-5])

label_181D:
	// Incoming jump from 0x181C, if not !(0x1f & stack[-5])
	// Inputs[7]
	// {
	//     @181D  stack[-1]
	//     @181E  stack[-2]
	//     @1821  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1838  stack[-5]
	//     @1840  memory[0x40:0x60]
	//     @1847  stack[-7]
	//     @1849  address(stack[-7]).code.length
	// }
	181D    80  DUP1
	181E    82  DUP3
	181F    03  SUB
	1820    80  DUP1
	1821    51  MLOAD
	1822    60  PUSH1 0x01
	1824    83  DUP4
	1825    60  PUSH1 0x20
	1827    03  SUB
	1828    61  PUSH2 0x0100
	182B    0A  EXP
	182C    03  SUB
	182D    19  NOT
	182E    16  AND
	182F    81  DUP2
	1830    52  MSTORE
	1831    60  PUSH1 0x20
	1833    01  ADD
	1834    91  SWAP2
	1835    50  POP
	1836    5B  JUMPDEST
	1837    50  POP
	1838    92  SWAP3
	1839    50  POP
	183A    50  POP
	183B    50  POP
	183C    60  PUSH1 0x00
	183E    60  PUSH1 0x40
	1840    51  MLOAD
	1841    80  DUP1
	1842    83  DUP4
	1843    03  SUB
	1844    81  DUP2
	1845    60  PUSH1 0x00
	1847    87  DUP8
	1848    80  DUP1
	1849    3B  EXTCODESIZE
	184A    15  ISZERO
	184B    15  ISZERO
	184C    61  PUSH2 0x1854
	184F    57  *JUMPI
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @1830  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]
	//     @1838  stack[-5] = 0x20 + (stack[-2] - stack[-1])
	//     @183C  stack[-4] = 0x00
	//     @1840  stack[-3] = memory[0x40:0x60]
	//     @1843  stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]
	//     @1844  stack[-1] = memory[0x40:0x60]
	//     @1845  stack[0] = 0x00
	//     @1847  stack[1] = stack[-7]
	// }
	// Block ends with conditional jump to 0x1854, if !!address(stack[-7]).code.length

label_1850:
	// Incoming jump from 0x184F, if not !!address(stack[-7]).code.length
	// Incoming jump from 0x184F, if not !!address(stack[-7]).code.length
	// Inputs[1] { @1853  memory[0x00:0x00] }
	1850    60  PUSH1 0x00
	1852    80  DUP1
	1853    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1853  revert(memory[0x00:0x00]); }
	// Block terminates

label_1854:
	// Incoming jump from 0x184F, if !!address(stack[-7]).code.length
	// Incoming jump from 0x184F, if !!address(stack[-7]).code.length
	// Inputs[9]
	// {
	//     @1855  msg.gas
	//     @1856  stack[-5]
	//     @1856  stack[-3]
	//     @1856  address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @1856  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @1856  stack[-1]
	//     @1856  stack[-4]
	//     @1856  stack[-2]
	//     @1856  stack[-6]
	// }
	1854    5B  JUMPDEST
	1855    5A  GAS
	1856    F1  CALL
	1857    15  ISZERO
	1858    15  ISZERO
	1859    61  PUSH2 0x1861
	185C    57  *JUMPI
	// Stack delta = -6
	// Outputs[1] { @1856  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) }
	// Block ends with conditional jump to 0x1861, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])

label_185D:
	// Incoming jump from 0x185C, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @1860  memory[0x00:0x00] }
	185D    60  PUSH1 0x00
	185F    80  DUP1
	1860    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1860  revert(memory[0x00:0x00]); }
	// Block terminates

label_1861:
	// Incoming jump from 0x185C, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @1868  stack[-7] }
	1861    5B  JUMPDEST
	1862    50  POP
	1863    50  POP
	1864    50  POP
	1865    50  POP
	1866    50  POP
	1867    50  POP
	1868    56  *JUMP
	// Stack delta = -7
	// Block ends with unconditional jump to stack[-7]

label_1869:
	// Incoming call from 0x0297, returns to 0x0298
	// Inputs[1] { @1871  msg.value }
	1869    5B  JUMPDEST
	186A    60  PUSH1 0x00
	186C    80  DUP1
	186D    60  PUSH1 0x00
	186F    60  PUSH1 0x2a
	1871    34  CALLVALUE
	1872    14  EQ
	1873    15  ISZERO
	1874    15  ISZERO
	1875    61  PUSH2 0x187c
	1878    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @186A  stack[0] = 0x00
	//     @186C  stack[1] = 0x00
	//     @186D  stack[2] = 0x00
	// }
	// Block ends with conditional jump to 0x187c, if !!(msg.value == 0x2a)

label_1879:
	// Incoming jump from 0x1878, if not !!(msg.value == 0x2a)
	1879    60  PUSH1 0x00
	187B    FF  *SELFDESTRUCT
	// Stack delta = +0
	// Outputs[1] { @187B  selfdestruct(0x00); }
	// Block terminates

label_187C:
	// Incoming jump from 0x1878, if !!(msg.value == 0x2a)
	187C    5B  JUMPDEST
	187D    61  PUSH2 0x1884
	1880    61  PUSH2 0x1dbd
	1883    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @187D  stack[0] = 0x1884 }
	// Block ends with call to 0x1dbd, returns to 0x1884

label_1884:
	// Incoming return from call to 0x1DBD at 0x1883
	// Inputs[1] { @1889  tx.gasprice }
	1884    5B  JUMPDEST
	1885    62  PUSH3 0x066a44
	1889    3A  GASPRICE
	188A    14  EQ
	188B    15  ISZERO
	188C    15  ISZERO
	188D    61  PUSH2 0x1894
	1890    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x1894, if !!(tx.gasprice == 0x066a44)

label_1891:
	// Incoming jump from 0x1890, if not !!(tx.gasprice == 0x066a44)
	1891    60  PUSH1 0x38
	1893    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_1894:
	// Incoming jump from 0x1890, if !!(tx.gasprice == 0x066a44)
	1894    5B  JUMPDEST
	1895    61  PUSH2 0x189c
	1898    61  PUSH2 0x1dbd
	189B    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1895  stack[0] = 0x189c }
	// Block ends with call to 0x1dbd, returns to 0x189C

label_189C:
	// Incoming return from call to 0x1DBD at 0x189B
	// Inputs[2]
	// {
	//     @189D  stack[-4]
	//     @18A1  memory[stack[-4]:stack[-4] + 0x20]
	// }
	189C    5B  JUMPDEST
	189D    83  DUP4
	189E    60  PUSH1 0x1a
	18A0    81  DUP2
	18A1    51  MLOAD
	18A2    81  DUP2
	18A3    10  LT
	18A4    15  ISZERO
	18A5    15  ISZERO
	18A6    61  PUSH2 0x18ab
	18A9    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @189D  stack[0] = stack[-4]
	//     @189E  stack[1] = 0x1a
	// }
	// Block ends with conditional jump to 0x18ab, if !!(0x1a < memory[stack[-4]:stack[-4] + 0x20])

label_18AA:
	// Incoming jump from 0x18A9, if not !!(0x1a < memory[stack[-4]:stack[-4] + 0x20])
	18AA    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @18AA  assert(); }
	// Block terminates

label_18AB:
	// Incoming jump from 0x18A9, if !!(0x1a < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[5]
	// {
	//     @18AC  stack[-2]
	//     @18AC  stack[-1]
	//     @18B1  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @18F7  stack[-6]
	//     @18FB  memory[stack[-6]:stack[-6] + 0x20]
	// }
	18AB    5B  JUMPDEST
	18AC    90  SWAP1
	18AD    60  PUSH1 0x20
	18AF    01  ADD
	18B0    01  ADD
	18B1    51  MLOAD
	18B2    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	18D3    90  SWAP1
	18D4    04  DIV
	18D5    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	18F6    02  MUL
	18F7    84  DUP5
	18F8    60  PUSH1 0x1b
	18FA    81  DUP2
	18FB    51  MLOAD
	18FC    81  DUP2
	18FD    10  LT
	18FE    15  ISZERO
	18FF    15  ISZERO
	1900    61  PUSH2 0x1905
	1903    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @18F6  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @18F7  stack[-1] = stack[-6]
	//     @18F8  stack[0] = 0x1b
	// }
	// Block ends with conditional jump to 0x1905, if !!(0x1b < memory[stack[-6]:stack[-6] + 0x20])

label_1904:
	// Incoming jump from 0x1903, if not !!(0x1b < memory[stack[-6]:stack[-6] + 0x20])
	1904    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1904  assert(); }
	// Block terminates

label_1905:
	// Incoming jump from 0x1903, if !!(0x1b < memory[stack[-6]:stack[-6] + 0x20])
	// Inputs[5]
	// {
	//     @1906  stack[-1]
	//     @1906  stack[-2]
	//     @190B  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1951  stack[-7]
	//     @1955  memory[stack[-7]:stack[-7] + 0x20]
	// }
	1905    5B  JUMPDEST
	1906    90  SWAP1
	1907    60  PUSH1 0x20
	1909    01  ADD
	190A    01  ADD
	190B    51  MLOAD
	190C    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	192D    90  SWAP1
	192E    04  DIV
	192F    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1950    02  MUL
	1951    85  DUP6
	1952    60  PUSH1 0x1c
	1954    81  DUP2
	1955    51  MLOAD
	1956    81  DUP2
	1957    10  LT
	1958    15  ISZERO
	1959    15  ISZERO
	195A    61  PUSH2 0x195f
	195D    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1950  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1951  stack[-1] = stack[-7]
	//     @1952  stack[0] = 0x1c
	// }
	// Block ends with conditional jump to 0x195f, if !!(0x1c < memory[stack[-7]:stack[-7] + 0x20])

label_195E:
	// Incoming jump from 0x195D, if not !!(0x1c < memory[stack[-7]:stack[-7] + 0x20])
	195E    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @195E  assert(); }
	// Block terminates

label_195F:
	// Incoming jump from 0x195D, if !!(0x1c < memory[stack[-7]:stack[-7] + 0x20])
	// Inputs[5]
	// {
	//     @1960  stack[-1]
	//     @1960  stack[-2]
	//     @1965  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @19AB  stack[-8]
	//     @19AF  memory[stack[-8]:stack[-8] + 0x20]
	// }
	195F    5B  JUMPDEST
	1960    90  SWAP1
	1961    60  PUSH1 0x20
	1963    01  ADD
	1964    01  ADD
	1965    51  MLOAD
	1966    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1987    90  SWAP1
	1988    04  DIV
	1989    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	19AA    02  MUL
	19AB    86  DUP7
	19AC    60  PUSH1 0x1d
	19AE    81  DUP2
	19AF    51  MLOAD
	19B0    81  DUP2
	19B1    10  LT
	19B2    15  ISZERO
	19B3    15  ISZERO
	19B4    61  PUSH2 0x19b9
	19B7    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @19AA  stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @19AB  stack[-1] = stack[-8]
	//     @19AC  stack[0] = 0x1d
	// }
	// Block ends with conditional jump to 0x19b9, if !!(0x1d < memory[stack[-8]:stack[-8] + 0x20])

label_19B8:
	// Incoming jump from 0x19B7, if not !!(0x1d < memory[stack[-8]:stack[-8] + 0x20])
	19B8    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @19B8  assert(); }
	// Block terminates

label_19B9:
	// Incoming jump from 0x19B7, if !!(0x1d < memory[stack[-8]:stack[-8] + 0x20])
	// Inputs[10]
	// {
	//     @19BA  stack[-1]
	//     @19BA  stack[-2]
	//     @19BF  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1A07  memory[0x40:0x60]
	//     @1A09  stack[-5]
	//     @1A53  stack[-4]
	//     @1A9D  stack[-3]
	//     @1B39  memory[0x40:0x60]
	//     @1B3E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @1B3F  stack[-8]
	// }
	19B9    5B  JUMPDEST
	19BA    90  SWAP1
	19BB    60  PUSH1 0x20
	19BD    01  ADD
	19BE    01  ADD
	19BF    51  MLOAD
	19C0    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	19E1    90  SWAP1
	19E2    04  DIV
	19E3    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1A04    02  MUL
	1A05    60  PUSH1 0x40
	1A07    51  MLOAD
	1A08    80  DUP1
	1A09    85  DUP6
	1A0A    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1A2A    19  NOT
	1A2B    16  AND
	1A2C    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1A4C    19  NOT
	1A4D    16  AND
	1A4E    81  DUP2
	1A4F    52  MSTORE
	1A50    60  PUSH1 0x01
	1A52    01  ADD
	1A53    84  DUP5
	1A54    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1A74    19  NOT
	1A75    16  AND
	1A76    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1A96    19  NOT
	1A97    16  AND
	1A98    81  DUP2
	1A99    52  MSTORE
	1A9A    60  PUSH1 0x01
	1A9C    01  ADD
	1A9D    83  DUP4
	1A9E    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1ABE    19  NOT
	1ABF    16  AND
	1AC0    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1AE0    19  NOT
	1AE1    16  AND
	1AE2    81  DUP2
	1AE3    52  MSTORE
	1AE4    60  PUSH1 0x01
	1AE6    01  ADD
	1AE7    82  DUP3
	1AE8    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1B08    19  NOT
	1B09    16  AND
	1B0A    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1B2A    19  NOT
	1B2B    16  AND
	1B2C    81  DUP2
	1B2D    52  MSTORE
	1B2E    60  PUSH1 0x01
	1B30    01  ADD
	1B31    94  SWAP5
	1B32    50  POP
	1B33    50  POP
	1B34    50  POP
	1B35    50  POP
	1B36    50  POP
	1B37    60  PUSH1 0x40
	1B39    51  MLOAD
	1B3A    80  DUP1
	1B3B    91  SWAP2
	1B3C    03  SUB
	1B3D    90  SWAP1
	1B3E    20  SHA3
	1B3F    92  SWAP3
	1B40    50  POP
	1B41    61  PUSH2 0x1b48
	1B44    61  PUSH2 0x1dbd
	1B47    56  *JUMP
	// Stack delta = -4
	// Outputs[6]
	// {
	//     @1A4F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5]
	//     @1A99  memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4]
	//     @1AE3  memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3]
	//     @1B2D  memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)
	//     @1B3F  stack[-8] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]])
	//     @1B41  stack[-5] = 0x1b48
	// }
	// Block ends with call to 0x1dbd, returns to 0x1B48

label_1B48:
	// Incoming return from call to 0x1DBD at 0x1B47
	// Inputs[3]
	// {
	//     @1B4B  stack[-2]
	//     @1B4E  stack[-4]
	//     @1B4F  memory[stack[-4]:stack[-4] + 0x20]
	// }
	1B48    5B  JUMPDEST
	1B49    60  PUSH1 0x00
	1B4B    91  SWAP2
	1B4C    50  POP
	1B4D    5B  JUMPDEST
	1B4E    83  DUP4
	1B4F    51  MLOAD
	1B50    82  DUP3
	1B51    10  LT
	1B52    15  ISZERO
	1B53    61  PUSH2 0x1c0f
	1B56    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @1B4B  stack[-2] = 0x00 }
	// Block ends with conditional jump to 0x1c0f, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])

label_1B57:
	// Incoming jump from 0x1B56, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Incoming jump from 0x1B56, if not !(stack[-2] < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[4]
	// {
	//     @1B57  msg.value
	//     @1B7A  stack[-4]
	//     @1B7B  stack[-2]
	//     @1B7D  memory[stack[-4]:stack[-4] + 0x20]
	// }
	1B57    34  CALLVALUE
	1B58    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1B79    02  MUL
	1B7A    84  DUP5
	1B7B    83  DUP4
	1B7C    81  DUP2
	1B7D    51  MLOAD
	1B7E    81  DUP2
	1B7F    10  LT
	1B80    15  ISZERO
	1B81    15  ISZERO
	1B82    61  PUSH2 0x1b87
	1B85    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @1B79  stack[0] = 0x0100000000000000000000000000000000000000000000000000000000000000 * msg.value
	//     @1B7A  stack[1] = stack[-4]
	//     @1B7B  stack[2] = stack[-2]
	// }
	// Block ends with conditional jump to 0x1b87, if !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20])

label_1B86:
	// Incoming jump from 0x1B85, if not !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20])
	1B86    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @1B86  assert(); }
	// Block terminates

label_1B87:
	// Incoming jump from 0x1B85, if !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[5]
	// {
	//     @1B88  stack[-2]
	//     @1B88  stack[-1]
	//     @1B8D  stack[-3]
	//     @1B8F  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20]
	//     @1C03  stack[-5]
	// }
	1B87    5B  JUMPDEST
	1B88    90  SWAP1
	1B89    60  PUSH1 0x20
	1B8B    01  ADD
	1B8C    01  ADD
	1B8D    81  DUP2
	1B8E    81  DUP2
	1B8F    51  MLOAD
	1B90    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1BB1    90  SWAP1
	1BB2    04  DIV
	1BB3    7F  PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000
	1BD4    02  MUL
	1BD5    18  XOR
	1BD6    91  SWAP2
	1BD7    50  POP
	1BD8    90  SWAP1
	1BD9    7E  PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1BF9    19  NOT
	1BFA    16  AND
	1BFB    90  SWAP1
	1BFC    81  DUP2
	1BFD    60  PUSH1 0x00
	1BFF    1A  BYTE
	1C00    90  SWAP1
	1C01    53  MSTORE8
	1C02    50  POP
	1C03    81  DUP2
	1C04    80  DUP1
	1C05    60  PUSH1 0x01
	1C07    01  ADD
	1C08    92  SWAP3
	1C09    50  POP
	1C0A    50  POP
	1C0B    61  PUSH2 0x1b4d
	1C0E    56  *JUMP
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @1C01  memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) ~ stack[-3]), 0x00)
	//     @1C08  stack[-5] = 0x01 + stack[-5]
	// }
	// Block ends with unconditional jump to 0x1b4d

label_1C0F:
	// Incoming jump from 0x1B56, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Incoming jump from 0x1B56, if !(stack[-2] < memory[stack[-4]:stack[-4] + 0x20])
	1C0F    5B  JUMPDEST
	1C10    61  PUSH2 0x1c17
	1C13    61  PUSH2 0x1dbd
	1C16    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1C10  stack[0] = 0x1c17 }
	// Block ends with call to 0x1dbd, returns to 0x1C17

label_1C17:
	// Incoming return from call to 0x1DBD at 0x1C16
	// Inputs[5]
	// {
	//     @1C18  address(this)
	//     @1C34  stack[-4]
	//     @1C37  memory[0x40:0x60]
	//     @1C70  memory[stack[-4]:stack[-4] + 0x20]
	//     @1C79  memory[stack[-4]:stack[-4] + 0x20]
	// }
	1C17    5B  JUMPDEST
	1C18    30  ADDRESS
	1C19    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	1C2E    16  AND
	1C2F    63  PUSH4 0xd6385778
	1C34    85  DUP6
	1C35    60  PUSH1 0x40
	1C37    51  MLOAD
	1C38    82  DUP3
	1C39    63  PUSH4 0xffffffff
	1C3E    16  AND
	1C3F    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	1C5D    02  MUL
	1C5E    81  DUP2
	1C5F    52  MSTORE
	1C60    60  PUSH1 0x04
	1C62    01  ADD
	1C63    80  DUP1
	1C64    80  DUP1
	1C65    60  PUSH1 0x20
	1C67    01  ADD
	1C68    82  DUP3
	1C69    81  DUP2
	1C6A    03  SUB
	1C6B    82  DUP3
	1C6C    52  MSTORE
	1C6D    83  DUP4
	1C6E    81  DUP2
	1C6F    81  DUP2
	1C70    51  MLOAD
	1C71    81  DUP2
	1C72    52  MSTORE
	1C73    60  PUSH1 0x20
	1C75    01  ADD
	1C76    91  SWAP2
	1C77    50  POP
	1C78    80  DUP1
	1C79    51  MLOAD
	1C7A    90  SWAP1
	1C7B    60  PUSH1 0x20
	1C7D    01  ADD
	1C7E    90  SWAP1
	1C7F    80  DUP1
	1C80    83  DUP4
	1C81    83  DUP4
	1C82    60  PUSH1 0x00
	1C84    5B  JUMPDEST
	1C85    83  DUP4
	1C86    81  DUP2
	1C87    10  LT
	1C88    15  ISZERO
	1C89    61  PUSH2 0x1c9f
	1C8C    57  *JUMPI
	// Stack delta = +12
	// Outputs[15]
	// {
	//     @1C2E  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this)
	//     @1C2F  stack[1] = 0xd6385778
	//     @1C34  stack[2] = stack[-4]
	//     @1C5F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xd6385778)
	//     @1C62  stack[3] = 0x04 + memory[0x40:0x60]
	//     @1C63  stack[4] = 0x04 + memory[0x40:0x60]
	//     @1C6C  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60])
	//     @1C72  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-4]:stack[-4] + 0x20]
	//     @1C76  stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @1C7E  stack[6] = 0x20 + stack[-4]
	//     @1C7E  stack[7] = memory[stack[-4]:stack[-4] + 0x20]
	//     @1C7F  stack[8] = memory[stack[-4]:stack[-4] + 0x20]
	//     @1C80  stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @1C81  stack[10] = 0x20 + stack[-4]
	//     @1C82  stack[11] = 0x00
	// }
	// Block ends with conditional jump to 0x1c9f, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])

label_1C8D:
	// Incoming jump from 0x1C8C, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x1C8C, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[4]
	// {
	//     @1C8D  stack[-1]
	//     @1C8E  stack[-2]
	//     @1C90  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1C92  stack[-3]
	// }
	1C8D    80  DUP1
	1C8E    82  DUP3
	1C8F    01  ADD
	1C90    51  MLOAD
	1C91    81  DUP2
	1C92    84  DUP5
	1C93    01  ADD
	1C94    52  MSTORE
	1C95    60  PUSH1 0x20
	1C97    81  DUP2
	1C98    01  ADD
	1C99    90  SWAP1
	1C9A    50  POP
	1C9B    61  PUSH2 0x1c84
	1C9E    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @1C94  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @1C99  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x1c84

label_1C9F:
	// Incoming jump from 0x1C8C, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x1C8C, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20])
	// Inputs[3]
	// {
	//     @1CA4  stack[-6]
	//     @1CA4  stack[-5]
	//     @1CA6  stack[-7]
	// }
	1C9F    5B  JUMPDEST
	1CA0    50  POP
	1CA1    50  POP
	1CA2    50  POP
	1CA3    50  POP
	1CA4    90  SWAP1
	1CA5    50  POP
	1CA6    90  SWAP1
	1CA7    81  DUP2
	1CA8    01  ADD
	1CA9    90  SWAP1
	1CAA    60  PUSH1 0x1f
	1CAC    16  AND
	1CAD    80  DUP1
	1CAE    15  ISZERO
	1CAF    61  PUSH2 0x1ccc
	1CB2    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @1CA9  stack[-7] = stack[-5] + stack[-7]
	//     @1CAC  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x1ccc, if !(0x1f & stack[-5])

label_1CB3:
	// Incoming jump from 0x1CB2, if not !(0x1f & stack[-5])
	// Inputs[7]
	// {
	//     @1CB3  stack[-1]
	//     @1CB4  stack[-2]
	//     @1CB7  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @1CCE  stack[-5]
	//     @1CD6  memory[0x40:0x60]
	//     @1CDD  stack[-7]
	//     @1CDF  address(stack[-7]).code.length
	// }
	1CB3    80  DUP1
	1CB4    82  DUP3
	1CB5    03  SUB
	1CB6    80  DUP1
	1CB7    51  MLOAD
	1CB8    60  PUSH1 0x01
	1CBA    83  DUP4
	1CBB    60  PUSH1 0x20
	1CBD    03  SUB
	1CBE    61  PUSH2 0x0100
	1CC1    0A  EXP
	1CC2    03  SUB
	1CC3    19  NOT
	1CC4    16  AND
	1CC5    81  DUP2
	1CC6    52  MSTORE
	1CC7    60  PUSH1 0x20
	1CC9    01  ADD
	1CCA    91  SWAP2
	1CCB    50  POP
	1CCC    5B  JUMPDEST
	1CCD    50  POP
	1CCE    92  SWAP3
	1CCF    50  POP
	1CD0    50  POP
	1CD1    50  POP
	1CD2    60  PUSH1 0x00
	1CD4    60  PUSH1 0x40
	1CD6    51  MLOAD
	1CD7    80  DUP1
	1CD8    83  DUP4
	1CD9    03  SUB
	1CDA    81  DUP2
	1CDB    60  PUSH1 0x00
	1CDD    87  DUP8
	1CDE    80  DUP1
	1CDF    3B  EXTCODESIZE
	1CE0    15  ISZERO
	1CE1    15  ISZERO
	1CE2    61  PUSH2 0x1cea
	1CE5    57  *JUMPI
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @1CC6  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]
	//     @1CCE  stack[-5] = 0x20 + (stack[-2] - stack[-1])
	//     @1CD2  stack[-4] = 0x00
	//     @1CD6  stack[-3] = memory[0x40:0x60]
	//     @1CD9  stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]
	//     @1CDA  stack[-1] = memory[0x40:0x60]
	//     @1CDB  stack[0] = 0x00
	//     @1CDD  stack[1] = stack[-7]
	// }
	// Block ends with conditional jump to 0x1cea, if !!address(stack[-7]).code.length

label_1CE6:
	// Incoming jump from 0x1CE5, if not !!address(stack[-7]).code.length
	// Incoming jump from 0x1CE5, if not !!address(stack[-7]).code.length
	// Inputs[1] { @1CE9  memory[0x00:0x00] }
	1CE6    60  PUSH1 0x00
	1CE8    80  DUP1
	1CE9    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1CE9  revert(memory[0x00:0x00]); }
	// Block terminates

label_1CEA:
	// Incoming jump from 0x1CE5, if !!address(stack[-7]).code.length
	// Incoming jump from 0x1CE5, if !!address(stack[-7]).code.length
	// Inputs[9]
	// {
	//     @1CEB  msg.gas
	//     @1CEC  stack[-5]
	//     @1CEC  stack[-1]
	//     @1CEC  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @1CEC  stack[-2]
	//     @1CEC  address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @1CEC  stack[-6]
	//     @1CEC  stack[-3]
	//     @1CEC  stack[-4]
	// }
	1CEA    5B  JUMPDEST
	1CEB    5A  GAS
	1CEC    F1  CALL
	1CED    15  ISZERO
	1CEE    15  ISZERO
	1CEF    61  PUSH2 0x1cf7
	1CF2    57  *JUMPI
	// Stack delta = -6
	// Outputs[1] { @1CEC  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) }
	// Block ends with conditional jump to 0x1cf7, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])

label_1CF3:
	// Incoming jump from 0x1CF2, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[1] { @1CF6  memory[0x00:0x00] }
	1CF3    60  PUSH1 0x00
	1CF5    80  DUP1
	1CF6    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1CF6  revert(memory[0x00:0x00]); }
	// Block terminates

label_1CF7:
	// Incoming jump from 0x1CF2, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @1D04  stack[-4]
	//     @1D07  msg.value
	// }
	1CF7    5B  JUMPDEST
	1CF8    50  POP
	1CF9    50  POP
	1CFA    50  POP
	1CFB    67  PUSH8 0x73686974636f696e
	1D04    90  SWAP1
	1D05    50  POP
	1D06    80  DUP1
	1D07    34  CALLVALUE
	1D08    14  EQ
	1D09    15  ISZERO
	1D0A    61  PUSH2 0x1d11
	1D0D    57  *JUMPI
	// Stack delta = -3
	// Outputs[1] { @1D04  stack[-4] = 0x73686974636f696e }
	// Block ends with conditional jump to 0x1d11, if !(msg.value == 0x73686974636f696e)

label_1D0E:
	// Incoming jump from 0x1D0D, if not !(msg.value == 0x73686974636f696e)
	1D0E    60  PUSH1 0x38
	1D10    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_1D11:
	// Incoming jump from 0x1D0D, if !(msg.value == 0x73686974636f696e)
	1D11    5B  JUMPDEST
	1D12    61  PUSH2 0x1d19
	1D15    61  PUSH2 0x1dbd
	1D18    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1D12  stack[0] = 0x1d19 }
	// Block ends with call to 0x1dbd, returns to 0x1D19

label_1D19:
	// Incoming return from call to 0x1DBD at 0x1D18
	// Inputs[4]
	// {
	//     @1D21  msg.sender
	//     @1D22  address(msg.sender).code[0x59:0x5d]
	//     @1D26  memory[0x0200:0x0220]
	//     @1D27  stack[-1]
	// }
	1D19    5B  JUMPDEST
	1D1A    60  PUSH1 0x04
	1D1C    60  PUSH1 0x59
	1D1E    61  PUSH2 0x021c
	1D21    33  CALLER
	1D22    3C  EXTCODECOPY
	1D23    61  PUSH2 0x0200
	1D26    51  MLOAD
	1D27    90  SWAP1
	1D28    50  POP
	1D29    61  PUSH2 0x1d30
	1D2C    61  PUSH2 0x1dbd
	1D2F    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1D22  memory[0x021c:0x0220] = address(msg.sender).code[0x59:0x5d]
	//     @1D27  stack[-1] = memory[0x0200:0x0220]
	//     @1D29  stack[0] = 0x1d30
	// }
	// Block ends with call to 0x1dbd, returns to 0x1D30

label_1D30:
	// Incoming return from call to 0x1DBD at 0x1D2F
	// Inputs[5]
	// {
	//     @1D31  stack[-3]
	//     @1D36  stack[-1]
	//     @1D58  memory[0x40:0x60]
	//     @1DA3  memory[0x40:0x60]
	//     @1DA8  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	1D30    5B  JUMPDEST
	1D31    82  DUP3
	1D32    60  PUSH1 0x00
	1D34    19  NOT
	1D35    16  AND
	1D36    81  DUP2
	1D37    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	1D55    02  MUL
	1D56    60  PUSH1 0x40
	1D58    51  MLOAD
	1D59    80  DUP1
	1D5A    82  DUP3
	1D5B    7B  PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1D78    19  NOT
	1D79    16  AND
	1D7A    7B  PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
	1D97    19  NOT
	1D98    16  AND
	1D99    81  DUP2
	1D9A    52  MSTORE
	1D9B    60  PUSH1 0x04
	1D9D    01  ADD
	1D9E    91  SWAP2
	1D9F    50  POP
	1DA0    50  POP
	1DA1    60  PUSH1 0x40
	1DA3    51  MLOAD
	1DA4    80  DUP1
	1DA5    91  SWAP2
	1DA6    03  SUB
	1DA7    90  SWAP1
	1DA8    20  SHA3
	1DA9    60  PUSH1 0x00
	1DAB    19  NOT
	1DAC    16  AND
	1DAD    14  EQ
	1DAE    15  ISZERO
	1DAF    15  ISZERO
	1DB0    61  PUSH2 0x1db7
	1DB3    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @1D9A  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000 * stack[-1] }
	// Block ends with conditional jump to 0x1db7, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3])

label_1DB4:
	// Incoming jump from 0x1DB3, if not !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3])
	1DB4    60  PUSH1 0x38
	1DB6    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0038

label_1DB7:
	// Incoming jump from 0x1DB3, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3])
	// Inputs[1] { @1DBC  stack[-5] }
	1DB7    5B  JUMPDEST
	1DB8    50  POP
	1DB9    50  POP
	1DBA    50  POP
	1DBB    50  POP
	1DBC    56  *JUMP
	// Stack delta = -5
	// Block ends with unconditional jump to stack[-5]

label_1DBD:
	// Incoming call from 0x1D18, returns to 0x1D19
	// Incoming call from 0x1B47, returns to 0x1B48
	// Incoming call from 0x0AE5, returns to 0x0AE6
	// Incoming call from 0x1883, returns to 0x1884
	// Incoming call from 0x1C16, returns to 0x1C17
	// Incoming call from 0x07EC, returns to 0x07ED
	// Incoming call from 0x0FDB, returns to 0x0FDC
	// Incoming call from 0x1780, returns to 0x1781
	// Incoming call from 0x11B1, returns to 0x11B2
	// Incoming call from 0x02CF, returns to 0x02D0
	// Incoming call from 0x0DD3, returns to 0x0DD4
	// Incoming call from 0x1D2F, returns to 0x1D30
	// Incoming call from 0x0E83, returns to 0x0E84
	// Incoming call from 0x10C7, returns to 0x10C8
	// Incoming call from 0x0C7B, returns to 0x0C7C
	// Incoming call from 0x071C, returns to 0x071D
	// Incoming call from 0x1177, returns to 0x1178
	// Incoming call from 0x189B, returns to 0x189C
	1DBD    5B  JUMPDEST
	1DBE    60  PUSH1 0x00
	1DC0    61  PUSH2 0x1dc6
	1DC3    01  ADD
	1DC4    80  DUP1
	1DC5    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1DC3  stack[0] = 0x1dc6 + 0x00 }
	// Block ends with unconditional jump to 0x1dc6 + 0x00

label_1DC6:
	// Incoming jump from 0x1DC5
	// Inputs[1] { @1DC8  stack[-2] }
	1DC6    5B  JUMPDEST
	1DC7    50  POP
	1DC8    56  *JUMP
	// Stack delta = -2
	// Block ends with unconditional jump to stack[-2]

	1DC9    00    *STOP
	1DCA    A1    LOG1
	1DCB    65    PUSH6 0x627a7a723058
	1DD2    20    SHA3
	1DD3    EA    EA
	1DD4    82    DUP3
	1DD5    3A    GASPRICE
	1DD6    E6    E6
	1DD7    4C    4C
	1DD8    4D    4D
	1DD9    0A    EXP
	1DDA    53    MSTORE8
	1DDB    8A    DUP11
	1DDC    62    PUSH3 0x5ed214
	1DE0    5F    5F
	1DE1    63    PUSH4 0x8d8dfa4a
	1DE6    01    ADD
	1DE7    54    SLOAD
	1DE8    A7    A7
	1DE9    DC    DC
	1DEA    19    NOT
	1DEB    EF    EF
	1DEC    EC    EC
	1DED    D1    D1
	1DEE    22    22
	1DEF    AE    AE
	1DF0    10    LT
	1DF1    12    SLT
	1DF2    C3    C3
	1DF3    00    *STOP
	1DF4    29    29