LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
imull -0x20(%rbp), %edx
movl %edx, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x262e
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x20(%rbp), %ecx
addl -0x38(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x25f5
popq %rbp
retq
// File: brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: fclip(float)
float fclip(float a) {
    if (a >= 255.0) {
        return 255.0;
    } else if (a <= 0.0) {
        return 0.0;
    } else {
        return a;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x8f6(%rip), %xmm1      # 0x3010
ucomisd %xmm1, %xmm0
jb 0x272f
movss 0x9bc(%rip), %xmm0      # 0x30e4
movss %xmm0, -0x4(%rbp)
jmp 0x2755
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x274b
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x2755
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x3520
movq -0x78(%rbp), %rsi
movq 0x4c66(%rip), %rdi      # 0x6fd8
callq 0x20f0
movq %rax, -0x70(%rbp)
jmp 0x237d
movq -0x70(%rbp), %rdi
leaq 0x2c7c(%rip), %rsi      # 0x5004
callq 0x2100
jmp 0x238f
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x35f0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3610
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0x2410
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movq 0x4c01(%rip), %rdi      # 0x6fd8
callq 0x20f0
movq %rax, %rdi
leaq 0x2c1f(%rip), %rsi      # 0x5005
callq 0x2100
movq -0x58(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
jmp 0x23ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x242c
movq 0x4bc1(%rip), %rdi      # 0x6fd8
movq 0x4baa(%rip), %rsi      # 0x6fc8
callq 0x2140
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x810, %rsp            # imm = 0x810
movq %rsi, -0x7f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x800(%rbp)
callq 0x83a0
movq -0x800(%rbp), %rdi
movq -0x7f0(%rbp), %rsi
addq $0x4e8, %rdi            # imm = 0x4E8
movq %rdi, -0x7f8(%rbp)
callq 0x6210
movq -0x7f0(%rbp), %rdi
callq 0x61f0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6490
cmpl $-0x1, %eax
je 0x7f70
movq -0x7f0(%rbp), %rsi
leaq -0x2a8(%rbp), %rdi
movl $0x8, %edx
callq 0x67d0
jmp 0x7e49
leaq -0x2e8(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
callq 0x83c0
leaq -0x2f8(%rbp), %rdi
callq 0x8420
leaq -0x2f9(%rbp), %rdi
movq %rdi, -0x808(%rbp)
callq 0x68d0
movq -0x808(%rbp), %r9
movq -0x2e8(%rbp), %rsi
movl -0x2e0(%rbp), %edx
movq -0x2f8(%rbp), %rcx
movl -0x2f0(%rbp), %r8d
leaq -0x2d8(%rbp), %rdi
callq 0x8450
jmp 0x7eab
leaq -0x2f9(%rbp), %rdi
callq 0x6560
xorl %eax, %eax
movl %eax, %edx
leaq -0x7e8(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x84e0
jmp 0x7ed0
movq -0x800(%rbp), %rdi
leaq -0x7e8(%rbp), %rsi
movl $0x4e8, %edx            # imm = 0x4E8
callq 0x6420
leaq -0x2a8(%rbp), %rdi
callq 0x60f0
jmp 0x7ef6
leaq -0x2d8(%rbp), %rdi
callq 0x6340
leaq -0x2a8(%rbp), %rdi
callq 0x6130
jmp 0x7f70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
jmp 0x7f79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x2f9(%rbp), %rdi
callq 0x6560
jmp 0x7f62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x2d8(%rbp), %rdi
callq 0x6340
leaq -0x2a8(%rbp), %rdi
callq 0x6130
jmp 0x7f79
addq $0x810, %rsp            # imm = 0x810
popq %rbp
retq
movq -0x7f8(%rbp), %rdi
callq 0x6340
movq -0x2b0(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x220(%rbp)
addq $0x4e8, %rsi            # imm = 0x4E8
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x6970
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x6650
movb %al, -0x215(%rbp)
jmp 0x81b2
movb -0x215(%rbp), %al
testb $0x1, %al
jne 0x81be
jmp 0x81f5
movq -0x220(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x8650
jmp 0x81d3
jmp 0x81f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x6760
jmp 0x8218
leaq -0x208(%rbp), %rdi
callq 0x6710
jmp 0x8203
leaq -0x208(%rbp), %rdi
callq 0x6760
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6210
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x7fa0
movq %rdx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x8275
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6340
movl $0x0, -0x58(%rbp)
cmpl $0x7, -0x58(%rbp)
jge 0x8355
movl -0x58(%rbp), %eax
movb %al, -0x8a(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x85a0
movq (%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x85a0
movq -0x98(%rbp), %rdx
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movb -0x8a(%rbp), %al
movq (%rcx), %rcx
movzbl %al, %esi
callq 0x8000
movq -0x88(%rbp), %rsi
movq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x8560
leaq -0x68(%rbp), %rdi
callq 0x8750
xorb $-0x1, %al
movb %al, -0x89(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8640
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x8328
jmp 0x8345
movb $0x0, -0x1(%rbp)
jmp 0x8359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6340
jmp 0x8367
jmp 0x8347
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x8295
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68c0
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x6090
movq -0xc0(%rbp), %rsi
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6210
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x36640
movl %eax, -0x9c(%rbp)
jmp 0x94ba
leaq -0x48(%rbp), %rdi
callq 0x6340
movl -0x9c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jne 0x9565
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6210
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3c2c0
movl %eax, -0xc4(%rbp)
jmp 0x951d
movl -0xc4(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6340
jmp 0x9565
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6340
jmp 0x95f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6340
jmp 0x95f6
callq 0x6090
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x98c0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x9910
leaq -0x90(%rbp), %rdi
callq 0x9950
movsd %xmm0, -0x88(%rbp)
movq 0x55a10(%rip), %rdi     # 0x5efc0
leaq 0x36b31(%rip), %rsi     # 0x400e8
callq 0x64e0
movq %rax, %rdi
movsd -0x88(%rbp), %xmm0
callq 0x6950
movq %rax, %rdi
leaq 0x36b2e(%rip), %rsi     # 0x40104
callq 0x64e0
movq %rax, %rdi
movq 0x559ab(%rip), %rsi     # 0x5ef90
callq 0x6540
movl -0x24(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68c0
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x36a70
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x977b
movl -0x14(%rbp), %edi
callq 0x3e410
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x97b3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x3c550
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x97a4
movl -0x14(%rbp), %edi
callq 0x3e410
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x97b3
movl -0x14(%rbp), %edi
callq 0x3e410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x54b9f(%rip), %rdi     # 0x5efc0
leaq 0x35f46(%rip), %rsi     # 0x4036e
callq 0x64e0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x6480
movq %rax, %rdi
leaq 0x35f3b(%rip), %rsi     # 0x4037e
callq 0x64e0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x6480
movq %rax, %rdi
leaq 0x35f29(%rip), %rsi     # 0x4038b
callq 0x64e0
movq %rax, %rdi
movq 0x54b1f(%rip), %rsi     # 0x5ef90
callq 0x6540
movq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9830
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x9380
movl %eax, -0x68(%rbp)
jmp 0xa4a4
leaq -0x58(%rbp), %rdi
callq 0x9890
movl -0x68(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9890
movq -0x60(%rbp), %rdi
callq 0x68c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x54752(%rip), %rdi     # 0x5efc0
leaq 0x35b4a(%rip), %rsi     # 0x403bf
callq 0x64e0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x6480
movq %rax, %rdi
leaq 0x35b3e(%rip), %rsi     # 0x403ce
callq 0x64e0
movq %rax, %rdi
movq 0x546f1(%rip), %rsi     # 0x5ef90
callq 0x6540
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6210
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x9600
movl %eax, -0x48(%rbp)
jmp 0xa8d2
leaq -0x38(%rbp), %rdi
callq 0x6340
movl -0x48(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6340
movq -0x40(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6210
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x33fa0
movb %al, -0x45(%rbp)
jmp 0x33e9e
leaq -0x38(%rbp), %rdi
callq 0x6340
movb -0x45(%rbp), %al
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x68(%rbp)
callq 0x34480
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x6070
testb $0x1, -0x11(%rbp)
jne 0x33f02
movq -0x58(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x33f02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6340
jmp 0x33f92
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rdi
addq $0x60, %rax
movq %rax, -0x88(%rbp)
callq 0x6780
movq -0x88(%rbp), %rdi
movzbl %al, %esi
callq 0x67a0
movq -0x60(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x61f0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x64e0
movq -0x60(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x20, %rdi
callq 0x6780
movq -0x78(%rbp), %rdi
movzbl %al, %esi
callq 0x67a0
movq -0x60(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x20, %rdi
callq 0x61f0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x64e0
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
callq 0x6390
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x68c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x34610
movq -0xc8(%rbp), %rdi
callq 0x34630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x345e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34580
testb $0x1, %al
jne 0x340b4
jmp 0x34206
leaq -0x18(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x34730
movq %rax, %rsi
leaq 0xd187(%rip), %rdx      # 0x41255
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x346b0
movq -0xd8(%rbp), %rdi
callq 0x34730
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x68(%rbp), %rdi
callq 0x34660
jmp 0x34106
leaq 0xd570(%rip), %rdx      # 0x4167d
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x34290
jmp 0x3411c
leaq -0x68(%rbp), %rdi
callq 0x6340
leaq -0x88(%rbp), %rdi
callq 0x6340
movl -0xc(%rbp), %eax
movl %eax, -0xdc(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6210
jmp 0x3414c
movl -0xdc(%rbp), %edi
leaq -0xb8(%rbp), %rsi
callq 0x3e3a0
jmp 0x34160
leaq -0xb8(%rbp), %rdi
callq 0x6340
leaq -0x48(%rbp), %rdi
callq 0x6340
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x34750
movq %rax, -0xc0(%rbp)
jmp 0x3408e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x341bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6340
leaq -0x88(%rbp), %rdi
callq 0x6340
jmp 0x3420f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x341fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x6340
leaq -0x48(%rbp), %rdi
callq 0x6340
jmp 0x3420f
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x68c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x36bb0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x36bd0
movq -0x40(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x40(%rax)
movl $0x0, 0x30(%rax)
movl $0x260, %edi            # imm = 0x260
callq 0x64f0
movq %rax, -0x38(%rbp)
jmp 0x35d8e
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %ecx
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x33940
jmp 0x35da3
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x36bf0
jmp 0x35dba
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x48(%rdi)
callq 0x36c30
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35e0a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x260, %esi            # imm = 0x260
callq 0x6500
movq -0x40(%rbp), %rdi
callq 0x36c60
movq -0x20(%rbp), %rdi
callq 0x68c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x28e45(%rip), %rdi     # 0x5efc0
leaq 0xb237(%rip), %rsi      # 0x413b9
callq 0x64e0
movq %rax, %rdi
leaq 0xb23a(%rip), %rsi      # 0x413cb
callq 0x64e0
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x36c80
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movl 0x38(%rax), %esi
callq 0x6880
movq %rax, %rdi
leaq 0xb214(%rip), %rsi      # 0x413d0
callq 0x64e0
movq %rax, %rdi
movq 0x28dc5(%rip), %rsi     # 0x5ef90
callq 0x6540
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x36c80
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x3bc90
leaq -0x8(%rbp), %rdi
callq 0x36c80
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x36f70
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x36f20
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x61f0
movq %rax, %rdi
callq 0x68f0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3625d
movq -0x38(%rbp), %rdi
callq 0x34220
movq -0x38(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
callq 0x6500
movq 0x28d5c(%rip), %rdi     # 0x5efc0
leaq 0xb171(%rip), %rsi      # 0x413dc
callq 0x64e0
movq %rax, %rdi
movq 0x28d16(%rip), %rsi     # 0x5ef90
callq 0x6540
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x36bd0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x36c30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36ec0
testb $0x1, %al
jne 0x36abc
jmp 0x36ae1
leaq -0x18(%rbp), %rdi
callq 0x36c80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x34050
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x36ef0
movq %rax, -0x28(%rbp)
jmp 0x36a9c
leaq -0x18(%rbp), %rdi
callq 0x36c80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x34050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x36bd0
movq -0x28(%rbp), %rdi
callq 0x36c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x36f90
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36ec0
testb $0x1, %al
jne 0x36b52
jmp 0x36b8c
leaq -0x10(%rbp), %rdi
callq 0x36c80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x36b7f
movq -0x30(%rbp), %rdi
callq 0x34220
movq -0x30(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
callq 0x6500
jmp 0x36b81
leaq -0x10(%rbp), %rdi
callq 0x36da0
jmp 0x36b32
movq -0x28(%rbp), %rdi
callq 0x36fc0
movq -0x28(%rbp), %rdi
callq 0x36c60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdx, -0x118(%rbp)
movq %rcx, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
callq 0x39730
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
addq $0x38, %rdi
movq %rdi, -0xf0(%rbp)
callq 0x6210
jmp 0x3836a
movq -0x108(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x120(%rbp)
callq 0x6850
jmp 0x38383
movq -0x108(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0x128(%rbp)
callq 0x6850
jmp 0x3839f
movq -0x108(%rbp), %rax
movq $0x0, 0x458(%rax)
movl $0xffffffff, 0x460(%rax) # imm = 0xFFFFFFFF
movl $0x508, %edi            # imm = 0x508
callq 0x64f0
movq %rax, -0x130(%rbp)
jmp 0x383ce
movq -0x118(%rbp), %rsi
movb $0x1, -0x51(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6210
jmp 0x383e4
movq -0x130(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7dc0
jmp 0x383f6
movq -0x108(%rbp), %rax
movq -0x130(%rbp), %rcx
movb $0x0, -0x51(%rbp)
movq %rcx, 0x30(%rax)
leaq -0x50(%rbp), %rdi
callq 0x6340
movq -0x110(%rbp), %rdi
callq 0x61f0
movq %rax, %rdi
leaq -0xe8(%rbp), %rsi
callq 0x6490
cmpl $-0x1, %eax
je 0x384c2
movq -0x108(%rbp), %rdi
callq 0x38510
jmp 0x38447
jmp 0x384c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x384ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x384e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x384d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x384cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x384a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6340
testb $0x1, -0x51(%rbp)
jne 0x384af
jmp 0x384c0
movq -0x130(%rbp), %rdi
movl $0x508, %esi            # imm = 0x508
callq 0x6500
jmp 0x384cb
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x6760
movq -0x120(%rbp), %rdi
callq 0x6760
movq -0xf0(%rbp), %rdi
callq 0x6340
movq -0x100(%rbp), %rdi
callq 0x39750
movq -0x28(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: prakhar2808[P]DBEngine/dbengine/sstableWrapper.cc
// Function: sstableWrapper::SSTableExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool sstableWrapper::SSTableExists(std::string filePath) {
  struct stat buff;
  if(stat(filePath.c_str(), &buff) == -1) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x61f0
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6490
cmpl $-0x1, %eax
jne 0x3bc73
movb $0x0, -0x1(%rbp)
jmp 0x3bc77
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c8c0
movq -0x40(%rbp), %rsi
movl $0x0, -0x1c(%rbp)
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3c8e0
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3c960
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3c930
testb $0x1, %al
jne 0x3c5b4
jmp 0x3c5df
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c9b0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x392b0
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c9e0
jmp 0x3c590
movq 0x229da(%rip), %rdi     # 0x5efc0
leaq 0x5015(%rip), %rsi      # 0x41602
callq 0x64e0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x6880
movq %rax, %rdi
leaq 0x5003(%rip), %rsi      # 0x4160a
callq 0x64e0
movq %rax, %rdi
movq 0x2297a(%rip), %rsi     # 0x5ef90
callq 0x6540
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ca10
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3ca30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3ca90
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3ca60
testb $0x1, %al
jne 0x3c68a
jmp 0x3c6c4
leaq -0x10(%rbp), %rdi
callq 0x3cac0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3c6b7
movq -0x30(%rbp), %rdi
callq 0x396b0
movq -0x30(%rbp), %rdi
movl $0x468, %esi            # imm = 0x468
callq 0x6500
jmp 0x3c6b9
leaq -0x10(%rbp), %rdi
callq 0x3cae0
jmp 0x3c666
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3c6e3
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x6500
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3cb00
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c770
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x69b0
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x3d9a6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d986
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x68d0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3cb8(%rip), %rsi      # 0x4167e
callq 0x9970
jmp 0x3d9cd
leaq -0x16(%rbp), %rdi
callq 0x6560
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x69b0
movq %rax, -0x50(%rbp)
jmp 0x3d9f2
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0x3da5c
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x69b0
movq %rax, -0x58(%rbp)
jmp 0x3da11
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movsbl (%rax), %esi
callq 0x6360
jmp 0x3da23
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d9df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x6560
jmp 0x3da79
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x6340
jmp 0x3da79
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x3da6f
movq -0x38(%rbp), %rdi
callq 0x6340
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: prakhar2808[P]DBEngine/dbengine/utils.cc
// Function: getIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, char)
int getIndex(std::string str, int start, char ch) {
  int len = str.length();
  if(start >= len) {
    return -1;
  }
  for(int i = start; i < len; i++) {
    if(str[i] == ch) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
callq 0x6780
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x3dac1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3db03
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3dafc
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x69b0
movsbl (%rax), %eax
movsbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3daef
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3db03
jmp 0x3daf1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3dac7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x21d35(%rip), %rdi     # 0x5fa10
callq 0x6750
leaq 0x21cd9(%rip), %rdi     # 0x5f9c0
callq 0x3e610
cmpq $0x0, %rax
jne 0x3dd05
leaq 0x21d3f(%rip), %rdi     # 0x5fa38
leaq 0x21d10(%rip), %rsi     # 0x5fa10
callq 0x67b0
leaq 0x21cb4(%rip), %rdi     # 0x5f9c0
callq 0x3e630
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x21ca1(%rip), %rdi     # 0x5f9c0
callq 0x3e650
leaq 0x21ce5(%rip), %rdi     # 0x5fa10
callq 0x63f0
cmpq $0x0, -0x10(%rbp)
je 0x3dd40
movq -0x10(%rbp), %rdi
callq 0x3dd90
jmp 0x3dccc
nopw %cs:(%rax,%rax)
// File: prakhar2808[P]DBEngine/serverCode/server.cc
// Function: check(int, char const*)
int check(int exp, const char* msg) {
  if(exp == SOCKETERROR) {
    perror(msg);
    exit(1);
  }
  return exp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x3dd78
movq -0x10(%rbp), %rdi
callq 0x6430
movl $0x1, %edi
callq 0x6620
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x66e0
movq -0x40(%rbp), %rdi
leaq 0x33f9(%rip), %rsi      # 0x416dc
callq 0x66d0
jmp 0x3e2ea
leaq 0x342a(%rip), %rsi      # 0x4171b
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e2fc
leaq 0x3457(%rip), %rsi      # 0x4175a
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e30e
leaq 0x3484(%rip), %rsi      # 0x41799
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e320
leaq 0x33b5(%rip), %rsi      # 0x416dc
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e332
movl -0x4(%rbp), %eax
movl %eax, -0x4c(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x69b0
movq %rax, -0x48(%rbp)
jmp 0x3e34b
leaq -0x28(%rbp), %rdi
callq 0x61f0
movq %rax, %rdi
callq 0x6220
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x6190
jmp 0x3e36d
leaq -0x28(%rbp), %rdi
callq 0x6340
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6340
movq -0x30(%rbp), %rdi
callq 0x68c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x66e0
movq -0x40(%rbp), %rdi
leaq 0x3219(%rip), %rsi      # 0x416dc
callq 0x66d0
jmp 0x3e4ca
leaq 0x3307(%rip), %rsi      # 0x417d8
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e4dc
leaq 0x31f9(%rip), %rsi      # 0x416dc
leaq -0x28(%rbp), %rdi
callq 0x64d0
jmp 0x3e4ee
movl -0x4(%rbp), %eax
movl %eax, -0x4c(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x69b0
movq %rax, -0x48(%rbp)
jmp 0x3e507
leaq -0x28(%rbp), %rdi
callq 0x61f0
movq %rax, %rdi
callq 0x6220
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x6190
jmp 0x3e529
leaq -0x28(%rbp), %rdi
callq 0x6340
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6340
movq -0x30(%rbp), %rdi
callq 0x68c0
nopw %cs:(%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/src/cache.cc
// Function: CACHE::update_fill_cycle()
void CACHE::update_fill_cycle()
{
    // update next_fill_cycle
    uint64_t min_cycle = UINT64_MAX;
    uint32_t min_index = MSHR.SIZE;
    for (uint32_t i=0; i<MSHR.SIZE; i++) {
        if ((MSHR.entry[i].returned == COMPLETED) && (MSHR.entry[i].event_cycle < min_cycle)) {
            min_cycle = MSHR.entry[i].event_cycle;
            min_index = i;
        }

        DP (if (warmup_complete[MSHR.entry[i].cpu]) {
        cout << "[" << NAME << "_MSHR] " <<  __func__ << " checking instr_id: " << MSHR.entry[i].instr_id;
        cout << " address: " << hex << MSHR.entry[i].address << " full_addr: " << MSHR.entry[i].full_addr;
        cout << " data: " << MSHR.entry[i].data << dec << " returned: " << +MSHR.entry[i].returned << " fill_level: " << MSHR.entry[i].fill_level;
        cout << " index: " << i << " occupancy: " << MSHR.occupancy;
        cout << " event: " << MSHR.entry[i].event_cycle << " current: " << current_core_cycle[MSHR.entry[i].cpu] << " next: " << MSHR.next_fill_cycle << endl; });
    }
    
    MSHR.next_fill_cycle = min_cycle;
    MSHR.next_fill_index = min_index;
    if (min_index < MSHR.SIZE) {

        DP (if (warmup_complete[MSHR.entry[min_index].cpu]) {
        cout << "[" << NAME << "_MSHR] " <<  __func__ << " instr_id: " << MSHR.entry[min_index].instr_id;
        cout << " address: " << hex << MSHR.entry[min_index].address << " full_addr: " << MSHR.entry[min_index].full_addr;
        cout << " data: " << MSHR.entry[min_index].data << dec << " num_returned: " << MSHR.num_returned;
        cout << " event: " << MSHR.entry[min_index].event_cycle << " current: " << current_core_cycle[MSHR.entry[min_index].cpu] << " next: " << MSHR.next_fill_cycle << endl; });
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq $-0x1, -0x10(%rsp)
movl 0xc9a8(%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movq -0x20(%rsp), %rcx
movl -0x18(%rsp), %eax
cmpl 0xc9a8(%rcx), %eax
jae 0x4acd
movq -0x20(%rsp), %rax
movq 0xca20(%rax), %rax
movl -0x18(%rsp), %ecx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
movzbl 0x32c(%rax), %eax
cmpl $0x2, %eax
jne 0x4abb
movq -0x20(%rsp), %rax
movq 0xca20(%rax), %rax
movl -0x18(%rsp), %ecx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
movq 0x378(%rax), %rax
cmpq -0x10(%rsp), %rax
jae 0x4abb
movq -0x20(%rsp), %rax
movq 0xca20(%rax), %rax
movl -0x18(%rsp), %ecx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
movq 0x378(%rax), %rax
movq %rax, -0x10(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x4abd
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x4a2a
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rax, 0xc9d0(%rcx)
movl -0x14(%rsp), %eax
movl %eax, 0xc9c4(%rcx)
movl -0x14(%rsp), %eax
cmpl 0xc9a8(%rcx), %eax
jae 0x4af6
jmp 0x4af6
retq
nopw (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/src/cache.cc
// Function: CACHE::check_mshr(PACKET*)
int CACHE::check_mshr(PACKET *packet)
{
    // search mshr
    for (uint32_t index=0; index<MSHR_SIZE; index++) {
        if (MSHR.entry[index].address == packet->address) {
            
            DP ( if (warmup_complete[packet->cpu]) {
            cout << "[" << NAME << "_MSHR] " << __func__ << " same entry instr_id: " << packet->instr_id << " prior_id: " << MSHR.entry[index].instr_id;
            cout << " address: " << hex << packet->address;
            cout << " full_addr: " << packet->full_addr << dec << endl; });

            return index;
        }
    }

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

    DP ( if (warmup_complete[packet->cpu] && (MSHR.occupancy == MSHR_SIZE)) { 
    cout << "[" << NAME << "_MSHR] " << __func__ << " mshr is full";
    cout << " instr_id: " << packet->instr_id << " mshr occupancy: " << MSHR.occupancy;
    cout << " address: " << hex << packet->address;
    cout << " full_addr: " << packet->full_addr << dec;
    cout << " cycle: " << current_core_cycle[packet->cpu] << endl; });

    return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x7388(%rcx), %eax
jae 0x63e5
movq -0x28(%rsp), %rax
movq 0xca20(%rax), %rax
movl -0x1c(%rsp), %ecx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
movq 0x340(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x340(%rcx), %rax
jne 0x63d6
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x63ed
jmp 0x63d8
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x638c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x7388(%rcx), %eax
jae 0x64ce
movq 0x8(%rsp), %rax
movq 0xca20(%rax), %rax
movl 0x14(%rsp), %ecx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
cmpq $0x0, 0x340(%rax)
jne 0x64bc
movq 0x8(%rsp), %rax
movq 0xca20(%rax), %rdi
movl 0x14(%rsp), %eax
imulq $0x380, %rax, %rax      # imm = 0x380
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl $0x380, %edx            # imm = 0x380
callq 0x31a0
movq 0x8(%rsp), %rax
movq 0xca20(%rax), %rcx
movl 0x14(%rsp), %edx
imulq $0x380, %rdx, %rdx      # imm = 0x380
addq %rdx, %rcx
movb $0x1, 0x32c(%rcx)
movl 0xc9bc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc9bc(%rax)
jmp 0x64ce
jmp 0x64be
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6428
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)