Online Solidity Decompiler

« Decompile another contract

Address

0xb6fb3a8181bf42a89e61420604033439d11a0953 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.

0x33ef3e6a Unknown

0x56389d8c Unknown

0xd826f88f reset()

0xdaea85c5 approve(address)

0xe3fa9cb4 Unknown

Internal Methods

func_00D5(arg0)

reset()

func_13B6(arg0, arg1) returns (r0)

func_165F(arg0) returns (r0)

func_1671(arg0) returns (r0)

func_169A(arg0) returns (r0)

func_16AD(arg0, arg1) returns (r0)

func_1740(arg0, arg1) returns (r0)

func_1759(arg0, arg1) returns (r0)

func_1866(arg0, arg1) returns (r0, r1)

func_188A(arg0, arg1) returns (r0)

func_18EE(arg0, arg1) returns (r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11)

func_1A02(arg0, arg1) returns (r0)

func_1A45(arg0, arg1) returns (r0)

func_1B4C(arg0, arg1) returns (r0)

func_1B64(arg0, arg1) returns (r0)

func_1B86(arg0, arg1) returns (r0)

func_1C04(arg0) returns (r0)

func_1C4D(arg0)

func_1C71(arg0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var var0 = msg.data[0x00:0x20] >> 0xe0;
    
        if (var0 == 0x1bea83fe) {
            // Dispatch table entry for 0x1bea83fe (unknown)
            var var1 = msg.value;
        
            if (var1) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0082;
            var var2 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
            var temp0 = memory[0x40:0x60];
            memory[temp0:temp0 + 0x20] = var2 & (0x01 << 0xa0) - 0x01;
            var temp1 = memory[0x40:0x60];
            return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
        } else if (var0 == 0x33ef3e6a) {
            // Dispatch table entry for 0x33ef3e6a (unknown)
            var1 = 0x00b2;
            var2 = 0x00ad;
            var var3 = msg.data.length;
            var var4 = 0x04;
            var2 = func_1740(var3, var4);
            var3 = 0x00;
            var4 = var3;
            var var5 = block.timestamp;
            var var6 = 0x011b;
            var var7 = var2 + 0x20;
            var var8 = var2;
            var6 = func_188A(var7, var8);
        
            if (var6 & 0xffffffffffffffff <= var5) { revert(memory[0x00:0x00]); }
        
            var5 = 0x00;
            var6 = var5;
            var7 = 0x00;
            var temp2 = memory[0x00:0x20];
            memory[0x00:0x20] = code[0x1c87:0x1ca7];
            var temp3 = memory[0x00:0x20];
            memory[0x00:0x20] = temp2;
            var8 = storage[temp3];
            var7 = var8;
        
            if (!var7) { revert(memory[0x00:0x00]); }
        
            var temp4 = memory[0x40:0x60];
            memory[temp4:temp4 + 0x20] = 0x133f7571 << 0xe3;
            memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = var7;
            var8 = 0x00;
            var var9 = var8;
            var var10 = var9;
            var var11 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
            var var12 = 0x99fbab88;
            var var13 = temp4 + 0x24;
            var var14 = 0x0180;
            var var15 = memory[0x40:0x60];
            var var16 = var13 - var15;
            var var17 = var15;
            var var18 = var11;
            var var19 = !address(var18).code.length;
        
            if (var19) { revert(memory[0x00:0x00]); }
        
            var temp5;
            temp5, memory[var15:var15 + var14] = address(var18).staticcall.gas(msg.gas)(memory[var17:var17 + var16]);
            var14 = !temp5;
        
            if (!var14) {
                var temp6 = memory[0x40:0x60];
                var temp7 = returndata.length;
                memory[0x40:0x60] = temp6 + (temp7 + 0x1f & ~0x1f);
                var11 = 0x01e1;
                var12 = temp6 + temp7;
                var13 = temp6;
                var var20;
                var var21;
                var var22;
                var11, var12, var13, var14, var15, var16, var17, var18, var19, var20, var21, var22 = func_18EE(var12, var13);
                var10 = var18;
                var9 = var14;
                var8 = var13;
                var11 = (0x01 << 0xa0) - 0x01 & 0xc36442b4a4522e871399cd717abdd847ab11fe88;
                var12 = 0x0c49ccbe;
                var temp8 = memory[0x40:0x60];
                memory[0x40:0x60] = temp8 + 0xa0;
                memory[temp8:temp8 + 0x20] = var7;
                var temp9 = temp8 + 0x20;
                memory[temp9:temp9 + 0x20] = var10 & (0x01 << 0x80) - 0x01;
                var temp10 = temp9 + 0x20;
                memory[temp10:temp10 + 0x20] = 0x00;
                var temp11 = temp10 + 0x20;
                memory[temp11:temp11 + 0x20] = 0x00;
                memory[temp11 + 0x20:temp11 + 0x20 + 0x20] = ~0x00;
                var temp12 = memory[0x40:0x60];
                memory[temp12:temp12 + 0x20] = (var12 & 0xffffffff) << 0xe0;
                var13 = 0x0263;
                var15 = temp12 + 0x04;
                var14 = temp8;
                var13 = func_1A45(var14, var15);
                var14 = 0x40;
                var15 = memory[var14:var14 + 0x20];
                var16 = var13 - var15;
                var17 = var15;
                var18 = 0x00;
                var19 = var11;
                var20 = !address(var19).code.length;
            
                if (var20) { revert(memory[0x00:0x00]); }
            
                var temp13;
                temp13, memory[var15:var15 + var14] = address(var19).call.gas(msg.gas).value(var18)(memory[var17:var17 + var16]);
                var14 = !temp13;
            
                if (!var14) {
                    var temp14 = memory[0x40:0x60];
                    var temp15 = returndata.length;
                    memory[0x40:0x60] = temp14 + (temp15 + 0x1f & ~0x1f);
                    var11 = 0x02b4;
                    var13 = temp14;
                    var12 = var13 + temp15;
                    var11, var12 = func_1866(var12, var13);
                    var11 = 0x00;
                    var12 = var11;
                    var13 = (0x01 << 0xa0) - 0x01 & 0xc36442b4a4522e871399cd717abdd847ab11fe88;
                    var14 = 0xfc6f7865;
                    var temp16 = memory[0x40:0x60];
                    var15 = temp16;
                    memory[0x40:0x60] = var15 + 0x80;
                    memory[var15:var15 + 0x20] = var7;
                    var16 = var15 + 0x20;
                    var17 = 0x0300;
                    var18 = var2 + 0x60 + 0x20;
                    var19 = var2 + 0x60;
                    var17 = func_16AD(var18, var19);
                    var temp17 = var16;
                    memory[temp17:temp17 + 0x20] = var17 & (0x01 << 0xa0) - 0x01;
                    var temp18 = (0x01 << 0x80) - 0x01;
                    memory[temp17 + 0x20:temp17 + 0x20 + 0x20] = temp18;
                    memory[temp17 + 0x40:temp17 + 0x40 + 0x20] = temp18;
                    var temp19 = memory[0x40:0x60];
                    memory[temp19:temp19 + 0x20] = (var14 << 0xe0) & ~((0x01 << 0xe0) - 0x01);
                    var temp20 = var15;
                    var15 = 0x033f;
                    var16 = temp20;
                    var17 = temp19 + 0x04;
                    var15 = func_1A02(var16, var17);
                    var16 = 0x40;
                    var17 = memory[var16:var16 + 0x20];
                    var18 = var15 - var17;
                    var19 = var17;
                    var20 = 0x00;
                    var21 = var13;
                    var22 = !address(var21).code.length;
                
                    if (var22) { revert(memory[0x00:0x00]); }
                
                    var temp21;
                    temp21, memory[var17:var17 + var16] = address(var21).call.gas(msg.gas).value(var20)(memory[var19:var19 + var18]);
                    var16 = !temp21;
                
                    if (!var16) {
                        var temp22 = memory[0x40:0x60];
                        var temp23 = returndata.length;
                        memory[0x40:0x60] = temp22 + (temp23 + 0x1f & ~0x1f);
                        var13 = 0x0390;
                        var14 = temp22 + temp23;
                        var15 = temp22;
                        var13, var14 = func_1866(var14, var15);
                        var temp24 = memory[0x40:0x60];
                        memory[temp24:temp24 + 0x20] = 0x0852cd8d << 0xe3;
                        memory[temp24 + 0x04:temp24 + 0x04 + 0x20] = var7;
                        var11 = var13;
                        var12 = var14;
                        var13 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
                        var14 = 0x42966c68;
                        var15 = temp24 + 0x24;
                        var16 = 0x00;
                        var17 = memory[0x40:0x60];
                        var18 = var15 - var17;
                        var19 = var17;
                        var20 = 0x00;
                        var21 = var13;
                        var22 = !address(var21).code.length;
                    
                        if (var22) { revert(memory[0x00:0x00]); }
                    
                        var temp25;
                        temp25, memory[var17:var17 + var16] = address(var21).call.gas(msg.gas).value(var20)(memory[var19:var19 + var18]);
                        var16 = !temp25;
                    
                        if (!var16) {
                            var13 = 0x00;
                            var14 = var13;
                            var16 = storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f4];
                            var15 = storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f3];
                            var13 = var15;
                            var14 = var16;
                            var15 = 0x045d;
                            var temp26 = var2;
                            var16 = temp26 + 0xa0;
                            var17 = temp26 + 0x80;
                            var15 = func_16AD(var16, var17);
                        
                            if (var8 & (0x01 << 0xa0) - 0x01 != var15 & (0x01 << 0xa0) - 0x01) {
                                var15 = 0x04d0;
                                var temp27 = var2;
                                var16 = temp27 + 0xc0;
                                var17 = temp27 + 0xa0;
                                var15 = func_16AD(var16, var17);
                            
                                if (var8 & (0x01 << 0xa0) - 0x01 != var15 & (0x01 << 0xa0) - 0x01) { revert(memory[0x00:0x00]); }
                            
                                var15 = 0x04fd;
                                var temp28 = var2;
                                var16 = temp28 + 0xa0;
                                var17 = temp28 + 0x80;
                                var15 = func_16AD(var16, var17);
                            
                                if (var9 & (0x01 << 0xa0) - 0x01 != var15 & (0x01 << 0xa0) - 0x01) { revert(memory[0x00:0x00]); }
                            
                                var15 = 0x0524;
                                var16 = var12;
                                var17 = var14;
                                var15 = func_13B6(var16, var17);
                                var6 = var15;
                                var15 = 0x0530;
                                var16 = var11;
                                var17 = var13;
                                var15 = func_13B6(var16, var17);
                                var5 = var15;
                            
                            label_0533:
                            
                                if (var5 i<= 0x00) {
                                    if (var6 i<= 0x00) { revert(memory[0x00:0x00]); }
                                
                                    var7 = 0x00;
                                    var8 = 0x05e0;
                                    var9 = 0x05d5;
                                    var10 = var5;
                                    var9 = func_1C04(var10);
                                    var10 = msg.data[var2 + 0x0100:var2 + 0x0100 + 0x20];
                                
                                label_13CC:
                                    var11 = 0x00;
                                    var12 = var10;
                                    var13 = 0x13da;
                                    var14 = 0x02;
                                    var15 = var12;
                                    var13 = func_1B64(var14, var15);
                                    var14 = 0x13ec;
                                    var15 = 0x0de0b6b3a7640000;
                                    var16 = var9;
                                    var14 = func_1B86(var15, var16);
                                    var temp29 = var13;
                                    var13 = 0x13f6;
                                    var temp30 = var14;
                                    var14 = temp29;
                                    var15 = temp30;
                                    var13 = func_1B4C(var14, var15);
                                    var temp31 = var12;
                                    var12 = 0x1400;
                                    var temp32 = var13;
                                    var13 = temp31;
                                    var14 = temp32;
                                    var12 = func_1B64(var13, var14);
                                
                                label_1400:
                                    var8 = var12;
                                    // Error: Could not resolve jump destination!
                                } else if (var6 i< 0x00) {
                                    var7 = 0x00;
                                    var8 = 0x0562;
                                    var9 = var5;
                                    var10 = msg.data[var2 + 0x0120:var2 + 0x0120 + 0x20];
                                    goto label_13CC;
                                } else { revert(memory[0x00:0x00]); }
                            } else {
                                var15 = 0x0486;
                                var temp33 = var2;
                                var16 = temp33 + 0xc0;
                                var17 = temp33 + 0xa0;
                                var15 = func_16AD(var16, var17);
                            
                                if (var9 & (0x01 << 0xa0) - 0x01 != var15 & (0x01 << 0xa0) - 0x01) { revert(memory[0x00:0x00]); }
                            
                                var15 = 0x04ad;
                                var16 = var11;
                                var17 = var13;
                                var15 = func_13B6(var16, var17);
                                var6 = var15;
                                var15 = 0x04b9;
                                var16 = var12;
                                var17 = var14;
                                var15 = func_13B6(var16, var17);
                                var5 = var15;
                                goto label_0533;
                            }
                        } else {
                            var temp34 = returndata.length;
                            memory[0x00:0x00 + temp34] = returndata[0x00:0x00 + temp34];
                            revert(memory[0x00:0x00 + returndata.length]);
                        }
                    } else {
                        var temp35 = returndata.length;
                        memory[0x00:0x00 + temp35] = returndata[0x00:0x00 + temp35];
                        revert(memory[0x00:0x00 + returndata.length]);
                    }
                } else {
                    var temp36 = returndata.length;
                    memory[0x00:0x00 + temp36] = returndata[0x00:0x00 + temp36];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            } else {
                var temp37 = returndata.length;
                memory[0x00:0x00 + temp37] = returndata[0x00:0x00 + temp37];
                revert(memory[0x00:0x00 + returndata.length]);
            }
        } else if (var0 == 0x56389d8c) {
            // Dispatch table entry for 0x56389d8c (unknown)
            var1 = 0x00da;
            var2 = 0x00d5;
            var3 = msg.data.length;
            var4 = 0x04;
            var2 = func_16AD(var3, var4);
            func_00D5(var2);
            stop();
        } else if (var0 == 0xd826f88f) {
            // Dispatch table entry for reset()
            var1 = 0x00da;
            reset();
            stop();
        } else if (var0 == 0xdaea85c5) {
            // Dispatch table entry for approve(address)
            var1 = 0x00da;
            var2 = 0x00f2;
            var3 = msg.data.length;
            var4 = 0x04;
            var2 = func_16AD(var3, var4);
            var3 = 0x00;
            var4 = var2 & (0x01 << 0xa0) - 0x01;
            var5 = 0x0dfe1681;
            var temp38 = memory[0x40:0x60];
            memory[temp38:temp38 + 0x20] = (var5 & 0xffffffff) << 0xe0;
            var6 = temp38 + 0x04;
            var7 = 0x20;
            var8 = memory[0x40:0x60];
            var9 = var6 - var8;
            var10 = var8;
            var11 = var4;
            var12 = !address(var11).code.length;
        
            if (var12) { revert(memory[0x00:0x00]); }
        
            var temp39;
            temp39, memory[var8:var8 + var7] = address(var11).staticcall.gas(msg.gas)(memory[var10:var10 + var9]);
            var7 = !temp39;
        
            if (!var7) {
                var temp40 = memory[0x40:0x60];
                var temp41 = returndata.length;
                memory[0x40:0x60] = temp40 + (temp41 + 0x1f & ~0x1f);
                var4 = 0x0ac1;
                var5 = temp40 + temp41;
                var6 = temp40;
            
            label_16CA:
                var7 = 0x00;
            
                if (var5 - var6 i< 0x20) { revert(memory[0x00:0x00]); }
            
                var8 = memory[var6:var6 + 0x20];
                var9 = 0x1400;
                var10 = var8;
                func_1C4D(var10);
                goto label_1400;
            } else {
                var temp42 = returndata.length;
                memory[0x00:0x00 + temp42] = returndata[0x00:0x00 + temp42];
                revert(memory[0x00:0x00 + returndata.length]);
            }
        } else if (var0 == 0xe3fa9cb4) {
            // Dispatch table entry for 0xe3fa9cb4 (unknown)
            var1 = 0x00da;
            var2 = 0x0105;
            var3 = msg.data.length;
            var4 = 0x04;
            var2 = func_1759(var3, var4);
            var3 = block.timestamp;
            var4 = 0x0b97;
            var5 = var2 + 0x20;
            var6 = var2;
            var4 = func_188A(var5, var6);
        
            if (var4 & 0xffffffffffffffff <= var3) { revert(memory[0x00:0x00]); }
        
            var temp43 = memory[0x00:0x20];
            memory[0x00:0x20] = code[0x1c87:0x1ca7];
            var temp44 = memory[0x00:0x20];
            memory[0x00:0x20] = temp43;
        
            if (storage[temp44]) { revert(memory[0x00:0x00]); }
        
            var3 = 0x00;
            var4 = 0x0bd7;
            var temp45 = var2;
            var5 = temp45 + 0x60;
            var6 = temp45 + 0x40;
            var4 = func_16AD(var5, var6);
            var temp46 = var4 & (0x01 << 0xa0) - 0x01;
            var4 = temp46;
            var5 = 0x0dfe1681;
            var temp47 = memory[0x40:0x60];
            memory[temp47:temp47 + 0x20] = (var5 & 0xffffffff) << 0xe0;
            var6 = temp47 + 0x04;
            var7 = 0x20;
            var8 = memory[0x40:0x60];
            var9 = var6 - var8;
            var10 = var8;
            var11 = var4;
            var12 = !address(var11).code.length;
        
            if (var12) { revert(memory[0x00:0x00]); }
        
            var temp48;
            temp48, memory[var8:var8 + var7] = address(var11).staticcall.gas(msg.gas)(memory[var10:var10 + var9]);
            var7 = !temp48;
        
            if (!var7) {
                var temp49 = memory[0x40:0x60];
                var temp50 = returndata.length;
                memory[0x40:0x60] = temp49 + (temp50 + 0x1f & ~0x1f);
                var4 = 0x0c47;
                var5 = temp49 + temp50;
                var6 = temp49;
                goto label_16CA;
            } else {
                var temp51 = returndata.length;
                memory[0x00:0x00 + temp51] = returndata[0x00:0x00 + temp51];
                revert(memory[0x00:0x00 + returndata.length]);
            }
        } else { revert(memory[0x00:0x00]); }
    }
    
    function func_00D5(var arg0) {
        var var0 = 0x00;
        var temp0 = memory[0x00:0x20];
        memory[0x00:0x20] = code[0x1c87:0x1ca7];
        var temp1 = memory[0x00:0x20];
        memory[0x00:0x20] = temp0;
        var var1 = storage[temp1];
        var0 = var1;
    
        if (!var0) { revert(memory[0x00:0x00]); }
    
        var temp2 = memory[0x40:0x60];
        memory[temp2:temp2 + 0x20] = 0x133f7571 << 0xe3;
        memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = var0;
        var1 = 0x00;
        var var2 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
        var var3 = 0x99fbab88;
        var var4 = temp2 + 0x24;
        var var5 = 0x0180;
        var var6 = memory[0x40:0x60];
        var var7 = var4 - var6;
        var var8 = var6;
        var var9 = var2;
        var var10 = !address(var9).code.length;
    
        if (var10) { revert(memory[0x00:0x00]); }
    
        var temp3;
        temp3, memory[var6:var6 + var5] = address(var9).staticcall.gas(msg.gas)(memory[var8:var8 + var7]);
        var5 = !temp3;
    
        if (!var5) {
            var temp4 = memory[0x40:0x60];
            var temp5 = returndata.length;
            memory[0x40:0x60] = temp4 + (temp5 + 0x1f & ~0x1f);
            var2 = 0x07e1;
            var4 = temp4;
            var3 = var4 + temp5;
            var var11;
            var var12;
            var var13;
            var2, var3, var4, var5, var6, var7, var8, var9, var10, var11, var12, var13 = func_18EE(var3, var4);
            var1 = var9;
        
            if (var1 & (0x01 << 0x80) - 0x01 <= 0x00) {
            label_08BA:
                var temp6 = memory[0x40:0x60];
                memory[0x40:0x60] = temp6 + 0x80;
                memory[temp6:temp6 + 0x20] = var0;
                memory[temp6 + 0x20:temp6 + 0x20 + 0x20] = arg0 & (0x01 << 0xa0) - 0x01;
                var temp7 = (0x01 << 0x80) - 0x01;
                memory[temp6 + 0x40:temp6 + 0x40 + 0x20] = temp7;
                memory[temp6 + 0x60:temp6 + 0x60 + 0x20] = temp7;
                var temp8 = memory[0x40:0x60];
                memory[temp8:temp8 + 0x20] = 0xfc6f7865 << 0xe0;
                var2 = 0x00;
                var3 = var2;
                var4 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
                var5 = 0xfc6f7865;
                var6 = 0x0923;
                var7 = temp6;
                var8 = temp8 + 0x04;
                var6 = func_1A02(var7, var8);
                var7 = 0x40;
                var8 = memory[var7:var7 + 0x20];
                var9 = var6 - var8;
                var10 = var8;
                var11 = 0x00;
                var12 = var4;
                var13 = !address(var12).code.length;
            
                if (var13) { revert(memory[0x00:0x00]); }
            
                var temp9;
                temp9, memory[var8:var8 + var7] = address(var12).call.gas(msg.gas).value(var11)(memory[var10:var10 + var9]);
                var7 = !temp9;
            
                if (!var7) {
                    var temp10 = memory[0x40:0x60];
                    var temp11 = returndata.length;
                    memory[0x40:0x60] = temp10 + (temp11 + 0x1f & ~0x1f);
                    var4 = 0x0974;
                    var6 = temp10;
                    var5 = var6 + temp11;
                    var4, var5 = func_1866(var5, var6);
                    var3 = var5;
                    var2 = var4;
                    var4 = var1 & (0x01 << 0x80) - 0x01 > 0x00;
                
                    if (!var4) {
                        var4 = var2 > 0x00;
                    
                        if (var4) { goto label_099B; }
                        else { goto label_0996; }
                    } else if (var4) {
                    label_099B:
                    
                        if (!var4) { revert(memory[0x00:0x00]); }
                    
                    label_09A4:
                        return;
                    } else {
                    label_0996:
                    
                        if (var3 > 0x00) { goto label_09A4; }
                        else { revert(memory[0x00:0x00]); }
                    }
                } else {
                    var temp12 = returndata.length;
                    memory[0x00:0x00 + temp12] = returndata[0x00:0x00 + temp12];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            } else {
                var temp13 = memory[0x40:0x60];
                memory[0x40:0x60] = temp13 + 0xa0;
                memory[temp13:temp13 + 0x20] = var0;
                memory[temp13 + 0x20:temp13 + 0x20 + 0x20] = var1 & (0x01 << 0x80) - 0x01;
                memory[temp13 + 0x40:temp13 + 0x40 + 0x20] = 0x00;
                memory[temp13 + 0x60:temp13 + 0x60 + 0x20] = 0x00;
                memory[temp13 + 0x80:temp13 + 0x80 + 0x20] = ~0x00;
                var temp14 = memory[0x40:0x60];
                memory[temp14:temp14 + 0x20] = 0x0624e65f << 0xe1;
                var2 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
                var3 = 0x0c49ccbe;
                var4 = 0x0866;
                var5 = temp13;
                var6 = temp14 + 0x04;
                var4 = func_1A45(var5, var6);
                var5 = 0x40;
                var6 = memory[var5:var5 + 0x20];
                var7 = var4 - var6;
                var8 = var6;
                var9 = 0x00;
                var10 = var2;
                var11 = !address(var10).code.length;
            
                if (var11) { revert(memory[0x00:0x00]); }
            
                var temp15;
                temp15, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]);
                var5 = !temp15;
            
                if (!var5) {
                    var temp16 = memory[0x40:0x60];
                    var temp17 = returndata.length;
                    memory[0x40:0x60] = temp16 + (temp17 + 0x1f & ~0x1f);
                    var2 = 0x08b7;
                    var4 = temp16;
                    var3 = var4 + temp17;
                    var2, var3 = func_1866(var3, var4);
                    goto label_08BA;
                } else {
                    var temp18 = returndata.length;
                    memory[0x00:0x00 + temp18] = returndata[0x00:0x00 + temp18];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            }
        } else {
            var temp19 = returndata.length;
            memory[0x00:0x00 + temp19] = returndata[0x00:0x00 + temp19];
            revert(memory[0x00:0x00 + returndata.length]);
        }
    }
    
    function reset() {
        var var0 = 0x00;
        var temp0 = memory[0x00:0x20];
        memory[0x00:0x20] = code[0x1c87:0x1ca7];
        var temp1 = memory[0x00:0x20];
        memory[0x00:0x20] = temp0;
        var var1 = storage[temp1];
        var0 = var1;
    
        if (!var0) { revert(memory[0x00:0x00]); }
    
        var temp2 = memory[0x40:0x60];
        memory[temp2:temp2 + 0x20] = 0x0852cd8d << 0xe3;
        memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = var0;
        var1 = 0xc36442b4a4522e871399cd717abdd847ab11fe88;
        var var2 = 0x42966c68;
        var var3 = temp2 + 0x24;
        var var4 = 0x00;
        var var5 = memory[0x40:0x60];
        var var6 = var3 - var5;
        var var7 = var5;
        var var8 = 0x00;
        var var9 = var1;
        var var10 = !address(var9).code.length;
    
        if (var10) { revert(memory[0x00:0x00]); }
    
        var temp3;
        temp3, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]);
        var4 = !temp3;
    
        if (!var4) {
            var temp4 = memory[0x00:0x20];
            memory[0x00:0x20] = code[0x1c87:0x1ca7];
            var temp5 = memory[0x00:0x20];
            memory[0x00:0x20] = temp4;
            storage[temp5] = 0x00;
            return;
        } else {
            var temp6 = returndata.length;
            memory[0x00:0x00 + temp6] = returndata[0x00:0x00 + temp6];
            revert(memory[0x00:0x00 + returndata.length]);
        }
    }
    
    function func_13B6(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        var var0 = temp0 - arg1;
    
        if (var0 i<= temp0) { return var0; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_165F(var arg0) returns (var r0) {
        var temp0 = memory[arg0:arg0 + 0x20];
        var var0 = temp0;
    
        if (var0 == signextend(0x02, var0)) { return var0; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_1671(var arg0) returns (var r0) {
        var temp0 = memory[arg0:arg0 + 0x20];
        var var0 = temp0;
    
        if (var0 == var0 & (0x01 << 0x80) - 0x01) { return var0; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_169A(var arg0) returns (var r0) {
        var temp0 = memory[arg0:arg0 + 0x20];
        var var0 = temp0;
    
        if (var0 == var0 & 0xffffff) { return var0; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_16AD(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); }
    
        var var1 = msg.data[arg1:arg1 + 0x20];
        var var2 = 0x1400;
        var var3 = var1;
        func_1C4D(var3);
        return var1;
    }
    
    function func_1740(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 - arg1 i>= 0x0180) { return arg1; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_1759(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 - arg1 i>= 0x0100) { return arg1; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_1866(var arg0, var arg1) returns (var r0, var arg0) {
        var var0 = 0x00;
        var var1 = var0;
    
        if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); }
    
        var temp0 = arg1;
        r0 = memory[temp0:temp0 + 0x20];
        arg0 = memory[temp0 + 0x20:temp0 + 0x20 + 0x20];
        return r0, arg0;
    }
    
    function func_188A(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); }
    
        var temp0 = msg.data[arg1:arg1 + 0x20];
        var var1 = temp0;
    
        if (var1 == var1 & 0xffffffffffffffff) { return var1; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_18EE(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3, var r4, var r5, var r6, var r7, var r8, var r9, var r10, var r11) {
        r3 = 0x00;
        r4 = r3;
        r5 = 0x00;
        r6 = r5;
        r7 = 0x00;
        r8 = r7;
        r9 = 0x00;
        r10 = r9;
        r11 = 0x00;
        var var9 = r11;
        var var10 = 0x00;
        var var11 = var10;
    
        if (arg0 - arg1 i< 0x0180) { revert(memory[0x00:0x00]); }
    
        var var12 = memory[arg1:arg1 + 0x20];
        var var13 = 0x191c;
        var var14 = var12;
        func_1C71(var14);
        var temp0 = var12;
        var12 = memory[arg1 + 0x20:arg1 + 0x20 + 0x20];
        r3 = temp0;
        var13 = 0x192d;
        var14 = var12;
        func_1C4D(var14);
        var temp1 = var12;
        var12 = memory[arg1 + 0x40:arg1 + 0x40 + 0x20];
        r4 = temp1;
        var13 = 0x193e;
        var14 = var12;
        func_1C4D(var14);
        var temp2 = var12;
        var12 = memory[arg1 + 0x60:arg1 + 0x60 + 0x20];
        r5 = temp2;
        var13 = 0x194f;
        var14 = var12;
        func_1C4D(var14);
        r6 = var12;
        var12 = 0x195d;
        var13 = arg1 + 0x80;
        var12 = func_169A(var13);
        r7 = var12;
        var12 = 0x196b;
        var13 = arg1 + 0xa0;
        var12 = func_165F(var13);
        r8 = var12;
        var12 = 0x1979;
        var13 = arg1 + 0xc0;
        var12 = func_165F(var13);
        r9 = var12;
        var12 = 0x1987;
        var13 = arg1 + 0xe0;
        var12 = func_1671(var13);
        r10 = var12;
        var temp3 = arg1;
        r11 = memory[temp3 + 0x0100:temp3 + 0x0100 + 0x20];
        var9 = memory[temp3 + 0x0120:temp3 + 0x0120 + 0x20];
        var12 = 0x19a6;
        var13 = temp3 + 0x0140;
        var12 = func_1671(var13);
        var10 = var12;
        var12 = 0x19b5;
        var13 = arg1 + 0x0160;
        var12 = func_1671(var13);
        var temp4 = r11;
        r11 = var12;
        var temp5 = r8;
        r8 = temp4;
        var temp6 = r5;
        r5 = temp5;
        arg1 = temp6;
        var temp7 = r10;
        r10 = var10;
        var temp8 = r7;
        r7 = temp7;
        var temp9 = r4;
        r4 = temp8;
        arg0 = temp9;
        var temp10 = r9;
        r9 = var9;
        var temp11 = r6;
        r6 = temp10;
        var temp12 = r3;
        r3 = temp11;
        r0 = temp12;
        return r0, arg0, arg1, r3, r4, r5, r6, r7, r8, r9, r10, r11;
    }
    
    function func_1A02(var arg0, var arg1) returns (var r0) {
        var temp0 = arg0;
        var temp1 = arg1;
        memory[temp1:temp1 + 0x20] = memory[temp0:temp0 + 0x20];
        memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = memory[temp0 + 0x20:temp0 + 0x20 + 0x20] & (0x01 << 0xa0) - 0x01;
        var temp2 = (0x01 << 0x80) - 0x01;
        memory[temp1 + 0x40:temp1 + 0x40 + 0x20] = temp2 & memory[temp0 + 0x40:temp0 + 0x40 + 0x20];
        memory[temp1 + 0x60:temp1 + 0x60 + 0x20] = memory[temp0 + 0x60:temp0 + 0x60 + 0x20] & temp2;
        return temp1 + 0x80;
    }
    
    function func_1A45(var arg0, var arg1) returns (var r0) {
        var temp0 = arg1;
        var temp1 = arg0;
        memory[temp0:temp0 + 0x20] = memory[temp1:temp1 + 0x20];
        memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = memory[temp1 + 0x20:temp1 + 0x20 + 0x20] & (0x01 << 0x80) - 0x01;
        memory[temp0 + 0x40:temp0 + 0x40 + 0x20] = memory[temp1 + 0x40:temp1 + 0x40 + 0x20];
        memory[temp0 + 0x60:temp0 + 0x60 + 0x20] = memory[temp1 + 0x60:temp1 + 0x60 + 0x20];
        memory[temp0 + 0x80:temp0 + 0x80 + 0x20] = memory[temp1 + 0x80:temp1 + 0x80 + 0x20];
        return temp0 + 0xa0;
    }
    
    function func_1B4C(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg1 <= ~arg0) { return arg1 + arg0; }
    
        var var1 = 0x1b5f;
        memory[0x00:0x20] = 0x4e487b71 << 0xe0;
        memory[0x04:0x24] = 0x11;
        revert(memory[0x00:0x24]);
    }
    
    function func_1B64(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0) { return arg1 / arg0; }
    
        memory[0x00:0x20] = 0x4e487b71 << 0xe0;
        memory[0x04:0x24] = 0x12;
        revert(memory[0x00:0x24]);
    }
    
    function func_1B86(var arg0, var arg1) returns (var r0) {
        var var0 = 0x00;
        var temp0 = arg1;
    
        if (!(!!temp0 & (arg0 > ~0x00 / temp0))) { return arg1 * arg0; }
    
        var var1 = 0x1ba0;
        memory[0x00:0x20] = 0x4e487b71 << 0xe0;
        memory[0x04:0x24] = 0x11;
        revert(memory[0x00:0x24]);
    }
    
    function func_1C04(var arg0) returns (var r0) {
        var var0 = 0x00;
    
        if (arg0 != 0x01 << 0xff) { return 0x00 - arg0; }
    
        var var1 = 0x1c1a;
        memory[0x00:0x20] = 0x4e487b71 << 0xe0;
        memory[0x04:0x24] = 0x11;
        revert(memory[0x00:0x24]);
    }
    
    function func_1C4D(var arg0) {
        var temp0 = arg0;
    
        if (temp0 == temp0 & (0x01 << 0xa0) - 0x01) { return; }
        else { revert(memory[0x00:0x00]); }
    }
    
    function func_1C71(var arg0) {
        var temp0 = arg0;
    
        if (temp0 == temp0 & (0x01 << 0x60) - 0x01) { return; }
        else { revert(memory[0x00:0x00]); }
    }
}

Disassembly

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

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

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

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

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

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

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

label_0055:
	// Incoming jump from 0x0054, if not 0xe3fa9cb4 == stack[-1]
	// Incoming jump from 0x000C, if msg.data.length < 0x04
	// Inputs[1] { @0059  memory[0x00:0x00] }
	0055    5B  JUMPDEST
	0056    60  PUSH1 0x00
	0058    80  DUP1
	0059    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0059  revert(memory[0x00:0x00]); }
	// Block terminates

label_005A:
	// Incoming jump from 0x001D, if 0x1bea83fe == msg.data[0x00:0x20] >> 0xe0
	// Inputs[1] { @005B  msg.value }
	005A    5B  JUMPDEST
	005B    34  CALLVALUE
	005C    80  DUP1
	005D    15  ISZERO
	005E    61  PUSH2 0x0066
	0061    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @005B  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0066, if !msg.value

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

label_0066:
	// Incoming jump from 0x0061, if !msg.value
	0066    5B  JUMPDEST
	0067    50  POP
	0068    61  PUSH2 0x0082
	006B    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0080    81  DUP2
	0081    56  *JUMP
	// Stack delta = +1
	// Outputs[2]
	// {
	//     @0068  stack[-1] = 0x0082
	//     @006B  stack[0] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	// }
	// Block ends with unconditional jump to 0x0082

label_0082:
	// Incoming jump from 0x0081
	// Inputs[4]
	// {
	//     @0085  memory[0x40:0x60]
	//     @008F  stack[-1]
	//     @0099  memory[0x40:0x60]
	//     @009E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0082    5B  JUMPDEST
	0083    60  PUSH1 0x40
	0085    51  MLOAD
	0086    60  PUSH1 0x01
	0088    60  PUSH1 0x01
	008A    60  PUSH1 0xa0
	008C    1B  SHL
	008D    03  SUB
	008E    90  SWAP1
	008F    91  SWAP2
	0090    16  AND
	0091    81  DUP2
	0092    52  MSTORE
	0093    60  PUSH1 0x20
	0095    01  ADD
	0096    5B  JUMPDEST
	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]
	// {
	//     @0092  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01
	//     @009E  return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]];
	// }
	// Block terminates

label_009F:
	// Incoming jump from 0x0028, if 0x33ef3e6a == stack[-1]
	// Inputs[1] { @00A6  msg.data.length }
	009F    5B  JUMPDEST
	00A0    61  PUSH2 0x00b2
	00A3    61  PUSH2 0x00ad
	00A6    36  CALLDATASIZE
	00A7    60  PUSH1 0x04
	00A9    61  PUSH2 0x1740
	00AC    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @00A0  stack[0] = 0x00b2
	//     @00A3  stack[1] = 0x00ad
	//     @00A6  stack[2] = msg.data.length
	//     @00A7  stack[3] = 0x04
	// }
	// Block ends with call to 0x1740, returns to 0x00AD

label_00AD:
	// Incoming return from call to 0x1740 at 0x00AC
	00AD    5B  JUMPDEST
	00AE    61  PUSH2 0x010a
	00B1    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x010a

	00B2    5B    JUMPDEST
	00B3    60    PUSH1 0x40
	00B5    80    DUP1
	00B6    51    MLOAD
	00B7    92    SWAP3
	00B8    83    DUP4
	00B9    52    MSTORE
	00BA    60    PUSH1 0x20
	00BC    83    DUP4
	00BD    01    ADD
	00BE    91    SWAP2
	00BF    90    SWAP1
	00C0    91    SWAP2
	00C1    52    MSTORE
	00C2    01    ADD
	00C3    61    PUSH2 0x0096
	00C6    56    *JUMP
label_00C7:
	// Incoming jump from 0x0033, if 0x56389d8c == stack[-1]
	// Inputs[1] { @00CE  msg.data.length }
	00C7    5B  JUMPDEST
	00C8    61  PUSH2 0x00da
	00CB    61  PUSH2 0x00d5
	00CE    36  CALLDATASIZE
	00CF    60  PUSH1 0x04
	00D1    61  PUSH2 0x16ad
	00D4    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @00C8  stack[0] = 0x00da
	//     @00CB  stack[1] = 0x00d5
	//     @00CE  stack[2] = msg.data.length
	//     @00CF  stack[3] = 0x04
	// }
	// Block ends with call to 0x16ad, returns to 0x00D5

label_00D5:
	// Incoming return from call to 0x16AD at 0x00D4
	00D5    5B  JUMPDEST
	00D6    61  PUSH2 0x0736
	00D9    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0736

label_00DA:
	// Incoming return from call to 0x00D5 at 0x00D4
	// Incoming return from call to 0x09AB at 0x00E3
	00DA    5B  JUMPDEST
	00DB    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @00DB  stop(); }
	// Block terminates

