Online Solidity Decompiler

« Decompile another contract

Address

0x2f797ebd6bb007b0bb1df71cb3b827a3e35a7625 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.

0x22e8c8fc gamble(uint256,uint256)

0x88896a0d deliverPrize(address,bytes)

0xfb4fd984 requestPrize(bytes32,uint8,bytes32,bytes32)

Internal Methods

gamble(arg0, arg1)

deliverPrize(arg0, arg1)

requestPrize(arg0, arg1, arg2, arg3) returns (r0)

Decompilation

contract Contract {
    function main() {
        memory[0x40:0x60] = 0x80;
    
        if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
    
        var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
    
        if (var0 == 0x22e8c8fc) {
            // Dispatch table entry for gamble(uint256,uint256)
            var var1 = msg.value;
        
            if (var1) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0091;
            var var2 = msg.data[0x04:0x24];
            var var3 = msg.data[0x24:0x44];
            gamble(var2, var3);
            stop();
        } else if (var0 == 0x88896a0d) {
            // Dispatch table entry for deliverPrize(address,bytes)
            var1 = msg.value;
        
            if (var1) { revert(memory[0x00:0x00]); }
        
            var1 = 0x011a;
            var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
            var temp0 = msg.data[0x24:0x44] + 0x04;
            var temp1 = msg.data[temp0:temp0 + 0x20];
            var temp2 = memory[0x40:0x60];
            memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20;
            memory[temp2:temp2 + 0x20] = temp1;
            memory[temp2 + 0x20:temp2 + 0x20 + temp1] = msg.data[temp0 + 0x20:temp0 + 0x20 + temp1];
            var3 = temp2;
            deliverPrize(var2, var3);
            stop();
        } else if (var0 == 0xfb4fd984) {
            // Dispatch table entry for requestPrize(bytes32,uint8,bytes32,bytes32)
            var1 = msg.value;
        
            if (var1) { revert(memory[0x00:0x00]); }
        
            var1 = 0x0174;
            var2 = msg.data[0x04:0x24];
            var3 = msg.data[0x24:0x44] & 0xff;
            var var4 = msg.data[0x44:0x64];
            var var5 = msg.data[0x64:0x84];
            var1 = requestPrize(var2, var3, var4, var5);
            var temp3 = memory[0x40:0x60];
            memory[temp3:temp3 + 0x20] = !!var1;
            var temp4 = memory[0x40:0x60];
            return memory[temp4:temp4 + (temp3 + 0x20) - temp4];
        } else { revert(memory[0x00:0x00]); }
    }
    
    function gamble(var arg0, var arg1) {
        var var0 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff;
        var var1 = 0x22e8c8fc;
        var temp0 = memory[0x40:0x60];
        memory[temp0:temp0 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
        var temp1 = temp0 + 0x04;
        memory[temp1:temp1 + 0x20] = arg0;
        var temp2 = temp1 + 0x20;
        memory[temp2:temp2 + 0x20] = arg1;
        var var2 = temp2 + 0x20;
        var var3 = 0x00;
        var var4 = memory[0x40:0x60];
        var var5 = var2 - var4;
        var var6 = var4;
        var var7 = 0x00;
        var var8 = var0;
        var var9 = !address(var8).code.length;
    
        if (var9) { revert(memory[0x00:0x00]); }
    
        var temp3;
        temp3, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]);
        var3 = !temp3;
    
        if (!var3) { return; }
    
        var temp4 = returndata.length;
        memory[0x00:0x00 + temp4] = returndata[0x00:0x00 + temp4];
        revert(memory[0x00:0x00 + returndata.length]);
    }
    
    function deliverPrize(var arg0, var arg1) {
        if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
    
        var var0 = 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80;
        var var1 = arg0;
        var temp0 = arg1;
        var var2 = temp0;
        var temp1 = memory[0x40:0x60];
        var var3 = temp1;
        memory[var3:var3 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff;
        var temp2 = var3 + 0x20;
        var var4 = temp2;
        var temp3 = var4 + 0x20;
        memory[var4:var4 + 0x20] = temp3 - var3;
        memory[temp3:temp3 + 0x20] = memory[var2:var2 + 0x20];
        var var5 = temp3 + 0x20;
        var var6 = var2 + 0x20;
        var var7 = memory[var2:var2 + 0x20];
        var var8 = var7;
        var var9 = var5;
        var var10 = var6;
        var var11 = 0x00;
    
        if (var11 >= var8) {
        label_0333:
            var temp4 = var7;
            var5 = temp4 + var5;
            var6 = temp4 & 0x1f;
        
            if (!var6) {
                var temp5 = memory[0x40:0x60];
                log(memory[temp5:temp5 + var5 - temp5], [stack[-7]]);
                return;
            } else {
                var temp6 = var6;
                var temp7 = var5 - temp6;
                memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
                var temp8 = memory[0x40:0x60];
                log(memory[temp8:temp8 + (temp7 + 0x20) - temp8], [stack[-7]]);
                return;
            }
        } else {
        label_0321:
            var temp9 = var11;
            memory[var9 + temp9:var9 + temp9 + 0x20] = memory[var10 + temp9:var10 + temp9 + 0x20];
            var11 = temp9 + 0x20;
        
            if (var11 >= var8) { goto label_0333; }
            else { goto label_0321; }
        }
    }
    
    function requestPrize(var arg0, var arg1, var arg2, var arg3) returns (var r0) {
        var var0 = 0x00;
        var var1 = msg.sender;
        var var2 = 0x01;
        var temp0 = memory[0x40:0x60];
        memory[temp0:temp0 + 0x20] = 0x00;
        memory[0x40:0x60] = temp0 + 0x20;
        var temp1 = memory[0x40:0x60];
        memory[temp1:temp1 + 0x20] = arg0;
        var temp2 = temp1 + 0x20;
        memory[temp2:temp2 + 0x20] = arg1 & 0xff;
        var temp3 = temp2 + 0x20;
        memory[temp3:temp3 + 0x20] = arg2;
        var temp4 = temp3 + 0x20;
        memory[temp4:temp4 + 0x20] = arg3;
        var var3 = temp4 + 0x20;
        var temp5 = memory[0x40:0x60];
        var temp6;
        temp6, memory[temp5 - 0x20:temp5 - 0x20 + 0x20] = address(var2).call.gas(msg.gas)(memory[temp5:temp5 + var3 - temp5]);
        var var4 = !temp6;
    
        if (!var4) {
            var temp7 = memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff == var1;
            var1 = temp7;
        
            if (!var1) {
            label_0522:
            
                if (!var1) { return 0x00; }
            
                var temp8 = memory[0x40:0x60];
                memory[temp8:temp8 + 0x20] = arg0;
                var temp9 = temp8 + 0x20;
                memory[temp9:temp9 + 0x20] = arg1 & 0xff;
                var temp10 = temp9 + 0x20;
                memory[temp10:temp10 + 0x20] = arg2;
                var temp11 = temp10 + 0x20;
                memory[temp11:temp11 + 0x20] = arg3;
                var temp12 = memory[0x40:0x60];
                log(memory[temp12:temp12 + (temp11 + 0x20) - temp12], [0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573]);
                return 0x01;
            } else {
                var1 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff;
                var2 = 0x9d9ca28d;
                var temp13 = memory[0x40:0x60];
                memory[temp13:temp13 + 0x20] = (var2 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000;
                var temp14 = temp13 + 0x04;
                memory[temp14:temp14 + 0x20] = msg.sender;
                var3 = temp14 + 0x20;
                var4 = 0x20;
                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 temp15;
                temp15, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]);
                var4 = !temp15;
            
                if (!var4) {
                    var1 = memory[0x40:0x60];
                    var2 = returndata.length;
                
                    if (var2 < 0x20) { revert(memory[0x00:0x00]); }
                
                    var1 = memory[var1:var1 + 0x20];
                    goto label_0522;
                } else {
                    var temp16 = returndata.length;
                    memory[0x00:0x00 + temp16] = returndata[0x00:0x00 + temp16];
                    revert(memory[0x00:0x00 + returndata.length]);
                }
            }
        } else {
            var temp17 = returndata.length;
            memory[0x00:0x00 + temp17] = returndata[0x00:0x00 + temp17];
            revert(memory[0x00:0x00 + returndata.length]);
        }
    }
}

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

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

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

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

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

