Online Solidity Decompiler

« Decompile another contract

Address

0xf97e0a5b616dffc913e72455fde9ea8bbe946a2b [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x0d9f5aed mixGenes(uint256,uint256,uint256)

0x1597ee44 encode(uint8[])

0x54c15b82 isGeneScience()

0x61a76900 decode(uint256)

0x77a74a20 expressingTraits(uint256)

Internal Methods

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

func_0468(arg0, arg1, arg4, arg8, arg10) returns (r0)

encode(arg0) returns (r0)

isGeneScience(arg0) returns (r0)

decode(arg0) returns (r0)

expressingTraits(arg0) returns (r0)

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

func_06F1(arg0, arg1) returns (r0)

func_0709() returns (r0)

func_071B() returns (r0)

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 == 0x0d9f5aed) {
            // Dispatch table entry for mixGenes(uint256,uint256,uint256)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var var1 = 0x008d;
            var var2 = msg.data[0x04:0x24];
            var var3 = msg.data[0x24:0x44];
            var var4 = msg.data[0x44:0x64];
            var1 = mixGenes(var2, var3, var4);
        
        label_008D:
            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 == 0x1597ee44) {
            // Dispatch table entry for encode(uint8[])
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x008d;
            var temp2 = msg.data[0x04:0x24];
            var temp3 = msg.data[temp2 + 0x04:temp2 + 0x04 + 0x20];
            var temp4 = memory[0x40:0x60];
            memory[0x40:0x60] = temp4 + temp3 * 0x20 + 0x20;
            memory[temp4:temp4 + 0x20] = temp3;
            var temp5 = temp3 * 0x20;
            memory[temp4 + 0x20:temp4 + 0x20 + temp5] = msg.data[temp2 + 0x24:temp2 + 0x24 + temp5];
            var2 = temp4;
            var1 = encode(var2);
            goto label_008D;
        } else if (var0 == 0x54c15b82) {
            // Dispatch table entry for isGeneScience()
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0101;
            var2 = isGeneScience();
            var temp6 = memory[0x40:0x60];
            memory[temp6:temp6 + 0x20] = !!var2;
            var temp7 = memory[0x40:0x60];
            return memory[temp7:temp7 + (temp6 + 0x20) - temp7];
        } else if (var0 == 0x61a76900) {
            // Dispatch table entry for decode(uint256)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x012b;
            var2 = msg.data[0x04:0x24];
            var1 = decode(var2);
            var temp8 = memory[0x40:0x60];
            var2 = temp8;
            memory[var2:var2 + 0x20] = 0x20;
            var3 = var2;
            var temp9 = var3 + 0x20;
            var temp10 = var1;
            memory[temp9:temp9 + 0x20] = memory[temp10:temp10 + 0x20];
            var4 = temp9 + 0x20;
            var var5 = temp10 + 0x20;
            var var6 = memory[temp10:temp10 + 0x20] * 0x20;
            var var7 = var6;
            var var8 = var4;
            var var9 = var5;
            var var10 = 0x00;
        
            if (var10 >= var7) {
            label_016A:
                var temp11 = memory[0x40:0x60];
                return memory[temp11:temp11 + (var6 + var4) - temp11];
            } else {
            label_015B:
                var temp12 = var10;
                memory[temp12 + var8:temp12 + var8 + 0x20] = memory[var9 + temp12:var9 + temp12 + 0x20];
                var10 = temp12 + 0x20;
            
                if (var10 >= var7) { goto label_016A; }
                else { goto label_015B; }
            }
        } else if (var0 == 0x77a74a20) {
            // Dispatch table entry for expressingTraits(uint256)
            if (msg.value) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0194;
            var2 = msg.data[0x04:0x24];
            var1 = expressingTraits(var2);
            var2 = memory[0x40:0x60];
            var3 = var2;
            var4 = var1;
            var5 = 0x0180;
            var6 = var5;
            var7 = var3;
            var8 = var4;
            var9 = 0x00;
        
            if (var9 >= var6) {
            label_01BA:
                var temp13 = memory[0x40:0x60];
                return memory[temp13:temp13 + (var5 + var3) - temp13];
            } else {
            label_01AB:
                var temp14 = var9;
                memory[temp14 + var7:temp14 + var7 + 0x20] = memory[var8 + temp14:var8 + temp14 + 0x20];
                var9 = temp14 + 0x20;
            
                if (var9 >= var6) { goto label_01BA; }
                else { goto label_01AB; }
            }
        } else { revert(memory[0x00:0x00]); }
    }
    
    function mixGenes(var arg0, var arg1, var arg2) returns (var r0) {
        var var0 = 0x00;
        var var1 = var0;
        var var2 = 0x00;
        var var3 = 0x01da;
        var3 = func_0709();
        var var4 = 0x01e2;
        var4 = func_0709();
        var var5 = 0x01ea;
        var5 = func_0709();
        var var6 = 0x00;
        var var7 = var6;
        var var8 = var7;
        var var9 = var8;
        var var10 = var9;
        var var11 = var10;
    
        if (block.number <= arg2) { revert(memory[0x00:0x00]); }
    
        var1 = block.blockHash(arg2);
    
        if (var1) {
        label_022B:
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = var1;
            var temp1 = temp0 + 0x20;
            memory[temp1:temp1 + 0x20] = arg0;
            var temp2 = temp1 + 0x20;
            memory[temp2:temp2 + 0x20] = arg1;
            var temp3 = temp2 + 0x20;
            memory[temp3:temp3 + 0x20] = arg2;
            var temp4 = memory[0x40:0x60];
            var1 = keccak256(memory[temp4:temp4 + (temp3 + 0x20) - temp4]);
            var2 = 0x00;
            var var12 = 0x0269;
            var var13 = arg0;
            var12 = decode(var13);
            var3 = var12;
            var12 = 0x0274;
            var13 = arg1;
            var12 = decode(var13);
            var4 = var12;
            var12 = 0x30;
            var13 = memory[0x40:0x60];
        
            if (MSIZE() < var13) {
                var temp5 = var13;
                var temp6 = var12;
                memory[temp5:temp5 + 0x20] = temp6;
                memory[0x40:0x60] = temp5 + temp6 * 0x20 + 0x20;
                var5 = temp5;
                var8 = 0x00;
            
                if (var8 >= 0x0c) {
                label_03EE:
                    var6 = 0x00;
                
                    if (var6 >= 0x30) {
                    label_053E:
                        var12 = 0x0547;
                        var13 = var5;
                        return encode(var13);
                    } else {
                    label_03FD:
                        var11 = 0x00;
                        var12 = !(var6 % 0x04);
                    
                        if (!var12) {
                        label_0440:
                        
                            if (!var12) {
                            label_0491:
                            
                                if (var11 & 0xff <= 0x00) {
                                    var12 = 0x04cc;
                                    var13 = var1;
                                    var var14 = 0x01;
                                    var var15 = var2;
                                    var12 = func_0668(var13, var14, var15);
                                    var10 = var12;
                                    var2 = var2 + 0x01;
                                
                                    if (var10 != 0x00) {
                                        var12 = var4;
                                        var13 = var6;
                                    
                                        if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                                    
                                        var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                                        var13 = var5;
                                        var14 = var6;
                                    
                                        if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                                    
                                        memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                                    
                                    label_0533:
                                        var11 = var11;
                                        var6 = var6 + 0x01;
                                    
                                        if (var6 >= 0x30) { goto label_053E; }
                                        else { goto label_03FD; }
                                    } else {
                                        var12 = var3;
                                        var13 = var6;
                                    
                                        if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                                    
                                        var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                                        var13 = var5;
                                        var14 = var6;
                                    
                                        if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                                    
                                    label_04AA:
                                        memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                                        goto label_0533;
                                    }
                                } else {
                                    var12 = var11;
                                    var13 = var5;
                                    var14 = var6;
                                
                                    if (var14 < memory[var13:var13 + 0x20]) { goto label_04AA; }
                                    else { assert(); }
                                }
                            } else {
                                var12 = 0x0451;
                                var13 = var1;
                                var14 = 0x03;
                                var15 = var2;
                                var12 = func_0668(var13, var14, var15);
                                var10 = var12;
                                var2 = var2 + 0x03;
                                var12 = 0x048e;
                                var13 = var3;
                                var14 = var6;
                            
                                if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                            
                                var12 = func_0468(var4, var6, var10, var13, var14);
                                var11 = var12;
                                goto label_0491;
                            }
                        } else {
                            var12 = var4;
                            var13 = var6;
                        
                            if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                        
                            var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20] & 0x01;
                            var13 = var3;
                            var14 = var6;
                        
                            if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                        
                            var12 = memory[var14 * 0x20 + var13 + 0x20:var14 * 0x20 + var13 + 0x20 + 0x20] & 0x01 != var12;
                            goto label_0440;
                        }
                    }
                } else {
                label_02A7:
                    var9 = 0x03;
                
                    if (var9 < 0x01) {
                    label_03E3:
                        var11 = var11;
                        var8 = var8 + 0x01;
                    
                        if (var8 >= 0x0c) { goto label_03EE; }
                        else { goto label_02A7; }
                    } else {
                    label_02B4:
                        var6 = var8 * 0x04 + var9;
                        var12 = 0x02c7;
                        var13 = var1;
                        var14 = 0x02;
                        var15 = var2;
                        var12 = func_0668(var13, var14, var15);
                        var10 = var12;
                        var2 = var2 + 0x02;
                    
                        if (var10 != 0x00) {
                        label_0349:
                            var12 = 0x0355;
                            var13 = var1;
                            var14 = 0x02;
                            var15 = var2;
                            var12 = func_0668(var13, var14, var15);
                            var10 = var12;
                            var2 = var2 + 0x02;
                        
                            if (var10 != 0x00) {
                            label_03D7:
                                var11 = var11;
                                var9 = var9 + ~0x00;
                            
                                if (var9 < 0x01) { goto label_03E3; }
                                else { goto label_02B4; }
                            } else {
                                var12 = var4;
                                var13 = var6;
                            
                                if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                            
                                var7 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                                var12 = var4;
                                var13 = var6 - 0x01;
                            
                                if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                            
                                var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                                var13 = var4;
                                var14 = var6;
                            
                                if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                            
                                memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                                var12 = var7;
                                var13 = var4;
                                var14 = var6 + ~0x00;
                            
                                if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                            
                                memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                                goto label_03D7;
                            }
                        } else {
                            var12 = var3;
                            var13 = var6;
                        
                            if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                        
                            var7 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                            var12 = var3;
                            var13 = var6 - 0x01;
                        
                            if (var13 >= memory[var12:var12 + 0x20]) { assert(); }
                        
                            var12 = memory[var13 * 0x20 + var12 + 0x20:var13 * 0x20 + var12 + 0x20 + 0x20];
                            var13 = var3;
                            var14 = var6;
                        
                            if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                        
                            memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                            var12 = var7;
                            var13 = var3;
                            var14 = var6 + ~0x00;
                        
                            if (var14 >= memory[var13:var13 + 0x20]) { assert(); }
                        
                            memory[var13 + var14 * 0x20 + 0x20:var13 + var14 * 0x20 + 0x20 + 0x20] = var12 & 0xff;
                            goto label_0349;
                        }
                    }
                }
            } else {
                var temp7 = MSIZE();
                var temp8 = var12;
                memory[temp7:temp7 + 0x20] = temp8;
                memory[0x40:0x60] = temp7 + temp8 * 0x20 + 0x20;
                var5 = temp7;
                var8 = 0x00;
            
                if (var8 >= 0x0c) { goto label_03EE; }
                else { goto label_02A7; }
            }
        } else {
            var temp9 = (block.number & ~0xff) + (arg2 & 0xff);
            arg2 = temp9;
        
            if (arg2 < block.number) {
                var1 = block.blockHash(arg2);
                goto label_022B;
            } else {
                var temp10 = arg2 - 0x0100;
                arg2 = temp10;
                var1 = block.blockHash(arg2);
                goto label_022B;
            }
        }
    }
    
    function func_0468(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) {
        arg3 = memory[arg4 * 0x20 + arg3 + 0x20:arg4 * 0x20 + arg3 + 0x20 + 0x20];
        arg4 = arg0;
        var var0 = arg1;
    
        if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); }
    
        arg4 = memory[var0 * 0x20 + arg4 + 0x20:var0 * 0x20 + arg4 + 0x20 + 0x20];
        var0 = arg2;
        var var1 = 0x00;
        var var2 = arg3;
        var var3 = arg4;
        var var4 = var1;
    
        if (var2 & 0xff <= var3 & 0xff) {
            var var5 = var3 - var2 & 0xff == 0x01;
        
            if (!var5) {
            label_06B6:
            
                if (!var5) {
                label_06E7:
                    return var1;
                } else {
                label_06BC:
                
                    if (var2 & 0xff >= 0x17) {
                        var4 = 0x00;
                    
                        if (var0 > var4) { goto label_06E7; }
                    
                    label_06DB:
                        var1 = (var2 & 0xff) / 0x02 + 0x10;
                        goto label_06E7;
                    } else {
                        var4 = 0x01;
                    
                        if (var0 > var4) { goto label_06E7; }
                        else { goto label_06DB; }
                    }
                }
            } else {
            label_06A8:
            
                if ((var2 & 0xff) % 0x02 & 0xff != 0x00) { goto label_06E7; }
                else { goto label_06BC; }
            }
        } else {
            var3 = arg3;
            var2 = arg4;
            var5 = var3 - var2 & 0xff == 0x01;
        
            if (!var5) { goto label_06B6; }
            else { goto label_06A8; }
        }
    }
    
    function encode(var arg0) returns (var r0) {
        var var0 = 0x00;
        var var1 = var0;
    
        if (var1 >= 0x30) {
        label_0597:
            return var0;
        } else {
        label_0568:
            var temp0 = var1;
            var0 = var0 * 0x20;
            var1 = temp0;
            var var2 = arg0;
            var var3 = 0x2f - var1;
        
            if (var3 >= memory[var2:var2 + 0x20]) { assert(); }
        
            var0 = (memory[var3 * 0x20 + var2 + 0x20:var3 * 0x20 + var2 + 0x20 + 0x20] & 0xff) | var0;
            var1 = var1 + 0x01;
        
            if (var1 >= 0x30) { goto label_0597; }
            else { goto label_0568; }
        }
    }
    
    function isGeneScience() returns (var r0) { return storage[0x00] & 0xff; }
    
    function decode(var arg0) returns (var r0) {
        var var0 = 0x05ae;
        var0 = func_0709();
        var var1 = 0x05b6;
        var1 = func_0709();
        var var2 = 0x00;
        var var3 = 0x30;
        var var4 = memory[0x40:0x60];
    
        if (MSIZE() < var4) {
            var temp0 = var4;
            var temp1 = var3;
            memory[temp0:temp0 + 0x20] = temp1;
            memory[0x40:0x60] = temp0 + temp1 * 0x20 + 0x20;
            var1 = temp0;
            var2 = 0x00;
        
            if (var2 >= 0x30) {
            label_0617:
                return var1;
            } else {
            label_05E9:
                var3 = 0x05f2;
                var4 = arg0;
                var var5 = var2;
                var3 = func_06F1(var4, var5);
                var4 = var1;
                var5 = var2;
            
                if (var5 >= memory[var4:var4 + 0x20]) { assert(); }
            
                memory[var4 + var5 * 0x20 + 0x20:var4 + var5 * 0x20 + 0x20 + 0x20] = var3 & 0xff;
                var2 = var2 + 0x01;
            
                if (var2 >= 0x30) { goto label_0617; }
                else { goto label_05E9; }
            }
        } else {
            var temp2 = MSIZE();
            var temp3 = var3;
            memory[temp2:temp2 + 0x20] = temp3;
            memory[0x40:0x60] = temp2 + temp3 * 0x20 + 0x20;
            var1 = temp2;
            var2 = 0x00;
        
            if (var2 >= 0x30) { goto label_0617; }
            else { goto label_05E9; }
        }
    }
    
    function expressingTraits(var arg0) returns (var r0) {
        var var0 = 0x0626;
        var0 = func_071B();
        var var1 = 0x062e;
        var1 = func_071B();
        var var2 = 0x00;
    
        if (var2 >= 0x0c) {
        label_0617:
            return var1;
        } else {
        label_063B:
            var var3 = 0x0647;
            var var4 = arg0;
            var var5 = var2 * 0x04;
            var3 = func_06F1(var4, var5);
            var4 = var1;
            var5 = var2;
        
            if (var5 >= 0x0c) { assert(); }
        
            memory[var5 * 0x20 + var4:var5 * 0x20 + var4 + 0x20] = var3 & 0xff;
            var2 = var2 + 0x01;
        
            if (var2 >= 0x0c) { goto label_0617; }
            else { goto label_063B; }
        }
    }
    
    function func_0668(var arg0, var arg1, var arg2) returns (var r0) {
        var temp0 = 0x02 ** arg2;
        return (temp0 * (0x02 ** arg1 + ~0x00) & arg0) / temp0;
    }
    
    function func_06F1(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var var1 = 0x0702;
        var var2 = arg0;
        var var3 = 0x05;
        var var4 = arg1 * 0x05;
        return func_0668(var2, var3, var4);
    }
    
    function func_0709() returns (var r0) {
        var temp0 = memory[0x40:0x60];
        memory[0x40:0x60] = temp0 + 0x20;
        memory[temp0:temp0 + 0x20] = 0x00;
        return temp0;
    }
    
    function func_071B() returns (var r0) {
        var temp0 = memory[0x40:0x60];
        var var0 = temp0;
        memory[0x40:0x60] = var0 + 0x0180;
        memory[var0:var0 + 0x20] = 0x00;
        var var1 = 0x0c + ~0x00;
        var var2 = var0 + 0x20;
    
        if (!var1) { goto label_073F; }
    
    label_072B:
        var temp1 = var2;
        memory[temp1:temp1 + 0x20] = 0x00;
        var1 = var1 + ~0x00;
        var2 = temp1 + 0x20;
    
        if (var1) { goto label_072B; }
    
    label_073F:
        return var0;
    }
}

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 0x006c
	000C    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0004  memory[0x40:0x60] = 0x60 }
	// Block ends with conditional jump to 0x006c, if msg.data.length < 0x04