label_00DC:
	// Incoming jump from 0x003E, if 0xd826f88f == stack[-1]
	00DC    5B  JUMPDEST
	00DD    61  PUSH2 0x00da
	00E0    61  PUSH2 0x09ab
	00E3    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @00DD  stack[0] = 0x00da }
	// Block ends with call to 0x09ab, returns to 0x00DA

label_00E4:
	// Incoming jump from 0x0049, if 0xdaea85c5 == stack[-1]
	// Inputs[1] { @00EB  msg.data.length }
	00E4    5B  JUMPDEST
	00E5    61  PUSH2 0x00da
	00E8    61  PUSH2 0x00f2
	00EB    36  CALLDATASIZE
	00EC    60  PUSH1 0x04
	00EE    61  PUSH2 0x16ad
	00F1    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @00E5  stack[0] = 0x00da
	//     @00E8  stack[1] = 0x00f2
	//     @00EB  stack[2] = msg.data.length
	//     @00EC  stack[3] = 0x04
	// }
	// Block ends with call to 0x16ad, returns to 0x00F2

label_00F2:
	// Incoming return from call to 0x16AD at 0x00F1
	00F2    5B  JUMPDEST
	00F3    61  PUSH2 0x0a4e
	00F6    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0a4e

label_00F7:
	// Incoming jump from 0x0054, if 0xe3fa9cb4 == stack[-1]
	// Inputs[1] { @00FE  msg.data.length }
	00F7    5B  JUMPDEST
	00F8    61  PUSH2 0x00da
	00FB    61  PUSH2 0x0105
	00FE    36  CALLDATASIZE
	00FF    60  PUSH1 0x04
	0101    61  PUSH2 0x1759
	0104    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @00F8  stack[0] = 0x00da
	//     @00FB  stack[1] = 0x0105
	//     @00FE  stack[2] = msg.data.length
	//     @00FF  stack[3] = 0x04
	// }
	// Block ends with call to 0x1759, returns to 0x0105

label_0105:
	// Incoming return from call to 0x1759 at 0x0104
	0105    5B  JUMPDEST
	0106    61  PUSH2 0x0b89
	0109    56  *JUMP
	// Stack delta = +0
	// Block ends with unconditional jump to 0x0b89

label_010A:
	// Incoming jump from 0x00B1
	// Inputs[2]
	// {
	//     @010E  block.timestamp
	//     @0114  stack[-1]
	// }
	010A    5B  JUMPDEST
	010B    60  PUSH1 0x00
	010D    80  DUP1
	010E    42  TIMESTAMP
	010F    61  PUSH2 0x011b
	0112    60  PUSH1 0x20
	0114    85  DUP6
	0115    01  ADD
	0116    85  DUP6
	0117    61  PUSH2 0x188a
	011A    56  *JUMP
	// Stack delta = +6
	// Outputs[6]
	// {
	//     @010B  stack[0] = 0x00
	//     @010D  stack[1] = 0x00
	//     @010E  stack[2] = block.timestamp
	//     @010F  stack[3] = 0x011b
	//     @0115  stack[4] = stack[-1] + 0x20
	//     @0116  stack[5] = stack[-1]
	// }
	// Block ends with call to 0x188a, returns to 0x011B

label_011B:
	// Incoming return from call to 0x188A at 0x011A
	// Inputs[2]
	// {
	//     @0125  stack[-1]
	//     @0126  stack[-2]
	// }
	011B    5B  JUMPDEST
	011C    67  PUSH8 0xffffffffffffffff
	0125    16  AND
	0126    11  GT
	0127    61  PUSH2 0x012f
	012A    57  *JUMPI
	// Stack delta = -2
	// Block ends with conditional jump to 0x012f, if 0xffffffffffffffff & stack[-1] > stack[-2]

label_012B:
	// Incoming jump from 0x012A, if not 0xffffffffffffffff & stack[-1] > stack[-2]
	// Inputs[1] { @012E  memory[0x00:0x00] }
	012B    60  PUSH1 0x00
	012D    80  DUP1
	012E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @012E  revert(memory[0x00:0x00]); }
	// Block terminates

label_012F:
	// Incoming jump from 0x012A, if 0xffffffffffffffff & stack[-1] > stack[-2]
	// Inputs[3]
	// {
	//     @013B  memory[0x00:0x20]
	//     @0144  memory[0x00:0x20]
	//     @0147  storage[memory[0x00:0x20]]
	// }
	012F    5B  JUMPDEST
	0130    60  PUSH1 0x00
	0132    80  DUP1
	0133    60  PUSH1 0x00
	0135    61  PUSH2 0x014a
	0138    60  PUSH1 0x00
	013A    80  DUP1
	013B    51  MLOAD
	013C    60  PUSH1 0x20
	013E    61  PUSH2 0x1c87
	0141    83  DUP4
	0142    39  CODECOPY
	0143    81  DUP2
	0144    51  MLOAD
	0145    91  SWAP2
	0146    52  MSTORE
	0147    54  SLOAD
	0148    90  SWAP1
	0149    56  *JUMP
	// Stack delta = +4
	// Outputs[6]
	// {
	//     @0130  stack[0] = 0x00
	//     @0132  stack[1] = 0x00
	//     @0133  stack[2] = 0x00
	//     @0142  memory[0x00:0x20] = code[0x1c87:0x1ca7]
	//     @0146  memory[0x00:0x20] = memory[0x00:0x20]
	//     @0148  stack[3] = storage[memory[0x00:0x20]]
	// }
	// Block ends with unconditional jump to 0x014a

label_014A:
	// Incoming jump from 0x0149
	// Inputs[2]
	// {
	//     @014B  stack[-1]
	//     @014B  stack[-2]
	// }
	014A    5B  JUMPDEST
	014B    90  SWAP1
	014C    50  POP
	014D    80  DUP1
	014E    61  PUSH2 0x0156
	0151    57  *JUMPI
	// Stack delta = -1
	// Outputs[1] { @014B  stack[-2] = stack[-1] }
	// Block ends with conditional jump to 0x0156, if stack[-1]

label_0152:
	// Incoming jump from 0x0151, if not stack[-1]
	// Inputs[1] { @0155  memory[0x00:0x00] }
	0152    60  PUSH1 0x00
	0154    80  DUP1
	0155    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0155  revert(memory[0x00:0x00]); }
	// Block terminates

label_0156:
	// Incoming jump from 0x0151, if stack[-1]
	// Inputs[4]
	// {
	//     @0159  memory[0x40:0x60]
	//     @0168  stack[-1]
	//     @0196  memory[0x40:0x60]
	//     @019D  address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	0156    5B  JUMPDEST
	0157    60  PUSH1 0x40
	0159    51  MLOAD
	015A    63  PUSH4 0x133f7571
	015F    60  PUSH1 0xe3
	0161    1B  SHL
	0162    81  DUP2
	0163    52  MSTORE
	0164    60  PUSH1 0x04
	0166    81  DUP2
	0167    01  ADD
	0168    82  DUP3
	0169    90  SWAP1
	016A    52  MSTORE
	016B    60  PUSH1 0x00
	016D    90  SWAP1
	016E    81  DUP2
	016F    90  SWAP1
	0170    81  DUP2
	0171    90  SWAP1
	0172    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0187    90  SWAP1
	0188    63  PUSH4 0x99fbab88
	018D    90  SWAP1
	018E    60  PUSH1 0x24
	0190    01  ADD
	0191    61  PUSH2 0x0180
	0194    60  PUSH1 0x40
	0196    51  MLOAD
	0197    80  DUP1
	0198    83  DUP4
	0199    03  SUB
	019A    81  DUP2
	019B    86  DUP7
	019C    80  DUP1
	019D    3B  EXTCODESIZE
	019E    15  ISZERO
	019F    80  DUP1
	01A0    15  ISZERO
	01A1    61  PUSH2 0x01a9
	01A4    57  *JUMPI
	// Stack delta = +12
	// Outputs[14]
	// {
	//     @0163  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x133f7571 << 0xe3
	//     @016A  memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1]
	//     @016D  stack[0] = 0x00
	//     @016F  stack[1] = 0x00
	//     @0171  stack[2] = 0x00
	//     @0187  stack[3] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @018D  stack[4] = 0x99fbab88
	//     @0190  stack[5] = 0x24 + memory[0x40:0x60]
	//     @0191  stack[6] = 0x0180
	//     @0196  stack[7] = memory[0x40:0x60]
	//     @0199  stack[8] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @019A  stack[9] = memory[0x40:0x60]
	//     @019B  stack[10] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @019E  stack[11] = !address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	// Block ends with conditional jump to 0x01a9, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length

label_01A5:
	// Incoming jump from 0x01A4, if not !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[1] { @01A8  memory[0x00:0x00] }
	01A5    60  PUSH1 0x00
	01A7    80  DUP1
	01A8    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @01A8  revert(memory[0x00:0x00]); }
	// Block terminates

label_01A9:
	// Incoming jump from 0x01A4, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[8]
	// {
	//     @01AB  msg.gas
	//     @01AC  stack[-5]
	//     @01AC  stack[-6]
	//     @01AC  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @01AC  stack[-3]
	//     @01AC  stack[-4]
	//     @01AC  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @01AC  stack[-2]
	// }
	01A9    5B  JUMPDEST
	01AA    50  POP
	01AB    5A  GAS
	01AC    FA  STATICCALL
	01AD    15  ISZERO
	01AE    80  DUP1
	01AF    15  ISZERO
	01B0    61  PUSH2 0x01bd
	01B3    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @01AC  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @01AD  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x01bd, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_01B4:
	// Incoming jump from 0x01B3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @01B4  returndata.length
	//     @01B8  returndata[0x00:0x00 + returndata.length]
	//     @01B9  returndata.length
	//     @01BC  memory[0x00:0x00 + returndata.length]
	// }
	01B4    3D  RETURNDATASIZE
	01B5    60  PUSH1 0x00
	01B7    80  DUP1
	01B8    3E  RETURNDATACOPY
	01B9    3D  RETURNDATASIZE
	01BA    60  PUSH1 0x00
	01BC    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @01B8  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @01BC  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_01BD:
	// Incoming jump from 0x01B3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @01C4  memory[0x40:0x60]
	//     @01C5  returndata.length
	// }
	01BD    5B  JUMPDEST
	01BE    50  POP
	01BF    50  POP
	01C0    50  POP
	01C1    50  POP
	01C2    60  PUSH1 0x40
	01C4    51  MLOAD
	01C5    3D  RETURNDATASIZE
	01C6    60  PUSH1 0x1f
	01C8    19  NOT
	01C9    60  PUSH1 0x1f
	01CB    82  DUP3
	01CC    01  ADD
	01CD    16  AND
	01CE    82  DUP3
	01CF    01  ADD
	01D0    80  DUP1
	01D1    60  PUSH1 0x40
	01D3    52  MSTORE
	01D4    50  POP
	01D5    81  DUP2
	01D6    01  ADD
	01D7    90  SWAP1
	01D8    61  PUSH2 0x01e1
	01DB    91  SWAP2
	01DC    90  SWAP1
	01DD    61  PUSH2 0x18ee
	01E0    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @01D3  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @01DB  stack[-4] = 0x01e1
	//     @01DC  stack[-2] = memory[0x40:0x60]
	//     @01DC  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x18ee, returns to 0x01E1

label_01E1:
	// Incoming return from call to 0x18EE at 0x01E0
	// Inputs[9]
	// {
	//     @01E6  stack[-5]
	//     @01E6  stack[-13]
	//     @01EB  stack[-14]
	//     @01EB  stack[-9]
	//     @01ED  stack[-15]
	//     @01ED  stack[-10]
	//     @0216  memory[0x40:0x60]
	//     @021F  stack[-16]
	//     @024A  memory[0x40:0x60]
	// }
	01E1    5B  JUMPDEST
	01E2    50  POP
	01E3    50  POP
	01E4    50  POP
	01E5    50  POP
	01E6    97  SWAP8
	01E7    50  POP
	01E8    50  POP
	01E9    50  POP
	01EA    50  POP
	01EB    94  SWAP5
	01EC    50  POP
	01ED    94  SWAP5
	01EE    50  POP
	01EF    50  POP
	01F0    50  POP
	01F1    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0206    60  PUSH1 0x01
	0208    60  PUSH1 0x01
	020A    60  PUSH1 0xa0
	020C    1B  SHL
	020D    03  SUB
	020E    16  AND
	020F    63  PUSH4 0x0c49ccbe
	0214    60  PUSH1 0x40
	0216    51  MLOAD
	0217    80  DUP1
	0218    60  PUSH1 0xa0
	021A    01  ADD
	021B    60  PUSH1 0x40
	021D    52  MSTORE
	021E    80  DUP1
	021F    87  DUP8
	0220    81  DUP2
	0221    52  MSTORE
	0222    60  PUSH1 0x20
	0224    01  ADD
	0225    84  DUP5
	0226    60  PUSH1 0x01
	0228    60  PUSH1 0x01
	022A    60  PUSH1 0x80
	022C    1B  SHL
	022D    03  SUB
	022E    16  AND
	022F    81  DUP2
	0230    52  MSTORE
	0231    60  PUSH1 0x20
	0233    01  ADD
	0234    60  PUSH1 0x00
	0236    81  DUP2
	0237    52  MSTORE
	0238    60  PUSH1 0x20
	023A    01  ADD
	023B    60  PUSH1 0x00
	023D    81  DUP2
	023E    52  MSTORE
	023F    60  PUSH1 0x20
	0241    01  ADD
	0242    60  PUSH1 0x00
	0244    19  NOT
	0245    81  DUP2
	0246    52  MSTORE
	0247    50  POP
	0248    60  PUSH1 0x40
	024A    51  MLOAD
	024B    82  DUP3
	024C    63  PUSH4 0xffffffff
	0251    16  AND
	0252    60  PUSH1 0xe0
	0254    1B  SHL
	0255    81  DUP2
	0256    52  MSTORE
	0257    60  PUSH1 0x04
	0259    01  ADD
	025A    61  PUSH2 0x0263
	025D    91  SWAP2
	025E    90  SWAP1
	025F    61  PUSH2 0x1a45
	0262    56  *JUMP
	// Stack delta = -7
	// Outputs[15]
	// {
	//     @01E6  stack[-13] = stack[-5]
	//     @01EB  stack[-14] = stack[-9]
	//     @01ED  stack[-15] = stack[-10]
	//     @020E  stack[-12] = (0x01 << 0xa0) - 0x01 & 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @020F  stack[-11] = 0x0c49ccbe
	//     @021D  memory[0x40:0x60] = 0xa0 + memory[0x40:0x60]
	//     @0221  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-16]
	//     @0230  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x01 << 0x80) - 0x01 & stack[-5]
	//     @0237  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00
	//     @023E  memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00
	//     @0246  memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00
	//     @0256  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0c49ccbe) << 0xe0
	//     @025D  stack[-10] = 0x0263
	//     @025E  stack[-9] = memory[0x40:0x60]
	//     @025E  stack[-8] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x1a45, returns to 0x0263

label_0263:
	// Incoming return from call to 0x1A45 at 0x0262
	// Inputs[4]
	// {
	//     @0267  memory[0x40:0x60]
	//     @0269  stack[-1]
	//     @026E  stack[-3]
	//     @0270  address(stack[-3]).code.length
	// }
	0263    5B  JUMPDEST
	0264    60  PUSH1 0x40
	0266    80  DUP1
	0267    51  MLOAD
	0268    80  DUP1
	0269    83  DUP4
	026A    03  SUB
	026B    81  DUP2
	026C    60  PUSH1 0x00
	026E    87  DUP8
	026F    80  DUP1
	0270    3B  EXTCODESIZE
	0271    15  ISZERO
	0272    80  DUP1
	0273    15  ISZERO
	0274    61  PUSH2 0x027c
	0277    57  *JUMPI
	// Stack delta = +7
	// Outputs[7]
	// {
	//     @0264  stack[0] = 0x40
	//     @0267  stack[1] = memory[0x40:0x60]
	//     @026A  stack[2] = stack[-1] - memory[0x40:0x60]
	//     @026B  stack[3] = memory[0x40:0x60]
	//     @026C  stack[4] = 0x00
	//     @026E  stack[5] = stack[-3]
	//     @0271  stack[6] = !address(stack[-3]).code.length
	// }
	// Block ends with conditional jump to 0x027c, if !!address(stack[-3]).code.length

label_0278:
	// Incoming jump from 0x0277, if not !!address(stack[-3]).code.length
	// Inputs[1] { @027B  memory[0x00:0x00] }
	0278    60  PUSH1 0x00
	027A    80  DUP1
	027B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @027B  revert(memory[0x00:0x00]); }
	// Block terminates

label_027C:
	// Incoming jump from 0x0277, if !!address(stack[-3]).code.length
	// Inputs[9]
	// {
	//     @027E  msg.gas
	//     @027F  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @027F  stack[-3]
	//     @027F  stack[-6]
	//     @027F  stack[-5]
	//     @027F  stack[-4]
	//     @027F  stack[-2]
	//     @027F  stack[-7]
	//     @027F  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	027C    5B  JUMPDEST
	027D    50  POP
	027E    5A  GAS
	027F    F1  CALL
	0280    15  ISZERO
	0281    80  DUP1
	0282    15  ISZERO
	0283    61  PUSH2 0x0290
	0286    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @027F  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0280  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x0290, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_0287:
	// Incoming jump from 0x0286, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @0287  returndata.length
	//     @028B  returndata[0x00:0x00 + returndata.length]
	//     @028C  returndata.length
	//     @028F  memory[0x00:0x00 + returndata.length]
	// }
	0287    3D  RETURNDATASIZE
	0288    60  PUSH1 0x00
	028A    80  DUP1
	028B    3E  RETURNDATACOPY
	028C    3D  RETURNDATASIZE
	028D    60  PUSH1 0x00
	028F    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @028B  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @028F  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0290:
	// Incoming jump from 0x0286, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0297  memory[0x40:0x60]
	//     @0298  returndata.length
	// }
	0290    5B  JUMPDEST
	0291    50  POP
	0292    50  POP
	0293    50  POP
	0294    50  POP
	0295    60  PUSH1 0x40
	0297    51  MLOAD
	0298    3D  RETURNDATASIZE
	0299    60  PUSH1 0x1f
	029B    19  NOT
	029C    60  PUSH1 0x1f
	029E    82  DUP3
	029F    01  ADD
	02A0    16  AND
	02A1    82  DUP3
	02A2    01  ADD
	02A3    80  DUP1
	02A4    60  PUSH1 0x40
	02A6    52  MSTORE
	02A7    50  POP
	02A8    81  DUP2
	02A9    01  ADD
	02AA    90  SWAP1
	02AB    61  PUSH2 0x02b4
	02AE    91  SWAP2
	02AF    90  SWAP1
	02B0    61  PUSH2 0x1866
	02B3    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @02A6  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @02AE  stack[-4] = 0x02b4
	//     @02AF  stack[-2] = memory[0x40:0x60]
	//     @02AF  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x1866, returns to 0x02B4

label_02B4:
	// Incoming return from call to 0x1866 at 0x02B3
	// Inputs[3]
	// {
	//     @02DF  memory[0x40:0x60]
	//     @02E8  stack[-6]
	//     @02EE  stack[-11]
	// }
	02B4    5B  JUMPDEST
	02B5    50  POP
	02B6    50  POP
	02B7    60  PUSH1 0x00
	02B9    80  DUP1
	02BA    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	02CF    60  PUSH1 0x01
	02D1    60  PUSH1 0x01
	02D3    60  PUSH1 0xa0
	02D5    1B  SHL
	02D6    03  SUB
	02D7    16  AND
	02D8    63  PUSH4 0xfc6f7865
	02DD    60  PUSH1 0x40
	02DF    51  MLOAD
	02E0    80  DUP1
	02E1    60  PUSH1 0x80
	02E3    01  ADD
	02E4    60  PUSH1 0x40
	02E6    52  MSTORE
	02E7    80  DUP1
	02E8    89  DUP10
	02E9    81  DUP2
	02EA    52  MSTORE
	02EB    60  PUSH1 0x20
	02ED    01  ADD
	02EE    8E  DUP15
	02EF    60  PUSH1 0x60
	02F1    01  ADD
	02F2    60  PUSH1 0x20
	02F4    81  DUP2
	02F5    01  ADD
	02F6    90  SWAP1
	02F7    61  PUSH2 0x0300
	02FA    91  SWAP2
	02FB    90  SWAP1
	02FC    61  PUSH2 0x16ad
	02FF    56  *JUMP
	// Stack delta = +7
	// Outputs[11]
	// {
	//     @02B7  stack[-2] = 0x00
	//     @02B9  stack[-1] = 0x00
	//     @02D7  stack[0] = (0x01 << 0xa0) - 0x01 & 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @02D8  stack[1] = 0xfc6f7865
	//     @02DF  stack[2] = memory[0x40:0x60]
	//     @02E6  memory[0x40:0x60] = 0x80 + memory[0x40:0x60]
	//     @02EA  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6]
	//     @02ED  stack[3] = 0x20 + memory[0x40:0x60]
	//     @02FA  stack[4] = 0x0300
	//     @02FB  stack[5] = 0x60 + stack[-11] + 0x20
	//     @02FB  stack[6] = 0x60 + stack[-11]
	// }
	// Block ends with call to 0x16ad, returns to 0x0300

label_0300:
	// Incoming return from call to 0x16AD at 0x02FF
	// Inputs[5]
	// {
	//     @0309  stack[-1]
	//     @030A  stack[-2]
	//     @0321  memory[0x40:0x60]
	//     @032D  stack[-4]
	//     @0336  stack[-3]
	// }
	0300    5B  JUMPDEST
	0301    60  PUSH1 0x01
	0303    60  PUSH1 0x01
	0305    60  PUSH1 0xa0
	0307    1B  SHL
	0308    03  SUB
	0309    16  AND
	030A    81  DUP2
	030B    52  MSTORE
	030C    60  PUSH1 0x01
	030E    60  PUSH1 0x01
	0310    60  PUSH1 0x80
	0312    1B  SHL
	0313    03  SUB
	0314    60  PUSH1 0x20
	0316    82  DUP3
	0317    01  ADD
	0318    81  DUP2
	0319    90  SWAP1
	031A    52  MSTORE
	031B    60  PUSH1 0x40
	031D    91  SWAP2
	031E    82  DUP3
	031F    01  ADD
	0320    52  MSTORE
	0321    51  MLOAD
	0322    60  PUSH1 0x01
	0324    60  PUSH1 0x01
	0326    60  PUSH1 0xe0
	0328    1B  SHL
	0329    03  SUB
	032A    19  NOT
	032B    60  PUSH1 0xe0
	032D    84  DUP5
	032E    90  SWAP1
	032F    1B  SHL
	0330    16  AND
	0331    81  DUP2
	0332    52  MSTORE
	0333    61  PUSH2 0x033f
	0336    91  SWAP2
	0337    90  SWAP1
	0338    60  PUSH1 0x04
	033A    01  ADD
	033B    61  PUSH2 0x1a02
	033E    56  *JUMP
	// Stack delta = +0
	// Outputs[7]
	// {
	//     @030B  memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @031A  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = (0x01 << 0x80) - 0x01
	//     @0320  memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] = (0x01 << 0x80) - 0x01
	//     @0332  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] << 0xe0) & ~((0x01 << 0xe0) - 0x01)
	//     @0336  stack[-3] = 0x033f
	//     @0337  stack[-2] = stack[-3]
	//     @033A  stack[-1] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x1a02, returns to 0x033F

label_033F:
	// Incoming return from call to 0x1A02 at 0x033E
	// Inputs[4]
	// {
	//     @0343  memory[0x40:0x60]
	//     @0345  stack[-1]
	//     @034A  stack[-3]
	//     @034C  address(stack[-3]).code.length
	// }
	033F    5B  JUMPDEST
	0340    60  PUSH1 0x40
	0342    80  DUP1
	0343    51  MLOAD
	0344    80  DUP1
	0345    83  DUP4
	0346    03  SUB
	0347    81  DUP2
	0348    60  PUSH1 0x00
	034A    87  DUP8
	034B    80  DUP1
	034C    3B  EXTCODESIZE
	034D    15  ISZERO
	034E    80  DUP1
	034F    15  ISZERO
	0350    61  PUSH2 0x0358
	0353    57  *JUMPI
	// Stack delta = +7
	// Outputs[7]
	// {
	//     @0340  stack[0] = 0x40
	//     @0343  stack[1] = memory[0x40:0x60]
	//     @0346  stack[2] = stack[-1] - memory[0x40:0x60]
	//     @0347  stack[3] = memory[0x40:0x60]
	//     @0348  stack[4] = 0x00
	//     @034A  stack[5] = stack[-3]
	//     @034D  stack[6] = !address(stack[-3]).code.length
	// }
	// Block ends with conditional jump to 0x0358, if !!address(stack[-3]).code.length

label_0354:
	// Incoming jump from 0x0353, if not !!address(stack[-3]).code.length
	// Inputs[1] { @0357  memory[0x00:0x00] }
	0354    60  PUSH1 0x00
	0356    80  DUP1
	0357    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0357  revert(memory[0x00:0x00]); }
	// Block terminates

label_0358:
	// Incoming jump from 0x0353, if !!address(stack[-3]).code.length
	// Inputs[9]
	// {
	//     @035A  msg.gas
	//     @035B  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @035B  stack[-6]
	//     @035B  stack[-5]
	//     @035B  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @035B  stack[-4]
	//     @035B  stack[-3]
	//     @035B  stack[-7]
	//     @035B  stack[-2]
	// }
	0358    5B  JUMPDEST
	0359    50  POP
	035A    5A  GAS
	035B    F1  CALL
	035C    15  ISZERO
	035D    80  DUP1
	035E    15  ISZERO
	035F    61  PUSH2 0x036c
	0362    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @035B  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @035C  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x036c, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_0363:
	// Incoming jump from 0x0362, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @0363  returndata.length
	//     @0367  returndata[0x00:0x00 + returndata.length]
	//     @0368  returndata.length
	//     @036B  memory[0x00:0x00 + returndata.length]
	// }
	0363    3D  RETURNDATASIZE
	0364    60  PUSH1 0x00
	0366    80  DUP1
	0367    3E  RETURNDATACOPY
	0368    3D  RETURNDATASIZE
	0369    60  PUSH1 0x00
	036B    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0367  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @036B  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_036C:
	// Incoming jump from 0x0362, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0373  memory[0x40:0x60]
	//     @0374  returndata.length
	// }
	036C    5B  JUMPDEST
	036D    50  POP
	036E    50  POP
	036F    50  POP
	0370    50  POP
	0371    60  PUSH1 0x40
	0373    51  MLOAD
	0374    3D  RETURNDATASIZE
	0375    60  PUSH1 0x1f
	0377    19  NOT
	0378    60  PUSH1 0x1f
	037A    82  DUP3
	037B    01  ADD
	037C    16  AND
	037D    82  DUP3
	037E    01  ADD
	037F    80  DUP1
	0380    60  PUSH1 0x40
	0382    52  MSTORE
	0383    50  POP
	0384    81  DUP2
	0385    01  ADD
	0386    90  SWAP1
	0387    61  PUSH2 0x0390
	038A    91  SWAP2
	038B    90  SWAP1
	038C    61  PUSH2 0x1866
	038F    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @0382  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @038A  stack[-4] = 0x0390
	//     @038B  stack[-2] = memory[0x40:0x60]
	//     @038B  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x1866, returns to 0x0390

label_0390:
	// Incoming return from call to 0x1866 at 0x038F
	// Inputs[8]
	// {
	//     @0393  memory[0x40:0x60]
	//     @03A2  stack[-8]
	//     @03A5  stack[-2]
	//     @03A6  stack[-4]
	//     @03A8  stack[-1]
	//     @03A8  stack[-3]
	//     @03CD  memory[0x40:0x60]
	//     @03D6  address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	0390    5B  JUMPDEST
	0391    60  PUSH1 0x40
	0393    51  MLOAD
	0394    63  PUSH4 0x0852cd8d
	0399    60  PUSH1 0xe3
	039B    1B  SHL
	039C    81  DUP2
	039D    52  MSTORE
	039E    60  PUSH1 0x04
	03A0    81  DUP2
	03A1    01  ADD
	03A2    89  DUP10
	03A3    90  SWAP1
	03A4    52  MSTORE
	03A5    91  SWAP2
	03A6    93  SWAP4
	03A7    50  POP
	03A8    91  SWAP2
	03A9    50  POP
	03AA    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	03BF    90  SWAP1
	03C0    63  PUSH4 0x42966c68
	03C5    90  SWAP1
	03C6    60  PUSH1 0x24
	03C8    01  ADD
	03C9    60  PUSH1 0x00
	03CB    60  PUSH1 0x40
	03CD    51  MLOAD
	03CE    80  DUP1
	03CF    83  DUP4
	03D0    03  SUB
	03D1    81  DUP2
	03D2    60  PUSH1 0x00
	03D4    87  DUP8
	03D5    80  DUP1
	03D6    3B  EXTCODESIZE
	03D7    15  ISZERO
	03D8    80  DUP1
	03D9    15  ISZERO
	03DA    61  PUSH2 0x03e2
	03DD    57  *JUMPI
	// Stack delta = +8
	// Outputs[14]
	// {
	//     @039D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0852cd8d << 0xe3
	//     @03A4  memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-8]
	//     @03A6  stack[-4] = stack[-2]
	//     @03A8  stack[-3] = stack[-1]
	//     @03BF  stack[-2] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @03C5  stack[-1] = 0x42966c68
	//     @03C8  stack[0] = 0x24 + memory[0x40:0x60]
	//     @03C9  stack[1] = 0x00
	//     @03CD  stack[2] = memory[0x40:0x60]
	//     @03D0  stack[3] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @03D1  stack[4] = memory[0x40:0x60]
	//     @03D2  stack[5] = 0x00
	//     @03D4  stack[6] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @03D7  stack[7] = !address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	// Block ends with conditional jump to 0x03e2, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length

