LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: SendToSeederList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void SendToSeederList(string filename, string SHA, int sock, string root_path,int RequestType){
    char sendBuffer[BUFFER_SIZE];
    memset(&sendBuffer, '\0',BUFFER_SIZE);

    cout<<"[+]system started...\n"; 
    cout<<"[+]system connecting...\n";

    string IP = MYIP, FilePath;
    int IPsize = IP.size(), RootPathSize = root_path.size();

    send(sock , &RequestType , sizeof(int) , 0 );
    send(sock , SHA.c_str() , SHA_DIGEST_LENGTH, 0 );

    send(sock , &IPsize, sizeof(int), 0 );
    send(sock , IP.c_str() , IPsize, 0 );
    send(sock , &PORT , sizeof(int) , 0 );
    send(sock , &RootPathSize , sizeof(int) , 0 );
    send(sock , root_path.c_str() , RootPathSize , 0 );

    return ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
leaq 0xc(%rsp), %r12
movl %r8d, (%r12)
movq 0x852f(%rip), %r13      # 0xffc8
leaq 0x3968(%rip), %rsi      # 0xb408
movq %r13, %rdi
callq 0x4330
leaq 0x396f(%rip), %rsi      # 0xb41e
movq %r13, %rdi
callq 0x4330
leaq 0x88ca(%rip), %rsi      # 0x10388
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x4470
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x8(%r13), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%r14), %eax
movl %eax, 0x4(%rsp)
pushq $0x4
popq %rdx
movl %ebx, %edi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x41d0
movq (%r15), %rsi
pushq $0x14
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
leaq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
movq 0x10(%rsp), %rsi
movslq 0x8(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
leaq 0x884b(%rip), %rsi      # 0x10380
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
movq (%r14), %rsi
movslq 0x4(%rsp), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
leaq 0x30(%rsp), %rdi
callq 0x4678
leaq 0x10(%rsp), %rdi
callq 0x4678
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4678
leaq 0x10(%rsp), %rdi
callq 0x4678
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: ReadSHA[abi:cxx11](int)
string ReadSHA(int TorrentFileD){
    char sendBuffer[BUFFER_SIZE];

    int read_size = read(TorrentFileD, sendBuffer, SHA_DIGEST_LENGTH);
    if(read_size == SHA_DIGEST_LENGTH){
        return sendBuffer;
    }
    return "-1";
}

// Assembly:
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
movl %esi, %eax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
pushq $0x14
popq %rdx
movl %eax, %edi
callq 0x4490
cmpl $0x14, %eax
jne 0x7bcc
leaq 0x10(%rsp), %rsi
jmp 0x7bd3
leaq 0x3832(%rip), %rsi      # 0xb405
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6040
movq %rbx, %rax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: BitVectorRequestToServers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void BitVectorRequestToServers(string IPaddress, int PORT, int thread_n,int TotalPacket, string SHA){
    int sock = Connection(IPaddress,PORT);

    int BitMapRequest = 1;
    send(sock , &BitMapRequest , sizeof(int) , 0 );
    send(sock , &TotalPacket , sizeof(int) , 0 );
    send(sock, SHA.c_str(), sizeof(SHA), 0);

    char recvBuffer[TotalPacket];
    memset(&recvBuffer, '\0',TotalPacket);
    int ack = 1, AvlPack;

    read(sock, recvBuffer, TotalPacket);
    read(sock, &AvlPack, sizeof(int));
    send(sock , &ack , sizeof(int) , 0 );

    string BitString = (string)recvBuffer;
    sem_wait(&mutex1);
        TotalAvlPack.insert(make_pair(AvlPack,thread_n));
        PacketNoAvl[thread_n] = BitString;
    sem_post(&mutex1);
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %rsi
movl %edx, -0x34(%rbp)
movl %ecx, -0x30(%rbp)
leaq -0x90(%rbp), %r15
movq %r15, %rdi
callq 0x4470
movq %r15, %rdi
movl %r14d, %esi
callq 0x86b7
movl %eax, %r14d
leaq -0x90(%rbp), %rdi
callq 0x4678
pushq $0x1
popq %rax
leaq -0x50(%rbp), %rsi
movl %eax, (%rsi)
pushq $0x4
popq %r15
movl %r14d, %edi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x41d0
leaq -0x30(%rbp), %r13
movl %r14d, %edi
movq %r13, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x41d0
movq (%r12), %rsi
pushq $0x20
popq %rdx
movl %r14d, %edi
xorl %ecx, %ecx
callq 0x41d0
movq %rsp, -0x40(%rbp)
movl (%r13), %eax
movq %rsp, %r12
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movslq (%r13), %r13
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x4210
leaq -0x4c(%rbp), %r15
pushq $0x1
popq %rax
movl %eax, (%r15)
movl %r14d, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4490
leaq -0x2c(%rbp), %rsi
movl %r14d, %edi
pushq $0x4
popq %r13
movq %r13, %rdx
callq 0x4490
movl %r14d, %edi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x41d0
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %r12, %rsi
callq 0x6040
leaq 0x8a15(%rip), %rdi      # 0x108f0
callq 0x4220
movl -0x2c(%rbp), %eax
shlq $0x20, %rbx
orq %rax, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0x8a50(%rip), %rdi      # 0x10948
callq 0x95ae
leaq 0x8a14(%rip), %rdi      # 0x10918
leaq -0x34(%rbp), %rsi
callq 0x8a6e
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x4200
leaq 0x89d0(%rip), %rdi      # 0x108f0
callq 0x4560
leaq -0x70(%rbp), %rdi
callq 0x4678
movq -0x40(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f54
movq %rax, %rbx
jmp 0x7f60
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x7f5b
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4678
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ClientConnection.cpp
// Function: Connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Connection(string IPaddress,int PORT){
    int sock = 0; 
    struct sockaddr_in serv_addr;
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    { 
        printf("\n Socket creation error \n"); 
        return -1; 
    } 
    memset(&serv_addr, '0', sizeof(serv_addr)); 
    serv_addr.sin_family = AF_INET; 
    serv_addr.sin_port = htons(PORT); 
    
    if(inet_pton(AF_INET, IPaddress.c_str() , &serv_addr.sin_addr)<=0){ 
        printf("\nInvalid address/ Address not supported \n"); 
        return -1; 
    } 
   
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){ 
        printf("\nConnection Failed \n"); 
        return -1; 
    }
    else{
        sem_wait(&mutex1);
            cout<<"> You are connected with: "<<IPaddress<<":"<<PORT<<"\n";
        sem_post(&mutex1);
    }
    return sock;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x4100
testl %eax, %eax
js 0x8787
movl %eax, %ebx
leaq 0xc(%rsp), %rdx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, (%rdx)
movl $0x30303030, 0x8(%rdx)  # imm = 0x30303030
movw $0x2, -0x4(%rdx)
movl %ebp, %eax
rolw $0x8, %ax
movw %ax, -0x2(%rdx)
movq (%r14), %rsi
pushq $0x2
popq %rdi
callq 0x4600
testl %eax, %eax
jle 0x8790
leaq 0x8(%rsp), %rsi
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x42c0
testl %eax, %eax
js 0x8799
leaq 0x81c1(%rip), %r15      # 0x108f0
movq %r15, %rdi
callq 0x4220
movq 0x788a(%rip), %rdi      # 0xffc8
leaq 0x2cf2(%rip), %rsi      # 0xb437
callq 0x4330
movq %rax, %rdi
movq %r14, %rsi
callq 0x4300
leaq 0x2996(%rip), %rsi      # 0xb0f2
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
movl %ebp, %esi
callq 0x4590
leaq 0x2c71(%rip), %rsi      # 0xb3e6
movq %rax, %rdi
callq 0x4330
movq %r15, %rdi
callq 0x4560
jmp 0x87a8
leaq 0x2da3(%rip), %rdi      # 0xb531
jmp 0x87a0
leaq 0x2d71(%rip), %rdi      # 0xb508
jmp 0x87a0
leaq 0x2d54(%rip), %rdi      # 0xb4f4
callq 0x44e0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: ServerConnection()
void ServerConnection(){
    int server_fd; 
    struct sockaddr_in address; 
    int opt = 1; 
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0){ 
        perror("socket failed"); 
        exit(EXIT_FAILURE); 
    } 
       
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,&opt, sizeof(opt))){ 
        perror("setsockopt"); 
        exit(EXIT_FAILURE); 
    } 
    address.sin_family = AF_INET; 
    address.sin_addr.s_addr = INADDR_ANY; 
    address.sin_port = htons( PORT ); 
       
    if (bind(server_fd, (struct sockaddr *)&address,sizeof(address))<0){ 
        perror("bind failed"); 
        exit(EXIT_FAILURE); 
    } 
    if (listen(server_fd, 3) < 0){ 
        perror("listen"); 
        exit(EXIT_FAILURE); printf("[+]server started...\n");
    }
    Communication(server_fd,address);
    return ;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl $0x1, 0xc(%rsp)
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x4100
testl %eax, %eax
jne 0x997f
leaq 0x1d36(%rip), %rdi      # 0xb6b3
jmp 0x99d9
movl %eax, %ebx
pushq $0x1
popq %rsi
pushq $0xf
popq %rdx
leaq 0xc(%rsp), %rcx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x45c0
testl %eax, %eax
jne 0x99d2
leaq 0x10(%rsp), %rsi
movw $0x2, (%rsi)
andl $0x0, 0x4(%rsi)
leaq 0x69d0(%rip), %rax      # 0x10380
movzwl (%rax), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsi)
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x4090
testl %eax, %eax
jns 0x99e6
leaq 0x1cfc(%rip), %rdi      # 0xb6cc
jmp 0x99d9
leaq 0x1ce8(%rip), %rdi      # 0xb6c1
callq 0x42d0
pushq $0x1
popq %rdi
callq 0x43e0
pushq $0x3
popq %rsi
movl %ebx, %edi
callq 0x4390
testl %eax, %eax
jns 0x99fd
leaq 0x1cdd(%rip), %rdi      # 0xb6d8
jmp 0x99d9
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %edi
callq 0x9a0e
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: Communication(int, sockaddr_in)
void Communication(int server_fd,struct sockaddr_in address){
    int new_socket,addrlen = sizeof(address), RequestType;
    printf("[+]server started...\n");
    while(1){
        printf("[+]Listening...\n");
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address,(socklen_t*)&addrlen))<0){ 
            perror("accept"); 
            exit(EXIT_FAILURE); 
        } 
        read(new_socket, &RequestType, sizeof(int));
        if(RequestType == 1)
            BitVectorDetailSend(new_socket);
        else
            SendData(new_socket);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x4(%rsp), %r15