label_005C:
	// Incoming jump from 0x0040, if 0x22e8c8fc == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000
	// Inputs[1] { @005D  msg.value }
	005C    5B  JUMPDEST
	005D    34  CALLVALUE
	005E    80  DUP1
	005F    15  ISZERO
	0060    61  PUSH2 0x0068
	0063    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @005D  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0068, if !msg.value

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

label_0068:
	// Incoming jump from 0x0063, if !msg.value
	// Inputs[3]
	// {
	//     @0070  msg.data.length
	//     @0077  msg.data[0x04:0x24]
	//     @0081  msg.data[0x24:0x44]
	// }
	0068    5B  JUMPDEST
	0069    50  POP
	006A    61  PUSH2 0x0091
	006D    60  PUSH1 0x04
	006F    80  DUP1
	0070    36  CALLDATASIZE
	0071    03  SUB
	0072    81  DUP2
	0073    01  ADD
	0074    90  SWAP1
	0075    80  DUP1
	0076    80  DUP1
	0077    35  CALLDATALOAD
	0078    90  SWAP1
	0079    60  PUSH1 0x20
	007B    01  ADD
	007C    90  SWAP1
	007D    92  SWAP3
	007E    91  SWAP2
	007F    90  SWAP1
	0080    80  DUP1
	0081    35  CALLDATALOAD
	0082    90  SWAP1
	0083    60  PUSH1 0x20
	0085    01  ADD
	0086    90  SWAP1
	0087    92  SWAP3
	0088    91  SWAP2
	0089    90  SWAP1
	008A    50  POP
	008B    50  POP
	008C    50  POP
	008D    61  PUSH2 0x018e
	0090    56  *JUMP
	// Stack delta = +2
	// Outputs[3]
	// {
	//     @006A  stack[-1] = 0x0091
	//     @007D  stack[0] = msg.data[0x04:0x24]
	//     @0087  stack[1] = msg.data[0x24:0x44]
	// }
	// Block ends with call to 0x018e, returns to 0x0091

label_0091:
	// Incoming return from call to 0x018E at 0x0090
	0091    5B  JUMPDEST
	0092    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @0092  stop(); }
	// Block terminates

label_0093:
	// Incoming jump from 0x004B, if 0x88896a0d == stack[-1]
	// Inputs[1] { @0094  msg.value }
	0093    5B  JUMPDEST
	0094    34  CALLVALUE
	0095    80  DUP1
	0096    15  ISZERO
	0097    61  PUSH2 0x009f
	009A    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @0094  stack[0] = msg.value }
	// Block ends with conditional jump to 0x009f, if !msg.value

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

