LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: main
int main() {
    test_constructors();
    test_inequalities();
    test_sequences();
    test_skip();
    test_addTurn();
    test_setAlgorithm();
    test_inversions();
    test_hidden_inversions();
    test_triples();
    test_hidden_triples();
    test_string();

    return 0;
}

// Assembly:
pushq %rax
callq 0x4a98
callq 0x4f56
callq 0x4fb3
callq 0x5425
callq 0x55fd
callq 0x58fa
callq 0x5ade
callq 0x60fc
callq 0x6527
callq 0x68c0
callq 0x79d7
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_inequalities()
void test_inequalities() {
    std::cout << "Testing inequalities... ";

    unsigned int val = 1;
    test_inequalities(val + 2);
    test_inequalities(val *= 12 + 3);
    test_inequalities(val *= 12 + 4);
    test_inequalities(val *= 12 + 5);
    test_inequalities(val *= 12 + 6); 

    std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %rbx
movq 0x907a(%rip), %rbx      # 0xdfd8
leaq 0x440c(%rip), %rsi      # 0x9371
movq %rbx, %rdi
callq 0x2140
pushq $0x3
popq %rdi
callq 0x7bdc
pushq $0xf
popq %rdi
callq 0x7bdc
movl $0xf0, %edi
callq 0x7bdc
movl $0xff0, %edi            # imm = 0xFF0
callq 0x7bdc
movl $0x11ee0, %edi          # imm = 0x11EE0
callq 0x7bdc
leaq 0x43c8(%rip), %rsi      # 0x936a
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
popq %rbx
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_setAlgorithm()
void test_setAlgorithm() {
    std::cout << "Testing set algorithm... ";

    std::vector<Turn> algorithm = {
        {Layer::L, true},  {Layer::F, false}, 
        {Layer::U, false}, {Layer::F, false}
    };

    Algorithm alg_1(algorithm);
    Algorithm alg_2;

    alg_2.setAlgorithm("L F' U' F'");
    verify_turns(alg_1.getAlgorithm(), algorithm);
    verify_turns(alg_2.getAlgorithm(), alg_1.getAlgorithm());

    std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
movq 0x86cf(%rip), %rdi      # 0xdfd8
leaq 0x3b56(%rip), %rsi      # 0x9466
callq 0x2140
movups 0x43b0(%rip), %xmm0     # 0x9ccc
leaq 0x90(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x438d(%rip), %xmm0     # 0x9cbc
movaps %xmm0, (%rsi)
leaq 0x78(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0xb8(%rsp), %rcx
movq %rbx, %rdi
callq 0x7e30
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x3382
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x242a
leaq 0x60(%rsp), %rdi
callq 0x358c
leaq 0xb8(%rsp), %rdi
callq 0x231c
leaq 0x3af9(%rip), %rsi      # 0x9480
leaq 0xb8(%rsp), %rdi
callq 0x2542
leaq 0x48(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x2a0c
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x3382
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7afb
leaq 0x30(%rsp), %rdi
callq 0x358c
leaq 0x48(%rsp), %rdi
callq 0x358c
leaq 0x18(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2a0c
movq %rsp, %rdi
leaq 0x90(%rsp), %rsi
callq 0x2a0c
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x7afb
movq %rsp, %rdi
callq 0x358c
leaq 0x18(%rsp), %rdi
callq 0x358c
movq 0x85b8(%rip), %rdi      # 0xdfd8
leaq 0x3943(%rip), %rsi      # 0x936a
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq 0xb8(%rsp), %rdi
callq 0x3558
leaq 0x90(%rsp), %rdi
callq 0x3558
leaq 0x78(%rsp), %rdi
callq 0x358c
addq $0xe0, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x358c
jmp 0x5a71
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x5a8f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x358c
jmp 0x5a8a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x358c
jmp 0x5ab2
movq %rax, %rbx
jmp 0x5abf
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x358c
jmp 0x5acc
movq %rax, %rbx
jmp 0x5acc
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x3558
leaq 0x90(%rsp), %rdi
callq 0x3558
leaq 0x78(%rsp), %rdi
callq 0x358c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_string()
void test_string() {
    std::cout << "Testing string... ";

    std::string str_1 = "F' L U' R' D B F'";
    std::string str_2;
    Algorithm alg_1;

    alg_1.setAlgorithm(str_1.c_str());
    str_2 = alg_1.getAlgorithmStr();

    assert(str_1.compare(str_2) == 0);

    std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq 0x65f0(%rip), %rdi      # 0xdfd8
leaq 0x1f52(%rip), %rsi      # 0x9941
callq 0x2140
leaq 0x1f59(%rip), %rsi      # 0x9954
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x3512
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x231c
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2542
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x291e
leaq 0x48(%rsp), %rbx
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
movq %r14, %rdi
callq 0x20a0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jne 0x7aae
movq 0x6565(%rip), %rdi      # 0xdfd8
leaq 0x18f0(%rip), %rsi      # 0x936a
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x3558
leaq 0x48(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
leaq 0x1eb1(%rip), %rdi      # 0x9966
leaq 0x17d1(%rip), %rsi      # 0x928d
leaq 0x1ebd(%rip), %rcx      # 0x9980
movl $0x252, %edx            # imm = 0x252
callq 0x20e0
jmp 0x7ad4
movq %rax, %rbx
jmp 0x7ae1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3558
leaq 0x48(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_inequalities(unsigned int)
void test_inequalities(unsigned int val) {
    Algorithm alg_1;
    Algorithm alg_2;

    alg_1 += val;
    alg_2 += val; 
    assert(alg_1 == alg_2);
    assert(alg_1 <= alg_2);
    assert(alg_2 >= alg_2);
    verify_turns(alg_1.getAlgorithm(), alg_2.getAlgorithm());

    alg_2 +=1;
    assert(alg_1 != alg_2);
    assert(alg_1  < alg_2);
    assert(alg_1 <= alg_2);
    assert(alg_2  > alg_1);
    assert(alg_2 >= alg_1);
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movl %edi, %ebx
leaq 0x28(%rsp), %rdi
callq 0x231c
movq %rsp, %rdi
callq 0x231c
movl %ebx, %ebx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2740
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2740
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x274e
testb %al, %al
je 0x7d1d
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x27dc
testb %al, %al
je 0x7d39
movq %rsp, %rdi
movq %rdi, %rsi
callq 0x2816
testb %al, %al
je 0x7d55
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a0c
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x2a0c
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7afb
leaq 0x50(%rsp), %rdi
callq 0x358c
leaq 0x68(%rsp), %rdi
callq 0x358c
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x2740
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x2754
testb %al, %al
je 0x7d6e
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x275a
testb %al, %al
je 0x7d87
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x27dc
testb %al, %al
je 0x7da0
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x280c
testb %al, %al
je 0x7db9
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2816
testb %al, %al
je 0x7dd2
movq %rsp, %rdi
callq 0x3558
leaq 0x28(%rsp), %rdi
callq 0x3558
addq $0x80, %rsp
popq %rbx
retq
leaq 0x1666(%rip), %rdi      # 0x938a
leaq 0x1562(%rip), %rsi      # 0x928d
leaq 0x1667(%rip), %rcx      # 0x9399
pushq $0x72
jmp 0x7de9
leaq 0x167e(%rip), %rdi      # 0x93be
leaq 0x1546(%rip), %rsi      # 0x928d
leaq 0x164b(%rip), %rcx      # 0x9399
pushq $0x73
jmp 0x7de9
leaq 0x1671(%rip), %rdi      # 0x93cd
leaq 0x152a(%rip), %rsi      # 0x928d
leaq 0x162f(%rip), %rcx      # 0x9399
pushq $0x74
jmp 0x7de9
leaq 0x1667(%rip), %rdi      # 0x93dc
leaq 0x1511(%rip), %rsi      # 0x928d
leaq 0x1616(%rip), %rcx      # 0x9399
pushq $0x78
jmp 0x7de9
leaq 0x165d(%rip), %rdi      # 0x93eb
leaq 0x14f8(%rip), %rsi      # 0x928d
leaq 0x15fd(%rip), %rcx      # 0x9399
pushq $0x79
jmp 0x7de9
leaq 0x1617(%rip), %rdi      # 0x93be
leaq 0x14df(%rip), %rsi      # 0x928d
leaq 0x15e4(%rip), %rcx      # 0x9399
pushq $0x7a
jmp 0x7de9
leaq 0x1639(%rip), %rdi      # 0x93f9
leaq 0x14c6(%rip), %rsi      # 0x928d
leaq 0x15cb(%rip), %rcx      # 0x9399
pushq $0x7b
jmp 0x7de9
leaq 0x162e(%rip), %rdi      # 0x9407
leaq 0x14ad(%rip), %rsi      # 0x928d
leaq 0x15b2(%rip), %rcx      # 0x9399
pushq $0x7c
popq %rdx
callq 0x20e0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x358c
jmp 0x7e01
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x358c
jmp 0x7e15
movq %rax, %rbx
jmp 0x7e1d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3558
leaq 0x28(%rsp), %rdi
callq 0x3558
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_vector_resize_inline_example.cpp
// Function: my_vv_size_handler_t<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters) override
   {
      vector_t vector(parameters[0]);
      size_t   new_size = static_cast<std::size_t>(scalar_t(parameters[1])());
      void*    key      = static_cast<void*>(&vector[0]);

      typename map_t::iterator itr = vector_map_.find(key);

      if (itr == vector_map_.end())
      {
         printf("my_vv_size_handler - Error: failed to find vector_view for address: %p\n",key);
         return T(0);
      }

      exprtk::vector_view<T>& vv = *itr->second;

      if (vv.base_size() < new_size)
      {
         printf("my_vv_size_handler - Error: vector_view for address: %p new size of %d greater than base_size of %d\n",
                key,
                static_cast<unsigned int>(new_size),
                static_cast<unsigned int>(vv.base_size()));
         return T(0);
      }

      return vv.set_size(new_size) ? T(1) : T(0);
   }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
addq $0x48, %rdi
callq 0x11200c
addq $0x50, %rbx
cmpq %rbx, %rax
je 0x111fd4
movapd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rsi
subsd 0x1250d4(%rip), %xmm0   # 0x237078
sarq $0x3f, %rsi
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rcx, %rdx
movq 0x28(%rax), %rax
movq (%rax), %rcx
cmpq %rdx, %rcx
jae 0x111ff1
movq 0x8(%rsp), %rsi
leaq 0x12a547(%rip), %rdi    # 0x23c512
xorl %eax, %eax
callq 0x10e060
jmp 0x111fe7
movq 0x8(%rsp), %rsi
leaq 0x12a4ea(%rip), %rdi    # 0x23c4ca
xorl %eax, %eax
callq 0x10e060
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq -0x1(%rdx), %rsi
xorpd %xmm0, %xmm0
cmpq %rcx, %rsi
jae 0x111feb
movq %rdx, 0x8(%rax)
movsd 0x125076(%rip), %xmm0   # 0x237080
jmp 0x111feb
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: ScanForToken(char, int&, int&, bool, bool, int*)
bool ScanForToken(char cToken, int &iIndex, int &iLine, bool bIgnoreWhiteSpace, bool bIgnoreOthers, int *iToken = 0)
{
	for(; iIndex < g_entdatasize; iIndex++)
	{
		// If we found a null char, consider it end of data.
		if(g_dentdata[iIndex] == '\0')
		{
			iIndex = g_entdatasize;
			return false;
		}

		// Count lines (for error message).
		if(g_dentdata[iIndex] == '\n')
		{
			iLine++;
		}

		// Ignore white space, if we are ignoring it.
		if(!bIgnoreWhiteSpace && isspace(g_dentdata[iIndex]))
		{
			continue;
		}

		if(g_dentdata[iIndex] != cToken)
		{
			if(bIgnoreOthers)
				continue;
			else
				return false;
		}

		// Advance the index past the token.
		iIndex++;

		// Return the index of the token if requested.
		if(iToken != 0)
		{
			*iToken = iIndex - 1;
		}

		return true;
	}

	// End of data.
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r15d
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movl %edi, 0x4(%rsp)
movl (%rsi), %r12d
leaq 0x814380(%rip), %r13    # 0x81f334
leaq 0x814385(%rip), %rbp    # 0x81f340
movl (%r13), %eax
cmpl %eax, %r12d
jge 0xb029
movslq %r12d, %rcx
movzbl (%rbp,%rcx), %ecx
cmpl $0xa, %ecx
je 0xafd7
testl %ecx, %ecx
jne 0xafe1
jmp 0xb026
movq 0x10(%rsp), %rax
incl (%rax)
movl (%r14), %r12d
movslq %r12d, %rax
movsbl (%rbp,%rax), %ebx
testb %r15b, %r15b
jne 0xaff9
movl %ebx, %edi
callq 0x3080
testl %eax, %eax
jne 0xb005
cmpb 0x4(%rsp), %bl
je 0xb00d
cmpb $0x0, (%rsp)
je 0xb029
incl %r12d
movl %r12d, (%r14)
jmp 0xafbb
leal 0x1(%r12), %eax
movl %eax, (%r14)
movb $0x1, %al
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0xb02b
movl %r12d, (%rcx)
jmp 0xb02b
movl %eax, (%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: Usage()
static void     Usage(void)
{
    //Log("%s " ZHLT_VERSIONSTRING "\n" MODIFICATIONS_STRING "\n", g_Program);
    //Log("  Usage: ripent [-import|-export] [-texdata n] bspname\n");

	// Modified to behave like other tools by Nem.

	Banner();
	Log("\n-= %s Options =-\n\n", g_Program);

#ifdef ZHLT_CONSOLE
	Log("    -console #      : Set to 0 to turn off the pop-up console (default is 1)\n");
#endif
#ifdef ZHLT_LANGFILE
	Log("    -lang file      : localization file\n");
#endif
	Log("    -export         : Export entity data\n");
	Log("    -import         : Import entity data\n\n");

	Log("    -parse          : Parse and format entity data\n\n");
#ifdef RIPENT_TEXTURE
	Log("    -textureexport  : Export texture data\n");
	Log("    -textureimport  : Import texture data\n");
	Log("    -textureparse   : Parse and format texture data\n\n");
#endif
#ifdef ZHLT_64BIT_FIX
	Log("    -writeextentfile : Create extent file for the map\n");
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
#ifdef RIPENT_TEXTURE
	Log("    -deleteembeddedlightmaps : Delete textures created by hlrad\n");
#endif
#endif

    Log("    -texdata #      : Alter maximum texture memory limit (in kb)\n");
    Log("    -lightdata #    : Alter maximum lighting memory limit (in kb)\n");
	Log("    -chart          : Display bsp statitics\n");
	Log("    -noinfo         : Do not show tool configuration information\n\n");
#ifdef RIPENT_PAUSE
	Log("    -pause          : Pause before exit\n\n");
#endif

	Log("    mapfile         : The mapfile to process\n\n");

    exit(1);
}

// Assembly:
pushq %rax
callq 0x7f91
leaq 0x99ad(%rip), %rax      # 0x162b0
movq (%rax), %rsi
leaq 0x3d35(%rip), %rdi      # 0x10642
xorl %eax, %eax
callq 0x7620
leaq 0x3d3b(%rip), %rdi      # 0x10656
xorl %eax, %eax
callq 0x7620
leaq 0x3d7b(%rip), %rdi      # 0x106a4
xorl %eax, %eax
callq 0x7620
leaq 0x3d96(%rip), %rdi      # 0x106cd
xorl %eax, %eax
callq 0x7620
leaq 0x3db2(%rip), %rdi      # 0x106f7
xorl %eax, %eax
callq 0x7620
leaq 0x3dcf(%rip), %rdi      # 0x10722
xorl %eax, %eax
callq 0x7620
leaq 0x3df6(%rip), %rdi      # 0x10757
xorl %eax, %eax
callq 0x7620
leaq 0x3e13(%rip), %rdi      # 0x10782
xorl %eax, %eax
callq 0x7620
leaq 0x3e30(%rip), %rdi      # 0x107ad
xorl %eax, %eax
callq 0x7620
leaq 0x3e58(%rip), %rdi      # 0x107e3
xorl %eax, %eax
callq 0x7620
leaq 0x3e81(%rip), %rdi      # 0x1081a
xorl %eax, %eax
callq 0x7620
leaq 0x3eb4(%rip), %rdi      # 0x1085b
xorl %eax, %eax
callq 0x7620
leaq 0x3ee8(%rip), %rdi      # 0x1089d
xorl %eax, %eax
callq 0x7620
leaq 0x3f1d(%rip), %rdi      # 0x108e0
xorl %eax, %eax
callq 0x7620
leaq 0x3f3c(%rip), %rdi      # 0x1090d
xorl %eax, %eax
callq 0x7620
leaq 0x3f71(%rip), %rdi      # 0x10950
xorl %eax, %eax
callq 0x7620
pushq $0x1
popq %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/error_diffusion1.cpp
// Function: main
int main(int argc, char** argv) {
    int mtd, serpentine;
    float gamma;
    imageP I1, I2;

    cout << "input: " << argv[1] << endl;
    cout << "mtd: " << argv[2] << endl;
    cout << "serpentine: " << argv[3] << endl;
    cout << "gamma: " << argv[4] << endl;
    cout << "outfile " << argv[5] << endl;

    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;

    mtd = atoi(argv[2]);
    serpentine = atoi(argv[3]);
    gamma = atof(argv[4]);


    error_diffusion(I1, mtd, serpentine, gamma, I2);

    IP_saveImage(I2, argv[5]);

    IP_freeImage(I1);
    IP_freeImage(I2);

    cout << "done!" << endl;

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x2cb2(%rip), %rbx      # 0x3fd0
leaq 0xcfb(%rip), %rsi       # 0x2020
movq %rbx, %rdi
callq 0x1090
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xce0(%rip), %rsi       # 0x2028
movq %rbx, %rdi
callq 0x1090
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xcc3(%rip), %rsi       # 0x202e
movq %rbx, %rdi
callq 0x1090
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xcad(%rip), %rsi       # 0x203b
movq %rbx, %rdi
callq 0x1090
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xc92(%rip), %rsi       # 0x2043
movq %rbx, %rdi
callq 0x1090
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq 0x8(%r14), %rdi
callq 0x17d8
movq %rax, %r15
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %r12
movq 0x18(%r14), %rdi
callq 0x1140
movl %eax, %ebp
movq 0x20(%r14), %rdi
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movq %r15, %rdi
movl %ebp, %edx
movq %r12, %rcx
callq 0x1448
movq 0x28(%r14), %rsi
movq %r12, %rdi
callq 0x19a2
movq %r15, %rdi
callq 0x1aa3
movq %r12, %rdi
callq 0x1aa3
leaq 0xc20(%rip), %rsi       # 0x204c
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %r8d
movl (%rdi), %r9d
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %r8
imull %r9d, %esi
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
movslq %esi, %rdx
addq 0x8(%rdi), %rdx
leaq (%rcx,%r8,4), %rcx
addq $0x4, %rcx
cmpq %rax, %r9
je 0x1e1b
movzbl (%rdx,%rax), %esi
cvtsi2ss %esi, %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %rax
jmp 0x1e04
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %r8d
movl (%rdi), %r9d
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %rax
addq %rcx, %rax
imull %r9d, %esi
movslq %esi, %rcx
xorl %edx, %edx
testl %r9d, %r9d
cmovlel %edx, %r9d
addq 0x8(%rdi), %rcx
cmpq %rdx, %r9
je 0x1e58
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x1e46
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x24(%rbp), %rsi
movl %edi, (%rsi)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x19b6
movq 0x2cce(%rip), %rdi      # 0x3fd8
movq %r15, %rsi
callq 0x10e0
leaq 0xceb(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x10f0
leaq -0x48(%rbp), %rdi
callq 0x1090
shlq $0x5, %rbx
movq 0x2ca3(%rip), %r15      # 0x3fd8
leaq 0xcc9(%rip), %r12       # 0x2005
testq %rbx, %rbx
je 0x1361
movq %r15, %rdi
movq %r14, %rsi
callq 0x10e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x10f0
addq $0x20, %r14
addq $-0x20, %rbx
jmp 0x133c
movq 0x2c70(%rip), %rdi      # 0x3fd8
callq 0x10a0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/errMsg_initList.cc
// Function: functionX[abi:cxx11]()
vector<string> functionX()
{
	string expected = "description", actual = "some other case";
	// . . .
	if (expected.empty())
		return {};  // return an empty vector
	else if (expected == actual)
		return {"functionX", "okay"}; // return list-initialized vector
	else 
		return {"functionX", expected, actual}; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0xc03(%rip), %rsi       # 0x2007
leaq -0x40(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x1060
leaq 0xbf8(%rip), %rsi       # 0x2013
leaq -0x60(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x1060
cmpq $0x0, -0x38(%rbp)
je 0x14a7
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1a38
testb %al, %al
je 0x14b4
leaq 0xbd9(%rip), %rsi       # 0x2023
leaq -0xc0(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x1060
leaq -0xa0(%rbp), %rdi
leaq 0xbc5(%rip), %rsi       # 0x202d
leaq -0x19(%rbp), %rdx
callq 0x1060
leaq -0xc0(%rbp), %rsi
pushq $0x2
popq %rdx
leaq -0x1b(%rbp), %rcx
movq %rbx, %rdi
callq 0x1a5c
pushq $0x20
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xc0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x148b
jmp 0x1525
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x1525
leaq 0xb68(%rip), %rsi       # 0x2023
leaq -0xc0(%rbp), %r14
leaq -0x1a(%rbp), %rdx
movq %r14, %rdi
callq 0x1060
leaq -0xa0(%rbp), %r15
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x1130
leaq -0x80(%rbp), %r15
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x1130
leaq -0xc0(%rbp), %rsi
pushq $0x3
popq %rdx
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x1a5c
pushq $0x40
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xc0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x150b
leaq -0x60(%rbp), %rdi
callq 0x1090
leaq -0x40(%rbp), %rdi
callq 0x1090
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xc0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x154f
jmp 0x15ba
movq %rax, %rbx
pushq $0x20
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xc0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1572
jmp 0x15ba
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x1090
jmp 0x15ba
jmp 0x15a1
movq %rax, %rbx
jmp 0x15ba
movq %rax, %rbx
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1090
cmpq %r14, %r15
jne 0x15a9
leaq -0x60(%rbp), %rdi
callq 0x1090
jmp 0x15c8
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %r8d
pushq $0x4
popq %r9
movl %esi, %eax
cltd
idivl %r9d
leal (,%rax,4), %edx
movslq %edx, %rdx
addq %rdi, %rdx
negl %eax
cltq
testq %rax, %rax
je 0x5aa3
movl (%rdx,%rax,4), %edi
imull $0xcc9e2d51, %edi, %r9d # imm = 0xCC9E2D51
imull $0x16a88000, %edi, %edi # imm = 0x16A88000
shrl $0x11, %r9d
orl %edi, %r9d
imull $0x1b873593, %r9d, %edi # imm = 0x1B873593
xorl %r8d, %edi
roll $0xd, %edi
leal (%rdi,%rdi,4), %r8d
addl $0xe6546b64, %r8d       # imm = 0xE6546B64
incq %rax
jmp 0x5a6a
movl %esi, %edi
andl $0x3, %edi
xorl %eax, %eax
leaq 0x11553(%rip), %r9      # 0x17004
movslq (%r9,%rdi,4), %rdi
addq %r9, %rdi
jmpq *%rdi
movzbl 0x2(%rdx), %eax
shll $0x10, %eax
movzbl 0x1(%rdx), %edi
shll $0x8, %edi
orl %edi, %eax
movzbl (%rdx), %edx
xorl %eax, %edx
imull $0xcc9e2d51, %edx, %eax # imm = 0xCC9E2D51
imull $0x16a88000, %edx, %edx # imm = 0x16A88000
shrl $0x11, %eax
orl %edx, %eax
imull $0x1b873593, %eax, %eax # imm = 0x1B873593
xorl %eax, %r8d
xorl %esi, %r8d
movl %r8d, %eax
shrl $0x10, %eax
xorl %r8d, %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_O2/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 %rbx
subq $0x7a0, %rsp            # imm = 0x7A0
movq %rsi, %r15
movq %rdi, %r14
movl $0x4e8, %edx            # imm = 0x4E8
xorl %esi, %esi
callq 0x5270
leaq 0x4e8(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5540
movq (%r15), %rdi
leaq 0x228(%rsp), %rsi
callq 0x5380
cmpl $-0x1, %eax
je 0x6152
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r15, %rsi
callq 0x5620
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x108(%rsp,%rax), %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x6464
leaq 0x2b8(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x634c
leaq 0x2b8(%rsp), %rsi
movl $0x4e8, %edx            # imm = 0x4E8
movq %r14, %rdi
callq 0x5320
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rsp, %rdi
callq 0x51d0
leaq 0x20(%rsp), %rdi
callq 0x50e0
addq $0x7a0, %rsp            # imm = 0x7A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6161
movq %rax, %r14
movq %rsp, %rdi
callq 0x51d0
jmp 0x6171
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x50e0
jmp 0x6180
movq %rax, %r14
movq %rbx, %rdi
callq 0x51d0
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x5750
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x6289
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6392
leaq 0x8(%rsp), %rdi
callq 0x5570
leaq 0x8(%rsp), %rdi
callq 0x55b0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5540
movq %r14, %rsi
callq 0x6190
movq %rax, %r14
movq %rdx, %r15
movq %rsp, %rdi
callq 0x51d0
xorl %eax, %eax
movl $0x2710, %ecx           # imm = 0x2710
movq %rax, %rsi
movq %r14, %rax
xorl %edx, %edx
divq %rcx
cmpq $0x7, %rsi
je 0x631b
movq %rdx, %rax
shrq $0x6, %rax
movq (%rbx,%rax,8), %rdi
leaq 0x1(%rsi), %rax
addq %r15, %r14
btq %rdx, %rdi
jb 0x62f2
cmpq $0x7, %rsi
setae %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rsi, %r12
movq %rdi, %r13
callq 0x5060
movq %rax, %rbx
movq (%r13), %rbp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5540
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x13faa
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x51d0
cmpl $0x3, %ebp
jne 0x68d4
movq 0x8(%r13), %r13
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5540
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x15d28
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x51d0
callq 0x5060
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1080f(%rip), %xmm0    # 0x170f8
movsd %xmm0, (%rsp)
movq 0x1e6cb(%rip), %rdi     # 0x24fc0
leaq 0x10804(%rip), %rsi     # 0x17100
callq 0x53b0
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x5610
leaq 0x10807(%rip), %rsi     # 0x1711c
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5210
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6938
movq %rax, %rbx
movq %r14, %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x141b0
movl %eax, %ebp
testl %eax, %eax
jne 0x6a22
movq 0x8(%r14), %rdi
movl %ebx, %esi
callq 0x15e68
movl %eax, %ebp
movl %ebx, %edi
callq 0x167ab
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq 0x1e0d1(%rip), %rdi     # 0x24fc0
leaq 0x1040c(%rip), %rsi     # 0x17302
callq 0x53b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x10405(%rip), %rsi     # 0x17312
movq %rax, %rdi
callq 0x53b0
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x5370
leaq 0x103f7(%rip), %rsi     # 0x1731f
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5210
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6a76
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x67e2
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x6ab0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6ab0
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/prakhar2808[P]DBEngine/dbengine/dbops.cc
// Function: filePutOp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, database*)
opStatus filePutOp(std::string& inBuffer,
                   int clientSocket,
                   database* dbObject) {
  std::vector<keyValuePair_t> keyValuePairVec;
  int keylen, valuelen;
  std::string key, value;
  // Starting after "FILEPUT".
  for(int i = 7; i < (int)inBuffer.length(); ++i) {
    // Parse key value pairs and put in vector.
    keylen = inBuffer[i];
    valuelen = inBuffer[i + keylen + 1];
    key = inBuffer.substr(i+1, keylen);
    value = inBuffer.substr(i + keylen + 2, keylen);
    keyValuePairVec.push_back(keyValuePair_t(key, value));
    //std::cout << key << " -- " << value << std::endl;
    i = i + keylen + valuelen + 1;
  }
  return dbObject->writeKeyValuePair(keyValuePairVec, clientSocket);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x20(%rsp), %rcx
andq $0x0, 0x10(%rcx)
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
xorl %ecx, %ecx
leaq 0x48(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
pushq $0x7
popq %rax
leaq 0xb8(%rsp), %r13
leaq 0x58(%rsp), %r12
leaq 0x38(%rsp), %rbp
movq %rdi, 0x18(%rsp)
cmpl 0x8(%r14), %eax
jge 0x70c7
movq %rbp, %r15
movslq %eax, %rbx
movq (%r14), %rcx
movsbq (%rcx,%rbx), %rbp
addq %rbp, %rbx
movsbl 0x1(%rcx,%rbx), %ecx
movl %ecx, 0xc(%rsp)
incl %eax
movslq %eax, %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rcx
callq 0x5400
movq %r12, %rdi
movq %r13, %rsi
callq 0x54b0
movq %r13, %rdi
callq 0x51d0
addl $0x2, %ebx
movslq %ebx, %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rcx
callq 0x5400
movq %r15, %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x54b0
movq %r13, %rdi
callq 0x51d0
leaq 0x98(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5540
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5540
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6b02
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x12c4e
movq %r13, %rdi
callq 0x6ab0
movq %r15, %rdi
callq 0x51d0
movq %r14, %rdi
callq 0x51d0
addl 0xc(%rsp), %ebx
movl %ebx, %eax
movq 0x18(%rsp), %r14
jmp 0x6fed
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
callq 0x6842
movl %eax, %ebx
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0x58(%rsp), %rdi
callq 0x51d0
leaq 0x20(%rsp), %rdi
callq 0x7370
movl %ebx, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7147
jmp 0x7147
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x6ab0
jmp 0x7127
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x51d0
jmp 0x7138
jmp 0x7147
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x51d0
jmp 0x714a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0x58(%rsp), %rdi
callq 0x51d0
leaq 0x20(%rsp), %rdi
callq 0x7370
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dda2(%rip), %rdi     # 0x24fc0
leaq 0x1012e(%rip), %rsi     # 0x17353
callq 0x53b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x10126(%rip), %rsi     # 0x17362
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5210
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5540
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x694c
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x51d0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5540
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13202
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x51d0
leaq 0x20(%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13412
movq %rax, %rdi
movq %r15, %rsi
callq 0x5260
testb %bpl, %bpl
jne 0x131a4
incl 0x30(%rbx)
addq $0x60, %rbx
movsbl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x5480
movq (%r14), %rsi
movq %rax, %rdi
callq 0x53b0
movsbl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x5480
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x53b0
movq %rbx, %rdi
callq 0x52c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
addq $0x8, %r14
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %r15
leaq 0x8(%rsp), %rbx
cmpq %r14, %r12
je 0x132eb
leaq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x4f6d(%rip), %rdx      # 0x181ed
callq 0x13497
leaq 0x40(%r12), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x13478
movq %r15, %rdi
movq %rbp, %rsi
leaq 0x4141(%rip), %rdx      # 0x173e3
callq 0x13375
movq %rbp, %rdi
callq 0x51d0
movq %r13, %rdi
callq 0x51d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5540
movl 0x4(%rsp), %edi
movq %rbx, %rsi
callq 0x1677c
movq %rbx, %rdi
callq 0x51d0
movq %r15, %rdi
callq 0x51d0
movq %r12, %rdi
callq 0x52d0
movq %rax, %r12
jmp 0x1326c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1330f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x51d0
leaq 0x28(%rsp), %rdi
jmp 0x1332d
movq %rax, %rbx
jmp 0x13328
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51d0
leaq 0x68(%rsp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x40(%rdi)
movl $0x260, %edi            # imm = 0x260
callq 0x53c0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
movl %ebp, %ecx
callq 0x12e40
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x14230
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, %r15
movl $0x260, %esi            # imm = 0x260
movq %r14, %rdi
callq 0x53d0
jmp 0x13a65
movq %rax, %r15
movq %rbx, %rdi
callq 0x14348
movq %r15, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x11350(%rip), %rbx     # 0x24fc0
leaq 0x46e2(%rip), %rsi      # 0x18359
movq %rbx, %rdi
callq 0x53b0
leaq 0x46e5(%rip), %rsi      # 0x1836b
movq %rax, %rdi
callq 0x53b0
movq 0x10(%r15), %rcx
movl 0x38(%rcx), %esi
movq %rax, %rdi
callq 0x5690
leaq 0x46cc(%rip), %rsi      # 0x18370
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5210
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x159d8
movq 0x10(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x14322
movq 0x40(%r12), %rdi
callq 0x56e0
movq %r12, %rdi
callq 0x1333a
movl $0x260, %esi            # imm = 0x260
movq %r12, %rdi
callq 0x53d0
leaq 0x4687(%rip), %rsi      # 0x1837c
movq %rbx, %rdi
callq 0x53b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5210
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq (%r14), %r12
movq 0x10(%r15), %rdi
movl %ebx, %esi
callq 0x13238
cmpq %r12, %r15
je 0x141da
movq 0x8(%r15), %r15
jmp 0x141c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%r15), %r15
cmpq %rbx, %r15
je 0x1421b
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x1420c
movq %r14, %rdi
callq 0x1333a
movl $0x260, %esi            # imm = 0x260
movq %r14, %rdi
callq 0x53d0
jmp 0x141f3
movq %rbx, %rdi
callq 0x14330
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x14348
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movq %rcx, %r13
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
movq %rdx, %rbp
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x5540
leaq 0x58(%rbx), %r15
movq %r15, %rdi
movq %r14, (%rsp)
callq 0x5670
leaq 0x258(%rbx), %r12
movq %r12, %rdi
callq 0x5670
andq $0x0, 0x458(%rbx)
orl $-0x1, 0x460(%rbx)
movl $0x508, %edi            # imm = 0x508
callq 0x53c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x5540
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6090
movq %r14, 0x30(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x51d0
movq (%r13), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5380
cmpl $-0x1, %eax
je 0x14656
movq %rbx, %rdi
callq 0x146c6
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1468b
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x51d0
jmp 0x1467c
movq %rax, %r13
movl $0x508, %esi            # imm = 0x508
movq %r14, %rdi
callq 0x53d0
jmp 0x1468e
movq %rax, %r13
movq %r12, %rdi
callq 0x55b0
jmp 0x1469b
movq %rax, %r13
movq %r15, %rdi
callq 0x55b0
movq (%rsp), %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x15092
movq %r13, %rdi
callq 0x56c0
movq %rax, %r13
jmp 0x146a3
movq %rax, %r13
jmp 0x146ac