movl $0x10, (%r15)
leaq 0x1cbc(%rip), %rdi      # 0xb6f9
callq 0x44e0
leaq 0x1cc5(%rip), %r12      # 0xb70e
movq %rsp, %r13
pushq $0x4
popq %rbp
movq %r12, %rdi
callq 0x44e0
movl %ebx, %edi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x4170
testl %eax, %eax
js 0x9a94
movl %eax, %r14d
movl %eax, %edi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4490
cmpl $0x1, (%rsp)
jne 0x9a8a
movl %r14d, %edi
callq 0x9aa8
jmp 0x9a4f
movl %r14d, %edi
callq 0x9bd3
jmp 0x9a4f
leaq 0x1c44(%rip), %rdi      # 0xb6df
callq 0x42d0
pushq $0x1
popq %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: BitVectorDetailSend(int)
void BitVectorDetailSend(int new_socket){
    if(fork() == 0){
        int ack, TotalPacket;
        char SHA[20];

        printf("Client is ready...\n");

        read(new_socket, &TotalPacket,sizeof(int));

        read(new_socket, SHA ,20);
        string BitBuffer = TotalFile[(string)SHA];

        send(new_socket, BitBuffer.c_str(), BitBuffer.size(), 0);

        int AvlPack = 0;
        for(int i = 0; i < TotalPacket; i++){
            if((BitBuffer[i]-'0')) AvlPack++;
        }
        send(new_socket, &AvlPack, sizeof(int), 0);
        read(new_socket, &ack, sizeof(int));
        
        close(new_socket);
        exit(0);
    }
    else{
        cout<<"[+]server busy...\n";
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
callq 0x4130
testl %eax, %eax
je 0x9ad4
movq 0x6507(%rip), %rdi      # 0xffc8
leaq 0x1c1e(%rip), %rsi      # 0xb6e6
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x4330
leaq 0x1c43(%rip), %rdi      # 0xb71e
callq 0x44e0
leaq 0xc(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
callq 0x4490
leaq 0x50(%rsp), %r14
pushq $0x14
popq %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x4490
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x6040
leaq 0x690e(%rip), %rdi      # 0x10428
leaq 0x10(%rsp), %rsi
callq 0x9e9c
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x4470
leaq 0x10(%rsp), %rdi
callq 0x4678
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
xorl %r14d, %r14d
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
andl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
testl %eax, %eax
cmovlel %r14d, %eax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x9b7f
cmpb $0x30, (%rcx,%rdx)
je 0x9b7a
incl %r14d
movl %r14d, 0x8(%rsp)
incq %rdx
jmp 0x9b67
leaq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x41d0
leaq 0x10(%rsp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
callq 0x4490
movl %ebx, %edi
callq 0x4660
xorl %edi, %edi
callq 0x43e0
jmp 0x9baf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x9bc1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4678
jmp 0x9bcb
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/girdhari9[P]mTORRENT/ServerConnection.cpp
// Function: SetBitMap(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SetBitMap(int TotalPacket, int flag, string SHA){
    char *BitBuffer = new char[TotalPacket];
    if(flag){
        for(int i=0; i<TotalPacket; i++)
            BitBuffer[i] = '1';
    }
    else{
        for(int i=0; i<TotalPacket; i++)
            BitBuffer[i] = '0';
    }
    TotalFile[SHA] = (string)BitBuffer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movslq %edi, %r14
movq %r14, %rdi
callq 0x4030
xorl %ecx, %ecx
testl %r14d, %r14d
cmovgl %r14d, %ecx
xorl %edx, %edx
testl %ebp, %ebp
je 0x9e40
cmpq %rdx, %rcx
je 0x9e45
movb $0x31, (%rax,%rdx)
incq %rdx
jmp 0x9e2b
movb $0x30, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x9e39
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x6040
leaq 0x65ca(%rip), %rdi      # 0x10428
movq %rbx, %rsi
callq 0x8a08
leaq 0x10(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x43f0
movq %rbx, %rdi
callq 0x4678
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4678
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_15.cc
// Function: connect(Destination*)
Connection connect(Destination* pDest)
{
	shared_ptr<Connection> pConn(new Connection(pDest->ip, pDest->port));

	// ...

	cout << "Creat connection(" << pConn.use_count() << ")" << endl;

	return *pConn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x20f0
movzwl 0x20(%r15), %r12d
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x20f0
movw %r12w, 0x20(%r14)
xorl %r15d, %r15d
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x270a
leaq -0x50(%rbp), %rdi
callq 0x2060
movq 0x2ce8(%rip), %rdi      # 0x4fd8
leaq 0xd0d(%rip), %rsi       # 0x3004
callq 0x20c0
movq -0x28(%rbp), %rcx
testq %rcx, %rcx
je 0x230d
movl 0x8(%rcx), %ecx
movslq %ecx, %rsi
jmp 0x230f
xorl %esi, %esi
movq %rax, %rdi
callq 0x20b0
leaq 0xcf8(%rip), %rsi       # 0x3016
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2070
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x264c
leaq -0x28(%rbp), %rdi
callq 0x266c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2369
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2060
testb %r15b, %r15b
je 0x2382
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x20e0
jmp 0x2382
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x266c
movq %rbx, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libutreexo/crypto/sha256.cpp
// Function: CSHA256::Write(unsigned char const*, unsigned long)
CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
{
    const unsigned char* end = data + len;
    size_t bufsize = bytes % 64;
    if (bufsize && bufsize + len >= 64) {
        // Fill the buffer, and process it.
        memcpy(buf + bufsize, data, 64 - bufsize);
        bytes += 64 - bufsize;
        data += 64 - bufsize;
        Transform(s, buf, 1);
        bufsize = 0;
    }
    if (end - data >= 64) {
        size_t blocks = (end - data) / 64;
        Transform(s, data, blocks);
        data += 64 * blocks;
        bytes += 64 * blocks;
    }
    if (end > data) {
        // Fill the buffer with what remains.
        memcpy(buf + bufsize, data, end - data);
        bytes += end - data;
    }
    return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq (%rsi,%rdx), %r14
movq 0x60(%rdi), %rbp
andq $0x3f, %rbp
je 0x17cc
addq %rbp, %rdx
cmpq $0x40, %rdx
jb 0x17ce
leaq 0x20(%rbx), %r12
leaq (%rbx,%rbp), %rdi
addq $0x20, %rdi
pushq $0x40
popq %r13
subq %rbp, %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x1080
addq %r13, 0x60(%rbx)
addq %r13, %r15
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq *0x298ac(%rip)          # 0x2b078
xorl %ebp, %ebp
movq %r14, %r12
subq %r15, %r12
cmpq $0x40, %r12
jl 0x1801
movq %r12, %rdx
shrq $0x6, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x2988b(%rip)          # 0x2b078
movabsq $0x7fffffffffffffc0, %rax # imm = 0x7FFFFFFFFFFFFFC0
andq %r12, %rax
addq %rax, %r15
addq %rax, 0x60(%rbx)
subq %r15, %r14
jbe 0x181d
leaq (%rbx,%rbp), %rdi
addq $0x20, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1080
addq %r14, 0x60(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libutreexo/crypto/sha256.cpp
// Function: CSHA256::Finalize(unsigned char*)
void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
{
    static const unsigned char pad[64] = {0x80};
    unsigned char sizedesc[8];
    WriteBE64(sizedesc, bytes << 3);
    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
    Write(sizedesc, 8);
    WriteBE32(hash, s[0]);
    WriteBE32(hash + 4, s[1]);
    WriteBE32(hash + 8, s[2]);
    WriteBE32(hash + 12, s[3]);
    WriteBE32(hash + 16, s[4]);
    WriteBE32(hash + 20, s[5]);
    WriteBE32(hash + 24, s[6]);
    WriteBE32(hash + 28, s[7]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rax
leaq (,%rax,8), %rcx
bswapq %rcx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
pushq $0x37
popq %rdx
subl %eax, %edx
andl $0x3f, %edx
incq %rdx
leaq 0x24858(%rip), %rsi     # 0x260c0
callq 0x1770
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1770
movl (%r14), %eax
bswapl %eax
movl %eax, (%rbx)
movl 0x4(%r14), %eax
bswapl %eax
movl %eax, 0x4(%rbx)
movl 0x8(%r14), %eax
bswapl %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movl 0x10(%r14), %eax
bswapl %eax
movl %eax, 0x10(%rbx)
movl 0x14(%r14), %eax
bswapl %eax
movl %eax, 0x14(%rbx)
movl 0x18(%r14), %eax
bswapl %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%r14), %eax
bswapl %eax
movl %eax, 0x1c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libutreexo/crypto/sha256.cpp
// Function: SHA256D64(unsigned char*, unsigned char const*, unsigned long)
void SHA256D64(unsigned char* out, const unsigned char* in, size_t blocks)
{
    if (TransformD64_8way) {
        while (blocks >= 8) {
            TransformD64_8way(out, in);
            out += 256;
            in += 512;
            blocks -= 8;
        }
    }
    if (TransformD64_4way) {
        while (blocks >= 4) {
            TransformD64_4way(out, in);
            out += 128;
            in += 256;
            blocks -= 4;
        }
    }
    if (TransformD64_2way) {
        while (blocks >= 2) {
            TransformD64_2way(out, in);
            out += 64;
            in += 128;
            blocks -= 2;
        }
    }
    while (blocks) {
        TransformD64(out, in);
        out += 32;
        in += 64;
        --blocks;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x8, %rdx
jb 0x1920
cmpq $0x0, 0x297ad(%rip)     # 0x2b0a8
je 0x1920
movq %r15, %rdi
movq %r14, %rsi
callq 0x8994
addq $0x100, %r15            # imm = 0x100
addq $0x200, %r14            # imm = 0x200
addq $-0x8, %rbx
cmpq $0x7, %rbx
ja 0x18fd
cmpq $0x4, %rbx
jb 0x1950
cmpq $0x0, 0x29772(%rip)     # 0x2b0a0
je 0x1950
movq %r15, %rdi
movq %r14, %rsi
callq 0x161e8
subq $-0x80, %r15
addq $0x100, %r14            # imm = 0x100
addq $-0x4, %rbx
cmpq $0x3, %rbx
ja 0x1930
cmpq $0x2, %rbx
jb 0x1993
cmpq $0x0, 0x2973a(%rip)     # 0x2b098
je 0x1993
movq %r15, %rdi
movq %r14, %rsi
callq 0x1454d
addq $0x40, %r15
subq $-0x80, %r14
addq $-0x2, %rbx
cmpq $0x1, %rbx
ja 0x1960
jmp 0x1993
movq %r15, %rdi
movq %r14, %rsi
callq *0x296f5(%rip)          # 0x2b080
addq $0x20, %r15
addq $0x40, %r14
subq $0x1, %rbx
jae 0x197f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libutreexo/crypto/sha256.cpp
// Function: (anonymous namespace)::sha256::Round(unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int)
void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k)
{
    uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
    uint32_t t2 = Sigma0(a) + Maj(a, b, c);
    d += t1;
    h = t1 + t2;
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %r11d
movl %r8d, %ebx
movl %r8d, %r10d
xorl %r11d, %r9d
andl %r8d, %r9d
roll $0x1a, %r8d
roll $0x15, %ebx
xorl %r8d, %ebx
roll $0x7, %r10d
xorl %ebx, %r10d
xorl %r11d, %r9d
addl 0x20(%rsp), %r10d
addl %r9d, %r10d
addl (%rax), %r10d
movl %edi, %r8d
movl %edi, %r9d
movl %esi, %r11d
andl %edi, %r11d
orl %edi, %esi
roll $0x1e, %edi
roll $0x13, %r8d
xorl %edi, %r8d
roll $0xa, %r9d
xorl %r8d, %r9d
andl %edx, %esi
addl %r10d, (%rcx)
orl %r11d, %esi
addl %r9d, %esi
addl %r10d, %esi
movl %esi, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/bsaikiran618[P]mandelbrot-set-viewer/main.cpp
// Function: main
int main()
{
	try
	{
		Window appWindow("SK's Mandelbrot Set Viewer", SDL_WINDOW_SHOWN);
		appWindow.startEventLoop();
	}
	catch(std::string errMsg)
	{
		std::cerr << errMsg << std::endl;
		exit(-1);
	}
	catch(...)
	{
		std::cerr << "An unknown error occured!" << std::endl;
		exit(-1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0xbf9(%rip), %rsi       # 0x3039
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2526
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x28c8
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x38(%rbp), %rdi
callq 0x2976
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x248d
movq %rdx, %r14
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20c0
jmp 0x2493
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x2, %r14d
jne 0x24cf
movq %rbx, %rdi
callq 0x21d0
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2090
movq 0x2b34(%rip), %rdi      # 0x4ff0
leaq -0x38(%rbp), %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20d0
jmp 0x24f2
movq %rbx, %rdi
callq 0x2090
movq 0x2b12(%rip), %rdi      # 0x4ff0
leaq 0xb6f(%rip), %rsi       # 0x3054
callq 0x21a0
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rdi
callq 0x21c0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
callq 0x2220
jmp 0x2515
movq %rax, %rbx
callq 0x2220
movq %rbx, %rdi
callq 0x2240
movq %rax, %rdi
callq 0x2561
nop
// File: /workspace/github_cpp_makefile_star2_O2/bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::drawAxes(Cartesian2DPlane*)
void Window::drawAxes( Cartesian2DPlane *plane )
{
	Cartesian2DPoint leftExtreme	(double(0),	-1000,	plane);
	Cartesian2DPoint rightExtreme	(double(0),	1000,	plane);
	Cartesian2DPoint topExtreme		(double(1000), 0,		plane);
	Cartesian2DPoint bottomExtreme	(double(-1000),0, 	plane);

	SDL_SetRenderDrawColor(screenRenderer, 120,120,120,SDL_ALPHA_OPAQUE);
	//The X axis
	SDL_RenderDrawLine(screenRenderer, leftExtreme.getOnScreenX(), leftExtreme.getOnScreenY(),	
										rightExtreme.getOnScreenX(), rightExtreme.getOnScreenY());
	//The Y axis
	SDL_RenderDrawLine(screenRenderer, topExtreme.getOnScreenX(), topExtreme.getOnScreenY(),
										bottomExtreme.getOnScreenX(), bottomExtreme.getOnScreenY());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x90(%rbp), %r13
movsd 0xa62(%rip), %xmm1      # 0x3098
xorps %xmm0, %xmm0
movq %r13, %rdi
callq 0x2a94
leaq -0x78(%rbp), %rdi
movsd 0xa53(%rip), %xmm1      # 0x30a0
xorps %xmm0, %xmm0
movq %rdi, %r12
movq %r14, %rsi
callq 0x2a94
leaq -0x60(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0xa36(%rip), %xmm0      # 0x30a0
movq %r14, %rsi
callq 0x2a94
leaq -0x48(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0xa17(%rip), %xmm0      # 0x3098
movq %r14, %rsi
callq 0x2a94
movq %rbx, -0x30(%rbp)
movq 0x10(%rbx), %rdi
pushq $0x78
popq %rcx
movl %ecx, %esi
movl %ecx, %edx
movl $0xff, %r8d
callq 0x21f0
movq 0x10(%rbx), %r14
movq %r13, %rdi
callq 0x2b4a
movq %rax, %r15
movq %r13, %rdi
callq 0x2bac
movq %rax, %r13
movq %r12, %rbx
movq %r12, %rdi
callq 0x2b4a
movq %rax, %r12
movq %rbx, %rdi
callq 0x2bac
movq %r14, %rdi
movl %r15d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x2080
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rbx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x2b4a
movq %rax, %r14
movq %r15, %rdi
callq 0x2bac
movq %rax, %r15
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0x2b4a
movq %rax, %r12
movq %r13, %rdi
callq 0x2bac
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x2080
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::Window(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Window::Window(std::string windowTitle, uint64_t flags)
{	
		if(SDL_Init(SDL_INIT_VIDEO) < 0) throw "Couldn't initialize SDL Video!";

		if((window = SDL_CreateWindow(windowTitle.c_str(), WINDOW_X, WINDOW_Y, SCREEN_W, SCREEN_H, flags)) == NULL)
			throw "Couldn't create SDL window!";

		//windowSurface = SDL_GetWindowSurface(window);

		if((screenRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED)) == NULL)
			throw "Couldn't create SDL Renderer!";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x2160
testl %eax, %eax
js 0x2931
movq (%r15), %rdi
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x384, %ecx            # imm = 0x384
movl $0x384, %r8d            # imm = 0x384
movl %r14d, %r9d
callq 0x2040
movq %rax, (%rbx)
testq %rax, %rax
je 0x2942
pushq $-0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x2953
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20e0
leaq 0x7ae(%rip), %rcx       # 0x30ee
jmp 0x2962
pushq $0x8
popq %rdi
callq 0x20e0
leaq 0x7bc(%rip), %rcx       # 0x310d
jmp 0x2962
pushq $0x8
popq %rdi
callq 0x20e0
leaq 0x7c7(%rip), %rcx       # 0x3129
movq %rcx, (%rax)
movq 0x2654(%rip), %rsi      # 0x4fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::startEventLoop()
void Window::startEventLoop()
{
		SDL_Event e;
		bool appQuit = false;
		bool changed = false;
		srand(42);
		
		Cartesian2DPlane plane(SCREEN_W, SCREEN_H, 150);
		drawScreen(&plane);
		while(!appQuit)
		{
			changed = false;
			while(SDL_PollEvent(&e))
			{
				if(e.type == SDL_QUIT)
				{
					appQuit = true;
					break;
				}
				else if(e.type == SDL_KEYDOWN)
				{
					switch(e.key.keysym.sym)
					{
						case SDLK_UP: 		plane.translateUp();	changed = true;break;
						case SDLK_DOWN: 	plane.translateDown();	changed = true;break;
						case SDLK_LEFT: 	plane.translateLeft();	changed = true;break;
						case SDLK_RIGHT: 	plane.translateRight();	changed = true;break;
						case SDLK_z: 	plane.zoomIn();			changed = true;break;
						case SDLK_x:	plane.zoomOut();		changed = true;break;
					}
				}
			}
			if(changed) drawScreen(&plane);
		}
		//event loop ends.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
pushq $0x2a
popq %rdi
callq 0x2190
leaq -0x90(%rbp), %r14
movsd 0x70f(%rip), %xmm0      # 0x30b0
movl $0x384, %esi            # imm = 0x384
movl $0x384, %edx            # imm = 0x384
movq %r14, %rdi
callq 0x2c18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2744
xorl %r13d, %r13d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x2100
movl %eax, %r12d
testl %eax, %eax
je 0x2a10
movl -0x60(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
je 0x2a10
cmpl $0x300, %eax            # imm = 0x300
jne 0x29c5
movl -0x4c(%rbp), %eax
leal -0x4000004f(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2a2b
leaq 0x6d6(%rip), %rdx       # 0x30d0
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x2d3a
movb $0x1, %r13b
jmp 0x29c5
testb $0x1, %r13b
je 0x2a21
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2744
xorl %r13d, %r13d
testl %r12d, %r12d
je 0x29c5
jmp 0x2a82
cmpl $0x78, %eax
je 0x2a42
cmpl $0x7a, %eax
jne 0x29c5
movq %r14, %rdi
callq 0x2c88
movb $0x1, %r13b
jmp 0x29c5
movq %r14, %rdi
callq 0x2cd4
movb $0x1, %r13b
jmp 0x29c5
movq %r14, %rdi
callq 0x2d52
movb $0x1, %r13b
jmp 0x29c5
movq %r14, %rdi
callq 0x2d46
movb $0x1, %r13b
jmp 0x29c5
movq %r14, %rdi
callq 0x2d2e
movb $0x1, %r13b
jmp 0x29c5
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/bsaikiran618[P]mandelbrot-set-viewer/Mandelbrot.cpp
// Function: inMandelbrotSet(std::complex<double>, unsigned long)
int inMandelbrotSet(std::complex<double> point, uint64_t max_iters)
{
	std::complex<double> initial = point;
	int count = 0;
	for(uint64_t i=0;i<max_iters;i++)
	{
		if(std::abs(point) > 2) return count;
		point = std::pow(point, 2) + initial;
		count++;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, (%r15)
movsd %xmm1, -0x38(%rbp)
movsd %xmm1, 0x8(%r15)
xorl %r13d, %r13d
pushq $-0x1
popq %r14
pushq $0x2
popq %r12
cmpq %r13, %rbx
je 0x2dd6
movq %r15, %rdi
callq 0x2de8
ucomisd 0x3cb(%rip), %xmm0      # 0x3178
ja 0x2dd3
movq %r15, %rdi
movl %r12d, %esi
callq 0x2dfb
addsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm1
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
incq %r13
jmp 0x2d98
movl %r13d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Basket.cc
// Function: Basket::display(std::ostream&) const
void Basket::display(ostream &os) const
{
    os << "Basket size: " << items.size() << endl;

    // print each distinct ISBN in the Basket along with
    // count of how many copies are ordered and what their price will be
    // upper_bound returns an iterator to the next item in the set
    for (auto next_item = items.cbegin();
              next_item != items.cend();
              next_item = items.upper_bound(*next_item))
    {
        // we know there's at least one element with this key in the Basket
        os << (*next_item)->isbn() << " occurs " 
           << items.count(*next_item) << " times" 
           << " for a price of " 
           << (*next_item)->net_price(items.count(*next_item)) 
           << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, %r14
leaq 0xe80(%rip), %rsi       # 0x41ae
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x20e0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
callq 0x2080
movq 0x18(%r14), %r13
leaq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %r15
cmpq -0x38(%rbp), %r13
je 0x3417
movq 0x20(%r13), %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x2120
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x20d0
movq %rax, %rdi
leaq 0xe2e(%rip), %rsi       # 0x41bc
callq 0x20e0
movq %rax, %r12
addq $0x20, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3538
movq %r12, %rdi
movq %rax, %rsi
callq 0x20a0
movq %rax, %rdi
leaq 0xe0b(%rip), %rsi       # 0x41c5
callq 0x20e0
movq %rax, %rdi
leaq 0xe03(%rip), %rsi       # 0x41cc
callq 0x20e0
movq %rax, %r12
movq (%r13), %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3538
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r12, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x2080
movq %r15, %rdi
callq 0x2070
movq %r14, %rdi
movq %r13, %rsi
callq 0x34dc
movq %rax, %r13
jmp 0x335e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Basket.cc
// Function: Basket::total_receipt(std::ostream&) const
double Basket::total_receipt(ostream &os) const
{
    double sum = 0.0;    // holds the running total 


    // iter refers to the first element in a batch of elements with the same ISBN
    // upper_bound returns an iterator to the element just past the end of that batch
    for (auto iter = items.cbegin(); 
              iter != items.cend();
              iter = items.upper_bound(*iter)) {
        // we know there's at least one element with this key in the Basket
		// print the line item for this book
        sum += print_total(os, **iter, items.count(*iter));  
    } 
	os << "Total Sale: " << sum << endl; // print the final overall total
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
leaq 0x8(%rdi), %r13
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpq %r13, %r15
je 0x34a3
movq 0x20(%r15), %r12
addq $0x20, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3538
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x365c
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x34dc
movq %rax, %r15
jmp 0x345f
leaq 0xd33(%rip), %rsi       # 0x41dd
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x2160
movq %rax, %rdi
callq 0x2080
movsd -0x30(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc
// Function: print_total(std::ostream&, Quote const&, unsigned long)
double print_total(ostream &os, 
                   const Quote &item, size_t n)
{
	// depending on the type of the object bound to the item parameter
	// calls either Quote::net_price or Bulk_quote::net_price
	double ret = item.net_price(n); 
    os << "ISBN: " << item.isbn() // calls Quote::isbn
       << " # sold: " << n << " total due: " << ret << endl;
 	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq *0x10(%rax)
movsd %xmm0, -0x28(%rbp)
leaq 0xb6c(%rip), %rsi       # 0x41f8
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
addq $0x8, %r14
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2120
movq %r15, %rdi
movq %r12, %rsi
callq 0x20d0
leaq 0xb43(%rip), %rsi       # 0x41ff
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20a0
leaq 0xb33(%rip), %rsi       # 0x4209
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x2160
movq %rax, %rdi
callq 0x2080
leaq -0x48(%rbp), %rdi
callq 0x2070
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc
// Function: Lim_quote::net_price(unsigned long) const
double Lim_quote::net_price(size_t cnt) const
{
    size_t discounted = min(cnt, quantity);
    size_t undiscounted = cnt - discounted;
    return discounted * (1 - discount) * price 
           + undiscounted * price;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
cmovaeq %rsi, %rax
subq %rax, %rsi
movq %rax, %xmm0
movq 0x89b(%rip), %xmm1      # 0x4020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x89f(%rip), %xmm2      # 0x4030
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movsd 0xa47(%rip), %xmm0      # 0x41f0
subsd 0x38(%rdi), %xmm0
mulsd %xmm3, %xmm0
movsd 0x28(%rdi), %xmm3
movq %rsi, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
addsd %xmm4, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/DbTest.cc
// Function: Create_DB_Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Create_DB_Test(string filename) {

    int record_num = 10;
    int ht_size = record_num * 2;

    Options opts;
    opts.segment_size = 256 * 1024;
    opts.hashtable_size = ht_size;

    KVDS *db = KVDS::Create_KVDS(filename.c_str(), opts);

    delete db;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x14ba8
movabsq $0x4000000000014, %rax  # imm = 0x4000000000014
movq %rax, 0x40(%r14)
movq (%rbx), %rax
pushq $0xa
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x10ad0
testq %rax, %rax
je 0x6a69
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/DbTest.cc
// Function: main
int main(int argc, char** argv) {
    string filename = argv[1];

    Create_DB_Test(filename);
    Open_DB_Test(filename);
    std::cout << "first process success" << std::endl;
    Create_DB_Test(filename);
    Open_DB_Test(filename);
    return 0;
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6150
leaq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0x6530
leaq 0x90(%rsp), %rdi
callq 0x6a1c
leaq 0x90(%rsp), %rdi
callq 0x6788
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6530
leaq 0x70(%rsp), %rdi
callq 0x6a74
leaq 0x70(%rsp), %rdi
callq 0x6788
movq 0x2ad76(%rip), %rdi     # 0x31fd0
leaq 0x17f1f(%rip), %rsi     # 0x1f180
callq 0x6400
movq %rax, %rdi
callq 0x61c0
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6530
leaq 0x50(%rsp), %rdi
callq 0x6a1c
leaq 0x50(%rsp), %rdi
callq 0x6788
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6530
leaq 0x30(%rsp), %rdi
callq 0x6a74
leaq 0x30(%rsp), %rdi
callq 0x6788
leaq 0x10(%rsp), %rdi
callq 0x6788
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x72f2
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x72f2
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x72f2
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6788
jmp 0x72fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6788
movq %rbx, %rdi
callq 0x6680
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/src/rmd160.c
// Function: MDfinish
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen) {
    dword i; /* counter       */
    dword X[16]; /* message words */

    memset(X, 0, 16 * sizeof(dword));

    /* put bytes from strptr into X */
    for (i = 0; i < (lswlen & 63); i++) {
        /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
        X[i >> 2] ^= (dword) *strptr++ << (8 * (i & 3));
    }

    /* append the bit m_n == 1 */
    X[(lswlen >> 2) & 15] ^= (dword) 1 << (8 * (lswlen & 3) + 7);

    if ((lswlen & 63) > 55) {
        /* length goes to next block */
        compress_(MDbuf, X);
        memset(X, 0, 16 * sizeof(dword));
    }

    /* append length in bits*/
    X[14] = lswlen << 3;
    X[15] = (lswlen >> 29) | (mswlen << 3);
    compress_(MDbuf, X);

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edx, %eax
andl $0x3f, %eax
xorl %edx, %edx
xorl %edi, %edi
cmpl %edi, %eax
je 0x8668
movzbl (%rsi,%rdi), %r8d
movl %edx, %ecx
andb $0x18, %cl
shll %cl, %r8d
movl %edi, %ecx
andl $-0x4, %ecx
xorl %r8d, (%rsp,%rcx)
incq %rdi
addl $0x8, %edx
jmp 0x8646
leal (,%r15,8), %ebp
movl $0x80, %edx
movl %ebp, %ecx
shll %cl, %edx
movl %r15d, %ecx
andl $0x3c, %ecx
xorl %edx, (%rsp,%rcx)
cmpl $0x38, %eax
jb 0x86af
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x7322
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %rsp, %rsi
movl %ebp, 0x38(%rsi)
shldl $0x3, %r15d, %ebx
movl %ebx, 0x3c(%rsi)
movq %r14, %rdi
callq 0x7322
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::ReadData(hlkvds::KVSlice&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Status DS_MultiTier_Impl::ReadData(KVSlice &slice, std::string &data) {
    HashEntry *entry;
    entry = &slice.GetHashEntry();

    TierType tier_type = locateTierFromEntry(entry);
    if (tier_type == TierType::FastTierType) {
        return ft_->ReadData(slice, data);
    }
    return mt_->ReadData(slice, data);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdx), %rax
movq (%rax), %rax
cmpw $0x64, 0x20(%rax)
jne 0x89b8
movq 0x30(%rsi), %rsi
movq %rbx, %rdi
callq 0x1bb0c
jmp 0x89c4
movq 0x38(%rsi), %rsi
movq %rbx, %rdi
callq 0x1c8a8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::GetSBReservedContent(char*, unsigned long)
bool DS_MultiTier_Impl::GetSBReservedContent(char* buf, uint64_t length) {
    if (length != SuperBlockManager::ReservedRegionLength()) {
        return false;
    }
    memset((void*)buf, 0, length);

    char* buf_ptr = buf;
    //Get sbResHeader_
    uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
    memcpy((void*)buf_ptr, (const void*)&sbResHeader_, header_size);
    buf_ptr += header_size;
    __DEBUG("SB_RESERVED_HEADER: sb_reserved_fast_tier_size = %d, sb_reserved_medium_tier_size = %d ",
            sbResHeader_.sb_reserved_fast_tier_size, sbResHeader_.sb_reserved_medium_tier_size);

    //Get FastTier
    if (!ft_->GetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_fast_tier_size)) {
        return false;
    }
    buf_ptr += sbResHeader_.sb_reserved_fast_tier_size;

    //Get MediumTier
    if (!mt_->GetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_medium_tier_size)) {
        return false;
    }

    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0xfc3, %rdx            # imm = 0xFC3
jne 0x8a4f
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfc3, %edx            # imm = 0xFC3
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6250
movq 0x28(%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rbx
movq 0x30(%r14), %rdi
movl 0x28(%r14), %edx
movq %rbx, %rsi
callq 0x1bc40
testb %al, %al
je 0x8a4f
movl 0x28(%r14), %eax
movl 0x2c(%r14), %edx
addq %rax, %rbx
movq 0x38(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ca0c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::SetSBReservedContent(char*, unsigned long)
bool DS_MultiTier_Impl::SetSBReservedContent(char* buf, uint64_t length) {
    if (length != SuperBlockManager::ReservedRegionLength()) {
        return false;
    }

    char* buf_ptr = buf;
    //Set sbResHeader_
    uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
    memcpy((void*)&sbResHeader_, (const void*)buf_ptr, header_size);
    buf_ptr += header_size;
    __DEBUG("SB_RESERVED_HEADER: sb_reserved_fast_tier_size = %d, sb_reserved_medium_tier_size = %d ",
            sbResHeader_.sb_reserved_fast_tier_size, sbResHeader_.sb_reserved_medium_tier_size);

    //Set FastTier
    if (!ft_->SetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_fast_tier_size)) {
        return false;
    }
    buf_ptr += sbResHeader_.sb_reserved_fast_tier_size;

    //Set MediumTier
    if (!mt_->SetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_medium_tier_size)) {
        return false;
    }

    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0xfc3, %rdx            # imm = 0xFC3
jne 0x8aa8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, 0x28(%rdi)
addq $0x8, %rbx
movq 0x30(%rdi), %rdi
movl %eax, %edx
movq %rbx, %rsi
callq 0x1bc8e
testb %al, %al
je 0x8aa8
movl 0x28(%r14), %eax
movl 0x2c(%r14), %edx
addq %rax, %rbx
movq 0x38(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1caea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq