LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WShabti-Team[P]WShabtiPict/wshabtilib/junit-test-case-generator/junit-test-case-generator.cpp
// Function: delta_check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool delta_check(string input_file_path, int num_of_parameters)
{
    ifstream test_with_oracle;
  	test_with_oracle.open(input_file_path, ios_base::in);
    string combination = "";

    while(!test_with_oracle.eof())
    {
        getline(test_with_oracle, combination);

        if((int) count(combination.begin(), combination.end(), ',') == (num_of_parameters + 1)) //If there's delta it is TRUE (+1 parameter)
        {
            test_with_oracle.close();
            return true;
        }
    }

    test_with_oracle.close();
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x278(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x76d0
movq -0x280(%rbp), %rdi
movq -0x278(%rbp), %rsi
movl $0x8, %edx
callq 0x7520
jmp 0x5d6c6
leaq -0x251(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x79e0
movq -0x288(%rbp), %rdx
leaq 0x854b(%rip), %rsi      # 0x65c32
leaq -0x250(%rbp), %rdi
callq 0xd700
jmp 0x5d6f5
leaq -0x251(%rbp), %rdi
callq 0x7660
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x7a30
movb %al, -0x289(%rbp)
jmp 0x5d721
movb -0x289(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d732
jmp 0x5d829
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x70e0
jmp 0x5d747
leaq -0x250(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x7540
movq -0x2a0(%rbp), %rdi
movq %rax, -0x260(%rbp)
callq 0x7360
movq %rax, -0x268(%rbp)
movb $0x2c, -0x269(%rbp)
movq -0x260(%rbp), %rdi
movq -0x268(%rbp), %rsi
leaq -0x269(%rbp), %rdx
callq 0x5e9b0
movq %rax, -0x298(%rbp)
jmp 0x5d79e
movq -0x298(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5d824
leaq -0x220(%rbp), %rdi
callq 0x7110
jmp 0x5d7bd
movb $0x1, -0x1(%rbp)
movl $0x1, -0x270(%rbp)
jmp 0x5d845
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x5d86b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x251(%rbp), %rdi
callq 0x7660
jmp 0x5d86b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x73e0
jmp 0x5d86b
jmp 0x5d701
leaq -0x220(%rbp), %rdi
callq 0x7110
jmp 0x5d837
movb $0x0, -0x1(%rbp)
movl $0x1, -0x270(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x73e0
leaq -0x220(%rbp), %rdi
callq 0x7140
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x7140
movq -0x228(%rbp), %rdi
callq 0x79d0
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/oracle-generator/oracle-generator.cpp
// Function: check_interval(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
bool check_interval(vector<string> oracle)
{
	for(string oracle_value : oracle)
	{
		if(oracle_value.find(':') != string::npos) //':' FOUND
      	{
			return true;
      	}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33300
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33180
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34570
testb $0x1, %al
jne 0x5ef0d
jmp 0x5ef6f
leaq -0x20(%rbp), %rdi
callq 0x339f0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x7270
leaq -0x48(%rbp), %rdi
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7790
cmpq $-0x1, %rax
je 0x5ef47
movb $0x1, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x5ef4e
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x73e0
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x5ef62
jmp 0x5ef60
jmp 0x5ef73
jmp 0x5ef64
leaq -0x20(%rbp), %rdi
callq 0x345d0
jmp 0x5eefa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: connect_and_login_ftp(ftplib*, ftpInfo*, int)
static int connect_and_login_ftp (ftplib* ftpClient, ftpInfo* pFtp, int retryTime) 
{
    int retry = 0;
    static int seeded = 0;
    if (!seeded) {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        srand((unsigned)tv.tv_usec);
        seeded = 1;
    }

    while (true) {
        if (ftpClient->Connect(pFtp->ftpServer)) {
            break;
        }
        
        if (retryTime > 0) {
            retry++;
            if (retry >= retryTime) {
                return -1;
            }
        } else {
            unsigned int sleepTime = rand();
            sleepTime = sleepTime % 31 + 2;
            sleep(sleepTime);
        }
    }
    if (!ftpClient->Login(pFtp->user, pFtp->pass)) {
        return -2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, 0x20847(%rip)     # 0x26638
jne 0x5e15
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4760
movq -0x28(%rbp), %rax
movl %eax, %edi
callq 0x4470
movl $0x1, 0x20823(%rip)     # 0x26638
jmp 0x5e17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x16ed0
cmpl $0x0, %eax
je 0x5e2e
jmp 0x5e74
cmpl $0x0, -0x1c(%rbp)
jle 0x5e50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x5e4e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5ea2
jmp 0x5e72
callq 0x4100
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1f, %ecx
xorl %edx, %edx
divl %ecx
addl $0x2, %edx
movl %edx, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x4330
jmp 0x5e17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x17390
cmpl $0x0, %eax
jne 0x5e9b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x5ea2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: get_task_from_queue(task<fileInfo>&)
static int get_task_from_queue (task<fileInfo>& curTask)
{
    std::unique_lock<std::mutex> lock(tasksMutex);
    while ((tasksQueue.empty()) && (!exitFlag)) {
        tasksExecuteCV.wait(lock);
    }
    if (!tasksQueue.empty()) {
        curTask = tasksQueue.front();
        tasksQueue.pop();
        tasksProductCV.notify_one();
    } else {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x20681(%rip), %rsi     # 0x26548
callq 0xe8f0
leaq 0x20625(%rip), %rdi     # 0x264f8
callq 0xd3f0
movb %al, -0x31(%rbp)
jmp 0x5edd
movb -0x31(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x32(%rbp)
jne 0x5eec
jmp 0x5f03
leaq 0x206f5(%rip), %rdi     # 0x265e8
callq 0xd230
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x5f0c
jmp 0x5f38
leaq 0x2068d(%rip), %rdi     # 0x265a0
leaq -0x20(%rbp), %rsi
callq 0x4130
jmp 0x5ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe9b0
jmp 0x5fbf
leaq 0x205b9(%rip), %rdi     # 0x264f8
callq 0xd3f0
movb %al, -0x33(%rbp)
jmp 0x5f49
movb -0x33(%rbp), %al
testb $0x1, %al
jne 0x5f8f
jmp 0x5f52
leaq 0x2059f(%rip), %rdi     # 0x264f8
callq 0xe930
movq %rax, -0x40(%rbp)
jmp 0x5f64
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xe950
jmp 0x5f73
leaq 0x2057e(%rip), %rdi     # 0x264f8
callq 0xe990
jmp 0x5f81
leaq 0x205e8(%rip), %rdi     # 0x26570
callq 0x4210
jmp 0x5f9f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x30(%rbp)
jmp 0x5fad
movl $0x0, -0x4(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe9b0
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4810
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: build_ftp_data_connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ftplib::accesstype, ftplib::transfermode, ftplib*, ftpInfo*, ftphandle**)
static int build_ftp_data_connection (string accessPath, ftplib::accesstype type, 
                                            ftplib::transfermode mode, ftplib* ftpClient,
                                            ftpInfo* pFtp, ftphandle** nData) 
{
    int retry = 0;
    while (retry < 5) {
        retry++;
        if (!ftpClient->FtpAccess(accessPath.c_str(), type, mode, ftpClient->mp_ftphandle, nData)) {
            if (ftpClient->mp_ftphandle->handle > 0) 
                net_close(ftpClient->mp_ftphandle->handle);
            int ret = connect_and_login_ftp (ftpClient, pFtp, 0);
            if (ret == -2) {  // login failed
                return ret;
            }
        } else {
            return 0;   // get ftp data connection succeed
        }
    }
    return -1;  // retry 5 times but failed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x608b
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x41b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %r8
movq -0x30(%rbp), %r9
callq 0x177f0
cmpl $0x0, %eax
jne 0x607d
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x605b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x48b0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5dd0
movl %eax, -0x38(%rbp)
cmpl $-0x2, -0x38(%rbp)
jne 0x607b
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6092
jmp 0x6086
movl $0x0, -0x4(%rbp)
jmp 0x6092
jmp 0x5ff9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: local2ftp_dispatcher(ftpInfo*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void local2ftp_dispatcher(ftpInfo * pFtp, string localPath, string ftpPath) 
{
    // normalize directory path format
    normalize_dir_format(localPath, ftpPath);

    // connect to ftp server and login
    ftplib * ftpClient = new ftplib();
    int ret = connect_and_login_ftp (ftpClient, pFtp, 0);
    if (ret < 0) {
        if (ret == -2)
            fprintf(stderr, "login ftp server %s failed.\n", pFtp->ftpServer);
        goto error_out;
    }
    
    // add task to queue
    local2ftp_dispatcher_core(ftpClient, localPath, ftpPath);

error_out:
    ftpClient->Quit();
    exitFlag = 1;
    tasksExecuteCV.notify_all();    
    delete ftpClient;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, %rax
movq -0x98(%rbp), %rsi
movq %rax, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rsi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x15d20
movl $0x8, %edi
callq 0x44b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x16370
jmp 0x6104
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x5dd0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x616c
cmpl $-0x2, -0x30(%rbp)
jne 0x616a
movq 0x1fe97(%rip), %rax     # 0x25fc8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x16cf1(%rip), %rsi     # 0x1ce33
movb $0x0, %al
callq 0x4680
jmp 0x616a
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x44c0
jmp 0x6247
jmp 0x61be
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41c0
movq -0x80(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x41c0
jmp 0x6196
movq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x6250
jmp 0x61ac
leaq -0x70(%rbp), %rdi
callq 0x4280
leaq -0x50(%rbp), %rdi
callq 0x4280
movq -0x20(%rbp), %rdi
callq 0x197d0
leaq 0x2041a(%rip), %rdi     # 0x265e8
movl $0x1, %esi
callq 0xd690
leaq 0x203c1(%rip), %rdi     # 0x265a0
callq 0x47c0
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x6212
movq -0xa8(%rbp), %rdi
callq 0x164c0
movq -0xa8(%rbp), %rdi
movl $0x8, %esi
callq 0x44c0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x623e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4280
leaq -0x50(%rbp), %rdi
callq 0x4280
movq -0x28(%rbp), %rdi
callq 0x4810
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: ftp2local_dispatcher(ftpInfo*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ftp2local_dispatcher(ftpInfo * pFtp, string ftpPath, string localPath) 
{
    // normalize directory path format
    normalize_dir_format(localPath, ftpPath);

    // connect to ftp server and login
    ftplib * ftpClient = new ftplib();
    int ret = connect_and_login_ftp (ftpClient, pFtp, 0);
    if (ret < 0) {
        if (ret == -2)
            fprintf(stderr, "login ftp server %s failed.\n", pFtp->ftpServer);
        goto error_out;
    }

    ftp2local_dispatcher_core(pFtp, ftpClient, ftpPath, localPath);

error_out:
    exitFlag = 1;
    tasksExecuteCV.notify_all();
    ftpClient->Quit();
    delete ftpClient;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rsi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x15d20
movl $0x8, %edi
callq 0x44b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x16370
jmp 0x7a43
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x5dd0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x7aab
cmpl $-0x2, -0x30(%rbp)
jne 0x7aa9
movq 0x1e558(%rip), %rax     # 0x25fc8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x153b2(%rip), %rsi     # 0x1ce33
movb $0x0, %al
callq 0x4680
jmp 0x7aa9
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x44c0
jmp 0x7b98
jmp 0x7b0f
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41c0
movq -0x80(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x41c0
jmp 0x7ae0
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x7bb0
jmp 0x7afd
leaq -0x70(%rbp), %rdi
callq 0x4280
leaq -0x50(%rbp), %rdi
callq 0x4280
leaq 0x1ead2(%rip), %rdi     # 0x265e8
movl $0x1, %esi
callq 0xd690
leaq 0x1ea79(%rip), %rdi     # 0x265a0
callq 0x47c0
movq -0x20(%rbp), %rdi
callq 0x197d0
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x7b63
movq -0xa8(%rbp), %rdi
callq 0x164c0
movq -0xa8(%rbp), %rdi
movl $0x8, %esi
callq 0x44c0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7b8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4280
leaq -0x50(%rbp), %rdi
callq 0x4280
movq -0x28(%rbp), %rdi
callq 0x4810
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: usage(char*)
static void usage(char * cmd)
{
    printf("ftp benchmark tool.\n");
    printf("Usage: %s -n <ftp server> -u <user name> -p <password> -s <source path>  -d <destination path> -i\n", cmd);
    printf("options:\n");	
    printf("    -t     # the number of threads\n");
    printf("    -i     # verbose, show ftp messages\n");
    printf("    -v     # verify data correctness\n");
    printf("    -h     # show usage\n");
    printf("Example:\n");
    printf("    %s -n 10.1.1.1:21 -u user -p pass -s local:/home -d ftp:/dir -t 8                 # upload local directory to ftp server\n", cmd);
    printf("    %s -n 10.1.1.1 -u user -p pass -s null -d ftp:/dir -w 3 -l 3 -f 10 -S 64K:1M -t 8 # upload random files to  ftp directory\n", cmd);
    printf("    %s -n 10.1.1.1 -u user -p pass -s ftp:/dir -d local:/home -t 8                    # download files from ftp server to local directory\n", cmd);
    printf("    %s -n ftp.boss.xiaoyun -u user -p pass -s ftp:/dir  -d null -t 16                 # download files from ftp server to /dev/null\n\n", cmd);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x100b2(%rip), %rdi     # 0x1d045
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rsi
leaq 0x100b5(%rip), %rdi     # 0x1d05a
movb $0x0, %al
callq 0x4070
leaq 0x1010a(%rip), %rdi     # 0x1d0bd
movb $0x0, %al
callq 0x4070
leaq 0x10106(%rip), %rdi     # 0x1d0c7
movb $0x0, %al
callq 0x4070
leaq 0x1011c(%rip), %rdi     # 0x1d0eb
movb $0x0, %al
callq 0x4070
leaq 0x10137(%rip), %rdi     # 0x1d114
movb $0x0, %al
callq 0x4070
leaq 0x1014f(%rip), %rdi     # 0x1d13a
movb $0x0, %al
callq 0x4070
leaq 0x1015a(%rip), %rdi     # 0x1d153
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rsi
leaq 0x10152(%rip), %rdi     # 0x1d15d
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rsi
leaq 0x101be(%rip), %rdi     # 0x1d1db
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rsi
leaq 0x1022b(%rip), %rdi     # 0x1d25a
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rsi
leaq 0x102a4(%rip), %rdi     # 0x1d2e5
movb $0x0, %al
callq 0x4070
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: put_task_to_queue(task<fileInfo>&)
static int put_task_to_queue (task<fileInfo>& curTask) 
{
    std::unique_lock<std::mutex> lock(tasksMutex);
    while ((tasksQueue.size() >= maxQueueSize) && (liveWorkThread > 0)) {
        tasksProductCV.wait(lock);
    }
    if (liveWorkThread > 0) {
        tasksQueue.push(curTask);
        tasksExecuteCV.notify_one();
    } else {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x19451(%rip), %rsi     # 0x26548
callq 0xe8f0
leaq 0x193f5(%rip), %rdi     # 0x264f8
callq 0x103a0
movq %rax, -0x38(%rbp)
jmp 0xd10e
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq $0x4000, %rcx           # imm = 0x4000
movb %al, -0x39(%rbp)
jb 0xd135
leaq 0x194c9(%rip), %rdi     # 0x265f0
callq 0xd230
cmpl $0x0, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xd13e
jmp 0xd167
leaq 0x1942b(%rip), %rdi     # 0x26570
leaq -0x20(%rbp), %rsi
callq 0x4130
jmp 0xd0fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe9b0
jmp 0xd1c8
leaq 0x19482(%rip), %rdi     # 0x265f0
callq 0xd230
cmpl $0x0, %eax
jle 0xd198
movq -0x10(%rbp), %rsi
leaq 0x19375(%rip), %rdi     # 0x264f8
callq 0x103c0
jmp 0xd18a
leaq 0x1940f(%rip), %rdi     # 0x265a0
callq 0x4210
jmp 0xd1a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x30(%rbp)
jmp 0xd1b6
movl $0x0, -0x4(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe9b0
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4810
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: is_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int is_dir(string path) 
{
    struct stat st;
    stat(path.c_str(), &st);
    if (S_ISDIR(st.st_mode)) {
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
callq 0x41b0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x43f0
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x15a6e
movl $0x1, -0x4(%rbp)
jmp 0x15a75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: size_to_string(unsigned long, char*)
void size_to_string(uint64_t size, char * buf)
{   
    uint64_t  multiplier = exbibytes;
    int i;

    for (i = 0; i < DIM(sizes); i++, multiplier /= 1024) {   
        if (size < multiplier)
            continue;
        if (size % multiplier == 0)
            sprintf(buf, "%llu %s", (unsigned long long)size / multiplier, sizes[i]);
        else
            sprintf(buf, "%.1f %s", (float) size / multiplier, sizes[i]);
        return ;
    }
    strcpy(buf, "0");
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $0x1000000000000000, %rax # imm = 0x1000000000000000
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x7, %rax
jae 0x15bec
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x15ad2
jmp 0x15bd2
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq $0x0, %rdx
jne 0x15b19
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x109ae(%rip), %rax     # 0x264b0
movq (%rax,%rcx,8), %rcx
leaq 0x7bcf(%rip), %rsi      # 0x1d6dc
movb $0x0, %al
callq 0x40d0
jmp 0x15bd0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x24(%rbp)
testq %rax, %rax
movss %xmm0, -0x20(%rbp)
js 0x15b5a
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x38(%rbp)
testq %rax, %rax
movss %xmm0, -0x34(%rbp)
js 0x15b9d
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movss -0x3c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movslq -0x1c(%rbp), %rcx
leaq 0x108f2(%rip), %rax     # 0x264b0
movq (%rax,%rcx,8), %rdx
leaq 0x7b1b(%rip), %rsi      # 0x1d6e4
movb $0x1, %al
callq 0x40d0
jmp 0x15bfc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
movq %rax, -0x18(%rbp)
jmp 0x15ab5
movq -0x10(%rbp), %rdi
leaq 0x7af5(%rip), %rsi      # 0x1d6ec
callq 0x4430
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: string_to_size(char const*)
int64_t string_to_size(const char * str)
{
    char c;
    int64_t num;
    int64_t ret;
    int64_t mult;
    char buf[32];

    strcpy(buf, str);
    
    c = buf[strlen(buf) - 1];
    if (c > '9') {
        buf[strlen(buf) - 1] = '\0';
    }
    double f = atof(buf);
    num = atoll(buf);

    if(isdigit(c))
        return num;
    
    switch(c) {
    case 't':
    case 'T':
        mult = 0x1ULL << 40; //1024 * 1024 * 1024*1024;
	break;
    case 'g':
    case 'G':
        mult = 0x1ULL << 30; //1024 * 1024 * 1024;
	break;
    case 'm':
    case 'M':
        mult = 0x1ULL << 20;//1024 * 1024;
	break;
    case 'k':
    case 'K':
        mult = 0x1ULL << 10;//1024;
	break;
    case 'b':
    case 'B':
        mult = 1;
	break;
    default:
        return -1;
    }

    ret = mult * f;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4430
leaq -0x50(%rbp), %rdi
callq 0x41d0
subq $0x1, %rax
movb -0x50(%rbp,%rax), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x39, %eax
jle 0x15c58
leaq -0x50(%rbp), %rdi
callq 0x41d0
subq $0x1, %rax
movb $0x0, -0x50(%rbp,%rax)
leaq -0x50(%rbp), %rdi
callq 0x45e0
movsd %xmm0, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4360
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x43e0
cmpl $0x0, %eax
je 0x15c8e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15d12
movsbl -0x11(%rbp), %eax
addl $-0x42, %eax
movl %eax, %ecx
movq %rcx, -0x60(%rbp)
subl $0x32, %eax
ja 0x15cec
movq -0x60(%rbp), %rax
leaq 0x7965(%rip), %rcx      # 0x1d610
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x10000000000, %rax    # imm = 0x10000000000
movq %rax, -0x30(%rbp)
jmp 0x15cf6
movq $0x40000000, -0x30(%rbp) # imm = 0x40000000
jmp 0x15cf6
movq $0x100000, -0x30(%rbp)  # imm = 0x100000
jmp 0x15cf6
movq $0x400, -0x30(%rbp)     # imm = 0x400
jmp 0x15cf6
movq $0x1, -0x30(%rbp)
jmp 0x15cf6
movq $-0x1, -0x8(%rbp)
jmp 0x15d12
cvtsi2sdq -0x30(%rbp), %xmm0
mulsd -0x58(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: normalize_dir_format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void normalize_dir_format(string& localPath, string& ftpPath) 
{
    if (localPath.length() > 0 && localPath.at(localPath.size() - 1) != '/') {
        localPath.push_back('/');
    }

    if (ftpPath.length() > 0) {
        if (ftpPath.at(0) != '/') {
            ftpPath = "/" + ftpPath;
        }
        if (ftpPath.at(ftpPath.size() - 1) != '/') {
            ftpPath.push_back('/');
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x46d0
cmpq $0x0, %rax
jbe 0x15d76
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x4880
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x15d76
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x43c0
movq -0x10(%rbp), %rdi
callq 0x46d0
cmpq $0x0, %rax
jbe 0x15dfd
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4880
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x15dc4
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x70d4(%rip), %rsi      # 0x1ce7d
callq 0x16100
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x45c0
leaq -0x30(%rbp), %rdi
callq 0x4280
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x4880
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x15dfb
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x43c0
jmp 0x15dfd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: resolve_list_entry(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void resolve_list_entry (const char * dataBuf, string& name, string& sizeStr) 
{
    if (dataBuf == NULL) return;
    int i = strlen(dataBuf) - 2;
    while (dataBuf[i] != ' ') {
        name = dataBuf[i] + name;
        --i;
    }
    int spaceNum = 0;
    while (spaceNum < 4) {
        if (dataBuf[i] == ' ')
            spaceNum++;
        --i;
    }
    while (dataBuf[i] != ' ') {
        sizeStr = dataBuf[i] + sizeStr;
        --i;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x15e30
jmp 0x15f0e
movq -0x8(%rbp), %rdi
callq 0x41d0
subq $0x2, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x15e8d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movsbl %al, %esi
callq 0x16210
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x45c0
leaq -0x40(%rbp), %rdi
callq 0x4280
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15e40
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x15ebf
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x15eb4
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15e94
jmp 0x15ec1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x15f0e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movsbl %al, %esi
callq 0x16210
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x45c0
leaq -0x68(%rbp), %rdi
callq 0x4280
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ec1
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: resolve_base_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string resolve_base_name (const string& srcPath) 
{
    int lastSlashLoc = 0;
    int slashLoc = 0;
    string baseName("");
    while ((slashLoc = srcPath.find('/', lastSlashLoc)) != std::string::npos) {
        if (slashLoc == srcPath.size() - 1) {
            baseName = srcPath.substr(lastSlashLoc, srcPath.size() - lastSlashLoc);
            break;
        }
        lastSlashLoc = slashLoc + 1;
    }
    
    if (baseName.empty()) {
        baseName = srcPath.substr(lastSlashLoc, srcPath.size() - lastSlashLoc);
    }
    return baseName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4820
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x69dd(%rip), %rsi      # 0x1c94c
callq 0xd720
jmp 0x15f76
leaq -0x1a(%rbp), %rdi
callq 0x4510
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movl $0x2f, %esi
callq 0x4610
movl %eax, -0x18(%rbp)
cltq
cmpq $-0x1, %rax
je 0x16063
movslq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42e0
movq %rax, %rcx
movq -0x90(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x16055
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x42e0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
movslq -0x14(%rbp), %rax
subq %rax, %rcx
leaq -0x50(%rbp), %rdi
callq 0x44d0
jmp 0x16009
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x45c0
leaq -0x50(%rbp), %rdi
callq 0x4280
jmp 0x16063
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4510
jmp 0x160e9
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4280
jmp 0x160e9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15f7f
movq -0x80(%rbp), %rdi
callq 0x47a0
testb $0x1, %al
jne 0x16072
jmp 0x160c6
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x42e0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
movslq -0x14(%rbp), %rax
subq %rax, %rcx
leaq -0x70(%rbp), %rdi
callq 0x44d0
jmp 0x160b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x45c0
leaq -0x70(%rbp), %rdi
callq 0x4280
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x160d9
movq -0x80(%rbp), %rdi
callq 0x4280
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4810
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::ftplib()
ftplib::ftplib()
{
    #if defined(_WIN32)
    WSADATA wsa;
    if (WSAStartup(MAKEWORD(1, 1), &wsa))
    {
         printf("WSAStartup() failed, %lu\n", (unsigned long)GetLastError());
    }
    #endif
                
	#ifndef NOSSL
	SSL_library_init();
	#endif	

	mp_ftphandle = static_cast<ftphandle *>(calloc(1,sizeof(ftphandle)));
	if (mp_ftphandle == NULL) perror("calloc");
	mp_ftphandle->buf = static_cast<char *>(malloc(FTPLIB_BUFSIZ));
	if (mp_ftphandle->buf == NULL)
	{
		perror("calloc");
		free(mp_ftphandle);
	}
	#ifndef NOSSL
	mp_ftphandle->ctx = SSL_CTX_new(_FTPLIB_SSL_CLIENT_METHOD_());
	SSL_CTX_set_verify(mp_ftphandle->ctx, SSL_VERIFY_NONE, NULL);
	mp_ftphandle->ssl = SSL_new(mp_ftphandle->ctx);
	#endif
	ClearHandle();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x42b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x163af
leaq 0x736e(%rip), %rdi      # 0x1d718
callq 0x43a0
movl $0x400, %edi            # imm = 0x400
callq 0x4620
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rdx, 0x20(%rcx)
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x163e9
leaq 0x7340(%rip), %rdi      # 0x1d718
callq 0x43a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rdi
callq 0x16400
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::ClearHandle()
void ftplib::ClearHandle()
{
	mp_ftphandle->dir = FTPLIB_CONTROL;
	mp_ftphandle->ctrl = NULL;
	mp_ftphandle->cmode = ftplib::pasv;
    //mp_ftphandle->cmode = ftplib::port;
	mp_ftphandle->idlecb = NULL;
	mp_ftphandle->idletime.tv_sec = 60;
    mp_ftphandle->idletime.tv_usec = 0;
	mp_ftphandle->cbarg = NULL;
	mp_ftphandle->xfered = 0;
	mp_ftphandle->xfered1 = 0;
	mp_ftphandle->cbbytes = 0;
#ifndef NOSSL	
	mp_ftphandle->tlsctrl = 0;
	mp_ftphandle->tlsdata = 0;
	mp_ftphandle->certcb = NULL;
#endif
	mp_ftphandle->offset = 0;
	mp_ftphandle->handle = 0;
	mp_ftphandle->logcb = NULL;
	mp_ftphandle->xfercb = NULL;
	mp_ftphandle->correctpasv = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl $0x0, 0x28(%rcx)
movq (%rax), %rcx
movq $0x0, 0x30(%rcx)
movq (%rax), %rcx
movl $0x1, 0x38(%rcx)
movq (%rax), %rcx
movq $0x0, 0x58(%rcx)
movq (%rax), %rcx
movq $0x3c, 0x40(%rcx)
movq (%rax), %rcx
movq $0x0, 0x48(%rcx)
movq (%rax), %rcx
movq $0x0, 0x68(%rcx)
movq (%rax), %rcx
movq $0x0, 0x70(%rcx)
movq (%rax), %rcx
movq $0x0, 0x80(%rcx)
movq (%rax), %rcx
movq $0x0, 0x78(%rcx)
movq (%rax), %rcx
movq $0x0, 0x1b0(%rcx)
movq (%rax), %rcx
movl $0x0, 0x10(%rcx)
movq (%rax), %rcx
movq $0x0, 0x60(%rcx)
movq (%rax), %rcx
movq $0x0, 0x50(%rcx)
movq (%rax), %rax
movb $0x0, 0x1b8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::socket_wait(ftphandle*)
int ftplib::socket_wait(ftphandle *ctl)
{
	fd_set fd,*rfd = NULL,*wfd = NULL;
	struct timeval tv;
	int rv = 0;

	if (ctl->idlecb == NULL) return 1;

	/*if ((ctl->dir == FTPLIB_CONTROL)
		|| (ctl->idlecb == NULL)
		|| ((ctl->idletime.tv_sec == 0)
		&& //(ctl->idletime.tv_usec 0))
	return 1;*/

	if (ctl->dir == FTPLIB_WRITE) wfd = &fd;
	else rfd = &fd;

	FD_ZERO(&fd);
	do
	{
		FD_SET(ctl->handle,&fd);
		tv = ctl->idletime;
		rv = select(ctl->handle+1, rfd, wfd, NULL, &tv);
		if (rv == -1)
		{
			rv = 0;
			strncpy(ctl->ctrl->response, strerror(errno), sizeof(ctl->ctrl->response));
			break;
		}
		else if (rv > 0)
		{
			rv = 1;
			break;
		}
	} while ((rv = ctl->idlecb(ctl->cbarg)));

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movl $0x0, -0xbc(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1657a
movl $0x1, -0x4(%rbp)
jmp 0x16706
movq -0x18(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x16594
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x165a2
leaq -0x98(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x165a4
leaq -0x98(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
cmpq $0x10, %rax
jae 0x165ee
movq -0xc8(%rbp), %rax
movl -0xc0(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc0(%rbp)
jmp 0x165bc
jmp 0x165f0
jmp 0x165f2
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x98(%rbp,%rax,8), %rcx
movq %rcx, -0x98(%rbp,%rax,8)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0xb8(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
addl $0x1, %edi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb8(%rbp), %r8
callq 0x4450
movl %eax, -0xbc(%rbp)
cmpl $-0x1, -0xbc(%rbp)
jne 0x166c3
movl $0x0, -0xbc(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x88, %rax
movq %rax, -0xd0(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x4150
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4230
jmp 0x166fd
cmpl $0x0, -0xbc(%rbp)
jle 0x166d8
movl $0x1, -0xbc(%rbp)
jmp 0x166fd
jmp 0x166da
jmp 0x166dc
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x68(%rcx), %rdi
callq *%rax
movl %eax, -0xbc(%rbp)
cmpl $0x0, %eax
jne 0x165f2
movl -0xbc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::readresp(char, ftphandle*)
int ftplib::readresp(char c, ftphandle *nControl)
{
	char match[5];
	
	if (readline(nControl->response,256,nControl) == -1)
	{
	    std::cerr << "Control socket "<< nControl->handle << " read failed: " << nControl->response << std::endl;
		return 0;
	}
	
	if (nControl->response[3] == '-')
	{
		strncpy(match,nControl->response,3);
		match[3] = ' ';
		match[4] = '\0';
		do
		{
			if (readline(nControl->response,256,nControl) == -1)
			{
                std::cerr << "Control socket "<< nControl->handle << " read failed: " 
                          << nControl->response << ", " << match << std::endl;
				return 0;
			}
		} while (strncmp(nControl->response,match,4));
	}

    if (nControl->response[0] == c) 
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
movq -0x20(%rbp), %rcx
movl $0x100, %edx            # imm = 0x100
callq 0x16720
cmpl $-0x1, %eax
jne 0x16d5b
movq 0xf2ed(%rip), %rdi      # 0x25ff0
leaq 0x6aae(%rip), %rsi      # 0x1d7b8
callq 0x4490
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x47f0
movq %rax, %rdi
leaq 0x6aa0(%rip), %rsi      # 0x1d7c8
callq 0x4490
movq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
callq 0x4490
movq %rax, %rdi
movq 0xf24e(%rip), %rsi      # 0x25f98
callq 0x44e0
movl $0x0, -0x4(%rbp)
jmp 0x16e72
movq -0x20(%rbp), %rax
movsbl 0x8b(%rax), %eax
cmpl $0x2d, %eax
jne 0x16e4f
leaq -0x25(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
movl $0x3, %edx
callq 0x4230
movb $0x20, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
movq -0x20(%rbp), %rcx
movl $0x100, %edx            # imm = 0x100
callq 0x16720
cmpl $-0x1, %eax
jne 0x16e29
movq 0xf237(%rip), %rdi      # 0x25ff0
leaq 0x69f8(%rip), %rsi      # 0x1d7b8
callq 0x4490
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x47f0
movq %rax, %rdi
leaq 0x69ea(%rip), %rsi      # 0x1d7c8
callq 0x4490
movq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
callq 0x4490
movq %rax, %rdi
leaq 0x69d7(%rip), %rsi      # 0x1d7d7
callq 0x4490
movq %rax, %rdi
leaq -0x25(%rbp), %rsi
callq 0x4490
movq %rax, %rdi
movq 0xf17d(%rip), %rsi      # 0x25f98
callq 0x44e0
movl $0x0, -0x4(%rbp)
jmp 0x16e72
jmp 0x16e2b
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
leaq -0x25(%rbp), %rsi
movl $0x4, %edx
callq 0x4200
cmpl $0x0, %eax
jne 0x16d90
jmp 0x16e4f
movq -0x20(%rbp), %rax
movsbl 0x88(%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x16e6b
movl $0x1, -0x4(%rbp)
jmp 0x16e72
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Login(char const*, char const*)
int ftplib::Login(const char *user, const char *pass)
{
	char tempbuf[64];

	if (((strlen(user) + 7) > sizeof(tempbuf)) || ((strlen(pass) + 7) > sizeof(tempbuf))) 
        return 0;
    
	sprintf(tempbuf, "USER %s", user);

    if (!FtpSendCmd(tempbuf,'3',mp_ftphandle)) 	{
		if (mp_ftphandle->ctrl != NULL) 
            return 1;
		if (*LastResponse() == '2') 
            return 1;
		return 0;
	}
	sprintf(tempbuf,"PASS %s",pass);
	return FtpSendCmd(tempbuf,'2',mp_ftphandle);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x40, %rax
ja 0x173d2
movq -0x20(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x40, %rax
jbe 0x173de
movl $0x0, -0x4(%rbp)
jmp 0x17476
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x647d(%rip), %rsi      # 0x1d86a
movb $0x0, %al
callq 0x40d0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq (%rdi), %rcx
movl $0x33, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x17448
movq -0x68(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x17425
movl $0x1, -0x4(%rbp)
jmp 0x17476
movq -0x68(%rbp), %rdi
callq 0x16e80
movsbl (%rax), %eax
cmpl $0x32, %eax
jne 0x1743f
movl $0x1, -0x4(%rbp)
jmp 0x17476
movl $0x0, -0x4(%rbp)
jmp 0x17476
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x641b(%rip), %rsi      # 0x1d872
movb $0x0, %al
callq 0x40d0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::FtpClose(ftphandle*)
int ftplib::FtpClose(ftphandle *nData)
{
	ftphandle *ctrl;

	if (nData->dir == FTPLIB_WRITE)
	{
		if (nData->buf != NULL) 
            writeline(NULL, 0, nData);
	}
	else if (nData->dir != FTPLIB_READ) 
        return 0;
	if (nData->buf) 
        free(nData->buf);
	shutdown(nData->handle,2);
	net_close(nData->handle);

	ctrl = nData->ctrl;
#ifndef NOSSL
	SSL_free(nData->ssl);
#endif
	free(nData);
	if (ctrl) 
        return readresp('2', ctrl);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x186d2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x186d0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x16a50
jmp 0x186e7
movq -0x18(%rbp), %rax
cmpl $0x1, 0x28(%rax)
je 0x186e5
movl $0x0, -0x4(%rbp)
jmp 0x18756
jmp 0x186e7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x186ff
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45a0
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
movl $0x2, %esi
callq 0x4640
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x48b0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45a0
cmpq $0x0, -0x20(%rbp)
je 0x1874f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x32, %esi
callq 0x16cc0
movl %eax, -0x4(%rbp)
jmp 0x18756
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::CorrectPasvResponse(unsigned char*)
int ftplib::CorrectPasvResponse(unsigned char *v)
{
	struct sockaddr ipholder;
	socklen_t ipholder_size = sizeof(ipholder);

	if (getpeername(mp_ftphandle->handle, &ipholder, &ipholder_size) == -1)
	{
		perror("getpeername");
		net_close(mp_ftphandle->handle);
		return 0;
	}
	
	for (int i = 2; i < 6; i++) v[i] = ipholder.sa_data[i];
	
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, -0x2c(%rbp)
movq (%rax), %rax
movl 0x10(%rax), %edi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x4300
cmpl $-0x1, %eax
jne 0x187bb
leaq 0x5330(%rip), %rdi      # 0x1dace
callq 0x43a0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x48b0
movl $0x0, -0x4(%rbp)
jmp 0x187ed
movl $0x2, -0x30(%rbp)
cmpl $0x6, -0x30(%rbp)
jge 0x187e6
movslq -0x30(%rbp), %rax
movb -0x26(%rbp,%rax), %dl
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x187c2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::FtpRead(void*, int, ftphandle*)
int ftplib::FtpRead(void *buf, int max, ftphandle *nData)
{
	int i;

	if (nData->dir != FTPLIB_READ)
	    return 0;
	if (nData->buf) 
        i = readline(static_cast<char*>(buf), max, nData);
	else
	{
		i = socket_wait(nData);
		if (i != 1) 
            return 0;
#ifndef NOSSL
		if (nData->tlsdata) 
            i = SSL_read(nData->ssl, buf, max);
		else 
            i = net_read(nData->handle,buf,max);
#else
		i = net_read(nData->handle,buf,max);
#endif
	}
	if (i == -1) 
        return 0;
	nData->xfered += i;
	if (nData->xfercb && nData->cbbytes)
	{
		nData->xfered1 += i;
		if (nData->xfered1 > nData->cbbytes)
		{
			if (nData->xfercb(nData->xfered, nData->cbarg) == 0) 
                return 0;
			nData->xfered1 = 0;
		}
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x28(%rax)
je 0x18835
movl $0x0, -0x4(%rbp)
jmp 0x18934
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x18859
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x16720
movl %eax, -0x2c(%rbp)
jmp 0x18892
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16530
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
je 0x1887b
movl $0x0, -0x4(%rbp)
jmp 0x18934
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4690
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x188a4
movl $0x0, -0x4(%rbp)
jmp 0x18934
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1892e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1892e
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jle 0x1892c
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x70(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x68(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x1891d
movl $0x0, -0x4(%rbp)
jmp 0x18934
movq -0x28(%rbp), %rax
movq $0x0, 0x80(%rax)
jmp 0x1892e
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)