label_009F:
	// Incoming jump from 0x009A, if !msg.value
	// Inputs[6]
	// {
	//     @00A7  msg.data.length
	//     @00AE  msg.data[0x04:0x24]
	//     @00CE  msg.data[0x24:0x44]
	//     @00D7  msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]
	//     @00ED  memory[0x40:0x60]
	//     @0104  msg.data[0x20 + 0x04 + msg.data[0x24:0x44]:0x20 + 0x04 + msg.data[0x24:0x44] + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]]
	// }
	009F    5B  JUMPDEST
	00A0    50  POP
	00A1    61  PUSH2 0x011a
	00A4    60  PUSH1 0x04
	00A6    80  DUP1
	00A7    36  CALLDATASIZE
	00A8    03  SUB
	00A9    81  DUP2
	00AA    01  ADD
	00AB    90  SWAP1
	00AC    80  DUP1
	00AD    80  DUP1
	00AE    35  CALLDATALOAD
	00AF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	00C4    16  AND
	00C5    90  SWAP1
	00C6    60  PUSH1 0x20
	00C8    01  ADD
	00C9    90  SWAP1
	00CA    92  SWAP3
	00CB    91  SWAP2
	00CC    90  SWAP1
	00CD    80  DUP1
	00CE    35  CALLDATALOAD
	00CF    90  SWAP1
	00D0    60  PUSH1 0x20
	00D2    01  ADD
	00D3    90  SWAP1
	00D4    82  DUP3
	00D5    01  ADD
	00D6    80  DUP1
	00D7    35  CALLDATALOAD
	00D8    90  SWAP1
	00D9    60  PUSH1 0x20
	00DB    01  ADD
	00DC    90  SWAP1
	00DD    80  DUP1
	00DE    80  DUP1
	00DF    60  PUSH1 0x1f
	00E1    01  ADD
	00E2    60  PUSH1 0x20
	00E4    80  DUP1
	00E5    91  SWAP2
	00E6    04  DIV
	00E7    02  MUL
	00E8    60  PUSH1 0x20
	00EA    01  ADD
	00EB    60  PUSH1 0x40
	00ED    51  MLOAD
	00EE    90  SWAP1
	00EF    81  DUP2
	00F0    01  ADD
	00F1    60  PUSH1 0x40
	00F3    52  MSTORE
	00F4    80  DUP1
	00F5    93  SWAP4
	00F6    92  SWAP3
	00F7    91  SWAP2
	00F8    90  SWAP1
	00F9    81  DUP2
	00FA    81  DUP2
	00FB    52  MSTORE
	00FC    60  PUSH1 0x20
	00FE    01  ADD
	00FF    83  DUP4
	0100    83  DUP4
	0101    80  DUP1
	0102    82  DUP3
	0103    84  DUP5
	0104    37  CALLDATACOPY
	0105    82  DUP3
	0106    01  ADD
	0107    91  SWAP2
	0108    50  POP
	0109    50  POP
	010A    50  POP
	010B    50  POP
	010C    50  POP
	010D    50  POP
	010E    91  SWAP2
	010F    92  SWAP3
	0110    91  SWAP2
	0111    92  SWAP3
	0112    90  SWAP1
	0113    50  POP
	0114    50  POP
	0115    50  POP
	0116    61  PUSH2 0x0242
	0119    56  *JUMP
	// Stack delta = +2
	// Outputs[6]
	// {
	//     @00A1  stack[-1] = 0x011a
	//     @00CA  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24]
	//     @00F3  memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]) / 0x20 * 0x20
	//     @00FB  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]
	//     @0104  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x24:0x44]:0x20 + 0x04 + msg.data[0x24:0x44] + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]]
	//     @0111  stack[1] = memory[0x40:0x60]
	// }
	// Block ends with call to 0x0242, returns to 0x011A

label_011A:
	// Incoming return from call to 0x0242 at 0x0119
	011A    5B  JUMPDEST
	011B    00  *STOP
	// Stack delta = +0
	// Outputs[1] { @011B  stop(); }
	// Block terminates

label_011C:
	// Incoming jump from 0x0056, if 0xfb4fd984 == stack[-1]
	// Inputs[1] { @011D  msg.value }
	011C    5B  JUMPDEST
	011D    34  CALLVALUE
	011E    80  DUP1
	011F    15  ISZERO
	0120    61  PUSH2 0x0128
	0123    57  *JUMPI
	// Stack delta = +1
	// Outputs[1] { @011D  stack[0] = msg.value }
	// Block ends with conditional jump to 0x0128, if !msg.value

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

label_0128:
	// Incoming jump from 0x0123, if !msg.value
	// Inputs[5]
	// {
	//     @0130  msg.data.length
	//     @0137  msg.data[0x04:0x24]
	//     @0145  msg.data[0x24:0x44]
	//     @0152  msg.data[0x44:0x64]
	//     @0160  msg.data[0x64:0x84]
	// }
	0128    5B  JUMPDEST
	0129    50  POP
	012A    61  PUSH2 0x0174
	012D    60  PUSH1 0x04
	012F    80  DUP1
	0130    36  CALLDATASIZE
	0131    03  SUB
	0132    81  DUP2
	0133    01  ADD
	0134    90  SWAP1
	0135    80  DUP1
	0136    80  DUP1
	0137    35  CALLDATALOAD
	0138    60  PUSH1 0x00
	013A    19  NOT
	013B    16  AND
	013C    90  SWAP1
	013D    60  PUSH1 0x20
	013F    01  ADD
	0140    90  SWAP1
	0141    92  SWAP3
	0142    91  SWAP2
	0143    90  SWAP1
	0144    80  DUP1
	0145    35  CALLDATALOAD
	0146    60  PUSH1 0xff
	0148    16  AND
	0149    90  SWAP1
	014A    60  PUSH1 0x20
	014C    01  ADD
	014D    90  SWAP1
	014E    92  SWAP3
	014F    91  SWAP2
	0150    90  SWAP1
	0151    80  DUP1
	0152    35  CALLDATALOAD
	0153    60  PUSH1 0x00
	0155    19  NOT
	0156    16  AND
	0157    90  SWAP1
	0158    60  PUSH1 0x20
	015A    01  ADD
	015B    90  SWAP1
	015C    92  SWAP3
	015D    91  SWAP2
	015E    90  SWAP1
	015F    80  DUP1
	0160    35  CALLDATALOAD
	0161    60  PUSH1 0x00
	0163    19  NOT
	0164    16  AND
	0165    90  SWAP1
	0166    60  PUSH1 0x20
	0168    01  ADD
	0169    90  SWAP1
	016A    92  SWAP3
	016B    91  SWAP2
	016C    90  SWAP1
	016D    50  POP
	016E    50  POP
	016F    50  POP
	0170    61  PUSH2 0x0372
	0173    56  *JUMP
	// Stack delta = +4
	// Outputs[5]
	// {
	//     @012A  stack[-1] = 0x0174
	//     @0141  stack[0] = ~0x00 & msg.data[0x04:0x24]
	//     @014E  stack[1] = 0xff & msg.data[0x24:0x44]
	//     @015C  stack[2] = ~0x00 & msg.data[0x44:0x64]
	//     @016A  stack[3] = ~0x00 & msg.data[0x64:0x84]
	// }
	// Block ends with call to 0x0372, returns to 0x0174

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

