LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: simonrharris[P]SKA/src/ska.cpp
// Function: weedHelp()
int weedHelp(void){
	std::cout << std::endl << "Usage:" << std::endl;
	std::cout << "ska weed [options] <split kmer files>" << std::endl << std::endl;
	std::cout << "Options:" << std::endl;
	std::cout << "-f <file>\tFile of split kmer file names. These will be added to or \n\t\tused as an alternative input to the list provided on the \n\t\tcommand line." << std::endl;
	std::cout << "-h\t\tPrint this help." << std::endl;
	std::cout << "-i <file>\tName of kmer file containing kmers to be weeded. [Required]" << std::endl;
	std::cout << "-m <int>\tMinimum number of samples required to possess a split\n\t\tkmer for that kmer to be retained. [Default = 0]" << std::endl;
	std::cout << "-M <int>\tMaximum number of samples required to possess a split\n\t\tkmer for that kmer to be retained. 0 = No maximum. [Default = 0]" << std::endl;
	std::cout << "-p <float>\tMinimum proportion of samples required to possess a split\n\t\tkmer for that kmer to be retained. [Default = 0.0]" << std::endl;
	std::cout << "-P <float>\tMaximum proportion of samples required to possess a split\n\t\tkmer for that kmer to be retained. [Default = 1.0]" << std::endl;
	                        //123456789012345678901234567890123456789012345678901234567890
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x21dad(%rip), %rdi     # 0x78fa8
movq 0x21d8e(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
leaq 0x37ef(%rip), %rsi      # 0x5aa00
callq 0x6520
movq %rax, %rdi
movq 0x21d70(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21d7c(%rip), %rdi     # 0x78fa8
leaq 0x59cd(%rip), %rsi      # 0x5cc00
callq 0x6520
movq %rax, %rdi
movq 0x21d4e(%rip), %rsi     # 0x78f90
callq 0x6570
movq %rax, %rdi
movq 0x21d3f(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21d4b(%rip), %rdi     # 0x78fa8
leaq 0x3bf5(%rip), %rsi      # 0x5ae59
callq 0x6520
movq %rax, %rdi
movq 0x21d1d(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21d29(%rip), %rdi     # 0x78fa8
leaq 0x3e62(%rip), %rsi      # 0x5b0e8
callq 0x6520
movq %rax, %rdi
movq 0x21cfb(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21d07(%rip), %rdi     # 0x78fa8
leaq 0x3bba(%rip), %rsi      # 0x5ae62
callq 0x6520
movq %rax, %rdi
movq 0x21cd9(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21ce5(%rip), %rdi     # 0x78fa8
leaq 0x595c(%rip), %rsi      # 0x5cc26
callq 0x6520
movq %rax, %rdi
movq 0x21cb7(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21cc3(%rip), %rdi     # 0x78fa8
leaq 0x5980(%rip), %rsi      # 0x5cc6c
callq 0x6520
movq %rax, %rdi
movq 0x21c95(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21ca1(%rip), %rdi     # 0x78fa8
leaq 0x59d0(%rip), %rsi      # 0x5ccde
callq 0x6520
movq %rax, %rdi
movq 0x21c73(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21c7f(%rip), %rdi     # 0x78fa8
leaq 0x5a30(%rip), %rsi      # 0x5cd60
callq 0x6520
movq %rax, %rdi
movq 0x21c51(%rip), %rsi     # 0x78f90
callq 0x6570
movq 0x21c5d(%rip), %rdi     # 0x78fa8
leaq 0x5a88(%rip), %rsi      # 0x5cdda
callq 0x6520
movq %rax, %rdi
movq 0x21c2f(%rip), %rsi     # 0x78f90
callq 0x6570
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::stringIsInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool MyHelper::stringIsInt(string string)
{
    try
    {
        stoi(string);
    }
    catch (invalid_argument &msg)
    {
        return false;
    }
    catch (out_of_range &msg)
    {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x44d0
jmp 0x3bfb
jmp 0x3c54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x3c30
movq -0x20(%rbp), %rdi
callq 0x3140
movq %rax, -0x38(%rbp)
movb $0x0, -0x1(%rbp)
callq 0x3560
jmp 0x3c58
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3c63
movq -0x20(%rbp), %rdi
callq 0x3140
movq %rax, -0x30(%rbp)
movb $0x0, -0x1(%rbp)
callq 0x3560
jmp 0x3c58
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x35c0
nopl (%rax)
// File: PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::filesInDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int MyHelper::filesInDirectory(string fullDir)
{
    int amountOfFiles = 0;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            amountOfFiles++;
        }
    }
    closedir(dir);
    return amountOfFiles;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x3150
movq %rax, %rdi
callq 0x34f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3500
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x407f
movq -0x20(%rbp), %rdi
movq (%rdi), %rsi
addq $0x13, %rsi
addq $0x10, %rdi
callq 0x3460
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq 0x620f(%rip), %rsi      # 0xa25e
callq 0x4510
testb $0x1, %al
jne 0x405a
jmp 0x407d
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq 0x61f4(%rip), %rsi      # 0xa25d
callq 0x4510
testb $0x1, %al
jne 0x4074
jmp 0x407d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4012
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3550
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::filenamesInDirecotry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> MyHelper::filenamesInDirecotry(string fullDir)
{
    vector<string> files;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            files.push_back(buffer);
        }
    }
    closedir(dir);
    return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4540
movq -0x40(%rbp), %rdi
callq 0x3150
movq %rax, %rdi
callq 0x34f0
movq %rax, -0x38(%rbp)
jmp 0x40eb
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3500
movq %rax, -0x60(%rbp)
jmp 0x410a
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x41aa
movq -0x48(%rbp), %rdi
movq (%rdi), %rsi
addq $0x13, %rsi
addq $0x10, %rdi
callq 0x3460
jmp 0x4135
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
leaq 0x611a(%rip), %rsi      # 0xa25e
callq 0x4510
movb %al, -0x61(%rbp)
jmp 0x414e
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4157
jmp 0x41a5
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
leaq 0x60f7(%rip), %rsi      # 0xa25d
callq 0x4510
movb %al, -0x62(%rbp)
jmp 0x4170
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x4179
jmp 0x41a5
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x10, %rsi
callq 0x4560
jmp 0x418c
jmp 0x41a5
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x45d0
jmp 0x41d6
jmp 0x40f7
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3550
jmp 0x41b9
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x41cc
movq -0x58(%rbp), %rdi
callq 0x45d0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x35c0
nop
// File: PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::subjectsInDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> MyHelper::subjectsInDirectory(string fullDir)
{
    vector<string> files;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            buffer = buffer.substr(0, buffer.length() - 4);
            files.push_back(buffer);
        }
    }
    closedir(dir);
    return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4540
movq -0x60(%rbp), %rdi
callq 0x3150
movq %rax, %rdi
callq 0x34f0
movq %rax, -0x58(%rbp)
jmp 0x422e
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3500
movq %rax, -0x80(%rbp)
jmp 0x424d
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x435a
movq -0x68(%rbp), %rdi
movq (%rdi), %rsi
addq $0x13, %rsi
addq $0x10, %rdi
callq 0x3460
jmp 0x4278
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
leaq 0x5fd7(%rip), %rsi      # 0xa25e
callq 0x4510
movb %al, -0x81(%rbp)
jmp 0x4294
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x42a3
jmp 0x4355
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
leaq 0x5fab(%rip), %rsi      # 0xa25d
callq 0x4510
movb %al, -0x82(%rbp)
jmp 0x42bf
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x42ce
jmp 0x4355
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
callq 0x34e0
movq -0x90(%rbp), %rsi
movq %rax, %rcx
addq $-0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
callq 0x3380
jmp 0x42ff
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x98(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x3420
movq -0xa0(%rbp), %rdi
callq 0x3210
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x4560
jmp 0x433c
jmp 0x4355
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x45d0
jmp 0x4389
jmp 0x423a
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3550
jmp 0x4369
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x437c
movq -0x78(%rbp), %rdi
callq 0x45d0
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x35c0
nopw %cs:(%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::MySocket(int)
MySocket::MySocket(int port)
{
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    address.sin_addr.s_addr = INADDR_ANY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x410, %rdi            # imm = 0x410
xorl %esi, %esi
movl $0x10, %edx
callq 0x31d0
movq -0x18(%rbp), %rax
movw $0x2, 0x410(%rax)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x3060
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x412(%rax)
movl $0x0, 0x414(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::MySocket(char const*, int)
MySocket::MySocket(const char *addr, int port)
{
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_aton(addr, &address.sin_addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x410, %rdi            # imm = 0x410
xorl %esi, %esi
movl $0x10, %edx
callq 0x31d0
movq -0x20(%rbp), %rax
movw $0x2, 0x410(%rax)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x3060
movq -0x20(%rbp), %rsi
movw %ax, 0x412(%rsi)
movq -0x10(%rbp), %rdi
addq $0x410, %rsi            # imm = 0x410
addq $0x4, %rsi
callq 0x3280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::acceptNewConnection()
int MySocket::acceptNewConnection()
{
    new_socket = accept(create_socket, (struct sockaddr *)&cliaddress, &addrlen);
    if (new_socket == -1)
    {
        socketError("accept error");
    }
    cout << "Client connected from " << inet_ntoa(cliaddress.sin_addr) << ":" << ntohs(cliaddress.sin_port) << endl;
    strcpy(buffer, "Welcome to myserver, Please enter your command:\0");
    if (send(new_socket, buffer, strlen(buffer), 0) == -1)
    {
        socketError("send error");
    }
    return new_socket;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movl (%rdx), %edi
movq %rdx, %rsi
addq $0x420, %rsi            # imm = 0x420
addq $0xc, %rdx
callq 0x3100
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $-0x1, 0x4(%rax)
jne 0x5928
movq -0x18(%rbp), %rdi
leaq 0x47e1(%rip), %rsi      # 0xa104
callq 0x5770
movq 0x86a1(%rip), %rdi      # 0xdfd0
leaq 0x47db(%rip), %rsi      # 0xa111
callq 0x3350
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x38(%rbp)
movl 0x424(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3180
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3350
movq %rax, %rdi
leaq 0x47bb(%rip), %rsi      # 0xa128
callq 0x3350
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x30(%rbp)
movzwl 0x422(%rax), %edi
callq 0x3600
movq -0x30(%rbp), %rdi
movzwl %ax, %esi
callq 0x3580
movq %rax, %rdi
movq 0x8619(%rip), %rsi      # 0xdfb8
callq 0x3390
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x478d(%rip), %rsi      # 0xa140
callq 0x3330
movq -0x18(%rbp), %rdi
movl 0x4(%rdi), %eax
movl %eax, -0x24(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x3170
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
cmpq $-0x1, %rax
jne 0x59fd
movq -0x18(%rbp), %rdi
leaq 0x4732(%rip), %rsi      # 0xa12a
callq 0x5770
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::recvMessage(int)
const char *MySocket::recvMessage(int socket)
{
    if (socket == -1)
    {
        // client
        size = recv(create_socket, buffer, BUF - 1, 0);
    }
    else
    {
        // server
        size = recv(socket, buffer, BUF - 1, 0);
    }

    if (size == -1)
    {
        socketError("recv error");
    }
    else if (size == 0)
    {
        return "QUIT\n\0";
    }
    buffer[size] = '\0';
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5a4f
movq -0x20(%rbp), %rsi
movl (%rsi), %edi
addq $0x10, %rsi
movl $0x3ff, %edx            # imm = 0x3FF
xorl %ecx, %ecx
callq 0x3110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x5a70
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edi
addq $0x10, %rsi
movl $0x3ff, %edx            # imm = 0x3FF
xorl %ecx, %ecx
callq 0x3110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x5a8c
movq -0x20(%rbp), %rdi
leaq 0x46b0(%rip), %rsi      # 0xa135
callq 0x5770
jmp 0x5aa5
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x5aa3
leaq 0x46d4(%rip), %rax      # 0xa171
movq %rax, -0x8(%rbp)
jmp 0x5aba
jmp 0x5aa5
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rcx
movb $0x0, 0x10(%rax,%rcx)
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::sendMessage(char const*, int)
void MySocket::sendMessage(const char *message, int socket)
{
    if (socket == -1)
    {
        // client
        if (send(create_socket, message, strlen(message), 0) == -1)
        {
            socketError("send error");
        }
    }
    else
    {
        // server
        if (send(socket, message, strlen(message), 0) == -1)
        {
            socketError("send error");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5b34
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
cmpq $-0x1, %rax
jne 0x5b32
movq -0x20(%rbp), %rdi
leaq 0x45fd(%rip), %rsi      # 0xa12a
callq 0x5770
jmp 0x5b74
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31b0
cmpq $-0x1, %rax
jne 0x5b72
movq -0x20(%rbp), %rdi
leaq 0x45bd(%rip), %rsi      # 0xa12a
callq 0x5770
jmp 0x5b74
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: PepiJK[P]Mail-Server-Client/src/myserver.cpp
// Function: main
int main(int argc, char *argv[])
{
   MyHelper helper;
   helper.checkServerArguments(argc, argv);

   MySocket serverSocket(stoi(argv[1]));
   serverSocket.createSocket();
   serverSocket.bindSocket();
   serverSocket.listenSocket();

   int new_socket;

   cout << "Waiting for connections..." << endl;
   while (1)
   {
      new_socket = serverSocket.acceptNewConnection();
      // create a new thread everytime a new client connects to the server
      // detach because we allow the execution of the thread to continue independently
      thread(serverThread, helper, ref(serverSocket), new_socket, argv[2]).detach();
   }
   return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x4c0(%rbp)
callq 0x3820
movq -0x4c0(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x3840
jmp 0x7dfe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x4d0(%rbp)
leaq -0x4a1(%rbp), %rdi
movq %rdi, -0x4c8(%rbp)
callq 0x35d0
movq -0x4d0(%rbp), %rsi
movq -0x4c8(%rbp), %rdx
leaq -0x4a0(%rbp), %rdi
callq 0x3470
jmp 0x7e3c
xorl %eax, %eax
movl %eax, %esi
leaq -0x4a0(%rbp), %rdi
movl $0xa, %edx
callq 0x44d0
movl %eax, -0x4d4(%rbp)
jmp 0x7e59
movl -0x4d4(%rbp), %esi
leaq -0x47c(%rbp), %rdi
callq 0x5650
jmp 0x7e6d
leaq -0x4a0(%rbp), %rdi
callq 0x3210
leaq -0x4a1(%rbp), %rdi
callq 0x33c0
leaq -0x47c(%rbp), %rdi
callq 0x5720
jmp 0x7e93
leaq -0x47c(%rbp), %rdi
callq 0x5840
jmp 0x7ea1
leaq -0x47c(%rbp), %rdi
callq 0x5890
jmp 0x7eaf
movq 0x611a(%rip), %rdi      # 0xdfd0
leaq 0x2388(%rip), %rsi      # 0xa245
callq 0x3350
movq %rax, -0x4e0(%rbp)
jmp 0x7ecb
movq -0x4e0(%rbp), %rdi
movq 0x60df(%rip), %rsi      # 0xdfb8
callq 0x3390
jmp 0x7ee0
jmp 0x7ee2
jmp 0x7ee4
leaq -0x47c(%rbp), %rdi
callq 0x58e0
movl %eax, -0x4e4(%rbp)
jmp 0x7ef8
movl -0x4e4(%rbp), %eax
movl %eax, -0x4a8(%rbp)
leaq -0x47c(%rbp), %rdi
callq 0x86f0
movq %rax, -0x4b8(%rbp)
movq -0x10(%rbp), %r9
addq $0x10, %r9
leaq -0x2376(%rip), %rsi     # 0x5bb0
leaq -0x4b0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x4b8(%rbp), %rcx
leaq -0x4a8(%rbp), %r8
callq 0x8720
jmp 0x7f46
leaq -0x4b0(%rbp), %rdi
callq 0x35b0
jmp 0x7f54
leaq -0x4b0(%rbp), %rdi
callq 0x87f0
jmp 0x7ee2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7f96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4a0(%rbp), %rdi
callq 0x3210
leaq -0x4a1(%rbp), %rdi
callq 0x33c0
jmp 0x7fd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x87f0
leaq -0x47c(%rbp), %rdi
callq 0x5b80
leaq -0x40(%rbp), %rdi
callq 0x4400
movq -0x48(%rbp), %rdi
callq 0x35c0
nopl (%rax,%rax)
// File: razimantv[P]DancingLinks/nqueens/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::DancingLinks()
DancingLinks::DancingLinks() {
  dummycolumn_ = new DancingLinksColumn;
  dummycolumn_->set_essential(false);
  columns_ = NULL;
  cells_ = NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x20, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x46f0
jmp 0x1d6e
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
xorl %esi, %esi
callq 0x2ae0
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x20, %esi
callq 0x10d0
movq 0x18(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: razimantv[P]DancingLinks/nqueens/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::Destroy()
void DancingLinks::Destroy() {
  // Delete memory allocated to the children at the header
  // Of course, use this only at the header and only after allocation has
  //  been done. Don't blame me if you screw up
  if (columns_ != NULL) {
    delete[] columns_;
    columns_ = NULL;
  }
  if (cells_ != NULL) {
    delete[] cells_;
    cells_ = NULL;
  }
  dummycolumn_->set_left_ptr(NULL);
  dummycolumn_->set_right_ptr(NULL);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x1ecb
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1ebe
movq 0x30(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
movq -0x8(%rcx), %rdx
movq %rdx, 0x20(%rsp)
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x1ea7
movq 0x28(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x10(%rsp)
callq 0x4780
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1e80
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
shlq $0x5, %rsi
addq $0x8, %rsi
callq 0x1150
movq 0x38(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f02
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1ef5
movq 0x8(%rsp), %rdi
callq 0x10f0
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b20
movq 0x38(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b00
addq $0x48, %rsp
retq
nopl (%rax)
// File: razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::DancingLinksColumn()
DancingLinksColumn::DancingLinksColumn() {
  left_ptr_ = right_ptr_ = NULL;
  dummycell_ = new DancingLinksCell;
  size_ = 0;
  essential_ = true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movl $0x30, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x45a0
jmp 0x472d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movb $0x1, 0x1c(%rax)
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x30, %esi
callq 0x10d0
movq 0x18(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::RemoveColumn()
void DancingLinksColumn::RemoveColumn() {
  // Remove the column from the column list
  left_ptr_->set_right_ptr(right_ptr_);
  right_ptr_->set_left_ptr(left_ptr_);

  // Find the 1-cells in the column and remove the other 1-cells in those rows
  //  from their respective columns
  for (DancingLinksCell *ptr = dummycell_->down_ptr(); ptr != dummycell_;
       ptr = ptr->down_ptr()) {
    // Found a 1-cell in the column
    // Erase the row by finding its row neighbours and removing their
    //  vertical links
    for (DancingLinksCell *ptr2 = ptr->right_ptr(); ptr2 != ptr;
         ptr2 = ptr2->right_ptr()) {
      // 1-cell in the row
      // Remove vertical links
      ptr2->RemoveCell();
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x2b00
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rsi
callq 0x2b20
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2cd0
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
je 0x485c
movq 0x18(%rsp), %rdi
callq 0x2d20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x4849
movq 0x10(%rsp), %rdi
callq 0x45e0
movq 0x10(%rsp), %rdi
callq 0x2d20
movq %rax, 0x10(%rsp)
jmp 0x4822
jmp 0x484b
movq 0x18(%rsp), %rdi
callq 0x2cd0
movq %rax, 0x18(%rsp)
jmp 0x4803
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::UnremoveColumn()
void DancingLinksColumn::UnremoveColumn() {
  // Put back the cells in the reverse order as they were removed
  for (DancingLinksCell *ptr = dummycell_->up_ptr(); ptr != dummycell_;
       ptr = ptr->up_ptr()) {
    for (DancingLinksCell *ptr2 = ptr->left_ptr(); ptr2 != ptr;
         ptr2 = ptr2->left_ptr()) {
      ptr2->UnremoveCell();
    }
  }

  // Insert the column to the column list
  left_ptr_->set_right_ptr(this);
  right_ptr_->set_left_ptr(this);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0x4910
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
je 0x48ea
movq 0x18(%rsp), %rdi
callq 0x2d40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x48d7
movq 0x10(%rsp), %rdi
callq 0x4630
movq 0x10(%rsp), %rdi
callq 0x2d40
movq %rax, 0x10(%rsp)
jmp 0x48b0
jmp 0x48d9
movq 0x18(%rsp), %rdi
callq 0x4910
movq %rax, 0x18(%rsp)
jmp 0x4891
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
callq 0x2b00
movq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x2b20
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: qmmlib[P]QmmLibrary/train.c
// Function: main
int main(int argc, char **argv)
{
	char input_file_name[1024];
	char model_file_name[1024];
	const char *error_msg;

	parse_command_line(argc, argv, input_file_name, model_file_name);
	read_problem(input_file_name);
	param.train_file = Malloc(char,1024);
	strcpy(param.train_file, input_file_name);
	error_msg = check_parameter(&prob,&param);

	if(error_msg)
	{
		fprintf(stderr,"ERROR: %s\n",error_msg);
		exit(1);
	}

	if(flag_cross_validation)
	{
		do_cross_validation();
	}
	else
	{
		clock_t start_cpu, end_cpu;
		double cpu_time_used;
     	start_cpu = clock();
		model_=train(&prob, &param);
		end_cpu = clock();
     	cpu_time_used = ((double) (end_cpu - start_cpu)) / CLOCKS_PER_SEC;
		if(save_model(model_file_name, model_))
		{
			fprintf(stderr,"can't save model to file %s\n",model_file_name);
			exit(1);
		}
		free_and_destroy_model(&model_);
	}
	destroy_param(&param);
	free(prob.y);
	free(prob.x);
	free(x_space);
	free(line);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x410(%rbp), %rdx
leaq -0x810(%rbp), %rcx
callq 0x38a0
leaq -0x410(%rbp), %rdi
callq 0x40a0
movl $0x400, %edi            # imm = 0x400
callq 0x33d0
movq %rax, 0x27da0(%rip)     # 0x2b4e0
movq 0x27d99(%rip), %rdi     # 0x2b4e0
leaq -0x410(%rbp), %rsi
callq 0x3280
leaq 0x27e06(%rip), %rdi     # 0x2b560
leaq 0x27d47(%rip), %rsi     # 0x2b4a8
callq 0xf420
movq %rax, -0x818(%rbp)
cmpq $0x0, -0x818(%rbp)
je 0x37a0
movq 0x2785a(%rip), %rax     # 0x2afd8
movq (%rax), %rdi
movq -0x818(%rbp), %rdx
leaq 0x2173c(%rip), %rsi     # 0x24ecb
movb $0x0, %al
callq 0x3400
movl $0x1, %edi
callq 0x3380
cmpl $0x0, 0x27de1(%rip)     # 0x2b588
je 0x37b3
callq 0x4570
jmp 0x3859
callq 0x3180
movq %rax, -0x820(%rbp)
leaq 0x27d9a(%rip), %rdi     # 0x2b560
leaq 0x27cdb(%rip), %rsi     # 0x2b4a8
callq 0xa140
movq %rax, 0x27da7(%rip)     # 0x2b580
callq 0x3180
movq %rax, -0x828(%rbp)
movq -0x828(%rbp), %rax
subq -0x820(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x20808(%rip), %xmm1    # 0x24008
divsd %xmm1, %xmm0
movsd %xmm0, -0x830(%rbp)
leaq -0x810(%rbp), %rdi
movq 0x27d66(%rip), %rsi     # 0x2b580
callq 0xe810
cmpl $0x0, %eax
je 0x384d
movq 0x277ad(%rip), %rax     # 0x2afd8
movq (%rax), %rdi
leaq -0x810(%rbp), %rdx
leaq 0x2169a(%rip), %rsi     # 0x24ed6
movb $0x0, %al
callq 0x3400
movl $0x1, %edi
callq 0x3380
leaq 0x27d2c(%rip), %rdi     # 0x2b580
callq 0xe400
leaq 0x27c48(%rip), %rdi     # 0x2b4a8
callq 0xf3d0
movq 0x27cfc(%rip), %rdi     # 0x2b568
callq 0x3370
movq 0x27cf8(%rip), %rdi     # 0x2b570
callq 0x3370
movq 0x27cd4(%rip), %rdi     # 0x2b558
callq 0x3370
movq 0x27d08(%rip), %rdi     # 0x2b598
callq 0x3370
xorl %eax, %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
// File: qmmlib[P]QmmLibrary/train.c
// Function: readline(_IO_FILE*, int)
static char* readline(FILE *input, int max_idx) 
{
	int len;
	
	if(fgets(line,max_line_len,input) == NULL)
		return NULL;

	while(strrchr(line,'\n') == NULL)
	{
		max_line_len *= 2;
		line = (char *) realloc(line,max_line_len);
		len = (int) strlen(line);
		if(fgets(line+len,max_line_len-len,input) == NULL)
			break;
	}

	if(max_idx>0 && (param.structured_w=='s' || param.structured_w=='a' || param.structured_w=='f')) 
	{
		int y;
		double * read_line = (double*) malloc(sizeof(double)*(max_idx+1));
		memset(read_line, 0, sizeof(double)*(max_idx+1));
		split(line, read_line, &y);
		transform_line(read_line,y,max_idx,line, param.structured_w,param.transform_matrix,param.tmx_r,param.tmx_c);
		free(read_line);
	}
	
	return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x26a42(%rip), %rdi     # 0x2b598
movl 0x26a44(%rip), %esi     # 0x2b5a0
movq -0x10(%rbp), %rdx
callq 0x3460
cmpq $0x0, %rax
jne 0x4b78
movq $0x0, -0x8(%rbp)
jmp 0x4cb7
jmp 0x4b7a
movq 0x26a17(%rip), %rdi     # 0x2b598
movl $0xa, %esi
callq 0x3330
cmpq $0x0, %rax
jne 0x4bf2
movl 0x26a09(%rip), %eax     # 0x2b5a0
shll %eax
movl %eax, 0x26a01(%rip)     # 0x2b5a0
movq 0x269f2(%rip), %rdi     # 0x2b598
movslq 0x269f3(%rip), %rsi     # 0x2b5a0
callq 0x3490
movq %rax, 0x269df(%rip)     # 0x2b598
movq 0x269d8(%rip), %rdi     # 0x2b598
callq 0x3120
movl %eax, -0x18(%rbp)
movq 0x269c9(%rip), %rdi     # 0x2b598
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movl 0x269c4(%rip), %esi     # 0x2b5a0
subl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x3460
cmpq $0x0, %rax
jne 0x4bf0
jmp 0x4bf2
jmp 0x4b7a
cmpl $0x0, -0x14(%rbp)
jle 0x4cac
movsbl 0x26911(%rip), %eax     # 0x2b514
cmpl $0x73, %eax
je 0x4c24
movsbl 0x26905(%rip), %eax     # 0x2b514
cmpl $0x61, %eax
je 0x4c24
movsbl 0x268f9(%rip), %eax     # 0x2b514
cmpl $0x66, %eax
jne 0x4cac
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x33d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3150
movq 0x2693f(%rip), %rdi     # 0x2b598
movq -0x28(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x216f0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
movq 0x26921(%rip), %rcx     # 0x2b598
movb 0x26896(%rip), %r8b     # 0x2b514
movq 0x26893(%rip), %r9      # 0x2b518
movl 0x26894(%rip), %r10d    # 0x2b520
movl 0x26892(%rip), %eax     # 0x2b524
movsbl %r8b, %r8d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x21970
movq -0x28(%rbp), %rdi
callq 0x3370
movq 0x268e5(%rip), %rax     # 0x2b598
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: qmmlib[P]QmmLibrary/train.c
// Function: endofline(_IO_FILE*)
int endofline(FILE *ifp)
{
	int c = fgetc(ifp);
	int d = c;
    int eol = (c == '\r' || c == '\n');
    if (c == '\r')
    {
        c = getc(ifp);
        if (c != '\n' && c != EOF)
            ungetc(c, ifp);
    }
    return(eol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movb $0x1, %al
cmpl $0xd, -0xc(%rbp)
movb %al, -0x15(%rbp)
je 0x4d03
cmpl $0xa, -0xc(%rbp)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0xd, -0xc(%rbp)
jne 0x4d3a
movq -0x8(%rbp), %rdi
callq 0x30d0
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
je 0x4d38
cmpl $-0x1, -0xc(%rbp)
je 0x4d38
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x3080
jmp 0x4d3a
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::TRON(function const*, double, int)
TRON::TRON(const function *fun_obj, double eps, int max_iter)
{
	this->fun_obj=const_cast<function *>(fun_obj);
	this->eps=eps;
	this->max_iter=max_iter;
	tron_print_string = default_print;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
leaq 0xa(%rip), %rcx         # 0x5940
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::norm_inf(int, double*)
double TRON::norm_inf(int n, double *x)
{
	double dmax = fabs(x[0]);
	for (int i=1; i<n; i++)
		if (fabs(x[i]) >= dmax)
			dmax = fabs(x[i]);
	return(dmax);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x1e6a2(%rip), %xmm1    # 0x25120
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6adf
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1e676(%rip), %xmm1    # 0x25120
pand %xmm1, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x6ad2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1e657(%rip), %xmm1    # 0x25120
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x6ad4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6a8e
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::l2r_lr_fun(problem const*, double*)
l2r_lr_fun::l2r_lr_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

	z = new double[l];
	D = new double[l];
	this->C = C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1fac0
movq -0x40(%rbp), %rax
leaq 0x2412c(%rip), %rcx     # 0x2ac68
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movslq -0x1c(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0x6b75
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movslq -0x1c(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0x6ba6
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1fb30
movq -0x28(%rbp), %rdi
callq 0x34b0
nop
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::fun(double*)
double l2r_lr_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2.0;
	for(i=0;i<l;i++)
	{
		double yz = y[i]*z[i];
		if (yz >= 0)
			f += C[i]*log(1 + exp(-yz));
		else
			f += C[i]*(-yz+log(1 + exp(yz)));
	}

	return(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x40(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rdi), %rdx
callq 0x6e70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x6d15
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6cd6
movsd -0x20(%rbp), %xmm0
movsd 0x1e566(%rip), %xmm1    # 0x25288
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x6e5e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6dd6
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x34d0
movaps %xmm0, %xmm1
movsd 0x1d277(%rip), %xmm0    # 0x24028
addsd %xmm1, %xmm0
callq 0x3220
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x6e4e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x34d0
movaps %xmm0, %xmm1
movsd 0x1d206(%rip), %xmm0    # 0x24028
addsd %xmm1, %xmm0
callq 0x3220
movsd -0x58(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x6e50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d32
movsd -0x20(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Xv(double*, double*)
void l2r_lr_fun::Xv(double *v, double *Xv)
{
	int i;
	int l=prob->l;
	feature_node **x=prob->x;

	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		Xv[i]=0;
		while(s->index!=-1)
		{
			Xv[i]+=v[s->index-1]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6f27
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x6f17
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x6ec8
jmp 0x6f19
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ea0
popq %rbp
retq
nopl (%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::grad(double*, double*)
void l2r_lr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	for(i=0;i<l;i++)
	{
		z[i] = 1/(1 + exp(-y[i]*z[i]));
		D[i] = z[i]*(1-z[i]);
		z[i] = C[i]*(z[i]-1)*y[i];
	}
	XTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + g[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x7065
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
callq 0x34d0
movq -0x38(%rbp), %rax
movsd 0x1d065(%rip), %xmm1    # 0x24028
addsd %xmm0, %xmm1
movsd 0x1d059(%rip), %xmm0    # 0x24028
divsd %xmm1, %xmm0
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd 0x1d02b(%rip), %xmm1    # 0x24028
subsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm0
movq 0x18(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd 0x1cff3(%rip), %xmm2    # 0x24028
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6f71
movq -0x38(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq -0x18(%rbp), %rdx
callq 0x70c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x70b7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x707d
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::XTv(double*, double*)
void l2r_lr_fun::XTv(double *v, double *XTv)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		while(s->index!=-1)
		{
			XTv[s->index-1]+=v[i]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq 0x20(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x712a
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7107
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x71a5
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x7198
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
jmp 0x7149
jmp 0x719a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7131
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Hv(double*, double*)
void l2r_lr_fun::Hv(double *s, double *Hs)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	double *wa = new double[l];

	Xv(s, wa);
	for(i=0;i<l;i++)
		wa[i] = C[i]*D[i]*wa[i];

	XTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + Hs[i];
	delete[] wa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x20(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x24(%rbp)
movslq -0x20(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6e70
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x728a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x723f
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x70c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x72dc
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x72a2
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x72f3
movq -0x40(%rbp), %rdi
callq 0x33b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::l2r_l2_svc_fun(problem const*, double*)
l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

	z = new double[l];
	D = new double[l];
	I = new int[l];
	this->C = C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1fac0
movq -0x40(%rbp), %rax
leaq 0x2397c(%rip), %rcx     # 0x2aca8
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movslq -0x1c(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0x7365
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movslq -0x1c(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0x7396
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movslq -0x1c(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x50(%rbp)
jmp 0x73c7
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1fb30
movq -0x28(%rbp), %rdi
callq 0x34b0
nop