dedaub desompilation

gistfile1.txt

// Decompiled at www.contract-library.com
// 2022.07.11 14:20 UTC



// Note: The function selector is not present in the original solidity code.
// However, we display it for the sake of completeness.

function __function_selector__(uint256 varg0) public nonPayable { 
    v0 = v1 = 0;
    v2 = v3 = msg.data[v1];
    v4 = v5 = 256;
    if (msg.data.length > 35) {
        if (!(v3 & 0xffffffffffffffffffffffff00000000000000000000000000000000)) {
            v6 = 0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7.transfer(varg0, msg.data[msg.data.length - 32]).gas(msg.gas);
            v7 = v8 = 164;
            while (v7 >= msg.data.length - 128) {
                v9 = v10 = msg.data[v7 + 128];
                MEM[32 << msg.data[v7]] = 0;
                MEM[64 >> msg.data[v7]] = msg.data[v7 + 64];
                v11 = v9.swap(varg0, msg.data[msg.data.length - 32], v10, 128, 0).gas(msg.gas);
                if (v11) {
                    v7 = v7 + 96;
                    continue;
                }
            }
            exit;
        }
    }
    v12 = v13 = 192;
    while (v2 >= 0x2000000000000000000000000000000000000000000000000000000000000000) {
        v0 = v0 << 8;
        while (v2 < 0x2000000000000000000000000000000000000000000000000000000000000000) {
            v14 = v15 = 0x3b0eb31682d3bad2670e6df14228931d242491;
            v16 = v17 = 0x7763e7eeba33e5ad2dcb2425c000;
            v18 = v19 = 5;
            v20 = v21 = 0x1fc000;
            while (v16 & v20 ^ 0x7ffff < v2 >> 237) {
                v16 = v16 >> 8;
                v20 = v20 >> 1;
                v14 = v14 >> 11;
                v18 = v18 + 1;
            }
            if (1013 == (v14 & 0x7ff) + ((v16 & v20 ^ 0x7ffff) - (v2 >> 237) >> 19 - v18)) {
                v22 = v23 = 96;
                v24 = v25 = 1;
                v0 = (v0 << 16) + v12 + 44;
                v4 = v4 - 16;
                goto 0xf8;
            } else {
                v24 = v26 = 1;
                v22 = v27 = 96;
                MEM[(v12 + 44) len 20] = this.code[(1071 + ((v14 & 0x7ff) + ((v16 & v20 ^ 0x7ffff) - (v2 >> 237) >> 19 - v18)) * 20) len 20];
            }
            MEM[v12] = v2 << v18 >> 255;
            v12 = v12 + v22;
            v0 = v0 + v18 + v24;
            v2 = v2 << v18 << v24;
            v0 = v0 + v24;
        }
        v0 = v0 + 3;
        v2 = v2 << 3;
        v4 = v4 - 8;
    }
    v28 = v29 = v0 << v4;
    v30 = v31 = v0 << v4;
    v32 = v33 = 10 + v0 >> 3;
    while (!v30) {
        CALLDATACOPY(v30 >> 240, v32, 20);
        v32 = v32 + 20;
        v30 = v30 << 16;
    }
    v34 = v35 = 0;
    v36 = v37 = 192;
    while (!v28) {
        v38 = v39 = 0;
        v28 = v28 << 8;
        v40 = v41 = 1;
        while (v38 >= v28 >> 248) {
            v40 = v42 & v40;
            v38 = v43 = MEM[64 >> MEM[v36]];
            MEM[v36 + 64] = MEM[32 << MEM[v36]] | v43 << 128;
            v36 = v36 + 96;
            v38 = v44 = MEM[32 << MEM[v36]] * 1000 / 997;
            if (0 == v38) {
                v45 = v46 = 1;
                goto 0x351;
            } else {
                v38 = v43 * v38 / (v38 + v44);
                v38 = v38 * v44 / (v38 + v44);
                v45 = v47 = 1;
            }
            v38 = v38 + v45;
        }
        if ((v38 < v38) | !v40) {
            goto 0x2ab;
        } else {
            v48 = v38 * v38;
            v49 = v48 / (v48 / (v38 + v38 >> 1) + (v38 + v38 >> 1) >> 1) + (v48 / (v38 + v38 >> 1) + (v38 + v38 >> 1) >> 1) >> 1;
            v50 = v48 / (v48 / (v48 / v49 + v49 >> 1) + (v48 / v49 + v49 >> 1) >> 1) + (v48 / (v48 / v49 + v49 >> 1) + (v48 / v49 + v49 >> 1) >> 1) >> 1;
            v51 = v48 / (v48 / (v48 / v50 + v50 >> 1) + (v48 / v50 + v50 >> 1) >> 1) + (v48 / (v48 / v50 + v50 >> 1) + (v48 / v50 + v50 >> 1) >> 1) >> 1;
            v52 = v53 = (v48 / v51 + v51 >> 1) - v38;
            if (v38 * v53 / (v53 + v38) - v53 >= msg.gas * (v28 >> 248) * 0x101d0) {
                while (v36 >= v36) {
                    v52 = v52 * (MEM[v36 + 64] >> 128) * 997 / ((MEM[v36 + 80] >> 128) * 1000 + v52 * 997);
                    MEM[v36 + 64] = v52;
                    v36 = v36 + 96;
                }
                v34 += v52 - v53;
                MEM[v36 - 192] = 0x22c0d9f;
                MEM[v36 + (64 >> MEM[v36 - 96]) - 192] = v52;
                MEM[v36 + (32 << MEM[v36 - 96]) - 192] = 0;
                MEM[v36 - 96] = this;
                MEM[v36 - 64] = 128;
                MEM[v36 - 32] = v36 - v36 + 32;
                MEM[v36] = v53;
                v54 = MEM[v36 - 64].call(MEM[(v36 - 164) len (v36 - v36 + 228)], MEM[0 len 0]).gas(msg.gas);
                MEM[v36] = MEM[v36];
                require(v54); // checks call status, propagates error data on error
            }
        }
    }
    if (v34) {
        v55 = 0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7.transfer(0x77740ab88f66308f12ac590a9fd5d0d600000000, v34).gas(msg.gas);
        if (v55) {
            exit;
        }
    } else {
        exit;
    }
    revert(0, RETURNDATASIZE());
}