label_018E:
	// Incoming call from 0x0090, returns to 0x0091
	// Inputs[6]
	// {
	//     @0193  storage[0x00]
	//     @01CC  stack[-2]
	//     @01CD  stack[-1]
	//     @01D0  memory[0x40:0x60]
	//     @0211  memory[0x40:0x60]
	//     @021A  address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// }
	018E    5B  JUMPDEST
	018F    60  PUSH1 0x00
	0191    80  DUP1
	0192    90  SWAP1
	0193    54  SLOAD
	0194    90  SWAP1
	0195    61  PUSH2 0x0100
	0198    0A  EXP
	0199    90  SWAP1
	019A    04  DIV
	019B    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01B0    16  AND
	01B1    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	01C6    16  AND
	01C7    63  PUSH4 0x22e8c8fc
	01CC    83  DUP4
	01CD    83  DUP4
	01CE    60  PUSH1 0x40
	01D0    51  MLOAD
	01D1    83  DUP4
	01D2    63  PUSH4 0xffffffff
	01D7    16  AND
	01D8    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	01F6    02  MUL
	01F7    81  DUP2
	01F8    52  MSTORE
	01F9    60  PUSH1 0x04
	01FB    01  ADD
	01FC    80  DUP1
	01FD    83  DUP4
	01FE    81  DUP2
	01FF    52  MSTORE
	0200    60  PUSH1 0x20
	0202    01  ADD
	0203    82  DUP3
	0204    81  DUP2
	0205    52  MSTORE
	0206    60  PUSH1 0x20
	0208    01  ADD
	0209    92  SWAP3
	020A    50  POP
	020B    50  POP
	020C    50  POP
	020D    60  PUSH1 0x00
	020F    60  PUSH1 0x40
	0211    51  MLOAD
	0212    80  DUP1
	0213    83  DUP4
	0214    03  SUB
	0215    81  DUP2
	0216    60  PUSH1 0x00
	0218    87  DUP8
	0219    80  DUP1
	021A    3B  EXTCODESIZE
	021B    15  ISZERO
	021C    80  DUP1
	021D    15  ISZERO
	021E    61  PUSH2 0x0226
	0221    57  *JUMPI
	// Stack delta = +10
	// Outputs[13]
	// {
	//     @01C6  stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00
	//     @01C7  stack[1] = 0x22e8c8fc
	//     @01F8  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x22e8c8fc)
	//     @01FF  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2]
	//     @0205  memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1]
	//     @0209  stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60]
	//     @020D  stack[3] = 0x00
	//     @0211  stack[4] = memory[0x40:0x60]
	//     @0214  stack[5] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0215  stack[6] = memory[0x40:0x60]
	//     @0216  stack[7] = 0x00
	//     @0218  stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00
	//     @021B  stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// }
	// Block ends with conditional jump to 0x0226, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length

label_0222:
	// Incoming jump from 0x0221, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// Inputs[1] { @0225  memory[0x00:0x00] }
	0222    60  PUSH1 0x00
	0224    80  DUP1
	0225    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @0225  revert(memory[0x00:0x00]); }
	// Block terminates

label_0226:
	// Incoming jump from 0x0221, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// Inputs[9]
	// {
	//     @0228  msg.gas
	//     @0229  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @0229  stack[-2]
	//     @0229  stack[-5]
	//     @0229  stack[-7]
	//     @0229  stack[-3]
	//     @0229  stack[-6]
	//     @0229  memory[stack[-4]:stack[-4] + stack[-5]]
	//     @0229  stack[-4]
	// }
	0226    5B  JUMPDEST
	0227    50  POP
	0228    5A  GAS
	0229    F1  CALL
	022A    15  ISZERO
	022B    80  DUP1
	022C    15  ISZERO
	022D    61  PUSH2 0x023a
	0230    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @0229  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @022A  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 0x023a, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

label_0231:
	// Incoming jump from 0x0230, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[4]
	// {
	//     @0231  returndata.length
	//     @0235  returndata[0x00:0x00 + returndata.length]
	//     @0236  returndata.length
	//     @0239  memory[0x00:0x00 + returndata.length]
	// }
	0231    3D  RETURNDATASIZE
	0232    60  PUSH1 0x00
	0234    80  DUP1
	0235    3E  RETURNDATACOPY
	0236    3D  RETURNDATASIZE
	0237    60  PUSH1 0x00
	0239    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0235  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0239  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_023A:
	// Incoming jump from 0x0230, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[1] { @0241  stack[-7] }
	023A    5B  JUMPDEST
	023B    50  POP
	023C    50  POP
	023D    50  POP
	023E    50  POP
	023F    50  POP
	0240    50  POP
	0241    56  *JUMP
	// Stack delta = -7
	// Block ends with unconditional jump to stack[-7]