label_000D:
	// Incoming jump from 0x000C, if not msg.data.length < 0x04
	// Inputs[1] { @0032  msg.data[0x00:0x20] }
	000D    63  PUSH4 0xffffffff
	0012    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	0030    60  PUSH1 0x00
	0032    35  CALLDATALOAD
	0033    04  DIV
	0034    16  AND
	0035    63  PUSH4 0x0d9f5aed
	003A    81  DUP2
	003B    14  EQ
	003C    61  PUSH2 0x0071
	003F    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0034  stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff }
	// Block ends with conditional jump to 0x0071, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed

label_0040:
	// Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed
	// Inputs[1] { @0040  stack[-1] }
	0040    80  DUP1
	0041    63  PUSH4 0x1597ee44
	0046    14  EQ
	0047    61  PUSH2 0x009f
	004A    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x009f, if 0x1597ee44 == stack[-1]

label_004B:
	// Incoming jump from 0x004A, if not 0x1597ee44 == stack[-1]
	// Inputs[1] { @004B  stack[-1] }
	004B    80  DUP1
	004C    63  PUSH4 0x54c15b82
	0051    14  EQ
	0052    61  PUSH2 0x00ee
	0055    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00ee, if 0x54c15b82 == stack[-1]

label_0056:
	// Incoming jump from 0x0055, if not 0x54c15b82 == stack[-1]
	// Inputs[1] { @0056  stack[-1] }
	0056    80  DUP1
	0057    63  PUSH4 0x61a76900
	005C    14  EQ
	005D    61  PUSH2 0x0115
	0060    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0115, if 0x61a76900 == stack[-1]

label_0061:
	// Incoming jump from 0x0060, if not 0x61a76900 == stack[-1]
	// Inputs[1] { @0061  stack[-1] }
	0061    80  DUP1
	0062    63  PUSH4 0x77a74a20
	0067    14  EQ
	0068    61  PUSH2 0x017e
	006B    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x017e, if 0x77a74a20 == stack[-1]

label_006C:
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Incoming jump from 0x006B, if not 0x77a74a20 == stack[-1]
	// Inputs[1] { @0070  memory[0x00:0x00] }
	006C    5B  JUMPDEST
	006D    60  PUSH1 0x00
	006F    80  DUP1
	0070    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0070  revert(memory[0x00:0x00]); }
	// Block terminates

label_0071:
	// Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x0d9f5aed
	// Inputs[1] { @0072  msg.value }
	0071    5B  JUMPDEST
	0072    34  CALLVALUE
	0073    15  ISZERO
	0074    61  PUSH2 0x007c
	0077    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x007c, if !msg.value

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

label_007C:
	// Incoming jump from 0x0077, if !msg.value
	// Inputs[3]
	// {
	//     @0082  msg.data[0x04:0x24]
	//     @0085  msg.data[0x24:0x44]
	//     @0088  msg.data[0x44:0x64]
	// }
	007C    5B  JUMPDEST
	007D    61  PUSH2 0x008d
	0080    60  PUSH1 0x04
	0082    35  CALLDATALOAD
	0083    60  PUSH1 0x24
	0085    35  CALLDATALOAD
	0086    60  PUSH1 0x44
	0088    35  CALLDATALOAD
	0089    61  PUSH2 0x01cd
	008C    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @007D  stack[0] = 0x008d
	//     @0082  stack[1] = msg.data[0x04:0x24]
	//     @0085  stack[2] = msg.data[0x24:0x44]
	//     @0088  stack[3] = msg.data[0x44:0x64]
	// }
	// Block ends with call to 0x01cd, returns to 0x008D

label_008D:
	// Incoming return from call to 0x01CD at 0x008C
	// Incoming return from call to 0x055A at 0x00ED
	// Inputs[4]
	// {
	//     @0090  memory[0x40:0x60]
	//     @0091  stack[-1]
	//     @0099  memory[0x40:0x60]
	//     @009E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	008D    5B  JUMPDEST
	008E    60  PUSH1 0x40
	0090    51  MLOAD
	0091    90  SWAP1
	0092    81  DUP2
	0093    52  MSTORE
	0094    60  PUSH1 0x20
	0096    01  ADD
	0097    60  PUSH1 0x40
	0099    51  MLOAD
	009A    80  DUP1
	009B    91  SWAP2
	009C    03  SUB
	009D    90  SWAP1
	009E    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0093  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1]
	//     @009E  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

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

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

label_00AA:
	// Incoming jump from 0x00A5, if !msg.value
	// Inputs[4]
	// {
	//     @00B3  msg.data[0x04:0x24]
	//     @00BA  msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @00C4  memory[0x40:0x60]
	//     @00DE  msg.data[msg.data[0x04:0x24] + 0x24:msg.data[0x04:0x24] + 0x24 + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	// }
	00AA    5B  JUMPDEST
	00AB    61  PUSH2 0x008d
	00AE    60  PUSH1 0x04
	00B0    60  PUSH1 0x24
	00B2    81  DUP2
	00B3    35  CALLDATALOAD
	00B4    81  DUP2
	00B5    81  DUP2
	00B6    01  ADD
	00B7    90  SWAP1
	00B8    83  DUP4
	00B9    01  ADD
	00BA    35  CALLDATALOAD
	00BB    80  DUP1
	00BC    60  PUSH1 0x20
	00BE    81  DUP2
	00BF    81  DUP2
	00C0    02  MUL
	00C1    01  ADD
	00C2    60  PUSH1 0x40
	00C4    51  MLOAD
	00C5    90  SWAP1
	00C6    81  DUP2
	00C7    01  ADD
	00C8    60  PUSH1 0x40
	00CA    52  MSTORE
	00CB    80  DUP1
	00CC    93  SWAP4
	00CD    92  SWAP3
	00CE    91  SWAP2
	00CF    90  SWAP1
	00D0    81  DUP2
	00D1    81  DUP2
	00D2    52  MSTORE
	00D3    60  PUSH1 0x20
	00D5    01  ADD
	00D6    83  DUP4
	00D7    83  DUP4
	00D8    60  PUSH1 0x20
	00DA    02  MUL
	00DB    80  DUP1
	00DC    82  DUP3
	00DD    84  DUP5
	00DE    37  CALLDATACOPY
	00DF    50  POP
	00E0    94  SWAP5
	00E1    96  SWAP7
	00E2    50  POP
	00E3    61  PUSH2 0x055a
	00E6    95  SWAP6
	00E7    50  POP
	00E8    50  POP
	00E9    50  POP
	00EA    50  POP
	00EB    50  POP
	00EC    50  POP
	00ED    56  *JUMP
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @00AB  stack[0] = 0x008d
	//     @00CA  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] + 0x20
	//     @00D2  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]
	//     @00DE  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[msg.data[0x04:0x24] + 0x24:msg.data[0x04:0x24] + 0x24 + 0x20 * msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]]
	//     @00E1  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x055a, returns to 0x008D

label_00EE:
	// Incoming jump from 0x0055, if 0x54c15b82 == stack[-1]
	// Inputs[1] { @00EF  msg.value }
	00EE    5B  JUMPDEST
	00EF    34  CALLVALUE
	00F0    15  ISZERO
	00F1    61  PUSH2 0x00f9
	00F4    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x00f9, if !msg.value

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

label_00F9:
	// Incoming jump from 0x00F4, if !msg.value
	00F9    5B  JUMPDEST
	00FA    61  PUSH2 0x0101
	00FD    61  PUSH2 0x059d
	0100    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @00FA  stack[0] = 0x0101 }
	// Block ends with call to 0x059d, returns to 0x0101

label_0101:
	// Incoming return from call to 0x059D at 0x0100
	// Inputs[4]
	// {
	//     @0104  memory[0x40:0x60]
	//     @0105  stack[-1]
	//     @010F  memory[0x40:0x60]
	//     @0114  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0101    5B  JUMPDEST
	0102    60  PUSH1 0x40
	0104    51  MLOAD
	0105    90  SWAP1
	0106    15  ISZERO
	0107    15  ISZERO
	0108    81  DUP2
	0109    52  MSTORE
	010A    60  PUSH1 0x20
	010C    01  ADD
	010D    60  PUSH1 0x40
	010F    51  MLOAD
	0110    80  DUP1
	0111    91  SWAP2
	0112    03  SUB
	0113    90  SWAP1
	0114    F3  *RETURN
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0109  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1]
	//     @0114  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_0115:
	// Incoming jump from 0x0060, if 0x61a76900 == stack[-1]
	// Inputs[1] { @0116  msg.value }
	0115    5B  JUMPDEST
	0116    34  CALLVALUE
	0117    15  ISZERO
	0118    61  PUSH2 0x0120
	011B    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0120, if !msg.value

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

label_0120:
	// Incoming jump from 0x011B, if !msg.value
	// Inputs[1] { @0126  msg.data[0x04:0x24] }
	0120    5B  JUMPDEST
	0121    61  PUSH2 0x012b
	0124    60  PUSH1 0x04
	0126    35  CALLDATALOAD
	0127    61  PUSH2 0x05a6
	012A    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0121  stack[0] = 0x012b
	//     @0126  stack[1] = msg.data[0x04:0x24]
	// }
	// Block ends with call to 0x05a6, returns to 0x012B

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

