LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x36c(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x370(%rax)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x388(%rcx), %eax
jl 0x62ab
movq -0x18(%rbp), %rax
movl 0x388(%rax), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x6288
jmp 0x62ad
cmpl $0x0, -0xc(%rbp)
jge 0x62c5
movq -0x18(%rbp), %rax
movl 0x388(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x62ad
movq -0x18(%rbp), %rax
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl 0x388(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x31d86(%rip), %xmm1    # 0x38068
mulsd %xmm1, %xmm0
movsd %xmm0, 0x378(%rax)
movl 0x3ac(%rax), %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x38c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x6331
movq -0x18(%rbp), %rax
movl 0x38c(%rax), %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x62fc
jmp 0x6333
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl 0x38c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
movl -0x20(%rbp), %eax
xorl %ecx, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jge 0x636a
movq -0x18(%rbp), %rax
movl 0x38c(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x6333
movq -0x18(%rbp), %rax
cvtsi2sdl -0x10(%rbp), %xmm0
cvtsi2sdl 0x38c(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x31ce1(%rip), %xmm1    # 0x38068
mulsd %xmm1, %xmm0
movsd %xmm0, 0x380(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movsd 0x31da4(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x338(%rdi)
movsd 0x31d94(%rip), %xmm0    # 0x38160
movsd %xmm0, 0x340(%rdi)
callq 0x6120
testb $0x1, %al
jne 0x63e2
jmp 0x64c3
movq -0x10(%rbp), %rax
movsd 0x328(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x6419
jmp 0x64c3
movq -0x10(%rbp), %rax
movsd 0x330(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x644d
jmp 0x64c3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x28(%rbp)
movsd 0x328(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x330(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x37140
movq -0x28(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rcx
cvtsi2sd %rax, %xmm2
movq %rcx, %rdx
addq $0x338, %rdx            # imm = 0x338
addq $0x340, %rcx            # imm = 0x340
xorl %esi, %esi
callq 0x5660
movq -0x10(%rbp), %rdi
movsd 0x338(%rdi), %xmm0
movsd 0x340(%rdi), %xmm1
callq 0x6070
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd 0x378(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x651f
jmp 0x65fc
movq -0x30(%rbp), %rax
movsd 0x380(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x6556
jmp 0x65fc
movq -0x30(%rbp), %rax
movsd 0x338(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x658a
jmp 0x65fc
movq -0x30(%rbp), %rax
movsd 0x340(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x65be
jmp 0x65fc
movq -0x30(%rbp), %rax
movsd 0x338(%rax), %xmm0
movsd 0x378(%rax), %xmm1
callq 0x36ef0
movq -0x30(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x340(%rax), %xmm0
movsd 0x380(%rax), %xmm1
callq 0x36ef0
movsd %xmm0, -0x28(%rbp)
jmp 0x6616
movsd 0x31b5c(%rip), %xmm0    # 0x38160
movsd %xmm0, -0x20(%rbp)
movsd 0x31b4f(%rip), %xmm0    # 0x38160
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x662a
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x663e
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x79e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x66f1
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
callq 0x79e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x66f1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x79e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x66f1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x79e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x66f1
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x9(%rbp)
jb 0x66f1
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x68b0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl (%rax), %edi
xorl %esi, %esi
callq 0x6a40
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
xorl %esi, %esi
callq 0x6a40
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
callq 0x6a50
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
xorl %esi, %esi
callq 0x6a50
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq 0x18(%rax), %rdx
xorl %esi, %esi
callq 0x6a60
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq 0x18(%rax), %rdx
xorl %esi, %esi
callq 0x6a60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %edi
callq 0x6990
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0x4(%rax), %edi
callq 0x6990
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
shll %ecx
orl -0x10(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movl 0x10(%rax), %eax
shll $0x2, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
je 0x6864
cmpl $0x4, -0x18(%rbp)
je 0x6864
cmpl $0x2, -0x18(%rbp)
je 0x6864
cmpl $0xb, -0x18(%rbp)
jne 0x6874
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpl $0xe, -0x18(%rbp)
je 0x688c
cmpl $0x7, -0x18(%rbp)
je 0x688c
cmpl $0x1, -0x18(%rbp)
je 0x688c
cmpl $0x8, -0x18(%rbp)
jne 0x689c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: philipperemy[P]digital-setting-circles/Object.cpp
// Function: Object::release()
void Object::release()
{
    int count = 0;
    while (!_objects_ptr.empty())
    {
        std::cout << "deleting[" << ++count << "] : " << _objects_ptr.back().name << std::endl;
        _objects_ptr.pop_back();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x40632(%rip), %rdi     # 0x48398
callq 0x31530
xorb $-0x1, %al
testb $0x1, %al
jne 0x7d73
jmp 0x7ddf
movq 0x4024e(%rip), %rdi     # 0x47fc8
leaq 0x31ea7(%rip), %rsi     # 0x39c28
callq 0x3320
movq %rax, %rdi
movl -0x4(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x4(%rbp)
callq 0x3500
movq %rax, %rdi
leaq 0x31e91(%rip), %rsi     # 0x39c32
callq 0x3320
movq %rax, -0x10(%rbp)
leaq 0x405e7(%rip), %rdi     # 0x48398
callq 0x31570
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x32c0
movq %rax, %rdi
movq 0x401dc(%rip), %rsi     # 0x47fa8
callq 0x3350
leaq 0x405c0(%rip), %rdi     # 0x48398
callq 0x315b0
jmp 0x7d5f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x5b7c(%rip), %xmm0     # 0x38160
movsd %xmm0, 0x8(%rax)
movsd 0x5b6f(%rip), %xmm0     # 0x38160
movsd %xmm0, 0x10(%rax)
movsd 0x5b62(%rip), %xmm0     # 0x38160
movsd %xmm0, 0x18(%rax)
movsd 0x5b55(%rip), %xmm0     # 0x38160
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x32780
jmp 0x3267b
movq -0x28(%rbp), %rdi
callq 0x32a70
jmp 0x32686
movq -0x28(%rbp), %rdi
callq 0x32cb0
jmp 0x32691
movq -0x28(%rbp), %rdi
callq 0x331e0
jmp 0x3269c
movq -0x28(%rbp), %rdi
callq 0x33660
jmp 0x326a7
movq -0x28(%rbp), %rdi
callq 0x338e0
jmp 0x326b2
movq -0x28(%rbp), %rdi
callq 0x33b10
jmp 0x326bd
movq -0x28(%rbp), %rdi
callq 0x33ca0
jmp 0x326c8
movq -0x28(%rbp), %rdi
callq 0x343d0
jmp 0x326d3
movq -0x28(%rbp), %rdi
callq 0x34810
jmp 0x326de
movq -0x28(%rbp), %rdi
callq 0x349d0
jmp 0x326e9
movq -0x28(%rbp), %rdi
callq 0x34dd0
jmp 0x326f4
jmp 0x32754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3276f
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x158b6(%rip), %rdi     # 0x47fe8
callq 0x3320
movq %rax, -0x30(%rbp)
jmp 0x3273d
movq -0x30(%rbp), %rdi
movq 0x15860(%rip), %rsi     # 0x47fa8
callq 0x3350
jmp 0x3274f
callq 0x34c0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x34c0
jmp 0x3276d
jmp 0x3276f
movq -0x10(%rbp), %rdi
callq 0x3540
movq %rax, %rdi
callq 0x5e50
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3550
movq -0x48(%rbp), %rdx
leaq 0xa1d7(%rip), %rsi      # 0x3dd13
leaq -0x28(%rbp), %rdi
callq 0x5b40
jmp 0x33b47
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35710
jmp 0x33b56
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
movsd 0x44b0(%rip), %xmm0     # 0x38020
callq 0x7920
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9ebc(%rip), %xmm0     # 0x3da40
callq 0x35d20
movsd 0x9fd7(%rip), %xmm0     # 0x3db68
callq 0x7920
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9e93(%rip), %xmm0     # 0x3da38
callq 0x35d20
movsd 0x598e(%rip), %xmm0     # 0x39540
callq 0x7940
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9e72(%rip), %xmm0     # 0x3da38
callq 0x35d20
movsd 0x9e65(%rip), %xmm0     # 0x3da38
callq 0x7940
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9e51(%rip), %xmm0     # 0x3da38
callq 0x35d20
movsd 0x442c(%rip), %xmm0     # 0x38020
callq 0x7960
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9e30(%rip), %xmm0     # 0x3da38
callq 0x35d20
movsd 0x9f53(%rip), %xmm0     # 0x3db68
callq 0x7960
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x4417(%rip), %xmm0     # 0x38040
callq 0x35d20
movsd 0x9f2a(%rip), %xmm0     # 0x3db60
movsd 0x9ed2(%rip), %xmm1     # 0x3db10
callq 0x3400
movq -0x50(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x9f06(%rip), %xmm0     # 0x3db58
callq 0x35d20
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
movq -0x38(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3550
movq -0x88(%rbp), %rdx
leaq 0x9529(%rip), %rsi      # 0x3dd71
leaq -0x28(%rbp), %rdi
callq 0x5b40
jmp 0x34853
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35710
jmp 0x34865
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
leaq -0x60(%rbp), %rdi
movl $0x17, %esi
movl %esi, -0x94(%rbp)
movl $0x18, %edx
callq 0x6730
movq -0x90(%rbp), %rdi
movl -0x94(%rbp), %esi
movl -0x60(%rbp), %edx
callq 0x361e0
jmp 0x348a7
movq -0x90(%rbp), %rdi
movl -0x5c(%rbp), %edx
movl $0x18, %esi
callq 0x361e0
jmp 0x348bd
leaq 0x13aac(%rip), %rdi     # 0x48370
callq 0x6b20
movq -0x90(%rbp), %rdi
movl %eax, %edx
movl $0x1, %esi
callq 0x361e0
jmp 0x348de
leaq -0x80(%rbp), %rdi
movl $0x15, %esi
movl $0x16, %edx
callq 0x6730
jmp 0x348f3
movq -0x90(%rbp), %rdi
movl -0x80(%rbp), %edx
movl $0x15, %esi
callq 0x361e0
jmp 0x34909
movq -0x90(%rbp), %rdi
movl -0x7c(%rbp), %edx
movl $0x16, %esi
callq 0x361e0
jmp 0x3491f
leaq 0x13a4a(%rip), %rdi     # 0x48370
callq 0x6b20
movq -0x90(%rbp), %rdi
movl %eax, %edx
movl $0x2, %esi
callq 0x361e0
jmp 0x34940
callq 0x69b0
jmp 0x34947
leaq -0x80(%rbp), %rdi
callq 0x67f0
leaq -0x60(%rbp), %rdi
callq 0x67f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
jmp 0x349bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x349b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x67f0
leaq -0x60(%rbp), %rdi
callq 0x67f0
movq -0x38(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3550
movq -0xe8(%rbp), %rdx
leaq 0x8fcd(%rip), %rsi      # 0x3ddd5
leaq -0x28(%rbp), %rdi
callq 0x5b40
jmp 0x34e13
movq -0xf0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35710
jmp 0x34e25
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3550
movq -0xf8(%rbp), %rdx
leaq 0x8f94(%rip), %rsi      # 0x3ddec
leaq -0xb0(%rbp), %rdi
callq 0x5b40
jmp 0x34e66
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3550
movq -0x100(%rbp), %rdx
leaq 0x8f6b(%rip), %rsi      # 0x3ddf2
leaq -0xd8(%rbp), %rdi
callq 0x5b40
jmp 0x34e95
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movsd 0x8d7d(%rip), %xmm1     # 0x3dc28
leaq -0xd8(%rbp), %rdx
movaps %xmm1, %xmm0
callq 0x7c60
jmp 0x34ebc
leaq -0xd8(%rbp), %rdi
callq 0x31c0
leaq -0xd9(%rbp), %rdi
callq 0x3370
leaq -0xb0(%rbp), %rdi
callq 0x31c0
leaq -0xb1(%rbp), %rdi
callq 0x3370
callq 0x7df0
jmp 0x34ef3
leaq 0x1349e(%rip), %rdi     # 0x48398
callq 0x31c20
movq -0xf0(%rbp), %rdi
movl %eax, %edx
movl $0x1e5, %esi            # imm = 0x1E5
callq 0x361e0
jmp 0x34f14
leaq 0x1347d(%rip), %rdi     # 0x48398
callq 0x31c20
movq -0xf0(%rbp), %rdi
movl %eax, %edx
movl $0x1e5, %esi            # imm = 0x1E5
callq 0x361e0
jmp 0x34f35
leaq -0x90(%rbp), %rdi
callq 0x7cf0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34f6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x29(%rbp), %rdi
callq 0x3370
jmp 0x34fea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34fc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34fac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x31c0
leaq -0xd9(%rbp), %rdi
callq 0x3370
leaq -0xb0(%rbp), %rdi
callq 0x31c0
leaq -0xb1(%rbp), %rdi
callq 0x3370
jmp 0x34fea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x7cf0
movq -0x38(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x3330
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x35260
jmp 0x35027
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x3330
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x352a0
jmp 0x3504a
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x352e0
movq -0x28(%rbp), %rdi
callq 0x352e0
movq -0x10(%rbp), %rdi
callq 0x353e0
movq -0x28(%rbp), %rdi
callq 0x353e0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3508e
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x350a6
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3340
jmp 0x350e2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3340
movq -0x18(%rbp), %rdi
callq 0x3540
nopl (%rax,%rax)
// File: philipperemy[P]digital-setting-circles/./Thread.h
// Function: Thread::start()
void start()
    {
        if (m_threadbase_ptr == NULL) {
            m_threadbase_ptr = new pthread_t;
            int rc = pthread_create(m_threadbase_ptr, NULL, threadbase_dispatcher, this);
            if (rc != 0) {
                throw std::runtime_error("threadbase pthread_create failed");
            }
        } else {
            throw std::runtime_error("multiple threadbase start");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x35380
movl $0x8, %edi
callq 0x3330
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rcx), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xf0(%rip), %rdx       # 0x35230
callq 0x35b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3537e
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x8acb(%rip), %rsi      # 0x3de14
callq 0x30e0
jmp 0x35350
movq -0x30(%rbp), %rdi
movq 0x12c95(%rip), %rsi     # 0x47ff0
movq 0x12c56(%rip), %rdx     # 0x47fb8
callq 0x34f0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3220
jmp 0x353d6
jmp 0x353d0
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x8a9a(%rip), %rsi      # 0x3de35
callq 0x30e0
jmp 0x353a2
movq -0x38(%rbp), %rdi
movq 0x12c43(%rip), %rsi     # 0x47ff0
movq 0x12c04(%rip), %rdx     # 0x47fb8
callq 0x34f0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3220
jmp 0x353d6
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3540
nop
// File: philipperemy[P]digital-setting-circles/./Thread.h
// Function: Thread::join()
void join()
    {
        if (m_threadbase_ptr) {
            int rc = pthread_join(*m_threadbase_ptr, NULL);
            if (rc != 0) {
                throw std::runtime_error("threadbase pthread_join failed");
            }
            delete m_threadbase_ptr;
            m_threadbase_ptr = NULL;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x35498
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3546c
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x8a18(%rip), %rsi      # 0x3de4f
callq 0x30e0
jmp 0x3543e
movq -0x30(%rbp), %rdi
movq 0x12ba7(%rip), %rsi     # 0x47ff0
movq 0x12b68(%rip), %rdx     # 0x47fb8
callq 0x34f0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3220
jmp 0x3549e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3548c
movq -0x38(%rbp), %rdi
movl $0x8, %esi
callq 0x3340
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3540
nopw (%rax,%rax)
// File: philipperemy[P]digital-setting-circles/./ThreadEncoderReader.h
// Function: ThreadEncoderReader::run()
virtual void run()
    {
        long u = 100000000;
        double elapsedTime = 0.0;

        struct timeval t1;
        gettimeofday(&t1, NULL);

        struct timeval t2;

        while(u > 0)
        {
            u--;
        }
        gettimeofday(&t2, NULL);

        elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;      // sec to ms
        elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;   // us to ms
        std::cout << elapsedTime << " ms.\n" << std::endl;

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x5f5e100, -0x10(%rbp) # imm = 0x5F5E100
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
cmpq $0x0, -0x10(%rbp)
jle 0x3556e
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x35559
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x38(%rbp), %rax
subq -0x28(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x86a0(%rip), %xmm1     # 0x3dc30
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x8682(%rip), %xmm1     # 0x3dc30
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq 0x12a00(%rip), %rdi     # 0x47fc8
callq 0x35f0
movq %rax, %rdi
leaq 0x881f(%rip), %rsi      # 0x3ddf6
callq 0x3320
movq %rax, %rdi
movq 0x129c2(%rip), %rsi     # 0x47fa8
callq 0x3350
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: philipperemy[P]digital-setting-circles/./ThreadTargetCalculator.h
// Function: ThreadTargetCalculator::run()
virtual void run()
    {
        long long k = 0;
        long long a = 0;
        while(true)
        {
            k = 0;
            for(int i=0;i<10000;i++)
            {
                k+=i;
            }
            k=0;
            a++;
            if(a > 10000)
            {
                std::cout << "hello I'm still here..." << std::endl;
                a = 0;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2710, -0x1c(%rbp)    # imm = 0x2710
jge 0x356bb
movslq -0x1c(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3569b
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x2710, -0x18(%rbp)    # imm = 0x2710
jle 0x35703
movq 0x128e8(%rip), %rdi     # 0x47fc8
leaq 0x8715(%rip), %rsi      # 0x3ddfc
callq 0x3320
movq %rax, %rdi
movq 0x128b2(%rip), %rsi     # 0x47fa8
callq 0x3350
movq $0x0, -0x18(%rbp)
jmp 0x3568c
nopw %cs:(%rax,%rax)
nop
// File: philipperemy[P]digital-setting-circles/Utils.cpp
// Function: Util::diff180(double, double)
double Util::diff180(double a, double b)
{
  double diff = a - b;

  while (diff <= -180.0)
  {
    diff += 360.0;
  }

  while (diff > 180.0)
  {
    diff -= 360.0;
  }

  return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x6ccb(%rip), %xmm0     # 0x3dbe0
ucomisd -0x18(%rbp), %xmm0
jb 0x36f30
movsd 0x1144(%rip), %xmm0     # 0x38068
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x36f0d
jmp 0x36f32
movsd -0x18(%rbp), %xmm0
movsd 0x6ca9(%rip), %xmm1     # 0x3dbe8
ucomisd %xmm1, %xmm0
jbe 0x36f5d
movsd -0x18(%rbp), %xmm0
movsd 0x1116(%rip), %xmm1     # 0x38068
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x36f32
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Utils.cpp
// Function: Util::crudeCalcSeparation(double, double, double, double)
unsigned int Util::crudeCalcSeparation(double az1, double el1, double az2, double el2)
{
    double cossep;

    az1 *= radPerDeg;
    el1 *= radPerDeg;
    az2 *= radPerDeg;
    el2 *= radPerDeg;

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

    return (unsigned int)(20000.0*(1.0-cossep));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x10bf(%rip), %xmm1     # 0x38058
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x7600
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x7600
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x75e0
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x75e0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
subsd %xmm1, %xmm0
callq 0x75e0
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x30(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0xfb9(%rip), %xmm0      # 0x38010
subsd %xmm1, %xmm0
movsd 0x6ea5(%rip), %xmm1     # 0x3df08
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Utils.cpp
// Function: Util::goodAlignmentGeometry(StarData&, StarData&)
bool Util::goodAlignmentGeometry(StarData& starData1, StarData& starData2)
{
    unsigned int crudeSep, minCrudeSep;
    double azDiff;

    // Reject alignments with insufficient separation in azimuth, even if the
    // elevations are quite different.

    azDiff = diff180(starData1.az, starData2.az);

    if (fabs(azDiff) < 5.0)
    {
        return false;
    }

    // Also make sure the recorded az/el positions are not identical
    // or very close to each other.
    minCrudeSep = crudeCalcSeparation(0.0, 0.0, 0.0, 5.0);  // 5.0 degree min sep

    crudeSep = crudeCalcSeparation(starData1.az, starData1.el, starData2.az, starData2.az);

    if (crudeSep < minCrudeSep)
    {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
callq 0x36ef0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movaps 0x10d8(%rip), %xmm0     # 0x38190
pand %xmm0, %xmm1
movsd 0x6984(%rip), %xmm0     # 0x3da48
ucomisd %xmm1, %xmm0
jbe 0x370d0
movb $0x0, -0x1(%rbp)
jmp 0x37127
xorps %xmm2, %xmm2
movsd 0x696d(%rip), %xmm3     # 0x3da48
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x36f70
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm3
callq 0x36f70
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x37123
movb $0x0, -0x1(%rbp)
jmp 0x37127
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philipperemy[P]digital-setting-circles/Utils.cpp
// Function: Util::getEffectiveTime()
long long Util::getEffectiveTime()
{
    time_t timer;
    struct tm y2k;
    double seconds;

    y2k.tm_hour = 0;   y2k.tm_min = 0; y2k.tm_sec = 0;
    y2k.tm_year = 100; y2k.tm_mon = 0; y2k.tm_mday = 1;

    time(&timer);  /* get current time; same as: timer = time(NULL)  */
    seconds = difftime(timer,mktime(&y2k));
    return seconds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x64, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x32e0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x3160
movsd %xmm0, -0x48(%rbp)
cvttsd2si -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::_List_iterator<std::pair<unsigned int, unsigned int>> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int, unsigned int>, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>::find_in_overflow<unsigned int, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>, (void*)0>(unsigned int const&)
iterator_overflow find_in_overflow(const K& key) {
        return std::find_if(m_overflow_elements.begin(), m_overflow_elements.end(), 
                            [&](const value_type& value) { 
                                return compare_keys(key, KeySelect()(value)); 
                            });
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
callq 0x3bc0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x20, %rdi
callq 0x3f20
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x3ea0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: narges64[P]SIMBA/common.cpp
// Function: parameter_value::parameter_value(int, char**)
parameter_value::parameter_value(int argc, char ** argv){
		trace_filename = new char[100]; 		 
		synthetic = false; 

		strcpy(filename, argv[1]);
		load_parameters(argv[1]);
	
		load_inline_parameters(argc, argv);
	
		if (synthetic) {	
			sprintf(trace_filename, "trace_%.1f_%d_%d_%d", syn_rd_ratio , 
							syn_req_size , syn_req_count ,
							syn_interarrival_mean);
		}
	
		// distribute luns between channels
		for (int i = 0; i < channel_number; i++){
				lun_channel[i] = 0;
		}
		int channel = 0;
		for (int i = 0; i < lun_num; i++){
				lun_channel[channel]++;
				channel = (channel + 1) % channel_number;
		}

		channel = 0;
		for (int i = 0; i < channel_number; i++){
				if (lun_channel[i] != 0){
						channel++;
				}
		}
		channel_number = channel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x64, %edi
callq 0x2040
movq -0x30(%rbp), %rdi
movq %rax, 0x340(%rdi)
movb $0x0, 0x348(%rdi)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x20f0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2650
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3860
movq -0x30(%rbp), %rax
testb $0x1, 0x348(%rax)
je 0x256a
movq -0x30(%rbp), %rax
movq 0x340(%rax), %rdi
movss 0x324(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movl 0x32c(%rax), %edx
movl 0x328(%rax), %ecx
movl 0x330(%rax), %r8d
leaq 0xcab1(%rip), %rsi      # 0xf014
movb $0x1, %al
callq 0x2070
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x98(%rcx), %eax
jae 0x259e
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, 0x9c(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2571
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x88(%rcx), %eax
jae 0x25f0
movq -0x30(%rbp), %rcx
movslq -0x20(%rbp), %rax
movl 0x9c(%rcx,%rax,4), %edx
addl $0x1, %edx
movl %edx, 0x9c(%rcx,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x98(%rcx)
movl %edx, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25ac
movl $0x0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x98(%rcx), %eax
jae 0x2635
movq -0x30(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, 0x9c(%rax,%rcx,4)
je 0x2628
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x262a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x25fe
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x98(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: narges64[P]SIMBA/common.cpp
// Function: parameter_value::print_all_parameters(_IO_FILE*)
void parameter_value::print_all_parameters(FILE * stat_file){
		FILE * fp = fopen(filename, "r");
		char buffer[300];
		while (fgets(buffer, 300, fp)){
				fprintf(stat_file, "%s", buffer);
				fflush(stat_file);
		}
		fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb3be(%rip), %rsi      # 0xf14c
callq 0x2190
movq %rax, -0x18(%rbp)
leaq -0x150(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x12c, %esi            # imm = 0x12C
callq 0x2210
cmpq $0x0, %rax
je 0x3dd6
movq -0x10(%rbp), %rdi
leaq -0x150(%rbp), %rdx
leaq 0xb264(%rip), %rsi      # 0xf028
movb $0x0, %al
callq 0x21f0
movq -0x10(%rbp), %rdi
callq 0x2180
jmp 0x3d97
movq -0x18(%rbp), %rdi
callq 0x2120
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: narges64[P]SIMBA/common.cpp
// Function: statistics::statistics(int)
statistics::statistics(int cons_deg){
	consolidation_degree = cons_deg;

	read_request_size = new int64_t[cons_deg];
	total_read_request_size = new int64_t[cons_deg];
	write_request_size = new int64_t[cons_deg];
	total_write_request_size = new int64_t[cons_deg];

	subreq_state_time = new int64_t[SR_MODE_NUM];

	reset_all();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x5380
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x5380
movq -0x18(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x53c0
movq -0x18(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x53c0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
movl $0x50, %edi
callq 0x2040
movq -0x18(%rbp), %rdi
movq %rax, 0x188(%rdi)
callq 0x4290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: narges64[P]SIMBA/common.cpp
// Function: statistics::reset_all()
void statistics::reset_all(){
	for (int i = 0; i < consolidation_degree; i++){

		read_request_size[i] = 0;
		total_read_request_size[i] = 0;
		write_request_size[i] = 0;
		total_write_request_size[i] = 0;
	}

	flash_read_count = 0;
	total_flash_read_count = 0;
	flash_prog_count = 0;
	total_flash_prog_count = 0;
	flash_erase_count = 0;
	total_flash_erase_count = 0;

	queue_read_count = 0;
	queue_prog_count = 0;
	direct_erase_count = 0;
	total_direct_erase_count = 0;

	m_plane_read_count = 0;
	total_m_plane_read_count = 0;
	m_plane_prog_count = 0;
	total_m_plane_prog_count = 0;
	m_plane_erase_count = 0;
	total_m_plane_erase_count = 0;

	interleave_read_count = 0;
	total_interleave_read_count = 0;
	interleave_prog_count = 0;
	total_interleave_prog_count = 0;
	interleave_erase_count = 0;
	total_interleave_erase_count = 0;

	gc_copy_back = 0;
	total_gc_copy_back = 0;

	waste_page_count = 0;
	total_waste_page_count = 0;

	update_read_count = 0;
	total_update_read_count = 0;


	gc_moved_page = 0;

	for (int i = 0; i < SR_MODE_NUM; i++){
		subreq_state_time[i] = 0;
	}

	read_multiplane_count = 0;
	write_multiplane_count = 0;
	erase_multiplane_count = 0;



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x4301
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x60(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x68(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42a7
movq -0x18(%rbp), %rax
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0xb0(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0xf8(%rax)
movq $0x0, 0x100(%rax)
movq $0x0, 0x108(%rax)
movq $0x0, 0x110(%rax)
movq $0x0, 0x118(%rax)
movq $0x0, 0x120(%rax)
movq $0x0, 0x128(%rax)
movq $0x0, 0x130(%rax)
movq $0x0, 0x138(%rax)
movq $0x0, 0x140(%rax)
movq $0x0, 0x148(%rax)
movq $0x0, 0x150(%rax)
movq $0x0, 0x158(%rax)
movq $0x0, 0x160(%rax)
movq $0x0, 0x168(%rax)
movq $0x0, 0x170(%rax)
movq $0x0, 0x178(%rax)
movq $0x0, 0x180(%rax)
movl $0x0, 0xc8(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x446f
movq -0x18(%rbp), %rax
movq 0x188(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4447
movq -0x18(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq $0x0, 0xe8(%rax)
movq $0x0, 0xf0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: narges64[P]SIMBA/common.cpp
// Function: statistics::~statistics()
statistics::~statistics(){
	delete read_request_size;
	delete total_read_request_size;
	delete write_request_size;
	delete total_write_request_size;
	delete subreq_state_time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x44d0
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x44f0
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4510
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4530
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x188(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4553
movq -0x38(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)