label_0242:
	// Incoming call from 0x0119, returns to 0x011A
	// Inputs[2]
	// {
	//     @0248  storage[0x01]
	//     @027C  msg.sender
	// }
	0242    5B  JUMPDEST
	0243    60  PUSH1 0x01
	0245    60  PUSH1 0x00
	0247    90  SWAP1
	0248    54  SLOAD
	0249    90  SWAP1
	024A    61  PUSH2 0x0100
	024D    0A  EXP
	024E    90  SWAP1
	024F    04  DIV
	0250    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0265    16  AND
	0266    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	027B    16  AND
	027C    33  CALLER
	027D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0292    16  AND
	0293    14  EQ
	0294    15  ISZERO
	0295    15  ISZERO
	0296    61  PUSH2 0x029e
	0299    57  *JUMPI
	// Stack delta = +0
	// Block ends with conditional jump to 0x029e, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00)

label_029A:
	// Incoming jump from 0x0299, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00)
	// Inputs[1] { @029D  memory[0x00:0x00] }
	029A    60  PUSH1 0x00
	029C    80  DUP1
	029D    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @029D  revert(memory[0x00:0x00]); }
	// Block terminates

label_029E:
	// Incoming jump from 0x0299, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00)
	// Inputs[5]
	// {
	//     @02C0  stack[-2]
	//     @02C1  stack[-1]
	//     @02C4  memory[0x40:0x60]
	//     @0304  memory[stack[-1]:stack[-1] + 0x20]
	//     @030D  memory[stack[-1]:stack[-1] + 0x20]
	// }
	029E    5B  JUMPDEST
	029F    7F  PUSH32 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80
	02C0    82  DUP3
	02C1    82  DUP3
	02C2    60  PUSH1 0x40
	02C4    51  MLOAD
	02C5    80  DUP1
	02C6    83  DUP4
	02C7    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02DC    16  AND
	02DD    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	02F2    16  AND
	02F3    81  DUP2
	02F4    52  MSTORE
	02F5    60  PUSH1 0x20
	02F7    01  ADD
	02F8    80  DUP1
	02F9    60  PUSH1 0x20
	02FB    01  ADD
	02FC    82  DUP3
	02FD    81  DUP2
	02FE    03  SUB
	02FF    82  DUP3
	0300    52  MSTORE
	0301    83  DUP4
	0302    81  DUP2
	0303    81  DUP2
	0304    51  MLOAD
	0305    81  DUP2
	0306    52  MSTORE
	0307    60  PUSH1 0x20
	0309    01  ADD
	030A    91  SWAP2
	030B    50  POP
	030C    80  DUP1
	030D    51  MLOAD
	030E    90  SWAP1
	030F    60  PUSH1 0x20
	0311    01  ADD
	0312    90  SWAP1
	0313    80  DUP1
	0314    83  DUP4
	0315    83  DUP4
	0316    60  PUSH1 0x00
	0318    5B  JUMPDEST
	0319    83  DUP4
	031A    81  DUP2
	031B    10  LT
	031C    15  ISZERO
	031D    61  PUSH2 0x0333
	0320    57  *JUMPI
	// Stack delta = +12
	// Outputs[15]
	// {
	//     @029F  stack[0] = 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80
	//     @02C0  stack[1] = stack[-2]
	//     @02C1  stack[2] = stack[-1]
	//     @02C4  stack[3] = memory[0x40:0x60]
	//     @02F4  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]
	//     @02F7  stack[4] = 0x20 + memory[0x40:0x60]
	//     @0300  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @0306  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20]
	//     @030A  stack[5] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60]
	//     @0312  stack[6] = 0x20 + stack[-1]
	//     @0312  stack[7] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0313  stack[8] = memory[stack[-1]:stack[-1] + 0x20]
	//     @0314  stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60]
	//     @0315  stack[10] = 0x20 + stack[-1]
	//     @0316  stack[11] = 0x00
	// }
	// Block ends with conditional jump to 0x0333, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])

label_0321:
	// Incoming jump from 0x0320, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0320, if not !(stack[-1] < stack[-4])
	// Inputs[4]
	// {
	//     @0321  stack[-1]
	//     @0322  stack[-2]
	//     @0324  memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @0326  stack[-3]
	// }
	0321    80  DUP1
	0322    82  DUP3
	0323    01  ADD
	0324    51  MLOAD
	0325    81  DUP2
	0326    84  DUP5
	0327    01  ADD
	0328    52  MSTORE
	0329    60  PUSH1 0x20
	032B    81  DUP2
	032C    01  ADD
	032D    90  SWAP1
	032E    50  POP
	032F    61  PUSH2 0x0318
	0332    56  *JUMP
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @0328  memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20]
	//     @032D  stack[-1] = stack[-1] + 0x20
	// }
	// Block ends with unconditional jump to 0x0318

label_0333:
	// Incoming jump from 0x0320, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20])
	// Incoming jump from 0x0320, if !(stack[-1] < stack[-4])
	// Inputs[3]
	// {
	//     @0338  stack[-6]
	//     @0338  stack[-5]
	//     @033A  stack[-7]
	// }
	0333    5B  JUMPDEST
	0334    50  POP
	0335    50  POP
	0336    50  POP
	0337    50  POP
	0338    90  SWAP1
	0339    50  POP
	033A    90  SWAP1
	033B    81  DUP2
	033C    01  ADD
	033D    90  SWAP1
	033E    60  PUSH1 0x1f
	0340    16  AND
	0341    80  DUP1
	0342    15  ISZERO
	0343    61  PUSH2 0x0360
	0346    57  *JUMPI
	// Stack delta = -5
	// Outputs[2]
	// {
	//     @033D  stack[-7] = stack[-5] + stack[-7]
	//     @0340  stack[-6] = 0x1f & stack[-5]
	// }
	// Block ends with conditional jump to 0x0360, if !(0x1f & stack[-5])