label_015B:
	// Incoming jump from 0x015A, if not !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x015A, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @015B  stack[-1]
	//     @015C  stack[-2]
	//     @015E  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @015F  stack[-3]
	// }
	015B    80  DUP1
	015C    82  DUP3
	015D    01  ADD
	015E    51  MLOAD
	015F    83  DUP4
	0160    82  DUP3
	0161    01  ADD
	0162    52  MSTORE
	0163    60  PUSH1 0x20
	0165    01  ADD
	0166    61  PUSH2 0x0152
	0169    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0162  memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0165  stack[-1] = 0x20 + stack[-1]
	// }
	// Block ends with unconditional jump to 0x0152

label_016A:
	// Incoming jump from 0x015A, if !(0x00 < 0x20 * memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x015A, if !(stack[-1] < stack[-4])
	// Inputs[6]
	// {
	//     @016F  stack[-5]
	//     @016F  stack[-6]
	//     @0171  stack[-7]
	//     @0172  stack[-10]
	//     @0178  memory[0x40:0x60]
	//     @017D  memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]
	// }
	016A    5B  JUMPDEST
	016B    50  POP
	016C    50  POP
	016D    50  POP
	016E    50  POP
	016F    90  SWAP1
	0170    50  POP
	0171    01  ADD
	0172    92  SWAP3
	0173    50  POP
	0174    50  POP
	0175    50  POP
	0176    60  PUSH1 0x40
	0178    51  MLOAD
	0179    80  DUP1
	017A    91  SWAP2
	017B    03  SUB
	017C    90  SWAP1
	017D    F3  *RETURN
	// Stack delta = -10
	// Outputs[1] { @017D  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; }
	// Block terminates

label_017E:
	// Incoming jump from 0x006B, if 0x77a74a20 == stack[-1]
	// Inputs[1] { @017F  msg.value }
	017E    5B  JUMPDEST
	017F    34  CALLVALUE
	0180    15  ISZERO
	0181    61  PUSH2 0x0189
	0184    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0189, if !msg.value

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

label_0189:
	// Incoming jump from 0x0184, if !msg.value
	// Inputs[1] { @018F  msg.data[0x04:0x24] }
	0189    5B  JUMPDEST
	018A    61  PUSH2 0x0194
	018D    60  PUSH1 0x04
	018F    35  CALLDATALOAD
	0190    61  PUSH2 0x061e
	0193    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @018A  stack[0] = 0x0194
	//     @018F  stack[1] = msg.data[0x04:0x24]
	// }
	// Block ends with call to 0x061e, returns to 0x0194

label_0194:
	// Incoming return from call to 0x061E at 0x0193
	// Inputs[2]
	// {
	//     @0197  memory[0x40:0x60]
	//     @0199  stack[-1]
	// }
	0194    5B  JUMPDEST
	0195    60  PUSH1 0x40
	0197    51  MLOAD
	0198    80  DUP1
	0199    82  DUP3
	019A    61  PUSH2 0x0180
	019D    80  DUP1
	019E    83  DUP4
	019F    83  DUP4
	01A0    60  PUSH1 0x00
	01A2    5B  JUMPDEST
	01A3    83  DUP4
	01A4    81  DUP2
	01A5    10  LT
	01A6    15  ISZERO
	01A7    61  PUSH2 0x01ba
	01AA    57  *JUMPI
	// Stack delta = +8
	// Outputs[8]
	// {
	//     @0197  stack[0] = memory[0x40:0x60]
	//     @0198  stack[1] = memory[0x40:0x60]
	//     @0199  stack[2] = stack[-1]
	//     @019A  stack[3] = 0x0180
	//     @019D  stack[4] = 0x0180
	//     @019E  stack[5] = memory[0x40:0x60]
	//     @019F  stack[6] = stack[-1]
	//     @01A0  stack[7] = 0x00
	// }
	// Block ends with conditional jump to 0x01ba, if !(0x00 < 0x0180)

label_01AB:
	// Incoming jump from 0x01AA, if not !(stack[-1] < stack[-4])
	// Incoming jump from 0x01AA, if not !(0x00 < 0x0180)
	// Inputs[4]
	// {
	//     @01AB  stack[-1]
	//     @01AC  stack[-2]
	//     @01AE  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @01AF  stack[-3]
	// }
	01AB    80  DUP1
	01AC    82  DUP3
	01AD    01  ADD
	01AE    51  MLOAD
	01AF    83  DUP4
	01B0    82  DUP3
	01B1    01  ADD
	01B2    52  MSTORE
	01B3    60  PUSH1 0x20
	01B5    01  ADD
	01B6    61  PUSH2 0x01a2
	01B9    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @01B2  memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @01B5  stack[-1] = 0x20 + stack[-1]
	// }
	// Block ends with unconditional jump to 0x01a2

label_01BA:
	// Incoming jump from 0x01AA, if !(stack[-1] < stack[-4])
	// Incoming jump from 0x01AA, if !(0x00 < 0x0180)
	// Inputs[6]
	// {
	//     @01BF  stack[-6]
	//     @01BF  stack[-5]
	//     @01C1  stack[-7]
	//     @01C2  stack[-9]
	//     @01C7  memory[0x40:0x60]
	//     @01CC  memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]
	// }
	01BA    5B  JUMPDEST
	01BB    50  POP
	01BC    50  POP
	01BD    50  POP
	01BE    50  POP
	01BF    90  SWAP1
	01C0    50  POP
	01C1    01  ADD
	01C2    91  SWAP2
	01C3    50  POP
	01C4    50  POP
	01C5    60  PUSH1 0x40
	01C7    51  MLOAD
	01C8    80  DUP1
	01C9    91  SWAP2
	01CA    03  SUB
	01CB    90  SWAP1
	01CC    F3  *RETURN
	// Stack delta = -9
	// Outputs[1] { @01CC  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; }
	// Block terminates

label_01CD:
	// Incoming call from 0x008C, returns to 0x008D
	01CD    5B  JUMPDEST
	01CE    60  PUSH1 0x00
	01D0    80  DUP1
	01D1    60  PUSH1 0x00
	01D3    61  PUSH2 0x01da
	01D6    61  PUSH2 0x0709
	01D9    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @01CE  stack[0] = 0x00
	//     @01D0  stack[1] = 0x00
	//     @01D1  stack[2] = 0x00
	//     @01D3  stack[3] = 0x01da
	// }
	// Block ends with call to 0x0709, returns to 0x01DA

label_01DA:
	// Incoming return from call to 0x0709 at 0x01D9
	01DA    5B  JUMPDEST
	01DB    61  PUSH2 0x01e2
	01DE    61  PUSH2 0x0709
	01E1    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01DB  stack[0] = 0x01e2 }
	// Block ends with call to 0x0709, returns to 0x01E2

label_01E2:
	// Incoming return from call to 0x0709 at 0x01E1
	01E2    5B  JUMPDEST
	01E3    61  PUSH2 0x01ea
	01E6    61  PUSH2 0x0709
	01E9    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @01E3  stack[0] = 0x01ea }
	// Block ends with call to 0x0709, returns to 0x01EA

label_01EA:
	// Incoming return from call to 0x0709 at 0x01E9
	// Inputs[2]
	// {
	//     @01F2  block.number
	//     @01F3  stack[-7]
	// }
	01EA    5B  JUMPDEST
	01EB    60  PUSH1 0x00
	01ED    80  DUP1
	01EE    80  DUP1
	01EF    80  DUP1
	01F0    80  DUP1
	01F1    80  DUP1
	01F2    43  NUMBER
	01F3    8D  DUP14
	01F4    90  SWAP1
	01F5    11  GT
	01F6    61  PUSH2 0x01fe
	01F9    57  *JUMPI
	// Stack delta = +6
	// Outputs[6]
	// {
	//     @01EB  stack[0] = 0x00
	//     @01ED  stack[1] = 0x00
	//     @01EE  stack[2] = 0x00
	//     @01EF  stack[3] = 0x00
	//     @01F0  stack[4] = 0x00
	//     @01F1  stack[5] = 0x00
	// }
	// Block ends with conditional jump to 0x01fe, if block.number > stack[-7]

label_01FA:
	// Incoming jump from 0x01F9, if not block.number > stack[-7]
	// Inputs[1] { @01FD  memory[0x00:0x00] }
	01FA    60  PUSH1 0x00
	01FC    80  DUP1
	01FD    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @01FD  revert(memory[0x00:0x00]); }
	// Block terminates

label_01FE:
	// Incoming jump from 0x01F9, if block.number > stack[-7]
	// Inputs[3]
	// {
	//     @01FF  stack[-13]
	//     @0200  block.blockHash(stack[-13])
	//     @0201  stack[-11]
	// }
	01FE    5B  JUMPDEST
	01FF    8C  DUP13
	0200    40  BLOCKHASH
	0201    9A  SWAP11
	0202    50  POP
	0203    8A  DUP11
	0204    15  ISZERO
	0205    15  ISZERO
	0206    61  PUSH2 0x022b
	0209    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0201  stack[-11] = block.blockHash(stack[-13]) }
	// Block ends with conditional jump to 0x022b, if !!block.blockHash(stack[-13])

label_020A:
	// Incoming jump from 0x0209, if not !!block.blockHash(stack[-13])
	// Inputs[3]
	// {
	//     @020C  stack[-13]
	//     @0211  block.number
	//     @0216  block.number
	// }
	020A    60  PUSH1 0xff
	020C    8D  DUP14
	020D    16  AND
	020E    60  PUSH1 0xff
	0210    19  NOT
	0211    43  NUMBER
	0212    16  AND
	0213    01  ADD
	0214    9C  SWAP13
	0215    50  POP
	0216    43  NUMBER
	0217    8D  DUP14
	0218    10  LT
	0219    15  ISZERO
	021A    15  ISZERO
	021B    61  PUSH2 0x0226
	021E    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @0214  stack[-13] = (block.number & ~0xff) + (stack[-13] & 0xff) }
	// Block ends with conditional jump to 0x0226, if !!((block.number & ~0xff) + (stack[-13] & 0xff) < block.number)

label_021F:
	// Incoming jump from 0x021E, if not !!((block.number & ~0xff) + (stack[-13] & 0xff) < block.number)
	// Inputs[3]
	// {
	//     @0222  stack[-13]
	//     @0228  block.blockHash(stack[-13] - 0x0100)
	//     @0229  stack[-11]
	// }
	021F    61  PUSH2 0x0100
	0222    8D  DUP14
	0223    03  SUB
	0224    9C  SWAP13
	0225    50  POP
	0226    5B  JUMPDEST
	0227    8C  DUP13
	0228    40  BLOCKHASH
	0229    9A  SWAP11
	022A    50  POP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0224  stack[-13] = stack[-13] - 0x0100
	//     @0229  stack[-11] = block.blockHash(stack[-13] - 0x0100)
	// }
	// Block continues

label_022B:
	// Incoming jump from 0x0209, if !!block.blockHash(stack[-13])
	// Incoming jump from 0x022A
	// Incoming jump from 0x022A
	// Inputs[8]
	// {
	//     @022C  stack[-11]
	//     @022D  stack[-15]
	//     @022E  stack[-14]
	//     @022F  stack[-13]
	//     @0232  memory[0x40:0x60]
	//     @0254  memory[0x40:0x60]
	//     @025A  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @025F  stack[-10]
	// }
	022B    5B  JUMPDEST
	022C    8A  DUP11
	022D    8F  DUP16
	022E    8F  DUP16
	022F    8F  DUP16
	0230    60  PUSH1 0x40
	0232    51  MLOAD
	0233    80  DUP1
	0234    85  DUP6
	0235    81  DUP2
	0236    52  MSTORE
	0237    60  PUSH1 0x20
	0239    01  ADD
	023A    84  DUP5
	023B    81  DUP2
	023C    52  MSTORE
	023D    60  PUSH1 0x20
	023F    01  ADD
	0240    83  DUP4
	0241    81  DUP2
	0242    52  MSTORE
	0243    60  PUSH1 0x20
	0245    01  ADD
	0246    82  DUP3
	0247    81  DUP2
	0248    52  MSTORE
	0249    60  PUSH1 0x20
	024B    01  ADD
	024C    94  SWAP5
	024D    50  POP
	024E    50  POP
	024F    50  POP
	0250    50  POP
	0251    50  POP
	0252    60  PUSH1 0x40
	0254    51  MLOAD
	0255    90  SWAP1
	0256    81  DUP2
	0257    90  SWAP1
	0258    03  SUB
	0259    90  SWAP1
	025A    20  SHA3
	025B    9A  SWAP11
	025C    50  POP
	025D    60  PUSH1 0x00
	025F    99  SWAP10
	0260    50  POP
	0261    61  PUSH2 0x0269
	0264    8F  DUP16
	0265    61  PUSH2 0x05a6
	0268    56  *JUMP
	// Stack delta = +2
	// Outputs[8]
	// {
	//     @0236  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-11]
	//     @023C  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-15]
	//     @0242  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-14]
	//     @0248  memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-13]
	//     @025B  stack[-11] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	//     @025F  stack[-10] = 0x00
	//     @0261  stack[0] = 0x0269
	//     @0264  stack[1] = stack[-15]
	// }
	// Block ends with call to 0x05a6, returns to 0x0269