label_03DE:
	// Incoming jump from 0x03DD, if not !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[1] { @03E1  memory[0x00:0x00] }
	03DE    60  PUSH1 0x00
	03E0    80  DUP1
	03E1    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @03E1  revert(memory[0x00:0x00]); }
	// Block terminates

label_03E2:
	// Incoming jump from 0x03DD, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[9]
	// {
	//     @03E4  msg.gas
	//     @03E5  stack[-4]
	//     @03E5  stack[-2]
	//     @03E5  stack[-3]
	//     @03E5  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @03E5  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @03E5  stack[-6]
	//     @03E5  stack[-7]
	//     @03E5  stack[-5]
	// }
	03E2    5B  JUMPDEST
	03E3    50  POP
	03E4    5A  GAS
	03E5    F1  CALL
	03E6    15  ISZERO
	03E7    80  DUP1
	03E8    15  ISZERO
	03E9    61  PUSH2 0x03f6
	03EC    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @03E5  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @03E6  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x03f6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_03ED:
	// Incoming jump from 0x03EC, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @03ED  returndata.length
	//     @03F1  returndata[0x00:0x00 + returndata.length]
	//     @03F2  returndata.length
	//     @03F5  memory[0x00:0x00 + returndata.length]
	// }
	03ED    3D  RETURNDATASIZE
	03EE    60  PUSH1 0x00
	03F0    80  DUP1
	03F1    3E  RETURNDATACOPY
	03F2    3D  RETURNDATASIZE
	03F3    60  PUSH1 0x00
	03F5    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @03F1  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @03F5  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_03F6:
	// Incoming jump from 0x03EC, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0422  storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f3]
	//     @0444  storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f4]
	// }
	03F6    5B  JUMPDEST
	03F7    50  POP
	03F8    50  POP
	03F9    50  POP
	03FA    50  POP
	03FB    60  PUSH1 0x00
	03FD    80  DUP1
	03FE    61  PUSH2 0x0448
	0401    7F  PUSH32 0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f3
	0422    54  SLOAD
	0423    7F  PUSH32 0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f4
	0444    54  SLOAD
	0445    90  SWAP1
	0446    91  SWAP2
	0447    56  *JUMP
	// Stack delta = +0
	// Outputs[4]
	// {
	//     @03FB  stack[-4] = 0x00
	//     @03FD  stack[-3] = 0x00
	//     @0445  stack[-1] = storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f4]
	//     @0446  stack[-2] = storage[0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f3]
	// }
	// Block ends with unconditional jump to 0x0448

label_0448:
	// Incoming jump from 0x0447
	// Inputs[5]
	// {
	//     @0449  stack[-1]
	//     @0449  stack[-2]
	//     @044A  stack[-4]
	//     @044C  stack[-3]
	//     @0453  stack[-15]
	// }
	0448    5B  JUMPDEST
	0449    90  SWAP1
	044A    92  SWAP3
	044B    50  POP
	044C    90  SWAP1
	044D    50  POP
	044E    61  PUSH2 0x045d
	0451    60  PUSH1 0xa0
	0453    8E  DUP15
	0454    01  ADD
	0455    60  PUSH1 0x80
	0457    8F  DUP16
	0458    01  ADD
	0459    61  PUSH2 0x16ad
	045C    56  *JUMP
	// Stack delta = +1
	// Outputs[5]
	// {
	//     @044A  stack[-4] = stack[-2]
	//     @044C  stack[-3] = stack[-1]
	//     @044E  stack[-2] = 0x045d
	//     @0454  stack[-1] = stack[-15] + 0xa0
	//     @0458  stack[0] = stack[-15] + 0x80
	// }
	// Block ends with call to 0x16ad, returns to 0x045D

label_045D:
	// Incoming return from call to 0x16AD at 0x045C
	// Inputs[2]
	// {
	//     @0466  stack[-1]
	//     @0467  stack[-8]
	// }
	045D    5B  JUMPDEST
	045E    60  PUSH1 0x01
	0460    60  PUSH1 0x01
	0462    60  PUSH1 0xa0
	0464    1B  SHL
	0465    03  SUB
	0466    16  AND
	0467    87  DUP8
	0468    60  PUSH1 0x01
	046A    60  PUSH1 0x01
	046C    60  PUSH1 0xa0
	046E    1B  SHL
	046F    03  SUB
	0470    16  AND
	0471    14  EQ
	0472    15  ISZERO
	0473    61  PUSH2 0x04c0
	0476    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x04c0, if !((0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1])

label_0477:
	// Incoming jump from 0x0476, if not !((0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1])
	// Inputs[1] { @047C  stack[-13] }
	0477    61  PUSH2 0x0486
	047A    60  PUSH1 0xc0
	047C    8E  DUP15
	047D    01  ADD
	047E    60  PUSH1 0xa0
	0480    8F  DUP16
	0481    01  ADD
	0482    61  PUSH2 0x16ad
	0485    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @0477  stack[0] = 0x0486
	//     @047D  stack[1] = stack[-13] + 0xc0
	//     @0481  stack[2] = stack[-13] + 0xa0
	// }
	// Block ends with call to 0x16ad, returns to 0x0486

label_0486:
	// Incoming return from call to 0x16AD at 0x0485
	// Inputs[2]
	// {
	//     @048F  stack[-1]
	//     @0490  stack[-7]
	// }
	0486    5B  JUMPDEST
	0487    60  PUSH1 0x01
	0489    60  PUSH1 0x01
	048B    60  PUSH1 0xa0
	048D    1B  SHL
	048E    03  SUB
	048F    16  AND
	0490    86  DUP7
	0491    60  PUSH1 0x01
	0493    60  PUSH1 0x01
	0495    60  PUSH1 0xa0
	0497    1B  SHL
	0498    03  SUB
	0499    16  AND
	049A    14  EQ
	049B    61  PUSH2 0x04a3
	049E    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x04a3, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]

label_049F:
	// Incoming jump from 0x049E, if not (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[1] { @04A2  memory[0x00:0x00] }
	049F    60  PUSH1 0x00
	04A1    80  DUP1
	04A2    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @04A2  revert(memory[0x00:0x00]); }
	// Block terminates

label_04A3:
	// Incoming jump from 0x049E, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[2]
	// {
	//     @04A7  stack[-4]
	//     @04A8  stack[-2]
	// }
	04A3    5B  JUMPDEST
	04A4    61  PUSH2 0x04ad
	04A7    84  DUP5
	04A8    83  DUP4
	04A9    61  PUSH2 0x13b6
	04AC    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @04A4  stack[0] = 0x04ad
	//     @04A7  stack[1] = stack[-4]
	//     @04A8  stack[2] = stack[-2]
	// }
	// Block ends with call to 0x13b6, returns to 0x04AD

label_04AD:
	// Incoming return from call to 0x13B6 at 0x04AC
	// Inputs[4]
	// {
	//     @04AE  stack[-1]
	//     @04AE  stack[-10]
	//     @04B3  stack[-4]
	//     @04B4  stack[-2]
	// }
	04AD    5B  JUMPDEST
	04AE    98  SWAP9
	04AF    50  POP
	04B0    61  PUSH2 0x04b9
	04B3    83  DUP4
	04B4    82  DUP3
	04B5    61  PUSH2 0x13b6
	04B8    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @04AE  stack[-10] = stack[-1]
	//     @04B0  stack[-1] = 0x04b9
	//     @04B3  stack[0] = stack[-4]
	//     @04B4  stack[1] = stack[-2]
	// }
	// Block ends with call to 0x13b6, returns to 0x04B9

label_04B9:
	// Incoming return from call to 0x13B6 at 0x04B8
	// Inputs[2]
	// {
	//     @04BA  stack[-11]
	//     @04BA  stack[-1]
	// }
	04B9    5B  JUMPDEST
	04BA    99  SWAP10
	04BB    50  POP
	04BC    61  PUSH2 0x0533
	04BF    56  *JUMP
	// Stack delta = -1
	// Outputs[1] { @04BA  stack[-11] = stack[-1] }
	// Block ends with unconditional jump to 0x0533

label_04C0:
	// Incoming jump from 0x0476, if !((0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1])
	// Inputs[1] { @04C6  stack[-13] }
	04C0    5B  JUMPDEST
	04C1    61  PUSH2 0x04d0
	04C4    60  PUSH1 0xc0
	04C6    8E  DUP15
	04C7    01  ADD
	04C8    60  PUSH1 0xa0
	04CA    8F  DUP16
	04CB    01  ADD
	04CC    61  PUSH2 0x16ad
	04CF    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @04C1  stack[0] = 0x04d0
	//     @04C7  stack[1] = stack[-13] + 0xc0
	//     @04CB  stack[2] = stack[-13] + 0xa0
	// }
	// Block ends with call to 0x16ad, returns to 0x04D0

label_04D0:
	// Incoming return from call to 0x16AD at 0x04CF
	// Inputs[2]
	// {
	//     @04D9  stack[-1]
	//     @04DA  stack[-8]
	// }
	04D0    5B  JUMPDEST
	04D1    60  PUSH1 0x01
	04D3    60  PUSH1 0x01
	04D5    60  PUSH1 0xa0
	04D7    1B  SHL
	04D8    03  SUB
	04D9    16  AND
	04DA    87  DUP8
	04DB    60  PUSH1 0x01
	04DD    60  PUSH1 0x01
	04DF    60  PUSH1 0xa0
	04E1    1B  SHL
	04E2    03  SUB
	04E3    16  AND
	04E4    14  EQ
	04E5    61  PUSH2 0x04ed
	04E8    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x04ed, if (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1]

label_04E9:
	// Incoming jump from 0x04E8, if not (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[1] { @04EC  memory[0x00:0x00] }
	04E9    60  PUSH1 0x00
	04EB    80  DUP1
	04EC    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @04EC  revert(memory[0x00:0x00]); }
	// Block terminates

label_04ED:
	// Incoming jump from 0x04E8, if (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[1] { @04F3  stack[-13] }
	04ED    5B  JUMPDEST
	04EE    61  PUSH2 0x04fd
	04F1    60  PUSH1 0xa0
	04F3    8E  DUP15
	04F4    01  ADD
	04F5    60  PUSH1 0x80
	04F7    8F  DUP16
	04F8    01  ADD
	04F9    61  PUSH2 0x16ad
	04FC    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @04EE  stack[0] = 0x04fd
	//     @04F4  stack[1] = stack[-13] + 0xa0
	//     @04F8  stack[2] = stack[-13] + 0x80
	// }
	// Block ends with call to 0x16ad, returns to 0x04FD

label_04FD:
	// Incoming return from call to 0x16AD at 0x04FC
	// Inputs[2]
	// {
	//     @0506  stack[-1]
	//     @0507  stack[-7]
	// }
	04FD    5B  JUMPDEST
	04FE    60  PUSH1 0x01
	0500    60  PUSH1 0x01
	0502    60  PUSH1 0xa0
	0504    1B  SHL
	0505    03  SUB
	0506    16  AND
	0507    86  DUP7
	0508    60  PUSH1 0x01
	050A    60  PUSH1 0x01
	050C    60  PUSH1 0xa0
	050E    1B  SHL
	050F    03  SUB
	0510    16  AND
	0511    14  EQ
	0512    61  PUSH2 0x051a
	0515    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x051a, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]

label_0516:
	// Incoming jump from 0x0515, if not (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[1] { @0519  memory[0x00:0x00] }
	0516    60  PUSH1 0x00
	0518    80  DUP1
	0519    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0519  revert(memory[0x00:0x00]); }
	// Block terminates

label_051A:
	// Incoming jump from 0x0515, if (0x01 << 0xa0) - 0x01 & stack[-7] == (0x01 << 0xa0) - 0x01 & stack[-1]
	// Inputs[2]
	// {
	//     @051E  stack[-3]
	//     @051F  stack[-1]
	// }
	051A    5B  JUMPDEST
	051B    61  PUSH2 0x0524
	051E    83  DUP4
	051F    82  DUP3
	0520    61  PUSH2 0x13b6
	0523    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @051B  stack[0] = 0x0524
	//     @051E  stack[1] = stack[-3]
	//     @051F  stack[2] = stack[-1]
	// }
	// Block ends with call to 0x13b6, returns to 0x0524

label_0524:
	// Incoming return from call to 0x13B6 at 0x0523
	// Inputs[4]
	// {
	//     @0525  stack[-10]
	//     @0525  stack[-1]
	//     @052A  stack[-5]
	//     @052B  stack[-3]
	// }
	0524    5B  JUMPDEST
	0525    98  SWAP9
	0526    50  POP
	0527    61  PUSH2 0x0530
	052A    84  DUP5
	052B    83  DUP4
	052C    61  PUSH2 0x13b6
	052F    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @0525  stack[-10] = stack[-1]
	//     @0527  stack[-1] = 0x0530
	//     @052A  stack[0] = stack[-5]
	//     @052B  stack[1] = stack[-3]
	// }
	// Block ends with call to 0x13b6, returns to 0x0530

label_0530:
	// Incoming return from call to 0x13B6 at 0x052F
	// Inputs[2]
	// {
	//     @0531  stack[-11]
	//     @0531  stack[-1]
	// }
	0530    5B  JUMPDEST
	0531    99  SWAP10
	0532    50  POP
	// Stack delta = -1
	// Outputs[1] { @0531  stack[-11] = stack[-1] }
	// Block continues

label_0533:
	// Incoming jump from 0x0532
	// Incoming jump from 0x04BF
	// Inputs[1] { @053E  stack[-10] }
	0533    5B  JUMPDEST
	0534    50  POP
	0535    50  POP
	0536    50  POP
	0537    50  POP
	0538    50  POP
	0539    50  POP
	053A    50  POP
	053B    50  POP
	053C    60  PUSH1 0x00
	053E    82  DUP3
	053F    13  SGT
	0540    15  ISZERO
	0541    61  PUSH2 0x05ba
	0544    57  *JUMPI
	// Stack delta = -8
	// Block ends with conditional jump to 0x05ba, if !(stack[-10] i> 0x00)

label_0545:
	// Incoming jump from 0x0544, if not !(stack[-10] i> 0x00)
	// Inputs[1] { @0547  stack[-1] }
	0545    60  PUSH1 0x00
	0547    81  DUP2
	0548    12  SLT
	0549    61  PUSH2 0x0551
	054C    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0551, if stack[-1] i< 0x00

label_054D:
	// Incoming jump from 0x054C, if not stack[-1] i< 0x00
	// Inputs[1] { @0550  memory[0x00:0x00] }
	054D    60  PUSH1 0x00
	054F    80  DUP1
	0550    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0550  revert(memory[0x00:0x00]); }
	// Block terminates

label_0551:
	// Incoming jump from 0x054C, if stack[-1] i< 0x00
	// Inputs[3]
	// {
	//     @0557  stack[-2]
	//     @0558  stack[-5]
	//     @055D  msg.data[0x0120 + stack[-5]:0x0120 + stack[-5] + 0x20]
	// }
	0551    5B  JUMPDEST
	0552    60  PUSH1 0x00
	0554    61  PUSH2 0x0562
	0557    83  DUP4
	0558    87  DUP8
	0559    61  PUSH2 0x0120
	055C    01  ADD
	055D    35  CALLDATALOAD
	055E    61  PUSH2 0x13cc
	0561    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0552  stack[0] = 0x00
	//     @0554  stack[1] = 0x0562
	//     @0557  stack[2] = stack[-2]
	//     @055D  stack[3] = msg.data[0x0120 + stack[-5]:0x0120 + stack[-5] + 0x20]
	// }
	// Block ends with unconditional jump to 0x13cc

	0562    5B    JUMPDEST
	0563    90    SWAP1
	0564    50    POP
	0565    61    PUSH2 0x0576
	0568    81    DUP2
	0569    61    PUSH2 0x0571
	056C    84    DUP5
	056D    61    PUSH2 0x1c04
	0570    56    *JUMP
	0571    5B    JUMPDEST
	0572    61    PUSH2 0x13b6
	0575    56    *JUMP
	0576    5B    JUMPDEST
	0577    93    SWAP4
	0578    50    POP
	0579    61    PUSH2 0x0581
	057C    82    DUP3
	057D    61    PUSH2 0x1c04
	0580    56    *JUMP
	0581    5B    JUMPDEST
	0582    94    SWAP5
	0583    50    POP
	0584    60    PUSH1 0x00
	0586    61    PUSH2 0x058f
	0589    85    DUP6
	058A    87    DUP8
	058B    61    PUSH2 0x13cc
	058E    56    *JUMP
	058F    5B    JUMPDEST
	0590    90    SWAP1
	0591    50    POP
	0592    61    PUSH2 0x05a7
	0595    61    PUSH2 0x059d
	0598    82    DUP3
	0599    61    PUSH2 0x1407
	059C    56    *JUMP
	059D    5B    JUMPDEST
	059E    88    DUP9
	059F    60    PUSH1 0xe0
	05A1    01    ADD
	05A2    35    CALLDATALOAD
	05A3    61    PUSH2 0x140f
	05A6    56    *JUMP
	05A7    5B    JUMPDEST
	05A8    86    DUP7
	05A9    11    GT
	05AA    15    ISZERO
	05AB    61    PUSH2 0x05b3
	05AE    57    *JUMPI
	05AF    60    PUSH1 0x00
	05B1    80    DUP1
	05B2    FD    *REVERT
	05B3    5B    JUMPDEST
	05B4    50    POP
	05B5    50    POP
	05B6    61    PUSH2 0x0624
	05B9    56    *JUMP
label_05BA:
	// Incoming jump from 0x0544, if !(stack[-10] i> 0x00)
	// Inputs[1] { @05BD  stack[-1] }
	05BA    5B  JUMPDEST
	05BB    60  PUSH1 0x00
	05BD    81  DUP2
	05BE    13  SGT
	05BF    61  PUSH2 0x05c7
	05C2    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x05c7, if stack[-1] i> 0x00

label_05C3:
	// Incoming jump from 0x05C2, if not stack[-1] i> 0x00
	// Inputs[1] { @05C6  memory[0x00:0x00] }
	05C3    60  PUSH1 0x00
	05C5    80  DUP1
	05C6    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @05C6  revert(memory[0x00:0x00]); }
	// Block terminates

label_05C7:
	// Incoming jump from 0x05C2, if stack[-1] i> 0x00
	// Inputs[1] { @05D0  stack[-2] }
	05C7    5B  JUMPDEST
	05C8    60  PUSH1 0x00
	05CA    61  PUSH2 0x05e0
	05CD    61  PUSH2 0x05d5
	05D0    84  DUP5
	05D1    61  PUSH2 0x1c04
	05D4    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @05C8  stack[0] = 0x00
	//     @05CA  stack[1] = 0x05e0
	//     @05CD  stack[2] = 0x05d5
	//     @05D0  stack[3] = stack[-2]
	// }
	// Block ends with call to 0x1c04, returns to 0x05D5

label_05D5:
	// Incoming return from call to 0x1C04 at 0x05D4
	// Inputs[2]
	// {
	//     @05D6  stack[-8]
	//     @05DB  msg.data[0x0100 + stack[-8]:0x0100 + stack[-8] + 0x20]
	// }
	05D5    5B  JUMPDEST
	05D6    87  DUP8
	05D7    61  PUSH2 0x0100
	05DA    01  ADD
	05DB    35  CALLDATALOAD
	05DC    61  PUSH2 0x13cc
	05DF    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @05DB  stack[0] = msg.data[0x0100 + stack[-8]:0x0100 + stack[-8] + 0x20] }
	// Block ends with unconditional jump to 0x13cc

	05E0    5B    JUMPDEST
	05E1    90    SWAP1
	05E2    50    POP
	05E3    61    PUSH2 0x05ec
	05E6    82    DUP3
	05E7    82    DUP3
	05E8    61    PUSH2 0x13b6
	05EB    56    *JUMP
	05EC    5B    JUMPDEST
	05ED    93    SWAP4
	05EE    50    POP
	05EF    80    DUP1
	05F0    94    SWAP5
	05F1    50    POP
	05F2    60    PUSH1 0x00
	05F4    61    PUSH2 0x05fd
	05F7    85    DUP6
	05F8    87    DUP8
	05F9    61    PUSH2 0x13cc
	05FC    56    *JUMP
	05FD    5B    JUMPDEST
	05FE    90    SWAP1
	05FF    50    POP
	0600    61    PUSH2 0x0615
	0603    61    PUSH2 0x060b
	0606    82    DUP3
	0607    61    PUSH2 0x1407
	060A    56    *JUMP
	060B    5B    JUMPDEST
	060C    88    DUP9
	060D    60    PUSH1 0xc0
	060F    01    ADD
	0610    35    CALLDATALOAD
	0611    61    PUSH2 0x140f
	0614    56    *JUMP
	0615    5B    JUMPDEST
	0616    86    DUP7
	0617    11    GT
	0618    15    ISZERO
	0619    61    PUSH2 0x0621
	061C    57    *JUMPI
	061D    60    PUSH1 0x00
	061F    80    DUP1
	0620    FD    *REVERT
	0621    5B    JUMPDEST
	0622    50    POP
	0623    50    POP
	0624    5B    JUMPDEST
	0625    84    DUP5
	0626    61    PUSH2 0x0160
	0629    01    ADD
	062A    35    CALLDATALOAD
	062B    84    DUP5
	062C    11    GT
	062D    15    ISZERO
	062E    61    PUSH2 0x0636
	0631    57    *JUMPI
	0632    60    PUSH1 0x00
	0634    80    DUP1
	0635    FD    *REVERT
	0636    5B    JUMPDEST
	0637    60    PUSH1 0x00
	0639    83    DUP4
	063A    13    SGT
	063B    61    PUSH2 0x0643
	063E    57    *JUMPI
	063F    60    PUSH1 0x00
	0641    80    DUP1
	0642    FD    *REVERT
	0643    5B    JUMPDEST
	0644    61    PUSH2 0x0140
	0647    85    DUP6
	0648    01    ADD
	0649    35    CALLDATALOAD
	064A    61    PUSH2 0x0653
	064D    84    DUP5
	064E    82    DUP3
	064F    61    PUSH2 0x140f
	0652    56    *JUMP
	0653    5B    JUMPDEST
	0654    93    SWAP4
	0655    50    POP
	0656    60    PUSH1 0x00
	0658    84    DUP5
	0659    13    SGT
	065A    61    PUSH2 0x0662
	065D    57    *JUMPI
	065E    60    PUSH1 0x00
	0660    80    DUP1
	0661    FD    *REVERT
	0662    5B    JUMPDEST
	0663    61    PUSH2 0x066c
	0666    85    DUP6
	0667    82    DUP3
	0668    61    PUSH2 0x140f
	066B    56    *JUMP
	066C    5B    JUMPDEST
	066D    94    SWAP5
	066E    50    POP
	066F    60    PUSH1 0x00
	0671    90    SWAP1
	0672    50    POP
	0673    61    PUSH2 0x0682
	0676    60    PUSH1 0x60
	0678    87    DUP8
	0679    01    ADD
	067A    60    PUSH1 0x40
	067C    88    DUP9
	067D    01    ADD
	067E    61    PUSH2 0x18b4
	0681    56    *JUMP
	0682    5B    JUMPDEST
	0683    60    PUSH1 0xff
	0685    16    AND
	0686    90    SWAP1
	0687    50    POP
	0688    60    PUSH1 0x00
	068A    61    PUSH2 0x0696
	068D    48    BASEFEE
	068E    62    PUSH3 0x0c3500
	0692    61    PUSH2 0x1b86
	0695    56    *JUMP
	0696    5B    JUMPDEST
	0697    90    SWAP1
	0698    50    POP
	0699    60    PUSH1 0x00
	069B    61    PUSH2 0x06e0
	069E    47    SELFBALANCE
	069F    61    PUSH2 0x06db
	06A2    61    PUSH2 0x06b1
	06A5    60    PUSH1 0x40
	06A7    8C    DUP13
	06A8    01    ADD
	06A9    60    PUSH1 0x20
	06AB    8D    DUP14
	06AC    01    ADD
	06AD    61    PUSH2 0x18d1
	06B0    56    *JUMP
	06B1    5B    JUMPDEST
	06B2    60    PUSH1 0x01
	06B4    60    PUSH1 0x01
	06B6    60    PUSH1 0x60
	06B8    1B    SHL
	06B9    03    SUB
	06BA    16    AND
	06BB    85    DUP6
	06BC    60    PUSH1 0xff
	06BE    61    PUSH2 0x06c7
	06C1    89    DUP10
	06C2    8D    DUP14
	06C3    61    PUSH2 0x1b86
	06C6    56    *JUMP
	06C7    5B    JUMPDEST
	06C8    61    PUSH2 0x06d1
	06CB    91    SWAP2
	06CC    90    SWAP1
	06CD    61    PUSH2 0x1b64
	06D0    56    *JUMP
	06D1    5B    JUMPDEST
	06D2    61    PUSH2 0x06db
	06D5    91    SWAP2
	06D6    90    SWAP1
	06D7    61    PUSH2 0x1bed
	06DA    56    *JUMP
	06DB    5B    JUMPDEST
	06DC    61    PUSH2 0x1424
	06DF    56    *JUMP
	06E0    5B    JUMPDEST
	06E1    90    SWAP1
	06E2    50    POP
	06E3    85    DUP6
	06E4    61    PUSH2 0x06ed
	06E7    83    DUP4
	06E8    83    DUP4
	06E9    61    PUSH2 0x1b4c
	06EC    56    *JUMP
	06ED    5B    JUMPDEST
	06EE    11    GT
	06EF    15    ISZERO
	06F0    61    PUSH2 0x06f8
	06F3    57    *JUMPI
	06F4    60    PUSH1 0x00
	06F6    80    DUP1
	06F7    FD    *REVERT
	06F8    5B    JUMPDEST
	06F9    60    PUSH1 0x40
	06FB    51    MLOAD
	06FC    41    COINBASE
	06FD    90    SWAP1
	06FE    82    DUP3
	06FF    15    ISZERO
	0700    61    PUSH2 0x08fc
	0703    02    MUL
	0704    90    SWAP1
	0705    83    DUP4
	0706    90    SWAP1
	0707    60    PUSH1 0x00
	0709    81    DUP2
	070A    81    DUP2
	070B    81    DUP2
	070C    85    DUP6
	070D    88    DUP9
	070E    88    DUP9
	070F    F1    CALL
	0710    93    SWAP4
	0711    50    POP
	0712    50    POP
	0713    50    POP
	0714    50    POP
	0715    50    POP
	0716    50    POP
	0717    50    POP
	0718    50    POP
	0719    61    PUSH2 0x072f
	071C    60    PUSH1 0x00
	071E    60    PUSH1 0x00
	0720    80    DUP1
	0721    51    MLOAD
	0722    60    PUSH1 0x20
	0724    61    PUSH2 0x1c87
	0727    83    DUP4
	0728    39    CODECOPY
	0729    81    DUP2
	072A    51    MLOAD
	072B    91    SWAP2
	072C    52    MSTORE
	072D    55    SSTORE
	072E    56    *JUMP
	072F    5B    JUMPDEST
	0730    50    POP
	0731    50    POP
	0732    91    SWAP2
	0733    50    POP
	0734    91    SWAP2
	0735    56    *JUMP
label_0736:
	// Incoming jump from 0x00D9
	// Inputs[3]
	// {
	//     @073F  memory[0x00:0x20]
	//     @0748  memory[0x00:0x20]
	//     @074B  storage[memory[0x00:0x20]]
	// }
	0736    5B  JUMPDEST
	0737    60  PUSH1 0x00
	0739    61  PUSH2 0x074e
	073C    60  PUSH1 0x00
	073E    80  DUP1
	073F    51  MLOAD
	0740    60  PUSH1 0x20
	0742    61  PUSH2 0x1c87
	0745    83  DUP4
	0746    39  CODECOPY
	0747    81  DUP2
	0748    51  MLOAD
	0749    91  SWAP2
	074A    52  MSTORE
	074B    54  SLOAD
	074C    90  SWAP1
	074D    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @0737  stack[0] = 0x00
	//     @0746  memory[0x00:0x20] = code[0x1c87:0x1ca7]
	//     @074A  memory[0x00:0x20] = memory[0x00:0x20]
	//     @074C  stack[1] = storage[memory[0x00:0x20]]
	// }
	// Block ends with unconditional jump to 0x074e

label_074E:
	// Incoming jump from 0x074D
	// Inputs[2]
	// {
	//     @074F  stack[-2]
	//     @074F  stack[-1]
	// }
	074E    5B  JUMPDEST
	074F    90  SWAP1
	0750    50  POP
	0751    80  DUP1
	0752    61  PUSH2 0x075a
	0755    57  *JUMPI
	// Stack delta = -1
	// Outputs[1] { @074F  stack[-2] = stack[-1] }
	// Block ends with conditional jump to 0x075a, if stack[-1]

label_0756:
	// Incoming jump from 0x0755, if not stack[-1]
	// Inputs[1] { @0759  memory[0x00:0x00] }
	0756    60  PUSH1 0x00
	0758    80  DUP1
	0759    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0759  revert(memory[0x00:0x00]); }
	// Block terminates

label_075A:
	// Incoming jump from 0x0755, if stack[-1]
	// Inputs[4]
	// {
	//     @075D  memory[0x40:0x60]
	//     @076C  stack[-1]
	//     @0796  memory[0x40:0x60]
	//     @079D  address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	075A    5B  JUMPDEST
	075B    60  PUSH1 0x40
	075D    51  MLOAD
	075E    63  PUSH4 0x133f7571
	0763    60  PUSH1 0xe3
	0765    1B  SHL
	0766    81  DUP2
	0767    52  MSTORE
	0768    60  PUSH1 0x04
	076A    81  DUP2
	076B    01  ADD
	076C    82  DUP3
	076D    90  SWAP1
	076E    52  MSTORE
	076F    60  PUSH1 0x00
	0771    90  SWAP1
	0772    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0787    90  SWAP1
	0788    63  PUSH4 0x99fbab88
	078D    90  SWAP1
	078E    60  PUSH1 0x24
	0790    01  ADD
	0791    61  PUSH2 0x0180
	0794    60  PUSH1 0x40
	0796    51  MLOAD
	0797    80  DUP1
	0798    83  DUP4
	0799    03  SUB
	079A    81  DUP2
	079B    86  DUP7
	079C    80  DUP1
	079D    3B  EXTCODESIZE
	079E    15  ISZERO
	079F    80  DUP1
	07A0    15  ISZERO
	07A1    61  PUSH2 0x07a9
	07A4    57  *JUMPI
	// Stack delta = +10
	// Outputs[12]
	// {
	//     @0767  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x133f7571 << 0xe3
	//     @076E  memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1]
	//     @0771  stack[0] = 0x00
	//     @0787  stack[1] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @078D  stack[2] = 0x99fbab88
	//     @0790  stack[3] = 0x24 + memory[0x40:0x60]
	//     @0791  stack[4] = 0x0180
	//     @0796  stack[5] = memory[0x40:0x60]
	//     @0799  stack[6] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @079A  stack[7] = memory[0x40:0x60]
	//     @079B  stack[8] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @079E  stack[9] = !address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	// Block ends with conditional jump to 0x07a9, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length

label_07A5:
	// Incoming jump from 0x07A4, if not !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[1] { @07A8  memory[0x00:0x00] }
	07A5    60  PUSH1 0x00
	07A7    80  DUP1
	07A8    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @07A8  revert(memory[0x00:0x00]); }
	// Block terminates

label_07A9:
	// Incoming jump from 0x07A4, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[8]
	// {
	//     @07AB  msg.gas
	//     @07AC  stack[-2]
	//     @07AC  stack[-3]
	//     @07AC  stack[-6]
	//     @07AC  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @07AC  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @07AC  stack[-5]
	//     @07AC  stack[-4]
	// }
	07A9    5B  JUMPDEST
	07AA    50  POP
	07AB    5A  GAS
	07AC    FA  STATICCALL
	07AD    15  ISZERO
	07AE    80  DUP1
	07AF    15  ISZERO
	07B0    61  PUSH2 0x07bd
	07B3    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @07AC  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @07AD  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x07bd, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_07B4:
	// Incoming jump from 0x07B3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @07B4  returndata.length
	//     @07B8  returndata[0x00:0x00 + returndata.length]
	//     @07B9  returndata.length
	//     @07BC  memory[0x00:0x00 + returndata.length]
	// }
	07B4    3D  RETURNDATASIZE
	07B5    60  PUSH1 0x00
	07B7    80  DUP1
	07B8    3E  RETURNDATACOPY
	07B9    3D  RETURNDATASIZE
	07BA    60  PUSH1 0x00
	07BC    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @07B8  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @07BC  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_07BD:
	// Incoming jump from 0x07B3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @07C4  memory[0x40:0x60]
	//     @07C5  returndata.length
	// }
	07BD    5B  JUMPDEST
	07BE    50  POP
	07BF    50  POP
	07C0    50  POP
	07C1    50  POP
	07C2    60  PUSH1 0x40
	07C4    51  MLOAD
	07C5    3D  RETURNDATASIZE
	07C6    60  PUSH1 0x1f
	07C8    19  NOT
	07C9    60  PUSH1 0x1f
	07CB    82  DUP3
	07CC    01  ADD
	07CD    16  AND
	07CE    82  DUP3
	07CF    01  ADD
	07D0    80  DUP1
	07D1    60  PUSH1 0x40
	07D3    52  MSTORE
	07D4    50  POP
	07D5    81  DUP2
	07D6    01  ADD
	07D7    90  SWAP1
	07D8    61  PUSH2 0x07e1
	07DB    91  SWAP2
	07DC    90  SWAP1
	07DD    61  PUSH2 0x18ee
	07E0    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @07D3  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @07DB  stack[-4] = 0x07e1
	//     @07DC  stack[-2] = memory[0x40:0x60]
	//     @07DC  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x18ee, returns to 0x07E1

label_07E1:
	// Incoming return from call to 0x18EE at 0x07E0
	// Inputs[2]
	// {
	//     @07E6  stack[-13]
	//     @07E6  stack[-5]
	// }
	07E1    5B  JUMPDEST
	07E2    50  POP
	07E3    50  POP
	07E4    50  POP
	07E5    50  POP
	07E6    97  SWAP8
	07E7    50  POP
	07E8    50  POP
	07E9    50  POP
	07EA    50  POP
	07EB    50  POP
	07EC    50  POP
	07ED    50  POP
	07EE    50  POP
	07EF    60  PUSH1 0x00
	07F1    81  DUP2
	07F2    60  PUSH1 0x01
	07F4    60  PUSH1 0x01
	07F6    60  PUSH1 0x80
	07F8    1B  SHL
	07F9    03  SUB
	07FA    16  AND
	07FB    11  GT
	07FC    15  ISZERO
	07FD    61  PUSH2 0x08ba
	0800    57  *JUMPI
	// Stack delta = -12
	// Outputs[1] { @07E6  stack[-13] = stack[-5] }
	// Block ends with conditional jump to 0x08ba, if !((0x01 << 0x80) - 0x01 & stack[-5] > 0x00)

label_0801:
	// Incoming jump from 0x0800, if not !((0x01 << 0x80) - 0x01 & stack[-5] > 0x00)
	// Inputs[4]
	// {
	//     @0804  memory[0x40:0x60]
	//     @080B  stack[-2]
	//     @0816  stack[-1]
	//     @0833  memory[0x40:0x60]
	// }
	0801    60  PUSH1 0x40
	0803    80  DUP1
	0804    51  MLOAD
	0805    60  PUSH1 0xa0
	0807    81  DUP2
	0808    01  ADD
	0809    82  DUP3
	080A    52  MSTORE
	080B    83  DUP4
	080C    81  DUP2
	080D    52  MSTORE
	080E    60  PUSH1 0x01
	0810    60  PUSH1 0x01
	0812    60  PUSH1 0x80
	0814    1B  SHL
	0815    03  SUB
	0816    83  DUP4
	0817    16  AND
	0818    60  PUSH1 0x20
	081A    82  DUP3
	081B    01  ADD
	081C    52  MSTORE
	081D    60  PUSH1 0x00
	081F    81  DUP2
	0820    83  DUP4
	0821    01  ADD
	0822    81  DUP2
	0823    90  SWAP1
	0824    52  MSTORE
	0825    60  PUSH1 0x60
	0827    82  DUP3
	0828    01  ADD
	0829    52  MSTORE
	082A    60  PUSH1 0x00
	082C    19  NOT
	082D    60  PUSH1 0x80
	082F    82  DUP3
	0830    01  ADD
	0831    52  MSTORE
	0832    90  SWAP1
	0833    51  MLOAD
	0834    63  PUSH4 0x0624e65f
	0839    60  PUSH1 0xe1
	083B    1B  SHL
	083C    81  DUP2
	083D    52  MSTORE
	083E    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0853    91  SWAP2
	0854    63  PUSH4 0x0c49ccbe
	0859    91  SWAP2
	085A    61  PUSH2 0x0866
	085D    91  SWAP2
	085E    90  SWAP1
	085F    60  PUSH1 0x04
	0861    01  ADD
	0862    61  PUSH2 0x1a45
	0865    56  *JUMP
	// Stack delta = +5
	// Outputs[12]
	// {
	//     @080A  memory[0x40:0x60] = memory[0x40:0x60] + 0xa0
	//     @080D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @081C  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0x80) - 0x01
	//     @0824  memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0x00
	//     @0829  memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00
	//     @0831  memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = ~0x00
	//     @083D  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0624e65f << 0xe1
	//     @0853  stack[0] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @0859  stack[1] = 0x0c49ccbe
	//     @085D  stack[2] = 0x0866
	//     @085E  stack[3] = memory[0x40:0x60]
	//     @0861  stack[4] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x1a45, returns to 0x0866

label_0866:
	// Incoming return from call to 0x1A45 at 0x0865
	// Inputs[4]
	// {
	//     @086A  memory[0x40:0x60]
	//     @086C  stack[-1]
	//     @0871  stack[-3]
	//     @0873  address(stack[-3]).code.length
	// }
	0866    5B  JUMPDEST
	0867    60  PUSH1 0x40
	0869    80  DUP1
	086A    51  MLOAD
	086B    80  DUP1
	086C    83  DUP4
	086D    03  SUB
	086E    81  DUP2
	086F    60  PUSH1 0x00
	0871    87  DUP8
	0872    80  DUP1
	0873    3B  EXTCODESIZE
	0874    15  ISZERO
	0875    80  DUP1
	0876    15  ISZERO
	0877    61  PUSH2 0x087f
	087A    57  *JUMPI
	// Stack delta = +7
	// Outputs[7]
	// {
	//     @0867  stack[0] = 0x40
	//     @086A  stack[1] = memory[0x40:0x60]
	//     @086D  stack[2] = stack[-1] - memory[0x40:0x60]
	//     @086E  stack[3] = memory[0x40:0x60]
	//     @086F  stack[4] = 0x00
	//     @0871  stack[5] = stack[-3]
	//     @0874  stack[6] = !address(stack[-3]).code.length
	// }
	// Block ends with conditional jump to 0x087f, if !!address(stack[-3]).code.length

label_087B:
	// Incoming jump from 0x087A, if not !!address(stack[-3]).code.length
	// Inputs[1] { @087E  memory[0x00:0x00] }
	087B    60  PUSH1 0x00
	087D    80  DUP1
	087E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @087E  revert(memory[0x00:0x00]); }
	// Block terminates

label_087F:
	// Incoming jump from 0x087A, if !!address(stack[-3]).code.length
	// Inputs[9]
	// {
	//     @0881  msg.gas
	//     @0882  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @0882  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0882  stack[-3]
	//     @0882  stack[-5]
	//     @0882  stack[-4]
	//     @0882  stack[-2]
	//     @0882  stack[-7]
	//     @0882  stack[-6]
	// }
	087F    5B  JUMPDEST
	0880    50  POP
	0881    5A  GAS
	0882    F1  CALL
	0883    15  ISZERO
	0884    80  DUP1
	0885    15  ISZERO
	0886    61  PUSH2 0x0893
	0889    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @0882  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0883  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x0893, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_088A:
	// Incoming jump from 0x0889, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @088A  returndata.length
	//     @088E  returndata[0x00:0x00 + returndata.length]
	//     @088F  returndata.length
	//     @0892  memory[0x00:0x00 + returndata.length]
	// }
	088A    3D  RETURNDATASIZE
	088B    60  PUSH1 0x00
	088D    80  DUP1
	088E    3E  RETURNDATACOPY
	088F    3D  RETURNDATASIZE
	0890    60  PUSH1 0x00
	0892    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @088E  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0892  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0893:
	// Incoming jump from 0x0889, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @089A  memory[0x40:0x60]
	//     @089B  returndata.length
	// }
	0893    5B  JUMPDEST
	0894    50  POP
	0895    50  POP
	0896    50  POP
	0897    50  POP
	0898    60  PUSH1 0x40
	089A    51  MLOAD
	089B    3D  RETURNDATASIZE
	089C    60  PUSH1 0x1f
	089E    19  NOT
	089F    60  PUSH1 0x1f
	08A1    82  DUP3
	08A2    01  ADD
	08A3    16  AND
	08A4    82  DUP3
	08A5    01  ADD
	08A6    80  DUP1
	08A7    60  PUSH1 0x40
	08A9    52  MSTORE
	08AA    50  POP
	08AB    81  DUP2
	08AC    01  ADD
	08AD    90  SWAP1
	08AE    61  PUSH2 0x08b7
	08B1    91  SWAP2
	08B2    90  SWAP1
	08B3    61  PUSH2 0x1866
	08B6    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @08A9  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @08B1  stack[-4] = 0x08b7
	//     @08B2  stack[-2] = memory[0x40:0x60]
	//     @08B2  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x1866, returns to 0x08B7

label_08B7:
	// Incoming return from call to 0x1866 at 0x08B6
	08B7    5B  JUMPDEST
	08B8    50  POP
	08B9    50  POP
	// Stack delta = -2
	// Block continues

label_08BA:
	// Incoming jump from 0x0800, if !((0x01 << 0x80) - 0x01 & stack[-5] > 0x00)
	// Incoming jump from 0x08B9
	// Inputs[4]
	// {
	//     @08BE  memory[0x40:0x60]
	//     @08C5  stack[-2]
	//     @08D0  stack[-3]
	//     @08EB  memory[0x40:0x60]
	// }
	08BA    5B  JUMPDEST
	08BB    60  PUSH1 0x40
	08BD    80  DUP1
	08BE    51  MLOAD
	08BF    60  PUSH1 0x80
	08C1    81  DUP2
	08C2    01  ADD
	08C3    82  DUP3
	08C4    52  MSTORE
	08C5    83  DUP4
	08C6    81  DUP2
	08C7    52  MSTORE
	08C8    60  PUSH1 0x01
	08CA    60  PUSH1 0x01
	08CC    60  PUSH1 0xa0
	08CE    1B  SHL
	08CF    03  SUB
	08D0    85  DUP6
	08D1    16  AND
	08D2    60  PUSH1 0x20
	08D4    82  DUP3
	08D5    01  ADD
	08D6    52  MSTORE
	08D7    60  PUSH1 0x01
	08D9    60  PUSH1 0x01
	08DB    60  PUSH1 0x80
	08DD    1B  SHL
	08DE    03  SUB
	08DF    81  DUP2
	08E0    83  DUP4
	08E1    01  ADD
	08E2    81  DUP2
	08E3    90  SWAP1
	08E4    52  MSTORE
	08E5    60  PUSH1 0x60
	08E7    82  DUP3
	08E8    01  ADD
	08E9    52  MSTORE
	08EA    90  SWAP1
	08EB    51  MLOAD
	08EC    63  PUSH4 0xfc6f7865
	08F1    60  PUSH1 0xe0
	08F3    1B  SHL
	08F4    81  DUP2
	08F5    52  MSTORE
	08F6    60  PUSH1 0x00
	08F8    91  SWAP2
	08F9    82  DUP3
	08FA    91  SWAP2
	08FB    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0910    91  SWAP2
	0911    63  PUSH4 0xfc6f7865
	0916    91  SWAP2
	0917    61  PUSH2 0x0923
	091A    91  SWAP2
	091B    90  SWAP1
	091C    60  PUSH1 0x04
	091E    01  ADD
	091F    61  PUSH2 0x1a02
	0922    56  *JUMP
	// Stack delta = +7
	// Outputs[13]
	// {
	//     @08C4  memory[0x40:0x60] = memory[0x40:0x60] + 0x80
	//     @08C7  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2]
	//     @08D6  memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01
	//     @08E4  memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = (0x01 << 0x80) - 0x01
	//     @08E9  memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = (0x01 << 0x80) - 0x01
	//     @08F5  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xfc6f7865 << 0xe0
	//     @08F8  stack[0] = 0x00
	//     @08FA  stack[1] = 0x00
	//     @0910  stack[2] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @0916  stack[3] = 0xfc6f7865
	//     @091A  stack[4] = 0x0923
	//     @091B  stack[5] = memory[0x40:0x60]
	//     @091E  stack[6] = 0x04 + memory[0x40:0x60]
	// }
	// Block ends with call to 0x1a02, returns to 0x0923

label_0923:
	// Incoming return from call to 0x1A02 at 0x0922
	// Inputs[4]
	// {
	//     @0927  memory[0x40:0x60]
	//     @0929  stack[-1]
	//     @092E  stack[-3]
	//     @0930  address(stack[-3]).code.length
	// }
	0923    5B  JUMPDEST
	0924    60  PUSH1 0x40
	0926    80  DUP1
	0927    51  MLOAD
	0928    80  DUP1
	0929    83  DUP4
	092A    03  SUB
	092B    81  DUP2
	092C    60  PUSH1 0x00
	092E    87  DUP8
	092F    80  DUP1
	0930    3B  EXTCODESIZE
	0931    15  ISZERO
	0932    80  DUP1
	0933    15  ISZERO
	0934    61  PUSH2 0x093c
	0937    57  *JUMPI
	// Stack delta = +7
	// Outputs[7]
	// {
	//     @0924  stack[0] = 0x40
	//     @0927  stack[1] = memory[0x40:0x60]
	//     @092A  stack[2] = stack[-1] - memory[0x40:0x60]
	//     @092B  stack[3] = memory[0x40:0x60]
	//     @092C  stack[4] = 0x00
	//     @092E  stack[5] = stack[-3]
	//     @0931  stack[6] = !address(stack[-3]).code.length
	// }
	// Block ends with conditional jump to 0x093c, if !!address(stack[-3]).code.length

label_0938:
	// Incoming jump from 0x0937, if not !!address(stack[-3]).code.length
	// Inputs[1] { @093B  memory[0x00:0x00] }
	0938    60  PUSH1 0x00
	093A    80  DUP1
	093B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @093B  revert(memory[0x00:0x00]); }
	// Block terminates

label_093C:
	// Incoming jump from 0x0937, if !!address(stack[-3]).code.length
	// Inputs[9]
	// {
	//     @093E  msg.gas
	//     @093F  stack[-6]
	//     @093F  stack[-4]
	//     @093F  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @093F  stack[-3]
	//     @093F  stack[-2]
	//     @093F  stack[-7]
	//     @093F  stack[-5]
	//     @093F  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	093C    5B  JUMPDEST
	093D    50  POP
	093E    5A  GAS
	093F    F1  CALL
	0940    15  ISZERO
	0941    80  DUP1
	0942    15  ISZERO
	0943    61  PUSH2 0x0950
	0946    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @093F  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0940  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x0950, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_0947:
	// Incoming jump from 0x0946, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @0947  returndata.length
	//     @094B  returndata[0x00:0x00 + returndata.length]
	//     @094C  returndata.length
	//     @094F  memory[0x00:0x00 + returndata.length]
	// }
	0947    3D  RETURNDATASIZE
	0948    60  PUSH1 0x00
	094A    80  DUP1
	094B    3E  RETURNDATACOPY
	094C    3D  RETURNDATASIZE
	094D    60  PUSH1 0x00
	094F    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @094B  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @094F  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0950:
	// Incoming jump from 0x0946, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0957  memory[0x40:0x60]
	//     @0958  returndata.length
	// }
	0950    5B  JUMPDEST
	0951    50  POP
	0952    50  POP
	0953    50  POP
	0954    50  POP
	0955    60  PUSH1 0x40
	0957    51  MLOAD
	0958    3D  RETURNDATASIZE
	0959    60  PUSH1 0x1f
	095B    19  NOT
	095C    60  PUSH1 0x1f
	095E    82  DUP3
	095F    01  ADD
	0960    16  AND
	0961    82  DUP3
	0962    01  ADD
	0963    80  DUP1
	0964    60  PUSH1 0x40
	0966    52  MSTORE
	0967    50  POP
	0968    81  DUP2
	0969    01  ADD
	096A    90  SWAP1
	096B    61  PUSH2 0x0974
	096E    91  SWAP2
	096F    90  SWAP1
	0970    61  PUSH2 0x1866
	0973    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @0966  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @096E  stack[-4] = 0x0974
	//     @096F  stack[-2] = memory[0x40:0x60]
	//     @096F  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with call to 0x1866, returns to 0x0974

label_0974:
	// Incoming return from call to 0x1866 at 0x0973
	// Inputs[5]
	// {
	//     @0975  stack[-3]
	//     @0975  stack[-1]
	//     @0977  stack[-2]
	//     @0977  stack[-4]
	//     @097B  stack[-5]
	// }
	0974    5B  JUMPDEST
	0975    91  SWAP2
	0976    50  POP
	0977    91  SWAP2
	0978    50  POP
	0979    60  PUSH1 0x00
	097B    83  DUP4
	097C    60  PUSH1 0x01
	097E    60  PUSH1 0x01
	0980    60  PUSH1 0x80
	0982    1B  SHL
	0983    03  SUB
	0984    16  AND
	0985    11  GT
	0986    80  DUP1
	0987    61  PUSH2 0x0990
	098A    57  *JUMPI
	// Stack delta = -1
	// Outputs[3]
	// {
	//     @0975  stack[-3] = stack[-1]
	//     @0977  stack[-4] = stack[-2]
	//     @0985  stack[-2] = (0x01 << 0x80) - 0x01 & stack[-5] > 0x00
	// }
	// Block ends with conditional jump to 0x0990, if (0x01 << 0x80) - 0x01 & stack[-5] > 0x00

label_098B:
	// Incoming jump from 0x098A, if not (0x01 << 0x80) - 0x01 & stack[-5] > 0x00
	// Inputs[1] { @098E  stack[-3] }
	098B    50  POP
	098C    60  PUSH1 0x00
	098E    82  DUP3
	098F    11  GT
	0990    5B  JUMPDEST
	0991    80  DUP1
	0992    61  PUSH2 0x099b
	0995    57  *JUMPI
	// Stack delta = +0
	// Outputs[1] { @098F  stack[-1] = stack[-3] > 0x00 }
	// Block ends with conditional jump to 0x099b, if stack[-3] > 0x00

label_0996:
	// Incoming jump from 0x0995, if not stack[-3] > 0x00
	// Incoming jump from 0x0995, if not stack[-1]
	// Inputs[1] { @0999  stack[-2] }
	0996    50  POP
	0997    60  PUSH1 0x00
	0999    81  DUP2
	099A    11  GT
	099B    5B  JUMPDEST
	099C    61  PUSH2 0x09a4
	099F    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x09a4, if stack[-2] > 0x00

label_09A0:
	// Incoming jump from 0x099F, if not stack[-1]
	// Incoming jump from 0x099F, if not stack[-2] > 0x00
	// Inputs[1] { @09A3  memory[0x00:0x00] }
	09A0    60  PUSH1 0x00
	09A2    80  DUP1
	09A3    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @09A3  revert(memory[0x00:0x00]); }
	// Block terminates

label_09A4:
	// Incoming jump from 0x099F, if stack[-1]
	// Incoming jump from 0x099F, if stack[-2] > 0x00
	// Inputs[1] { @09AA  stack[-6] }
	09A4    5B  JUMPDEST
	09A5    50  POP
	09A6    50  POP
	09A7    50  POP
	09A8    50  POP
	09A9    50  POP
	09AA    56  *JUMP
	// Stack delta = -6
	// Block ends with unconditional jump to stack[-6]

label_09AB:
	// Incoming call from 0x00E3, returns to 0x00DA
	// Inputs[3]
	// {
	//     @09B4  memory[0x00:0x20]
	//     @09BD  memory[0x00:0x20]
	//     @09C0  storage[memory[0x00:0x20]]
	// }
	09AB    5B  JUMPDEST
	09AC    60  PUSH1 0x00
	09AE    61  PUSH2 0x09c3
	09B1    60  PUSH1 0x00
	09B3    80  DUP1
	09B4    51  MLOAD
	09B5    60  PUSH1 0x20
	09B7    61  PUSH2 0x1c87
	09BA    83  DUP4
	09BB    39  CODECOPY
	09BC    81  DUP2
	09BD    51  MLOAD
	09BE    91  SWAP2
	09BF    52  MSTORE
	09C0    54  SLOAD
	09C1    90  SWAP1
	09C2    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @09AC  stack[0] = 0x00
	//     @09BB  memory[0x00:0x20] = code[0x1c87:0x1ca7]
	//     @09BF  memory[0x00:0x20] = memory[0x00:0x20]
	//     @09C1  stack[1] = storage[memory[0x00:0x20]]
	// }
	// Block ends with unconditional jump to 0x09c3

label_09C3:
	// Incoming jump from 0x09C2
	// Inputs[2]
	// {
	//     @09C4  stack[-2]
	//     @09C4  stack[-1]
	// }
	09C3    5B  JUMPDEST
	09C4    90  SWAP1
	09C5    50  POP
	09C6    80  DUP1
	09C7    61  PUSH2 0x09cf
	09CA    57  *JUMPI
	// Stack delta = -1
	// Outputs[1] { @09C4  stack[-2] = stack[-1] }
	// Block ends with conditional jump to 0x09cf, if stack[-1]

label_09CB:
	// Incoming jump from 0x09CA, if not stack[-1]
	// Inputs[1] { @09CE  memory[0x00:0x00] }
	09CB    60  PUSH1 0x00
	09CD    80  DUP1
	09CE    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @09CE  revert(memory[0x00:0x00]); }
	// Block terminates

label_09CF:
	// Incoming jump from 0x09CA, if stack[-1]
	// Inputs[4]
	// {
	//     @09D2  memory[0x40:0x60]
	//     @09E1  stack[-1]
	//     @0A07  memory[0x40:0x60]
	//     @0A10  address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	09CF    5B  JUMPDEST
	09D0    60  PUSH1 0x40
	09D2    51  MLOAD
	09D3    63  PUSH4 0x0852cd8d
	09D8    60  PUSH1 0xe3
	09DA    1B  SHL
	09DB    81  DUP2
	09DC    52  MSTORE
	09DD    60  PUSH1 0x04
	09DF    81  DUP2
	09E0    01  ADD
	09E1    82  DUP3
	09E2    90  SWAP1
	09E3    52  MSTORE
	09E4    73  PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	09F9    90  SWAP1
	09FA    63  PUSH4 0x42966c68
	09FF    90  SWAP1
	0A00    60  PUSH1 0x24
	0A02    01  ADD
	0A03    60  PUSH1 0x00
	0A05    60  PUSH1 0x40
	0A07    51  MLOAD
	0A08    80  DUP1
	0A09    83  DUP4
	0A0A    03  SUB
	0A0B    81  DUP2
	0A0C    60  PUSH1 0x00
	0A0E    87  DUP8
	0A0F    80  DUP1
	0A10    3B  EXTCODESIZE
	0A11    15  ISZERO
	0A12    80  DUP1
	0A13    15  ISZERO
	0A14    61  PUSH2 0x0a1c
	0A17    57  *JUMPI
	// Stack delta = +10
	// Outputs[12]
	// {
	//     @09DC  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0852cd8d << 0xe3
	//     @09E3  memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1]
	//     @09F9  stack[0] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @09FF  stack[1] = 0x42966c68
	//     @0A02  stack[2] = 0x24 + memory[0x40:0x60]
	//     @0A03  stack[3] = 0x00
	//     @0A07  stack[4] = memory[0x40:0x60]
	//     @0A0A  stack[5] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0A0B  stack[6] = memory[0x40:0x60]
	//     @0A0C  stack[7] = 0x00
	//     @0A0E  stack[8] = 0xc36442b4a4522e871399cd717abdd847ab11fe88
	//     @0A11  stack[9] = !address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// }
	// Block ends with conditional jump to 0x0a1c, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length

label_0A18:
	// Incoming jump from 0x0A17, if not !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[1] { @0A1B  memory[0x00:0x00] }
	0A18    60  PUSH1 0x00
	0A1A    80  DUP1
	0A1B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0A1B  revert(memory[0x00:0x00]); }
	// Block terminates

label_0A1C:
	// Incoming jump from 0x0A17, if !!address(0xc36442b4a4522e871399cd717abdd847ab11fe88).code.length
	// Inputs[9]
	// {
	//     @0A1E  msg.gas
	//     @0A1F  stack[-4]
	//     @0A1F  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0A1F  stack[-7]
	//     @0A1F  stack[-5]
	//     @0A1F  stack[-3]
	//     @0A1F  stack[-6]
	//     @0A1F  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @0A1F  stack[-2]
	// }
	0A1C    5B  JUMPDEST
	0A1D    50  POP
	0A1E    5A  GAS
	0A1F    F1  CALL
	0A20    15  ISZERO
	0A21    80  DUP1
	0A22    15  ISZERO
	0A23    61  PUSH2 0x0a30
	0A26    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @0A1F  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0A20  stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// }
	// Block ends with conditional jump to 0x0a30, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_0A27:
	// Incoming jump from 0x0A26, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @0A27  returndata.length
	//     @0A2B  returndata[0x00:0x00 + returndata.length]
	//     @0A2C  returndata.length
	//     @0A2F  memory[0x00:0x00 + returndata.length]
	// }
	0A27    3D  RETURNDATASIZE
	0A28    60  PUSH1 0x00
	0A2A    80  DUP1
	0A2B    3E  RETURNDATACOPY
	0A2C    3D  RETURNDATASIZE
	0A2D    60  PUSH1 0x00
	0A2F    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0A2B  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0A2F  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0A30:
	// Incoming jump from 0x0A26, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0A3D  memory[0x00:0x20]
	//     @0A46  memory[0x00:0x20]
	// }
	0A30    5B  JUMPDEST
	0A31    50  POP
	0A32    50  POP
	0A33    50  POP
	0A34    50  POP
	0A35    61  PUSH2 0x0a4b
	0A38    60  PUSH1 0x00
	0A3A    60  PUSH1 0x00
	0A3C    80  DUP1
	0A3D    51  MLOAD
	0A3E    60  PUSH1 0x20
	0A40    61  PUSH2 0x1c87
	0A43    83  DUP4
	0A44    39  CODECOPY
	0A45    81  DUP2
	0A46    51  MLOAD
	0A47    91  SWAP2
	0A48    52  MSTORE
	0A49    55  SSTORE
	0A4A    56  *JUMP
	// Stack delta = -4
	// Outputs[3]
	// {
	//     @0A44  memory[0x00:0x20] = code[0x1c87:0x1ca7]
	//     @0A48  memory[0x00:0x20] = memory[0x00:0x20]
	//     @0A49  storage[memory[0x00:0x20]] = 0x00
	// }
	// Block ends with unconditional jump to 0x0a4b

label_0A4B:
	// Incoming jump from 0x1C81, if stack[-1] == stack[-1] & (0x01 << 0x60) - 0x01
	// Incoming jump from 0x0A4A
	// Incoming jump from 0x1C5D, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01
	// Inputs[1] { @0A4D  stack[-2] }
	0A4B    5B  JUMPDEST
	0A4C    50  POP
	0A4D    56  *JUMP
	// Stack delta = -2
	// Block ends with unconditional jump to stack[-2]

label_0A4E:
	// Incoming jump from 0x00F6
	// Inputs[4]
	// {
	//     @0A51  stack[-1]
	//     @0A62  memory[0x40:0x60]
	//     @0A76  memory[0x40:0x60]
	//     @0A7D  address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// }
	0A4E    5B  JUMPDEST
	0A4F    60  PUSH1 0x00
	0A51    81  DUP2
	0A52    60  PUSH1 0x01
	0A54    60  PUSH1 0x01
	0A56    60  PUSH1 0xa0
	0A58    1B  SHL
	0A59    03  SUB
	0A5A    16  AND
	0A5B    63  PUSH4 0x0dfe1681
	0A60    60  PUSH1 0x40
	0A62    51  MLOAD
	0A63    81  DUP2
	0A64    63  PUSH4 0xffffffff
	0A69    16  AND
	0A6A    60  PUSH1 0xe0
	0A6C    1B  SHL
	0A6D    81  DUP2
	0A6E    52  MSTORE
	0A6F    60  PUSH1 0x04
	0A71    01  ADD
	0A72    60  PUSH1 0x20
	0A74    60  PUSH1 0x40
	0A76    51  MLOAD
	0A77    80  DUP1
	0A78    83  DUP4
	0A79    03  SUB
	0A7A    81  DUP2
	0A7B    86  DUP7
	0A7C    80  DUP1
	0A7D    3B  EXTCODESIZE
	0A7E    15  ISZERO
	0A7F    80  DUP1
	0A80    15  ISZERO
	0A81    61  PUSH2 0x0a89
	0A84    57  *JUMPI
	// Stack delta = +10
	// Outputs[11]
	// {
	//     @0A4F  stack[0] = 0x00
	//     @0A5A  stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @0A5B  stack[2] = 0x0dfe1681
	//     @0A6E  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0
	//     @0A71  stack[3] = 0x04 + memory[0x40:0x60]
	//     @0A72  stack[4] = 0x20
	//     @0A76  stack[5] = memory[0x40:0x60]
	//     @0A79  stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0A7A  stack[7] = memory[0x40:0x60]
	//     @0A7B  stack[8] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @0A7E  stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// }
	// Block ends with conditional jump to 0x0a89, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length

label_0A85:
	// Incoming jump from 0x0A84, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// Inputs[1] { @0A88  memory[0x00:0x00] }
	0A85    60  PUSH1 0x00
	0A87    80  DUP1
	0A88    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0A88  revert(memory[0x00:0x00]); }
	// Block terminates

label_0A89:
	// Incoming jump from 0x0A84, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// Inputs[8]
	// {
	//     @0A8B  msg.gas
	//     @0A8C  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0A8C  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @0A8C  stack[-5]
	//     @0A8C  stack[-2]
	//     @0A8C  stack[-4]
	//     @0A8C  stack[-6]
	//     @0A8C  stack[-3]
	// }
	0A89    5B  JUMPDEST
	0A8A    50  POP
	0A8B    5A  GAS
	0A8C    FA  STATICCALL
	0A8D    15  ISZERO
	0A8E    80  DUP1
	0A8F    15  ISZERO
	0A90    61  PUSH2 0x0a9d
	0A93    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0A8C  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0A8D  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x0a9d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_0A94:
	// Incoming jump from 0x0A93, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @0A94  returndata.length
	//     @0A98  returndata[0x00:0x00 + returndata.length]
	//     @0A99  returndata.length
	//     @0A9C  memory[0x00:0x00 + returndata.length]
	// }
	0A94    3D  RETURNDATASIZE
	0A95    60  PUSH1 0x00
	0A97    80  DUP1
	0A98    3E  RETURNDATACOPY
	0A99    3D  RETURNDATASIZE
	0A9A    60  PUSH1 0x00
	0A9C    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0A98  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0A9C  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0A9D:
	// Incoming jump from 0x0A93, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @0AA4  memory[0x40:0x60]
	//     @0AA5  returndata.length
	// }
	0A9D    5B  JUMPDEST
	0A9E    50  POP
	0A9F    50  POP
	0AA0    50  POP
	0AA1    50  POP
	0AA2    60  PUSH1 0x40
	0AA4    51  MLOAD
	0AA5    3D  RETURNDATASIZE
	0AA6    60  PUSH1 0x1f
	0AA8    19  NOT
	0AA9    60  PUSH1 0x1f
	0AAB    82  DUP3
	0AAC    01  ADD
	0AAD    16  AND
	0AAE    82  DUP3
	0AAF    01  ADD
	0AB0    80  DUP1
	0AB1    60  PUSH1 0x40
	0AB3    52  MSTORE
	0AB4    50  POP
	0AB5    81  DUP2
	0AB6    01  ADD
	0AB7    90  SWAP1
	0AB8    61  PUSH2 0x0ac1
	0ABB    91  SWAP2
	0ABC    90  SWAP1
	0ABD    61  PUSH2 0x16ca
	0AC0    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @0AB3  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @0ABB  stack[-4] = 0x0ac1
	//     @0ABC  stack[-2] = memory[0x40:0x60]
	//     @0ABC  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with unconditional jump to 0x16ca

	0AC1    5B    JUMPDEST
	0AC2    90    SWAP1
	0AC3    50    POP
	0AC4    60    PUSH1 0x00
	0AC6    82    DUP3
	0AC7    60    PUSH1 0x01
	0AC9    60    PUSH1 0x01
	0ACB    60    PUSH1 0xa0
	0ACD    1B    SHL
	0ACE    03    SUB
	0ACF    16    AND
	0AD0    63    PUSH4 0xd21220a7
	0AD5    60    PUSH1 0x40
	0AD7    51    MLOAD
	0AD8    81    DUP2
	0AD9    63    PUSH4 0xffffffff
	0ADE    16    AND
	0ADF    60    PUSH1 0xe0
	0AE1    1B    SHL
	0AE2    81    DUP2
	0AE3    52    MSTORE
	0AE4    60    PUSH1 0x04
	0AE6    01    ADD
	0AE7    60    PUSH1 0x20
	0AE9    60    PUSH1 0x40
	0AEB    51    MLOAD
	0AEC    80    DUP1
	0AED    83    DUP4
	0AEE    03    SUB
	0AEF    81    DUP2
	0AF0    86    DUP7
	0AF1    80    DUP1
	0AF2    3B    EXTCODESIZE
	0AF3    15    ISZERO
	0AF4    80    DUP1
	0AF5    15    ISZERO
	0AF6    61    PUSH2 0x0afe
	0AF9    57    *JUMPI
	0AFA    60    PUSH1 0x00
	0AFC    80    DUP1
	0AFD    FD    *REVERT
	0AFE    5B    JUMPDEST
	0AFF    50    POP
	0B00    5A    GAS
	0B01    FA    STATICCALL
	0B02    15    ISZERO
	0B03    80    DUP1
	0B04    15    ISZERO
	0B05    61    PUSH2 0x0b12
	0B08    57    *JUMPI
	0B09    3D    RETURNDATASIZE
	0B0A    60    PUSH1 0x00
	0B0C    80    DUP1
	0B0D    3E    RETURNDATACOPY
	0B0E    3D    RETURNDATASIZE
	0B0F    60    PUSH1 0x00
	0B11    FD    *REVERT
	0B12    5B    JUMPDEST
	0B13    50    POP
	0B14    50    POP
	0B15    50    POP
	0B16    50    POP
	0B17    60    PUSH1 0x40
	0B19    51    MLOAD
	0B1A    3D    RETURNDATASIZE
	0B1B    60    PUSH1 0x1f
	0B1D    19    NOT
	0B1E    60    PUSH1 0x1f
	0B20    82    DUP3
	0B21    01    ADD
	0B22    16    AND
	0B23    82    DUP3
	0B24    01    ADD
	0B25    80    DUP1
	0B26    60    PUSH1 0x40
	0B28    52    MSTORE
	0B29    50    POP
	0B2A    81    DUP2
	0B2B    01    ADD
	0B2C    90    SWAP1
	0B2D    61    PUSH2 0x0b36
	0B30    91    SWAP2
	0B31    90    SWAP1
	0B32    61    PUSH2 0x16ca
	0B35    56    *JUMP
	0B36    5B    JUMPDEST
	0B37    90    SWAP1
	0B38    50    POP
	0B39    61    PUSH2 0x0b5e
	0B3C    82    DUP3
	0B3D    73    PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0B52    60    PUSH1 0x01
	0B54    60    PUSH1 0x01
	0B56    60    PUSH1 0x60
	0B58    1B    SHL
	0B59    03    SUB
	0B5A    61    PUSH2 0x143b
	0B5D    56    *JUMP
	0B5E    5B    JUMPDEST
	0B5F    61    PUSH2 0x0b84
	0B62    81    DUP2
	0B63    73    PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	0B78    60    PUSH1 0x01
	0B7A    60    PUSH1 0x01
	0B7C    60    PUSH1 0x60
	0B7E    1B    SHL
	0B7F    03    SUB
	0B80    61    PUSH2 0x143b
	0B83    56    *JUMP
	0B84    5B    JUMPDEST
	0B85    50    POP
	0B86    50    POP
	0B87    50    POP
	0B88    56    *JUMP
label_0B89:
	// Incoming jump from 0x0109
	// Inputs[2]
	// {
	//     @0B8A  block.timestamp
	//     @0B90  stack[-1]
	// }
	0B89    5B  JUMPDEST
	0B8A    42  TIMESTAMP
	0B8B    61  PUSH2 0x0b97
	0B8E    60  PUSH1 0x20
	0B90    83  DUP4
	0B91    01  ADD
	0B92    83  DUP4
	0B93    61  PUSH2 0x188a
	0B96    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0B8A  stack[0] = block.timestamp
	//     @0B8B  stack[1] = 0x0b97
	//     @0B91  stack[2] = stack[-1] + 0x20
	//     @0B92  stack[3] = stack[-1]
	// }
	// Block ends with call to 0x188a, returns to 0x0B97

label_0B97:
	// Incoming return from call to 0x188A at 0x0B96
	// Inputs[2]
	// {
	//     @0BA1  stack[-1]
	//     @0BA2  stack[-2]
	// }
	0B97    5B  JUMPDEST
	0B98    67  PUSH8 0xffffffffffffffff
	0BA1    16  AND
	0BA2    11  GT
	0BA3    61  PUSH2 0x0bab
	0BA6    57  *JUMPI
	// Stack delta = -2
	// Block ends with conditional jump to 0x0bab, if 0xffffffffffffffff & stack[-1] > stack[-2]

label_0BA7:
	// Incoming jump from 0x0BA6, if not 0xffffffffffffffff & stack[-1] > stack[-2]
	// Inputs[1] { @0BAA  memory[0x00:0x00] }
	0BA7    60  PUSH1 0x00
	0BA9    80  DUP1
	0BAA    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0BAA  revert(memory[0x00:0x00]); }
	// Block terminates

label_0BAB:
	// Incoming jump from 0x0BA6, if 0xffffffffffffffff & stack[-1] > stack[-2]
	// Inputs[3]
	// {
	//     @0BAF  memory[0x00:0x20]
	//     @0BB8  memory[0x00:0x20]
	//     @0BBB  storage[memory[0x00:0x20]]
	// }
	0BAB    5B  JUMPDEST
	0BAC    60  PUSH1 0x00
	0BAE    80  DUP1
	0BAF    51  MLOAD
	0BB0    60  PUSH1 0x20
	0BB2    61  PUSH2 0x1c87
	0BB5    83  DUP4
	0BB6    39  CODECOPY
	0BB7    81  DUP2
	0BB8    51  MLOAD
	0BB9    91  SWAP2
	0BBA    52  MSTORE
	0BBB    54  SLOAD
	0BBC    15  ISZERO
	0BBD    61  PUSH2 0x0bc5
	0BC0    57  *JUMPI
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0BB6  memory[0x00:0x20] = code[0x1c87:0x1ca7]
	//     @0BBA  memory[0x00:0x20] = memory[0x00:0x20]
	// }
	// Block ends with conditional jump to 0x0bc5, if !storage[memory[0x00:0x20]]

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

label_0BC5:
	// Incoming jump from 0x0BC0, if !storage[memory[0x00:0x20]]
	// Inputs[1] { @0BCD  stack[-1] }
	0BC5    5B  JUMPDEST
	0BC6    60  PUSH1 0x00
	0BC8    61  PUSH2 0x0bd7
	0BCB    60  PUSH1 0x60
	0BCD    83  DUP4
	0BCE    01  ADD
	0BCF    60  PUSH1 0x40
	0BD1    84  DUP5
	0BD2    01  ADD
	0BD3    61  PUSH2 0x16ad
	0BD6    56  *JUMP
	// Stack delta = +4
	// Outputs[4]
	// {
	//     @0BC6  stack[0] = 0x00
	//     @0BC8  stack[1] = 0x0bd7
	//     @0BCE  stack[2] = stack[-1] + 0x60
	//     @0BD2  stack[3] = stack[-1] + 0x40
	// }
	// Block ends with call to 0x16ad, returns to 0x0BD7

label_0BD7:
	// Incoming return from call to 0x16AD at 0x0BD6
	// Inputs[4]
	// {
	//     @0BE0  stack[-1]
	//     @0BE8  memory[0x40:0x60]
	//     @0BFC  memory[0x40:0x60]
	//     @0C03  address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// }
	0BD7    5B  JUMPDEST
	0BD8    60  PUSH1 0x01
	0BDA    60  PUSH1 0x01
	0BDC    60  PUSH1 0xa0
	0BDE    1B  SHL
	0BDF    03  SUB
	0BE0    16  AND
	0BE1    63  PUSH4 0x0dfe1681
	0BE6    60  PUSH1 0x40
	0BE8    51  MLOAD
	0BE9    81  DUP2
	0BEA    63  PUSH4 0xffffffff
	0BEF    16  AND
	0BF0    60  PUSH1 0xe0
	0BF2    1B  SHL
	0BF3    81  DUP2
	0BF4    52  MSTORE
	0BF5    60  PUSH1 0x04
	0BF7    01  ADD
	0BF8    60  PUSH1 0x20
	0BFA    60  PUSH1 0x40
	0BFC    51  MLOAD
	0BFD    80  DUP1
	0BFE    83  DUP4
	0BFF    03  SUB
	0C00    81  DUP2
	0C01    86  DUP7
	0C02    80  DUP1
	0C03    3B  EXTCODESIZE
	0C04    15  ISZERO
	0C05    80  DUP1
	0C06    15  ISZERO
	0C07    61  PUSH2 0x0c0f
	0C0A    57  *JUMPI
	// Stack delta = +8
	// Outputs[10]
	// {
	//     @0BE0  stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @0BE1  stack[0] = 0x0dfe1681
	//     @0BF4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0
	//     @0BF7  stack[1] = 0x04 + memory[0x40:0x60]
	//     @0BF8  stack[2] = 0x20
	//     @0BFC  stack[3] = memory[0x40:0x60]
	//     @0BFF  stack[4] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0C00  stack[5] = memory[0x40:0x60]
	//     @0C01  stack[6] = (0x01 << 0xa0) - 0x01 & stack[-1]
	//     @0C04  stack[7] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// }
	// Block ends with conditional jump to 0x0c0f, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length

label_0C0B:
	// Incoming jump from 0x0C0A, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// Inputs[1] { @0C0E  memory[0x00:0x00] }
	0C0B    60  PUSH1 0x00
	0C0D    80  DUP1
	0C0E    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0C0E  revert(memory[0x00:0x00]); }
	// Block terminates

label_0C0F:
	// Incoming jump from 0x0C0A, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length
	// Inputs[8]
	// {
	//     @0C11  msg.gas
	//     @0C12  stack[-6]
	//     @0C12  stack[-2]
	//     @0C12  stack[-5]
	//     @0C12  stack[-4]
	//     @0C12  address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0C12  memory[stack[-3]:stack[-3] + stack[-4]]
	//     @0C12  stack[-3]
	// }
	0C0F    5B  JUMPDEST
	0C10    50  POP
	0C11    5A  GAS
	0C12    FA  STATICCALL
	0C13    15  ISZERO
	0C14    80  DUP1
	0C15    15  ISZERO
	0C16    61  PUSH2 0x0c23
	0C19    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @0C12  memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	//     @0C13  stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// }
	// Block ends with conditional jump to 0x0c23, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])

label_0C1A:
	// Incoming jump from 0x0C19, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[4]
	// {
	//     @0C1A  returndata.length
	//     @0C1E  returndata[0x00:0x00 + returndata.length]
	//     @0C1F  returndata.length
	//     @0C22  memory[0x00:0x00 + returndata.length]
	// }
	0C1A    3D  RETURNDATASIZE
	0C1B    60  PUSH1 0x00
	0C1D    80  DUP1
	0C1E    3E  RETURNDATACOPY
	0C1F    3D  RETURNDATASIZE
	0C20    60  PUSH1 0x00
	0C22    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0C1E  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0C22  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0C23:
	// Incoming jump from 0x0C19, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]])
	// Inputs[2]
	// {
	//     @0C2A  memory[0x40:0x60]
	//     @0C2B  returndata.length
	// }
	0C23    5B  JUMPDEST
	0C24    50  POP
	0C25    50  POP
	0C26    50  POP
	0C27    50  POP
	0C28    60  PUSH1 0x40
	0C2A    51  MLOAD
	0C2B    3D  RETURNDATASIZE
	0C2C    60  PUSH1 0x1f
	0C2E    19  NOT
	0C2F    60  PUSH1 0x1f
	0C31    82  DUP3
	0C32    01  ADD
	0C33    16  AND
	0C34    82  DUP3
	0C35    01  ADD
	0C36    80  DUP1
	0C37    60  PUSH1 0x40
	0C39    52  MSTORE
	0C3A    50  POP
	0C3B    81  DUP2
	0C3C    01  ADD
	0C3D    90  SWAP1
	0C3E    61  PUSH2 0x0c47
	0C41    91  SWAP2
	0C42    90  SWAP1
	0C43    61  PUSH2 0x16ca
	0C46    56  *JUMP
	// Stack delta = -1
	// Outputs[4]
	// {
	//     @0C39  memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f)
	//     @0C41  stack[-4] = 0x0c47
	//     @0C42  stack[-2] = memory[0x40:0x60]
	//     @0C42  stack[-3] = memory[0x40:0x60] + returndata.length
	// }
	// Block ends with unconditional jump to 0x16ca

	0C47    5B    JUMPDEST
	0C48    90    SWAP1
	0C49    50    POP
	0C4A    60    PUSH1 0x00
	0C4C    61    PUSH2 0x0c5b
	0C4F    60    PUSH1 0x60
	0C51    84    DUP5
	0C52    01    ADD
	0C53    60    PUSH1 0x40
	0C55    85    DUP6
	0C56    01    ADD
	0C57    61    PUSH2 0x16ad
	0C5A    56    *JUMP
	0C5B    5B    JUMPDEST
	0C5C    60    PUSH1 0x01
	0C5E    60    PUSH1 0x01
	0C60    60    PUSH1 0xa0
	0C62    1B    SHL
	0C63    03    SUB
	0C64    16    AND
	0C65    63    PUSH4 0xd21220a7
	0C6A    60    PUSH1 0x40
	0C6C    51    MLOAD
	0C6D    81    DUP2
	0C6E    63    PUSH4 0xffffffff
	0C73    16    AND
	0C74    60    PUSH1 0xe0
	0C76    1B    SHL
	0C77    81    DUP2
	0C78    52    MSTORE
	0C79    60    PUSH1 0x04
	0C7B    01    ADD
	0C7C    60    PUSH1 0x20
	0C7E    60    PUSH1 0x40
	0C80    51    MLOAD
	0C81    80    DUP1
	0C82    83    DUP4
	0C83    03    SUB
	0C84    81    DUP2
	0C85    86    DUP7
	0C86    80    DUP1
	0C87    3B    EXTCODESIZE
	0C88    15    ISZERO
	0C89    80    DUP1
	0C8A    15    ISZERO
	0C8B    61    PUSH2 0x0c93
	0C8E    57    *JUMPI
	0C8F    60    PUSH1 0x00
	0C91    80    DUP1
	0C92    FD    *REVERT
	0C93    5B    JUMPDEST
	0C94    50    POP
	0C95    5A    GAS
	0C96    FA    STATICCALL
	0C97    15    ISZERO
	0C98    80    DUP1
	0C99    15    ISZERO
	0C9A    61    PUSH2 0x0ca7
	0C9D    57    *JUMPI
	0C9E    3D    RETURNDATASIZE
	0C9F    60    PUSH1 0x00
	0CA1    80    DUP1
	0CA2    3E    RETURNDATACOPY
	0CA3    3D    RETURNDATASIZE
	0CA4    60    PUSH1 0x00
	0CA6    FD    *REVERT
	0CA7    5B    JUMPDEST
	0CA8    50    POP
	0CA9    50    POP
	0CAA    50    POP
	0CAB    50    POP
	0CAC    60    PUSH1 0x40
	0CAE    51    MLOAD
	0CAF    3D    RETURNDATASIZE
	0CB0    60    PUSH1 0x1f
	0CB2    19    NOT
	0CB3    60    PUSH1 0x1f
	0CB5    82    DUP3
	0CB6    01    ADD
	0CB7    16    AND
	0CB8    82    DUP3
	0CB9    01    ADD
	0CBA    80    DUP1
	0CBB    60    PUSH1 0x40
	0CBD    52    MSTORE
	0CBE    50    POP
	0CBF    81    DUP2
	0CC0    01    ADD
	0CC1    90    SWAP1
	0CC2    61    PUSH2 0x0ccb
	0CC5    91    SWAP2
	0CC6    90    SWAP1
	0CC7    61    PUSH2 0x16ca
	0CCA    56    *JUMP
	0CCB    5B    JUMPDEST
	0CCC    90    SWAP1
	0CCD    50    POP
	0CCE    60    PUSH1 0x00
	0CD0    80    DUP1
	0CD1    80    DUP1
	0CD2    61    PUSH2 0x0ce2
	0CD5    61    PUSH2 0x0100
	0CD8    87    DUP8
	0CD9    01    ADD
	0CDA    60    PUSH1 0xe0
	0CDC    88    DUP9
	0CDD    01    ADD
	0CDE    61    PUSH2 0x171d
	0CE1    56    *JUMP
	0CE2    5B    JUMPDEST
	0CE3    60    PUSH1 0x00
	0CE5    0B    SIGNEXTEND
	0CE6    12    SLT
	0CE7    61    PUSH2 0x0da9
	0CEA    57    *JUMPI
	0CEB    60    PUSH1 0x01
	0CED    60    PUSH1 0x01
	0CEF    60    PUSH1 0x01
	0CF1    60    PUSH1 0xa0
	0CF3    1B    SHL
	0CF4    03    SUB
	0CF5    85    DUP6
	0CF6    16    AND
	0CF7    63    PUSH4 0x70a08231
	0CFC    61    PUSH2 0x0d0b
	0CFF    60    PUSH1 0x40
	0D01    89    DUP10
	0D02    01    ADD
	0D03    60    PUSH1 0x20
	0D05    8A    DUP11
	0D06    01    ADD
	0D07    61    PUSH2 0x16ad
	0D0A    56    *JUMP
	0D0B    5B    JUMPDEST
	0D0C    60    PUSH1 0x40
	0D0E    51    MLOAD
	0D0F    60    PUSH1 0x01
	0D11    60    PUSH1 0x01
	0D13    60    PUSH1 0xe0
	0D15    1B    SHL
	0D16    03    SUB
	0D17    19    NOT
	0D18    60    PUSH1 0xe0
	0D1A    84    DUP5
	0D1B    90    SWAP1
	0D1C    1B    SHL
	0D1D    16    AND
	0D1E    81    DUP2
	0D1F    52    MSTORE
	0D20    60    PUSH1 0x01
	0D22    60    PUSH1 0x01
	0D24    60    PUSH1 0xa0
	0D26    1B    SHL
	0D27    03    SUB
	0D28    90    SWAP1
	0D29    91    SWAP2
	0D2A    16    AND
	0D2B    60    PUSH1 0x04
	0D2D    82    DUP3
	0D2E    01    ADD
	0D2F    52    MSTORE
	0D30    60    PUSH1 0x24
	0D32    01    ADD
	0D33    60    PUSH1 0x20
	0D35    60    PUSH1 0x40
	0D37    51    MLOAD
	0D38    80    DUP1
	0D39    83    DUP4
	0D3A    03    SUB
	0D3B    81    DUP2
	0D3C    86    DUP7
	0D3D    80    DUP1
	0D3E    3B    EXTCODESIZE
	0D3F    15    ISZERO
	0D40    80    DUP1
	0D41    15    ISZERO
	0D42    61    PUSH2 0x0d4a
	0D45    57    *JUMPI
	0D46    60    PUSH1 0x00
	0D48    80    DUP1
	0D49    FD    *REVERT
	0D4A    5B    JUMPDEST
	0D4B    50    POP
	0D4C    5A    GAS
	0D4D    FA    STATICCALL
	0D4E    15    ISZERO
	0D4F    80    DUP1
	0D50    15    ISZERO
	0D51    61    PUSH2 0x0d5e
	0D54    57    *JUMPI
	0D55    3D    RETURNDATASIZE
	0D56    60    PUSH1 0x00
	0D58    80    DUP1
	0D59    3E    RETURNDATACOPY
	0D5A    3D    RETURNDATASIZE
	0D5B    60    PUSH1 0x00
	0D5D    FD    *REVERT
	0D5E    5B    JUMPDEST
	0D5F    50    POP
	0D60    50    POP
	0D61    50    POP
	0D62    50    POP
	0D63    60    PUSH1 0x40
	0D65    51    MLOAD
	0D66    3D    RETURNDATASIZE
	0D67    60    PUSH1 0x1f
	0D69    19    NOT
	0D6A    60    PUSH1 0x1f
	0D6C    82    DUP3
	0D6D    01    ADD
	0D6E    16    AND
	0D6F    82    DUP3
	0D70    01    ADD
	0D71    80    DUP1
	0D72    60    PUSH1 0x40
	0D74    52    MSTORE
	0D75    50    POP
	0D76    81    DUP2
	0D77    01    ADD
	0D78    90    SWAP1
	0D79    61    PUSH2 0x0d82
	0D7C    91    SWAP2
	0D7D    90    SWAP1
	0D7E    61    PUSH2 0x1811
	0D81    56    *JUMP
	0D82    5B    JUMPDEST
	0D83    61    PUSH2 0x0d8c
	0D86    91    SWAP2
	0D87    90    SWAP1
	0D88    61    PUSH2 0x1bed
	0D8B    56    *JUMP
	0D8C    5B    JUMPDEST
	0D8D    91    SWAP2
	0D8E    50    POP
	0D8F    61    PUSH2 0x0da9
	0D92    84    DUP5
	0D93    61    PUSH2 0x0da2
	0D96    60    PUSH1 0x40
	0D98    88    DUP9
	0D99    01    ADD
	0D9A    60    PUSH1 0x20
	0D9C    89    DUP10
	0D9D    01    ADD
	0D9E    61    PUSH2 0x16ad
	0DA1    56    *JUMP
	0DA2    5B    JUMPDEST
	0DA3    30    ADDRESS
	0DA4    85    DUP6
	0DA5    61    PUSH2 0x150c
	0DA8    56    *JUMP
	0DA9    5B    JUMPDEST
	0DAA    60    PUSH1 0x00
	0DAC    61    PUSH2 0x0dbc
	0DAF    61    PUSH2 0x0100
	0DB2    87    DUP8
	0DB3    01    ADD
	0DB4    60    PUSH1 0xe0
	0DB6    88    DUP9
	0DB7    01    ADD
	0DB8    61    PUSH2 0x171d
	0DBB    56    *JUMP
	0DBC    5B    JUMPDEST
	0DBD    60    PUSH1 0x00
	0DBF    0B    SIGNEXTEND
	0DC0    13    SGT
	0DC1    61    PUSH2 0x0e83
	0DC4    57    *JUMPI
	0DC5    60    PUSH1 0x01
	0DC7    60    PUSH1 0x01
	0DC9    60    PUSH1 0x01
	0DCB    60    PUSH1 0xa0
	0DCD    1B    SHL
	0DCE    03    SUB
	0DCF    84    DUP5
	0DD0    16    AND
	0DD1    63    PUSH4 0x70a08231
	0DD6    61    PUSH2 0x0de5
	0DD9    60    PUSH1 0x40
	0DDB    89    DUP10
	0DDC    01    ADD
	0DDD    60    PUSH1 0x20
	0DDF    8A    DUP11
	0DE0    01    ADD
	0DE1    61    PUSH2 0x16ad
	0DE4    56    *JUMP
	0DE5    5B    JUMPDEST
	0DE6    60    PUSH1 0x40
	0DE8    51    MLOAD
	0DE9    60    PUSH1 0x01
	0DEB    60    PUSH1 0x01
	0DED    60    PUSH1 0xe0
	0DEF    1B    SHL
	0DF0    03    SUB
	0DF1    19    NOT
	0DF2    60    PUSH1 0xe0
	0DF4    84    DUP5
	0DF5    90    SWAP1
	0DF6    1B    SHL
	0DF7    16    AND
	0DF8    81    DUP2
	0DF9    52    MSTORE
	0DFA    60    PUSH1 0x01
	0DFC    60    PUSH1 0x01
	0DFE    60    PUSH1 0xa0
	0E00    1B    SHL
	0E01    03    SUB
	0E02    90    SWAP1
	0E03    91    SWAP2
	0E04    16    AND
	0E05    60    PUSH1 0x04
	0E07    82    DUP3
	0E08    01    ADD
	0E09    52    MSTORE
	0E0A    60    PUSH1 0x24
	0E0C    01    ADD
	0E0D    60    PUSH1 0x20
	0E0F    60    PUSH1 0x40
	0E11    51    MLOAD
	0E12    80    DUP1
	0E13    83    DUP4
	0E14    03    SUB
	0E15    81    DUP2
	0E16    86    DUP7
	0E17    80    DUP1
	0E18    3B    EXTCODESIZE
	0E19    15    ISZERO
	0E1A    80    DUP1
	0E1B    15    ISZERO
	0E1C    61    PUSH2 0x0e24
	0E1F    57    *JUMPI
	0E20    60    PUSH1 0x00
	0E22    80    DUP1
	0E23    FD    *REVERT
	0E24    5B    JUMPDEST
	0E25    50    POP
	0E26    5A    GAS
	0E27    FA    STATICCALL
	0E28    15    ISZERO
	0E29    80    DUP1
	0E2A    15    ISZERO
	0E2B    61    PUSH2 0x0e38
	0E2E    57    *JUMPI
	0E2F    3D    RETURNDATASIZE
	0E30    60    PUSH1 0x00
	0E32    80    DUP1
	0E33    3E    RETURNDATACOPY
	0E34    3D    RETURNDATASIZE
	0E35    60    PUSH1 0x00
	0E37    FD    *REVERT
	0E38    5B    JUMPDEST
	0E39    50    POP
	0E3A    50    POP
	0E3B    50    POP
	0E3C    50    POP
	0E3D    60    PUSH1 0x40
	0E3F    51    MLOAD
	0E40    3D    RETURNDATASIZE
	0E41    60    PUSH1 0x1f
	0E43    19    NOT
	0E44    60    PUSH1 0x1f
	0E46    82    DUP3
	0E47    01    ADD
	0E48    16    AND
	0E49    82    DUP3
	0E4A    01    ADD
	0E4B    80    DUP1
	0E4C    60    PUSH1 0x40
	0E4E    52    MSTORE
	0E4F    50    POP
	0E50    81    DUP2
	0E51    01    ADD
	0E52    90    SWAP1
	0E53    61    PUSH2 0x0e5c
	0E56    91    SWAP2
	0E57    90    SWAP1
	0E58    61    PUSH2 0x1811
	0E5B    56    *JUMP
	0E5C    5B    JUMPDEST
	0E5D    61    PUSH2 0x0e66
	0E60    91    SWAP2
	0E61    90    SWAP1
	0E62    61    PUSH2 0x1bed
	0E65    56    *JUMP
	0E66    5B    JUMPDEST
	0E67    90    SWAP1
	0E68    50    POP
	0E69    61    PUSH2 0x0e83
	0E6C    83    DUP4
	0E6D    61    PUSH2 0x0e7c
	0E70    60    PUSH1 0x40
	0E72    88    DUP9
	0E73    01    ADD
	0E74    60    PUSH1 0x20
	0E76    89    DUP10
	0E77    01    ADD
	0E78    61    PUSH2 0x16ad
	0E7B    56    *JUMP
	0E7C    5B    JUMPDEST
	0E7D    30    ADDRESS
	0E7E    84    DUP5
	0E7F    61    PUSH2 0x150c
	0E82    56    *JUMP
	0E83    5B    JUMPDEST
	0E84    60    PUSH1 0x00
	0E86    61    PUSH2 0x0e95
	0E89    60    PUSH1 0x60
	0E8B    87    DUP8
	0E8C    01    ADD
	0E8D    60    PUSH1 0x40
	0E8F    88    DUP9
	0E90    01    ADD
	0E91    61    PUSH2 0x16ad
	0E94    56    *JUMP
	0E95    5B    JUMPDEST
	0E96    60    PUSH1 0x01
	0E98    60    PUSH1 0x01
	0E9A    60    PUSH1 0xa0
	0E9C    1B    SHL
	0E9D    03    SUB
	0E9E    16    AND
	0E9F    63    PUSH4 0xddca3f43
	0EA4    60    PUSH1 0x40
	0EA6    51    MLOAD
	0EA7    81    DUP2
	0EA8    63    PUSH4 0xffffffff
	0EAD    16    AND
	0EAE    60    PUSH1 0xe0
	0EB0    1B    SHL
	0EB1    81    DUP2
	0EB2    52    MSTORE
	0EB3    60    PUSH1 0x04
	0EB5    01    ADD
	0EB6    60    PUSH1 0x20
	0EB8    60    PUSH1 0x40
	0EBA    51    MLOAD
	0EBB    80    DUP1
	0EBC    83    DUP4
	0EBD    03    SUB
	0EBE    81    DUP2
	0EBF    86    DUP7
	0EC0    80    DUP1
	0EC1    3B    EXTCODESIZE
	0EC2    15    ISZERO
	0EC3    80    DUP1
	0EC4    15    ISZERO
	0EC5    61    PUSH2 0x0ecd
	0EC8    57    *JUMPI
	0EC9    60    PUSH1 0x00
	0ECB    80    DUP1
	0ECC    FD    *REVERT
	0ECD    5B    JUMPDEST
	0ECE    50    POP
	0ECF    5A    GAS
	0ED0    FA    STATICCALL
	0ED1    15    ISZERO
	0ED2    80    DUP1
	0ED3    15    ISZERO
	0ED4    61    PUSH2 0x0ee1
	0ED7    57    *JUMPI
	0ED8    3D    RETURNDATASIZE
	0ED9    60    PUSH1 0x00
	0EDB    80    DUP1
	0EDC    3E    RETURNDATACOPY
	0EDD    3D    RETURNDATASIZE
	0EDE    60    PUSH1 0x00
	0EE0    FD    *REVERT
	0EE1    5B    JUMPDEST
	0EE2    50    POP
	0EE3    50    POP
	0EE4    50    POP
	0EE5    50    POP
	0EE6    60    PUSH1 0x40
	0EE8    51    MLOAD
	0EE9    3D    RETURNDATASIZE
	0EEA    60    PUSH1 0x1f
	0EEC    19    NOT
	0EED    60    PUSH1 0x1f
	0EEF    82    DUP3
	0EF0    01    ADD
	0EF1    16    AND
	0EF2    82    DUP3
	0EF3    01    ADD
	0EF4    80    DUP1
	0EF5    60    PUSH1 0x40
	0EF7    52    MSTORE
	0EF8    50    POP
	0EF9    81    DUP2
	0EFA    01    ADD
	0EFB    90    SWAP1
	0EFC    61    PUSH2 0x0f05
	0EFF    91    SWAP2
	0F00    90    SWAP1
	0F01    61    PUSH2 0x17f6
	0F04    56    *JUMP
	0F05    5B    JUMPDEST
	0F06    90    SWAP1
	0F07    50    POP
	0F08    60    PUSH1 0x00
	0F0A    61    PUSH2 0x0f19
	0F0D    60    PUSH1 0x60
	0F0F    88    DUP9
	0F10    01    ADD
	0F11    60    PUSH1 0x40
	0F13    89    DUP10
	0F14    01    ADD
	0F15    61    PUSH2 0x16ad
	0F18    56    *JUMP
	0F19    5B    JUMPDEST
	0F1A    60    PUSH1 0x01
	0F1C    60    PUSH1 0x01
	0F1E    60    PUSH1 0xa0
	0F20    1B    SHL
	0F21    03    SUB
	0F22    16    AND
	0F23    63    PUSH4 0xd0c93a7c
	0F28    60    PUSH1 0x40
	0F2A    51    MLOAD
	0F2B    81    DUP2
	0F2C    63    PUSH4 0xffffffff
	0F31    16    AND
	0F32    60    PUSH1 0xe0
	0F34    1B    SHL
	0F35    81    DUP2
	0F36    52    MSTORE
	0F37    60    PUSH1 0x04
	0F39    01    ADD
	0F3A    60    PUSH1 0x20
	0F3C    60    PUSH1 0x40
	0F3E    51    MLOAD
	0F3F    80    DUP1
	0F40    83    DUP4
	0F41    03    SUB
	0F42    81    DUP2
	0F43    86    DUP7
	0F44    80    DUP1
	0F45    3B    EXTCODESIZE
	0F46    15    ISZERO
	0F47    80    DUP1
	0F48    15    ISZERO
	0F49    61    PUSH2 0x0f51
	0F4C    57    *JUMPI
	0F4D    60    PUSH1 0x00
	0F4F    80    DUP1
	0F50    FD    *REVERT
	0F51    5B    JUMPDEST
	0F52    50    POP
	0F53    5A    GAS
	0F54    FA    STATICCALL
	0F55    15    ISZERO
	0F56    80    DUP1
	0F57    15    ISZERO
	0F58    61    PUSH2 0x0f65
	0F5B    57    *JUMPI
	0F5C    3D    RETURNDATASIZE
	0F5D    60    PUSH1 0x00
	0F5F    80    DUP1
	0F60    3E    RETURNDATACOPY
	0F61    3D    RETURNDATASIZE
	0F62    60    PUSH1 0x00
	0F64    FD    *REVERT
	0F65    5B    JUMPDEST
	0F66    50    POP
	0F67    50    POP
	0F68    50    POP
	0F69    50    POP
	0F6A    60    PUSH1 0x40
	0F6C    51    MLOAD
	0F6D    3D    RETURNDATASIZE
	0F6E    60    PUSH1 0x1f
	0F70    19    NOT
	0F71    60    PUSH1 0x1f
	0F73    82    DUP3
	0F74    01    ADD
	0F75    16    AND
	0F76    82    DUP3
	0F77    01    ADD
	0F78    80    DUP1
	0F79    60    PUSH1 0x40
	0F7B    52    MSTORE
	0F7C    50    POP
	0F7D    81    DUP2
	0F7E    01    ADD
	0F7F    90    SWAP1
	0F80    61    PUSH2 0x0f89
	0F83    91    SWAP2
	0F84    90    SWAP1
	0F85    61    PUSH2 0x1702
	0F88    56    *JUMP
	0F89    5B    JUMPDEST
	0F8A    90    SWAP1
	0F8B    50    POP
	0F8C    60    PUSH1 0x00
	0F8E    80    DUP1
	0F8F    80    DUP1
	0F90    80    DUP1
	0F91    61    PUSH2 0x0fa0
	0F94    60    PUSH1 0x60
	0F96    8C    DUP13
	0F97    01    ADD
	0F98    60    PUSH1 0x40
	0F9A    8D    DUP14
	0F9B    01    ADD
	0F9C    61    PUSH2 0x16ad
	0F9F    56    *JUMP
	0FA0    5B    JUMPDEST
	0FA1    60    PUSH1 0x01
	0FA3    60    PUSH1 0x01
	0FA5    60    PUSH1 0xa0
	0FA7    1B    SHL
	0FA8    03    SUB
	0FA9    16    AND
	0FAA    63    PUSH4 0x3850c7bd
	0FAF    60    PUSH1 0x40
	0FB1    51    MLOAD
	0FB2    81    DUP2
	0FB3    63    PUSH4 0xffffffff
	0FB8    16    AND
	0FB9    60    PUSH1 0xe0
	0FBB    1B    SHL
	0FBC    81    DUP2
	0FBD    52    MSTORE
	0FBE    60    PUSH1 0x04
	0FC0    01    ADD
	0FC1    60    PUSH1 0xe0
	0FC3    60    PUSH1 0x40
	0FC5    51    MLOAD
	0FC6    80    DUP1
	0FC7    83    DUP4
	0FC8    03    SUB
	0FC9    81    DUP2
	0FCA    86    DUP7
	0FCB    80    DUP1
	0FCC    3B    EXTCODESIZE
	0FCD    15    ISZERO
	0FCE    80    DUP1
	0FCF    15    ISZERO
	0FD0    61    PUSH2 0x0fd8
	0FD3    57    *JUMPI
	0FD4    60    PUSH1 0x00
	0FD6    80    DUP1
	0FD7    FD    *REVERT
	0FD8    5B    JUMPDEST
	0FD9    50    POP
	0FDA    5A    GAS
	0FDB    FA    STATICCALL
	0FDC    15    ISZERO
	0FDD    80    DUP1
	0FDE    15    ISZERO
	0FDF    61    PUSH2 0x0fec
	0FE2    57    *JUMPI
	0FE3    3D    RETURNDATASIZE
	0FE4    60    PUSH1 0x00
	0FE6    80    DUP1
	0FE7    3E    RETURNDATACOPY
	0FE8    3D    RETURNDATASIZE
	0FE9    60    PUSH1 0x00
	0FEB    FD    *REVERT
	0FEC    5B    JUMPDEST
	0FED    50    POP
	0FEE    50    POP
	0FEF    50    POP
	0FF0    50    POP
	0FF1    60    PUSH1 0x40
	0FF3    51    MLOAD
	0FF4    3D    RETURNDATASIZE
	0FF5    60    PUSH1 0x1f
	0FF7    19    NOT
	0FF8    60    PUSH1 0x1f
	0FFA    82    DUP3
	0FFB    01    ADD
	0FFC    16    AND
	0FFD    82    DUP3
	0FFE    01    ADD
	0FFF    80    DUP1
	1000    60    PUSH1 0x40
	1002    52    MSTORE
	1003    50    POP
	1004    81    DUP2
	1005    01    ADD
	1006    90    SWAP1
	1007    61    PUSH2 0x1010
	100A    91    SWAP2
	100B    90    SWAP1
	100C    61    PUSH2 0x176c
	100F    56    *JUMP
	1010    5B    JUMPDEST
	1011    50    POP
	1012    50    POP
	1013    50    POP
	1014    50    POP
	1015    50    POP
	1016    91    SWAP2
	1017    50    POP
	1018    91    SWAP2
	1019    50    POP
	101A    8A    DUP11
	101B    60    PUSH1 0xe0
	101D    01    ADD
	101E    60    PUSH1 0x20
	1020    81    DUP2
	1021    01    ADD
	1022    90    SWAP1
	1023    61    PUSH2 0x102c
	1026    91    SWAP2
	1027    90    SWAP1
	1028    61    PUSH2 0x171d
	102B    56    *JUMP
	102C    5B    JUMPDEST
	102D    60    PUSH1 0x00
	102F    0B    SIGNEXTEND
	1030    85    DUP6
	1031    02    MUL
	1032    85    DUP6
	1033    60    PUSH1 0x02
	1035    0B    SIGNEXTEND
	1036    82    DUP3
	1037    60    PUSH1 0x02
	1039    0B    SIGNEXTEND
	103A    81    DUP2
	103B    61    PUSH2 0x1046
	103E    57    *JUMPI
	103F    61    PUSH2 0x1046
	1042    61    PUSH2 0x1c37
	1045    56    *JUMP
	1046    5B    JUMPDEST
	1047    07    SMOD
	1048    82    DUP3
	1049    03    SUB
	104A    01    ADD
	104B    93    SWAP4
	104C    50    POP
	104D    60    PUSH1 0x00
	104F    81    DUP2
	1050    60    PUSH1 0x02
	1052    0B    SIGNEXTEND
	1053    12    SLT
	1054    61    PUSH2 0x105c
	1057    57    *JUMPI
	1058    92    SWAP3
	1059    84    DUP5
	105A    01    ADD
	105B    92    SWAP3
	105C    5B    JUMPDEST
	105D    61    PUSH2 0x1065
	1060    82    DUP3
	1061    61    PUSH2 0x15ed
	1064    56    *JUMP
	1065    5B    JUMPDEST
	1066    92    SWAP3
	1067    50    POP
	1068    50    POP
	1069    50    POP
	106A    60    PUSH1 0x00
	106C    80    DUP1
	106D    60    PUSH1 0x00
	106F    73    PUSH20 0xc36442b4a4522e871399cd717abdd847ab11fe88
	1084    60    PUSH1 0x01
	1086    60    PUSH1 0x01
	1088    60    PUSH1 0xa0
	108A    1B    SHL
	108B    03    SUB
	108C    16    AND
	108D    63    PUSH4 0x88316456
	1092    60    PUSH1 0x40
	1094    51    MLOAD
	1095    80    DUP1
	1096    61    PUSH2 0x0160
	1099    01    ADD
	109A    60    PUSH1 0x40
	109C    52    MSTORE
	109D    80    DUP1
	109E    8E    DUP15
	109F    60    PUSH1 0x01
	10A1    60    PUSH1 0x01
	10A3    60    PUSH1 0xa0
	10A5    1B    SHL
	10A6    03    SUB
	10A7    16    AND
	10A8    81    DUP2
	10A9    52    MSTORE
	10AA    60    PUSH1 0x20
	10AC    01    ADD
	10AD    8D    DUP14
	10AE    60    PUSH1 0x01
	10B0    60    PUSH1 0x01
	10B2    60    PUSH1 0xa0
	10B4    1B    SHL
	10B5    03    SUB
	10B6    16    AND
	10B7    81    DUP2
	10B8    52    MSTORE
	10B9    60    PUSH1 0x20
	10BB    01    ADD
	10BC    8A    DUP11
	10BD    62    PUSH3 0xffffff
	10C1    16    AND
	10C2    81    DUP2
	10C3    52    MSTORE
	10C4    60    PUSH1 0x20
	10C6    01    ADD
	10C7    89    DUP10
	10C8    89    DUP10
	10C9    61    PUSH2 0x10d2
	10CC    91    SWAP2
	10CD    90    SWAP1
	10CE    61    PUSH2 0x1ba5
	10D1    56    *JUMP
	10D2    5B    JUMPDEST
	10D3    60    PUSH1 0x02
	10D5    0B    SIGNEXTEND
	10D6    81    DUP2
	10D7    52    MSTORE
	10D8    60    PUSH1 0x20
	10DA    01    ADD
	10DB    88    DUP9
	10DC    60    PUSH1 0x02
	10DE    0B    SIGNEXTEND
	10DF    81    DUP2
	10E0    52    MSTORE
	10E1    60    PUSH1 0x20
	10E3    01    ADD
	10E4    8C    DUP13
	10E5    81    DUP2
	10E6    52    MSTORE
	10E7    60    PUSH1 0x20
	10E9    01    ADD
	10EA    8B    DUP12
	10EB    81    DUP2
	10EC    52    MSTORE
	10ED    60    PUSH1 0x20
	10EF    01    ADD
	10F0    60    PUSH1 0x00
	10F2    81    DUP2
	10F3    52    MSTORE
	10F4    60    PUSH1 0x20
	10F6    01    ADD
	10F7    60    PUSH1 0x00
	10F9    81    DUP2
	10FA    52    MSTORE
	10FB    60    PUSH1 0x20
	10FD    01    ADD
	10FE    30    ADDRESS
	10FF    60    PUSH1 0x01
	1101    60    PUSH1 0x01
	1103    60    PUSH1 0xa0
	1105    1B    SHL
	1106    03    SUB
	1107    16    AND
	1108    81    DUP2
	1109    52    MSTORE
	110A    60    PUSH1 0x20
	110C    01    ADD
	110D    60    PUSH1 0x00
	110F    19    NOT
	1110    81    DUP2
	1111    52    MSTORE
	1112    50    POP
	1113    60    PUSH1 0x40
	1115    51    MLOAD
	1116    82    DUP3
	1117    63    PUSH4 0xffffffff
	111C    16    AND
	111D    60    PUSH1 0xe0
	111F    1B    SHL
	1120    81    DUP2
	1121    52    MSTORE
	1122    60    PUSH1 0x04
	1124    01    ADD
	1125    61    PUSH2 0x112e
	1128    91    SWAP2
	1129    90    SWAP1
	112A    61    PUSH2 0x1a88
	112D    56    *JUMP
	112E    5B    JUMPDEST
	112F    60    PUSH1 0x80
	1131    60    PUSH1 0x40
	1133    51    MLOAD
	1134    80    DUP1
	1135    83    DUP4
	1136    03    SUB
	1137    81    DUP2
	1138    60    PUSH1 0x00
	113A    87    DUP8
	113B    80    DUP1
	113C    3B    EXTCODESIZE
	113D    15    ISZERO
	113E    80    DUP1
	113F    15    ISZERO
	1140    61    PUSH2 0x1148
	1143    57    *JUMPI
	1144    60    PUSH1 0x00
	1146    80    DUP1
	1147    FD    *REVERT
	1148    5B    JUMPDEST
	1149    50    POP
	114A    5A    GAS
	114B    F1    CALL
	114C    15    ISZERO
	114D    80    DUP1
	114E    15    ISZERO
	114F    61    PUSH2 0x115c
	1152    57    *JUMPI
	1153    3D    RETURNDATASIZE
	1154    60    PUSH1 0x00
	1156    80    DUP1
	1157    3E    RETURNDATACOPY
	1158    3D    RETURNDATASIZE
	1159    60    PUSH1 0x00
	115B    FD    *REVERT
	115C    5B    JUMPDEST
	115D    50    POP
	115E    50    POP
	115F    50    POP
	1160    50    POP
	1161    60    PUSH1 0x40
	1163    51    MLOAD
	1164    3D    RETURNDATASIZE
	1165    60    PUSH1 0x1f
	1167    19    NOT
	1168    60    PUSH1 0x1f
	116A    82    DUP3
	116B    01    ADD
	116C    16    AND
	116D    82    DUP3
	116E    01    ADD
	116F    80    DUP1
	1170    60    PUSH1 0x40
	1172    52    MSTORE
	1173    50    POP
	1174    81    DUP2
	1175    01    ADD
	1176    90    SWAP1
	1177    61    PUSH2 0x1180
	117A    91    SWAP2
	117B    90    SWAP1
	117C    61    PUSH2 0x182a
	117F    56    *JUMP
	1180    5B    JUMPDEST
	1181    93    SWAP4
	1182    50    POP
	1183    93    SWAP4
	1184    50    POP
	1185    50    POP
	1186    92    SWAP3
	1187    50    POP
	1188    60    PUSH1 0x00
	118A    80    DUP1
	118B    8D    DUP14
	118C    60    PUSH1 0x60
	118E    01    ADD
	118F    60    PUSH1 0x20
	1191    81    DUP2
	1192    01    ADD
	1193    90    SWAP1
	1194    61    PUSH2 0x119d
	1197    91    SWAP2
	1198    90    SWAP1
	1199    61    PUSH2 0x16ad
	119C    56    *JUMP
	119D    5B    JUMPDEST
	119E    60    PUSH1 0x01
	11A0    60    PUSH1 0x01
	11A2    60    PUSH1 0xa0
	11A4    1B    SHL
	11A5    03    SUB
	11A6    16    AND
	11A7    8D    DUP14
	11A8    60    PUSH1 0x01
	11AA    60    PUSH1 0x01
	11AC    60    PUSH1 0xa0
	11AE    1B    SHL
	11AF    03    SUB
	11B0    16    AND
	11B1    14    EQ
	11B2    15    ISZERO
	11B3    61    PUSH2 0x11f0
	11B6    57    *JUMPI
	11B7    8D    DUP14
	11B8    60    PUSH1 0x80
	11BA    01    ADD
	11BB    60    PUSH1 0x20
	11BD    81    DUP2
	11BE    01    ADD
	11BF    90    SWAP1
	11C0    61    PUSH2 0x11c9
	11C3    91    SWAP2
	11C4    90    SWAP1
	11C5    61    PUSH2 0x16ad
	11C8    56    *JUMP
	11C9    5B    JUMPDEST
	11CA    60    PUSH1 0x01
	11CC    60    PUSH1 0x01
	11CE    60    PUSH1 0xa0
	11D0    1B    SHL
	11D1    03    SUB
	11D2    16    AND
	11D3    8C    DUP13
	11D4    60    PUSH1 0x01
	11D6    60    PUSH1 0x01
	11D8    60    PUSH1 0xa0
	11DA    1B    SHL
	11DB    03    SUB
	11DC    16    AND
	11DD    14    EQ
	11DE    61    PUSH2 0x11e6
	11E1    57    *JUMPI
	11E2    60    PUSH1 0x00
	11E4    80    DUP1
	11E5    FD    *REVERT
	11E6    5B    JUMPDEST
	11E7    50    POP
	11E8    81    DUP2
	11E9    90    SWAP1
	11EA    50    POP
	11EB    82    DUP3
	11EC    61    PUSH2 0x126a
	11EF    56    *JUMP
	11F0    5B    JUMPDEST
	11F1    8D    DUP14
	11F2    60    PUSH1 0x80
	11F4    01    ADD
	11F5    60    PUSH1 0x20
	11F7    81    DUP2
	11F8    01    ADD
	11F9    90    SWAP1
	11FA    61    PUSH2 0x1203
	11FD    91    SWAP2
	11FE    90    SWAP1
	11FF    61    PUSH2 0x16ad
	1202    56    *JUMP
	1203    5B    JUMPDEST
	1204    60    PUSH1 0x01
	1206    60    PUSH1 0x01
	1208    60    PUSH1 0xa0
	120A    1B    SHL
	120B    03    SUB
	120C    16    AND
	120D    8D    DUP14
	120E    60    PUSH1 0x01
	1210    60    PUSH1 0x01
	1212    60    PUSH1 0xa0
	1214    1B    SHL
	1215    03    SUB
	1216    16    AND
	1217    14    EQ
	1218    61    PUSH2 0x1220
	121B    57    *JUMPI
	121C    60    PUSH1 0x00
	121E    80    DUP1
	121F    FD    *REVERT
	1220    5B    JUMPDEST
	1221    8D    DUP14
	1222    60    PUSH1 0x60
	1224    01    ADD
	1225    60    PUSH1 0x20
	1227    81    DUP2
	1228    01    ADD
	1229    90    SWAP1
	122A    61    PUSH2 0x1233
	122D    91    SWAP2
	122E    90    SWAP1
	122F    61    PUSH2 0x16ad
	1232    56    *JUMP
	1233    5B    JUMPDEST
	1234    60    PUSH1 0x01
	1236    60    PUSH1 0x01
	1238    60    PUSH1 0xa0
	123A    1B    SHL
	123B    03    SUB
	123C    16    AND
	123D    8C    DUP13
	123E    60    PUSH1 0x01
	1240    60    PUSH1 0x01
	1242    60    PUSH1 0xa0
	1244    1B    SHL
	1245    03    SUB
	1246    16    AND
	1247    14    EQ
	1248    61    PUSH2 0x1250
	124B    57    *JUMPI
	124C    60    PUSH1 0x00
	124E    80    DUP1
	124F    FD    *REVERT
	1250    5B    JUMPDEST
	1251    50    POP
	1252    82    DUP3
	1253    90    SWAP1
	1254    50    POP
	1255    81    DUP2
	1256    61    PUSH2 0x1267
	1259    67    PUSH8 0x0de0b6b3a7640000
	1262    87    DUP8
	1263    61    PUSH2 0x13cc
	1266    56    *JUMP
	1267    5B    JUMPDEST
	1268    95    SWAP6
	1269    50    POP
	126A    5B    JUMPDEST
	126B    60    PUSH1 0x00
	126D    62    PUSH3 0x0f4240
	1271    67    PUSH8 0x0de0b6b3a7640000
	127A    62    PUSH3 0xffffff
	127E    8C    DUP13
	127F    16    AND
	1280    02    MUL
	1281    04    DIV
	1282    67    PUSH8 0x0de0b6b3a7640000
	128B    01    ADD
	128C    90    SWAP1
	128D    50    POP
	128E    82    DUP3
	128F    60    PUSH1 0x00
	1291    14    EQ
	1292    61    PUSH2 0x12af
	1295    57    *JUMPI
	1296    8E    DUP15
	1297    60    PUSH1 0xa0
	1299    01    ADD
	129A    35    CALLDATALOAD
	129B    61    PUSH2 0x12a4
	129E    88    DUP9
	129F    83    DUP4
	12A0    61    PUSH2 0x13cc
	12A3    56    *JUMP
	12A4    5B    JUMPDEST
	12A5    11    GT
	12A6    15    ISZERO
	12A7    61    PUSH2 0x12af
	12AA    57    *JUMPI
	12AB    60    PUSH1 0x00
	12AD    80    DUP1
	12AE    FD    *REVERT
	12AF    5B    JUMPDEST
	12B0    81    DUP2
	12B1    15    ISZERO
	12B2    61    PUSH2 0x12cf
	12B5    57    *JUMPI
	12B6    8E    DUP15
	12B7    60    PUSH1 0xc0
	12B9    01    ADD
	12BA    35    CALLDATALOAD
	12BB    61    PUSH2 0x12c4
	12BE    88    DUP9
	12BF    83    DUP4
	12C0    61    PUSH2 0x140f
	12C3    56    *JUMP
	12C4    5B    JUMPDEST
	12C5    10    LT
	12C6    15    ISZERO
	12C7    61    PUSH2 0x12cf
	12CA    57    *JUMPI
	12CB    60    PUSH1 0x00
	12CD    80    DUP1
	12CE    FD    *REVERT
	12CF    5B    JUMPDEST
	12D0    50    POP
	12D1    50    POP
	12D2    50    POP
	12D3    88    DUP9
	12D4    82    DUP3
	12D5    11    GT
	12D6    15    ISZERO
	12D7    61    PUSH2 0x12df
	12DA    57    *JUMPI
	12DB    60    PUSH1 0x00
	12DD    80    DUP1
	12DE    FD    *REVERT
	12DF    5B    JUMPDEST
	12E0    81    DUP2
	12E1    89    DUP10
	12E2    11    GT
	12E3    15    ISZERO
	12E4    61    PUSH2 0x130d
	12E7    57    *JUMPI
	12E8    61    PUSH2 0x130d
	12EB    8B    DUP12
	12EC    8D    DUP14
	12ED    60    PUSH1 0x20
	12EF    01    ADD
	12F0    60    PUSH1 0x20
	12F2    81    DUP2
	12F3    01    ADD
	12F4    90    SWAP1
	12F5    61    PUSH2 0x12fe
	12F8    91    SWAP2
	12F9    90    SWAP1
	12FA    61    PUSH2 0x16ad
	12FD    56    *JUMP
	12FE    5B    JUMPDEST
	12FF    61    PUSH2 0x1308
	1302    85    DUP6
	1303    8D    DUP14
	1304    61    PUSH2 0x1bed
	1307    56    *JUMP
	1308    5B    JUMPDEST
	1309    61    PUSH2 0x161a
	130C    56    *JUMP
	130D    5B    JUMPDEST
	130E    87    DUP8
	130F    81    DUP2
	1310    11    GT
	1311    15    ISZERO
	1312    61    PUSH2 0x131a
	1315    57    *JUMPI
	1316    60    PUSH1 0x00
	1318    80    DUP1
	1319    FD    *REVERT
	131A    5B    JUMPDEST
	131B    80    DUP1
	131C    88    DUP9
	131D    11    GT
	131E    15    ISZERO
	131F    61    PUSH2 0x1343
	1322    57    *JUMPI
	1323    61    PUSH2 0x1343
	1326    8A    DUP11
	1327    8D    DUP14
	1328    60    PUSH1 0x20
	132A    01    ADD
	132B    60    PUSH1 0x20
	132D    81    DUP2
	132E    01    ADD
	132F    90    SWAP1
	1330    61    PUSH2 0x1339
	1333    91    SWAP2
	1334    90    SWAP1
	1335    61    PUSH2 0x16ad
	1338    56    *JUMP
	1339    5B    JUMPDEST
	133A    61    PUSH2 0x1308
	133D    84    DUP5
	133E    8C    DUP13
	133F    61    PUSH2 0x1bed
	1342    56    *JUMP
	1343    5B    JUMPDEST
	1344    82    DUP3
	1345    61    PUSH2 0x134d
	1348    57    *JUMPI
	1349    60    PUSH1 0x00
	134B    80    DUP1
	134C    FD    *REVERT
	134D    5B    JUMPDEST
	134E    61    PUSH2 0x1363
	1351    83    DUP4
	1352    60    PUSH1 0x00
	1354    80    DUP1
	1355    51    MLOAD
	1356    60    PUSH1 0x20
	1358    61    PUSH2 0x1c87
	135B    83    DUP4
	135C    39    CODECOPY
	135D    81    DUP2
	135E    51    MLOAD
	135F    91    SWAP2
	1360    52    MSTORE
	1361    55    SSTORE
	1362    56    *JUMP
	1363    5B    JUMPDEST
	1364    7F    PUSH32 0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f3
	1385    91    SWAP2
	1386    90    SWAP1
	1387    91    SWAP2
	1388    55    SSTORE
	1389    7F    PUSH32 0x829946f87d7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f4
	13AA    55    SSTORE
	13AB    50    POP
	13AC    50    POP
	13AD    50    POP
	13AE    50    POP
	13AF    50    POP
	13B0    50    POP
	13B1    50    POP
	13B2    50    POP
	13B3    50    POP
	13B4    50    POP
	13B5    56    *JUMP
