// File: /workspace/github_cpp_makefile_star2_O1/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: main
int main(int argc, char *argv[])
{
    if (argc == 1) {
        usage(argv[0]);
        return -1;
    }

    string srcDirPath = "";
    string dstDirPath = "";
    string sizeStr = "";
    int threadNum = 8;
    bool recursively = false;
    ftpInfo * pFtp = new ftpInfo();
    recvParam * pRecv = new recvParam();
    char optchar;

    gFtpDebug = false;
    while ((optchar = getopt(argc, argv, "s:d:t:r:n:u:p:w:l:f:S:vih")) != -1) {
        switch(optchar) {
        case 's':
            srcDirPath = optarg;
            break;
        case 'd':
            dstDirPath =  optarg;
            break;
        case 't':
            threadNum = atoi(optarg);
            break;
        case 'i':
            gFtpDebug = true;
            break;
        case 'r':
            recursively = true;
            break;
        case 'n':
            pFtp->ftpServer = optarg;
            break;
        case 'u':
            pFtp->user = optarg;
            pRecv->testName = optarg;
            break;
        case 'p':
            pFtp->pass = optarg;
            break;
        case 'w':
            pRecv->width = atoi(optarg);
            break;
        case 'l':
            pRecv->layer = atoi(optarg);
            break;
        case 'f':
            pRecv->fileNum = atoi(optarg);
            break;
        case 'S':
            sizeStr = optarg;
            break;
        case 'v':
            pRecv->verify = true;
            break;
        case 'h':
            usage(argv[0]);
            exit(0);
        default:
            fprintf(stderr, "unkown option: %c\n", optchar);
            return -1;
        }
    }

    if (pFtp->ftpServer == NULL || strlen(pFtp->ftpServer) == 0) {
        fprintf(stderr, "ftp server not specified.\n");
        return -1;
    }

    if (pFtp->user == NULL || strlen(pFtp->user) == 0) {
        fprintf(stderr, "ftp user not specified.\n");
        return -1;
    }

    if (pFtp->pass == NULL || strlen(pFtp->pass) == 0) {
        fprintf(stderr, "ftp password not specified.\n");
        return -1;
    }

    if (srcDirPath.empty()) {
        fprintf(stderr, "source directory path not specified.\n");
        return -1;
    }

    if (dstDirPath.empty()) {
        fprintf(stderr, " destination directory path not specified.\n");
        return -1;
    }

    if (srcDirPath.compare("null") == 0) {
        if (pRecv->fileNum < 0) {
            fprintf(stderr, " source path is %s, please specify the number of file by option '-f'.\n", srcDirPath.c_str());
            return -1;
        }
        if (sizeStr == "") {
            fprintf(stderr, " source path is %s, please specify file size by option '-S'.\n", srcDirPath.c_str());
            return -1;
        }
        if (pRecv->width < 0) {
            fprintf(stderr, " source path is %s, please specify directry width by option '-w'.\n", srcDirPath.c_str());
            return -1;
        }
        if (pRecv->layer < 0) {
            fprintf(stderr, " source path is %s, please specify directory layer by option '-l'.\n", srcDirPath.c_str());
            return -1;
        }
        size_t colonLoc = sizeStr.find_first_of(":");
		if (colonLoc == std::string::npos) {
            pRecv->fileSize = string_to_size(sizeStr.c_str());
		} else {
			pRecv->minSize = string_to_size(sizeStr.substr(0, colonLoc).c_str());
		    pRecv->maxSize = string_to_size(sizeStr.substr(colonLoc+1).c_str());
	        if ((pRecv->minSize < 0) || (pRecv->maxSize <= 0) || (pRecv->minSize > pRecv->maxSize)) {
	            printf("the value of sizerange is invalid: minsize is %ld, maxsize is %ld.\n", 
					pRecv->minSize, pRecv->maxSize);
				return 0;
	        }
	        pRecv->fileSize = pRecv->maxSize;
		}
    }

    // parse source path and destination path and get the compound mode
    string srcLocation, dstLocation;
    string realSrcPath, realDstPath;
    int compoundMode = 0;  // 1: local to ftp, 2: ftp to local, 3: ftp to null
    int colonLoc = 0;
    colonLoc = srcDirPath.find(":");
    if (colonLoc != std::string::npos) {
        srcLocation = srcDirPath.substr(0, colonLoc);
        realSrcPath = srcDirPath.substr(colonLoc + 1, srcDirPath.size() - colonLoc - 1);
    } else {
        if (srcDirPath.compare("null") != 0) {
            fprintf(stderr, "the format of source path %s is invalid.\n\n", srcDirPath.c_str());
            usage(argv[0]);
            return -1;
        } else {
            realSrcPath = srcDirPath;
        }
    }

    if (dstDirPath.compare("null") != 0) {
        if (dstDirPath.at(dstDirPath.size() - 1) != '/') {
            dstDirPath.push_back('/');
        }
    }

    colonLoc = dstDirPath.find(":");
    if (colonLoc != std::string::npos) {
        dstLocation = dstDirPath.substr(0, colonLoc);
        realDstPath = dstDirPath.substr(colonLoc + 1, dstDirPath.size() - colonLoc - 1);
    } else {
        if (dstDirPath.compare("null") != 0) {
            fprintf(stderr, "the format of destination path %s is invalid.\n\n ", dstDirPath.c_str());
            usage(argv[0]);
            return -1;
        } else {
            realDstPath = dstDirPath;
        }
    }

    if ((srcLocation.compare("local") == 0) && (dstLocation.compare("ftp") == 0)) {
        compoundMode = 1;
    } else if ((srcLocation.compare("ftp") == 0) && (dstLocation.compare("local") == 0)) {
        compoundMode = 2;
    } else if ((srcLocation.compare("ftp") == 0) && (dstDirPath.compare("null") == 0)) {
        compoundMode = 3;
    } else if ((srcDirPath.compare("null") == 0) && (dstLocation.compare("ftp") == 0)) {
        compoundMode = 4;
    } else {
        fprintf(stderr, "the format of source path %s or destination path %s is invalid.\n\n ",\
                                                       srcDirPath.c_str(), dstDirPath.c_str());
        usage(argv[0]);
        return -1;
    }

    // open log file
    normalFd = fopen(normalLogFile, "a");
    if (normalFd == NULL) {
        fprintf(stdout, "open file '%s' failed.\n", normalLogFile);
        return -1;
    }
    errorFd = fopen(errorLogFile, "a");
    if (errorFd == NULL) {
        fprintf(stdout, "open file '%s' failed.\n", errorLogFile);
        return -1;
    }


    char printBuf[1024];
    char * buf = new char[128];
    int len = snprintf(printBuf, sizeof(printBuf) - 1, "\nStarting a new Data Transfer Task.\n");
    snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "source path: %s, destintion path: %s\n", 
                                                           srcDirPath.c_str(), dstDirPath.c_str());
    std::cout << printBuf << std::endl;
    fwrite(printBuf, 1, strlen(printBuf), normalFd);
    
    len = snprintf(printBuf, sizeof(printBuf) - 1, "\nData Transfer Error Information.\n");
    snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "source path: %s, destintion path: %s\n", 
                                                           srcDirPath.c_str(), dstDirPath.c_str());
    fwrite(printBuf, 1, strlen(printBuf), errorFd);
    snprintf(printBuf, sizeof(printBuf), "=========================================================================================\n");
    fwrite(printBuf, 1, strlen(printBuf), normalFd);
    fwrite(printBuf, 1, strlen(printBuf), errorFd);

    std::thread printThread;
    std::thread taskThread;
    std::vector<std::thread> workThreads;

    int deep = 1;
    struct timeval start_time;
    struct timeval end_time;
    gettimeofday(&start_time, NULL);

    // according to compound mode, running corresponding task producer and task executor
    if (compoundMode == 1) {  // source is local, destination is ftp
        taskThread = std::thread(local2ftp_dispatcher, pFtp, realSrcPath, realDstPath);
        for (int i = 0; i < threadNum; i++) {
            workThreads.push_back(std::thread(local2ftp_worker, pFtp, i, pRecv->verify));
            ++liveWorkThread;
        }
    } else if (compoundMode == 2) {  // source is ftp, destination is local
        taskThread = std::thread(ftp2local_dispatcher, pFtp, realSrcPath, realDstPath);
        for (int i = 0; i < threadNum; i++) {
            workThreads.push_back(std::thread(ftp2local_worker, pFtp, i, pRecv->verify));
            ++liveWorkThread;
        }
    } else if (compoundMode == 3) {  // source is ftp, destination is null
        taskThread = std::thread(ftp2null_dispatcher, pFtp, realSrcPath, realDstPath);
        for (int i = 0; i < threadNum; i++) {
            workThreads.push_back(std::thread(ftp2null_worker, pFtp, i, pRecv->verify));
            ++liveWorkThread;
        }
    } else if (compoundMode == 4) {  // source is null, destination is ftp
        fileNum = pow(pRecv->width, pRecv->layer) * pRecv->fileNum * threadNum;
        for (int i = 0; i < threadNum; i++) {
            workThreads.push_back(std::thread(null2ftp_worker, pFtp, pRecv, realDstPath, i));
            ++liveWorkThread;
        }
    }
    printThread = std::thread(task_print);

    if (compoundMode != 4) {
        taskThread.join();
    }
    for (auto & th : workThreads) {
        th.join();
    }
    gettimeofday(&end_time, NULL);

    endFlag = 1;
    printThread.join();

    len = snprintf(printBuf, sizeof(printBuf) - 1, "\n\n---------- statistic information ----------\n");

    long long interval = ((long long)end_time.tv_sec*1000000 + end_time.tv_usec) - ((long long)start_time.tv_sec*1000000 + start_time.tv_usec);
    len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "total time: %.2f s\n", ((float)interval / 1000000));

    size_to_string(totalFileSize, buf);
    len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "total size: %s (%ld B)\n", buf, totalFileSize);

    int64_t finishSizeTmp = finishSize;
    size_to_string(finishSizeTmp, buf);
    len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "transfer size: %s (%ld B)\n", buf, finishSizeTmp);

    long errorSizeTmp = errorSize;
    size_to_string(errorSizeTmp, buf);
    len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "failed size: %s (%ld B)\n", buf, errorSizeTmp);

    if (pRecv->verify) {
        if (compoundMode == 1 || compoundMode == 4) {  // ftp is destination, upload
            long md5UploadFailed = md5Failed;
            len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "md5 file upload failed: %ld\n", md5UploadFailed);
        } else if (compoundMode == 2 || compoundMode == 3) {  // ftp is source, download
            long verifyFailedNum = verifyFailed;
            len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "verify failed: %ld\n", verifyFailedNum);
        }
    }

    int uploadRate = ((double)finishSizeTmp/interval) * 1000000;
    size_to_string(uploadRate, buf);
    snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "average copy rate: %s/s\n\n", buf);
    write(1, printBuf, strlen(printBuf));
    fwrite(printBuf, 1, strlen(printBuf), normalFd);

    long fileNumTmp = fileNum;
    if (failed == 0) {
        long finishedTmp = finished;
        len = snprintf(printBuf, sizeof(printBuf) - 1, "Data Migration Succeeded!\n");
        len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "source path: %s, destintion path: %s, total number: %ld, Finished number: %ld\n",
                                                                     srcDirPath.c_str(), dstDirPath.c_str(), fileNumTmp, finishedTmp);
        snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "=========================================================================================\n\n");
        fwrite(printBuf, 1, strlen(printBuf), normalFd);
    } else {
        long failedTmp = failed;
        len = snprintf(printBuf, sizeof(printBuf) - 1, "Data Migration failed!\n");
        len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "Please view the file './FtpBenchMarkError.log' for detailed information.\n");
        len += snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "source path: %s, destintion path: %s, total number: %ld, Failed number: %ld\n",
                                                                     srcDirPath.c_str(), dstDirPath.c_str(), fileNumTmp, failedTmp);
        snprintf(printBuf + len, sizeof(printBuf) - 1 - len, "=========================================================================================\n\n");
        fwrite(printBuf, 1, strlen(printBuf), normalFd);
    }
    fwrite(printBuf + len, 1, strlen(printBuf) - len, errorFd);

    if (normalFd) {
        fflush(normalFd);
        fclose(normalFd);
    }
    if (errorFd) {
        fflush(errorFd);
        fclose(errorFd);
    }
    delete [] buf;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp            # imm = 0x588
movq %rsi, %r15
cmpl $0x1, %edi
jne 0xa72a
movq (%r15), %rdi
callq 0xbc94
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xba8b
movl %edi, %ebp
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x81c6(%rip), %rbx      # 0x12902
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xd47e
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xd47e
leaq 0xb0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x818a(%rip), %rdx      # 0x12902
leaq 0xa0(%rsp), %rdi
movq %rdx, %rsi
callq 0xd47e
movl $0x18, %edi
callq 0x43f0
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x28(%rsp)
movl $0x50, %edi
callq 0x43f0
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb %cl, 0x10(%rax)
movq $-0x1, 0x20(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movb %cl, 0x4c(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x30(%rax)
movq %rcx, 0x40(%rax)
movq %rax, 0x20(%rsp)
movb %cl, 0xdcea(%rip)       # 0x184d8
leaq 0x7ebe(%rip), %rdx      # 0x126b3
movl %ebp, %edi
movq %r15, %rsi
callq 0x40b0
shll $0x18, %eax
movl $0x8, 0x40(%rsp)
cmpl $0xff000000, %eax       # imm = 0xFF000000
movq %r15, 0x30(%rsp)
je 0xa953
movl $0x8, 0x40(%rsp)
movq 0xd77f(%rip), %r12      # 0x17fa8
leaq 0x7e83(%rip), %rbx      # 0x126b3
leaq 0x77e9(%rip), %r14      # 0x12020
sarl $0x18, %eax
leal -0x64(%rax), %ecx
cmpl $0x13, %ecx
ja 0xa859
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movq (%r12), %r15
leaq 0x68(%rsp), %r12
jmp 0xa8e4
cmpl $0x53, %eax
jne 0xba0f
movq (%r12), %r15
leaq 0xa0(%rsp), %r12
jmp 0xa8e4
movq (%r12), %r15
movq 0x28(%rsp), %rax
movq %r15, 0x8(%rax)
movq 0x20(%rsp), %r12
jmp 0xa8e4
movq (%r12), %rdi
callq 0x4600
movq 0x20(%rsp), %rcx
movl %eax, 0x20(%rcx)
jmp 0xa938
movq (%r12), %rdi
callq 0x4600
movl %eax, 0x40(%rsp)
jmp 0xa938
movq (%r12), %rdi
callq 0x4600
movq 0x20(%rsp), %rcx
movl %eax, 0x24(%rcx)
jmp 0xa938
movb $0x1, 0xdc12(%rip)      # 0x184d8
jmp 0xa938
movq (%r12), %rdi
callq 0x4600
movq 0x20(%rsp), %rcx
movl %eax, 0x28(%rcx)
jmp 0xa938
movq (%r12), %r15
leaq 0x48(%rsp), %r12
movq 0x8(%r12), %r13
movq %r15, %rdi
callq 0x4180
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x45f0
movq 0x30(%rsp), %r15
movq 0xd698(%rip), %r12      # 0x17fa8
jmp 0xa938
movq (%r12), %rax
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
jmp 0xa938
movq 0x20(%rsp), %rax
movb $0x1, 0x4c(%rax)
jmp 0xa938
movq (%r12), %rax
movq 0x28(%rsp), %rcx
movq %rax, 0x10(%rcx)
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40b0
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0xa837
movq 0x28(%rsp), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0xab19
cmpb $0x0, (%rcx)
je 0xab19
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xab23
cmpb $0x0, (%rcx)
je 0xab23
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xab2d
cmpb $0x0, (%rax)
je 0xab2d
cmpq $0x0, 0x50(%rsp)
je 0xb396
cmpq $0x0, 0x70(%rsp)
je 0xb3a0
leaq 0x7dcb(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xab4d
movq 0x20(%rsp), %rax
cmpl $0x0, 0x28(%rax)
js 0xb9df
leaq 0x7f22(%rip), %rsi      # 0x12902
leaq 0xa0(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xb9eb
movq 0x20(%rsp), %rax
cmpl $0x0, 0x20(%rax)
js 0xb9f7
cmpl $0x0, 0x24(%rax)
js 0xba03
leaq 0x898b(%rip), %rsi      # 0x133a0
leaq 0xa0(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x45b0
cmpq $-0x1, %rax
je 0xab37
movq %rax, %rbx
leaq 0x180(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4410
movq 0x180(%rsp), %rdi
callq 0xdd46
movq 0x20(%rsp), %rcx
movq %rax, 0x40(%rcx)
leaq 0x190(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xaa87
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
incq %rbx
leaq 0x180(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x4410
movq 0x180(%rsp), %rdi
callq 0xdd46
movq 0x20(%rsp), %rcx
movq %rax, 0x38(%rcx)
movq 0x180(%rsp), %rdi
cmpq %r14, %rdi
je 0xaadc
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x20(%rsp), %rcx
movq 0x40(%rcx), %rsi
testq %rsi, %rsi
js 0xab00
movq 0x38(%rcx), %rax
testq %rax, %rax
setg %dl
cmpq %rax, %rsi
setle %dil
testb %dil, %dl
jne 0xab49
movq 0x38(%rcx), %rdx
leaq 0x7d89(%rip), %rdi      # 0x12894
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4060
jmp 0xba2e
callq 0x4b63
jmp 0xba29
callq 0x4b41
jmp 0xba29
callq 0x4b1f
jmp 0xba29
movq 0xa0(%rsp), %rdi
callq 0xdd46
movq 0x20(%rsp), %rcx
movq %rax, 0x30(%rcx)
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
leaq 0x150(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x130(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x110(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xe8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x87f8(%rip), %rsi      # 0x133a0
leaq 0x48(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x46d0
movq %rax, %rbx
shlq $0x20, %rbx
cmpq %r13, %rbx
jne 0xabf5
leaq 0x7bb7(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb9bb
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4200
jmp 0xacad
movslq %eax, %r15
leaq 0x180(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4410
leaq 0x140(%rsp), %rdi
leaq 0x180(%rsp), %r12
movq %r12, %rsi
callq 0x44c0
movq (%r12), %rdi
leaq 0x190(%rsp), %r14
cmpq %r14, %rdi
je 0xac48
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbx
sarq $0x20, %rbx
notq %r15
leaq 0x48(%rsp), %rsi
addq 0x8(%rsi), %r15
leaq 0x180(%rsp), %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4410
leaq 0x100(%rsp), %rdi
leaq 0x180(%rsp), %rbx
movq %rbx, %rsi
callq 0x44c0
movq (%rbx), %rdi
cmpq %r14, %rdi
movq 0x30(%rsp), %r15
je 0xacad
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
leaq 0x7acf(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xacee
movq 0x70(%rsp), %rdx
movq %rdx, %rsi
subq $0x1, %rsi
jb 0xbaae
movq 0x68(%rsp), %rax
cmpb $0x2f, (%rax,%rsi)
je 0xacee
leaq 0x68(%rsp), %rdi
movl $0x2f, %esi
callq 0x4320
leaq 0x86ab(%rip), %rsi      # 0x133a0
leaq 0x68(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x46d0
movq %rax, %rbx
shlq $0x20, %rbx
cmpq %r13, %rbx
jne 0xad42
leaq 0x7a6a(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb9cd
leaq 0xd8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4200
jmp 0xadfa
movslq %eax, %r15
leaq 0x180(%rsp), %rdi
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4410
leaq 0x120(%rsp), %rdi
leaq 0x180(%rsp), %r12
movq %r12, %rsi
callq 0x44c0
movq (%r12), %rdi
leaq 0x190(%rsp), %r14
cmpq %r14, %rdi
je 0xad95
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbx
sarq $0x20, %rbx
notq %r15
leaq 0x68(%rsp), %rsi
addq 0x8(%rsi), %r15
leaq 0x180(%rsp), %rdi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4410
leaq 0xd8(%rsp), %rdi
leaq 0x180(%rsp), %rbx
movq %rbx, %rsi
callq 0x44c0
movq (%rbx), %rdi
cmpq %r14, %rdi
movq 0x30(%rsp), %r15
je 0xadfa
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
leaq 0x7b33(%rip), %rsi      # 0x12934
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xae2e
leaq 0x7b21(%rip), %rsi      # 0x1293a
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xaecf
leaq 0x7b05(%rip), %rsi      # 0x1293a
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xae5e
leaq 0x7ae7(%rip), %rsi      # 0x12934
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xaed5
leaq 0x7ad5(%rip), %rsi      # 0x1293a
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xae8b
leaq 0x7906(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xaedf
leaq 0x78f1(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb3aa
leaq 0x7a8f(%rip), %rsi      # 0x1293a
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb3aa
movb $0x1, %al
movl %eax, 0x30(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
jmp 0xaeee
movb $0x1, %bl
xorl %ebp, %ebp
jmp 0xaeda
movb $0x1, %bpl
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0xaee6
movb $0x1, %r14b
xorl %ebx, %ebx
xorl %ebp, %ebp
movl $0x0, 0x30(%rsp)
movq 0xd4e3(%rip), %rdi      # 0x183d8
leaq 0x7a85(%rip), %rsi      # 0x12981
callq 0x4490
movq %rax, 0xd5d8(%rip)      # 0x184e0
testq %rax, %rax
je 0xb1d0
movq 0xd4c8(%rip), %rdi      # 0x183e0
leaq 0x7a62(%rip), %rsi      # 0x12981
callq 0x4490
movq %rax, 0xd5bd(%rip)      # 0x184e8
testq %rax, %rax
je 0xb1e3
movl %r14d, 0x94(%rsp)
movl %ebp, 0x98(%rsp)
movl %ebx, 0x9c(%rsp)
movl $0x80, %edi
callq 0x4030
movq %rax, 0xf8(%rsp)
movups 0x7a48(%rip), %xmm0     # 0x129ab
leaq 0x1a4(%rsp), %rdi
movaps %xmm0, -0x14(%rdi)
movupd 0x7a24(%rip), %xmm0     # 0x1299b
movapd %xmm0, -0x24(%rdi)
movabsq $0xa2e6b73615420, %rax  # imm = 0xA2E6B73615420
movq %rax, -0x7(%rdi)
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
leaq 0x7a25(%rip), %rdx      # 0x129c0
movl $0x3db, %esi            # imm = 0x3DB
xorl %eax, %eax
callq 0x4620
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xd002(%rip), %rbx      # 0x17fc0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4460
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x43b0
movsbl %al, %esi
movq 0xcfd6(%rip), %rdi      # 0x17fc0
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xd4d2(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4760
movups 0x79c1(%rip), %xmm0     # 0x129e6
leaq 0x1a2(%rsp), %rdi
movaps %xmm0, -0x22(%rdi)
movupd 0x79bd(%rip), %xmm0     # 0x129f6
movapd %xmm0, -0x12(%rdi)
movl $0xa2e6e, -0x3(%rdi)    # imm = 0xA2E6E
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
leaq 0x796a(%rip), %rdx      # 0x129c0
xorl %ebx, %ebx
movl $0x3dd, %esi            # imm = 0x3DD
xorl %eax, %eax
callq 0x4620
movq %r14, %rdi
callq 0x4180
movq 0xd475(%rip), %rcx      # 0x184e8
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4760
leaq 0x797f(%rip), %rsi      # 0x12a09
movl $0x5b, %edx
movq %r14, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4180
movq 0xd43a(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4760
movq %r14, %rdi
callq 0x4180
movq 0xd423(%rip), %rcx      # 0x184e8
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4760
movq %rbx, 0x88(%rsp)
movq %rbx, 0x38(%rsp)
movq %rbx, 0xd0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xc0(%rsp)
leaq 0x170(%rsp), %rdi
xorl %esi, %esi
callq 0x4640
cmpb $0x0, 0x9c(%rsp)
movl 0x40(%rsp), %r14d
je 0xb20c
leaq -0x5252(%rip), %rsi     # 0x5ece
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbee8
cmpq $0x0, 0x38(%rsp)
jne 0xbc27
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb478
leaq -0x5f8c(%rip), %rbx     # 0x51e1
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x14(%rsp), %rbp
leaq 0xc0(%rsp), %r15
movq 0x20(%rsp), %r8
addq $0x4c, %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xbf94
movq %r15, %rdi
movq %r12, %rsi
callq 0xd91e
cmpq $0x0, 0x18(%rsp)
jne 0xbc27
lock
incl 0xd33c(%rip)            # 0x184f8
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb184
jmp 0xb478
movq 0xcdc1(%rip), %rax      # 0x17f98
movq (%rax), %rdi
movq 0xd1f7(%rip), %rdx      # 0x183d8
jmp 0xb1f4
movq 0xcdae(%rip), %rax      # 0x17f98
movq (%rax), %rdi
movq 0xd1ec(%rip), %rdx      # 0x183e0
leaq 0x7788(%rip), %rsi      # 0x12983
xorl %eax, %eax
callq 0x4540
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb921
cmpb $0x0, 0x98(%rsp)
je 0xb2d1
leaq -0x3cbb(%rip), %rsi     # 0x7566
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbee8
cmpq $0x0, 0x38(%rsp)
jne 0xbc27
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb478
leaq -0x4808(%rip), %rbx     # 0x6a66
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x14(%rsp), %rbp
leaq 0xc0(%rsp), %r15
movq 0x20(%rsp), %r8
addq $0x4c, %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xbf94
movq %r15, %rdi
movq %r12, %rsi
callq 0xd91e
cmpq $0x0, 0x18(%rsp)
jne 0xbc27
lock
incl 0xd23b(%rip)            # 0x184f8
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb285
jmp 0xb478
cmpb $0x0, 0x94(%rsp)
je 0xb3c1
leaq -0x25f7(%rip), %rsi     # 0x8cef
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbee8
cmpq $0x0, 0x38(%rsp)
jne 0xbc27
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb478
leaq -0x3018(%rip), %rbx     # 0x831b
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x14(%rsp), %rbp
leaq 0xc0(%rsp), %r15
movq 0x20(%rsp), %r8
addq $0x4c, %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xbf94
movq %r15, %rdi
movq %r12, %rsi
callq 0xd91e
cmpq $0x0, 0x18(%rsp)
jne 0xbc27
lock
incl 0xd176(%rip)            # 0x184f8
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb34a
jmp 0xb478
callq 0x4afd
jmp 0xba29
callq 0x4adb
jmp 0xba29
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %r15, %rdx
callq 0x4a1c
jmp 0xb202
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0x20(%rax), %xmm0
cvtsi2sdl 0x24(%rax), %xmm1
callq 0x46e0
movq 0x20(%rsp), %rax
xorps %xmm1, %xmm1
cvtsi2sdl 0x28(%rax), %xmm1
cvtsi2sd %r14d, %xmm2
mulsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
xchgq %rax, 0xd102(%rip)      # 0x18500
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb478
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x20(%rsp), %rbp
leaq 0xd8(%rsp), %r15
leaq 0x14(%rsp), %r14
leaq 0xc0(%rsp), %rbx
movq %r12, %rdi
leaq -0x1bb3(%rip), %rsi     # 0x9886
movq %r13, %rdx
movq %rbp, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xc03e
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd91e
cmpq $0x0, 0x18(%rsp)
jne 0xbc27
lock
incl 0xd090(%rip)            # 0x184f8
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl 0x40(%rsp), %eax
jl 0xb42f
leaq -0x65d3(%rip), %rsi     # 0x4eac
leaq 0x18(%rsp), %rdi
callq 0xc0fe
cmpq $0x0, 0x88(%rsp)
jne 0xbc27
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
cmpb $0x0, 0x30(%rsp)
jne 0xb4b6
leaq 0x38(%rsp), %rdi
callq 0x46b0
movq 0xc0(%rsp), %rbx
movq 0xc8(%rsp), %r14
cmpq %r14, %rbx
je 0xb4d9
movq %rbx, %rdi
callq 0x46b0
addq $0x8, %rbx
jmp 0xb4c6
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
callq 0x4640
movl $0x1, %eax
xchgl %eax, 0xd001(%rip)      # 0x184f4
leaq 0x88(%rsp), %rdi
callq 0x46b0
movups 0x757c(%rip), %xmm0     # 0x12a83
leaq 0x1ae(%rsp), %rdi
movups %xmm0, -0xf(%rdi)
movups 0x755a(%rip), %xmm0     # 0x12a74
movaps %xmm0, -0x1e(%rdi)
movups 0x753f(%rip), %xmm0     # 0x12a64
movq 0x160(%rsp), %rax
subq 0x170(%rsp), %rax
movq 0x168(%rsp), %r13
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
subq 0x178(%rsp), %r13
addq %rax, %r13
xorps %xmm1, %xmm1
cvtsi2ss %r13, %xmm1
movaps %xmm0, -0x2e(%rdi)
divss 0x6aa1(%rip), %xmm1     # 0x12004
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x7522(%rip), %rdx      # 0x12a93
movl $0x3d1, %ebx            # imm = 0x3D1
movl $0x3d1, %esi            # imm = 0x3D1
movb $0x1, %al
callq 0x4620
movl %eax, %r12d
movq 0xcfac(%rip), %rdi      # 0x18538
movq 0xf8(%rsp), %r14
movq %r14, %rsi
callq 0xdca2
movslq %r12d, %rax
leaq 0x180(%rsp), %rcx
leaq (%rax,%rcx), %rdi
addq $0x2e, %rdi
subq %rax, %rbx
movq 0xcf7f(%rip), %r8       # 0x18538
leaq 0x74e7(%rip), %rdx      # 0x12aa7
movq %rbx, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x4620
movl %eax, %ebp
movq 0xcf52(%rip), %r15      # 0x18528
movq %r15, %rdi
movq %r14, %rsi
callq 0xdca2
movq %r14, %rbx
addl $0x2e, %r12d
addl %r12d, %ebp
movslq %ebp, %rax
leaq (%rsp,%rax), %rdi
addq $0x180, %rdi            # imm = 0x180
movl $0x3ff, %r14d           # imm = 0x3FF
movl $0x3ff, %esi            # imm = 0x3FF
subq %rax, %rsi
leaq 0x74b1(%rip), %rdx      # 0x12abf
movq %rbx, %rcx
movq %r15, 0x40(%rsp)
movq %r15, %r8
xorl %eax, %eax
callq 0x4620
movl %eax, %r12d
movq 0xcf06(%rip), %r15      # 0x18530
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdca2
addl %ebp, %r12d
movslq %r12d, %r12
leaq (%rsp,%r12), %rdi
addq $0x180, %rdi            # imm = 0x180
subq %r12, %r14
leaq 0x748a(%rip), %rdx      # 0x12ada
movq %r14, %rsi
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x4620
addl %eax, %r12d
movq 0x20(%rsp), %rax
cmpb $0x1, 0x4c(%rax)
movq %rbx, %r14
jne 0xb693
movl 0x9c(%rsp), %eax
orb 0x30(%rsp), %al
movq 0x40(%rsp), %rbx
je 0xb69a
leaq 0x7469(%rip), %rdx      # 0x12af3
leaq 0xce87(%rip), %rax      # 0x18518
jmp 0xb6ba
movq 0x40(%rsp), %rbx
jmp 0xb6dd
movl 0x98(%rsp), %eax
orb 0x94(%rsp), %al
cmpb $0x1, %al
jne 0xb6dd
leaq 0x745d(%rip), %rdx      # 0x12b10
leaq 0xce66(%rip), %rax      # 0x18520
movq (%rax), %rcx
movslq %r12d, %r12
leaq (%rsp,%r12), %rdi
addq $0x180, %rdi            # imm = 0x180
movl $0x3ff, %esi            # imm = 0x3FF
subq %r12, %rsi
xorl %eax, %eax
callq 0x4620
addl %eax, %r12d
cvtsi2sd %rbx, %xmm0
cvtsi2sd %r13, %xmm1
divsd %xmm1, %xmm0
mulsd 0x6915(%rip), %xmm0     # 0x12008
cvttsd2si %xmm0, %eax
movslq %eax, %rdi
movq %r14, %rsi
callq 0xdca2
movslq %r12d, %rax
leaq (%rsp,%rax), %rdi
addq $0x180, %rdi            # imm = 0x180
movl $0x3ff, %esi            # imm = 0x3FF
subq %rax, %rsi
leaq 0x7405(%rip), %rdx      # 0x12b24
movq %r14, %rcx
xorl %eax, %eax
callq 0x4620
leaq 0x180(%rsp), %rbx
movq %rbx, %rdi
callq 0x4180
movl $0x1, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4140
leaq 0x180(%rsp), %rbx
movq %rbx, %rdi
callq 0x4180
movq 0xcd80(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4760
movq 0xcd89(%rip), %rbx      # 0x18500
movq 0xcd92(%rip), %rax      # 0x18510
testq %rax, %rax
je 0xb7ef
movq 0xcd86(%rip), %r14      # 0x18510
movabsq $0xa2164656c6961, %rax  # imm = 0xA2164656C6961
leaq 0x197(%rsp), %rdi
movq %rax, -0x7(%rdi)
movupd 0x745c(%rip), %xmm0     # 0x12c04
movapd %xmm0, -0x17(%rdi)
leaq 0x7468(%rip), %rsi      # 0x12c1c
movl $0x4a, %edx
callq 0x42f0
leaq 0x1e0(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
movq %r14, (%rsp)
leaq 0x748b(%rip), %rdx      # 0x12c66
movl $0x39f, %esi            # imm = 0x39F
movq %rbx, %r9
xorl %eax, %eax
callq 0x4620
addl $0x60, %eax
jmp 0xb83d
movq 0xcd12(%rip), %rax      # 0x18508
movups 0x734c(%rip), %xmm0     # 0x12b49
leaq 0x19a(%rsp), %rdi
movups %xmm0, -0xf(%rdi)
movupd 0x732d(%rip), %xmm0     # 0x12b3e
movapd %xmm0, -0x1a(%rdi)
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
movq %rax, (%rsp)
leaq 0x732e(%rip), %rdx      # 0x12b59
movl $0x3e5, %esi            # imm = 0x3E5
movq %rbx, %r9
xorl %eax, %eax
callq 0x4620
addl $0x1a, %eax
movslq %eax, %r15
leaq (%rsp,%r15), %rbx
addq $0x180, %rbx            # imm = 0x180
movl $0x3ff, %esi            # imm = 0x3FF
subq %r15, %rsi
leaq 0x734e(%rip), %rdx      # 0x12ba8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4620
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xcc65(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4760
movq %r14, %rdi
callq 0x4180
subq %r15, %rax
movq 0xcc4b(%rip), %rcx      # 0x184e8
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4760
movq 0xcc2c(%rip), %rdi      # 0x184e0
testq %rdi, %rdi
je 0xb8ca
callq 0x4480
movq 0xcc1b(%rip), %rdi      # 0x184e0
callq 0x43e0
movq 0xcc17(%rip), %rdi      # 0x184e8
testq %rdi, %rdi
movq 0xf8(%rsp), %rbx
je 0xb8ef
callq 0x4480
movq 0xcbfe(%rip), %rdi      # 0x184e8
callq 0x43e0
movq %rbx, %rdi
callq 0x44e0
leaq 0xc0(%rsp), %rdi
callq 0xc178
cmpq $0x0, 0x38(%rsp)
jne 0xbc27
cmpq $0x0, 0x88(%rsp)
jne 0xbc27
xorl %ebx, %ebx
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0xb946
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0xb96b
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0xb990
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x140(%rsp), %rdi
leaq 0x150(%rsp), %rax
cmpq %rax, %rdi
je 0xba2e
movq 0x150(%rsp), %rsi
incq %rsi
callq 0x4400
jmp 0xba2e
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x49c4
jmp 0xb202
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x49f0
jmp 0xb202
leaq 0x48(%rsp), %rdi
callq 0x4ab7
jmp 0xba29
leaq 0x48(%rsp), %rdi
callq 0x4a93
jmp 0xba29
leaq 0x48(%rsp), %rdi
callq 0x4a6f
jmp 0xba29
leaq 0x48(%rsp), %rdi
callq 0x4a4b
jmp 0xba29
movq 0xc5b2(%rip), %rcx      # 0x17fc8
movq (%rcx), %rdi
leaq 0x6cad(%rip), %rsi      # 0x126cd
movl %eax, %edx
xorl %eax, %eax
callq 0x4540
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0xba53
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xba6f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xba8b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4400
movl %ebx, %eax
addq $0x588, %rsp            # imm = 0x588
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
callq 0xbc94
xorl %edi, %edi
callq 0x44b0
leaq 0x77e1(%rip), %rdi      # 0x13296
xorl %eax, %eax
callq 0x45a0
jmp 0xbb66
jmp 0xbb66
jmp 0xbc2c
jmp 0xbb66
movq %rax, %rbx
movq 0x180(%rsp), %rdi
cmpq %r14, %rdi
jne 0xbb02
jmp 0xbc2f
jmp 0xbc2c
movq %rax, %rbx
leaq 0x190(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc2f
movq 0x190(%rsp), %rsi
jmp 0xbc1d
jmp 0xbc2c
jmp 0xbb66
jmp 0xbb66
jmp 0xbb66
jmp 0xbb66
jmp 0xbb38
jmp 0xbb38
jmp 0xbb38
jmp 0xbb38
jmp 0xbb38
jmp 0xbb66
jmp 0xbb66
jmp 0xbb66
jmp 0xbb59
jmp 0xbb66
jmp 0xbb59
jmp 0xbb38
jmp 0xbb66
jmp 0xbb59
movq %rax, %rbx
jmp 0xbb91
jmp 0xbc2c
jmp 0xbc2c
movq %rax, %rbx
jmp 0xbc54
movq %rax, %rbx
jmp 0xbc70
jmp 0xbb66
cmpq $0x0, 0x18(%rsp)
je 0xbb66
jmp 0xbc27
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xc178
cmpq $0x0, 0x38(%rsp)
jne 0xbc27
cmpq $0x0, 0x88(%rsp)
jne 0xbc27
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0xbbb6
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0xbbdb
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0xbc00
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x140(%rsp), %rdi
leaq 0x150(%rsp), %rax
cmpq %rax, %rdi
je 0xbc2f
movq 0x150(%rsp), %rsi
incq %rsi
callq 0x4400
jmp 0xbc2f
callq 0x40e0
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0xbc54
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xbc70
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xbc8c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4400
movq %rbx, %rdi
callq 0x46f0