label_0269:
	// Incoming return from call to 0x05A6 at 0x0268
	// Inputs[3]
	// {
	//     @026A  stack[-10]
	//     @026A  stack[-1]
	//     @026F  stack[-15]
	// }
	0269    5B  JUMPDEST
	026A    98  SWAP9
	026B    50  POP
	026C    61  PUSH2 0x0274
	026F    8E  DUP15
	0270    61  PUSH2 0x05a6
	0273    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @026A  stack[-10] = stack[-1]
	//     @026C  stack[-1] = 0x0274
	//     @026F  stack[0] = stack[-15]
	// }
	// Block ends with call to 0x05a6, returns to 0x0274

label_0274:
	// Incoming return from call to 0x05A6 at 0x0273
	// Inputs[4]
	// {
	//     @0275  stack[-9]
	//     @0275  stack[-1]
	//     @027B  memory[0x40:0x60]
	//     @027D  MSIZE()
	// }
	0274    5B  JUMPDEST
	0275    97  SWAP8
	0276    50  POP
	0277    60  PUSH1 0x30
	0279    60  PUSH1 0x40
	027B    51  MLOAD
	027C    80  DUP1
	027D    59  MSIZE
	027E    10  LT
	027F    61  PUSH2 0x0285
	0282    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0275  stack[-9] = stack[-1]
	//     @0277  stack[-1] = 0x30
	//     @027B  stack[0] = memory[0x40:0x60]
	// }
	// Block ends with conditional jump to 0x0285, if MSIZE() < memory[0x40:0x60]

label_0283:
	// Incoming jump from 0x0282, if not MSIZE() < memory[0x40:0x60]
	// Inputs[4]
	// {
	//     @0284  MSIZE()
	//     @0286  stack[-2]
	//     @0297  stack[-9]
	//     @029B  stack[-6]
	// }
	0283    50  POP
	0284    59  MSIZE
	0285    5B  JUMPDEST
	0286    90  SWAP1
	0287    80  DUP1
	0288    82  DUP3
	0289    52  MSTORE
	028A    80  DUP1
	028B    60  PUSH1 0x20
	028D    02  MUL
	028E    60  PUSH1 0x20
	0290    01  ADD
	0291    82  DUP3
	0292    01  ADD
	0293    60  PUSH1 0x40
	0295    52  MSTORE
	0296    50  POP
	0297    96  SWAP7
	0298    50  POP
	0299    60  PUSH1 0x00
	029B    93  SWAP4
	029C    50  POP
	029D    5B  JUMPDEST
	029E    60  PUSH1 0x0c
	02A0    84  DUP5
	02A1    10  LT
	02A2    15  ISZERO
	02A3    61  PUSH2 0x03ee
	02A6    57  *JUMPI
	// Stack delta = -2
	// Outputs[4]
	// {
	//     @0289  memory[MSIZE():MSIZE() + 0x20] = stack[-2]
	//     @0295  memory[0x40:0x60] = MSIZE() + 0x20 + 0x20 * stack[-2]
	//     @0297  stack[-9] = MSIZE()
	//     @029B  stack[-6] = 0x00
	// }
	// Block ends with conditional jump to 0x03ee, if !(0x00 < 0x0c)

label_02A7:
	// Incoming jump from 0x02A6, if not !(0x00 < 0x0c)
	// Incoming jump from 0x02A6, if not !(0x00 < 0x0c)
	// Incoming jump from 0x02A6, if not !(stack[-4] < 0x0c)
	// Inputs[1] { @02A9  stack[-3] }
	02A7    60  PUSH1 0x03
	02A9    92  SWAP3
	02AA    50  POP
	02AB    5B  JUMPDEST
	02AC    60  PUSH1 0x01
	02AE    83  DUP4
	02AF    10  LT
	02B0    61  PUSH2 0x03e3
	02B3    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @02A9  stack[-3] = 0x03 }
	// Block ends with conditional jump to 0x03e3, if 0x03 < 0x01

label_02B4:
	// Incoming jump from 0x02B3, if not 0x03 < 0x01
	// Incoming jump from 0x02B3, if not stack[-3] < 0x01
	// Inputs[5]
	// {
	//     @02B4  stack[-3]
	//     @02B5  stack[-4]
	//     @02BA  stack[-6]
	//     @02BF  stack[-11]
	//     @02C2  stack[-10]
	// }
	02B4    82  DUP3
	02B5    84  DUP5
	02B6    60  PUSH1 0x04
	02B8    02  MUL
	02B9    01  ADD
	02BA    95  SWAP6
	02BB    50  POP
	02BC    61  PUSH2 0x02c7
	02BF    8B  DUP12
	02C0    60  PUSH1 0x02
	02C2    8C  DUP13
	02C3    61  PUSH2 0x0668
	02C6    56  *JUMP
	// Stack delta = +4
	// Outputs[5]
	// {
	//     @02BA  stack[-6] = 0x04 * stack[-4] + stack[-3]
	//     @02BC  stack[0] = 0x02c7
	//     @02BF  stack[1] = stack[-11]
	//     @02C0  stack[2] = 0x02
	//     @02C2  stack[3] = stack[-10]
	// }
	// Block ends with call to 0x0668, returns to 0x02C7

label_02C7:
	// Incoming return from call to 0x0668 at 0x02C6
	// Inputs[3]
	// {
	//     @02C8  stack[-3]
	//     @02C8  stack[-1]
	//     @02CC  stack[-11]
	// }
	02C7    5B  JUMPDEST
	02C8    91  SWAP2
	02C9    50  POP
	02CA    60  PUSH1 0x02
	02CC    8A  DUP11
	02CD    01  ADD
	02CE    99  SWAP10
	02CF    50  POP
	02D0    81  DUP2
	02D1    60  PUSH1 0x00
	02D3    14  EQ
	02D4    15  ISZERO
	02D5    61  PUSH2 0x0349
	02D8    57  *JUMPI
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @02C8  stack[-3] = stack[-1]
	//     @02CE  stack[-11] = stack[-11] + 0x02
	// }
	// Block ends with conditional jump to 0x0349, if !(0x00 == stack[-1])

label_02D9:
	// Incoming jump from 0x02D8, if not !(0x00 == stack[-1])
	// Inputs[3]
	// {
	//     @02D9  stack[-9]
	//     @02DA  stack[-6]
	//     @02DC  memory[stack[-9]:stack[-9] + 0x20]
	// }
	02D9    88  DUP9
	02DA    86  DUP7
	02DB    81  DUP2
	02DC    51  MLOAD
	02DD    81  DUP2
	02DE    10  LT
	02DF    61  PUSH2 0x02e4
	02E2    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @02D9  stack[0] = stack[-9]
	//     @02DA  stack[1] = stack[-6]
	// }
	// Block ends with conditional jump to 0x02e4, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20]

label_02E3:
	// Incoming jump from 0x02E2, if not stack[-6] < memory[stack[-9]:stack[-9] + 0x20]
	02E3    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @02E3  assert(); }
	// Block terminates

label_02E4:
	// Incoming jump from 0x02E2, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20]
	// Inputs[7]
	// {
	//     @02E5  stack[-1]
	//     @02E5  stack[-2]
	//     @02EE  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @02EF  stack[-7]
	//     @02F1  stack[-11]
	//     @02F4  stack[-8]
	//     @02F7  memory[stack[-11]:stack[-11] + 0x20]
	// }
	02E4    5B  JUMPDEST
	02E5    90  SWAP1
	02E6    60  PUSH1 0x20
	02E8    01  ADD
	02E9    90  SWAP1
	02EA    60  PUSH1 0x20
	02EC    02  MUL
	02ED    01  ADD
	02EE    51  MLOAD
	02EF    94  SWAP5
	02F0    50  POP
	02F1    88  DUP9
	02F2    60  PUSH1 0x01
	02F4    87  DUP8
	02F5    03  SUB
	02F6    81  DUP2
	02F7    51  MLOAD
	02F8    81  DUP2
	02F9    10  LT
	02FA    61  PUSH2 0x02ff
	02FD    57  *JUMPI
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @02EF  stack[-7] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @02F1  stack[-2] = stack[-11]
	//     @02F5  stack[-1] = stack[-8] - 0x01
	// }
	// Block ends with conditional jump to 0x02ff, if stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20]

label_02FE:
	// Incoming jump from 0x02FD, if not stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20]
	02FE    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @02FE  assert(); }
	// Block terminates

label_02FF:
	// Incoming jump from 0x02FD, if stack[-8] - 0x01 < memory[stack[-11]:stack[-11] + 0x20]
	// Inputs[6]
	// {
	//     @0300  stack[-2]
	//     @0300  stack[-1]
	//     @0309  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @030A  stack[-11]
	//     @030B  stack[-8]
	//     @030D  memory[stack[-11]:stack[-11] + 0x20]
	// }
	02FF    5B  JUMPDEST
	0300    90  SWAP1
	0301    60  PUSH1 0x20
	0303    01  ADD
	0304    90  SWAP1
	0305    60  PUSH1 0x20
	0307    02  MUL
	0308    01  ADD
	0309    51  MLOAD
	030A    89  DUP10
	030B    87  DUP8
	030C    81  DUP2
	030D    51  MLOAD
	030E    81  DUP2
	030F    10  LT
	0310    61  PUSH2 0x0315
	0313    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0309  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @030A  stack[-1] = stack[-11]
	//     @030B  stack[0] = stack[-8]
	// }
	// Block ends with conditional jump to 0x0315, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20]

label_0314:
	// Incoming jump from 0x0313, if not stack[-8] < memory[stack[-11]:stack[-11] + 0x20]
	0314    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0314  assert(); }
	// Block terminates

label_0315:
	// Incoming jump from 0x0313, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20]
	// Inputs[7]
	// {
	//     @0318  stack[-1]
	//     @0319  stack[-3]
	//     @0321  stack[-2]
	//     @0327  stack[-8]
	//     @0328  stack[-12]
	//     @032C  stack[-9]
	//     @032F  memory[stack[-12]:stack[-12] + 0x20]
	// }
	0315    5B  JUMPDEST
	0316    60  PUSH1 0xff
	0318    90  SWAP1
	0319    92  SWAP3
	031A    16  AND
	031B    60  PUSH1 0x20
	031D    92  SWAP3
	031E    83  DUP4
	031F    02  MUL
	0320    90  SWAP1
	0321    91  SWAP2
	0322    01  ADD
	0323    90  SWAP1
	0324    91  SWAP2
	0325    01  ADD
	0326    52  MSTORE
	0327    84  DUP5
	0328    89  DUP10
	0329    60  PUSH1 0x00
	032B    19  NOT
	032C    88  DUP9
	032D    01  ADD
	032E    81  DUP2
	032F    51  MLOAD
	0330    81  DUP2
	0331    10  LT
	0332    61  PUSH2 0x0337
	0335    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @0326  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff
	//     @0327  stack[-3] = stack[-8]
	//     @0328  stack[-2] = stack[-12]
	//     @032D  stack[-1] = stack[-9] + ~0x00
	// }
	// Block ends with conditional jump to 0x0337, if stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20]

label_0336:
	// Incoming jump from 0x0335, if not stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20]
	0336    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0336  assert(); }
	// Block terminates

label_0337:
	// Incoming jump from 0x0335, if stack[-9] + ~0x00 < memory[stack[-12]:stack[-12] + 0x20]
	// Inputs[3]
	// {
	//     @033A  stack[-1]
	//     @033B  stack[-3]
	//     @0343  stack[-2]
	// }
	0337    5B  JUMPDEST
	0338    60  PUSH1 0xff
	033A    90  SWAP1
	033B    92  SWAP3
	033C    16  AND
	033D    60  PUSH1 0x20
	033F    92  SWAP3
	0340    83  DUP4
	0341    02  MUL
	0342    90  SWAP1
	0343    91  SWAP2
	0344    01  ADD
	0345    90  SWAP1
	0346    91  SWAP2
	0347    01  ADD
	0348    52  MSTORE
	// Stack delta = -3
	// Outputs[1] { @0348  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff }
	// Block continues

label_0349:
	// Incoming jump from 0x02D8, if !(0x00 == stack[-1])
	// Incoming jump from 0x0348
	// Inputs[2]
	// {
	//     @034D  stack[-11]
	//     @0350  stack[-10]
	// }
	0349    5B  JUMPDEST
	034A    61  PUSH2 0x0355
	034D    8B  DUP12
	034E    60  PUSH1 0x02
	0350    8C  DUP13
	0351    61  PUSH2 0x0668
	0354    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @034A  stack[0] = 0x0355
	//     @034D  stack[1] = stack[-11]
	//     @034E  stack[2] = 0x02
	//     @0350  stack[3] = stack[-10]
	// }
	// Block ends with call to 0x0668, returns to 0x0355

label_0355:
	// Incoming return from call to 0x0668 at 0x0354
	// Inputs[3]
	// {
	//     @0356  stack[-3]
	//     @0356  stack[-1]
	//     @035A  stack[-11]
	// }
	0355    5B  JUMPDEST
	0356    91  SWAP2
	0357    50  POP
	0358    60  PUSH1 0x02
	035A    8A  DUP11
	035B    01  ADD
	035C    99  SWAP10
	035D    50  POP
	035E    81  DUP2
	035F    60  PUSH1 0x00
	0361    14  EQ
	0362    15  ISZERO
	0363    61  PUSH2 0x03d7
	0366    57  *JUMPI
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @0356  stack[-3] = stack[-1]
	//     @035C  stack[-11] = stack[-11] + 0x02
	// }
	// Block ends with conditional jump to 0x03d7, if !(0x00 == stack[-1])

label_0367:
	// Incoming jump from 0x0366, if not !(0x00 == stack[-1])
	// Inputs[3]
	// {
	//     @0367  stack[-8]
	//     @0368  stack[-6]
	//     @036A  memory[stack[-8]:stack[-8] + 0x20]
	// }
	0367    87  DUP8
	0368    86  DUP7
	0369    81  DUP2
	036A    51  MLOAD
	036B    81  DUP2
	036C    10  LT
	036D    61  PUSH2 0x0372
	0370    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0367  stack[0] = stack[-8]
	//     @0368  stack[1] = stack[-6]
	// }
	// Block ends with conditional jump to 0x0372, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20]

