// File: /workspace/github_cpp_makefile_star2_O3/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 0xa6f9
movq (%r15), %rdi
callq 0xbc61
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xba56
movl %edi, %ebp
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x81f7(%rip), %rbx      # 0x12902
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xd43e
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xd43e
leaq 0xb0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x81bb(%rip), %rdx      # 0x12902
leaq 0xa0(%rsp), %rdi
movq %rdx, %rsi
callq 0xd43e
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, 0xdd13(%rip)       # 0x184d0
leaq 0x7eef(%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 0xa922
movl $0x8, 0x40(%rsp)
movq 0xd7b0(%rip), %r12      # 0x17fa8
leaq 0x7eb4(%rip), %rbx      # 0x126b3
leaq 0x781a(%rip), %r14      # 0x12020
sarl $0x18, %eax
leal -0x64(%rax), %ecx
cmpl $0x13, %ecx
ja 0xa828
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movq (%r12), %r15
leaq 0x68(%rsp), %r12
jmp 0xa8b3
cmpl $0x53, %eax
jne 0xb9da
movq (%r12), %r15
leaq 0xa0(%rsp), %r12
jmp 0xa8b3
movq (%r12), %r15
movq 0x28(%rsp), %rax
movq %r15, 0x8(%rax)
movq 0x20(%rsp), %r12
jmp 0xa8b3
movq (%r12), %rdi
callq 0x45f0
movq 0x20(%rsp), %rcx
movl %eax, 0x20(%rcx)
jmp 0xa907
movq (%r12), %rdi
callq 0x45f0
movl %eax, 0x40(%rsp)
jmp 0xa907
movq (%r12), %rdi
callq 0x45f0
movq 0x20(%rsp), %rcx
movl %eax, 0x24(%rcx)
jmp 0xa907
movb $0x1, 0xdc3b(%rip)      # 0x184d0
jmp 0xa907
movq (%r12), %rdi
callq 0x45f0
movq 0x20(%rsp), %rcx
movl %eax, 0x28(%rcx)
jmp 0xa907
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 0x45e0
movq 0x30(%rsp), %r15
movq 0xd6c9(%rip), %r12      # 0x17fa8
jmp 0xa907
movq (%r12), %rax
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
jmp 0xa907
movq 0x20(%rsp), %rax
movb $0x1, 0x4c(%rax)
jmp 0xa907
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 0xa806
movq 0x28(%rsp), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0xaae4
cmpb $0x0, (%rcx)
je 0xaae4
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xaaee
cmpb $0x0, (%rcx)
je 0xaaee
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xaaf8
cmpb $0x0, (%rax)
je 0xaaf8
cmpq $0x0, 0x50(%rsp)
je 0xb361
cmpq $0x0, 0x70(%rsp)
je 0xb36b
leaq 0x7dfc(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xab1b
movq 0x20(%rsp), %rax
cmpl $0x0, 0x28(%rax)
js 0xb9aa
leaq 0x7f53(%rip), %rsi      # 0x12902
leaq 0xa0(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xb9b6
movq 0x20(%rsp), %rax
cmpl $0x0, 0x20(%rax)
js 0xb9c2
cmpl $0x0, 0x24(%rax)
js 0xb9ce
leaq 0x89bc(%rip), %rsi      # 0x133a0
leaq 0xa0(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x45a0
cmpq $-0x1, %rax
je 0xab02
movq %rax, %rbx
leaq 0x180(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4410
movq 0x180(%rsp), %rdi
callq 0xdd0a
movq 0x20(%rsp), %rcx
movq %rax, 0x40(%rcx)
leaq 0x190(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xaa56
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 0xdd0a
movq 0x20(%rsp), %rcx
movq %rax, 0x38(%rcx)
movq 0x180(%rsp), %rdi
cmpq %r14, %rdi
je 0xaab0
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rdx
movq 0x40(%rcx), %rsi
testq %rsi, %rsi
js 0xaacf
testq %rdx, %rdx
setg %al
cmpq %rdx, %rsi
setle %dil
testb %dil, %al
jne 0xab17
leaq 0x7dbe(%rip), %rdi      # 0x12894
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4060
jmp 0xb9f9
callq 0x4b53
jmp 0xb9f4
callq 0x4b31
jmp 0xb9f4
callq 0x4b0f
jmp 0xb9f4
movq 0xa0(%rsp), %rdi
callq 0xdd0a
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq %rdx, 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 0x882a(%rip), %rsi      # 0x133a0
leaq 0x48(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x46c0
movq %rax, %rbx
shlq $0x20, %rbx
cmpq %r13, %rbx
jne 0xabc3
leaq 0x7be9(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb986
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4200
jmp 0xac7b
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 0xac16
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 0xac7b
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
leaq 0x7b01(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xacb9
movq 0x70(%rsp), %rsi
subq $0x1, %rsi
jb 0xba79
movq 0x68(%rsp), %rax
cmpb $0x2f, (%rax,%rsi)
je 0xacb9
leaq 0x68(%rsp), %rdi
movl $0x2f, %esi
callq 0x4320
leaq 0x86e0(%rip), %rsi      # 0x133a0
leaq 0x68(%rsp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
callq 0x46c0
movq %rax, %rbx
shlq $0x20, %rbx
cmpq %r13, %rbx
jne 0xad0d
leaq 0x7a9f(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb998
leaq 0xd8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4200
jmp 0xadc5
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 0xad60
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 0xadc5
movq 0x190(%rsp), %rsi
incq %rsi
callq 0x4400
leaq 0x7b68(%rip), %rsi      # 0x12934
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xadf9
leaq 0x7b56(%rip), %rsi      # 0x1293a
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xae9a
leaq 0x7b3a(%rip), %rsi      # 0x1293a
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xae29
leaq 0x7b1c(%rip), %rsi      # 0x12934
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xaea0
leaq 0x7b0a(%rip), %rsi      # 0x1293a
leaq 0x140(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xae56
leaq 0x793b(%rip), %rsi      # 0x12783
leaq 0x68(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
je 0xaeaa
leaq 0x7926(%rip), %rsi      # 0x12783
leaq 0x48(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb375
leaq 0x7ac4(%rip), %rsi      # 0x1293a
leaq 0x120(%rsp), %rdi
callq 0x40f0
testl %eax, %eax
jne 0xb375
movb $0x1, %al
movl %eax, 0x30(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
jmp 0xaeb9
movb $0x1, %bl
xorl %ebp, %ebp
jmp 0xaea5
movb $0x1, %bpl
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0xaeb1
movb $0x1, %r14b
xorl %ebx, %ebx
xorl %ebp, %ebp
movl $0x0, 0x30(%rsp)
movq 0xd510(%rip), %rdi      # 0x183d0
leaq 0x7aba(%rip), %rsi      # 0x12981
callq 0x4490
movq %rax, 0xd605(%rip)      # 0x184d8
testq %rax, %rax
je 0xb19b
movq 0xd4f5(%rip), %rdi      # 0x183d8
leaq 0x7a97(%rip), %rsi      # 0x12981
callq 0x4490
movq %rax, 0xd5ea(%rip)      # 0x184e0
testq %rax, %rax
je 0xb1ae
movl %r14d, 0x94(%rsp)
movl %ebp, 0x98(%rsp)
movl %ebx, 0x9c(%rsp)
movl $0x80, %edi
callq 0x4030
movq %rax, 0xf8(%rsp)
movups 0x7a7d(%rip), %xmm0     # 0x129ab
leaq 0x1a4(%rsp), %rdi
movaps %xmm0, -0x14(%rdi)
movupd 0x7a59(%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 0x7a5a(%rip), %rdx      # 0x129c0
movl $0x3db, %esi            # imm = 0x3DB
xorl %eax, %eax
callq 0x4610
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xd037(%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 0xd00b(%rip), %rdi      # 0x17fc0
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xd4ff(%rip), %rcx      # 0x184d8
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4750
movups 0x79f6(%rip), %xmm0     # 0x129e6
leaq 0x1a2(%rsp), %rdi
movaps %xmm0, -0x22(%rdi)
movupd 0x79f2(%rip), %xmm0     # 0x129f6
movapd %xmm0, -0x12(%rdi)
movl $0xa2e6e, -0x3(%rdi)    # imm = 0xA2E6E
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
leaq 0x799f(%rip), %rdx      # 0x129c0
xorl %ebx, %ebx
movl $0x3dd, %esi            # imm = 0x3DD
xorl %eax, %eax
callq 0x4610
movq %r14, %rdi
callq 0x4180
movq 0xd4a2(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4750
leaq 0x79b4(%rip), %rsi      # 0x12a09
movl $0x5b, %edx
movq %r14, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4180
movq 0xd467(%rip), %rcx      # 0x184d8
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4750
movq %r14, %rdi
callq 0x4180
movq 0xd450(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4750
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 0x4630
cmpb $0x0, 0x9c(%rsp)
movl 0x40(%rsp), %r14d
je 0xb1d7
leaq -0x5230(%rip), %rsi     # 0x5ebb
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbeb4
cmpq $0x0, 0x38(%rsp)
jne 0xbbf4
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb443
leaq -0x5f87(%rip), %rbx     # 0x51b1
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 0xbf50
movq %r15, %rdi
movq %r12, %rsi
callq 0xd8e4
cmpq $0x0, 0x18(%rsp)
jne 0xbbf4
lock
incl 0xd369(%rip)            # 0x184f0
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb14f
jmp 0xb443
movq 0xcdf6(%rip), %rax      # 0x17f98
movq (%rax), %rdi
movq 0xd224(%rip), %rdx      # 0x183d0
jmp 0xb1bf
movq 0xcde3(%rip), %rax      # 0x17f98
movq (%rax), %rdi
movq 0xd219(%rip), %rdx      # 0x183d8
leaq 0x77bd(%rip), %rsi      # 0x12983
xorl %eax, %eax
callq 0x4530
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb8ec
cmpb $0x0, 0x98(%rsp)
je 0xb29c
leaq -0x3c8d(%rip), %rsi     # 0x755f
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbeb4
cmpq $0x0, 0x38(%rsp)
jne 0xbbf4
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb443
leaq -0x47f6(%rip), %rbx     # 0x6a43
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 0xbf50
movq %r15, %rdi
movq %r12, %rsi
callq 0xd8e4
cmpq $0x0, 0x18(%rsp)
jne 0xbbf4
lock
incl 0xd268(%rip)            # 0x184f0
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb250
jmp 0xb443
cmpb $0x0, 0x94(%rsp)
je 0xb38c
leaq -0x25db(%rip), %rsi     # 0x8cd6
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0xd8(%rsp), %r8
callq 0xbeb4
cmpq $0x0, 0x38(%rsp)
jne 0xbbf4
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb443
leaq -0x3002(%rip), %rbx     # 0x82fc
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 0xbf50
movq %r15, %rdi
movq %r12, %rsi
callq 0xd8e4
cmpq $0x0, 0x18(%rsp)
jne 0xbbf4
lock
incl 0xd1a3(%rip)            # 0x184f0
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl %r14d, %eax
jl 0xb315
jmp 0xb443
callq 0x4aed
jmp 0xb9f4
callq 0x4acb
jmp 0xb9f4
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %r15, %rdx
callq 0x4a0c
jmp 0xb1cd
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0x20(%rax), %xmm0
cvtsi2sdl 0x24(%rax), %xmm1
callq 0x46d0
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, 0xd12f(%rip)      # 0x184f8
movl $0x0, 0x14(%rsp)
testl %r14d, %r14d
jle 0xb443
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 -0x1bae(%rip), %rsi     # 0x9856
movq %r13, %rdx
movq %rbp, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xbfe8
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd8e4
cmpq $0x0, 0x18(%rsp)
jne 0xbbf4
lock
incl 0xd0bd(%rip)            # 0x184f0
movl 0x14(%rsp), %eax
incl %eax
movl %eax, 0x14(%rsp)
cmpl 0x40(%rsp), %eax
jl 0xb3fa
leaq -0x65ce(%rip), %rsi     # 0x4e7c
leaq 0x18(%rsp), %rdi
callq 0xc096
cmpq $0x0, 0x88(%rsp)
jne 0xbbf4
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
cmpb $0x0, 0x30(%rsp)
jne 0xb481
leaq 0x38(%rsp), %rdi
callq 0x46a0
movq 0xc0(%rsp), %rbx
movq 0xc8(%rsp), %r14
cmpq %r14, %rbx
je 0xb4a4
movq %rbx, %rdi
callq 0x46a0
addq $0x8, %rbx
jmp 0xb491
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
callq 0x4630
movl $0x1, %eax
xchgl %eax, 0xd02e(%rip)      # 0x184ec
leaq 0x88(%rsp), %rdi
callq 0x46a0
movups 0x75b1(%rip), %xmm0     # 0x12a83
leaq 0x1ae(%rsp), %rdi
movups %xmm0, -0xf(%rdi)
movups 0x758f(%rip), %xmm0     # 0x12a74
movaps %xmm0, -0x1e(%rdi)
movups 0x7574(%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 0x6ad6(%rip), %xmm1     # 0x12004
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x7557(%rip), %rdx      # 0x12a93
movl $0x3d1, %ebx            # imm = 0x3D1
movl $0x3d1, %esi            # imm = 0x3D1
movb $0x1, %al
callq 0x4610
movl %eax, %r12d
movq 0xcfd9(%rip), %rdi      # 0x18530
movq 0xf8(%rsp), %r14
movq %r14, %rsi
callq 0xdc66
movslq %r12d, %rax
leaq 0x180(%rsp), %rcx
leaq (%rax,%rcx), %rdi
addq $0x2e, %rdi
subq %rax, %rbx
movq 0xcfac(%rip), %r8       # 0x18530
leaq 0x751c(%rip), %rdx      # 0x12aa7
movq %rbx, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x4610
movl %eax, %ebp
movq 0xcf7f(%rip), %r15      # 0x18520
movq %r15, %rdi
movq %r14, %rsi
callq 0xdc66
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 0x74e6(%rip), %rdx      # 0x12abf
movq %rbx, %rcx
movq %r15, 0x40(%rsp)
movq %r15, %r8
xorl %eax, %eax
callq 0x4610
movl %eax, %r12d
movq 0xcf33(%rip), %r15      # 0x18528
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdc66
addl %ebp, %r12d
movslq %r12d, %r12
leaq (%rsp,%r12), %rdi
addq $0x180, %rdi            # imm = 0x180
subq %r12, %r14
leaq 0x74bf(%rip), %rdx      # 0x12ada
movq %r14, %rsi
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x4610
addl %eax, %r12d
movq 0x20(%rsp), %rax
cmpb $0x1, 0x4c(%rax)
movq %rbx, %r14
jne 0xb65e
movl 0x9c(%rsp), %eax
orb 0x30(%rsp), %al
movq 0x40(%rsp), %rbx
je 0xb665
leaq 0x749e(%rip), %rdx      # 0x12af3
leaq 0xceb4(%rip), %rax      # 0x18510
jmp 0xb685
movq 0x40(%rsp), %rbx
jmp 0xb6a8
movl 0x98(%rsp), %eax
orb 0x94(%rsp), %al
cmpb $0x1, %al
jne 0xb6a8
leaq 0x7492(%rip), %rdx      # 0x12b10
leaq 0xce93(%rip), %rax      # 0x18518
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 0x4610
addl %eax, %r12d
cvtsi2sd %rbx, %xmm0
cvtsi2sd %r13, %xmm1
divsd %xmm1, %xmm0
mulsd 0x694a(%rip), %xmm0     # 0x12008
cvttsd2si %xmm0, %eax
movslq %eax, %rdi
movq %r14, %rsi
callq 0xdc66
movslq %r12d, %rax
leaq (%rsp,%rax), %rdi
addq $0x180, %rdi            # imm = 0x180
movl $0x3ff, %esi            # imm = 0x3FF
subq %rax, %rsi
leaq 0x743a(%rip), %rdx      # 0x12b24
movq %r14, %rcx
xorl %eax, %eax
callq 0x4610
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 0xcdad(%rip), %rcx      # 0x184d8
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4750
movq 0xcdb6(%rip), %rbx      # 0x184f8
movq 0xcdbf(%rip), %rax      # 0x18508
testq %rax, %rax
je 0xb7ba
movq 0xcdb3(%rip), %r14      # 0x18508
movabsq $0xa2164656c6961, %rax  # imm = 0xA2164656C6961
leaq 0x197(%rsp), %rdi
movq %rax, -0x7(%rdi)
movupd 0x7491(%rip), %xmm0     # 0x12c04
movapd %xmm0, -0x17(%rdi)
leaq 0x749d(%rip), %rsi      # 0x12c1c
movl $0x4a, %edx
callq 0x42f0
leaq 0x1e0(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
movq %r14, (%rsp)
leaq 0x74c0(%rip), %rdx      # 0x12c66
movl $0x39f, %esi            # imm = 0x39F
movq %rbx, %r9
xorl %eax, %eax
callq 0x4610
addl $0x60, %eax
jmp 0xb808
movq 0xcd3f(%rip), %rax      # 0x18500
movups 0x7381(%rip), %xmm0     # 0x12b49
leaq 0x19a(%rsp), %rdi
movups %xmm0, -0xf(%rdi)
movupd 0x7362(%rip), %xmm0     # 0x12b3e
movapd %xmm0, -0x1a(%rdi)
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %r8
movq %rax, (%rsp)
leaq 0x7363(%rip), %rdx      # 0x12b59
movl $0x3e5, %esi            # imm = 0x3E5
movq %rbx, %r9
xorl %eax, %eax
callq 0x4610
addl $0x1a, %eax
movslq %eax, %r15
leaq (%rsp,%r15), %rbx
addq $0x180, %rbx            # imm = 0x180
movl $0x3ff, %esi            # imm = 0x3FF
subq %r15, %rsi
leaq 0x7383(%rip), %rdx      # 0x12ba8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4610
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x4180
movq 0xcc92(%rip), %rcx      # 0x184d8
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4750
movq %r14, %rdi
callq 0x4180
subq %r15, %rax
movq 0xcc78(%rip), %rcx      # 0x184e0
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x4750
movq 0xcc59(%rip), %rdi      # 0x184d8
testq %rdi, %rdi
je 0xb895
callq 0x4480
movq 0xcc48(%rip), %rdi      # 0x184d8
callq 0x43e0
movq 0xcc44(%rip), %rdi      # 0x184e0
testq %rdi, %rdi
movq 0xf8(%rsp), %rbx
je 0xb8ba
callq 0x4480
movq 0xcc2b(%rip), %rdi      # 0x184e0
callq 0x43e0
movq %rbx, %rdi
callq 0x44e0
leaq 0xc0(%rsp), %rdi
callq 0xc100
cmpq $0x0, 0x38(%rsp)
jne 0xbbf4
cmpq $0x0, 0x88(%rsp)
jne 0xbbf4
xorl %ebx, %ebx
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0xb911
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0xb936
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0xb95b
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x140(%rsp), %rdi
leaq 0x150(%rsp), %rax
cmpq %rax, %rdi
je 0xb9f9
movq 0x150(%rsp), %rsi
incq %rsi
callq 0x4400
jmp 0xb9f9
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x49b4
jmp 0xb1cd
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x49e0
jmp 0xb1cd
leaq 0x48(%rsp), %rdi
callq 0x4aa7
jmp 0xb9f4
leaq 0x48(%rsp), %rdi
callq 0x4a83
jmp 0xb9f4
leaq 0x48(%rsp), %rdi
callq 0x4a5f
jmp 0xb9f4
leaq 0x48(%rsp), %rdi
callq 0x4a3b
jmp 0xb9f4
movq 0xc5e7(%rip), %rcx      # 0x17fc8
movq (%rcx), %rdi
leaq 0x6ce2(%rip), %rsi      # 0x126cd
movl %eax, %edx
xorl %eax, %eax
callq 0x4530
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0xba1e
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xba3a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xba56
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 0xbc61
xorl %edi, %edi
callq 0x44b0
leaq 0x7816(%rip), %rdi      # 0x13296
xorl %edx, %edx
xorl %eax, %eax
callq 0x4590
jmp 0xbb33
jmp 0xbb33
jmp 0xbbf9
jmp 0xbb33
movq %rax, %rbx
movq 0x180(%rsp), %rdi
cmpq %r14, %rdi
jne 0xbacf
jmp 0xbbfc
jmp 0xbbf9
movq %rax, %rbx
leaq 0x190(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbbfc
movq 0x190(%rsp), %rsi
jmp 0xbbea
jmp 0xbbf9
jmp 0xbb33
jmp 0xbb33
jmp 0xbb33
jmp 0xbb33
jmp 0xbb05
jmp 0xbb05
jmp 0xbb05
jmp 0xbb05
jmp 0xbb05
jmp 0xbb33
jmp 0xbb33
jmp 0xbb33
jmp 0xbb26
jmp 0xbb33
jmp 0xbb26
jmp 0xbb05
jmp 0xbb33
jmp 0xbb26
movq %rax, %rbx
jmp 0xbb5e
jmp 0xbbf9
jmp 0xbbf9
movq %rax, %rbx
jmp 0xbc21
movq %rax, %rbx
jmp 0xbc3d
jmp 0xbb33
cmpq $0x0, 0x18(%rsp)
je 0xbb33
jmp 0xbbf4
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xc100
cmpq $0x0, 0x38(%rsp)
jne 0xbbf4
cmpq $0x0, 0x88(%rsp)
jne 0xbbf4
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0xbb83
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0xbba8
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0xbbcd
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x140(%rsp), %rdi
leaq 0x150(%rsp), %rax
cmpq %rax, %rdi
je 0xbbfc
movq 0x150(%rsp), %rsi
incq %rsi
callq 0x4400
jmp 0xbbfc
callq 0x40e0
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0xbc21
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xbc3d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4400
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xbc59
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4400
movq %rbx, %rdi
callq 0x46e0