label_0347:
	// Incoming jump from 0x0346, if not !(0x1f & stack[-5])
	// Inputs[8]
	// {
	//     @0347  stack[-1]
	//     @0348  stack[-2]
	//     @034B  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @0362  stack[-6]
	//     @0369  memory[0x40:0x60]
	//     @036E  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]
	//     @036E  stack[-7]
	//     @0371  stack[-10]
	// }
	0347    80  DUP1
	0348    82  DUP3
	0349    03  SUB
	034A    80  DUP1
	034B    51  MLOAD
	034C    60  PUSH1 0x01
	034E    83  DUP4
	034F    60  PUSH1 0x20
	0351    03  SUB
	0352    61  PUSH2 0x0100
	0355    0A  EXP
	0356    03  SUB
	0357    19  NOT
	0358    16  AND
	0359    81  DUP2
	035A    52  MSTORE
	035B    60  PUSH1 0x20
	035D    01  ADD
	035E    91  SWAP2
	035F    50  POP
	0360    5B  JUMPDEST
	0361    50  POP
	0362    93  SWAP4
	0363    50  POP
	0364    50  POP
	0365    50  POP
	0366    50  POP
	0367    60  PUSH1 0x40
	0369    51  MLOAD
	036A    80  DUP1
	036B    91  SWAP2
	036C    03  SUB
	036D    90  SWAP1
	036E    A1  LOG1
	036F    50  POP
	0370    50  POP
	0371    56  *JUMP
	// Stack delta = -10
	// Outputs[2]
	// {
	//     @035A  memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20]
	//     @036E  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-7]]);
	// }
	// Block ends with unconditional jump to stack[-10]

label_0372:
	// Incoming call from 0x0173, returns to 0x0174
	// Inputs[11]
	// {
	//     @0375  msg.sender
	//     @038E  stack[-4]
	//     @038F  stack[-3]
	//     @0390  stack[-2]
	//     @0391  stack[-1]
	//     @0394  memory[0x40:0x60]
	//     @03A1  memory[0x40:0x60]
	//     @03E3  memory[0x40:0x60]
	//     @03F0  msg.gas
	//     @03F1  address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	//     @03F1  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	// }
	0372    5B  JUMPDEST
	0373    60  PUSH1 0x00
	0375    33  CALLER
	0376    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	038B    16  AND
	038C    60  PUSH1 0x01
	038E    86  DUP7
	038F    86  DUP7
	0390    86  DUP7
	0391    86  DUP7
	0392    60  PUSH1 0x40
	0394    51  MLOAD
	0395    60  PUSH1 0x00
	0397    81  DUP2
	0398    52  MSTORE
	0399    60  PUSH1 0x20
	039B    01  ADD
	039C    60  PUSH1 0x40
	039E    52  MSTORE
	039F    60  PUSH1 0x40
	03A1    51  MLOAD
	03A2    80  DUP1
	03A3    85  DUP6
	03A4    60  PUSH1 0x00
	03A6    19  NOT
	03A7    16  AND
	03A8    60  PUSH1 0x00
	03AA    19  NOT
	03AB    16  AND
	03AC    81  DUP2
	03AD    52  MSTORE
	03AE    60  PUSH1 0x20
	03B0    01  ADD
	03B1    84  DUP5
	03B2    60  PUSH1 0xff
	03B4    16  AND
	03B5    60  PUSH1 0xff
	03B7    16  AND
	03B8    81  DUP2
	03B9    52  MSTORE
	03BA    60  PUSH1 0x20
	03BC    01  ADD
	03BD    83  DUP4
	03BE    60  PUSH1 0x00
	03C0    19  NOT
	03C1    16  AND
	03C2    60  PUSH1 0x00
	03C4    19  NOT
	03C5    16  AND
	03C6    81  DUP2
	03C7    52  MSTORE
	03C8    60  PUSH1 0x20
	03CA    01  ADD
	03CB    82  DUP3
	03CC    60  PUSH1 0x00
	03CE    19  NOT
	03CF    16  AND
	03D0    60  PUSH1 0x00
	03D2    19  NOT
	03D3    16  AND
	03D4    81  DUP2
	03D5    52  MSTORE
	03D6    60  PUSH1 0x20
	03D8    01  ADD
	03D9    94  SWAP5
	03DA    50  POP
	03DB    50  POP
	03DC    50  POP
	03DD    50  POP
	03DE    50  POP
	03DF    60  PUSH1 0x20
	03E1    60  PUSH1 0x40
	03E3    51  MLOAD
	03E4    60  PUSH1 0x20
	03E6    81  DUP2
	03E7    03  SUB
	03E8    90  SWAP1
	03E9    80  DUP1
	03EA    84  DUP5
	03EB    03  SUB
	03EC    90  SWAP1
	03ED    60  PUSH1 0x00
	03EF    86  DUP7
	03F0    5A  GAS
	03F1    F1  CALL
	03F2    15  ISZERO
	03F3    80  DUP1
	03F4    15  ISZERO
	03F5    61  PUSH2 0x0402
	03F8    57  *JUMPI
	// Stack delta = +5
	// Outputs[12]
	// {
	//     @0373  stack[0] = 0x00
	//     @038B  stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @038C  stack[2] = 0x01
	//     @0398  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00
	//     @039E  memory[0x40:0x60] = 0x20 + memory[0x40:0x60]
	//     @03AD  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-4]
	//     @03B9  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-3]
	//     @03C7  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-2]
	//     @03D5  memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-1]
	//     @03D9  stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]
	//     @03F1  memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	//     @03F2  stack[4] = !address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// }
	// Block ends with conditional jump to 0x0402, if !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])

label_03F9:
	// Incoming jump from 0x03F8, if not !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// Inputs[4]
	// {
	//     @03F9  returndata.length
	//     @03FD  returndata[0x00:0x00 + returndata.length]
	//     @03FE  returndata.length
	//     @0401  memory[0x00:0x00 + returndata.length]
	// }
	03F9    3D  RETURNDATASIZE
	03FA    60  PUSH1 0x00
	03FC    80  DUP1
	03FD    3E  RETURNDATACOPY
	03FE    3D  RETURNDATASIZE
	03FF    60  PUSH1 0x00
	0401    FD  *REVERT
	// Stack delta = +0
	// Outputs[2]
	// {
	//     @03FD  memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length]
	//     @0401  revert(memory[0x00:0x00 + returndata.length]);
	// }
	// Block terminates