label_0371:
	// Incoming jump from 0x0370, if not stack[-6] < memory[stack[-8]:stack[-8] + 0x20]
	0371    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0371  assert(); }
	// Block terminates

label_0372:
	// Incoming jump from 0x0370, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20]
	// Inputs[7]
	// {
	//     @0373  stack[-1]
	//     @0373  stack[-2]
	//     @037C  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @037D  stack[-7]
	//     @037F  stack[-10]
	//     @0382  stack[-8]
	//     @0385  memory[stack[-10]:stack[-10] + 0x20]
	// }
	0372    5B  JUMPDEST
	0373    90  SWAP1
	0374    60  PUSH1 0x20
	0376    01  ADD
	0377    90  SWAP1
	0378    60  PUSH1 0x20
	037A    02  MUL
	037B    01  ADD
	037C    51  MLOAD
	037D    94  SWAP5
	037E    50  POP
	037F    87  DUP8
	0380    60  PUSH1 0x01
	0382    87  DUP8
	0383    03  SUB
	0384    81  DUP2
	0385    51  MLOAD
	0386    81  DUP2
	0387    10  LT
	0388    61  PUSH2 0x038d
	038B    57  *JUMPI
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @037D  stack[-7] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @037F  stack[-2] = stack[-10]
	//     @0383  stack[-1] = stack[-8] - 0x01
	// }
	// Block ends with conditional jump to 0x038d, if stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20]

label_038C:
	// Incoming jump from 0x038B, if not stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20]
	038C    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @038C  assert(); }
	// Block terminates

label_038D:
	// Incoming jump from 0x038B, if stack[-8] - 0x01 < memory[stack[-10]:stack[-10] + 0x20]
	// Inputs[6]
	// {
	//     @038E  stack[-1]
	//     @038E  stack[-2]
	//     @0397  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0398  stack[-10]
	//     @0399  stack[-8]
	//     @039B  memory[stack[-10]:stack[-10] + 0x20]
	// }
	038D    5B  JUMPDEST
	038E    90  SWAP1
	038F    60  PUSH1 0x20
	0391    01  ADD
	0392    90  SWAP1
	0393    60  PUSH1 0x20
	0395    02  MUL
	0396    01  ADD
	0397    51  MLOAD
	0398    88  DUP9
	0399    87  DUP8
	039A    81  DUP2
	039B    51  MLOAD
	039C    81  DUP2
	039D    10  LT
	039E    61  PUSH2 0x03a3
	03A1    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0397  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0398  stack[-1] = stack[-10]
	//     @0399  stack[0] = stack[-8]
	// }
	// Block ends with conditional jump to 0x03a3, if stack[-8] < memory[stack[-10]:stack[-10] + 0x20]

label_03A2:
	// Incoming jump from 0x03A1, if not stack[-8] < memory[stack[-10]:stack[-10] + 0x20]
	03A2    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @03A2  assert(); }
	// Block terminates

label_03A3:
	// Incoming jump from 0x03A1, if stack[-8] < memory[stack[-10]:stack[-10] + 0x20]
	// Inputs[7]
	// {
	//     @03A6  stack[-1]
	//     @03A7  stack[-3]
	//     @03AF  stack[-2]
	//     @03B5  stack[-8]
	//     @03B6  stack[-11]
	//     @03BA  stack[-9]
	//     @03BD  memory[stack[-11]:stack[-11] + 0x20]
	// }
	03A3    5B  JUMPDEST
	03A4    60  PUSH1 0xff
	03A6    90  SWAP1
	03A7    92  SWAP3
	03A8    16  AND
	03A9    60  PUSH1 0x20
	03AB    92  SWAP3
	03AC    83  DUP4
	03AD    02  MUL
	03AE    90  SWAP1
	03AF    91  SWAP2
	03B0    01  ADD
	03B1    90  SWAP1
	03B2    91  SWAP2
	03B3    01  ADD
	03B4    52  MSTORE
	03B5    84  DUP5
	03B6    88  DUP9
	03B7    60  PUSH1 0x00
	03B9    19  NOT
	03BA    88  DUP9
	03BB    01  ADD
	03BC    81  DUP2
	03BD    51  MLOAD
	03BE    81  DUP2
	03BF    10  LT
	03C0    61  PUSH2 0x03c5
	03C3    57  *JUMPI
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @03B4  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff
	//     @03B5  stack[-3] = stack[-8]
	//     @03B6  stack[-2] = stack[-11]
	//     @03BB  stack[-1] = stack[-9] + ~0x00
	// }
	// Block ends with conditional jump to 0x03c5, if stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20]

label_03C4:
	// Incoming jump from 0x03C3, if not stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20]
	03C4    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @03C4  assert(); }
	// Block terminates

label_03C5:
	// Incoming jump from 0x03C3, if stack[-9] + ~0x00 < memory[stack[-11]:stack[-11] + 0x20]
	// Inputs[3]
	// {
	//     @03C8  stack[-1]
	//     @03C9  stack[-3]
	//     @03D1  stack[-2]
	// }
	03C5    5B  JUMPDEST
	03C6    60  PUSH1 0xff
	03C8    90  SWAP1
	03C9    92  SWAP3
	03CA    16  AND
	03CB    60  PUSH1 0x20
	03CD    92  SWAP3
	03CE    83  DUP4
	03CF    02  MUL
	03D0    90  SWAP1
	03D1    91  SWAP2
	03D2    01  ADD
	03D3    90  SWAP1
	03D4    91  SWAP2
	03D5    01  ADD
	03D6    52  MSTORE
	// Stack delta = -3
	// Outputs[1] { @03D6  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff }
	// Block continues

label_03D7:
	// Incoming jump from 0x0366, if !(0x00 == stack[-1])
	// Incoming jump from 0x03D6
	// Inputs[2]
	// {
	//     @03DB  stack[-1]
	//     @03DC  stack[-3]
	// }
	03D7    5B  JUMPDEST
	03D8    60  PUSH1 0x00
	03DA    19  NOT
	03DB    90  SWAP1
	03DC    92  SWAP3
	03DD    01  ADD
	03DE    91  SWAP2
	03DF    61  PUSH2 0x02ab
	03E2    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @03DE  stack[-3] = stack[-3] + ~0x00
	//     @03DE  stack[-1] = stack[-1]
	// }
	// Block ends with unconditional jump to 0x02ab

label_03E3:
	// Incoming jump from 0x02B3, if 0x03 < 0x01
	// Incoming jump from 0x02B3, if stack[-3] < 0x01
	// Inputs[2]
	// {
	//     @03E6  stack[-1]
	//     @03E7  stack[-4]
	// }
	03E3    5B  JUMPDEST
	03E4    60  PUSH1 0x01
	03E6    90  SWAP1
	03E7    93  SWAP4
	03E8    01  ADD
	03E9    92  SWAP3
	03EA    61  PUSH2 0x029d
	03ED    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @03E9  stack[-4] = stack[-4] + 0x01
	//     @03E9  stack[-1] = stack[-1]
	// }
	// Block ends with unconditional jump to 0x029d

label_03EE:
	// Incoming jump from 0x02A6, if !(0x00 < 0x0c)
	// Incoming jump from 0x02A6, if !(0x00 < 0x0c)
	// Incoming jump from 0x02A6, if !(stack[-4] < 0x0c)
	// Inputs[1] { @03F1  stack[-6] }
	03EE    5B  JUMPDEST
	03EF    60  PUSH1 0x00
	03F1    95  SWAP6
	03F2    50  POP
	03F3    5B  JUMPDEST
	03F4    60  PUSH1 0x30
	03F6    86  DUP7
	03F7    10  LT
	03F8    15  ISZERO
	03F9    61  PUSH2 0x053e
	03FC    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @03F1  stack[-6] = 0x00 }
	// Block ends with conditional jump to 0x053e, if !(0x00 < 0x30)

label_03FD:
	// Incoming jump from 0x03FC, if not !(stack[-6] < 0x30)
	// Incoming jump from 0x03FC, if not !(0x00 < 0x30)
	// Inputs[1] { @0402  stack[-6] }
	03FD    50  POP
	03FE    60  PUSH1 0x00
	0400    60  PUSH1 0x04
	0402    86  DUP7
	0403    06  MOD
	0404    15  ISZERO
	0405    80  DUP1
	0406    15  ISZERO
	0407    61  PUSH2 0x0440
	040A    57  *JUMPI
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @03FE  stack[-1] = 0x00
	//     @0404  stack[0] = !(stack[-6] % 0x04)
	// }
	// Block ends with conditional jump to 0x0440, if !!(stack[-6] % 0x04)

label_040B:
	// Incoming jump from 0x040A, if not !!(stack[-6] % 0x04)
	// Inputs[3]
	// {
	//     @040C  stack[-9]
	//     @040D  stack[-7]
	//     @040F  memory[stack[-9]:stack[-9] + 0x20]
	// }
	040B    50  POP
	040C    87  DUP8
	040D    86  DUP7
	040E    81  DUP2
	040F    51  MLOAD
	0410    81  DUP2
	0411    10  LT
	0412    61  PUSH2 0x0417
	0415    57  *JUMPI
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @040C  stack[-1] = stack[-9]
	//     @040D  stack[0] = stack[-7]
	// }
	// Block ends with conditional jump to 0x0417, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20]

label_0416:
	// Incoming jump from 0x0415, if not stack[-7] < memory[stack[-9]:stack[-9] + 0x20]
	0416    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0416  assert(); }
	// Block terminates

label_0417:
	// Incoming jump from 0x0415, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20]
	// Inputs[6]
	// {
	//     @0418  stack[-1]
	//     @0418  stack[-2]
	//     @0421  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0425  stack[-11]
	//     @0426  stack[-8]
	//     @0428  memory[stack[-11]:stack[-11] + 0x20]
	// }
	0417    5B  JUMPDEST
	0418    90  SWAP1
	0419    60  PUSH1 0x20
	041B    01  ADD
	041C    90  SWAP1
	041D    60  PUSH1 0x20
	041F    02  MUL
	0420    01  ADD
	0421    51  MLOAD
	0422    60  PUSH1 0x01
	0424    16  AND
	0425    89  DUP10
	0426    87  DUP8
	0427    81  DUP2
	0428    51  MLOAD
	0429    81  DUP2
	042A    10  LT
	042B    61  PUSH2 0x0430
	042E    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0424  stack[-2] = 0x01 & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0425  stack[-1] = stack[-11]
	//     @0426  stack[0] = stack[-8]
	// }
	// Block ends with conditional jump to 0x0430, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20]

label_042F:
	// Incoming jump from 0x042E, if not stack[-8] < memory[stack[-11]:stack[-11] + 0x20]
	042F    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @042F  assert(); }
	// Block terminates

label_0430:
	// Incoming jump from 0x042E, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20]
	// Inputs[4]
	// {
	//     @0431  stack[-1]
	//     @0431  stack[-2]
	//     @043A  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @043E  stack[-3]
	// }
	0430    5B  JUMPDEST
	0431    90  SWAP1
	0432    60  PUSH1 0x20
	0434    01  ADD
	0435    90  SWAP1
	0436    60  PUSH1 0x20
	0438    02  MUL
	0439    01  ADD
	043A    51  MLOAD
	043B    60  PUSH1 0x01
	043D    16  AND
	043E    14  EQ
	043F    15  ISZERO
	// Stack delta = -2
	// Outputs[1] { @043F  stack[-3] = !(0x01 & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20] == stack[-3]) }
	// Block continues

label_0440:
	// Incoming jump from 0x040A, if !!(stack[-6] % 0x04)
	// Incoming jump from 0x043F
	// Inputs[1] { @0441  stack[-1] }
	0440    5B  JUMPDEST
	0441    15  ISZERO
	0442    61  PUSH2 0x0491
	0445    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x0491, if !stack[-1]

label_0446:
	// Incoming jump from 0x0445, if not !stack[-1]
	// Inputs[2]
	// {
	//     @0449  stack[-11]
	//     @044C  stack[-10]
	// }
	0446    61  PUSH2 0x0451
	0449    8B  DUP12
	044A    60  PUSH1 0x03
	044C    8C  DUP13
	044D    61  PUSH2 0x0668
	0450    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0446  stack[0] = 0x0451
	//     @0449  stack[1] = stack[-11]
	//     @044A  stack[2] = 0x03
	//     @044C  stack[3] = stack[-10]
	// }
	// Block ends with call to 0x0668, returns to 0x0451

label_0451:
	// Incoming return from call to 0x0668 at 0x0450
	// Inputs[6]
	// {
	//     @0452  stack[-3]
	//     @0452  stack[-1]
	//     @0456  stack[-11]
	//     @045D  stack[-10]
	//     @045E  stack[-7]
	//     @0460  memory[stack[-10]:stack[-10] + 0x20]
	// }
	0451    5B  JUMPDEST
	0452    91  SWAP2
	0453    50  POP
	0454    60  PUSH1 0x03
	0456    8A  DUP11
	0457    01  ADD
	0458    99  SWAP10
	0459    50  POP
	045A    61  PUSH2 0x048e
	045D    89  DUP10
	045E    87  DUP8
	045F    81  DUP2
	0460    51  MLOAD
	0461    81  DUP2
	0462    10  LT
	0463    61  PUSH2 0x0468
	0466    57  *JUMPI
	// Stack delta = +2
	// Outputs[5]
	// {
	//     @0452  stack[-3] = stack[-1]
	//     @0458  stack[-11] = stack[-11] + 0x03
	//     @045A  stack[-1] = 0x048e
	//     @045D  stack[0] = stack[-10]
	//     @045E  stack[1] = stack[-7]
	// }
	// Block ends with conditional call to 0x0468, returns to 0x048E, if stack[-7] < memory[stack[-10]:stack[-10] + 0x20]

label_0467:
	// Incoming jump from 0x0466, if not stack[-7] < memory[stack[-10]:stack[-10] + 0x20]
	0467    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0467  assert(); }
	// Block terminates

label_0468:
	// Incoming call from 0x0466, returns to 0x048E, if stack[-7] < memory[stack[-10]:stack[-10] + 0x20]
	// Inputs[6]
	// {
	//     @0469  stack[-2]
	//     @0469  stack[-1]
	//     @0472  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0473  stack[-11]
	//     @0474  stack[-9]
	//     @0476  memory[stack[-11]:stack[-11] + 0x20]
	// }
	0468    5B  JUMPDEST
	0469    90  SWAP1
	046A    60  PUSH1 0x20
	046C    01  ADD
	046D    90  SWAP1
	046E    60  PUSH1 0x20
	0470    02  MUL
	0471    01  ADD
	0472    51  MLOAD
	0473    89  DUP10
	0474    88  DUP9
	0475    81  DUP2
	0476    51  MLOAD
	0477    81  DUP2
	0478    10  LT
	0479    61  PUSH2 0x047e
	047C    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0472  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0473  stack[-1] = stack[-11]
	//     @0474  stack[0] = stack[-9]
	// }
	// Block ends with conditional jump to 0x047e, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20]

label_047D:
	// Incoming jump from 0x047C, if not stack[-9] < memory[stack[-11]:stack[-11] + 0x20]
	047D    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @047D  assert(); }
	// Block terminates

label_047E:
	// Incoming jump from 0x047C, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20]
	// Inputs[4]
	// {
	//     @047F  stack[-2]
	//     @047F  stack[-1]
	//     @0488  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0489  stack[-6]
	// }
	047E    5B  JUMPDEST
	047F    90  SWAP1
	0480    60  PUSH1 0x20
	0482    01  ADD
	0483    90  SWAP1
	0484    60  PUSH1 0x20
	0486    02  MUL
	0487    01  ADD
	0488    51  MLOAD
	0489    84  DUP5
	048A    61  PUSH2 0x067e
	048D    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0488  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0489  stack[-1] = stack[-6]
	// }
	// Block ends with unconditional jump to 0x067e

label_048E:
	// Incoming return from call to 0x0468 at 0x0466
	// Inputs[2]
	// {
	//     @048F  stack[-2]
	//     @048F  stack[-1]
	// }
	048E    5B  JUMPDEST
	048F    90  SWAP1
	0490    50  POP
	// Stack delta = -1
	// Outputs[1] { @048F  stack[-2] = stack[-1] }
	// Block continues

label_0491:
	// Incoming jump from 0x0490
	// Incoming jump from 0x0445, if !stack[-1]
	// Inputs[1] { @0494  stack[-1] }
	0491    5B  JUMPDEST
	0492    60  PUSH1 0x00
	0494    81  DUP2
	0495    60  PUSH1 0xff
	0497    16  AND
	0498    11  GT
	0499    15  ISZERO
	049A    61  PUSH2 0x04c0
	049D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x04c0, if !(0xff & stack[-1] > 0x00)

label_049E:
	// Incoming jump from 0x049D, if not !(0xff & stack[-1] > 0x00)
	// Inputs[4]
	// {
	//     @049E  stack[-1]
	//     @049F  stack[-7]
	//     @04A0  stack[-6]
	//     @04A2  memory[stack[-7]:stack[-7] + 0x20]
	// }
	049E    80  DUP1
	049F    87  DUP8
	04A0    87  DUP8
	04A1    81  DUP2
	04A2    51  MLOAD
	04A3    81  DUP2
	04A4    10  LT
	04A5    61  PUSH2 0x04aa
	04A8    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @049E  stack[0] = stack[-1]
	//     @049F  stack[1] = stack[-7]
	//     @04A0  stack[2] = stack[-6]
	// }
	// Block ends with conditional jump to 0x04aa, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20]

label_04A9:
	// Incoming jump from 0x04A8, if not stack[-6] < memory[stack[-7]:stack[-7] + 0x20]
	04A9    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @04A9  assert(); }
	// Block terminates

label_04AA:
	// Incoming jump from 0x04A8, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20]
	// Incoming jump from 0x04FD, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20]
	// Inputs[3]
	// {
	//     @04AD  stack[-1]
	//     @04AE  stack[-3]
	//     @04B6  stack[-2]
	// }
	04AA    5B  JUMPDEST
	04AB    60  PUSH1 0xff
	04AD    90  SWAP1
	04AE    92  SWAP3
	04AF    16  AND
	04B0    60  PUSH1 0x20
	04B2    92  SWAP3
	04B3    83  DUP4
	04B4    02  MUL
	04B5    90  SWAP1
	04B6    91  SWAP2
	04B7    01  ADD
	04B8    90  SWAP1
	04B9    91  SWAP2
	04BA    01  ADD
	04BB    52  MSTORE
	04BC    61  PUSH2 0x0533
	04BF    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @04BB  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff }
	// Block ends with unconditional jump to 0x0533

label_04C0:
	// Incoming jump from 0x049D, if !(0xff & stack[-1] > 0x00)
	// Inputs[2]
	// {
	//     @04C4  stack[-11]
	//     @04C7  stack[-10]
	// }
	04C0    5B  JUMPDEST
	04C1    61  PUSH2 0x04cc
	04C4    8B  DUP12
	04C5    60  PUSH1 0x01
	04C7    8C  DUP13
	04C8    61  PUSH2 0x0668
	04CB    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @04C1  stack[0] = 0x04cc
	//     @04C4  stack[1] = stack[-11]
	//     @04C5  stack[2] = 0x01
	//     @04C7  stack[3] = stack[-10]
	// }
	// Block ends with call to 0x0668, returns to 0x04CC

label_04CC:
	// Incoming return from call to 0x0668 at 0x04CB
	// Inputs[3]
	// {
	//     @04CD  stack[-3]
	//     @04CD  stack[-1]
	//     @04D1  stack[-11]
	// }
	04CC    5B  JUMPDEST
	04CD    91  SWAP2
	04CE    50  POP
	04CF    60  PUSH1 0x01
	04D1    8A  DUP11
	04D2    01  ADD
	04D3    99  SWAP10
	04D4    50  POP
	04D5    81  DUP2
	04D6    60  PUSH1 0x00
	04D8    14  EQ
	04D9    15  ISZERO
	04DA    61  PUSH2 0x04ff
	04DD    57  *JUMPI
	// Stack delta = -1
	// Outputs[2]
	// {
	//     @04CD  stack[-3] = stack[-1]
	//     @04D3  stack[-11] = stack[-11] + 0x01
	// }
	// Block ends with conditional jump to 0x04ff, if !(0x00 == stack[-1])

label_04DE:
	// Incoming jump from 0x04DD, if not !(0x00 == stack[-1])
	// Inputs[3]
	// {
	//     @04DE  stack[-9]
	//     @04DF  stack[-6]
	//     @04E1  memory[stack[-9]:stack[-9] + 0x20]
	// }
	04DE    88  DUP9
	04DF    86  DUP7
	04E0    81  DUP2
	04E1    51  MLOAD
	04E2    81  DUP2
	04E3    10  LT
	04E4    61  PUSH2 0x04e9
	04E7    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @04DE  stack[0] = stack[-9]
	//     @04DF  stack[1] = stack[-6]
	// }
	// Block ends with conditional jump to 0x04e9, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20]

label_04E8:
	// Incoming jump from 0x04E7, if not stack[-6] < memory[stack[-9]:stack[-9] + 0x20]
	04E8    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @04E8  assert(); }
	// Block terminates

label_04E9:
	// Incoming jump from 0x04E7, if stack[-6] < memory[stack[-9]:stack[-9] + 0x20]
	// Inputs[6]
	// {
	//     @04EA  stack[-1]
	//     @04EA  stack[-2]
	//     @04F3  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @04F4  stack[-9]
	//     @04F5  stack[-8]
	//     @04F7  memory[stack[-9]:stack[-9] + 0x20]
	// }
	04E9    5B  JUMPDEST
	04EA    90  SWAP1
	04EB    60  PUSH1 0x20
	04ED    01  ADD
	04EE    90  SWAP1
	04EF    60  PUSH1 0x20
	04F1    02  MUL
	04F2    01  ADD
	04F3    51  MLOAD
	04F4    87  DUP8
	04F5    87  DUP8
	04F6    81  DUP2
	04F7    51  MLOAD
	04F8    81  DUP2
	04F9    10  LT
	04FA    61  PUSH2 0x04aa
	04FD    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @04F3  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @04F4  stack[-1] = stack[-9]
	//     @04F5  stack[0] = stack[-8]
	// }
	// Block ends with conditional jump to 0x04aa, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20]

label_04FE:
	// Incoming jump from 0x04FD, if not stack[-8] < memory[stack[-9]:stack[-9] + 0x20]
	04FE    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @04FE  assert(); }
	// Block terminates

label_04FF:
	// Incoming jump from 0x04DD, if !(0x00 == stack[-1])
	// Inputs[3]
	// {
	//     @0500  stack[-8]
	//     @0501  stack[-6]
	//     @0503  memory[stack[-8]:stack[-8] + 0x20]
	// }
	04FF    5B  JUMPDEST
	0500    87  DUP8
	0501    86  DUP7
	0502    81  DUP2
	0503    51  MLOAD
	0504    81  DUP2
	0505    10  LT
	0506    61  PUSH2 0x050b
	0509    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0500  stack[0] = stack[-8]
	//     @0501  stack[1] = stack[-6]
	// }
	// Block ends with conditional jump to 0x050b, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20]

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

label_050B:
	// Incoming jump from 0x0509, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20]
	// Inputs[6]
	// {
	//     @050C  stack[-2]
	//     @050C  stack[-1]
	//     @0515  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0516  stack[-9]
	//     @0517  stack[-8]
	//     @0519  memory[stack[-9]:stack[-9] + 0x20]
	// }
	050B    5B  JUMPDEST
	050C    90  SWAP1
	050D    60  PUSH1 0x20
	050F    01  ADD
	0510    90  SWAP1
	0511    60  PUSH1 0x20
	0513    02  MUL
	0514    01  ADD
	0515    51  MLOAD
	0516    87  DUP8
	0517    87  DUP8
	0518    81  DUP2
	0519    51  MLOAD
	051A    81  DUP2
	051B    10  LT
	051C    61  PUSH2 0x0521
	051F    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0515  stack[-2] = memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @0516  stack[-1] = stack[-9]
	//     @0517  stack[0] = stack[-8]
	// }
	// Block ends with conditional jump to 0x0521, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20]

label_0520:
	// Incoming jump from 0x051F, if not stack[-8] < memory[stack[-9]:stack[-9] + 0x20]
	0520    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0520  assert(); }
	// Block terminates

label_0521:
	// Incoming jump from 0x051F, if stack[-8] < memory[stack[-9]:stack[-9] + 0x20]
	// Inputs[3]
	// {
	//     @0524  stack[-1]
	//     @0525  stack[-3]
	//     @052D  stack[-2]
	// }
	0521    5B  JUMPDEST
	0522    60  PUSH1 0xff
	0524    90  SWAP1
	0525    92  SWAP3
	0526    16  AND
	0527    60  PUSH1 0x20
	0529    92  SWAP3
	052A    83  DUP4
	052B    02  MUL
	052C    90  SWAP1
	052D    91  SWAP2
	052E    01  ADD
	052F    90  SWAP1
	0530    91  SWAP2
	0531    01  ADD
	0532    52  MSTORE
	// Stack delta = -3
	// Outputs[1] { @0532  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff }
	// Block continues

label_0533:
	// Incoming jump from 0x04BF
	// Incoming jump from 0x0532
	// Inputs[2]
	// {
	//     @0536  stack[-1]
	//     @0537  stack[-6]
	// }
	0533    5B  JUMPDEST
	0534    60  PUSH1 0x01
	0536    90  SWAP1
	0537    95  SWAP6
	0538    01  ADD
	0539    94  SWAP5
	053A    61  PUSH2 0x03f3
	053D    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0539  stack[-6] = stack[-6] + 0x01
	//     @0539  stack[-1] = stack[-1]
	// }
	// Block ends with unconditional jump to 0x03f3

label_053E:
	// Incoming jump from 0x03FC, if !(stack[-6] < 0x30)
	// Incoming jump from 0x03FC, if !(0x00 < 0x30)
	// Inputs[1] { @0542  stack[-7] }
	053E    5B  JUMPDEST
	053F    61  PUSH2 0x0547
	0542    87  DUP8
	0543    61  PUSH2 0x055a
	0546    56  *JUMP
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @053F  stack[0] = 0x0547
	//     @0542  stack[1] = stack[-7]
	// }
	// Block ends with call to 0x055a, returns to 0x0547

label_0547:
	// Incoming return from call to 0x055A at 0x0546
	// Inputs[3]
	// {
	//     @0548  stack[-1]
	//     @0548  stack[-17]
	//     @0549  stack[-16]
	// }
	0547    5B  JUMPDEST
	0548    9F  SWAP16
	0549    9E  SWAP15
	054A    50  POP
	054B    50  POP
	054C    50  POP
	054D    50  POP
	054E    50  POP
	054F    50  POP
	0550    50  POP
	0551    50  POP
	0552    50  POP
	0553    50  POP
	0554    50  POP
	0555    50  POP
	0556    50  POP
	0557    50  POP
	0558    50  POP
	0559    56  *JUMP
	// Stack delta = -16
	// Outputs[1] { @0548  stack[-17] = stack[-1] }
	// Block ends with unconditional jump to stack[-17]

