LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: floatCopyToBuffer(imageS*, int, int, float*)
void floatCopyToBuffer(imageP I1, int row, int bufRowsRequired, float *buffer) {
    int height = I1->height;
    int width = I1->width;
    unsigned char *in;
    float *ptr;
    in = I1->image;

    int bufStartIndex = (row % bufRowsRequired) * width;

    ptr = &buffer[bufStartIndex+1];
    for (int x=0; x<width; x++) {
        ptr[0] = in[row*width+x];
        ptr++;
    }
}

// Assembly:
movslq (%rdi), %r9
testq %r9, %r9
jle 0x3204
movl %edx, %r8d
movq 0x8(%rdi), %rdi
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %rdx
imull %r9d, %esi
movslq %esi, %rax
addq %rdi, %rax
leaq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
xorl %edx, %edx
movzbl (%rax,%rdx), %esi
xorps %xmm0, %xmm0
cvtsi2ss %esi, %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r9
jne 0x31ec
retq
// File: /workspace/github_cpp_makefile_star2_O1/brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: copyToBufferPadded(imageS*, int, int, unsigned char*)
void copyToBufferPadded(imageP I1, int row, int bufRowsRequired, unsigned char *buffer) {
    int height = I1->height;
    int width = I1->width;
    unsigned char *in, *ptr;
    in = I1->image;

    int bufStartIndex = (row % bufRowsRequired) * width;

    ptr = &buffer[bufStartIndex];
    for (int x=0; x<width; x++) {
        ptr[0] = in[row*width+x];
        ptr++;
    }
}

// Assembly:
movslq (%rdi), %r9
testq %r9, %r9
jle 0x3240
movl %edx, %r8d
movq 0x8(%rdi), %rdi
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %rax
addq %rax, %rcx
imull %r9d, %esi
movslq %esi, %rax
addq %rdi, %rax
xorl %edx, %edx
movb (%rax,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r9
jne 0x3230
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/errMsg_initList.cc
// Function: error_msg(ErrCode, std::initializer_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void error_msg(ErrCode e, initializer_list<string> il)
{
	cout << e.msg() << ": ";
	for (const auto &elem : il)
		cout << elem << " " ;
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2f3c
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x3b35(%rip), %r15      # 0x5fd8
movq %r15, %rdi
callq 0x2130
leaq 0x1b52(%rip), %rsi      # 0x4004
movl $0x2, %edx
movq %rax, %rdi
callq 0x2130
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24d8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
testq %rbx, %rbx
je 0x251a
shlq $0x5, %rbx
addq %r14, %rbx
movq 0x3aed(%rip), %r12      # 0x5fd8
leaq 0x1b13(%rip), %r13      # 0x4005
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x2130
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x24f2
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x256c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/MurmurHash3.cc
// Function: MurmurHash3_x86_32(void const*, int, unsigned int, void*)
void MurmurHash3_x86_32 ( const void * key, int len,
                          uint32_t seed, void * out )
{
  const uint8_t * data = (const uint8_t*)key;
  const int nblocks = len / 4;

  uint32_t h1 = seed;

  const uint32_t c1 = 0xcc9e2d51;
  const uint32_t c2 = 0x1b873593;

  //----------
  // body

  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);

  for(int i = -nblocks; i; i++)
  {
    uint32_t k1 = getblock32(blocks,i);

    k1 *= c1;
    k1 = ROTL32(k1,15);
    k1 *= c2;
    
    h1 ^= k1;
    h1 = ROTL32(h1,13); 
    h1 = h1*5+0xe6546b64;
  }

  //----------
  // tail

  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);

  uint32_t k1 = 0;

  switch(len & 3)
  {
  case 3: k1 ^= tail[2] << 16;
  case 2: k1 ^= tail[1] << 8;
  case 1: k1 ^= tail[0];
          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
  };

  //----------
  // finalization

  h1 ^= len;

  h1 = fmix32(h1);

  *(uint32_t*)out = h1;
}