label_0402:
	// Incoming jump from 0x03F8, if !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]])
	// Inputs[3]
	// {
	//     @040A  memory[0x40:0x60]
	//     @040C  memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20]
	//     @0423  stack[-4]
	// }
	0402    5B  JUMPDEST
	0403    50  POP
	0404    50  POP
	0405    50  POP
	0406    60  PUSH1 0x20
	0408    60  PUSH1 0x40
	040A    51  MLOAD
	040B    03  SUB
	040C    51  MLOAD
	040D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0422    16  AND
	0423    14  EQ
	0424    80  DUP1
	0425    15  ISZERO
	0426    61  PUSH2 0x0522
	0429    57  *JUMPI
	// Stack delta = -3
	// Outputs[1] { @0423  stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4] }
	// Block ends with conditional jump to 0x0522, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4])

label_042A:
	// Incoming jump from 0x0429, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4])
	// Inputs[5]
	// {
	//     @042F  storage[0x00]
	//     @0468  msg.sender
	//     @046B  memory[0x40:0x60]
	//     @04D1  memory[0x40:0x60]
	//     @04DA  address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// }
	042A    50  POP
	042B    60  PUSH1 0x00
	042D    80  DUP1
	042E    90  SWAP1
	042F    54  SLOAD
	0430    90  SWAP1
	0431    61  PUSH2 0x0100
	0434    0A  EXP
	0435    90  SWAP1
	0436    04  DIV
	0437    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	044C    16  AND
	044D    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	0462    16  AND
	0463    63  PUSH4 0x9d9ca28d
	0468    33  CALLER
	0469    60  PUSH1 0x40
	046B    51  MLOAD
	046C    82  DUP3
	046D    63  PUSH4 0xffffffff
	0472    16  AND
	0473    7C  PUSH29 0x0100000000000000000000000000000000000000000000000000000000
	0491    02  MUL
	0492    81  DUP2
	0493    52  MSTORE
	0494    60  PUSH1 0x04
	0496    01  ADD
	0497    80  DUP1
	0498    82  DUP3
	0499    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04AE    16  AND
	04AF    73  PUSH20 0xffffffffffffffffffffffffffffffffffffffff
	04C4    16  AND
	04C5    81  DUP2
	04C6    52  MSTORE
	04C7    60  PUSH1 0x20
	04C9    01  ADD
	04CA    91  SWAP2
	04CB    50  POP
	04CC    50  POP
	04CD    60  PUSH1 0x20
	04CF    60  PUSH1 0x40
	04D1    51  MLOAD
	04D2    80  DUP1
	04D3    83  DUP4
	04D4    03  SUB
	04D5    81  DUP2
	04D6    60  PUSH1 0x00
	04D8    87  DUP8
	04D9    80  DUP1
	04DA    3B  EXTCODESIZE
	04DB    15  ISZERO
	04DC    80  DUP1
	04DD    15  ISZERO
	04DE    61  PUSH2 0x04e6
	04E1    57  *JUMPI
	// Stack delta = +9
	// Outputs[12]
	// {
	//     @0462  stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00
	//     @0463  stack[0] = 0x9d9ca28d
	//     @0493  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x9d9ca28d)
	//     @04C6  memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender
	//     @04CA  stack[1] = 0x20 + 0x04 + memory[0x40:0x60]
	//     @04CD  stack[2] = 0x20
	//     @04D1  stack[3] = memory[0x40:0x60]
	//     @04D4  stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]
	//     @04D5  stack[5] = memory[0x40:0x60]
	//     @04D6  stack[6] = 0x00
	//     @04D8  stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00
	//     @04DB  stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// }
	// Block ends with conditional jump to 0x04e6, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length

label_04E2:
	// Incoming jump from 0x04E1, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// Inputs[1] { @04E5  memory[0x00:0x00] }
	04E2    60  PUSH1 0x00
	04E4    80  DUP1
	04E5    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @04E5  revert(memory[0x00:0x00]); }
	// Block terminates

label_04E6:
	// Incoming jump from 0x04E1, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length
	// Inputs[9]
	// {
	//     @04E8  msg.gas
	//     @04E9  stack[-7]
	//     @04E9  address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @04E9  stack[-2]
	//     @04E9  stack[-5]
	//     @04E9  stack[-3]
	//     @04E9  stack[-6]
	//     @04E9  stack[-4]
	//     @04E9  memory[stack[-4]:stack[-4] + stack[-5]]
	// }
	04E6    5B  JUMPDEST
	04E7    50  POP
	04E8    5A  GAS
	04E9    F1  CALL
	04EA    15  ISZERO
	04EB    80  DUP1
	04EC    15  ISZERO
	04ED    61  PUSH2 0x04fa
	04F0    57  *JUMPI
	// Stack delta = -6
	// Outputs[2]
	// {
	//     @04E9  memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	//     @04EA  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 0x04fa, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])

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

label_04FA:
	// Incoming jump from 0x04F0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]])
	// Inputs[2]
	// {
	//     @0501  memory[0x40:0x60]
	//     @0502  returndata.length
	// }
	04FA    5B  JUMPDEST
	04FB    50  POP
	04FC    50  POP
	04FD    50  POP
	04FE    50  POP
	04FF    60  PUSH1 0x40
	0501    51  MLOAD
	0502    3D  RETURNDATASIZE
	0503    60  PUSH1 0x20
	0505    81  DUP2
	0506    10  LT
	0507    15  ISZERO
	0508    61  PUSH2 0x0510
	050B    57  *JUMPI
	// Stack delta = -2
	// Outputs[2]
	// {
	//     @0501  stack[-4] = memory[0x40:0x60]
	//     @0502  stack[-3] = returndata.length
	// }
	// Block ends with conditional jump to 0x0510, if !(returndata.length < 0x20)

label_050C:
	// Incoming jump from 0x050B, if not !(returndata.length < 0x20)
	// Inputs[1] { @050F  memory[0x00:0x00] }
	050C    60  PUSH1 0x00
	050E    80  DUP1
	050F    FD  *REVERT
	// Stack delta = +0
	// Outputs[1] { @050F  revert(memory[0x00:0x00]); }
	// Block terminates

label_0510:
	// Incoming jump from 0x050B, if !(returndata.length < 0x20)
	// Inputs[3]
	// {
	//     @0511  stack[-2]
	//     @0512  stack[-1]
	//     @0516  memory[stack[-2]:stack[-2] + 0x20]
	// }
	0510    5B  JUMPDEST
	0511    81  DUP2
	0512    01  ADD
	0513    90  SWAP1
	0514    80  DUP1
	0515    80  DUP1
	0516    51  MLOAD
	0517    90  SWAP1
	0518    60  PUSH1 0x20
	051A    01  ADD
	051B    90  SWAP1
	051C    92  SWAP3
	051D    91  SWAP2
	051E    90  SWAP1
	051F    50  POP
	0520    50  POP
	0521    50  POP
	// Stack delta = -1
	// Outputs[1] { @051C  stack[-2] = memory[stack[-2]:stack[-2] + 0x20] }
	// Block continues

label_0522:
	// Incoming jump from 0x0521
	// Incoming jump from 0x0429, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4])
	// Inputs[1] { @0523  stack[-1] }
	0522    5B  JUMPDEST
	0523    15  ISZERO
	0524    61  PUSH2 0x059d
	0527    57  *JUMPI
	// Stack delta = -1
	// Block ends with conditional jump to 0x059d, if !stack[-1]

label_0528:
	// Incoming jump from 0x0527, if not !stack[-1]
	// Inputs[8]
	// {
	//     @0549  stack[-5]
	//     @054A  stack[-4]
	//     @054B  stack[-3]
	//     @054C  stack[-2]
	//     @054F  memory[0x40:0x60]
	//     @058F  memory[0x40:0x60]
	//     @0594  memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]
	//     @0597  stack[-1]
	// }
	0528    7F  PUSH32 0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573
	0549    85  DUP6
	054A    85  DUP6
	054B    85  DUP6
	054C    85  DUP6
	054D    60  PUSH1 0x40
	054F    51  MLOAD
	0550    80  DUP1
	0551    85  DUP6
	0552    60  PUSH1 0x00
	0554    19  NOT
	0555    16  AND
	0556    60  PUSH1 0x00
	0558    19  NOT
	0559    16  AND
	055A    81  DUP2
	055B    52  MSTORE
	055C    60  PUSH1 0x20
	055E    01  ADD
	055F    84  DUP5
	0560    60  PUSH1 0xff
	0562    16  AND
	0563    60  PUSH1 0xff
	0565    16  AND
	0566    81  DUP2
	0567    52  MSTORE
	0568    60  PUSH1 0x20
	056A    01  ADD
	056B    83  DUP4
	056C    60  PUSH1 0x00
	056E    19  NOT
	056F    16  AND
	0570    60  PUSH1 0x00
	0572    19  NOT
	0573    16  AND
	0574    81  DUP2
	0575    52  MSTORE
	0576    60  PUSH1 0x20
	0578    01  ADD
	0579    82  DUP3
	057A    60  PUSH1 0x00
	057C    19  NOT
	057D    16  AND
	057E    60  PUSH1 0x00
	0580    19  NOT
	0581    16  AND
	0582    81  DUP2
	0583    52  MSTORE
	0584    60  PUSH1 0x20
	0586    01  ADD
	0587    94  SWAP5
	0588    50  POP
	0589    50  POP
	058A    50  POP
	058B    50  POP
	058C    50  POP
	058D    60  PUSH1 0x40
	058F    51  MLOAD
	0590    80  DUP1
	0591    91  SWAP2
	0592    03  SUB
	0593    90  SWAP1
	0594    A1  LOG1
	0595    60  PUSH1 0x01
	0597    90  SWAP1
	0598    50  POP
	0599    61  PUSH2 0x05a2
	059C    56  *JUMP
	// Stack delta = +0
	// Outputs[6]
	// {
	//     @055B  memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-5]
	//     @0567  memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-4]
	//     @0575  memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-3]
	//     @0583  memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-2]
	//     @0594  log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573]);
	//     @0597  stack[-1] = 0x01
	// }
	// Block ends with unconditional jump to 0x05a2

label_059D:
	// Incoming jump from 0x0527, if !stack[-1]
	// Inputs[3]
	// {
	//     @05A0  stack[-1]
	//     @05A3  stack[-6]
	//     @05A4  stack[-5]
	// }
	059D    5B  JUMPDEST
	059E    60  PUSH1 0x00
	05A0    90  SWAP1
	05A1    50  POP
	05A2    5B  JUMPDEST
	05A3    94  SWAP5
	05A4    93  SWAP4
	05A5    50  POP
	05A6    50  POP
	05A7    50  POP
	05A8    50  POP
	05A9    56  *JUMP
	// Stack delta = -5
	// Outputs[1] { @05A3  stack[-6] = 0x00 }
	// Block ends with unconditional jump to stack[-6]

	05AA    00    *STOP
	05AB    A1    LOG1
	05AC    65    PUSH6 0x627a7a723058
	05B3    20    SHA3
	05B4    56    *JUMP
	05B5    37    CALLDATACOPY
	05B6    88    DUP9
	05B7    B2    SWAP
	05B8    B3    B3
	05B9    C0    C0
	05BA    A0    LOG0
	05BB    28    28
	05BC    9F    SWAP16
	05BD    77    PUSH24 0x20eb886c7c25bc46e44529473e0adbc9c56b0c68c7920029