label_13B6:
	// Incoming call from 0x04AC, returns to 0x04AD
	// Incoming call from 0x04B8, returns to 0x04B9
	// Incoming call from 0x0523, returns to 0x0524
	// Incoming call from 0x052F, returns to 0x0530
	// Inputs[2]
	// {
	//     @13B7  stack[-1]
	//     @13B8  stack[-2]
	// }
	13B6    5B  JUMPDEST
	13B7    80  DUP1
	13B8    82  DUP3
	13B9    03  SUB
	13BA    82  DUP3
	13BB    81  DUP2
	13BC    13  SGT
	13BD    15  ISZERO
	13BE    61  PUSH2 0x13c6
	13C1    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @13B9  stack[0] = stack[-2] - stack[-1] }
	// Block ends with conditional jump to 0x13c6, if !(stack[-2] - stack[-1] i> stack[-2])

label_13C2:
	// Incoming jump from 0x13C1, if not !(stack[-2] - stack[-1] i> stack[-2])
	// Inputs[1] { @13C5  memory[0x00:0x00] }
	13C2    60  PUSH1 0x00
	13C4    80  DUP1
	13C5    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @13C5  revert(memory[0x00:0x00]); }
	// Block terminates

label_13C6:
	// Incoming jump from 0x13C1, if !(stack[-2] - stack[-1] i> stack[-2])
	// Inputs[3]
	// {
	//     @13C7  stack[-4]
	//     @13C7  stack[-1]
	//     @13C8  stack[-3]
	// }
	13C6    5B  JUMPDEST
	13C7    92  SWAP3
	13C8    91  SWAP2
	13C9    50  POP
	13CA    50  POP
	13CB    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @13C7  stack[-4] = stack[-1] }
	// Block ends with unconditional jump to stack[-4]

label_13CC:
	// Incoming jump from 0x0561
	// Incoming jump from 0x05DF
	// Inputs[1] { @13CF  stack[-1] }
	13CC    5B  JUMPDEST
	13CD    60  PUSH1 0x00
	13CF    81  DUP2
	13D0    61  PUSH2 0x13da
	13D3    60  PUSH1 0x02
	13D5    82  DUP3
	13D6    61  PUSH2 0x1b64
	13D9    56  *JUMP
	// Stack delta = +5
	// Outputs[5]
	// {
	//     @13CD  stack[0] = 0x00
	//     @13CF  stack[1] = stack[-1]
	//     @13D0  stack[2] = 0x13da
	//     @13D3  stack[3] = 0x02
	//     @13D5  stack[4] = stack[-1]
	// }
	// Block ends with call to 0x1b64, returns to 0x13DA

label_13DA:
	// Incoming return from call to 0x1B64 at 0x13D9
	// Inputs[1] { @13E7  stack[-5] }
	13DA    5B  JUMPDEST
	13DB    61  PUSH2 0x13ec
	13DE    67  PUSH8 0x0de0b6b3a7640000
	13E7    86  DUP7
	13E8    61  PUSH2 0x1b86
	13EB    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @13DB  stack[0] = 0x13ec
	//     @13DE  stack[1] = 0x0de0b6b3a7640000
	//     @13E7  stack[2] = stack[-5]
	// }
	// Block ends with call to 0x1b86, returns to 0x13EC

label_13EC:
	// Incoming return from call to 0x1B86 at 0x13EB
	// Inputs[2]
	// {
	//     @13F0  stack[-2]
	//     @13F1  stack[-1]
	// }
	13EC    5B  JUMPDEST
	13ED    61  PUSH2 0x13f6
	13F0    91  SWAP2
	13F1    90  SWAP1
	13F2    61  PUSH2 0x1b4c
	13F5    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @13F0  stack[-2] = 0x13f6
	//     @13F1  stack[-1] = stack[-2]
	//     @13F1  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x1b4c, returns to 0x13F6

label_13F6:
	// Incoming return from call to 0x1B4C at 0x13F5
	// Inputs[2]
	// {
	//     @13FA  stack[-2]
	//     @13FB  stack[-1]
	// }
	13F6    5B  JUMPDEST
	13F7    61  PUSH2 0x1400
	13FA    91  SWAP2
	13FB    90  SWAP1
	13FC    61  PUSH2 0x1b64
	13FF    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @13FA  stack[-2] = 0x1400
	//     @13FB  stack[-1] = stack[-2]
	//     @13FB  stack[0] = stack[-1]
	// }
	// Block ends with call to 0x1b64, returns to 0x1400

label_1400:
	// Incoming return from call to 0x1B64 at 0x13FF
	// Incoming return from call to 0x1C4D at 0x16C9
	// Incoming jump from 0x18AF, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffff
	// Incoming return from call to 0x1C4D at 0x16E6
	// Inputs[3]
	// {
	//     @1401  stack[-1]
	//     @1401  stack[-5]
	//     @1402  stack[-4]
	// }
	1400    5B  JUMPDEST
	1401    93  SWAP4
	1402    92  SWAP3
	1403    50  POP
	1404    50  POP
	1405    50  POP
	1406    56  *JUMP
	// Stack delta = -4
	// Outputs[1] { @1401  stack[-5] = stack[-1] }
	// Block ends with unconditional jump to stack[-5]

	1407    5B    JUMPDEST
	1408    60    PUSH1 0x00
	140A    61    PUSH2 0x13c6
	140D    82    DUP3
	140E    83    DUP4
	140F    5B    JUMPDEST
	1410    60    PUSH1 0x00
	1412    67    PUSH8 0x0de0b6b3a7640000
	141B    61    PUSH2 0x13f6
	141E    83    DUP4
	141F    85    DUP6
	1420    61    PUSH2 0x1b86
	1423    56    *JUMP
	1424    5B    JUMPDEST
	1425    60    PUSH1 0x00
	1427    81    DUP2
	1428    83    DUP4
	1429    11    GT
	142A    15    ISZERO
	142B    61    PUSH2 0x1434
	142E    57    *JUMPI
	142F    81    DUP2
	1430    61    PUSH2 0x1400
	1433    56    *JUMP
	1434    5B    JUMPDEST
	1435    50    POP
	1436    90    SWAP1
	1437    91    SWAP2
	1438    90    SWAP1
	1439    50    POP
	143A    56    *JUMP
	143B    5B    JUMPDEST
	143C    60    PUSH1 0x40
	143E    51    MLOAD
	143F    60    PUSH1 0x01
	1441    60    PUSH1 0x01
	1443    60    PUSH1 0xa0
	1445    1B    SHL
	1446    03    SUB
	1447    83    DUP4
	1448    81    DUP2
	1449    16    AND
	144A    60    PUSH1 0x24
	144C    83    DUP4
	144D    01    ADD
	144E    52    MSTORE
	144F    60    PUSH1 0x44
	1451    82    DUP3
	1452    01    ADD
	1453    83    DUP4
	1454    90    SWAP1
	1455    52    MSTORE
	1456    60    PUSH1 0x00
	1458    91    SWAP2
	1459    82    DUP3
	145A    91    SWAP2
	145B    86    DUP7
	145C    16    AND
	145D    90    SWAP1
	145E    63    PUSH4 0x095ea7b3
	1463    90    SWAP1
	1464    60    PUSH1 0x64
	1466    01    ADD
	1467    5B    JUMPDEST
	1468    60    PUSH1 0x40
	146A    51    MLOAD
	146B    60    PUSH1 0x20
	146D    81    DUP2
	146E    83    DUP4
	146F    03    SUB
	1470    03    SUB
	1471    81    DUP2
	1472    52    MSTORE
	1473    90    SWAP1
	1474    60    PUSH1 0x40
	1476    52    MSTORE
	1477    90    SWAP1
	1478    60    PUSH1 0xe0
	147A    1B    SHL
	147B    60    PUSH1 0x20
	147D    82    DUP3
	147E    01    ADD
	147F    80    DUP1
	1480    51    MLOAD
	1481    60    PUSH1 0x01
	1483    60    PUSH1 0x01
	1485    60    PUSH1 0xe0
	1487    1B    SHL
	1488    03    SUB
	1489    83    DUP4
	148A    81    DUP2
	148B    83    DUP4
	148C    16    AND
	148D    17    OR
	148E    83    DUP4
	148F    52    MSTORE
	1490    50    POP
	1491    50    POP
	1492    50    POP
	1493    50    POP
	1494    60    PUSH1 0x40
	1496    51    MLOAD
	1497    61    PUSH2 0x14a0
	149A    91    SWAP2
	149B    90    SWAP1
	149C    61    PUSH2 0x19c7
	149F    56    *JUMP
	14A0    5B    JUMPDEST
	14A1    60    PUSH1 0x00
	14A3    60    PUSH1 0x40
	14A5    51    MLOAD
	14A6    80    DUP1
	14A7    83    DUP4
	14A8    03    SUB
	14A9    81    DUP2
	14AA    60    PUSH1 0x00
	14AC    86    DUP7
	14AD    5A    GAS
	14AE    F1    CALL
	14AF    91    SWAP2
	14B0    50    POP
	14B1    50    POP
	14B2    3D    RETURNDATASIZE
	14B3    80    DUP1
	14B4    60    PUSH1 0x00
	14B6    81    DUP2
	14B7    14    EQ
	14B8    61    PUSH2 0x14dd
	14BB    57    *JUMPI
	14BC    60    PUSH1 0x40
	14BE    51    MLOAD
	14BF    91    SWAP2
	14C0    50    POP
	14C1    60    PUSH1 0x1f
	14C3    19    NOT
	14C4    60    PUSH1 0x3f
	14C6    3D    RETURNDATASIZE
	14C7    01    ADD
	14C8    16    AND
	14C9    82    DUP3
	14CA    01    ADD
	14CB    60    PUSH1 0x40
	14CD    52    MSTORE
	14CE    3D    RETURNDATASIZE
	14CF    82    DUP3
	14D0    52    MSTORE
	14D1    3D    RETURNDATASIZE
	14D2    60    PUSH1 0x00
	14D4    60    PUSH1 0x20
	14D6    84    DUP5
	14D7    01    ADD
	14D8    3E    RETURNDATACOPY
	14D9    61    PUSH2 0x14e2
	14DC    56    *JUMP
	14DD    5B    JUMPDEST
	14DE    60    PUSH1 0x60
	14E0    91    SWAP2
	14E1    50    POP
	14E2    5B    JUMPDEST
	14E3    50    POP
	14E4    91    SWAP2
	14E5    50    POP
	14E6    91    SWAP2
	14E7    50    POP
	14E8    81    DUP2
	14E9    80    DUP1
	14EA    15    ISZERO
	14EB    61    PUSH2 0x099b
	14EE    57    *JUMPI
	14EF    50    POP
	14F0    80    DUP1
	14F1    51    MLOAD
	14F2    15    ISZERO
	14F3    80    DUP1
	14F4    61    PUSH2 0x099b
	14F7    57    *JUMPI
	14F8    50    POP
	14F9    80    DUP1
	14FA    80    DUP1
	14FB    60    PUSH1 0x20
	14FD    01    ADD
	14FE    90    SWAP1
	14FF    51    MLOAD
	1500    81    DUP2
	1501    01    ADD
	1502    90    SWAP1
	1503    61    PUSH2 0x099b
	1506    91    SWAP2
	1507    90    SWAP1
	1508    61    PUSH2 0x16e7
	150B    56    *JUMP
	150C    5B    JUMPDEST
	150D    60    PUSH1 0x40
	150F    80    DUP1
	1510    51    MLOAD
	1511    60    PUSH1 0x01
	1513    60    PUSH1 0x01
	1515    60    PUSH1 0xa0
	1517    1B    SHL
	1518    03    SUB
	1519    85    DUP6
	151A    81    DUP2
	151B    16    AND
	151C    60    PUSH1 0x24
	151E    83    DUP4
	151F    01    ADD
	1520    52    MSTORE
	1521    84    DUP5
	1522    81    DUP2
	1523    16    AND
	1524    60    PUSH1 0x44
	1526    83    DUP4
	1527    01    ADD
	1528    52    MSTORE
	1529    60    PUSH1 0x64
	152B    80    DUP1
	152C    83    DUP4
	152D    01    ADD
	152E    85    DUP6
	152F    90    SWAP1
	1530    52    MSTORE
	1531    83    DUP4
	1532    51    MLOAD
	1533    80    DUP1
	1534    84    DUP5
	1535    03    SUB
	1536    90    SWAP1
	1537    91    SWAP2
	1538    01    ADD
	1539    81    DUP2
	153A    52    MSTORE
	153B    60    PUSH1 0x84
	153D    90    SWAP1
	153E    92    SWAP3
	153F    01    ADD
	1540    83    DUP4
	1541    52    MSTORE
	1542    60    PUSH1 0x20
	1544    82    DUP3
	1545    01    ADD
	1546    80    DUP1
	1547    51    MLOAD
	1548    60    PUSH1 0x01
	154A    60    PUSH1 0x01
	154C    60    PUSH1 0xe0
	154E    1B    SHL
	154F    03    SUB
	1550    16    AND
	1551    63    PUSH4 0x23b872dd
	1556    60    PUSH1 0xe0
	1558    1B    SHL
	1559    17    OR
	155A    90    SWAP1
	155B    52    MSTORE
	155C    91    SWAP2
	155D    51    MLOAD
	155E    60    PUSH1 0x00
	1560    92    SWAP3
	1561    83    DUP4
	1562    92    SWAP3
	1563    90    SWAP1
	1564    88    DUP9
	1565    16    AND
	1566    91    SWAP2
	1567    61    PUSH2 0x1570
	156A    91    SWAP2
	156B    90    SWAP1
	156C    61    PUSH2 0x19c7
	156F    56    *JUMP
	1570    5B    JUMPDEST
	1571    60    PUSH1 0x00
	1573    60    PUSH1 0x40
	1575    51    MLOAD
	1576    80    DUP1
	1577    83    DUP4
	1578    03    SUB
	1579    81    DUP2
	157A    60    PUSH1 0x00
	157C    86    DUP7
	157D    5A    GAS
	157E    F1    CALL
	157F    91    SWAP2
	1580    50    POP
	1581    50    POP
	1582    3D    RETURNDATASIZE
	1583    80    DUP1
	1584    60    PUSH1 0x00
	1586    81    DUP2
	1587    14    EQ
	1588    61    PUSH2 0x15ad
	158B    57    *JUMPI
	158C    60    PUSH1 0x40
	158E    51    MLOAD
	158F    91    SWAP2
	1590    50    POP
	1591    60    PUSH1 0x1f
	1593    19    NOT
	1594    60    PUSH1 0x3f
	1596    3D    RETURNDATASIZE
	1597    01    ADD
	1598    16    AND
	1599    82    DUP3
	159A    01    ADD
	159B    60    PUSH1 0x40
	159D    52    MSTORE
	159E    3D    RETURNDATASIZE
	159F    82    DUP3
	15A0    52    MSTORE
	15A1    3D    RETURNDATASIZE
	15A2    60    PUSH1 0x00
	15A4    60    PUSH1 0x20
	15A6    84    DUP5
	15A7    01    ADD
	15A8    3E    RETURNDATACOPY
	15A9    61    PUSH2 0x15b2
	15AC    56    *JUMP
	15AD    5B    JUMPDEST
	15AE    60    PUSH1 0x60
	15B0    91    SWAP2
	15B1    50    POP
	15B2    5B    JUMPDEST
	15B3    50    POP
	15B4    91    SWAP2
	15B5    50    POP
	15B6    91    SWAP2
	15B7    50    POP
	15B8    81    DUP2
	15B9    80    DUP1
	15BA    15    ISZERO
	15BB    61    PUSH2 0x15dc
	15BE    57    *JUMPI
	15BF    50    POP
	15C0    80    DUP1
	15C1    51    MLOAD
	15C2    15    ISZERO
	15C3    80    DUP1
	15C4    61    PUSH2 0x15dc
	15C7    57    *JUMPI
	15C8    50    POP
	15C9    80    DUP1
	15CA    80    DUP1
	15CB    60    PUSH1 0x20
	15CD    01    ADD
	15CE    90    SWAP1
	15CF    51    MLOAD
	15D0    81    DUP2
	15D1    01    ADD
	15D2    90    SWAP1
	15D3    61    PUSH2 0x15dc
	15D6    91    SWAP2
	15D7    90    SWAP1
	15D8    61    PUSH2 0x16e7
	15DB    56    *JUMP
	15DC    5B    JUMPDEST
	15DD    61    PUSH2 0x15e5
	15E0    57    *JUMPI
	15E1    60    PUSH1 0x00
	15E3    80    DUP1
	15E4    FD    *REVERT
	15E5    5B    JUMPDEST
	15E6    50    POP
	15E7    50    POP
	15E8    50    POP
	15E9    50    POP
	15EA    50    POP
	15EB    50    POP
	15EC    56    *JUMP
	15ED    5B    JUMPDEST
	15EE    60    PUSH1 0x00
	15F0    80    DUP1
	15F1    60    PUSH1 0x60
	15F3    61    PUSH2 0x160d
	15F6    67    PUSH8 0x0de0b6b3a7640000
	15FF    60    PUSH1 0x01
	1601    60    PUSH1 0x01
	1603    60    PUSH1 0xa0
	1605    1B    SHL
	1606    03    SUB
	1607    86    DUP7
	1608    16    AND
	1609    61    PUSH2 0x1b86
	160C    56    *JUMP
	160D    5B    JUMPDEST
	160E    90    SWAP1
	160F    1C    SHR
	1610    90    SWAP1
	1611    50    POP
	1612    61    PUSH2 0x1400
	1615    81    DUP2
	1616    61    PUSH2 0x1407
	1619    56    *JUMP
	161A    5B    JUMPDEST
	161B    60    PUSH1 0x40
	161D    51    MLOAD
	161E    60    PUSH1 0x01
	1620    60    PUSH1 0x01
	1622    60    PUSH1 0xa0
	1624    1B    SHL
	1625    03    SUB
	1626    83    DUP4
	1627    81    DUP2
	1628    16    AND
	1629    60    PUSH1 0x24
	162B    83    DUP4
	162C    01    ADD
	162D    52    MSTORE
	162E    60    PUSH1 0x44
	1630    82    DUP3
	1631    01    ADD
	1632    83    DUP4
	1633    90    SWAP1
	1634    52    MSTORE
	1635    60    PUSH1 0x00
	1637    91    SWAP2
	1638    82    DUP3
	1639    91    SWAP2
	163A    86    DUP7
	163B    16    AND
	163C    90    SWAP1
	163D    63    PUSH4 0xa9059cbb
	1642    90    SWAP1
	1643    60    PUSH1 0x64
	1645    01    ADD
	1646    61    PUSH2 0x1467
	1649    56    *JUMP
	164A    5B    JUMPDEST
	164B    80    DUP1
	164C    51    MLOAD
	164D    80    DUP1
	164E    15    ISZERO
	164F    15    ISZERO
	1650    81    DUP2
	1651    14    EQ
	1652    61    PUSH2 0x165a
	1655    57    *JUMPI
	1656    60    PUSH1 0x00
	1658    80    DUP1
	1659    FD    *REVERT
label_165A:
	// Incoming jump from 0x1683, if memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & (0x01 << 0x80) - 0x01
	// Incoming jump from 0x166C, if memory[stack[-1]:stack[-1] + 0x20] == signextend(0x02, memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x16A8, if memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & 0xffffff
	// Inputs[3]
	// {
	//     @165B  stack[-3]
	//     @165B  stack[-1]
	//     @165C  stack[-2]
	// }
	165A    5B  JUMPDEST
	165B    91  SWAP2
	165C    90  SWAP1
	165D    50  POP
	165E    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @165B  stack[-3] = stack[-1] }
	// Block ends with unconditional jump to stack[-3]

label_165F:
	// Incoming call from 0x1978, returns to 0x1979
	// Incoming call from 0x196A, returns to 0x196B
	// Inputs[2]
	// {
	//     @1660  stack[-1]
	//     @1661  memory[stack[-1]:stack[-1] + 0x20]
	// }
	165F    5B  JUMPDEST
	1660    80  DUP1
	1661    51  MLOAD
	1662    60  PUSH1 0x02
	1664    81  DUP2
	1665    90  SWAP1
	1666    0B  SIGNEXTEND
	1667    81  DUP2
	1668    14  EQ
	1669    61  PUSH2 0x165a
	166C    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1661  stack[0] = memory[stack[-1]:stack[-1] + 0x20] }
	// Block ends with conditional jump to 0x165a, if memory[stack[-1]:stack[-1] + 0x20] == signextend(0x02, memory[stack[-1]:stack[-1] + 0x20])

label_166D:
	// Incoming jump from 0x166C, if not memory[stack[-1]:stack[-1] + 0x20] == signextend(0x02, memory[stack[-1]:stack[-1] + 0x20])
	// Inputs[1] { @1670  memory[0x00:0x00] }
	166D    60  PUSH1 0x00
	166F    80  DUP1
	1670    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1670  revert(memory[0x00:0x00]); }
	// Block terminates

label_1671:
	// Incoming call from 0x1986, returns to 0x1987
	// Incoming call from 0x19B4, returns to 0x19B5
	// Incoming call from 0x19A5, returns to 0x19A6
	// Inputs[2]
	// {
	//     @1672  stack[-1]
	//     @1673  memory[stack[-1]:stack[-1] + 0x20]
	// }
	1671    5B  JUMPDEST
	1672    80  DUP1
	1673    51  MLOAD
	1674    60  PUSH1 0x01
	1676    60  PUSH1 0x01
	1678    60  PUSH1 0x80
	167A    1B  SHL
	167B    03  SUB
	167C    81  DUP2
	167D    16  AND
	167E    81  DUP2
	167F    14  EQ
	1680    61  PUSH2 0x165a
	1683    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1673  stack[0] = memory[stack[-1]:stack[-1] + 0x20] }
	// Block ends with conditional jump to 0x165a, if memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & (0x01 << 0x80) - 0x01

label_1684:
	// Incoming jump from 0x1683, if not memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & (0x01 << 0x80) - 0x01
	// Inputs[1] { @1687  memory[0x00:0x00] }
	1684    60  PUSH1 0x00
	1686    80  DUP1
	1687    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1687  revert(memory[0x00:0x00]); }
	// Block terminates

	1688    5B    JUMPDEST
	1689    80    DUP1
	168A    51    MLOAD
	168B    61    PUSH2 0xffff
	168E    81    DUP2
	168F    16    AND
	1690    81    DUP2
	1691    14    EQ
	1692    61    PUSH2 0x165a
	1695    57    *JUMPI
	1696    60    PUSH1 0x00
	1698    80    DUP1
	1699    FD    *REVERT
label_169A:
	// Incoming call from 0x195C, returns to 0x195D
	// Inputs[2]
	// {
	//     @169B  stack[-1]
	//     @169C  memory[stack[-1]:stack[-1] + 0x20]
	// }
	169A    5B  JUMPDEST
	169B    80  DUP1
	169C    51  MLOAD
	169D    62  PUSH3 0xffffff
	16A1    81  DUP2
	16A2    16  AND
	16A3    81  DUP2
	16A4    14  EQ
	16A5    61  PUSH2 0x165a
	16A8    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @169C  stack[0] = memory[stack[-1]:stack[-1] + 0x20] }
	// Block ends with conditional jump to 0x165a, if memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & 0xffffff

label_16A9:
	// Incoming jump from 0x16A8, if not memory[stack[-1]:stack[-1] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] & 0xffffff
	// Inputs[1] { @16AC  memory[0x00:0x00] }
	16A9    60  PUSH1 0x00
	16AB    80  DUP1
	16AC    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @16AC  revert(memory[0x00:0x00]); }
	// Block terminates

label_16AD:
	// Incoming call from 0x04FC, returns to 0x04FD
	// Incoming call from 0x0485, returns to 0x0486
	// Incoming call from 0x045C, returns to 0x045D
	// Incoming call from 0x00D4, returns to 0x00D5
	// Incoming call from 0x00F1, returns to 0x00F2
	// Incoming call from 0x0BD6, returns to 0x0BD7
	// Incoming call from 0x04CF, returns to 0x04D0
	// Incoming call from 0x02FF, returns to 0x0300
	// Inputs[2]
	// {
	//     @16B2  stack[-1]
	//     @16B3  stack[-2]
	// }
	16AD    5B  JUMPDEST
	16AE    60  PUSH1 0x00
	16B0    60  PUSH1 0x20
	16B2    82  DUP3
	16B3    84  DUP5
	16B4    03  SUB
	16B5    12  SLT
	16B6    15  ISZERO
	16B7    61  PUSH2 0x16bf
	16BA    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @16AE  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x16bf, if !(stack[-2] - stack[-1] i< 0x20)

label_16BB:
	// Incoming jump from 0x16BA, if not !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[1] { @16BE  memory[0x00:0x00] }
	16BB    60  PUSH1 0x00
	16BD    80  DUP1
	16BE    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @16BE  revert(memory[0x00:0x00]); }
	// Block terminates

label_16BF:
	// Incoming jump from 0x16BA, if !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[2]
	// {
	//     @16C0  stack[-2]
	//     @16C1  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	16BF    5B  JUMPDEST
	16C0    81  DUP2
	16C1    35  CALLDATALOAD
	16C2    61  PUSH2 0x1400
	16C5    81  DUP2
	16C6    61  PUSH2 0x1c4d
	16C9    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @16C1  stack[0] = msg.data[stack[-2]:stack[-2] + 0x20]
	//     @16C2  stack[1] = 0x1400
	//     @16C5  stack[2] = msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	// Block ends with call to 0x1c4d, returns to 0x1400

label_16CA:
	// Incoming jump from 0x0AC0
	// Incoming jump from 0x0C46
	// Inputs[2]
	// {
	//     @16CF  stack[-1]
	//     @16D0  stack[-2]
	// }
	16CA    5B  JUMPDEST
	16CB    60  PUSH1 0x00
	16CD    60  PUSH1 0x20
	16CF    82  DUP3
	16D0    84  DUP5
	16D1    03  SUB
	16D2    12  SLT
	16D3    15  ISZERO
	16D4    61  PUSH2 0x16dc
	16D7    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @16CB  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x16dc, if !(stack[-2] - stack[-1] i< 0x20)

label_16D8:
	// Incoming jump from 0x16D7, if not !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[1] { @16DB  memory[0x00:0x00] }
	16D8    60  PUSH1 0x00
	16DA    80  DUP1
	16DB    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @16DB  revert(memory[0x00:0x00]); }
	// Block terminates

label_16DC:
	// Incoming jump from 0x16D7, if !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[2]
	// {
	//     @16DD  stack[-2]
	//     @16DE  memory[stack[-2]:stack[-2] + 0x20]
	// }
	16DC    5B  JUMPDEST
	16DD    81  DUP2
	16DE    51  MLOAD
	16DF    61  PUSH2 0x1400
	16E2    81  DUP2
	16E3    61  PUSH2 0x1c4d
	16E6    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @16DE  stack[0] = memory[stack[-2]:stack[-2] + 0x20]
	//     @16DF  stack[1] = 0x1400
	//     @16E2  stack[2] = memory[stack[-2]:stack[-2] + 0x20]
	// }
	// Block ends with call to 0x1c4d, returns to 0x1400

	16E7    5B    JUMPDEST
	16E8    60    PUSH1 0x00
	16EA    60    PUSH1 0x20
	16EC    82    DUP3
	16ED    84    DUP5
	16EE    03    SUB
	16EF    12    SLT
	16F0    15    ISZERO
	16F1    61    PUSH2 0x16f9
	16F4    57    *JUMPI
	16F5    60    PUSH1 0x00
	16F7    80    DUP1
	16F8    FD    *REVERT
	16F9    5B    JUMPDEST
	16FA    61    PUSH2 0x1400
	16FD    82    DUP3
	16FE    61    PUSH2 0x164a
	1701    56    *JUMP
	1702    5B    JUMPDEST
	1703    60    PUSH1 0x00
	1705    60    PUSH1 0x20
	1707    82    DUP3
	1708    84    DUP5
	1709    03    SUB
	170A    12    SLT
	170B    15    ISZERO
	170C    61    PUSH2 0x1714
	170F    57    *JUMPI
	1710    60    PUSH1 0x00
	1712    80    DUP1
	1713    FD    *REVERT
	1714    5B    JUMPDEST
	1715    61    PUSH2 0x1400
	1718    82    DUP3
	1719    61    PUSH2 0x165f
	171C    56    *JUMP
	171D    5B    JUMPDEST
	171E    60    PUSH1 0x00
	1720    60    PUSH1 0x20
	1722    82    DUP3
	1723    84    DUP5
	1724    03    SUB
	1725    12    SLT
	1726    15    ISZERO
	1727    61    PUSH2 0x172f
	172A    57    *JUMPI
	172B    60    PUSH1 0x00
	172D    80    DUP1
	172E    FD    *REVERT
	172F    5B    JUMPDEST
	1730    81    DUP2
	1731    35    CALLDATALOAD
	1732    80    DUP1
	1733    60    PUSH1 0x00
	1735    0B    SIGNEXTEND
	1736    81    DUP2
	1737    14    EQ
	1738    61    PUSH2 0x1400
	173B    57    *JUMPI
	173C    60    PUSH1 0x00
	173E    80    DUP1
	173F    FD    *REVERT
label_1740:
	// Incoming call from 0x00AC, returns to 0x00AD
	// Inputs[2]
	// {
	//     @1746  stack[-1]
	//     @1747  stack[-2]
	// }
	1740    5B  JUMPDEST
	1741    60  PUSH1 0x00
	1743    61  PUSH2 0x0180
	1746    82  DUP3
	1747    84  DUP5
	1748    03  SUB
	1749    12  SLT
	174A    15  ISZERO
	174B    61  PUSH2 0x1753
	174E    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1741  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1753, if !(stack[-2] - stack[-1] i< 0x0180)

label_174F:
	// Incoming jump from 0x174E, if not !(stack[-2] - stack[-1] i< 0x0180)
	// Inputs[1] { @1752  memory[0x00:0x00] }
	174F    60  PUSH1 0x00
	1751    80  DUP1
	1752    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1752  revert(memory[0x00:0x00]); }
	// Block terminates

label_1753:
	// Incoming jump from 0x174E, if !(stack[-2] - stack[-1] i< 0x0180)
	// Incoming jump from 0x1767, if !(stack[-2] - stack[-1] i< 0x0100)
	// Inputs[3]
	// {
	//     @1755  stack[-2]
	//     @1755  stack[-4]
	//     @1756  stack[-3]
	// }
	1753    5B  JUMPDEST
	1754    50  POP
	1755    91  SWAP2
	1756    90  SWAP1
	1757    50  POP
	1758    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @1755  stack[-4] = stack[-2] }
	// Block ends with unconditional jump to stack[-4]

label_1759:
	// Incoming call from 0x0104, returns to 0x0105
	// Inputs[2]
	// {
	//     @175F  stack[-1]
	//     @1760  stack[-2]
	// }
	1759    5B  JUMPDEST
	175A    60  PUSH1 0x00
	175C    61  PUSH2 0x0100
	175F    82  DUP3
	1760    84  DUP5
	1761    03  SUB
	1762    12  SLT
	1763    15  ISZERO
	1764    61  PUSH2 0x1753
	1767    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @175A  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1753, if !(stack[-2] - stack[-1] i< 0x0100)

label_1768:
	// Incoming jump from 0x1767, if not !(stack[-2] - stack[-1] i< 0x0100)
	// Inputs[1] { @176B  memory[0x00:0x00] }
	1768    60  PUSH1 0x00
	176A    80  DUP1
	176B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @176B  revert(memory[0x00:0x00]); }
	// Block terminates

	176C    5B    JUMPDEST
	176D    60    PUSH1 0x00
	176F    80    DUP1
	1770    60    PUSH1 0x00
	1772    80    DUP1
	1773    60    PUSH1 0x00
	1775    80    DUP1
	1776    60    PUSH1 0x00
	1778    60    PUSH1 0xe0
	177A    88    DUP9
	177B    8A    DUP11
	177C    03    SUB
	177D    12    SLT
	177E    15    ISZERO
	177F    61    PUSH2 0x1787
	1782    57    *JUMPI
	1783    60    PUSH1 0x00
	1785    80    DUP1
	1786    FD    *REVERT
	1787    5B    JUMPDEST
	1788    87    DUP8
	1789    51    MLOAD
	178A    61    PUSH2 0x1792
	178D    81    DUP2
	178E    61    PUSH2 0x1c4d
	1791    56    *JUMP
	1792    5B    JUMPDEST
	1793    96    SWAP7
	1794    50    POP
	1795    61    PUSH2 0x17a0
	1798    60    PUSH1 0x20
	179A    89    DUP10
	179B    01    ADD
	179C    61    PUSH2 0x165f
	179F    56    *JUMP
	17A0    5B    JUMPDEST
	17A1    95    SWAP6
	17A2    50    POP
	17A3    61    PUSH2 0x17ae
	17A6    60    PUSH1 0x40
	17A8    89    DUP10
	17A9    01    ADD
	17AA    61    PUSH2 0x1688
	17AD    56    *JUMP
	17AE    5B    JUMPDEST
	17AF    94    SWAP5
	17B0    50    POP
	17B1    61    PUSH2 0x17bc
	17B4    60    PUSH1 0x60
	17B6    89    DUP10
	17B7    01    ADD
	17B8    61    PUSH2 0x1688
	17BB    56    *JUMP
	17BC    5B    JUMPDEST
	17BD    93    SWAP4
	17BE    50    POP
	17BF    61    PUSH2 0x17ca
	17C2    60    PUSH1 0x80
	17C4    89    DUP10
	17C5    01    ADD
	17C6    61    PUSH2 0x1688
	17C9    56    *JUMP
	17CA    5B    JUMPDEST
	17CB    92    SWAP3
	17CC    50    POP
	17CD    60    PUSH1 0xa0
	17CF    88    DUP9
	17D0    01    ADD
	17D1    51    MLOAD
	17D2    61    PUSH2 0x17da
	17D5    81    DUP2
	17D6    61    PUSH2 0x1c62
	17D9    56    *JUMP
	17DA    5B    JUMPDEST
	17DB    91    SWAP2
	17DC    50    POP
	17DD    61    PUSH2 0x17e8
	17E0    60    PUSH1 0xc0
	17E2    89    DUP10
	17E3    01    ADD
	17E4    61    PUSH2 0x164a
	17E7    56    *JUMP
	17E8    5B    JUMPDEST
	17E9    90    SWAP1
	17EA    50    POP
	17EB    92    SWAP3
	17EC    95    SWAP6
	17ED    98    SWAP9
	17EE    91    SWAP2
	17EF    94    SWAP5
	17F0    97    SWAP8
	17F1    50    POP
	17F2    92    SWAP3
	17F3    95    SWAP6
	17F4    50    POP
	17F5    56    *JUMP
	17F6    5B    JUMPDEST
	17F7    60    PUSH1 0x00
	17F9    60    PUSH1 0x20
	17FB    82    DUP3
	17FC    84    DUP5
	17FD    03    SUB
	17FE    12    SLT
	17FF    15    ISZERO
	1800    61    PUSH2 0x1808
	1803    57    *JUMPI
	1804    60    PUSH1 0x00
	1806    80    DUP1
	1807    FD    *REVERT
	1808    5B    JUMPDEST
	1809    61    PUSH2 0x1400
	180C    82    DUP3
	180D    61    PUSH2 0x169a
	1810    56    *JUMP
	1811    5B    JUMPDEST
	1812    60    PUSH1 0x00
	1814    60    PUSH1 0x20
	1816    82    DUP3
	1817    84    DUP5
	1818    03    SUB
	1819    12    SLT
	181A    15    ISZERO
	181B    61    PUSH2 0x1823
	181E    57    *JUMPI
	181F    60    PUSH1 0x00
	1821    80    DUP1
	1822    FD    *REVERT
	1823    5B    JUMPDEST
	1824    50    POP
	1825    51    MLOAD
	1826    91    SWAP2
	1827    90    SWAP1
	1828    50    POP
	1829    56    *JUMP
	182A    5B    JUMPDEST
	182B    60    PUSH1 0x00
	182D    80    DUP1
	182E    60    PUSH1 0x00
	1830    80    DUP1
	1831    60    PUSH1 0x80
	1833    85    DUP6
	1834    87    DUP8
	1835    03    SUB
	1836    12    SLT
	1837    15    ISZERO
	1838    61    PUSH2 0x1840
	183B    57    *JUMPI
	183C    60    PUSH1 0x00
	183E    80    DUP1
	183F    FD    *REVERT
	1840    5B    JUMPDEST
	1841    84    DUP5
	1842    51    MLOAD
	1843    93    SWAP4
	1844    50    POP
	1845    61    PUSH2 0x1850
	1848    60    PUSH1 0x20
	184A    86    DUP7
	184B    01    ADD
	184C    61    PUSH2 0x1671
	184F    56    *JUMP
	1850    5B    JUMPDEST
	1851    60    PUSH1 0x40
	1853    86    DUP7
	1854    01    ADD
	1855    51    MLOAD
	1856    60    PUSH1 0x60
	1858    90    SWAP1
	1859    96    SWAP7
	185A    01    ADD
	185B    51    MLOAD
	185C    94    SWAP5
	185D    97    SWAP8
	185E    90    SWAP1
	185F    96    SWAP7
	1860    50    POP
	1861    92    SWAP3
	1862    50    POP
	1863    50    POP
	1864    50    POP
	1865    56    *JUMP
label_1866:
	// Incoming call from 0x02B3, returns to 0x02B4
	// Incoming call from 0x038F, returns to 0x0390
	// Incoming call from 0x0973, returns to 0x0974
	// Incoming call from 0x08B6, returns to 0x08B7
	// Inputs[2]
	// {
	//     @186C  stack[-1]
	//     @186D  stack[-2]
	// }
	1866    5B  JUMPDEST
	1867    60  PUSH1 0x00
	1869    80  DUP1
	186A    60  PUSH1 0x40
	186C    83  DUP4
	186D    85  DUP6
	186E    03  SUB
	186F    12  SLT
	1870    15  ISZERO
	1871    61  PUSH2 0x1879
	1874    57  *JUMPI
	// Stack delta = +2
	// Outputs[2]
	// {
	//     @1867  stack[0] = 0x00
	//     @1869  stack[1] = 0x00
	// }
	// Block ends with conditional jump to 0x1879, if !(stack[-2] - stack[-1] i< 0x40)

label_1875:
	// Incoming jump from 0x1874, if not !(stack[-2] - stack[-1] i< 0x40)
	// Inputs[1] { @1878  memory[0x00:0x00] }
	1875    60  PUSH1 0x00
	1877    80  DUP1
	1878    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1878  revert(memory[0x00:0x00]); }
	// Block terminates

label_1879:
	// Incoming jump from 0x1874, if !(stack[-2] - stack[-1] i< 0x40)
	// Inputs[5]
	// {
	//     @187C  stack[-3]
	//     @187D  memory[stack[-3]:stack[-3] + 0x20]
	//     @1883  memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]
	//     @1885  stack[-5]
	//     @1887  stack[-4]
	// }
	1879    5B  JUMPDEST
	187A    50  POP
	187B    50  POP
	187C    80  DUP1
	187D    51  MLOAD
	187E    60  PUSH1 0x20
	1880    90  SWAP1
	1881    91  SWAP2
	1882    01  ADD
	1883    51  MLOAD
	1884    90  SWAP1
	1885    92  SWAP3
	1886    90  SWAP1
	1887    91  SWAP2
	1888    50  POP
	1889    56  *JUMP
	// Stack delta = -3
	// Outputs[2]
	// {
	//     @1885  stack[-5] = memory[stack[-3]:stack[-3] + 0x20]
	//     @1887  stack[-4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]
	// }
	// Block ends with unconditional jump to stack[-5]

label_188A:
	// Incoming call from 0x011A, returns to 0x011B
	// Incoming call from 0x0B96, returns to 0x0B97
	// Inputs[2]
	// {
	//     @188F  stack[-1]
	//     @1890  stack[-2]
	// }
	188A    5B  JUMPDEST
	188B    60  PUSH1 0x00
	188D    60  PUSH1 0x20
	188F    82  DUP3
	1890    84  DUP5
	1891    03  SUB
	1892    12  SLT
	1893    15  ISZERO
	1894    61  PUSH2 0x189c
	1897    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @188B  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x189c, if !(stack[-2] - stack[-1] i< 0x20)

label_1898:
	// Incoming jump from 0x1897, if not !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[1] { @189B  memory[0x00:0x00] }
	1898    60  PUSH1 0x00
	189A    80  DUP1
	189B    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @189B  revert(memory[0x00:0x00]); }
	// Block terminates

label_189C:
	// Incoming jump from 0x1897, if !(stack[-2] - stack[-1] i< 0x20)
	// Inputs[2]
	// {
	//     @189D  stack[-2]
	//     @189E  msg.data[stack[-2]:stack[-2] + 0x20]
	// }
	189C    5B  JUMPDEST
	189D    81  DUP2
	189E    35  CALLDATALOAD
	189F    67  PUSH8 0xffffffffffffffff
	18A8    81  DUP2
	18A9    16  AND
	18AA    81  DUP2
	18AB    14  EQ
	18AC    61  PUSH2 0x1400
	18AF    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @189E  stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] }
	// Block ends with conditional jump to 0x1400, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffff

label_18B0:
	// Incoming jump from 0x18AF, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffff
	// Inputs[1] { @18B3  memory[0x00:0x00] }
	18B0    60  PUSH1 0x00
	18B2    80  DUP1
	18B3    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @18B3  revert(memory[0x00:0x00]); }
	// Block terminates

	18B4    5B    JUMPDEST
	18B5    60    PUSH1 0x00
	18B7    60    PUSH1 0x20
	18B9    82    DUP3
	18BA    84    DUP5
	18BB    03    SUB
	18BC    12    SLT
	18BD    15    ISZERO
	18BE    61    PUSH2 0x18c6
	18C1    57    *JUMPI
	18C2    60    PUSH1 0x00
	18C4    80    DUP1
	18C5    FD    *REVERT
	18C6    5B    JUMPDEST
	18C7    81    DUP2
	18C8    35    CALLDATALOAD
	18C9    61    PUSH2 0x1400
	18CC    81    DUP2
	18CD    61    PUSH2 0x1c62
	18D0    56    *JUMP
	18D1    5B    JUMPDEST
	18D2    60    PUSH1 0x00
	18D4    60    PUSH1 0x20
	18D6    82    DUP3
	18D7    84    DUP5
	18D8    03    SUB
	18D9    12    SLT
	18DA    15    ISZERO
	18DB    61    PUSH2 0x18e3
	18DE    57    *JUMPI
	18DF    60    PUSH1 0x00
	18E1    80    DUP1
	18E2    FD    *REVERT
	18E3    5B    JUMPDEST
	18E4    81    DUP2
	18E5    35    CALLDATALOAD
	18E6    61    PUSH2 0x1400
	18E9    81    DUP2
	18EA    61    PUSH2 0x1c71
	18ED    56    *JUMP
label_18EE:
	// Incoming call from 0x01E0, returns to 0x01E1
	// Incoming call from 0x07E0, returns to 0x07E1
	// Inputs[2]
	// {
	//     @1904  stack[-1]
	//     @1905  stack[-2]
	// }
	18EE    5B  JUMPDEST
	18EF    60  PUSH1 0x00
	18F1    80  DUP1
	18F2    60  PUSH1 0x00
	18F4    80  DUP1
	18F5    60  PUSH1 0x00
	18F7    80  DUP1
	18F8    60  PUSH1 0x00
	18FA    80  DUP1
	18FB    60  PUSH1 0x00
	18FD    80  DUP1
	18FE    60  PUSH1 0x00
	1900    80  DUP1
	1901    61  PUSH2 0x0180
	1904    8D  DUP14
	1905    8F  DUP16
	1906    03  SUB
	1907    12  SLT
	1908    15  ISZERO
	1909    61  PUSH2 0x1911
	190C    57  *JUMPI
	// Stack delta = +12
	// Outputs[12]
	// {
	//     @18EF  stack[0] = 0x00
	//     @18F1  stack[1] = 0x00
	//     @18F2  stack[2] = 0x00
	//     @18F4  stack[3] = 0x00
	//     @18F5  stack[4] = 0x00
	//     @18F7  stack[5] = 0x00
	//     @18F8  stack[6] = 0x00
	//     @18FA  stack[7] = 0x00
	//     @18FB  stack[8] = 0x00
	//     @18FD  stack[9] = 0x00
	//     @18FE  stack[10] = 0x00
	//     @1900  stack[11] = 0x00
	// }
	// Block ends with conditional jump to 0x1911, if !(stack[-2] - stack[-1] i< 0x0180)

label_190D:
	// Incoming jump from 0x190C, if not !(stack[-2] - stack[-1] i< 0x0180)
	// Inputs[1] { @1910  memory[0x00:0x00] }
	190D    60  PUSH1 0x00
	190F    80  DUP1
	1910    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1910  revert(memory[0x00:0x00]); }
	// Block terminates

label_1911:
	// Incoming jump from 0x190C, if !(stack[-2] - stack[-1] i< 0x0180)
	// Inputs[2]
	// {
	//     @1912  stack[-13]
	//     @1913  memory[stack[-13]:stack[-13] + 0x20]
	// }
	1911    5B  JUMPDEST
	1912    8C  DUP13
	1913    51  MLOAD
	1914    61  PUSH2 0x191c
	1917    81  DUP2
	1918    61  PUSH2 0x1c71
	191B    56  *JUMP
	// Stack delta = +3
	// Outputs[3]
	// {
	//     @1913  stack[0] = memory[stack[-13]:stack[-13] + 0x20]
	//     @1914  stack[1] = 0x191c
	//     @1917  stack[2] = memory[stack[-13]:stack[-13] + 0x20]
	// }
	// Block ends with call to 0x1c71, returns to 0x191C

label_191C:
	// Incoming return from call to 0x1C71 at 0x191B
	// Inputs[4]
	// {
	//     @191F  stack[-14]
	//     @1921  memory[stack[-14] + 0x20:stack[-14] + 0x20 + 0x20]
	//     @1922  stack[-1]
	//     @1923  stack[-13]
	// }
	191C    5B  JUMPDEST
	191D    60  PUSH1 0x20
	191F    8E  DUP15
	1920    01  ADD
	1921    51  MLOAD
	1922    90  SWAP1
	1923    9C  SWAP13
	1924    50  POP
	1925    61  PUSH2 0x192d
	1928    81  DUP2
	1929    61  PUSH2 0x1c4d
	192C    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @1922  stack[-1] = memory[stack[-14] + 0x20:stack[-14] + 0x20 + 0x20]
	//     @1923  stack[-13] = stack[-1]
	//     @1925  stack[0] = 0x192d
	//     @1928  stack[1] = memory[stack[-14] + 0x20:stack[-14] + 0x20 + 0x20]
	// }
	// Block ends with call to 0x1c4d, returns to 0x192D

label_192D:
	// Incoming return from call to 0x1C4D at 0x192C
	// Inputs[4]
	// {
	//     @1930  stack[-14]
	//     @1932  memory[stack[-14] + 0x40:stack[-14] + 0x40 + 0x20]
	//     @1933  stack[-1]
	//     @1934  stack[-12]
	// }
	192D    5B  JUMPDEST
	192E    60  PUSH1 0x40
	1930    8E  DUP15
	1931    01  ADD
	1932    51  MLOAD
	1933    90  SWAP1
	1934    9B  SWAP12
	1935    50  POP
	1936    61  PUSH2 0x193e
	1939    81  DUP2
	193A    61  PUSH2 0x1c4d
	193D    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @1933  stack[-1] = memory[stack[-14] + 0x40:stack[-14] + 0x40 + 0x20]
	//     @1934  stack[-12] = stack[-1]
	//     @1936  stack[0] = 0x193e
	//     @1939  stack[1] = memory[stack[-14] + 0x40:stack[-14] + 0x40 + 0x20]
	// }
	// Block ends with call to 0x1c4d, returns to 0x193E

label_193E:
	// Incoming return from call to 0x1C4D at 0x193D
	// Inputs[4]
	// {
	//     @1941  stack[-14]
	//     @1943  memory[stack[-14] + 0x60:stack[-14] + 0x60 + 0x20]
	//     @1944  stack[-1]
	//     @1945  stack[-11]
	// }
	193E    5B  JUMPDEST
	193F    60  PUSH1 0x60
	1941    8E  DUP15
	1942    01  ADD
	1943    51  MLOAD
	1944    90  SWAP1
	1945    9A  SWAP11
	1946    50  POP
	1947    61  PUSH2 0x194f
	194A    81  DUP2
	194B    61  PUSH2 0x1c4d
	194E    56  *JUMP
	// Stack delta = +2
	// Outputs[4]
	// {
	//     @1944  stack[-1] = memory[stack[-14] + 0x60:stack[-14] + 0x60 + 0x20]
	//     @1945  stack[-11] = stack[-1]
	//     @1947  stack[0] = 0x194f
	//     @194A  stack[1] = memory[stack[-14] + 0x60:stack[-14] + 0x60 + 0x20]
	// }
	// Block ends with call to 0x1c4d, returns to 0x194F

label_194F:
	// Incoming return from call to 0x1C4D at 0x194E
	// Inputs[3]
	// {
	//     @1950  stack[-10]
	//     @1950  stack[-1]
	//     @1957  stack[-14]
	// }
	194F    5B  JUMPDEST
	1950    98  SWAP9
	1951    50  POP
	1952    61  PUSH2 0x195d
	1955    60  PUSH1 0x80
	1957    8E  DUP15
	1958    01  ADD
	1959    61  PUSH2 0x169a
	195C    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @1950  stack[-10] = stack[-1]
	//     @1952  stack[-1] = 0x195d
	//     @1958  stack[0] = stack[-14] + 0x80
	// }
	// Block ends with call to 0x169a, returns to 0x195D

label_195D:
	// Incoming return from call to 0x169A at 0x195C
	// Inputs[3]
	// {
	//     @195E  stack[-9]
	//     @195E  stack[-1]
	//     @1965  stack[-14]
	// }
	195D    5B  JUMPDEST
	195E    97  SWAP8
	195F    50  POP
	1960    61  PUSH2 0x196b
	1963    60  PUSH1 0xa0
	1965    8E  DUP15
	1966    01  ADD
	1967    61  PUSH2 0x165f
	196A    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @195E  stack[-9] = stack[-1]
	//     @1960  stack[-1] = 0x196b
	//     @1966  stack[0] = stack[-14] + 0xa0
	// }
	// Block ends with call to 0x165f, returns to 0x196B

label_196B:
	// Incoming return from call to 0x165F at 0x196A
	// Inputs[3]
	// {
	//     @196C  stack[-1]
	//     @196C  stack[-8]
	//     @1973  stack[-14]
	// }
	196B    5B  JUMPDEST
	196C    96  SWAP7
	196D    50  POP
	196E    61  PUSH2 0x1979
	1971    60  PUSH1 0xc0
	1973    8E  DUP15
	1974    01  ADD
	1975    61  PUSH2 0x165f
	1978    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @196C  stack[-8] = stack[-1]
	//     @196E  stack[-1] = 0x1979
	//     @1974  stack[0] = stack[-14] + 0xc0
	// }
	// Block ends with call to 0x165f, returns to 0x1979

label_1979:
	// Incoming return from call to 0x165F at 0x1978
	// Inputs[3]
	// {
	//     @197A  stack[-7]
	//     @197A  stack[-1]
	//     @1981  stack[-14]
	// }
	1979    5B  JUMPDEST
	197A    95  SWAP6
	197B    50  POP
	197C    61  PUSH2 0x1987
	197F    60  PUSH1 0xe0
	1981    8E  DUP15
	1982    01  ADD
	1983    61  PUSH2 0x1671
	1986    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @197A  stack[-7] = stack[-1]
	//     @197C  stack[-1] = 0x1987
	//     @1982  stack[0] = stack[-14] + 0xe0
	// }
	// Block ends with call to 0x1671, returns to 0x1987

label_1987:
	// Incoming return from call to 0x1671 at 0x1986
	// Inputs[7]
	// {
	//     @1988  stack[-1]
	//     @1988  stack[-6]
	//     @198D  stack[-14]
	//     @198F  memory[stack[-14] + 0x0100:stack[-14] + 0x0100 + 0x20]
	//     @1990  stack[-5]
	//     @1997  memory[stack[-14] + 0x0120:stack[-14] + 0x0120 + 0x20]
	//     @1998  stack[-4]
	// }
	1987    5B  JUMPDEST
	1988    94  SWAP5
	1989    50  POP
	198A    61  PUSH2 0x0100
	198D    8D  DUP14
	198E    01  ADD
	198F    51  MLOAD
	1990    93  SWAP4
	1991    50  POP
	1992    61  PUSH2 0x0120
	1995    8D  DUP14
	1996    01  ADD
	1997    51  MLOAD
	1998    92  SWAP3
	1999    50  POP
	199A    61  PUSH2 0x19a6
	199D    61  PUSH2 0x0140
	19A0    8E  DUP15
	19A1    01  ADD
	19A2    61  PUSH2 0x1671
	19A5    56  *JUMP
	// Stack delta = +1
	// Outputs[5]
	// {
	//     @1988  stack[-6] = stack[-1]
	//     @1990  stack[-5] = memory[stack[-14] + 0x0100:stack[-14] + 0x0100 + 0x20]
	//     @1998  stack[-4] = memory[stack[-14] + 0x0120:stack[-14] + 0x0120 + 0x20]
	//     @199A  stack[-1] = 0x19a6
	//     @19A1  stack[0] = stack[-14] + 0x0140
	// }
	// Block ends with call to 0x1671, returns to 0x19A6

label_19A6:
	// Incoming return from call to 0x1671 at 0x19A5
	// Inputs[3]
	// {
	//     @19A7  stack[-1]
	//     @19A7  stack[-3]
	//     @19AF  stack[-14]
	// }
	19A6    5B  JUMPDEST
	19A7    91  SWAP2
	19A8    50  POP
	19A9    61  PUSH2 0x19b5
	19AC    61  PUSH2 0x0160
	19AF    8E  DUP15
	19B0    01  ADD
	19B1    61  PUSH2 0x1671
	19B4    56  *JUMP
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @19A7  stack[-3] = stack[-1]
	//     @19A9  stack[-1] = 0x19b5
	//     @19B0  stack[0] = stack[-14] + 0x0160
	// }
	// Block ends with call to 0x1671, returns to 0x19B5

label_19B5:
	// Incoming return from call to 0x1671 at 0x19B4
	// Inputs[16]
	// {
	//     @19B6  stack[-1]
	//     @19B6  stack[-2]
	//     @19B8  stack[-5]
	//     @19B9  stack[-8]
	//     @19BA  stack[-11]
	//     @19BB  stack[-14]
	//     @19BD  stack[-6]
	//     @19BD  stack[-3]
	//     @19BE  stack[-9]
	//     @19BF  stack[-12]
	//     @19C0  stack[-15]
	//     @19C2  stack[-4]
	//     @19C2  stack[-7]
	//     @19C3  stack[-10]
	//     @19C4  stack[-13]
	//     @19C5  stack[-16]
	// }
	19B5    5B  JUMPDEST
	19B6    90  SWAP1
	19B7    50  POP
	19B8    92  SWAP3
	19B9    95  SWAP6
	19BA    98  SWAP9
	19BB    9B  SWAP12
	19BC    50  POP
	19BD    92  SWAP3
	19BE    95  SWAP6
	19BF    98  SWAP9
	19C0    9B  SWAP12
	19C1    50  POP
	19C2    92  SWAP3
	19C3    95  SWAP6
	19C4    98  SWAP9
	19C5    9B  SWAP12
	19C6    56  *JUMP
	// Stack delta = -4
	// Outputs[12]
	// {
	//     @19B8  stack[-5] = stack[-1]
	//     @19B9  stack[-8] = stack[-5]
	//     @19BA  stack[-11] = stack[-8]
	//     @19BB  stack[-14] = stack[-11]
	//     @19BD  stack[-6] = stack[-3]
	//     @19BE  stack[-9] = stack[-6]
	//     @19BF  stack[-12] = stack[-9]
	//     @19C0  stack[-15] = stack[-12]
	//     @19C2  stack[-7] = stack[-4]
	//     @19C3  stack[-10] = stack[-7]
	//     @19C4  stack[-13] = stack[-10]
	//     @19C5  stack[-16] = stack[-13]
	// }
	// Block ends with unconditional jump to stack[-16]

	19C7    5B    JUMPDEST
	19C8    60    PUSH1 0x00
	19CA    82    DUP3
	19CB    51    MLOAD
	19CC    60    PUSH1 0x00
	19CE    5B    JUMPDEST
	19CF    81    DUP2
	19D0    81    DUP2
	19D1    10    LT
	19D2    15    ISZERO
	19D3    61    PUSH2 0x19e8
	19D6    57    *JUMPI
	19D7    60    PUSH1 0x20
	19D9    81    DUP2
	19DA    86    DUP7
	19DB    01    ADD
	19DC    81    DUP2
	19DD    01    ADD
	19DE    51    MLOAD
	19DF    85    DUP6
	19E0    83    DUP4
	19E1    01    ADD
	19E2    52    MSTORE
	19E3    01    ADD
	19E4    61    PUSH2 0x19ce
	19E7    56    *JUMP
	19E8    5B    JUMPDEST
	19E9    81    DUP2
	19EA    81    DUP2
	19EB    11    GT
	19EC    15    ISZERO
	19ED    61    PUSH2 0x19f7
	19F0    57    *JUMPI
	19F1    60    PUSH1 0x00
	19F3    82    DUP3
	19F4    85    DUP6
	19F5    01    ADD
	19F6    52    MSTORE
	19F7    5B    JUMPDEST
	19F8    50    POP
	19F9    91    SWAP2
	19FA    90    SWAP1
	19FB    91    SWAP2
	19FC    01    ADD
	19FD    92    SWAP3
	19FE    91    SWAP2
	19FF    50    POP
	1A00    50    POP
	1A01    56    *JUMP
label_1A02:
	// Incoming call from 0x033E, returns to 0x033F
	// Incoming call from 0x0922, returns to 0x0923
	// Inputs[7]
	// {
	//     @1A03  stack[-2]
	//     @1A04  memory[stack[-2]:stack[-2] + 0x20]
	//     @1A05  stack[-1]
	//     @1A0C  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	//     @1A1F  memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20]
	//     @1A37  memory[0x60 + stack[-2]:0x60 + stack[-2] + 0x20]
	//     @1A43  stack[-3]
	// }
	1A02    5B  JUMPDEST
	1A03    81  DUP2
	1A04    51  MLOAD
	1A05    81  DUP2
	1A06    52  MSTORE
	1A07    60  PUSH1 0x20
	1A09    80  DUP1
	1A0A    83  DUP4
	1A0B    01  ADD
	1A0C    51  MLOAD
	1A0D    60  PUSH1 0x01
	1A0F    60  PUSH1 0x01
	1A11    60  PUSH1 0xa0
	1A13    1B  SHL
	1A14    03  SUB
	1A15    16  AND
	1A16    90  SWAP1
	1A17    82  DUP3
	1A18    01  ADD
	1A19    52  MSTORE
	1A1A    60  PUSH1 0x40
	1A1C    80  DUP1
	1A1D    83  DUP4
	1A1E    01  ADD
	1A1F    51  MLOAD
	1A20    60  PUSH1 0x01
	1A22    60  PUSH1 0x01
	1A24    60  PUSH1 0x80
	1A26    1B  SHL
	1A27    03  SUB
	1A28    90  SWAP1
	1A29    81  DUP2
	1A2A    16  AND
	1A2B    91  SWAP2
	1A2C    83  DUP4
	1A2D    01  ADD
	1A2E    91  SWAP2
	1A2F    90  SWAP1
	1A30    91  SWAP2
	1A31    52  MSTORE
	1A32    60  PUSH1 0x60
	1A34    92  SWAP3
	1A35    83  DUP4
	1A36    01  ADD
	1A37    51  MLOAD
	1A38    16  AND
	1A39    91  SWAP2
	1A3A    81  DUP2
	1A3B    01  ADD
	1A3C    91  SWAP2
	1A3D    90  SWAP1
	1A3E    91  SWAP2
	1A3F    52  MSTORE
	1A40    60  PUSH1 0x80
	1A42    01  ADD
	1A43    90  SWAP1
	1A44    56  *JUMP
	// Stack delta = -2
	// Outputs[5]
	// {
	//     @1A06  memory[stack[-1]:stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20]
	//     @1A19  memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	//     @1A31  memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = (0x01 << 0x80) - 0x01 & memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20]
	//     @1A3F  memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = memory[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] & (0x01 << 0x80) - 0x01
	//     @1A43  stack[-3] = 0x80 + stack[-1]
	// }
	// Block ends with unconditional jump to stack[-3]

label_1A45:
	// Incoming call from 0x0262, returns to 0x0263
	// Incoming call from 0x0865, returns to 0x0866
	// Inputs[8]
	// {
	//     @1A4A  stack[-1]
	//     @1A4E  stack[-2]
	//     @1A4F  memory[stack[-2]:stack[-2] + 0x20]
	//     @1A5E  memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20]
	//     @1A69  memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20]
	//     @1A73  memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20]
	//     @1A7D  memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20]
	//     @1A83  stack[-3]
	// }
	1A45    5B  JUMPDEST
	1A46    60  PUSH1 0x00
	1A48    60  PUSH1 0xa0
	1A4A    82  DUP3
	1A4B    01  ADD
	1A4C    90  SWAP1
	1A4D    50  POP
	1A4E    82  DUP3
	1A4F    51  MLOAD
	1A50    82  DUP3
	1A51    52  MSTORE
	1A52    60  PUSH1 0x01
	1A54    60  PUSH1 0x01
	1A56    60  PUSH1 0x80
	1A58    1B  SHL
	1A59    03  SUB
	1A5A    60  PUSH1 0x20
	1A5C    84  DUP5
	1A5D    01  ADD
	1A5E    51  MLOAD
	1A5F    16  AND
	1A60    60  PUSH1 0x20
	1A62    83  DUP4
	1A63    01  ADD
	1A64    52  MSTORE
	1A65    60  PUSH1 0x40
	1A67    83  DUP4
	1A68    01  ADD
	1A69    51  MLOAD
	1A6A    60  PUSH1 0x40
	1A6C    83  DUP4
	1A6D    01  ADD
	1A6E    52  MSTORE
	1A6F    60  PUSH1 0x60
	1A71    83  DUP4
	1A72    01  ADD
	1A73    51  MLOAD
	1A74    60  PUSH1 0x60
	1A76    83  DUP4
	1A77    01  ADD
	1A78    52  MSTORE
	1A79    60  PUSH1 0x80
	1A7B    83  DUP4
	1A7C    01  ADD
	1A7D    51  MLOAD
	1A7E    60  PUSH1 0x80
	1A80    83  DUP4
	1A81    01  ADD
	1A82    52  MSTORE
	1A83    92  SWAP3
	1A84    91  SWAP2
	1A85    50  POP
	1A86    50  POP
	1A87    56  *JUMP
	// Stack delta = -2
	// Outputs[6]
	// {
	//     @1A51  memory[stack[-1]:stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20]
	//     @1A64  memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & (0x01 << 0x80) - 0x01
	//     @1A6E  memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20]
	//     @1A78  memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20]
	//     @1A82  memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20]
	//     @1A83  stack[-3] = stack[-1] + 0xa0
	// }
	// Block ends with unconditional jump to stack[-3]

	1A88    5B    JUMPDEST
	1A89    81    DUP2
	1A8A    51    MLOAD
	1A8B    60    PUSH1 0x01
	1A8D    60    PUSH1 0x01
	1A8F    60    PUSH1 0xa0
	1A91    1B    SHL
	1A92    03    SUB
	1A93    16    AND
	1A94    81    DUP2
	1A95    52    MSTORE
	1A96    61    PUSH2 0x0160
	1A99    81    DUP2
	1A9A    01    ADD
	1A9B    60    PUSH1 0x20
	1A9D    83    DUP4
	1A9E    01    ADD
	1A9F    51    MLOAD
	1AA0    61    PUSH2 0x1ab4
	1AA3    60    PUSH1 0x20
	1AA5    84    DUP5
	1AA6    01    ADD
	1AA7    82    DUP3
	1AA8    60    PUSH1 0x01
	1AAA    60    PUSH1 0x01
	1AAC    60    PUSH1 0xa0
	1AAE    1B    SHL
	1AAF    03    SUB
	1AB0    16    AND
	1AB1    90    SWAP1
	1AB2    52    MSTORE
	1AB3    56    *JUMP
	1AB4    5B    JUMPDEST
	1AB5    50    POP
	1AB6    60    PUSH1 0x40
	1AB8    83    DUP4
	1AB9    01    ADD
	1ABA    51    MLOAD
	1ABB    61    PUSH2 0x1acb
	1ABE    60    PUSH1 0x40
	1AC0    84    DUP5
	1AC1    01    ADD
	1AC2    82    DUP3
	1AC3    62    PUSH3 0xffffff
	1AC7    16    AND
	1AC8    90    SWAP1
	1AC9    52    MSTORE
	1ACA    56    *JUMP
	1ACB    5B    JUMPDEST
	1ACC    50    POP
	1ACD    60    PUSH1 0x60
	1ACF    83    DUP4
	1AD0    01    ADD
	1AD1    51    MLOAD
	1AD2    61    PUSH2 0x1ae0
	1AD5    60    PUSH1 0x60
	1AD7    84    DUP5
	1AD8    01    ADD
	1AD9    82    DUP3
	1ADA    60    PUSH1 0x02
	1ADC    0B    SIGNEXTEND
	1ADD    90    SWAP1
	1ADE    52    MSTORE
	1ADF    56    *JUMP
	1AE0    5B    JUMPDEST
	1AE1    50    POP
	1AE2    60    PUSH1 0x80
	1AE4    83    DUP4
	1AE5    01    ADD
	1AE6    51    MLOAD
	1AE7    61    PUSH2 0x1af5
	1AEA    60    PUSH1 0x80
	1AEC    84    DUP5
	1AED    01    ADD
	1AEE    82    DUP3
	1AEF    60    PUSH1 0x02
	1AF1    0B    SIGNEXTEND
	1AF2    90    SWAP1
	1AF3    52    MSTORE
	1AF4    56    *JUMP
	1AF5    5B    JUMPDEST
	1AF6    50    POP
	1AF7    60    PUSH1 0xa0
	1AF9    83    DUP4
	1AFA    01    ADD
	1AFB    51    MLOAD
	1AFC    60    PUSH1 0xa0
	1AFE    83    DUP4
	1AFF    01    ADD
	1B00    52    MSTORE
	1B01    60    PUSH1 0xc0
	1B03    83    DUP4
	1B04    01    ADD
	1B05    51    MLOAD
	1B06    60    PUSH1 0xc0
	1B08    83    DUP4
	1B09    01    ADD
	1B0A    52    MSTORE
	1B0B    60    PUSH1 0xe0
	1B0D    83    DUP4
	1B0E    01    ADD
	1B0F    51    MLOAD
	1B10    60    PUSH1 0xe0
	1B12    83    DUP4
	1B13    01    ADD
	1B14    52    MSTORE
	1B15    61    PUSH2 0x0100
	1B18    80    DUP1
	1B19    84    DUP5
	1B1A    01    ADD
	1B1B    51    MLOAD
	1B1C    81    DUP2
	1B1D    84    DUP5
	1B1E    01    ADD
	1B1F    52    MSTORE
	1B20    50    POP
	1B21    61    PUSH2 0x0120
	1B24    80    DUP1
	1B25    84    DUP5
	1B26    01    ADD
	1B27    51    MLOAD
	1B28    61    PUSH2 0x1b3b
	1B2B    82    DUP3
	1B2C    85    DUP6
	1B2D    01    ADD
	1B2E    82    DUP3
	1B2F    60    PUSH1 0x01
	1B31    60    PUSH1 0x01
	1B33    60    PUSH1 0xa0
	1B35    1B    SHL
	1B36    03    SUB
	1B37    16    AND
	1B38    90    SWAP1
	1B39    52    MSTORE
	1B3A    56    *JUMP
	1B3B    5B    JUMPDEST
	1B3C    50    POP
	1B3D    50    POP
	1B3E    61    PUSH2 0x0140
	1B41    92    SWAP3
	1B42    83    DUP4
	1B43    01    ADD
	1B44    51    MLOAD
	1B45    91    SWAP2
	1B46    90    SWAP1
	1B47    92    SWAP3
	1B48    01    ADD
	1B49    52    MSTORE
	1B4A    90    SWAP1
	1B4B    56    *JUMP
label_1B4C:
	// Incoming call from 0x13F5, returns to 0x13F6
	// Inputs[2]
	// {
	//     @1B4F  stack[-2]
	//     @1B51  stack[-1]
	// }
	1B4C    5B  JUMPDEST
	1B4D    60  PUSH1 0x00
	1B4F    82  DUP3
	1B50    19  NOT
	1B51    82  DUP3
	1B52    11  GT
	1B53    15  ISZERO
	1B54    61  PUSH2 0x1b5f
	1B57    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1B4D  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1b5f, if !(stack[-1] > ~stack[-2])

label_1B58:
	// Incoming jump from 0x1B57, if not !(stack[-1] > ~stack[-2])
	1B58    61  PUSH2 0x1b5f
	1B5B    61  PUSH2 0x1c21
	1B5E    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1B58  stack[0] = 0x1b5f }
	// Block ends with unconditional jump to 0x1c21

label_1B5F:
	// Incoming jump from 0x1B57, if !(stack[-1] > ~stack[-2])
	// Inputs[3]
	// {
	//     @1B61  stack[-3]
	//     @1B61  stack[-2]
	//     @1B62  stack[-4]
	// }
	1B5F    5B  JUMPDEST
	1B60    50  POP
	1B61    01  ADD
	1B62    90  SWAP1
	1B63    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @1B62  stack[-4] = stack[-2] + stack[-3] }
	// Block ends with unconditional jump to stack[-4]

label_1B64:
	// Incoming call from 0x13FF, returns to 0x1400
	// Incoming call from 0x13D9, returns to 0x13DA
	// Inputs[1] { @1B67  stack[-2] }
	1B64    5B  JUMPDEST
	1B65    60  PUSH1 0x00
	1B67    82  DUP3
	1B68    61  PUSH2 0x1b81
	1B6B    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1B65  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1b81, if stack[-2]

label_1B6C:
	// Incoming jump from 0x1B6B, if not stack[-2]
	// Inputs[1] { @1B80  memory[0x00:0x24] }
	1B6C    63  PUSH4 0x4e487b71
	1B71    60  PUSH1 0xe0
	1B73    1B  SHL
	1B74    60  PUSH1 0x00
	1B76    52  MSTORE
	1B77    60  PUSH1 0x12
	1B79    60  PUSH1 0x04
	1B7B    52  MSTORE
	1B7C    60  PUSH1 0x24
	1B7E    60  PUSH1 0x00
	1B80    FD  *REVERT
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @1B76  memory[0x00:0x20] = 0x4e487b71 << 0xe0
	//     @1B7B  memory[0x04:0x24] = 0x12
	//     @1B80  revert(memory[0x00:0x24]);
	// }
	// Block terminates

label_1B81:
	// Incoming jump from 0x1B6B, if stack[-2]
	// Inputs[3]
	// {
	//     @1B83  stack[-3]
	//     @1B83  stack[-2]
	//     @1B84  stack[-4]
	// }
	1B81    5B  JUMPDEST
	1B82    50  POP
	1B83    04  DIV
	1B84    90  SWAP1
	1B85    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @1B84  stack[-4] = stack[-2] / stack[-3] }
	// Block ends with unconditional jump to stack[-4]

label_1B86:
	// Incoming call from 0x13EB, returns to 0x13EC
	// Inputs[2]
	// {
	//     @1B89  stack[-1]
	//     @1B8E  stack[-2]
	// }
	1B86    5B  JUMPDEST
	1B87    60  PUSH1 0x00
	1B89    81  DUP2
	1B8A    60  PUSH1 0x00
	1B8C    19  NOT
	1B8D    04  DIV
	1B8E    83  DUP4
	1B8F    11  GT
	1B90    82  DUP3
	1B91    15  ISZERO
	1B92    15  ISZERO
	1B93    16  AND
	1B94    15  ISZERO
	1B95    61  PUSH2 0x1ba0
	1B98    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1B87  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1ba0, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1]))

label_1B99:
	// Incoming jump from 0x1B98, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1]))
	1B99    61  PUSH2 0x1ba0
	1B9C    61  PUSH2 0x1c21
	1B9F    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1B99  stack[0] = 0x1ba0 }
	// Block ends with unconditional jump to 0x1c21

label_1BA0:
	// Incoming jump from 0x1B98, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1]))
	// Inputs[3]
	// {
	//     @1BA2  stack[-3]
	//     @1BA2  stack[-2]
	//     @1BA3  stack[-4]
	// }
	1BA0    5B  JUMPDEST
	1BA1    50  POP
	1BA2    02  MUL
	1BA3    90  SWAP1
	1BA4    56  *JUMP
	// Stack delta = -3
	// Outputs[1] { @1BA3  stack[-4] = stack[-2] * stack[-3] }
	// Block ends with unconditional jump to stack[-4]

	1BA5    5B    JUMPDEST
	1BA6    60    PUSH1 0x00
	1BA8    81    DUP2
	1BA9    60    PUSH1 0x02
	1BAB    0B    SIGNEXTEND
	1BAC    83    DUP4
	1BAD    60    PUSH1 0x02
	1BAF    0B    SIGNEXTEND
	1BB0    60    PUSH1 0x00
	1BB2    81    DUP2
	1BB3    12    SLT
	1BB4    81    DUP2
	1BB5    62    PUSH3 0x7fffff
	1BB9    19    NOT
	1BBA    01    ADD
	1BBB    83    DUP4
	1BBC    12    SLT
	1BBD    81    DUP2
	1BBE    15    ISZERO
	1BBF    16    AND
	1BC0    15    ISZERO
	1BC1    61    PUSH2 0x1bcc
	1BC4    57    *JUMPI
	1BC5    61    PUSH2 0x1bcc
	1BC8    61    PUSH2 0x1c21
	1BCB    56    *JUMP
	1BCC    5B    JUMPDEST
	1BCD    81    DUP2
	1BCE    62    PUSH3 0x7fffff
	1BD2    01    ADD
	1BD3    83    DUP4
	1BD4    13    SGT
	1BD5    81    DUP2
	1BD6    16    AND
	1BD7    15    ISZERO
	1BD8    61    PUSH2 0x1be3
	1BDB    57    *JUMPI
	1BDC    61    PUSH2 0x1be3
	1BDF    61    PUSH2 0x1c21
	1BE2    56    *JUMP
	1BE3    5B    JUMPDEST
	1BE4    50    POP
	1BE5    90    SWAP1
	1BE6    03    SUB
	1BE7    93    SWAP4
	1BE8    92    SWAP3
	1BE9    50    POP
	1BEA    50    POP
	1BEB    50    POP
	1BEC    56    *JUMP
	1BED    5B    JUMPDEST
	1BEE    60    PUSH1 0x00
	1BF0    82    DUP3
	1BF1    82    DUP3
	1BF2    10    LT
	1BF3    15    ISZERO
	1BF4    61    PUSH2 0x1bff
	1BF7    57    *JUMPI
	1BF8    61    PUSH2 0x1bff
	1BFB    61    PUSH2 0x1c21
	1BFE    56    *JUMP
	1BFF    5B    JUMPDEST
	1C00    50    POP
	1C01    03    SUB
	1C02    90    SWAP1
	1C03    56    *JUMP
label_1C04:
	// Incoming call from 0x05D4, returns to 0x05D5
	// Inputs[1] { @1C0C  stack[-1] }
	1C04    5B  JUMPDEST
	1C05    60  PUSH1 0x00
	1C07    60  PUSH1 0x01
	1C09    60  PUSH1 0xff
	1C0B    1B  SHL
	1C0C    82  DUP3
	1C0D    14  EQ
	1C0E    15  ISZERO
	1C0F    61  PUSH2 0x1c1a
	1C12    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @1C05  stack[0] = 0x00 }
	// Block ends with conditional jump to 0x1c1a, if !(stack[-1] == 0x01 << 0xff)

label_1C13:
	// Incoming jump from 0x1C12, if not !(stack[-1] == 0x01 << 0xff)
	1C13    61  PUSH2 0x1c1a
	1C16    61  PUSH2 0x1c21
	1C19    56  *JUMP
	// Stack delta = +1
	// Outputs[1] { @1C13  stack[0] = 0x1c1a }
	// Block ends with unconditional jump to 0x1c21

label_1C1A:
	// Incoming jump from 0x1C12, if !(stack[-1] == 0x01 << 0xff)
	// Inputs[2]
	// {
	//     @1C1E  stack[-2]
	//     @1C1F  stack[-3]
	// }
	1C1A    5B  JUMPDEST
	1C1B    50  POP
	1C1C    60  PUSH1 0x00
	1C1E    03  SUB
	1C1F    90  SWAP1
	1C20    56  *JUMP
	// Stack delta = -2
	// Outputs[1] { @1C1F  stack[-3] = 0x00 - stack[-2] }
	// Block ends with unconditional jump to stack[-3]

label_1C21:
	// Incoming jump from 0x1B5E
	// Incoming jump from 0x1B9F
	// Incoming jump from 0x1C19
	// Inputs[1] { @1C36  memory[0x00:0x24] }
	1C21    5B  JUMPDEST
	1C22    63  PUSH4 0x4e487b71
	1C27    60  PUSH1 0xe0
	1C29    1B  SHL
	1C2A    60  PUSH1 0x00
	1C2C    52  MSTORE
	1C2D    60  PUSH1 0x11
	1C2F    60  PUSH1 0x04
	1C31    52  MSTORE
	1C32    60  PUSH1 0x24
	1C34    60  PUSH1 0x00
	1C36    FD  *REVERT
	// Stack delta = +0
	// Outputs[3]
	// {
	//     @1C2C  memory[0x00:0x20] = 0x4e487b71 << 0xe0
	//     @1C31  memory[0x04:0x24] = 0x11
	//     @1C36  revert(memory[0x00:0x24]);
	// }
	// Block terminates

	1C37    5B    JUMPDEST
	1C38    63    PUSH4 0x4e487b71
	1C3D    60    PUSH1 0xe0
	1C3F    1B    SHL
	1C40    60    PUSH1 0x00
	1C42    52    MSTORE
	1C43    60    PUSH1 0x12
	1C45    60    PUSH1 0x04
	1C47    52    MSTORE
	1C48    60    PUSH1 0x24
	1C4A    60    PUSH1 0x00
	1C4C    FD    *REVERT
label_1C4D:
	// Incoming call from 0x16C9, returns to 0x1400
	// Incoming call from 0x16E6, returns to 0x1400
	// Incoming call from 0x193D, returns to 0x193E
	// Incoming call from 0x192C, returns to 0x192D
	// Incoming call from 0x194E, returns to 0x194F
	// Inputs[1] { @1C56  stack[-1] }
	1C4D    5B  JUMPDEST
	1C4E    60  PUSH1 0x01
	1C50    60  PUSH1 0x01
	1C52    60  PUSH1 0xa0
	1C54    1B  SHL
	1C55    03  SUB
	1C56    81  DUP2
	1C57    16  AND
	1C58    81  DUP2
	1C59    14  EQ
	1C5A    61  PUSH2 0x0a4b
	1C5D    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0a4b, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01

label_1C5E:
	// Incoming jump from 0x1C5D, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01
	// Inputs[1] { @1C61  memory[0x00:0x00] }
	1C5E    60  PUSH1 0x00
	1C60    80  DUP1
	1C61    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1C61  revert(memory[0x00:0x00]); }
	// Block terminates

	1C62    5B    JUMPDEST
	1C63    60    PUSH1 0xff
	1C65    81    DUP2
	1C66    16    AND
	1C67    81    DUP2
	1C68    14    EQ
	1C69    61    PUSH2 0x0a4b
	1C6C    57    *JUMPI
	1C6D    60    PUSH1 0x00
	1C6F    80    DUP1
	1C70    FD    *REVERT
label_1C71:
	// Incoming call from 0x191B, returns to 0x191C
	// Inputs[1] { @1C7A  stack[-1] }
	1C71    5B  JUMPDEST
	1C72    60  PUSH1 0x01
	1C74    60  PUSH1 0x01
	1C76    60  PUSH1 0x60
	1C78    1B  SHL
	1C79    03  SUB
	1C7A    81  DUP2
	1C7B    16  AND
	1C7C    81  DUP2
	1C7D    14  EQ
	1C7E    61  PUSH2 0x0a4b
	1C81    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x0a4b, if stack[-1] == stack[-1] & (0x01 << 0x60) - 0x01

label_1C82:
	// Incoming jump from 0x1C81, if not stack[-1] == stack[-1] & (0x01 << 0x60) - 0x01
	// Inputs[1] { @1C85  memory[0x00:0x00] }
	1C82    60  PUSH1 0x00
	1C84    80  DUP1
	1C85    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @1C85  revert(memory[0x00:0x00]); }
	// Block terminates

	1C86    FE    *ASSERT
	1C87    82    DUP3
	1C88    99    SWAP10
	1C89    46    CHAINID
	1C8A    F8    F8
	1C8B    7D    PUSH30 0x7248b79f2478fffd8cba0088f288d620ca8dd92ff57a0e7bab40f2a26469
	1CAA    70    PUSH17 0x667358221220bbb97b6a5bdee5b5eb43bf
	1CBC    4F    4F
	1CBD    76    PUSH23 0x19c4c7b1bb9ee5e2d0cc99f3ced41279bc508464736f6c
	1CD5    63    PUSH4 0x43000807
	1CDA    00    *STOP
	1CDB    33    CALLER