LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
movq 0x2879c(%rip), %r14     # 0x2dfc8
leaq 0x1c415(%rip), %r15     # 0x21c48
leaq 0x1c418(%rip), %r12     # 0x21c52
leaq 0x28ae7(%rip), %r13     # 0x2e328
movq 0x28ae0(%rip), %rax     # 0x2e328
cmpq 0x28ae1(%rip), %rax     # 0x2e330
je 0x5898
movq %r14, %rdi
movq %r15, %rsi
callq 0x32a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3460
movq %rax, %rdi
movq %r12, %rsi
callq 0x32a0
movq 0x28ab8(%rip), %rsi     # 0x2e330
addq $-0x50, %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x1b70a
incl %ebx
jmp 0x5841
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x28(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bc8c
movq %rbx, %rdi
callq 0x1beb2
movq %rbx, %rdi
callq 0x1c020
movq %rbx, %rdi
callq 0x1c4d0
movq %rbx, %rdi
callq 0x1c8d8
movq %rbx, %rdi
callq 0x1cac2
movq %rbx, %rdi
callq 0x1cca0
movq %rbx, %rdi
callq 0x1cdca
movq %rbx, %rdi
callq 0x1d464
movq %rbx, %rdi
callq 0x1d754
movq %rbx, %rdi
callq 0x1d876
movq %rbx, %rdi
callq 0x1db10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1bc7c
movq %rbx, %rdi
callq 0x30d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x1238f(%rip), %rdi     # 0x2dfe8
movq %rax, %rsi
callq 0x32a0
movq %rax, %rdi
callq 0x3110
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3410
movq %rax, %rbx
callq 0x3410
movq %rbx, %rdi
callq 0x34a0
movq %rax, %rdi
callq 0x5372
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x9d98(%rip), %rsi      # 0x25c60
leaq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x4ce2
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x1df6c
leaq -0x88(%rbp), %rdi
callq 0x3100
leaq -0x68(%rbp), %rdi
callq 0x1bb80
leaq -0x38(%rbp), %rdi
callq 0x1bb80
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x68(%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, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %r8, -0x10(%rbp)
callq 0x1dcc1
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1e196
leaq -0x38(%rbp), %rdi
callq 0x1dcc1
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1e196
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1dd2c
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1e196
leaq -0x68(%rbp), %rdi
callq 0x1bbac
leaq -0x38(%rbp), %rdi
callq 0x1bbac
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1dd2c
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1e196
leaq -0x38(%rbp), %rdi
callq 0x1bba6
leaq -0x68(%rbp), %rdi
callq 0x1bba6
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x1c00e
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3100
jmp 0x1c017
movq %rax, %rbx
jmp 0x1c017
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1bba6
leaq -0x68(%rbp), %rdi
callq 0x1bba6
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/philipperemy[P]digital-setting-circles/Test.cpp
// Function: Test::test_MathLib_hyperbolic()
void Test::test_MathLib_hyperbolic()
{
    setUpErrorMessage("test_MathLib_hyperbolic() - failed");

    assertEquals((MathLib::exp(3) + MathLib::exp(-3))/2, MathLib::cosh(3));
    assertEquals((MathLib::exp(3) - MathLib::exp(-3))/2, MathLib::sinh(3));
    assertEquals((MathLib::exp(3) - MathLib::exp(-3))/(MathLib::exp(3) + MathLib::exp(-3)), MathLib::tanh(3));

    assertEquals(MathLib::log(33 + MathLib::sqrt(33*33 - 1)), MathLib::acosh(33));
    assertEquals(MathLib::log(33 + MathLib::sqrt(33*33 + 1)), MathLib::asinh(33));

    //ERREUR NEED TO SEE WHATS GOING ON THERE
    //assertEquals(MathLib::log(0.5*MathLib::log((double)(1.0+0.6)/(1.0-0.6))), MathLib::atanh(0.6));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x9415(%rip), %rsi      # 0x25d02
leaq -0x48(%rbp), %r14
leaq -0x19(%rbp), %rdx
movq %r14, %rdi
callq 0x4ce2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1df6c
leaq -0x48(%rbp), %rdi
callq 0x3100
movsd 0x9147(%rip), %xmm0     # 0x25a60
callq 0x55de
movsd %xmm0, -0x18(%rbp)
movsd 0x4c35(%rip), %xmm0     # 0x21560
callq 0x55de
addsd -0x18(%rbp), %xmm0
mulsd 0x3703(%rip), %xmm0     # 0x20040
movsd %xmm0, -0x18(%rbp)
movsd 0x9116(%rip), %xmm0     # 0x25a60
callq 0x55a2
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2a6
movsd 0x90f9(%rip), %xmm0     # 0x25a60
callq 0x55de
movsd %xmm0, -0x18(%rbp)
movsd 0x4be7(%rip), %xmm0     # 0x21560
callq 0x55de
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x36b1(%rip), %xmm1     # 0x20040
movsd %xmm1, -0x18(%rbp)
movsd 0x90c4(%rip), %xmm0     # 0x25a60
callq 0x55ac
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2a6
movsd 0x90a7(%rip), %xmm0     # 0x25a60
callq 0x55de
movsd %xmm0, -0x18(%rbp)
movsd 0x4b95(%rip), %xmm0     # 0x21560
callq 0x55de
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x907a(%rip), %xmm0     # 0x25a60
callq 0x55de
movsd %xmm0, -0x28(%rbp)
movsd 0x4b68(%rip), %xmm0     # 0x21560
callq 0x55de
addsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x9048(%rip), %xmm0     # 0x25a60
callq 0x55b6
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2a6
movsd 0x90db(%rip), %xmm0     # 0x25b10
callq 0x564c
addsd 0x908e(%rip), %xmm0     # 0x25ad0
callq 0x55fc
movsd %xmm0, -0x18(%rbp)
movsd 0x907c(%rip), %xmm0     # 0x25ad0
callq 0x55c0
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2a6
movsd 0x90a7(%rip), %xmm0     # 0x25b18
callq 0x564c
addsd 0x9052(%rip), %xmm0     # 0x25ad0
callq 0x55fc
movsd %xmm0, -0x18(%rbp)
movsd 0x9040(%rip), %xmm0     # 0x25ad0
callq 0x55ca
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2a6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x924e(%rip), %rsi      # 0x25d25
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x4ce2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1df6c
leaq -0x38(%rbp), %rdi
callq 0x3100
movsd 0x8f55(%rip), %xmm0     # 0x25a58
movsd 0x8f55(%rip), %xmm1     # 0x25a60
callq 0x5642
movaps %xmm0, %xmm1
movsd 0x3c95(%rip), %xmm0     # 0x207b0
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8ff5(%rip), %xmm0     # 0x25b20
movsd 0x8f2d(%rip), %xmm1     # 0x25a60
callq 0x5642
movaps %xmm0, %xmm1
movsd 0x8fe5(%rip), %xmm0     # 0x25b28
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x49dd(%rip), %xmm0     # 0x21530
movsd 0x8f0d(%rip), %xmm1     # 0x25a68
callq 0x5642
movaps %xmm0, %xmm1
movsd 0x8fc5(%rip), %xmm0     # 0x25b30
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8fbd(%rip), %xmm0     # 0x25b38
callq 0x564c
movaps %xmm0, %xmm1
movsd 0x8fb5(%rip), %xmm0     # 0x25b40
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8fad(%rip), %xmm0     # 0x25b48
callq 0x564c
movaps %xmm0, %xmm1
movsd 0x8fa5(%rip), %xmm0     # 0x25b50
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8f9d(%rip), %xmm0     # 0x25b58
callq 0x564c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8e92(%rip), %xmm0     # 0x25a60
callq 0x1e2a6
movsd 0x8f85(%rip), %xmm0     # 0x25b60
callq 0x564c
movaps %xmm0, %xmm1
movsd 0x8f7d(%rip), %xmm0     # 0x25b68
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8e65(%rip), %xmm0     # 0x25a60
movsd 0x8e65(%rip), %xmm1     # 0x25a68
callq 0x5666
movaps %xmm0, %xmm1
movsd 0x8e5d(%rip), %xmm0     # 0x25a70
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8e45(%rip), %xmm0     # 0x25a68
movsd 0x8e45(%rip), %xmm1     # 0x25a70
callq 0x5666
movaps %xmm0, %xmm1
movsd 0x8f35(%rip), %xmm0     # 0x25b70
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x3b65(%rip), %xmm0     # 0x207b0
callq 0x567c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8dfa(%rip), %xmm0     # 0x25a58
callq 0x1e2a6
movsd 0x8f0d(%rip), %xmm0     # 0x25b78
callq 0x567c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8df2(%rip), %xmm0     # 0x25a70
callq 0x1e2a6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x9086(%rip), %rsi      # 0x25d3b
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x4ce2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1df6c
leaq -0x38(%rbp), %rdi
callq 0x3100
movsd 0x3347(%rip), %xmm0     # 0x20028
callq 0x5686
movaps %xmm0, %xmm1
movsd 0x8d77(%rip), %xmm0     # 0x25a68
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8e7f(%rip), %xmm0     # 0x25b80
callq 0x5686
movaps %xmm0, %xmm1
movsd 0x8d4f(%rip), %xmm0     # 0x25a60
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x483f(%rip), %xmm0     # 0x21560
callq 0x5690
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8d2c(%rip), %xmm0     # 0x25a60
callq 0x1e2a6
movsd 0x8d1f(%rip), %xmm0     # 0x25a60
callq 0x5690
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8d0c(%rip), %xmm0     # 0x25a60
callq 0x1e2a6
movsd 0x32c7(%rip), %xmm0     # 0x20028
callq 0x569e
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8cec(%rip), %xmm0     # 0x25a60
callq 0x1e2a6
movsd 0x8dff(%rip), %xmm0     # 0x25b80
callq 0x569e
movaps %xmm0, %xmm1
movsd 0x8cc7(%rip), %xmm0     # 0x25a58
movq %rbx, %rdi
callq 0x1e2a6
movsd 0x8de7(%rip), %xmm0     # 0x25b88
movq %rbx, %rdi
movaps %xmm0, %xmm1
callq 0x1e2a6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x862e(%rip), %rsi      # 0x25d99
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4ce2
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x1df6c
leaq -0x78(%rbp), %rdi
callq 0x3100
leaq -0x58(%rbp), %r14
pushq $0x17
popq %r15
pushq $0x18
popq %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x526c
movl (%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1e5d6
movl -0x54(%rbp), %edx
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x1e5d6
leaq 0x10b3a(%rip), %r14     # 0x2e300
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x3, %rdx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1e5d6
leaq -0x38(%rbp), %rdi
pushq $0x15
popq %rsi
pushq $0x16
popq %rdx
callq 0x526c
movl -0x38(%rbp), %edx
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0x1e5d6
movl -0x34(%rbp), %edx
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x1e5d6
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x3, %rdx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1e5d6
callq 0x5338
leaq -0x38(%rbp), %rdi
callq 0x52a0
leaq -0x58(%rbp), %rdi
callq 0x52a0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d854
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3100
jmp 0x1d86e
movq %rax, %rbx
jmp 0x1d86e
movq %rax, %rbx
jmp 0x1d865
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x52a0
leaq -0x58(%rbp), %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x82d3(%rip), %rsi      # 0x25dfd
leaq -0x80(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x4ce2
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x1df6c
leaq -0x80(%rbp), %rdi
callq 0x3100
leaq 0x82be(%rip), %rsi      # 0x25e14
leaq -0x60(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x4ce2
leaq 0x82b0(%rip), %rsi      # 0x25e1a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4ce2
leaq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movsd 0x80c6(%rip), %xmm0     # 0x25c50
leaq -0x40(%rbp), %rdx
movaps %xmm0, %xmm1
callq 0x577c
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq -0x60(%rbp), %rdi
callq 0x3100
callq 0x58a8
leaq 0x10774(%rip), %r14     # 0x2e328
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x50
popq %r15
cqto
idivq %r15
movq %rbx, %rdi
movl $0x1e5, %esi            # imm = 0x1E5
movl %eax, %edx
callq 0x1e5d6
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r15
movq %rbx, %rdi
movl $0x1e5, %esi            # imm = 0x1E5
movl %eax, %edx
callq 0x1e5d6
leaq -0xd0(%rbp), %rdi
callq 0x57de
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3100
jmp 0x1dc19
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x1dc28
jmp 0x1dc2f
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3100
jmp 0x1dc43
movq %rax, %rbx
jmp 0x1dc43
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x57de
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq $0x10
popq %r14
movq %r14, %rdi
callq 0x32b0
movq %rax, %rbx
andq $0x0, 0x8(%rax)
leaq 0x10072(%rip), %rax     # 0x2dce0
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x32b0
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x100a8(%rip), %rax     # 0x2dd30
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1dd6c
movq %r14, %rdi
callq 0x1dd6c
movq %rbx, %rdi
callq 0x1de08
movq %r14, %rdi
callq 0x1de08
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x8(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x1dda6
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0x32b0
movq %rax, 0x8(%rbx)
leaq -0x33(%rip), %rdx       # 0x1dd5d
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x34f0
testl %eax, %eax
jne 0x1ddc2
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x80a5(%rip), %rsi      # 0x25e5d
movq %rax, %rdi
callq 0x30c0
jmp 0x1dddc
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x8068(%rip), %rsi      # 0x25e3c
movq %rax, %rdi
callq 0x30c0
movq 0x1020d(%rip), %rsi     # 0x2dff0
movq 0x101d6(%rip), %rdx     # 0x2dfc0
movq %rbx, %rdi
callq 0x3450
jmp 0x1ddf4
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1de3a
movq %rdi, %rbx
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3260
testl %eax, %eax
jne 0x1de3f
movq 0x8(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x32c0
andq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x8026(%rip), %rsi      # 0x25e77
movq %rax, %rdi
callq 0x30c0
movq 0x10190(%rip), %rsi     # 0x2dff0
movq 0x10159(%rip), %rdx     # 0x2dfc0
movq %rbx, %rdi
callq 0x3450
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x33f0
leaq -0x20(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x33f0
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq (%rbx), %rax
cvtsi2sd %rax, %xmm1
movsd 0x7d84(%rip), %xmm2     # 0x25c58
mulsd %xmm2, %xmm1
subq 0x8(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x100d8(%rip), %rdi     # 0x2dfc8
callq 0x33e0
leaq 0x7f22(%rip), %rsi      # 0x25e1e
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
xorl %eax, %eax
movq 0x1008a(%rip), %rbx     # 0x2dfc8
leaq 0x7edf(%rip), %r14      # 0x25e24
leaq 0x1(%rax), %rcx
cmpq $0x2710, %rax           # imm = 0x2710
movq %rcx, %rax
jl 0x1df45
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32a0
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
jmp 0x1df45
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subsd %xmm1, %xmm0
movsd 0x6db8(%rip), %xmm1     # 0x25c08
movsd 0x1210(%rip), %xmm2     # 0x20068
ucomisd %xmm0, %xmm1
jb 0x1ee64
addsd %xmm2, %xmm0
jmp 0x1ee58
pushq %rbp
movq %rsp, %rbp
movsd 0x6da0(%rip), %xmm1     # 0x25c10
movsd 0x70b8(%rip), %xmm2     # 0x25f30
popq %rbp
ucomisd %xmm1, %xmm0
jbe 0x1ee85
addsd %xmm2, %xmm0
jmp 0x1ee79
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movapd %xmm1, %xmm4
movsd 0x11c6(%rip), %xmm1     # 0x20060
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm4
movsd %xmm4, -0x10(%rbp)
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, -0x20(%rbp)
mulsd %xmm3, %xmm1
movsd %xmm1, -0x8(%rbp)
movapd %xmm4, %xmm0
callq 0x558e
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x558e
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x5584
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5584
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x5584
mulsd -0x8(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd 0x10ee(%rip), %xmm0     # 0x20010
subsd %xmm1, %xmm0
mulsd 0x700a(%rip), %xmm0     # 0x25f38
cvttsd2si %xmm0, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x8(%rdi), %xmm0
movsd 0x8(%rsi), %xmm1
callq 0x1ee44
andpd 0x125f(%rip), %xmm0     # 0x201c0
movsd 0x6b07(%rip), %xmm1     # 0x25a70
ucomisd %xmm0, %xmm1
jbe 0x1ef73
xorl %eax, %eax
jmp 0x1efad
movsd 0x6af5(%rip), %xmm3     # 0x25a70
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x1ee86
movl %eax, %r15d
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x8(%rbx), %xmm2
movaps %xmm2, %xmm3
callq 0x1ee86
cmpl %r15d, %eax
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x50(%rbp), %rbx
movq %rax, 0x8(%rbx)
andq $0x0, (%rbx)
movabsq $0x6400000000, %rax     # imm = 0x6400000000
movq %rax, 0x10(%rbx)
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x3270
movq (%r14), %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
movq %rax, %rsi
callq 0x3140
cvttsd2si %xmm0, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rdx
movq %rdi, %rcx
leaq 0x20(%rdi), %rsi
movq 0x20(%rdi), %rdi
jmp 0x1d53
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x64
popq %rdi
callq 0x2040
movq %rax, 0x340(%rbx)
movb $0x0, 0x348(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2110
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x25a2
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x33c8
cmpb $0x1, 0x348(%rbx)
jne 0x253c
cvtss2sd 0x324(%rbx), %xmm0
movq 0x340(%rbx), %rdi
movl 0x328(%rbx), %ecx
movl 0x32c(%rbx), %edx
movl 0x330(%rbx), %r8d
leaq 0x6b0f(%rip), %rsi      # 0x9044
movb $0x1, %al
callq 0x2070
movl 0x98(%rbx), %ecx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x2556
andl $0x0, 0x9c(%rbx,%rax,4)
incq %rax
jmp 0x2544
xorl %edx, %edx
xorl %esi, %esi
cmpl 0x88(%rbx), %esi
jae 0x257c
movslq %edx, %rax
incl 0x9c(%rbx,%rax,4)
incl %eax
movl 0x98(%rbx), %ecx
xorl %edx, %edx
divl %ecx
incl %esi
jmp 0x255a
movl %ecx, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %rax
je 0x2597
cmpl $0x1, 0x9c(%rbx,%rcx,4)
sbbl $-0x1, %edx
incq %rcx
jmp 0x2582
movl %edx, 0x98(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %rbx
leaq 0x59f5(%rip), %rsi      # 0x913d
callq 0x21d0
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movl $0x12c, %esi            # imm = 0x12C
movq %r14, %rdx
callq 0x2280
testq %rax, %rax
je 0x377d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x21c0
jmp 0x3753
movq %r14, %rdi
callq 0x2150
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x28(%rdi)
andq $0x0, 0x20(%rdi)
andl $0x0, 0x30(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rax, 0x50(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, 0x190(%rdi)
movups %xmm0, 0x1a0(%rdi)
movups %xmm0, 0x1b0(%rdi)
movups %xmm0, 0x1c0(%rdi)
movl %esi, (%rdi)
movl %esi, %eax
shlq $0x3, %rax
testl %esi, %esi
pushq $-0x1
popq %r14
cmovnsq %rax, %r14
movq %r14, %rdi
callq 0x2040
movq %rax, 0x58(%rbx)
movq %r14, %rdi
callq 0x2040
movq %rax, 0x60(%rbx)
movq %r14, %rdi
callq 0x2040
movq %rax, 0x68(%rbx)
movq %r14, %rdi
callq 0x2040
movq %rax, 0x70(%rbx)
pushq $0x50
popq %rdi
callq 0x2040
movq %rax, 0x188(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a54
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
pushq $0x8
popq %r14
movq %r14, %rsi
callq 0x2170
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x188(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: dram_info::dram_info(parameter_value*)
dram_info::dram_info(parameter_value * parameters)
{
	map = new map_info();
	int page_num = parameters->page_block*parameters->block_plane*parameters->plane_lun*parameters->lun_num;
	map->count = page_num * (1-parameters->overprovide); 
	map->map_entry = new entry[page_num];

	dram_capacity = parameters->dram_capacity;
	gcb_capacity = 0; // parameters->gcb_capacity; 
	int io_share = dram_capacity - gcb_capacity; 
	buffer = new write_buffer(io_share, parameters->subpage_page);
	gc_buffer = buffer; // new write_buffer(gcb_capacity , parameters->subpage_page);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2160
movq %rax, %r15
movq %rax, 0x10(%rbx)
movl 0x230(%r14), %eax
imull 0x234(%r14), %eax
imull 0x22c(%r14), %eax
imull 0x88(%r14), %eax
cvtsi2ss %eax, %xmm0
movss 0x54a3(%rip), %xmm1     # 0x9040
subss 0x25c(%r14), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movl %ecx, 0x8(%r15)
movslq %eax, %r13
movq %r13, %r12
shlq $0x4, %r12
testl %r13d, %r13d
pushq $-0x1
popq %rdi
cmovnsq %r12, %rdi
callq 0x2040
testl %r13d, %r13d
je 0x3bee
movq %rax, %rcx
addq %r12, %rcx
movq %rax, %rdx
orl $-0x1, (%rdx)
movb $0x0, 0x4(%rdx)
andq $0x0, 0x8(%rdx)
addq $0x10, %rdx
cmpq %rcx, %rdx
jne 0x3bd9
movq %rax, (%r15)
movl 0x8c(%r14), %ebp
movl %ebp, (%rbx)
andl $0x0, 0x4(%rbx)
pushq $0x28
popq %rdi
callq 0x2160
movq %rax, %rcx
shll $0xb, %ebp
movl %ebp, %eax
cltd
idivl 0x238(%r14)
movl %eax, 0x8(%rcx)
andq $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0xc(%rcx)
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: blk_info::blk_info(parameter_value*)
blk_info::blk_info(parameter_value * parameters)
{
	free_page_num = parameters->page_block;	// all pages are free
	last_write_page = -1;	// no page has been programmed
	last_write_time = 0; 
	page_num = parameters->page_block;
	invalid_page_num = 0;

	page_head = new page_info*[parameters->page_block];
	for(int i = 0; i<parameters->page_block; i++)
	{
		page_head[i] = new page_info();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x234(%rsi), %r15d
movl %r15d, 0x4(%rdi)
orl $-0x1, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movl %r15d, 0xc(%rdi)
andl $0x0, 0x8(%rdi)
leaq (,%r15,8), %rdi
callq 0x2040
movq %rax, 0x20(%rbx)
xorl %r12d, %r12d
pushq $0x8
popq %r14
cmpq %r12, %r15
je 0x3ca8
movq %r14, %rdi
callq 0x2160
movb $0x0, (%rax)
orl $-0x1, 0x4(%rax)
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x3c87
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: plane_info::plane_info(parameter_value*)
plane_info::plane_info(parameter_value  * parameters)
{
	free_page=parameters->block_plane*parameters->page_block;
	invalid_page = 0; 
	
	blk_head = new blk_info*[parameters->block_plane];
	for(int i = 0; i<parameters->block_plane; i++)
	{
		blk_head[i] = new blk_info(parameters);
	}
	block_num = parameters->block_plane;
	active_block = 0;
	cold_active_block = 1; 
	erase_count = 0;
	program_count = 0;
	GCMode = false;
	current_state = PLANE_MODE_IDLE;
	next_state = PLANE_MODE_IDLE;
	current_time = 0;
	next_state_predict_time = 0;
	state_time = new int64_t[PLANE_MODE_NUM];
	for (int i = 0; i < PLANE_MODE_NUM; i++){
		state_time[i] = 0;
	}
	scheduled_gc = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x230(%rsi), %r12d
movl 0x234(%rsi), %eax
imull %r12d, %eax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %r12, %rdi
shlq $0x3, %rdi
callq 0x2040
movq %rax, 0x20(%rbx)
xorl %r13d, %r13d
pushq $0x28
popq %r15
movl %r12d, %eax
cmpq %rax, %r13
jae 0x3d25
movq %r15, %rdi
callq 0x2160
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3c48
movq 0x20(%rbx), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movl 0x230(%r14), %r12d
jmp 0x3cf3
movq %rax, 0x28(%rbx)
andq $0x0, 0x10(%rbx)
movq $0x1, 0x18(%rbx)
andq $0x0, 0x30(%rbx)
movb $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
pushq $0x18
popq %rdi
callq 0x2040
movq %rax, 0x60(%rbx)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x3d68
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x3d58
andq $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: lun_info::lun_info(parameter_value*)
lun_info::lun_info(parameter_value * parameter)
{
	current_state = LUN_MODE_IDLE;
	next_state = LUN_MODE_IDLE;
	current_time = 0;
	next_state_predict_time = 0;
	read_count = 0;
	program_count = 0;
	erase_count = 0;
	read_avg = 0;
	program_avg = 0;
	gc_avg = 0;
	plane_token = 0;

	GCMode = false;
	plane_head = new plane_info*[parameter->plane_lun];
	for (int i = 0; i<parameter->plane_lun; i++)
	{
		plane_head[i] = new plane_info(parameter);
	}

	state_time = new int64_t [LUN_MODE_NUM];
	for (int i = 0; i < LUN_MODE_NUM; i++)
		state_time[i] = 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
andl $0x0, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
andl $0x0, 0x88(%rdi)
movb $0x0, 0x98(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
andl $0x0, 0x58(%rdi)
movups %xmm0, 0x9c(%rdi)
movups %xmm0, 0xac(%rdi)
movups %xmm0, 0xbc(%rdi)
movups %xmm0, 0xcc(%rdi)
movups %xmm0, 0xdc(%rdi)
andl $0x0, 0xfc(%rdi)
movups %xmm0, 0xec(%rdi)
movl 0x22c(%rsi), %r12d
movq %r12, %rdi
shlq $0x3, %rdi
callq 0x2040
movq %rax, (%rbx)
xorl %r13d, %r13d
pushq $0x78
popq %r15
movl %r12d, %eax
cmpq %rax, %r13
jae 0x3e5f
movq %r15, %rdi
callq 0x2160
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x3cb4
movq (%rbx), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movl 0x22c(%r14), %r12d
jmp 0x3e2e
pushq $0x18
popq %rdi
callq 0x2040
movq %rax, 0x90(%rbx)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x3e80
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x3e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: channel_info::channel_info(int, parameter_value*)
channel_info::channel_info(int channel_number, parameter_value * parameters) {
	// set the parameter of each channel
	lun_num = parameters->lun_channel[channel_number];
	current_state = CHANNEL_MODE_IDLE;
	next_state = CHANNEL_MODE_IDLE;
	current_time = 0;
	next_state_predict_time = 0;
	lun_head = new lun_info*[lun_num];

	for (int j = 0; j< lun_num; j++)
	{
		lun_head[j] = new lun_info(parameters);
	}

	state_time = new int64_t[CHANNEL_MODE_NUM];
	for (int i = 0; i < CHANNEL_MODE_NUM; i++){
		state_time[i] = 0;
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %rax
movslq 0x9c(%rdx,%rax,4), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, (%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
andq $0x0, 0x48(%rbx)
callq 0x2040
movq %rax, 0x50(%rbx)
xorl %r12d, %r12d
movslq %r15d, %rax
cmpq %rax, %r12
jge 0x3f3c
movl $0x100, %edi            # imm = 0x100
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3d9c
movq 0x50(%rbx), %rax
movq %r15, (%rax,%r12,8)
incq %r12
movl (%rbx), %r15d
jmp 0x3f0c
pushq $0x18
popq %rdi
callq 0x2040
movq %rax, 0x58(%rbx)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x3f5a
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x3f4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: file_assert(int, char const*)
void file_assert(int error,const char *s){
	if(error == 0) return;
	printf("open %s error\n",s);
	getchar();
	exit(-1);
}

// Assembly:
testl %edi, %edi
jne 0x3f83
retq
pushq %rax
leaq 0x549b(%rip), %rdi      # 0x9426
xorl %eax, %eax
callq 0x2050
callq 0x2220
pushq $-0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: trace_assert(long, int, unsigned int, int, int)
void trace_assert(int64_t time,int device,unsigned int lsn,int size,int ope)
{
	if(time <0 || device < 0  || size < 0 || ope < 0)
	{
		cout << "trace error: " << time << "  " << device << " " << lsn << " " << size << "  " << ope << endl;
		getchar();
		exit(-1);
	}
	if(time == 0 && device == 0 && lsn == 0 && size == 0 && ope == 0)
	{
		printf("probable read a blank line\n");
		getchar();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
testq %rdi, %rdi
js 0x3ff9
movl %ebp, %eax
orl %r12d, %eax
movl %eax, %ecx
orl %ebx, %ecx
js 0x3ff9
testq %r15, %r15
setne %cl
orl %r14d, %eax
orl %ebx, %eax
setne %al
orb %cl, %al
jne 0x3ff0
leaq 0x54a5(%rip), %rdi      # 0x9483
callq 0x2270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x9fd0(%rip), %rdi      # 0xdfd0
leaq 0x542e(%rip), %rsi      # 0x9435
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x22c0
leaq 0x5425(%rip), %r15      # 0x9443
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
movl %r12d, %esi
callq 0x22a0
leaq 0x5e8f(%rip), %r12      # 0x9eca
movq %rax, %rdi
movq %r12, %rsi
callq 0x2140
movq %rax, %rdi
movl %r14d, %esi
callq 0x2210
movq %rax, %rdi
movq %r12, %rsi
callq 0x2140
movq %rax, %rdi
movl %ebp, %esi
callq 0x22a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20b0
callq 0x2220
pushq $-0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: SubQueue::find_subreq(sub_request*)
bool SubQueue::find_subreq(sub_request * sub){
	// is there any request for the same location and same operation (read and write FIXME??? )
	sub_request * qsub = queue_head;

	while (qsub != NULL){

		if (qsub == sub) return true;
		if (qsub->lpn == sub->lpn) return true;
		if (qsub->location->channel == sub->location->channel && qsub->location->lun == sub->location->lun && qsub->location->plane == sub->location->plane){

			if (qsub->location->block == sub->location->block && qsub->location->page == sub->location->page) {
				// FIXME do we need to compare state??
				return true;

			}

		}

		qsub = qsub->next_node;
	}
	return false;
}

// Assembly:
movq (%rdi), %rdi
testq %rdi, %rdi
setne %al
cmpq %rsi, %rdi
je 0x411f
testq %rdi, %rdi
je 0x411f
movl 0xc(%rdi), %ecx
movb $0x1, %al
cmpl 0xc(%rsi), %ecx
je 0x411f
movq 0x60(%rdi), %rcx
movl (%rcx), %r8d
movq 0x60(%rsi), %rdx
cmpl (%rdx), %r8d
jne 0x4119
movl 0x4(%rcx), %r8d
cmpl 0x4(%rdx), %r8d
jne 0x4119
movl 0x8(%rcx), %r8d
cmpl 0x8(%rdx), %r8d
jne 0x4119
movl 0xc(%rcx), %r8d
cmpl 0xc(%rdx), %r8d
jne 0x4119
movl 0x10(%rcx), %ecx
cmpl 0x10(%rdx), %ecx
je 0x411f
addq $0x70, %rdi
jmp 0x40c6
retq
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: SubQueue::push_head(sub_request*)
void SubQueue::push_head(sub_request * sub){
	if (sub == NULL) return;

	size++;
	if (queue_tail == NULL){
		queue_head = sub;
		queue_tail = sub;
		return;
	}

	sub->next_node = queue_head;
	queue_head = sub;

}

// Assembly:
testq %rsi, %rsi
je 0x416a
incl 0x10(%rdi)
cmpq $0x0, 0x8(%rdi)
je 0x4160
movq (%rdi), %rax
movq %rax, 0x70(%rsi)
jmp 0x4167
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rsi, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/common.cpp
// Function: SubQueue::target_request(int, int, int)
sub_request * SubQueue::target_request(int plane, int block, int page ){

	sub_request * sub = queue_head;

	while (sub != NULL){
		if (sub->location->plane == plane)
			if (block == -1 || sub->location->block == block )
				if (page == -1 || sub->location->page == page)
					return sub;


		sub = sub->next_node;

	}

	return sub;
}

// Assembly:
movq %rdi, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x41ec
movq 0x60(%rax), %rdi
cmpl %esi, 0x8(%rdi)
jne 0x41e6
cmpl $-0x1, %edx
je 0x41dc
cmpl %edx, 0xc(%rdi)
jne 0x41e6
cmpl $-0x1, %ecx
je 0x41ec
cmpl %ecx, 0x10(%rdi)
je 0x41ec
addq $0x70, %rax
jmp 0x41c1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narges64[P]SIMBA/ftl.cpp
// Function: invalid_old_page(ssd_info*, int, local*)
STATE invalid_old_page(ssd_info * ssd, const int lpn, local * location){
	if (ssd->dram->map->map_entry[lpn].state == false) {
		if (ssd->current_time > 0){
			#if DEBUG 
			cout << "error in invalid old page error 1 " << endl;
			#endif 
		}
		return FAIL;
	}
	int old_ppn = ssd->dram->map->map_entry[lpn].pn;
	find_location(ssd, old_ppn, location);
	if( update_physical_page(ssd, old_ppn, -1) == FAIL) {
			cout << "could not update physical page " << endl;
			return FAIL;
	}
	if (update_map_entry(ssd, lpn, -1) == FAIL ) {
		cout << "could not update mapping entry " << endl;
		return FAIL;
	}
	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
xorl %ebx, %ebx
cmpb $0x0, 0x4(%rax,%rcx)
je 0x44b9
movl %esi, %ebp
movq %rdi, %r14
addq %rcx, %rax
movl (%rax), %r15d
movl %r15d, %esi
callq 0x45f8
pushq $-0x1
popq %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x582f
testl %eax, %eax
je 0x449e
pushq $-0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x57f5
pushq $0x1
popq %rbx
jmp 0x44b9
movq 0x9b2b(%rip), %rdi      # 0xdfd0
leaq 0x51ff(%rip), %rsi      # 0x96ab
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq