LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WeiqiangZhou[P]BIRD/source/create_library_function.cpp
// Function: ReadVector_d(char*, double*)
int ReadVector_d(char *infile, double *data)
{
	FILE *p_in;
	int i = 0;
	double temp_double;
	p_in = fopen(infile, "r");
	if (p_in != NULL)
	{
		std::cout << "Reading " << infile << "..." << std::endl;
		while (!feof(p_in) && fscanf(p_in, "%lf", &temp_double) == 1)
		{
			data[i] = temp_double;
			i++;
		}
		fclose(p_in);
	}
	else
	{
		std::cout << "Error! File "<<infile<<" not found!" << std::endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x1864(%rip), %rsi      # 0x543c
callq 0x2160
testq %rax, %rax
je 0x3c21
movq %rax, %r14
movq 0x33ec(%rip), %r15      # 0x6fd8
leaq 0x17fd(%rip), %rsi      # 0x53f0
movl $0x8, %edx
movq %r15, %rdi
callq 0x2150
testq %r12, %r12
je 0x3c64
movq %r12, %rdi
callq 0x2090
movq 0x33c4(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3c7c
movq 0x33b0(%rip), %rbx      # 0x6fd8
leaq 0x1956(%rip), %rsi      # 0x5585
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2150
testq %r12, %r12
je 0x3d08
movq %r12, %rdi
callq 0x2090
movq 0x3384(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3d1f
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21e0
leaq 0x16ca(%rip), %rsi      # 0x534d
movl $0x3, %edx
movq %r15, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x3cfc
leaq 0x18f8(%rip), %r15      # 0x55c2
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2220
cmpl $0x1, %eax
jne 0x3cfc
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rbx)
movq %r14, %rdi
callq 0x21b0
addq $0x8, %rbx
testl %eax, %eax
je 0x3cce
movq %r14, %rdi
callq 0x2130
xorl %eax, %eax
jmp 0x3d5f
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x21e0
leaq 0x186c(%rip), %rsi      # 0x5592
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeiqiangZhou[P]BIRD/source/create_library_function.cpp
// Function: ReadVector_i(char*, int*)
int ReadVector_i(char *infile, int *data)
{
	FILE *p_in;
	int i = 0;
	int temp_int;
	p_in = fopen(infile, "r");
	if (p_in != NULL)
	{
		std::cout << "Reading " << infile << "..." << std::endl;
		while (!feof(p_in) && fscanf(p_in, "%d", &temp_int) == 1)
		{
			data[i] = temp_int;
			i++;
		}
		fclose(p_in);
	}
	else
	{
		std::cout << "Error! File " << infile << " not found!" << std::endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x16b4(%rip), %rsi      # 0x543c
callq 0x2160
testq %rax, %rax
je 0x3dd1
movq %rax, %r14
movq 0x323c(%rip), %r15      # 0x6fd8
leaq 0x164d(%rip), %rsi      # 0x53f0
movl $0x8, %edx
movq %r15, %rdi
callq 0x2150
testq %r12, %r12
je 0x3e14
movq %r12, %rdi
callq 0x2090
movq 0x3214(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3e2c
movq 0x3200(%rip), %rbx      # 0x6fd8
leaq 0x17a6(%rip), %rsi      # 0x5585
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2150
testq %r12, %r12
je 0x3eb4
movq %r12, %rdi
callq 0x2090
movq 0x31d4(%rip), %rdi      # 0x6fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x2150
jmp 0x3ecb
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21e0
leaq 0x151a(%rip), %rsi      # 0x534d
movl $0x3, %edx
movq %r15, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x3ea8
leaq 0x1582(%rip), %r15      # 0x53fc
leaq -0x24(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2220
cmpl $0x1, %eax
jne 0x3ea8
movl -0x24(%rbp), %eax
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x21b0
addq $0x4, %rbx
testl %eax, %eax
je 0x3e7e
movq %r14, %rdi
callq 0x2130
xorl %eax, %eax
jmp 0x3f0b
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x21e0
leaq 0x16c0(%rip), %rsi      # 0x5592
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/Test/Chi_Square_test.cpp
// Function: get_frequencies(double*, double*, double*, int, int)
int* get_frequencies(double *upper, double *lower, double *items, int num_buckets, int stream_size)
{
  int *frequencies = new int[num_buckets];
  for (int i = 0; i < num_buckets; i++)
    frequencies[i] = 0;
  for (int i = 0; i < stream_size; i++)
  {
    //cout << "item: " << items[i] << " ***" << endl;
    int lo = 0, hi = num_buckets;
    while (lo <= hi)
    {
      int mid = (lo + hi) / 2;
      //cout << "mid: " << endl;
      if (items[i] <= upper[mid] && items[i] >= lower[mid])
      {
	frequencies[mid]++;
	break;
      }
      /*else if (items[i] < upper[0])
      {
	cout << "hello" << endl;
	frequencies[0]++;
	break;
      }
      else if (items[i] > lower[num_buckets-1])
      {
	cout << "hi" << endl;
	frequencies[num_buckets-1]++;
	break;
	}*/
      else if (items[i] < lower[mid])
	{
	  //	  cout << "lower, " << endl;
	hi = mid;
	}
      else
	lo = mid + 1;
    }
  }
  return frequencies;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x2c(%rbp)
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq %ecx, %rcx
movq %rcx, -0x38(%rbp)
leaq (,%rcx,4), %rax
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r13
cmpl $0x0, -0x38(%rbp)
jle 0x5e13
movl %ebx, %edx
shlq $0x2, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x2100
movl -0x2c(%rbp), %eax
testl %eax, %eax
jle 0x5e81
movl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movl %ebx, %esi
cmpl %esi, %edx
jg 0x5e79
leal (%rsi,%rdx), %r8d
movl %r8d, %edi
shrl $0x1f, %edi
addl %r8d, %edi
sarl %edi
movsd (%r14,%rcx,8), %xmm0
movslq %edi, %r8
movsd (%r12,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x5e52
ucomisd (%r15,%r8,8), %xmm0
jae 0x5e6d
movsd (%r15,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x5e65
incl %edi
movl %edi, %edx
movl %esi, %r8d
movb $0x1, %dil
movl %r8d, %esi
jmp 0x5e74
incl (%r13,%r8,4)
xorl %edi, %edi
testb %dil, %dil
jne 0x5e22
incq %rcx
cmpq %rax, %rcx
jne 0x5e1e
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/UP.cc
// Function: main
int main()
{
	// up points to an array of ten uninitialized ints
	unique_ptr<int[]> up(new int[10]);
	for (size_t i = 0; i != 10; ++i)
		up[i] = i;  // assign a new value to each of the elements
	up.release();   // automatically uses delete[] to destroy its pointer

	// to use a shared_ptr we must supply a deleter
	shared_ptr<int> sp(new int[10],
						[](int *p) {
							cout << "lambda call." << endl;
							delete[] p;
						});
	// shared_ptrs don't have subscript operator
	// and don't support pointer arithmetic
	for (size_t i = 0; i != 10; ++i)
		*(sp.get() + i) = i;  // use get to get a built-in pointer
	sp.reset(); // uses the lambda we supplied
	            // that uses delete[] to free the array
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x28, %edi
callq 0x1030
movq %rax, %rbx
movl $0x18, %edi
callq 0x10a0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2a72(%rip), %rcx      # 0x3d10
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
xorl %ecx, %ecx
movl %ecx, (%rbx,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x12a7
movq %rax, %rdi
callq 0x142e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x12f2
callq 0x10f0
movq %rax, %rbx
callq 0x1110
movq %rbx, %rdi
callq 0x1120
movq %rax, %rdi
callq 0x149a
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::VVtoW()
void Calc::VVtoW()
{
 W = VV[1][1]*VV[2][2]*VV[3][3]+VV[1][2]*VV[2][3]*VV[3][1];
 W = W+VV[1][3]*VV[3][2]*VV[2][1];
 W = W-VV[1][3]*VV[2][2]*VV[3][1]-VV[1][1]*VV[3][2]*VV[2][3];
 W = W-VV[1][2]*VV[2][1]*VV[3][3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0xd0(%rdi), %xmm2
movsd 0xa8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm6
movapd %xmm0, %xmm4
mulsd %xmm2, %xmm4
movsd 0xf8(%rdi), %xmm1
movsd 0xd8(%rdi), %xmm3
movsd 0xb8(%rdi), %xmm5
movsd 0xf0(%rdi), %xmm7
mulsd %xmm5, %xmm2
mulsd %xmm7, %xmm5
movsd 0xc8(%rdi), %xmm8
mulsd %xmm8, %xmm5
mulsd %xmm6, %xmm8
mulsd %xmm3, %xmm6
movsd 0xe8(%rdi), %xmm9
mulsd %xmm9, %xmm6
mulsd %xmm1, %xmm4
addsd %xmm6, %xmm4
addsd %xmm4, %xmm5
mulsd %xmm9, %xmm2
subsd %xmm2, %xmm5
mulsd %xmm0, %xmm7
mulsd %xmm3, %xmm7
subsd %xmm7, %xmm5
mulsd %xmm1, %xmm8
subsd %xmm8, %xmm5
movsd %xmm5, 0x290(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::YY1toFH(bool)
void Calc::YY1toFH(bool flipped)
{
  double C = MathLib::sqrt(sqr(YY[1][1])+sqr(YY[2][1]));

  // Since C is always non-negative, H will be between -90 and 90 degrees.
  if (C==0 && YY[3][1]==0)
    H = 0;  // Undefined result!
  else
    H = MathLib::atan2(YY[3][1], C);

  if (C==0)
    F = 1; // Elevation is +-90 deg, so az is arbitrary.
  else {
    // Note: Since C>0, both YY[2][1] and YY[1][1] must be != 0.
    F = MathLib::atan2(YY[2][1], YY[1][1]);
    // The atan2() function provides a 4-quadrant result, but in
    // the -p...pi range instead of 0...2*pi.
    if (F<0)
      F += (2*pi);
  }

  // No longer any need to clip F to 0..2*pi.

  // If desired, convert the result to flipped mode.
  if (flipped) {
    // Flip the elevation to the other side of the zenith.
    if (H >= 0)
      H = pi - H;
    else
      H = -pi - H;

    // Rotate (not flip) the azimuth 180 degrees.
    F -= pi;
    if (F<0)
      F += (2*pi);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movsd 0x228(%rdi), %xmm1
movsd 0x248(%rdi), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
callq 0x57ec
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
movsd 0x268(%rbx), %xmm1
jne 0x3a3e
jp 0x3a3e
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x3a3e
jnp 0x3a55
movapd %xmm1, %xmm0
movapd %xmm3, %xmm1
movsd %xmm3, -0x18(%rbp)
callq 0x571a
movsd -0x18(%rbp), %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
movsd %xmm0, 0x288(%rbx)
jne 0x3a7c
jp 0x3a7c
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x280(%rbx)
jmp 0x3ab3
movsd 0x228(%rbx), %xmm1
movsd 0x248(%rbx), %xmm0
callq 0x571a
movsd %xmm0, 0x280(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3ab3
addsd 0x2855d(%rip), %xmm0    # 0x2c008
movsd %xmm0, 0x280(%rbx)
testb %r14b, %r14b
je 0x3b13
movsd 0x280(%rbx), %xmm0
movsd 0x288(%rbx), %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm1
setb %al
leaq 0x285a4(%rip), %rcx     # 0x2c080
movsd (%rcx,%rax,8), %xmm3
subsd %xmm1, %xmm3
addsd 0x28523(%rip), %xmm0    # 0x2c010
movsd %xmm3, 0x288(%rbx)
movsd %xmm0, 0x280(%rbx)
ucomisd %xmm0, %xmm2
jbe 0x3b13
addsd 0x284fd(%rip), %xmm0    # 0x2c008
movsd %xmm0, 0x280(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::AzEltoYY0()
void Calc::AzEltoYY0()
{
  H += Z3;
  YY[1][0] = MathLib::cos(F)*MathLib::cos(H) - MathLib::sin(F)*Z2 + MathLib::sin(F)*MathLib::sin(H)*Z1;
  YY[2][0] = MathLib::sin(F)*MathLib::cos(H) + MathLib::cos(F)*Z2 - MathLib::cos(F)*MathLib::sin(H)*Z1;
  YY[3][0] = MathLib::sin(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x280(%rdi), %xmm0
movsd 0x308(%rdi), %xmm1
addsd 0x288(%rdi), %xmm1
movsd %xmm1, 0x288(%rdi)
callq 0x5724
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5724
movsd %xmm0, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x572e
mulsd 0x300(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x572e
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x572e
mulsd -0x10(%rbp), %xmm0
mulsd 0x2f8(%rbx), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x220(%rbx)
movsd 0x280(%rbx), %xmm0
callq 0x572e
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x5724
movsd %xmm0, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5724
mulsd 0x300(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x280(%rbx), %xmm0
callq 0x5724
movsd %xmm0, -0x10(%rbp)
movsd 0x288(%rbx), %xmm0
callq 0x572e
mulsd -0x10(%rbp), %xmm0
mulsd 0x2f8(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x240(%rbx)
movsd 0x288(%rbx), %xmm0
callq 0x572e
movsd %xmm0, 0x260(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::ApparentToTrueAzEl()
void Calc::ApparentToTrueAzEl()
{
  int J;

  AzEltoYY0();
  for (J=1; J<=3; J++)
    YY[J][1] = YY[J][0];
  YY1toFH(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3b1c
movl $0x228, %eax            # imm = 0x228
movsd -0x8(%rbx,%rax), %xmm0
movsd %xmm0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x288, %rax            # imm = 0x288
jne 0x3def
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x39e8
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::calcApparentSeparation()
double Calc::calcApparentSeparation()
{
  double corrAz1, corrAz2, corrEl1, corrEl2;

  F = alignAz[1];
  H = alignEl[1];
  ApparentToTrueAzEl();
  corrAz1 = F;
  corrEl1 = H;

  F = alignAz[2];
  H = alignEl[2];
  ApparentToTrueAzEl();
  corrAz2 = F;
  corrEl2 = H;

  return calcSeparation(corrAz1, corrEl1, corrAz2, corrEl2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x2a0(%rdi), %xmm0
movsd 0x2b8(%rdi), %xmm1
movsd %xmm0, 0x280(%rdi)
movsd %xmm1, 0x288(%rdi)
callq 0x3ddc
movsd 0x280(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x288(%rbx), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2a8(%rbx), %xmm0
movsd %xmm0, 0x280(%rbx)
movsd 0x2c0(%rbx), %xmm0
movsd %xmm0, 0x288(%rbx)
movq %rbx, %rdi
callq 0x3ddc
movsd 0x280(%rbx), %xmm2
movsd 0x288(%rbx), %xmm3
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x3eae
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::calcSeparation(double, double, double, double)
double Calc::calcSeparation(double az1, double el1, double az2, double el2)
{
  double cossep;

  cossep = (MathLib::sin(el1)*MathLib::sin(el2)) + (MathLib::cos(el1)*MathLib::cos(el2)*MathLib::cos(az1-az2));

  // Avoid a domain error for acos due to rounding.
  if (cossep >= 1.0)
    return 0.0;
  if (cossep <= -1.0)
    return pi;

  return MathLib::acos(cossep);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm3, -0x8(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x20(%rbp)
movaps %xmm1, %xmm0
callq 0x572e
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x572e
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x5724
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5724
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x5724
movsd -0x18(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd 0x280e9(%rip), %xmm1    # 0x2c020
jae 0x3f5d
movsd 0x280ef(%rip), %xmm0    # 0x2c030
ucomisd %xmm1, %xmm0
jae 0x3f55
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
jmp 0x56fc
movsd 0x280cb(%rip), %xmm0    # 0x2c028
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::setAlignmentData(int, double, double, double, double, double)
void Calc::setAlignmentData(int i, double ra, double dec,
		      double az, double el, double time)
{

  if (i<0 || i>1)
    return;

  i++;  // I must be 1 or 2 to index the arrays!

  // This entire package measures azimuth backwards!
  alignAz[i] = (360.0-az)*radPerDeg;
  alignEl[i] = el*radPerDeg;
  alignRA[i] =  (ra-degreesPerMinute*time)/degPerRad;
  alignDec[i] =  dec/degPerRad;
}

// Assembly:
cmpl $0x1, %esi
ja 0x44c2
pushq %rbp
movq %rsp, %rbp
movsd 0x27bfd(%rip), %xmm5    # 0x2c068
subsd %xmm2, %xmm5
movsd 0x27be9(%rip), %xmm2    # 0x2c060
mulsd %xmm2, %xmm5
movl %esi, %eax
movsd %xmm5, 0x2a0(%rdi,%rax,8)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x2b8(%rdi,%rax,8)
mulsd 0x27bd5(%rip), %xmm4    # 0x2c070
addsd %xmm0, %xmm4
movsd 0x27bb1(%rip), %xmm0    # 0x2c058
divsd %xmm0, %xmm4
movsd %xmm4, 0x2d0(%rdi,%rax,8)
divsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rdi,%rax,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::EqToAzEl(double, double, double, bool, double*, double*)
void Calc::EqToAzEl(double ra, double dec, double time, bool flipped, double *azptr, double *elptr)
{
  int I, J;

  double RA = ra;
  double DEC = dec;

  DEC=DEC/degPerRad;
  RA=(RA-degreesPerMinute*time)/degPerRad;
  XX[1][1]=MathLib::cos(DEC)*MathLib::cos(RA);
  XX[2][1]=MathLib::cos(DEC)*MathLib::sin(RA);
  XX[3][1]=MathLib::sin(DEC);

  YY[1][1]=0; YY[2][1]=0; YY[3][1]=0;
  for (I=1; I<=3; I++) {
    for (J=1; J<=3; J++) {
      YY[I][1] += (RR[I][J]*XX[J][1]);
    }
  }

  YY1toFH(flipped);

  TrueToApparentAzEl(flipped);

  F *= degPerRad;
  H *= degPerRad;

  // This code measures azimuth backwards!
  F = 360.0-F;

  if (azptr)
    *azptr = F;

  if (elptr)
    *elptr = H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movsd 0x27557(%rip), %xmm3    # 0x2c058
divsd %xmm3, %xmm1
movsd %xmm1, -0x38(%rbp)
mulsd 0x2755e(%rip), %xmm2    # 0x2c070
addsd %xmm2, %xmm0
divsd %xmm3, %xmm0
movsd %xmm0, -0x30(%rbp)
movapd %xmm1, %xmm0
callq 0x5724
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x5724
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x1a8(%r14)
movsd -0x38(%rbp), %xmm0
callq 0x5724
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x572e
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x1c8(%r14)
movsd -0x38(%rbp), %xmm0
callq 0x572e
movsd %xmm0, 0x1e8(%r14)
leaq 0x200(%r14), %rax
xorl %ecx, %ecx
movq %rcx, 0x228(%r14)
movq %rcx, 0x248(%r14)
movq %rcx, 0x268(%r14)
leaq 0x128(%r14), %rcx
movl $0x1, %edx
movq %rdx, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
addq $0x8, %rsi
movsd (%rsi), %xmm0
xorl %edi, %edi
movsd (%rcx,%rdi), %xmm1
mulsd 0x1a8(%r14,%rdi,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rdi
cmpq $0x18, %rdi
jne 0x4bbd
incq %rdx
addq $0x20, %rcx
cmpq $0x4, %rdx
jne 0x4ba9
movzbl %r12b, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x39e8
movq %r14, %rdi
callq 0x3c6a
movq %r14, %rdi
movl %r12d, %esi
callq 0x39e8
movsd 0x288(%r14), %xmm0
subsd 0x308(%r14), %xmm0
movsd 0x280(%r14), %xmm1
movsd 0x27428(%rip), %xmm2    # 0x2c058
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm0
movsd %xmm0, 0x288(%r14)
movsd 0x2741f(%rip), %xmm0    # 0x2c068
subsd %xmm1, %xmm0
movsd %xmm0, 0x280(%r14)
testq %r15, %r15
je 0x4c60
movsd %xmm0, (%r15)
testq %rbx, %rbx
je 0x4c72
movsd 0x288(%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Calc.cpp
// Function: Calc::AzElToEq(double, double, double, double*, double*)
void Calc::AzElToEq(double az, double el, double time, double *raptr, double *decptr)
{
  int I, J;

  F = 360.0 - az; // This code measures azimuth backwards!
  H = el;

  F *= radPerDeg;
  H *= radPerDeg;

  AzEltoYY0();
  XX[1][1]=YY[1][0]; XX[2][1]=YY[2][0]; XX[3][1]=YY[3][0];
  YY[1][1]=0; YY[2][1]=0; YY[3][1]=0;

  for (I=1; I<=3; I++) {
    for (J=1; J<=3; J++) {
      YY[I][1] += (QQ[I][J]*XX[J][1]);
    }
  }
  YY1toFH(false);

  F *= degPerRad;
  H *= degPerRad;

  F += degreesPerMinute*time;

  F=F-MathLib::floor(F/360)*360;
  //F = fmod(F, 360.0);

  if (raptr)
    *raptr = F;

  if (decptr)
    *decptr = H;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movsd %xmm2, -0x20(%rbp)
movq %rdi, %r14
movsd 0x273c8(%rip), %xmm2    # 0x2c068
subsd %xmm0, %xmm2
movsd 0x273b4(%rip), %xmm0    # 0x2c060
mulsd %xmm0, %xmm2
movsd %xmm2, 0x280(%rdi)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x288(%rdi)
callq 0x3b1c
leaq 0x200(%r14), %rax
movsd 0x220(%r14), %xmm0
movsd 0x240(%r14), %xmm1
movsd %xmm0, 0x1a8(%r14)
movsd %xmm1, 0x1c8(%r14)
movsd 0x260(%r14), %xmm0
movsd %xmm0, 0x1e8(%r14)
xorl %ecx, %ecx
movq %rcx, 0x228(%r14)
movq %rcx, 0x248(%r14)
movq %rcx, 0x268(%r14)
leaq 0x28(%r14), %rcx
movl $0x1, %edx
movq %rdx, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
addq $0x8, %rsi
movsd (%rsi), %xmm0
xorl %edi, %edi
movsd (%rcx,%rdi), %xmm1
mulsd 0x1a8(%r14,%rdi,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rdi
cmpq $0x18, %rdi
jne 0x4d3a
incq %rdx
addq $0x20, %rcx
cmpq $0x4, %rdx
jne 0x4d26
movq %r14, %rdi
xorl %esi, %esi
callq 0x39e8
movsd 0x272de(%rip), %xmm0    # 0x2c058
movsd 0x280(%r14), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x288(%r14), %xmm0
movsd %xmm0, 0x288(%r14)
movsd -0x20(%rbp), %xmm0
mulsd 0x272d2(%rip), %xmm0    # 0x2c078
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd %xmm0, 0x280(%r14)
movsd 0x272a8(%rip), %xmm1    # 0x2c068
divsd %xmm1, %xmm0
callq 0x584e
movsd -0x20(%rbp), %xmm1
mulsd 0x27292(%rip), %xmm0    # 0x2c068
subsd %xmm0, %xmm1
movsd %xmm1, 0x280(%r14)
testq %r15, %r15
je 0x4ded
movsd %xmm1, (%r15)
testq %rbx, %rbx
je 0x4dff
movsd 0x288(%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Data.cpp
// Function: Data::Data(StarData&, StarData&)
Data::Data(StarData& starData1, StarData& starData2)
: starData1(starData1), starData2(starData2),
epochReference(0), elEncoderOffset(0)
{
    //ctor
    curAz = NAN;
    curEl = NAN;

    aligned = false;

    targetRA = 0.0;
    targetDec = 0.0;

    targetAz = NAN;
    targetEl = NAN;

    //Avoid diving by 0
    azEncoderRes = 8192;

    Z1 = 0.0;
    Z2 = 0.0;
    Z3 = 0.0;

    //Default is 10
    encoderReadRate = 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x308(%rdi)
xorl %eax, %eax
movq %rax, 0x318(%rdi)
leaq 0x358(%rdi), %rcx
movq %rcx, 0x348(%rdi)
movq %rax, 0x350(%rdi)
movb %al, 0x358(%rdi)
movl %eax, 0x368(%rdi)
movl %eax, 0x3ac(%rdi)
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
movq %rcx, 0x378(%rdi)
movq %rcx, 0x380(%rdi)
movb %al, 0x320(%rdi)
movups %xmm0, 0x328(%rdi)
movq %rcx, 0x338(%rdi)
movq %rcx, 0x340(%rdi)
movl $0x2000, 0x388(%rdi)    # imm = 0x2000
movups %xmm0, 0x390(%rdi)
movq %rax, 0x3a0(%rdi)
movl $0xa, 0x3a8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Data.cpp
// Function: Data::updateCurrentAzEl(int, int)
void Data::updateCurrentAzEl(int azpos, int elpos)
{
    curAzCount = azpos;
    curElCount = elpos;

    // Get the az value into the 0 .. res-1 range
    while (azpos >= azEncoderRes)
    {
        azpos -= azEncoderRes;
    }

    while (azpos < 0)
    {
        azpos += azEncoderRes;
    }

    // Convert az to 0..360.0 range
    curAz = (double)azpos / azEncoderRes * 360.0;

    // Apply the elevation zero correction that was established during
    // encoder reset.
    elpos -= elEncoderOffset;

    while (elpos >= (elEncoderRes/2))
    {
      elpos -= elEncoderRes;
    }

    while (elpos < -(elEncoderRes/2))
    {
      elpos += elEncoderRes;
    }

    curEl = (double)elpos / elEncoderRes * 360.0;
}

// Assembly:
movl %edx, %ecx
movl %esi, 0x36c(%rdi)
movl %edx, 0x370(%rdi)
movl 0x388(%rdi), %r8d
addl %r8d, %esi
movl %esi, %edx
negl %edx
subl %r8d, %esi
addl %r8d, %edx
cmpl %r8d, %esi
jge 0x50a6
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
xorl %r9d, %r9d
cmpl %esi, %eax
setne %r9b
cmpl $0x1, %r8d
movl %r8d, %r10d
adcl $0x0, %r10d
subl %r9d, %eax
addl %edx, %eax
xorl %edx, %edx
divl %r10d
addl %r9d, %eax
imull %r8d, %eax
addl %esi, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sd %r8d, %xmm1
divsd %xmm1, %xmm0
mulsd 0x26f70(%rip), %xmm0    # 0x2c068
movsd %xmm0, 0x378(%rdi)
movl 0x38c(%rdi), %esi
movl 0x3ac(%rdi), %edx
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
leal (%rsi,%rcx), %r8d
subl %edx, %r8d
subl %esi, %edx
subl %ecx, %edx
subl %esi, %r8d
addl %esi, %edx
cmpl %eax, %r8d
jge 0x5120
negl %eax
cmpl %r8d, %eax
cmovlel %r8d, %eax
xorl %ecx, %ecx
cmpl %eax, %r8d
setne %cl
cmpl $0x1, %esi
movl %esi, %r9d
adcl $0x0, %r9d
subl %ecx, %eax
addl %edx, %eax
xorl %edx, %edx
divl %r9d
addl %ecx, %eax
imull %esi, %eax
addl %r8d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x26ef8(%rip), %xmm0    # 0x2c068
movsd %xmm0, 0x380(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Data.cpp
// Function: Data::calculateTargetAzEl()
void Data::calculateTargetAzEl()
{
    targetAz = NAN;
    targetEl = NAN;

    // If we have valid alignment data,
    // recalculate everything based on the current position and time,
    // and update the form's result fields.

    if(isAligned() && finite(targetRA) && finite(targetDec))
    {
        calc.EqToAzEl(targetRA, targetDec, Util::getEffectiveTime(),
	      false, &targetAz, &targetEl);

        setTargetAzEl(targetAz, targetEl);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, 0x338(%rdi)
movq %rax, 0x340(%rdi)
cmpb $0x1, 0x320(%rdi)
jne 0x51e3
movq %rdi, %rbx
movq 0x328(%rdi), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %rcx
jg 0x51e3
movq 0x330(%rbx), %xmm1
movq %xmm1, %rcx
btrq $0x3f, %rcx
cmpq %rax, %rcx
jle 0x51ee
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x338(%rbx), %r14
leaq 0x340(%rbx), %r15
addq $0x10, %rbx
movq %xmm0, -0x20(%rbp)
movq %xmm1, -0x28(%rbp)
callq 0x2b232
cvtsi2sd %rax, %xmm2
movq %rbx, %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ade
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Data.cpp
// Function: Data::CalculateAzElError(double*, double*)
void Data::CalculateAzElError(double *azPtr, double *elPtr)
{
    double azErr, elErr;

    if (finite(curAz) &&
        finite(curEl) &&
        finite(targetAz) &&
        finite(targetEl)) {

            azErr = Util::diff180(targetAz, curAz);
            elErr = Util::diff180(targetEl, curEl);

      } else {

            azErr = NAN;
            elErr = NAN;
      }

    //If pointers are not NULL, affect them
    if (azPtr)
    {
        *azPtr = azErr;
    }
    if (elPtr)
    {
        *elPtr = elErr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x378(%rdi), %xmm1
movq %xmm1, %rcx
btrq $0x3f, %rcx
movsd 0x26f26(%rip), %xmm3    # 0x2c188
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %rcx
jg 0x52a5
movq %rdi, %r15
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq 0x380(%rdi), %rdx
andq %rcx, %rdx
cmpq %rax, %rdx
jg 0x52a5
movq 0x338(%r15), %xmm2
movq %xmm2, %rdx
btrq $0x3f, %rdx
cmpq %rax, %rdx
jle 0x52c6
movaps %xmm3, %xmm0
testq %r14, %r14
je 0x52b2
movsd %xmm3, (%r14)
testq %rbx, %rbx
je 0x52bb
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq 0x340(%r15), %rcx
movaps %xmm3, %xmm0
cmpq %rax, %rcx
jg 0x52a8
movdqa %xmm2, %xmm0
callq 0x2b070
movq %xmm0, -0x20(%rbp)
movsd 0x340(%r15), %xmm0
movq 0x380(%r15), %xmm1
callq 0x2b070
movsd -0x20(%rbp), %xmm3
jmp 0x52a8
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/./StarData.h
// Function: starDataNamespace::validStarData(StarData&)
static bool validStarData(StarData& sd)
    {
      return (  MathLib::finite(sd.ra) &&
                MathLib::finite(sd.dec) &&
                MathLib::finite(sd.az) &&
                MathLib::finite(sd.el) &&
                sd.time >= 0.0 &&
                sd.ra >= 0.0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
callq 0x5884
testl %eax, %eax
je 0x5363
movsd 0x20(%rbx), %xmm0
callq 0x5884
testl %eax, %eax
je 0x5363
movsd 0x8(%rbx), %xmm0
callq 0x5884
testl %eax, %eax
je 0x5363
movsd 0x10(%rbx), %xmm0
callq 0x5884
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x5365
movsd 0x28(%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x5365
movsd 0x18(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0x5365
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Encoder.cpp
// Function: Encoder::setup_encoder()
void Encoder::setup_encoder()
{
    register_to_callback();

    value = 0;
    last_encoded = 0;

    pinMode(pin_a, INPUT);
    pinMode(pin_b, INPUT);
    pullUpDnControl(pin_a, PUD_UP);
    pullUpDnControl(pin_b, PUD_UP);
    wiringPiISR(pin_a, INT_EDGE_BOTH, call_back_encoder_ptr);
    wiringPiISR(pin_b, INT_EDGE_BOTH, call_back_encoder_ptr);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd6(%rip), %rax        # 0x5530
movq %rax, 0x18(%rdi)
leaq -0x10(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x34e94(%rip), %rdi     # 0x3a300
callq 0x5582
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Encoder.cpp
// Function: Encoder::update_encoder()
void Encoder::update_encoder()
{
    int MSB = digitalRead(pin_a);
    int LSB = digitalRead(pin_b);

    int encoded = (MSB << 1) | LSB;
    int sum = (last_encoded << 2) | encoded;

    if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011)
    {
        value++;
    }

    if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000)
    {
        value--;
    }

    last_encoded = encoded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x34e80(%rip), %eax     # 0x3a318
leal 0x1(%rax), %ecx
leal 0x2(%rax), %edx
movl %edx, 0x34e74(%rip)     # 0x3a318
addl %eax, %eax
orl %ecx, %eax
movl 0x10(%rdi), %ecx
shll $0x2, %ecx
orl %eax, %ecx
cmpl $0xe, %ecx
ja 0x54d6
movl $0x2814, %edx           # imm = 0x2814
btl %ecx, %edx
jae 0x54c8
incq 0x8(%rdi)
cmpl $0xe, %ecx
ja 0x54d6
movl $0x4182, %edx           # imm = 0x4182
btl %ecx, %edx
jae 0x54d6
decq 0x8(%rdi)
movl %eax, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/StarData.cpp
// Function: StarData::StarData()
StarData::StarData()
{
    //ctor
    az = NAN;
    el = NAN;
    ra = NAN;
    dec = NAN;
    time = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::run_all()
void Test::run_all()
{
    try
    {
        //test_Thread();
        test_StarData();
        test_StarDataNamespaceFunctions();
        test_MathLib_trigonometric();
        test_MathLib_exponential_logarithmic();
        test_MathLib_hyperbolic();
        test_power();
        test_nearest_absolute_remainder();
        test_miscellaneous();
        test_Util();
        test_Encoder();
        test_Data();
        test_Object();
    }
    catch(const std::exception& fail)
    {
        std::cerr << fail.what() << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2681c
movq %rbx, %rdi
callq 0x26a66
movq %rbx, %rdi
callq 0x26c1e
movq %rbx, %rdi
callq 0x270f4
movq %rbx, %rdi
callq 0x2752e
movq %rbx, %rdi
callq 0x27740
movq %rbx, %rdi
callq 0x27946
movq %rbx, %rdi
callq 0x27a96
movq %rbx, %rdi
callq 0x2815a
movq %rbx, %rdi
callq 0x2845e
movq %rbx, %rdi
callq 0x285e4
movq %rbx, %rdi
callq 0x2894a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2680c
movq %rbx, %rdi
callq 0x3100
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x137ff(%rip), %rdi     # 0x39fe8
movq %rax, %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x3120
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3420
movq %rax, %rbx
callq 0x3420
movq %rbx, %rdi
callq 0x34b0
movq %rax, %rdi
callq 0x2620a
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_StarDataNamespaceFunctions()
void Test::test_StarDataNamespaceFunctions()
{
    setUpErrorMessage("test_StarDataNamespaceFunctions() - failed");

    StarData starData1;
    StarData starData2;

    starData1.az = 1;
    starData1.el = 2;
    starData1.ra = 3;
    starData1.dec = 4;
    starData1.time = 5;

    starData2.az = 1;
    starData2.el = 2;
    starData2.ra = 3;
    starData2.dec = 4;
    starData2.time = 5;

    assertTrue(starDataNamespace::validStarData(starData1));
    assertTrue(starDataNamespace::validStarData(starData2));

    assertTrue(starDataNamespace::validAlignementData(starData1, starData2));

    starDataNamespace::clearAlignmentData(starData1, starData2);

    assertTrue(!starDataNamespace::validAlignementData(starData1, starData2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xb1d8(%rip), %rsi      # 0x31c60
leaq 0xb1fb(%rip), %rdx      # 0x31c8a
leaq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x4e0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e38
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x26abb
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x32e0
leaq -0x98(%rbp), %rdi
callq 0x2670c
leaq -0x48(%rbp), %rdi
callq 0x2670c
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x98(%rbp), %rdi
movq %rax, 0x8(%rdi)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0x10(%rdi)
movabsq $0x4008000000000000, %rdx # imm = 0x4008000000000000
movq %rdx, 0x18(%rdi)
movabsq $0x4010000000000000, %rsi # imm = 0x4010000000000000
movq %rsi, 0x20(%rdi)
movabsq $0x4014000000000000, %r8 # imm = 0x4014000000000000
movq %r8, 0x28(%rdi)
movq %rax, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x20(%rbp)
callq 0x28b69
movzbl %al, %esi
movq %rbx, %rdi
callq 0x291ce
leaq -0x48(%rbp), %rdi
callq 0x28b69
movzbl %al, %esi
movq %rbx, %rdi
callq 0x291ce
leaq -0x98(%rbp), %rdi
callq 0x28b69
testb %al, %al
je 0x26b70
leaq -0x48(%rbp), %rdi
callq 0x28b69
jmp 0x26b72
xorl %eax, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x291ce
leaq -0x98(%rbp), %rdi
callq 0x2673a
leaq -0x48(%rbp), %rdi
callq 0x2673a
leaq -0x98(%rbp), %rdi
callq 0x28b69
testb %al, %al
je 0x26bad
leaq -0x48(%rbp), %rdi
callq 0x28b69
jmp 0x26baf
xorl %eax, %eax
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x291ce
leaq -0x48(%rbp), %rdi
callq 0x26734
leaq -0x98(%rbp), %rdi
callq 0x26734
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x26c0a
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x26c16
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x32e0
jmp 0x26c16
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x26734
leaq -0x98(%rbp), %rdi
callq 0x26734
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_power()
void Test::test_power()
{
    setUpErrorMessage("test_power() - failed");

    assertEquals(8.0, MathLib::pow(2, 3));
    assertEquals(0.001, MathLib::pow(0.1, 3));
    assertEquals(10000.0, MathLib::pow(10, 4));

    assertEquals(25.0, MathLib::sqrt(625));
    assertEquals(11.0, MathLib::sqrt(121));
    assertEquals(3.0, MathLib::sqrt(9));
    assertEquals(11.09053, MathLib::sqrt(123));

    //hypotenuse of the right triangle
    assertEquals(5.0, MathLib::hypot(3,4));
    assertEquals(6.40312, MathLib::hypot(4,5));

    assertEquals(2.0, MathLib::cbrt(8.0));
    assertEquals(5.0, MathLib::cbrt(125.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa5c6(%rip), %rsi      # 0x31d25
leaq 0xa5d4(%rip), %rdx      # 0x31d3a
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4e0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e38
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x27792
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
movsd 0xa2be(%rip), %xmm0     # 0x31a58
movsd 0xa2be(%rip), %xmm1     # 0x31a60
callq 0x57e2
movaps %xmm0, %xmm1
movsd 0x4ffe(%rip), %xmm0     # 0x2c7b0
movq %rbx, %rdi
callq 0x2943c
movsd 0xa35e(%rip), %xmm0     # 0x31b20
movsd 0xa296(%rip), %xmm1     # 0x31a60
callq 0x57e2
movaps %xmm0, %xmm1
movsd 0xa34e(%rip), %xmm0     # 0x31b28
movq %rbx, %rdi
callq 0x2943c
movsd 0x5d46(%rip), %xmm0     # 0x2d530
movsd 0xa276(%rip), %xmm1     # 0x31a68
callq 0x57e2
movaps %xmm0, %xmm1
movsd 0xa32e(%rip), %xmm0     # 0x31b30
movq %rbx, %rdi
callq 0x2943c
movsd 0xa326(%rip), %xmm0     # 0x31b38
callq 0x57ec
movaps %xmm0, %xmm1
movsd 0xa31e(%rip), %xmm0     # 0x31b40
movq %rbx, %rdi
callq 0x2943c
movsd 0xa316(%rip), %xmm0     # 0x31b48
callq 0x57ec
movaps %xmm0, %xmm1
movsd 0xa30e(%rip), %xmm0     # 0x31b50
movq %rbx, %rdi
callq 0x2943c
movsd 0xa306(%rip), %xmm0     # 0x31b58
callq 0x57ec
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa1fb(%rip), %xmm0     # 0x31a60
callq 0x2943c
movsd 0xa2ee(%rip), %xmm0     # 0x31b60
callq 0x57ec
movaps %xmm0, %xmm1
movsd 0xa2e6(%rip), %xmm0     # 0x31b68
movq %rbx, %rdi
callq 0x2943c
movsd 0xa1ce(%rip), %xmm0     # 0x31a60
movsd 0xa1ce(%rip), %xmm1     # 0x31a68
callq 0x5806
movaps %xmm0, %xmm1
movsd 0xa1c6(%rip), %xmm0     # 0x31a70
movq %rbx, %rdi
callq 0x2943c
movsd 0xa1ae(%rip), %xmm0     # 0x31a68
movsd 0xa1ae(%rip), %xmm1     # 0x31a70
callq 0x5806
movaps %xmm0, %xmm1
movsd 0xa29e(%rip), %xmm0     # 0x31b70
movq %rbx, %rdi
callq 0x2943c
movsd 0x4ece(%rip), %xmm0     # 0x2c7b0
callq 0x582c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa163(%rip), %xmm0     # 0x31a58
callq 0x2943c
movsd 0xa276(%rip), %xmm0     # 0x31b78
callq 0x582c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa15b(%rip), %xmm0     # 0x31a70
callq 0x2943c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2793d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_nearest_absolute_remainder()
void Test::test_nearest_absolute_remainder()
{
    setUpErrorMessage("test_nearest_absolute_remainder() - failed");

    //next nearest integer
    assertEquals(4.0, MathLib::ceil(pi));
    assertEquals(3.0, MathLib::ceil(2.987));

    assertEquals(3.0, MathLib::fabs(-3.0));
    assertEquals(3.0, MathLib::fabs(3.0));

    //previous nearest integer
    assertEquals(3.0, MathLib::floor(pi));
    assertEquals(2.0, MathLib::floor(2.987));

    assertEquals(36.0, fmod(4587, 123));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa3d6(%rip), %rsi      # 0x31d3b
leaq 0xa3f9(%rip), %rdx      # 0x31d65
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4e0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e38
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x27998
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
movsd 0x4688(%rip), %xmm0     # 0x2c028
callq 0x5836
movaps %xmm0, %xmm1
movsd 0xa0b8(%rip), %xmm0     # 0x31a68
movq %rbx, %rdi
callq 0x2943c
movsd 0xa1c0(%rip), %xmm0     # 0x31b80
callq 0x5836
movaps %xmm0, %xmm1
movsd 0xa090(%rip), %xmm0     # 0x31a60
movq %rbx, %rdi
callq 0x2943c
movsd 0x5b80(%rip), %xmm0     # 0x2d560
callq 0x5840
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa06d(%rip), %xmm0     # 0x31a60
callq 0x2943c
movsd 0xa060(%rip), %xmm0     # 0x31a60
callq 0x5840
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa04d(%rip), %xmm0     # 0x31a60
callq 0x2943c
movsd 0x4608(%rip), %xmm0     # 0x2c028
callq 0x584e
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0xa02d(%rip), %xmm0     # 0x31a60
callq 0x2943c
movsd 0xa140(%rip), %xmm0     # 0x31b80
callq 0x584e
movaps %xmm0, %xmm1
movsd 0xa008(%rip), %xmm0     # 0x31a58
movq %rbx, %rdi
callq 0x2943c
movsd 0xa128(%rip), %xmm0     # 0x31b88
movq %rbx, %rdi
movaps %xmm0, %xmm1
callq 0x2943c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x27a8e
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_Encoder()
void Test::test_Encoder()
{
    setUpErrorMessage("test_Encoder() - failed");

    Encoder encoder(23, 24);
    assertEquals(23, encoder.pin_a);
    assertEquals(24, encoder.pin_b);

    assertEquals(1, Encoder::_encoders_ptr.size());

    Encoder encoder2(21, 22);
    assertEquals(21, encoder2.pin_a);
    assertEquals(22, encoder2.pin_b);

    assertEquals(2, Encoder::_encoders_ptr.size());

    encoderNameSpace::_callback();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x991c(%rip), %rsi      # 0x31d99
leaq 0x992c(%rip), %rdx      # 0x31db0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4e0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e38
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x284b0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movl $0x17, %esi
movl $0x18, %edx
callq 0x5408
movl (%r14), %edx
movq %rbx, %rdi
movl $0x17, %esi
callq 0x29c7a
movl -0x74(%rbp), %edx
movq %rbx, %rdi
movl $0x18, %esi
callq 0x29c7a
leaq 0x11e13(%rip), %r14     # 0x3a300
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29c7a
leaq -0x58(%rbp), %rdi
movl $0x15, %esi
movl $0x16, %edx
callq 0x5408
movl -0x58(%rbp), %edx
movq %rbx, %rdi
movl $0x15, %esi
callq 0x29c7a
movl -0x54(%rbp), %edx
movq %rbx, %rdi
movl $0x16, %esi
callq 0x29c7a
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x29c7a
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x28586
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rdi
callq 0x548e
incq %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x28564
leaq -0x58(%rbp), %rdi
callq 0x5488
leaq -0x78(%rbp), %rdi
callq 0x5488
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x285c1
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x285db
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
jmp 0x285db
jmp 0x285c6
movq %rax, %rbx
jmp 0x285d2
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5488
leaq -0x78(%rbp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_Object()
void Test::test_Object()
{
    setUpErrorMessage("test_Object() - failed");

    Object object("dsfds", 22, 22, "dsq");

    Object::fill();
    assertEquals(485, Object::_objects_ptr.size());
    assertEquals(485, Object::_objects_ptr.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x9491(%rip), %rsi      # 0x31dfd
leaq 0x94a0(%rip), %rdx      # 0x31e13
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x4e0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e38
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2899f
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x32e0
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x9466(%rip), %rsi      # 0x31e14
leaq 0x9464(%rip), %rdx      # 0x31e19
leaq -0x58(%rbp), %rdi
callq 0x4e0a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x944d(%rip), %rsi      # 0x31e1a
leaq 0x9449(%rip), %rdx      # 0x31e1d
leaq -0x38(%rbp), %rdi
callq 0x4e0a
leaq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movsd 0x9260(%rip), %xmm0     # 0x31c50
leaq -0x38(%rbp), %rdx
movaps %xmm0, %xmm1
callq 0x592c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x28a11
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x28a26
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x32e0
callq 0x5b00
leaq 0x118f6(%rip), %r14     # 0x3a328
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %edx # imm = 0xCCCCCCCD
movq %rbx, %rdi
movl $0x1e5, %esi            # imm = 0x1E5
callq 0x29c7a
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %edx # imm = 0xCCCCCCCD
movq %rbx, %rdi
movl $0x1e5, %esi            # imm = 0x1E5
callq 0x29c7a
leaq -0xc8(%rbp), %rdi
callq 0x59c0
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x28aa5
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32e0
jmp 0x28aa5
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x28ae2
movq -0x48(%rbp), %rsi
jmp 0x28ac9
movq %rax, %rbx
jmp 0x28ae2
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x28ae2
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x32e0
jmp 0x28ae2
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x59c0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_Thread()
void Test::test_Thread()
{
    Thread * t = new ThreadEncoderReader();
    Thread * t2  = new ThreadTargetCalculator();
    t->start();
    t2->start();
    t->join();
    t2->join();
    delete(t);
    delete(t2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x10, %edi
callq 0x32d0
movq %rax, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
leaq 0x111a1(%rip), %rax     # 0x39cb0
movq %rax, (%rbx)
movl $0x10, %edi
callq 0x32d0
movq %rax, %r14
movq %r15, 0x8(%rax)
leaq 0x111fe(%rip), %rax     # 0x39d28
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x28be2
movq %r14, %rdi
callq 0x28be2
movq %rbx, %rdi
callq 0x28c84
movq %r14, %rdi
callq 0x28c84
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)