label_055A:
	// Incoming call from 0x0546, returns to 0x0547
	// Incoming call from 0x00ED, returns to 0x008D
	055A    5B  JUMPDEST
	055B    60  PUSH1 0x00
	055D    80  DUP1
	055E    5B  JUMPDEST
	055F    60  PUSH1 0x30
	0561    81  DUP2
	0562    10  LT
	0563    15  ISZERO
	0564    61  PUSH2 0x0597
	0567    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @055B  stack[0] = 0x00
	//     @055D  stack[1] = 0x00
	// }
	// Block ends with conditional jump to 0x0597, if !(0x00 < 0x30)

label_0568:
	// Incoming jump from 0x0567, if not !(stack[-1] < 0x30)
	// Incoming jump from 0x0567, if not !(0x00 < 0x30)
	// Inputs[4]
	// {
	//     @056A  stack[-1]
	//     @056B  stack[-2]
	//     @056E  stack[-3]
	//     @0575  memory[stack[-3]:stack[-3] + 0x20]
	// }
	0568    60  PUSH1 0x20
	056A    90  SWAP1
	056B    91  SWAP2
	056C    02  MUL
	056D    90  SWAP1
	056E    82  DUP3
	056F    60  PUSH1 0x2f
	0571    82  DUP3
	0572    90  SWAP1
	0573    03  SUB
	0574    81  DUP2
	0575    51  MLOAD
	0576    81  DUP2
	0577    10  LT
	0578    61  PUSH2 0x057d
	057B    57  *JUMPI
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @056D  stack[-2] = stack[-2] * 0x20
	//     @056D  stack[-1] = stack[-1]
	//     @056E  stack[0] = stack[-3]
	//     @0573  stack[1] = 0x2f - stack[-1]
	// }
	// Block ends with conditional jump to 0x057d, if 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20]

label_057C:
	// Incoming jump from 0x057B, if not 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20]
	057C    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @057C  assert(); }
	// Block terminates

label_057D:
	// Incoming jump from 0x057B, if 0x2f - stack[-1] < memory[stack[-3]:stack[-3] + 0x20]
	// Inputs[5]
	// {
	//     @057E  stack[-2]
	//     @057E  stack[-1]
	//     @0587  memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]
	//     @058B  stack[-4]
	//     @058C  stack[-3]
	// }
	057D    5B  JUMPDEST
	057E    90  SWAP1
	057F    60  PUSH1 0x20
	0581    01  ADD
	0582    90  SWAP1
	0583    60  PUSH1 0x20
	0585    02  MUL
	0586    01  ADD
	0587    51  MLOAD
	0588    60  PUSH1 0xff
	058A    16  AND
	058B    91  SWAP2
	058C    90  SWAP1
	058D    91  SWAP2
	058E    17  OR
	058F    90  SWAP1
	0590    60  PUSH1 0x01
	0592    01  ADD
	0593    61  PUSH2 0x055e
	0596    56  *JUMP
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @058F  stack[-4] = (0xff & memory[0x20 * stack[-1] + 0x20 + stack[-2]:0x20 * stack[-1] + 0x20 + stack[-2] + 0x20]) | stack[-4]
	//     @0592  stack[-3] = 0x01 + stack[-3]
	// }
	// Block ends with unconditional jump to 0x055e

label_0597:
	// Incoming jump from 0x0567, if !(stack[-1] < 0x30)
	// Incoming jump from 0x0567, if !(0x00 < 0x30)
	// Inputs[3]
	// {
	//     @0599  stack[-4]
	//     @0599  stack[-2]
	//     @059A  stack[-3]
	// }
	0597    5B  JUMPDEST
	0598    50  POP
	0599    91  SWAP2
	059A    90  SWAP1
	059B    50  POP
	059C    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @0599  stack[-4] = stack[-2] }
	// Block ends with unconditional jump to stack[-4]

label_059D:
	// Incoming call from 0x0100, returns to 0x0101
	// Inputs[2]
	// {
	//     @05A0  storage[0x00]
	//     @05A4  stack[-1]
	// }
	059D    5B  JUMPDEST
	059E    60  PUSH1 0x00
	05A0    54  SLOAD
	05A1    60  PUSH1 0xff
	05A3    16  AND
	05A4    81  DUP2
	05A5    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @05A3  stack[0] = 0xff & storage[0x00] }
	// Block ends with unconditional jump to stack[-1]

label_05A6:
	// Incoming call from 0x0268, returns to 0x0269
	// Incoming call from 0x012A, returns to 0x012B
	// Incoming call from 0x0273, returns to 0x0274
	05A6    5B  JUMPDEST
	05A7    61  PUSH2 0x05ae
	05AA    61  PUSH2 0x0709
	05AD    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @05A7  stack[0] = 0x05ae }
	// Block ends with call to 0x0709, returns to 0x05AE

label_05AE:
	// Incoming return from call to 0x0709 at 0x05AD
	05AE    5B  JUMPDEST
	05AF    61  PUSH2 0x05b6
	05B2    61  PUSH2 0x0709
	05B5    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @05AF  stack[0] = 0x05b6 }
	// Block ends with call to 0x0709, returns to 0x05B6

label_05B6:
	// Incoming return from call to 0x0709 at 0x05B5
	// Inputs[2]
	// {
	//     @05BD  memory[0x40:0x60]
	//     @05BF  MSIZE()
	// }
	05B6    5B  JUMPDEST
	05B7    60  PUSH1 0x00
	05B9    60  PUSH1 0x30
	05BB    60  PUSH1 0x40
	05BD    51  MLOAD
	05BE    80  DUP1
	05BF    59  MSIZE
	05C0    10  LT
	05C1    61  PUSH2 0x05c7
	05C4    57  *JUMPI
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @05B7  stack[0] = 0x00
	//     @05B9  stack[1] = 0x30
	//     @05BD  stack[2] = memory[0x40:0x60]
	// }
	// Block ends with conditional jump to 0x05c7, if MSIZE() < memory[0x40:0x60]

label_05C5:
	// Incoming jump from 0x05C4, if not MSIZE() < memory[0x40:0x60]
	// Inputs[4]
	// {
	//     @05C6  MSIZE()
	//     @05C8  stack[-2]
	//     @05D9  stack[-4]
	//     @05DD  stack[-3]
	// }
	05C5    50  POP
	05C6    59  MSIZE
	05C7    5B  JUMPDEST
	05C8    90  SWAP1
	05C9    80  DUP1
	05CA    82  DUP3
	05CB    52  MSTORE
	05CC    80  DUP1
	05CD    60  PUSH1 0x20
	05CF    02  MUL
	05D0    60  PUSH1 0x20
	05D2    01  ADD
	05D3    82  DUP3
	05D4    01  ADD
	05D5    60  PUSH1 0x40
	05D7    52  MSTORE
	05D8    50  POP
	05D9    91  SWAP2
	05DA    50  POP
	05DB    60  PUSH1 0x00
	05DD    90  SWAP1
	05DE    50  POP
	05DF    5B  JUMPDEST
	05E0    60  PUSH1 0x30
	05E2    81  DUP2
	05E3    10  LT
	05E4    15  ISZERO
	05E5    61  PUSH2 0x0617
	05E8    57  *JUMPI
	// Stack delta = -2
	// Outputs[4]
	// {
	//     @05CB  memory[MSIZE():MSIZE() + 0x20] = stack[-2]
	//     @05D7  memory[0x40:0x60] = MSIZE() + 0x20 + 0x20 * stack[-2]
	//     @05D9  stack[-4] = MSIZE()
	//     @05DD  stack[-3] = 0x00
	// }
	// Block ends with conditional jump to 0x0617, if !(0x00 < 0x30)

label_05E9:
	// Incoming jump from 0x05E8, if not !(0x00 < 0x30)
	// Incoming jump from 0x05E8, if not !(0x00 < 0x30)
	// Incoming jump from 0x05E8, if not !(stack[-1] < 0x30)
	// Inputs[2]
	// {
	//     @05EC  stack[-4]
	//     @05ED  stack[-1]
	// }
	05E9    61  PUSH2 0x05f2
	05EC    84  DUP5
	05ED    82  DUP3
	05EE    61  PUSH2 0x06f1
	05F1    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @05E9  stack[0] = 0x05f2
	//     @05EC  stack[1] = stack[-4]
	//     @05ED  stack[2] = stack[-1]
	// }
	// Block ends with call to 0x06f1, returns to 0x05F2

label_05F2:
	// Incoming return from call to 0x06F1 at 0x05F1
	// Inputs[3]
	// {
	//     @05F3  stack[-3]
	//     @05F4  stack[-2]
	//     @05F6  memory[stack[-3]:stack[-3] + 0x20]
	// }
	05F2    5B  JUMPDEST
	05F3    82  DUP3
	05F4    82  DUP3
	05F5    81  DUP2
	05F6    51  MLOAD
	05F7    81  DUP2
	05F8    10  LT
	05F9    61  PUSH2 0x05fe
	05FC    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @05F3  stack[0] = stack[-3]
	//     @05F4  stack[1] = stack[-2]
	// }
	// Block ends with conditional jump to 0x05fe, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20]

label_05FD:
	// Incoming jump from 0x05FC, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20]
	05FD    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @05FD  assert(); }
	// Block terminates

label_05FE:
	// Incoming jump from 0x05FC, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20]
	// Inputs[4]
	// {
	//     @0601  stack[-1]
	//     @0602  stack[-3]
	//     @060A  stack[-2]
	//     @0612  stack[-4]
	// }
	05FE    5B  JUMPDEST
	05FF    60  PUSH1 0xff
	0601    90  SWAP1
	0602    92  SWAP3
	0603    16  AND
	0604    60  PUSH1 0x20
	0606    92  SWAP3
	0607    83  DUP4
	0608    02  MUL
	0609    90  SWAP1
	060A    91  SWAP2
	060B    01  ADD
	060C    90  SWAP1
	060D    91  SWAP2
	060E    01  ADD
	060F    52  MSTORE
	0610    60  PUSH1 0x01
	0612    01  ADD
	0613    61  PUSH2 0x05df
	0616    56  *JUMP
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @060F  memory[0x20 + stack[-2] + 0x20 * stack[-1]:0x20 + stack[-2] + 0x20 * stack[-1] + 0x20] = stack[-3] & 0xff
	//     @0612  stack[-4] = 0x01 + stack[-4]
	// }
	// Block ends with unconditional jump to 0x05df

label_0617:
	// Incoming jump from 0x05E8, if !(0x00 < 0x30)
	// Incoming jump from 0x063A, if !(0x00 < 0x0c)
	// Incoming jump from 0x05E8, if !(stack[-1] < 0x30)
	// Incoming jump from 0x063A, if !(stack[-1] < 0x0c)
	// Incoming jump from 0x05E8, if !(0x00 < 0x30)
	// Inputs[3]
	// {
	//     @0619  stack[-2]
	//     @0619  stack[-5]
	//     @061A  stack[-4]
	// }
	0617    5B  JUMPDEST
	0618    50  POP
	0619    92  SWAP3
	061A    91  SWAP2
	061B    50  POP
	061C    50  POP
	061D    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @0619  stack[-5] = stack[-2] }
	// Block ends with unconditional jump to stack[-5]

label_061E:
	// Incoming call from 0x0193, returns to 0x0194
	061E    5B  JUMPDEST
	061F    61  PUSH2 0x0626
	0622    61  PUSH2 0x071b
	0625    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @061F  stack[0] = 0x0626 }
	// Block ends with call to 0x071b, returns to 0x0626

label_0626:
	// Incoming return from call to 0x071B at 0x0625
	0626    5B  JUMPDEST
	0627    61  PUSH2 0x062e
	062A    61  PUSH2 0x071b
	062D    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @0627  stack[0] = 0x062e }
	// Block ends with call to 0x071b, returns to 0x062E

label_062E:
	// Incoming return from call to 0x071B at 0x062D
	062E    5B  JUMPDEST
	062F    60  PUSH1 0x00
	0631    5B  JUMPDEST
	0632    60  PUSH1 0x0c
	0634    81  DUP2
	0635    10  LT
	0636    15  ISZERO
	0637    61  PUSH2 0x0617
	063A    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @062F  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x0617, if !(0x00 < 0x0c)

label_063B:
	// Incoming jump from 0x063A, if not !(0x00 < 0x0c)
	// Incoming jump from 0x063A, if not !(stack[-1] < 0x0c)
	// Inputs[2]
	// {
	//     @063E  stack[-4]
	//     @063F  stack[-1]
	// }
	063B    61  PUSH2 0x0647
	063E    84  DUP5
	063F    82  DUP3
	0640    60  PUSH1 0x04
	0642    02  MUL
	0643    61  PUSH2 0x06f1
	0646    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @063B  stack[0] = 0x0647
	//     @063E  stack[1] = stack[-4]
	//     @0642  stack[2] = 0x04 * stack[-1]
	// }
	// Block ends with call to 0x06f1, returns to 0x0647

label_0647:
	// Incoming return from call to 0x06F1 at 0x0646
	// Inputs[2]
	// {
	//     @0648  stack[-3]
	//     @0649  stack[-2]
	// }
	0647    5B  JUMPDEST
	0648    82  DUP3
	0649    82  DUP3
	064A    60  PUSH1 0x0c
	064C    81  DUP2
	064D    10  LT
	064E    61  PUSH2 0x0653
	0651    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @0648  stack[0] = stack[-3]
	//     @0649  stack[1] = stack[-2]
	// }
	// Block ends with conditional jump to 0x0653, if stack[-2] < 0x0c

label_0652:
	// Incoming jump from 0x0651, if not stack[-2] < 0x0c
	0652    FE  *ASSERT
	// Stack delta = +0
	// Outputs[1] { @0652  assert(); }
	// Block terminates

label_0653:
	// Incoming jump from 0x0651, if stack[-2] < 0x0c
	// Inputs[4]
	// {
	//     @0656  stack[-1]
	//     @0657  stack[-3]
	//     @065F  stack[-2]
	//     @0663  stack[-4]
	// }
	0653    5B  JUMPDEST
	0654    60  PUSH1 0xff
	0656    90  SWAP1
	0657    92  SWAP3
	0658    16  AND
	0659    60  PUSH1 0x20
	065B    92  SWAP3
	065C    90  SWAP1
	065D    92  SWAP3
	065E    02  MUL
	065F    01  ADD
	0660    52  MSTORE
	0661    60  PUSH1 0x01
	0663    01  ADD
	0664    61  PUSH2 0x0631
	0667    56  *JUMP
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @0660  memory[0x20 * stack[-1] + stack[-2]:0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] & 0xff
	//     @0663  stack[-4] = 0x01 + stack[-4]
	// }
	// Block ends with unconditional jump to 0x0631

label_0668:
	// Incoming call from 0x04CB, returns to 0x04CC
	// Incoming call from 0x0354, returns to 0x0355
	// Incoming call from 0x0701, returns to 0x0702
	// Incoming call from 0x0450, returns to 0x0451
	// Incoming call from 0x02C6, returns to 0x02C7
	// Inputs[4]
	// {
	//     @066B  stack[-1]
	//     @066E  stack[-2]
	//     @0677  stack[-3]
	//     @067C  stack[-4]
	// }
	0668    5B  JUMPDEST
	0669    60  PUSH1 0x02
	066B    90  SWAP1
	066C    81  DUP2
	066D    0A  EXP
	066E    91  SWAP2
	066F    90  SWAP1
	0670    0A  EXP
	0671    60  PUSH1 0x00
	0673    19  NOT
	0674    01  ADD
	0675    81  DUP2
	0676    02  MUL
	0677    91  SWAP2
	0678    90  SWAP1
	0679    91  SWAP2
	067A    16  AND
	067B    04  DIV
	067C    90  SWAP1
	067D    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @067C  stack[-4] = (0x02 ** stack[-1] * (~0x00 + 0x02 ** stack[-2]) & stack[-3]) / 0x02 ** stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_067E:
	// Incoming jump from 0x048D
	// Inputs[2]
	// {
	//     @0681  stack[-3]
	//     @0682  stack[-2]
	// }
	067E    5B  JUMPDEST
	067F    60  PUSH1 0x00
	0681    83  DUP4
	0682    83  DUP4
	0683    82  DUP3
	0684    60  PUSH1 0xff
	0686    80  DUP1
	0687    83  DUP4
	0688    16  AND
	0689    90  SWAP1
	068A    84  DUP5
	068B    16  AND
	068C    11  GT
	068D    15  ISZERO
	068E    61  PUSH2 0x0698
	0691    57  *JUMPI
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @067F  stack[0] = 0x00
	//     @0681  stack[1] = stack[-3]
	//     @0682  stack[2] = stack[-2]
	//     @0683  stack[3] = 0x00
	// }
	// Block ends with conditional jump to 0x0698, if !(stack[-3] & 0xff > stack[-2] & 0xff)

label_0692:
	// Incoming jump from 0x0691, if not !(stack[-3] & 0xff > stack[-2] & 0xff)
	// Inputs[4]
	// {
	//     @0692  stack[-7]
	//     @0693  stack[-2]
	//     @0695  stack[-6]
	//     @0696  stack[-3]
	// }
	0692    86  DUP7
	0693    91  SWAP2
	0694    50  POP
	0695    85  DUP6
	0696    92  SWAP3
	0697    50  POP
	0698    5B  JUMPDEST
	0699    82  DUP3
	069A    82  DUP3
	069B    03  SUB
	069C    60  PUSH1 0xff
	069E    16  AND
	069F    60  PUSH1 0x01
	06A1    14  EQ
	06A2    80  DUP1
	06A3    15  ISZERO
	06A4    61  PUSH2 0x06b6
	06A7    57  *JUMPI
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0693  stack[-2] = stack[-7]
	//     @0696  stack[-3] = stack[-6]
	//     @06A1  stack[0] = 0x01 == 0xff & stack[-7] - stack[-6]
	// }
	// Block ends with conditional jump to 0x06b6, if !(0x01 == 0xff & stack[-7] - stack[-6])

label_06A8:
	// Incoming jump from 0x06A7, if not !(0x01 == 0xff & stack[-7] - stack[-6])
	// Incoming jump from 0x06A7, if not !(0x01 == 0xff & stack[-2] - stack[-3])
	// Inputs[1] { @06AD  stack[-4] }
	06A8    50  POP
	06A9    60  PUSH1 0x02
	06AB    60  PUSH1 0xff
	06AD    84  DUP5
	06AE    16  AND
	06AF    06  MOD
	06B0    60  PUSH1 0xff
	06B2    16  AND
	06B3    60  PUSH1 0x00
	06B5    14  EQ
	06B6    5B  JUMPDEST
	06B7    15  ISZERO
	06B8    61  PUSH2 0x06e7
	06BB    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x06e7, if !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02)

label_06BC:
	// Incoming jump from 0x06BB, if not !stack[-1]
	// Incoming jump from 0x06BB, if not !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02)
	// Inputs[1] { @06BE  stack[-3] }
	06BC    60  PUSH1 0x17
	06BE    83  DUP4
	06BF    60  PUSH1 0xff
	06C1    16  AND
	06C2    10  LT
	06C3    15  ISZERO
	06C4    61  PUSH2 0x06cf
	06C7    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x06cf, if !(0xff & stack[-3] < 0x17)

label_06C8:
	// Incoming jump from 0x06C7, if not !(0xff & stack[-3] < 0x17)
	06C8    50  POP
	06C9    60  PUSH1 0x01
	06CB    61  PUSH2 0x06d3
	06CE    56  *JUMP
	// Stack delta = +0
	// Outputs[1] { @06C9  stack[-1] = 0x01 }
	// Block ends with unconditional jump to 0x06d3

label_06CF:
	// Incoming jump from 0x06C7, if !(0xff & stack[-3] < 0x17)
	// Inputs[1] { @06D5  stack[-5] }
	06CF    5B  JUMPDEST
	06D0    50  POP
	06D1    60  PUSH1 0x00
	06D3    5B  JUMPDEST
	06D4    80  DUP1
	06D5    85  DUP6
	06D6    11  GT
	06D7    61  PUSH2 0x06e7
	06DA    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @06D1  stack[-1] = 0x00 }
	// Block ends with conditional jump to 0x06e7, if stack[-5] > 0x00

label_06DB:
	// Incoming jump from 0x06DA, if not stack[-5] > stack[-1]
	// Incoming jump from 0x06DA, if not stack[-5] > 0x00
	// Inputs[2]
	// {
	//     @06DF  stack[-3]
	//     @06E5  stack[-4]
	// }
	06DB    60  PUSH1 0x02
	06DD    60  PUSH1 0xff
	06DF    84  DUP5
	06E0    16  AND
	06E1    04  DIV
	06E2    60  PUSH1 0x10
	06E4    01  ADD
	06E5    93  SWAP4
	06E6    50  POP
	// Stack delta = +0
	// Outputs[1] { @06E5  stack[-4] = 0x10 + (stack[-3] & 0xff) / 0x02 }
	// Block continues

label_06E7:
	// Incoming jump from 0x06BB, if !stack[-1]
	// Incoming jump from 0x06DA, if stack[-5] > stack[-1]
	// Incoming jump from 0x06BB, if !(0x00 == 0xff & (stack[-4] & 0xff) % 0x02)
	// Incoming jump from 0x06DA, if stack[-5] > 0x00
	// Incoming jump from 0x06E6
	// Inputs[3]
	// {
	//     @06EB  stack[-4]
	//     @06EB  stack[-8]
	//     @06EC  stack[-7]
	// }
	06E7    5B  JUMPDEST
	06E8    50  POP
	06E9    50  POP
	06EA    50  POP
	06EB    93  SWAP4
	06EC    92  SWAP3
	06ED    50  POP
	06EE    50  POP
	06EF    50  POP
	06F0    56  *JUMP
	// Stack delta = -7
	// Outputs[1] { @06EB  stack[-8] = stack[-4] }
	// Block ends with unconditional jump to stack[-8]

label_06F1:
	// Incoming call from 0x0646, returns to 0x0647
	// Incoming call from 0x05F1, returns to 0x05F2
	// Inputs[2]
	// {
	//     @06F7  stack[-2]
	//     @06FA  stack[-1]
	// }
	06F1    5B  JUMPDEST
	06F2    60  PUSH1 0x00
	06F4    61  PUSH2 0x0702
	06F7    83  DUP4
	06F8    60  PUSH1 0x05
	06FA    84  DUP5
	06FB    60  PUSH1 0x05
	06FD    02  MUL
	06FE    61  PUSH2 0x0668
	0701    56  *JUMP
	// Stack delta = +5
	// Outputs[5]
	// {
	//     @06F2  stack[0] = 0x00
	//     @06F4  stack[1] = 0x0702
	//     @06F7  stack[2] = stack[-2]
	//     @06F8  stack[3] = 0x05
	//     @06FD  stack[4] = 0x05 * stack[-1]
	// }
	// Block ends with call to 0x0668, returns to 0x0702

label_0702:
	// Incoming return from call to 0x0668 at 0x0701
	// Inputs[3]
	// {
	//     @0703  stack[-1]
	//     @0703  stack[-5]
	//     @0704  stack[-4]
	// }
	0702    5B  JUMPDEST
	0703    93  SWAP4
	0704    92  SWAP3
	0705    50  POP
	0706    50  POP
	0707    50  POP
	0708    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @0703  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

label_0709:
	// Incoming call from 0x05AD, returns to 0x05AE
	// Incoming call from 0x01D9, returns to 0x01DA
	// Incoming call from 0x05B5, returns to 0x05B6
	// Incoming call from 0x01E1, returns to 0x01E2
	// Incoming call from 0x01E9, returns to 0x01EA
	// Inputs[2]
	// {
	//     @070E  memory[0x40:0x60]
	//     @0719  stack[-1]
	// }
	0709    5B  JUMPDEST
	070A    60  PUSH1 0x20
	070C    60  PUSH1 0x40
	070E    51  MLOAD
	070F    90  SWAP1
	0710    81  DUP2
	0711    01  ADD
	0712    60  PUSH1 0x40
	0714    52  MSTORE
	0715    60  PUSH1 0x00
	0717    81  DUP2
	0718    52  MSTORE
	0719    90  SWAP1
	071A    56  *JUMP
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @0714  memory[0x40:0x60] = memory[0x40:0x60] + 0x20
	//     @0718  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00
	//     @0719  stack[-1] = memory[0x40:0x60]
	// }
	// Block ends with unconditional jump to stack[-1]

label_071B:
	// Incoming call from 0x0625, returns to 0x0626
	// Incoming call from 0x062D, returns to 0x062E
	// Inputs[1] { @0721  memory[0x40:0x60] }
	071B    5B  JUMPDEST
	071C    61  PUSH2 0x0180
	071F    60  PUSH1 0x40
	0721    51  MLOAD
	0722    90  SWAP1
	0723    81  DUP2
	0724    01  ADD
	0725    60  PUSH1 0x40
	0727    52  MSTORE
	0728    60  PUSH1 0x0c
	072A    81  DUP2
	072B    5B  JUMPDEST
	072C    60  PUSH1 0x00
	072E    81  DUP2
	072F    52  MSTORE
	0730    60  PUSH1 0x00
	0732    19  NOT
	0733    90  SWAP1
	0734    91  SWAP2
	0735    01  ADD
	0736    90  SWAP1
	0737    60  PUSH1 0x20
	0739    01  ADD
	073A    81  DUP2
	073B    61  PUSH2 0x072b
	073E    57  *JUMPI
	// Stack delta = +3
	// Outputs[5]
	// {
	//     @0722  stack[0] = memory[0x40:0x60]
	//     @0727  memory[0x40:0x60] = memory[0x40:0x60] + 0x0180
	//     @072F  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00
	//     @0736  stack[1] = 0x0c + ~0x00
	//     @0739  stack[2] = 0x20 + memory[0x40:0x60]
	// }
	// Block ends with conditional jump to 0x072b, if 0x0c + ~0x00

label_073F:
	// Incoming jump from 0x073E, if not 0x0c + ~0x00
	// Incoming jump from 0x073E, if not stack[-2] + ~0x00
	// Inputs[4]
	// {
	//     @073F  stack[-1]
	//     @073F  stack[-2]
	//     @0742  stack[-3]
	//     @0742  stack[-4]
	// }
	073F    90  SWAP1
	0740    50  POP
	0741    50  POP
	0742    90  SWAP1
	0743    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @0742  stack[-4] = stack[-3] }
	// Block ends with unconditional jump to stack[-4]

	0744    00    *STOP
	0745    A1    LOG1
	0746    65    PUSH6 0x627a7a723058
	074D    20    SHA3
	074E    02    MUL
	074F    48    BASEFEE
	0750    3C    EXTCODECOPY
	0751    C8    C8
	0752    EE    EE
	0753    32    ORIGIN
	0754    39    CODECOPY
	0755    61    PUSH2 0xb70a
	0758    73    PUSH20 0x1235c3564df45a0ae6eb45983dc9e88e1c380635
	076D    78    PUSH25 0x0029