// Assembly:
leal 0x3(%rsi), %r9d
testl %esi, %esi
movl %esi, %r8d
cmovsl %r9d, %r8d
movl %r8d, %eax
andl $-0x4, %eax
cltq
addq %rdi, %rax
cmpl $0x7, %r9d
jb 0x5d2a
sarl $0x2, %r8d
negl %r8d
movslq %r8d, %rdi
movl (%rax,%rdi,4), %r8d
imull $0xcc9e2d51, %r8d, %r9d # imm = 0xCC9E2D51
imull $0x16a88000, %r8d, %r8d # imm = 0x16A88000
shrl $0x11, %r9d
orl %r8d, %r9d
imull $0x1b873593, %r9d, %r8d # imm = 0x1B873593
xorl %edx, %r8d
roll $0xd, %r8d
leal (%r8,%r8,4), %edx
addl $0xe6546b64, %edx       # imm = 0xE6546B64
incq %rdi
jne 0x5cf4
movl %esi, %r8d
andl $0x3, %r8d
xorl %edi, %edi
leaq 0x152ca(%rip), %r9      # 0x1b004
movslq (%r9,%r8,4), %r8
addq %r9, %r8
jmpq *%r8
movzbl 0x2(%rax), %edi
shll $0x10, %edi
movzbl 0x1(%rax), %r8d
shll $0x8, %r8d
orl %r8d, %edi
movzbl (%rax), %eax
xorl %edi, %eax
imull $0xcc9e2d51, %eax, %edi # imm = 0xCC9E2D51
imull $0x16a88000, %eax, %eax # imm = 0x16A88000
shrl $0x11, %edi
orl %eax, %edi
imull $0x1b873593, %edi, %eax # imm = 0x1B873593
xorl %eax, %edx
xorl %esi, %edx
movl %edx, %eax
shrl $0x10, %eax
xorl %edx, %eax
imull $0x85ebca6b, %eax, %eax # imm = 0x85EBCA6B
movl %eax, %edx
shrl $0xd, %edx
xorl %eax, %edx
imull $0xc2b2ae35, %edx, %eax # imm = 0xC2B2AE35
movl %eax, %edx
shrl $0x10, %edx
xorl %eax, %edx
movl %edx, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/bloomFilter.cc
// Function: bloomFilter::bloomFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bloomFilter::bloomFilter(std::string bloomFilePath)
  : bloomFilePath(bloomFilePath){
  //Load file into bitset if the bloom file exists.
  struct stat buff;
  if(stat(bloomFilePath.c_str(), &buff) != -1) {
    std::ifstream bloomFile(bloomFilePath);
    // Load the file into the string
    std::string tempStr((std::istreambuf_iterator<char>(bloomFile)),
                        std::istreambuf_iterator<char>());  
    filterArr = std::bitset<FILTER_SIZE>(tempStr);
    bloomFile.close();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a8, %rsp            # imm = 0x7A8
movq %rsi, %r15
movq %rdi, %r14
movl $0x4e8, %edx            # imm = 0x4E8
xorl %esi, %esi
callq 0x5230
leaq 0x4e8(%r14), %rbx
leaq 0x4f8(%r14), %r12
movq %r12, 0x4e8(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6924
movq (%r15), %rdi
leaq 0x230(%rsp), %rsi
callq 0x5340
cmpl $-0x1, %eax
je 0x6437
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x55d0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x110(%rsp,%rax), %rsi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x69b4
leaq 0x2c0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x678e
leaq 0x2c0(%rsp), %rsi
movl $0x4e8, %edx            # imm = 0x4E8
movq %r14, %rdi
callq 0x52e0
leaq 0x28(%rsp), %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x642d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x28(%rsp), %rdi
callq 0x50d0
addq $0x7a8, %rsp            # imm = 0x7A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6448
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6467
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x6467
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x50d0
jmp 0x6476
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x648a
movq (%r12), %rsi
incq %rsi
callq 0x5390
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/bloomFilter.cc
// Function: bloomFilter::writeToFile()
void bloomFilter::writeToFile() {
  // Dump to disk.
	std::ofstream ofs(bloomFilePath);
  if (ofs) {
      ofs << filterArr;
  }
  ofs.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x4e8(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x5700
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x65fd
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x67f2
leaq 0x8(%rsp), %rdi
callq 0x5510
movq 0x1f992(%rip), %rax     # 0x25fa0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x5300
leaq 0x100(%rsp), %rdi
callq 0x5130
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5560
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/bloomFilter.cc
// Function: bloomFilter::possiblyContains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool bloomFilter::possiblyContains(std::string data) {
  auto hashValues = hash(data);
  for (int n = 0; n < NUM_HASHES; n++) {
      if (!filterArr[nthHash(n, hashValues[0], hashValues[1])]) {
          return false;
      }
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6924
movq (%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x28(%rsp), %rcx
xorl %edx, %edx
callq 0x60d8
movq 0x28(%rsp), %r14
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x66c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movabsq $0x346dc5d63886594b, %rcx # imm = 0x346DC5D63886594B
movq %r14, %rax
mulq %rcx
shrq $0xb, %rdx
imulq $0x2710, %rdx, %rax     # imm = 0x2710
movq %r14, %rdx
subq %rax, %rdx
movl %edx, %eax
shrl $0x3, %eax
andl $0x7f8, %eax            # imm = 0x7F8
movq (%rbx,%rax), %rax
btq %rdx, %rax
jae 0x673b
addq %r15, %r14
xorl %eax, %eax
movq %rax, %rsi
movq %r14, %rax
mulq %rcx
cmpq $0x6, %rsi
je 0x6732
shrq $0xb, %rdx
imulq $0x2710, %rdx, %rax     # imm = 0x2710
movq %r14, %rdx
subq %rax, %rdx
movq %rdx, %rax
shrq $0x6, %rax
movq (%rbx,%rax,8), %rdi
addq %r15, %r14
leaq 0x1(%rsi), %rax
btq %rdx, %rdi
jb 0x66fa
cmpq $0x6, %rsi
setae %al
jmp 0x673d
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6763
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/db.cc
// Function: database::readValueFromKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
opStatus database::readValueFromKey(std::string key, 
                                    int clientSocket) {

  auto t_start = std::chrono::high_resolution_clock::now();

  opStatus status = memtableWrapperObjRef->getValueFromKey(key, clientSocket);
  if(status == opStatus::opFail) {
    // Check SSTables
    status = sstableWrapperObjRef->getValueFromKey(key, clientSocket);
  }

  auto t_end = std::chrono::high_resolution_clock::now();
  double time_elapsed_ms =
    std::chrono::duration<double, std::milli>(t_end - t_start).count();
  std::cout << "Get operation performed in "
            << time_elapsed_ms
            << " ms!"
            << std::endl;
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
callq 0x5070
movq %rax, (%rsp)
movq (%r12), %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x6924
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x16f4c
movl %eax, %ebx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x6fb1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
cmpl $0x3, %ebx
jne 0x7001
movq 0x8(%r12), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6924
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19c94
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7001
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
callq 0x5070
subq (%rsp), %rax
cvtsi2sd %rax, %xmm0
divsd 0x14109(%rip), %xmm0    # 0x1b120
movsd %xmm0, (%rsp)
movq 0x1ef9d(%rip), %r14     # 0x25fc0
leaq 0x140fe(%rip), %rsi     # 0x1b128
movl $0x1b, %edx
movq %r14, %rdi
callq 0x5430
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x55c0
movq %rax, %r14
leaq 0x140f6(%rip), %rsi     # 0x1b144
movl $0x4, %edx
movq %rax, %rdi
callq 0x5430
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5280
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x70a5
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x70b5
movq (%r14), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/db.cc
// Function: database::readAllValues(int)
opStatus database::readAllValues(int clientSocket) {
  opStatus memtableStatus = memtableWrapperObjRef->getAllValues(clientSocket);
  if(memtableStatus != opStatus::opSuccess) {
    sendEndMsgToClient(clientSocket);
    return memtableStatus;
  }  
  //List from SSTables
  opStatus sstableStatus = sstableWrapperObjRef->getAllValues(clientSocket);
  if(sstableStatus != opStatus::opSuccess) {
    sendEndMsgToClient(clientSocket);
    return sstableStatus;
  }
  //Sending end message after fetching from memTables and SSTables
  sendEndMsgToClient(clientSocket);

  return opStatus::opSuccess;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x17288
testl %eax, %eax
jne 0x7216
movq 0x8(%r14), %rdi
movl %ebx, %esi
callq 0x19f14
movl %eax, %ebp
movl %ebx, %edi
callq 0x1aa44
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/dbops.cc
// Function: putOp(keyValuePair_t, int, database*)
opStatus putOp(keyValuePair_t keyValuePair, 
               int clientSocket, 
               database* dbObject) {
  std::cout << "Putting key = <"
            << keyValuePair.key << ">, value = <"
            << keyValuePair.value << "> ..." << std::endl;
  return dbObject->writeKeyValuePair(keyValuePair, clientSocket);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq 0x1e62c(%rip), %r12     # 0x25fc0
leaq 0x13967(%rip), %rsi     # 0x1b302
movl $0xf, %edx
movq %r12, %rdi
callq 0x5430
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x5430
movq %rax, %r12
leaq 0x13951(%rip), %rsi     # 0x1b312
movl $0xc, %edx
movq %rax, %rdi
callq 0x5430
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x5430
movq %rax, %r12
leaq 0x13937(%rip), %rsi     # 0x1b31f
movl $0x5, %edx
movq %rax, %rdi
callq 0x5430
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5280
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6924
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
callq 0x6924
movq %rsp, %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x6e5a
movl %eax, %ebx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x7a7d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5390
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7a93
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7278
jmp 0x7ac9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7ac9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/dbops.cc
// Function: deleteOp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, database*)
opStatus deleteOp(std::string key, int clientSocket, database* dbObject) {
  std::cout << "Deleting key <" 
            << key 
            << "> from the database ... " 
            << std::endl;
  return dbObject->deleteKey(key, clientSocket);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq 0x1e0b2(%rip), %r12     # 0x25fc0
leaq 0x1343e(%rip), %rsi     # 0x1b353
movl $0xe, %edx
movq %r12, %rdi
callq 0x5430
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x5430
movq %rax, %r12
leaq 0x13427(%rip), %rsi     # 0x1b362
movl $0x18, %edx
movq %rax, %rdi
callq 0x5430
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5280
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6924
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x70be
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7fb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7fdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtable.cc
// Function: memtable::putKeyValuePair(keyValuePair_t)
void memtable::putKeyValuePair(keyValuePair_t keyValuePair) {
  bool isKeyPresent = this->isKeyPresent(keyValuePair.key);
  table[keyValuePair.key] = keyValuePair.value;
  // Increase size only on addition of a new key, and not on update.
  if(!isKeyPresent) {
    ++size;
  }
  // Log into the journal
  journalWritefd << (unsigned char)(keyValuePair.key.length())
                 << keyValuePair.key.c_str()
                 << (unsigned char)(keyValuePair.value.length())
                 << keyValuePair.value.c_str();
  journalWritefd.flush();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x6924
movq %rbx, %rdi
movq %r15, %rsi
callq 0x164ea
movq %rax, %r15
leaq 0x8(%rbx), %r13
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x15bfd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x20(%r14), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15ff0
movq %rax, %rdi
movq %r12, %rsi
callq 0x5220
cmpq %r13, %r15
jne 0x15c1f
incl 0x30(%rbx)
addq $0x60, %rbx
movb 0x8(%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5430
movq %rax, %r15
movq (%r14), %r12
testq %r12, %r12
je 0x15c5e
movq %r12, %rdi
callq 0x51c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5430
jmp 0x15c78
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x5620
movb 0x28(%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x15cb4
movq %r14, %rdi
callq 0x51c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5430
jmp 0x15cce
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x5620
movq %rbx, %rdi
callq 0x5280
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x15cfe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtable.cc
// Function: memtable::getAllValues(int)
void memtable::getAllValues(int clientSocket) {
  std::map<std::string, std::string>::iterator it;
  for(it=table.begin();it!=table.end();it++){
    std::string ret = it->first+" -------> "+it->second+"\n";
    sendToClient(clientSocket, ret);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x15efd
leaq 0x58(%rsp), %rbx
leaq 0x38(%rsp), %r13
leaq 0x8(%rsp), %r12
leaq 0x68(%rsp), %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x6924
movq %r12, %rdi
leaq 0x643f(%rip), %rsi      # 0x1c1ed
callq 0x56f0
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
movq %r12, %rdi
callq 0x5100
movq %rbx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x15de6
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x15dec
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x55d3(%rip), %rsi      # 0x1b3e3
callq 0x56f0
movq %r13, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x15e38
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x15e40
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x15e6f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15e8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x6924
movl 0x4(%rsp), %edi
movq %rbp, %rsi
callq 0x1aa0a
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x15ed2
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x15ee9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %r15, %rdi
callq 0x5290
movq %rax, %r15
cmpq %r14, %rax
jne 0x15d87
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15f11
movq %rax, %r14
jmp 0x15f30
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x15f30
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15f81
movq 0x18(%rsp), %rsi
jmp 0x15f79
movq %rax, %r14
jmp 0x15f6a
movq %rax, %r14
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x15f6a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x15f81
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtableWrapper.cc
// Function: memtableWrapper::memtableWrapper(int)
memtableWrapper::memtableWrapper(int lastMemtableID)
  : writeMutex(PTHREAD_MUTEX_INITIALIZER) {
  // Inserting atleast one memtableObject
  memtable* memtableObjPointer = new memtable(0, 
                                              MAX_MEMTABLE_SIZE, 
                                              lastMemtableID);
  memtableObjPointersList.push_back(memtableObjPointer);
  this->lastMemtableID = lastMemtableID;
  index = memtableObjPointersList.begin();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq $0x0, 0x40(%rdi)
movl $0x260, %edi            # imm = 0x260
callq 0x5380
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
movl %ebp, %ecx
callq 0x1563c
movl $0x18, %edi
callq 0x5380
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5080
incq 0x10(%rbx)
movl %ebp, 0x48(%rbx)
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x260, %esi            # imm = 0x260
movq %r15, %rdi
callq 0x5390
jmp 0x165bf
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x165dc
movq (%rdi), %r15
movl $0x18, %esi
callq 0x5390
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x165c7
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtableWrapper.cc
// Function: memtableWrapper::writeMemtableToDisk(std::_List_iterator<memtable*>, sstableWrapper*, memtableWrapper*)
void memtableWrapper::writeMemtableToDisk(std::list<memtable*>::iterator iter,
    sstableWrapper* sstableWrapperObjRef, memtableWrapper* thisObj) {
  std::cout << "Dumping memtable "
            << "ID: " << (*iter)->memtableID
            << " to disk..." << std::endl;
  sstableWrapperObjRef->dumpMemtableToSSTable(*iter);
  //std::this_thread::sleep_for(std::chrono::seconds(20));
  //Delete index from list.
  memtable* memtableObj = *iter;
  thisObj->memtableObjPointersList.erase(iter);
  // Erase the journal file and then delete the object
  std::remove(memtableObj->journalFilePath.c_str());
  delete memtableObj;
  std::cout << "Dumped memtable." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0xf6d3(%rip), %rbx      # 0x25fc0
leaq 0x5a65(%rip), %rsi      # 0x1c359
movl $0x11, %edx
movq %rbx, %rdi
callq 0x5430
leaq 0x5a63(%rip), %rsi      # 0x1c36b
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5430
movq 0x10(%r14), %rax
movl 0x38(%rax), %esi
movq %rbx, %rdi
callq 0x5650
movq %rax, %r13
leaq 0x5a42(%rip), %rsi      # 0x1c370
movl $0xb, %edx
movq %rax, %rdi
callq 0x5430
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r13, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5280
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq 0x19500
movq 0x10(%r14), %r12
decq 0x10(%r15)
movq %r14, %rdi
callq 0x55f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x5390
movq 0x40(%r12), %rdi
callq 0x5690
testq %r12, %r12
je 0x169b0
movq %r12, %rdi
callq 0x15f8a
movl $0x260, %esi            # imm = 0x260
movq %r12, %rdi
callq 0x5390
leaq 0x59c5(%rip), %rsi      # 0x1c37c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x5430
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtableWrapper.cc
// Function: memtableWrapper::getAllValues(int)
opStatus memtableWrapper::getAllValues(int clientSocket) {
  std::list<memtable*>::iterator iter;
  for(iter = index; iter != memtableObjPointersList.begin(); iter--) {
    (*iter)->getAllValues(clientSocket);
  }
  // Checking in the memtable at the head of the list.
  (*iter)->getAllValues(clientSocket);
  return opStatus::opSuccess;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x18(%rdi), %r15
cmpq %r15, (%rdi)
je 0x172af
movq %rdi, %r14
movq 0x10(%r15), %rdi
movl %ebx, %esi
callq 0x15d4a
movq 0x8(%r15), %r15
cmpq (%r14), %r15
jne 0x1729b
movq 0x10(%r15), %rdi
movl %ebx, %esi
callq 0x15d4a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/memtableWrapper.cc
// Function: memtableWrapper::~memtableWrapper()
memtableWrapper::~memtableWrapper() {
  std::list<memtable*>::iterator iter;
  for(iter = memtableObjPointersList.begin(); 
      iter != memtableObjPointersList.end();
      ++iter) {
    delete *iter;
  }
  memtableObjPointersList.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
cmpq %rdi, %r15
je 0x172f8
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x172f0
movq %r14, %rdi
callq 0x15f8a
movl $0x260, %esi            # imm = 0x260
movq %r14, %rdi
callq 0x5390
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x172d2
movq %rbx, %rdi
callq 0x173d2
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1731d
movq (%rdi), %r14
movl $0x18, %esi
callq 0x5390
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x17308
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/sstable.cc
// Function: sstable::sstable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
sstable::sstable(std::string filePath, 
                 std::string bloomFilePath,
                 std::string indexFilePath)
  : filePath(filePath),
    no_bytes(0),
    total_blocks(-1){
  
  // Bloom filter object  
  filter = new bloomFilter(bloomFilePath);
  
  struct stat buff;
  // Check if index present
  if(stat(indexFilePath.c_str(), &buff) != -1) {
    loadIndexInMemory();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x38(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x6924
leaq 0x58(%rbx), %r12
movq %r12, %rdi
movq %r15, 0x10(%rsp)
callq 0x5630
movq %r12, 0x8(%rsp)
leaq 0x258(%rbx), %r12
movq %r12, %rdi
callq 0x5630
movq $0x0, 0x458(%rbx)
movl $0xffffffff, 0x460(%rbx) # imm = 0xFFFFFFFF
movl $0x508, %edi            # imm = 0x508
callq 0x5380
movq %rax, %rbp
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x6924
leaq 0x18(%rsp), %rsi
movq %rbp, %rdi
callq 0x6340
movq %rbp, 0x30(%rbx)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x17664
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
movq (%r13), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5340
cmpl $-0x1, %eax
je 0x1767f
movq %rbx, %rdi
callq 0x17712
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x176c1
movq %rax, %r13
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x176b2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x176b2
movq %rax, %r13
movl $0x508, %esi            # imm = 0x508
movq %rbp, %rdi
callq 0x5390
jmp 0x176c4
movq %rax, %r13
movq %r12, %rdi
callq 0x5560
jmp 0x176d1
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x5560
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x17702
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5390
jmp 0x17702
movq %rax, %r13
jmp 0x176db
movq %rax, %r13
movq %rbx, %rdi
callq 0x185ec
movq %r13, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/sstableWrapper.cc
// Function: sstableWrapper::getAllValues(int)
opStatus sstableWrapper::getAllValues(int clientSocket) {
  std::list<sstable*>::reverse_iterator iter;
  int count = 0;
  for(iter = sstableObjRefList.rbegin();
      iter != sstableObjRefList.rend();
      ++iter) {
    ++count;
    opStatus ret = (*iter)->getAllValues(clientSocket);
  }
  std::cout << "Listed " << count << " SSTables!" << std::endl;
  return opStatus::opSuccess;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x19f48
movl %esi, %ebp
xorl %ebx, %ebx
movq %r14, %r15
incl %ebx
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movl %ebp, %esi
callq 0x180ea
movq 0x8(%r15), %r15
cmpq (%r14), %r15
jne 0x19f2c
jmp 0x19f4a
xorl %ebx, %ebx
movq 0xc06f(%rip), %r14      # 0x25fc0
leaq 0x264a(%rip), %rsi      # 0x1c5a2
movl $0x7, %edx
movq %r14, %rdi
callq 0x5430
movq %r14, %rdi
movl %ebx, %esi
callq 0x5650
movq %rax, %rbx
leaq 0x2631(%rip), %rsi      # 0x1c5aa
movl $0xa, %edx
movq %rax, %rdi
callq 0x5430
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5280
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/sstableWrapper.cc
// Function: sstableWrapper::~sstableWrapper()
sstableWrapper::~sstableWrapper() {
  std::list<sstable*>::iterator iter;
  for(iter = sstableObjRefList.begin();
      iter != sstableObjRefList.end();
      ++iter) {
    delete *iter;
  }
  delete sstable_no;
  sstableObjRefList.clear(); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq %rbx, %r12
je 0x19ff7
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x19ff1
movq %r15, %rdi
callq 0x184ca
movl $0x468, %esi            # imm = 0x468
movq %r15, %rdi
callq 0x5390
movq (%r12), %r12
jmp 0x19fcd
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a009
movl $0x4, %esi
callq 0x5390
movq %rbx, %rdi
callq 0x1a03a
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1a02e
movq (%rdi), %r14
movl $0x18, %esi
callq 0x5390
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x1a019
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/utils.cc
// Function: getKeyValuePair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
keyValuePair_t getKeyValuePair(std::string inBuffer) {
  int i = 0;
  // Operator
  while(inBuffer[i] != '<') {
    ++i;
  }
  // Key
  std::string key = "";
  ++i;
  while(inBuffer[i] != '>') {
    key += inBuffer[i];
    ++i;
  }
  // Value
  std::string value = "";
  while(inBuffer[i] != '<') {
    ++i;
  }
  ++i;
  while(inBuffer[i] != '>') {
    value += inBuffer[i];
    ++i;
  }
  return keyValuePair_t(key, value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
xorl %ebp, %ebp
cmpb $0x3c, (%rax,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x1a094
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1335(%rip), %rdx      # 0x1b3e4
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7326
movq (%r14), %rax
movb (%rax,%rbp), %al
cmpb $0x3e, %al
je 0x1a0d9
incq %rbp
movsbl %al, %esi
movq %r15, %rdi
callq 0x5310
jmp 0x1a0bf
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x12fb(%rip), %rdx      # 0x1b3e4
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x7326
movq (%r14), %rax
cmpb $0x3c, (%rax,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x1a0f9
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movb (%rax,%rbp), %al
cmpb $0x3e, %al
je 0x1a122
incq %rbp
movsbl %al, %esi
movq %r15, %rdi
callq 0x5310
jmp 0x1a108
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x6924
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x6924
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x72ae
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a18b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a1a2
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a1b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a1d0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a204
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x1a204
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a224
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x1a224
jmp 0x1a221
jmp 0x1a23d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a240
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x1a240
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a257
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/dbengine/utils.cc
// Function: getKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string getKey(std::string inBuffer) {
  int i = 0;
  // Operator
  while(inBuffer[i] != '<') {
    ++i;
  }
  // Key
  std::string key = "";
  ++i;
  while(inBuffer[i] != '>') {
    key += inBuffer[i];
    ++i;
  }
  return key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
xorl %r12d, %r12d
cmpb $0x3c, (%rax,%r12)
leaq 0x1(%r12), %r12
jne 0x1a273
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
leaq 0x1157(%rip), %rdx      # 0x1b3e4
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7326
movq (%r14), %rax
movb (%rax,%r12), %al
cmpb $0x3e, %al
je 0x1a2b3
incq %r12
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5310
jmp 0x1a298
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1a2d8
movq (%r15), %rsi
incq %rsi
callq 0x5390
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/serverCode/server.cc
// Function: thread_function(void*)
void* thread_function(void* arg) {
  int* pclient;
  while(true) {
    pclient = NULL;

    pthread_mutex_lock(&mutex);
    if(conn_queue.size() == 0) {
      // The thread waits until it is signaled to wake up. The lock (mutex) is
      // also released meanwhile, and when signaled the thread first acquires
      // lock and then only returns here to continue execution.
      pthread_cond_wait(&condition_var, &mutex);
    }
    // Now there is a request in the queue to be handled.
    pclient = conn_queue.front();
    conn_queue.pop();
    pthread_mutex_unlock(&mutex);

    if(pclient != NULL) {
      handle_connection(pclient);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc3df(%rip), %rbx      # 0x268c0
leaq 0xc400(%rip), %r14      # 0x268e8
leaq 0xc381(%rip), %r15      # 0x26870
movq %rbx, %rdi
callq 0x5550
movq 0xc3ba(%rip), %rax      # 0x268b8
movq %rax, %rcx
subq 0xc390(%rip), %rcx      # 0x26898
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0xc385(%rip), %rax      # 0x268a0
subq 0xc386(%rip), %rax      # 0x268a8
shlq $0x6, %rcx
sarq $0x3, %rax
addq %rcx, %rax
movq 0xc35c(%rip), %rcx      # 0x26890
subq 0xc345(%rip), %rcx      # 0x26880
sarq $0x3, %rcx
addq %rax, %rcx
jne 0x1a54f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5580
movq 0xc32a(%rip), %rax      # 0x26880
movq (%rax), %r12
movq %r15, %rdi
callq 0x1af66
movq %rbx, %rdi
callq 0x52c0
testq %r12, %r12
je 0x1a4ef
movq %r12, %rdi
callq 0x1a58c
jmp 0x1a4ef
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/serverCode/server.cc
// Function: sendWelcomeMessage(int)
void sendWelcomeMessage(int client_socket) {
  std::string welcome;
  
  welcome = "*************************************************************\n";
  welcome += "*                Welcome to myDB Engine                     *\n";
  welcome += "*        Created by : Prakhar Sinha, Shorya Jain            *\n";
  welcome += "*        (Type exit to terminate the connection)            *\n";
  welcome += "*************************************************************\n"; 
  
  write(client_socket, &welcome[0], strlen(welcome.c_str()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x1ce6(%rip), %rcx      # 0x1c648
movq %rsp, %rdi
movl $0x3e, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x55b0
leaq 0x1d0c(%rip), %rsi      # 0x1c687
movq %rsp, %rdi
callq 0x56f0
leaq 0x1d3c(%rip), %rsi      # 0x1c6c6
movq %rsp, %rdi
callq 0x56f0
leaq 0x1d6c(%rip), %rsi      # 0x1c705
movq %rsp, %rdi
callq 0x56f0
leaq 0x1ca0(%rip), %rsi      # 0x1c648
movq %rsp, %rdi
callq 0x56f0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x51c0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5140
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1a9df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1aa02
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/prakhar2808[P]DBEngine/serverCode/server.cc
// Function: sendGoodByeMessage(int)
void sendGoodByeMessage(int client_socket) {
  std::string goodBye;
  
  goodBye = "*************************************************************\n";
  goodBye += "*                       Good Bye!                           *\n";
  goodBye += "*************************************************************\n";

  write(client_socket, &goodBye[0], strlen(goodBye.c_str()));  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x1b65(%rip), %rcx      # 0x1c648
movq %rsp, %rdi
movl $0x3e, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x55b0
leaq 0x1c48(%rip), %rsi      # 0x1c744
movq %rsp, %rdi
callq 0x56f0
leaq 0x1b3d(%rip), %rsi      # 0x1c648
movq %rsp, %rdi
callq 0x56f0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x51c0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5140
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1ab42
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1ab65
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/NishadSaraf[P]Championship-Simulator/src/cache.cc
// Function: CACHE::add_mshr(PACKET*)
void CACHE::add_mshr(PACKET *packet)
{
    uint32_t index = 0;

    // search mshr
    for (index=0; index<MSHR_SIZE; index++) {
        if (MSHR.entry[index].address == 0) {
            
            memcpy(&MSHR.entry[index], packet, sizeof(PACKET));
            MSHR.entry[index].returned = INFLIGHT;
            MSHR.occupancy++;

            DP ( if (warmup_complete[packet->cpu]) {
            cout << "[" << NAME << "_MSHR] " << __func__ << " instr_id: " << packet->instr_id;
            cout << " address: " << hex << packet->address << " full_addr: " << packet->full_addr << dec;
            cout << " index: " << index << " occupancy: " << MSHR.occupancy << endl; });

            break;
        }
    }
}

// Assembly:
movl 0x7388(%rdi), %eax
testl %eax, %eax
je 0x4b9b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xca20(%rdi), %rdi
xorl %r14d, %r14d
cmpq $0x0, 0x340(%rdi,%r14)
je 0x4b71
addq $0x380, %r14            # imm = 0x380
decl %eax
jne 0x4b59
jmp 0x4b94
addq %r14, %rdi
movl $0x380, %edx            # imm = 0x380
callq 0x31c0
movq 0xca20(%rbx), %rax
movb $0x1, 0x32c(%rax,%r14)
incl 0xc9bc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/NishadSaraf[P]Championship-Simulator/src/cache.cc
// Function: CACHE::operate()
void CACHE::operate()
{
    handle_fill();
    handle_writeback();
    handle_read();

    if (PQ.occupancy && (RQ.occupancy == 0))
        handle_prefetch();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x392c
movq %rbx, %rdi
callq 0x4188
movq %rbx, %rdi
callq 0x4b9c
cmpl $0x0, 0xad1c(%rbx)
je 0x58e2
cmpl $0x0, 0x907c(%rbx)
jne 0x58e2
movq %rbx, %rdi
popq %rbx
jmp 0x546e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/NishadSaraf[P]Championship-Simulator/src/cache.cc
// Function: CACHE::invalidate_entry(unsigned long)
int CACHE::invalidate_entry(uint64_t inval_addr)
{
    uint32_t set = get_set(inval_addr);
    int match_way = -1;

    if (NUM_SET < set) {
        cerr << "[" << NAME << "_ERROR] " << __func__ << " invalid set index: " << set << " NUM_SET: " << NUM_SET;
        cerr << " inval_addr: " << hex << inval_addr << dec << endl;
        assert(0);
    }

    // invalidate
    for (uint32_t way=0; way<NUM_WAY; way++) {
        if (block[set][way].valid && (block[set][way].tag == inval_addr)) {

            block[set][way].valid = 0;

            match_way = way;

            DP ( if (warmup_complete[cpu]) {
            cout << "[" << NAME << "] " << __func__ << " inval_addr: " << hex << inval_addr;  
            cout << " tag: " << block[set][way].tag << " data: " << block[set][way].data << dec;
            cout << " set: " << set << " way: " << way << " lru: " << block[set][way].lru << " cycle: " << current_core_cycle[cpu] << endl; });

            break;
        }
    }

    return match_way;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x7370(%rdi), %edi
callq 0x9196
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
movl %ebx, %ebp
andl %edx, %ebp
cmpl %ebp, 0x7370(%r14)
jb 0x599b
movl 0x7374(%r14), %ecx
testq %rcx, %rcx
je 0x5990
movq 0x7390(%r14), %rdx
movl %ebp, %esi
movq (%rdx,%rsi,8), %rsi
xorl %edx, %edx
cmpb $0x0, (%rsi)
je 0x597d
cmpq %rbx, 0x28(%rsi)
je 0x598b
incq %rdx
addq $0x50, %rsi
cmpq %rdx, %rcx
jne 0x5972
jmp 0x5990
movb $0x0, (%rsi)
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1464e(%rip), %r15     # 0x19ff0
leaq 0xe6e7(%rip), %rsi      # 0x14090
movq %r15, %rdi
callq 0x3250
leaq 0x7350(%r14), %rsi
movq %rax, %rdi
callq 0x31e0
leaq 0xf31f(%rip), %rsi      # 0x14ce6
movq %rax, %rdi
callq 0x3250
leaq 0xe7ed(%rip), %rsi      # 0x141c3
movq %rax, %rdi
callq 0x3250
leaq 0xe77e(%rip), %rsi      # 0x14163
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
movl %ebp, %esi
callq 0x32d0
leaq 0xe77a(%rip), %rsi      # 0x14178
movq %rax, %rdi
callq 0x3250
movl 0x7370(%r14), %esi
movq %rax, %rdi
callq 0x32d0
leaq 0xe7b8(%rip), %rsi      # 0x141d4
movq %r15, %rdi
callq 0x3250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
callq 0x3110
leaq 0xe5ff(%rip), %rdi      # 0x14067
leaq 0xe5fa(%rip), %rsi      # 0x14069
leaq 0xe76c(%rip), %rcx      # 0x141e2
movl $0x389, %edx            # imm = 0x389
callq 0x3160