LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/config.cpp
// Function: Config::preprocessDistribution(char*)
void Config::preprocessDistribution(char* newDistribution)
{
    std::vector<std::string> tempDistribution = split(newDistribution, ' ');

    distribution.clear();
    distribution.push_back(0);

    int l = tempDistribution.size()+1;

    for (int i = 1; i < l; ++i)
    {
       distribution.push_back(distribution[i-1]+atof(tempDistribution[i-1].c_str()));
   }

   for (int i = 1; i < l; ++i) 
   {
       distribution[i] = distribution[i]/distribution[l-1];
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x820e
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
callq 0xd352
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64bb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rsi
cmpq %rax, %rsi
je 0x64d5
movq %rax, 0x80(%rbx)
movq %rax, %rsi
leaq 0x78(%rbx), %rbp
movq $0x0, 0x10(%rsp)
cmpq 0x88(%rbx), %rsi
je 0x64ff
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x650c
leaq 0x10(%rsp), %rdx
movq %rbp, %rdi
callq 0x47d4
movq 0x48(%rsp), %r12
subq 0x40(%rsp), %r12
movq %r12, %rax
shrq $0x5, %rax
incl %eax
cmpl $0x2, %eax
jl 0x65c8
movq %rax, 0x30(%rsp)
movl %eax, %r13d
leaq -0x1(%r13), %r15
xorl %r14d, %r14d
movq 0x78(%rbx), %rax
movsd (%rax,%r14), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax,%r14,4), %rdi
callq 0x3300
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x6582
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x658f
movq %rbp, %rdi
leaq 0x10(%rsp), %rdx
callq 0x47d4
addq $0x8, %r14
decq %r15
jne 0x6537
cmpl $0x2, 0x30(%rsp)
jl 0x65c8
movq (%rbp), %rax
shlq $0x1b, %r12
sarq $0x1d, %r12
movl $0x1, %ecx
movsd (%rax,%rcx,8), %xmm0
divsd (%rax,%r12), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x65b0
leaq 0x40(%rsp), %rdi
callq 0x8130
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6608
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6615
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x6615
movq %rax, %rbx
jmp 0x6615
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8130
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/config.cpp
// Function: Config::setBins(char const*)
void Config::setBins(const char *newBins)
{
    bins.clear();
    // split: divides a string into multiple strings that are separated by space ' '.
    std::vector<std::string> tempBins = split(newBins, ' ');
    bins.clear();
    for(unsigned int stage=0; stage<tempBins.size(); stage++)
    {
        int value = atoi(tempBins[stage].c_str());
        bins.push_back(value);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x804c
movq %rax, 0x30(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0xd392
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x806e
movq %rax, 0x30(%rbx)
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
cmpq %r12, %r13
je 0x80dc
leaq 0x28(%rbx), %r14
movl $0x1, %ebp
xorl %eax, %eax
leaq 0x4(%rsp), %r15
shlq $0x5, %rax
movq (%r12,%rax), %rdi
callq 0x33e0
movl %eax, 0x4(%rsp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x80b4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x80c9
movq %r14, %rdi
movq %r15, %rdx
callq 0x824c
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
movl %ebp, %eax
movq %r13, %rcx
subq %r12, %rcx
sarq $0x5, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x808d
leaq 0x8(%rsp), %rdi
callq 0x8130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8130
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/customizedinput.cpp
// Function: CustomizedInput::process()
void CustomizedInput::process()
{
    chrono->start("Input");

    for (int k = 0; k < config->getSignalLength(); k++)
    {
	neededSamples.insert(k);
    }

    convertFileToTimeSignal();
    
    chrono->stop("Input");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x65fd(%rip), %rsi      # 0xec4b
leaq 0x65fb(%rip), %rdx      # 0xec50
movq %rsp, %rdi
callq 0x4430
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5940
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x867e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movl $0x0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c28
testl %eax, %eax
jle 0x86b9
leaq 0x50(%rbx), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8d0c
movl (%rsp), %ebp
incl %ebp
movl %ebp, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c28
cmpl %eax, %ebp
jl 0x8699
movq %rbx, %rdi
callq 0x8736
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x6579(%rip), %rsi      # 0xec4b
leaq 0x6577(%rip), %rdx      # 0xec50
callq 0x4430
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x59dc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x86ff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8710
jmp 0x872b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x872e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x872e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/customizedinput.cpp
// Function: CustomizedInput::process(std::vector<int, std::allocator<int>>)
void CustomizedInput::process(std::vector<int> delays)
{
    chrono->start("Input");

    findNeededSamples(delays);
    convertFileToTimeSignal();

    chrono->stop("Input");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x627b(%rip), %rsi      # 0xec4b
leaq 0x6279(%rip), %rdx      # 0xec50
movq %rsp, %rdi
callq 0x4430
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5940
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8a00
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x539c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8ac6
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8a32
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x8736
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x6200(%rip), %rsi      # 0xec4b
leaq 0x61fe(%rip), %rdx      # 0xec50
callq 0x4430
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x59dc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8a78
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8a9f
jmp 0x8aba
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8abd
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
jmp 0x8ab3
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8abd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x8abd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/customizedinput.cpp
// Function: CustomizedInput::findNeededSamples(std::vector<int, std::allocator<int>>)
void CustomizedInput::findNeededSamples(std::vector<int> delays)
{

    int signalBitLength = config->getSignalBitLength();
    for (int c = 0; c < config->getBinsNb(); c++)
    {
        int binIndices = config->getSamplingPattern(c);

        int b = config->getBinNumIndices(c);
        int B = pow(2,b); // number of bins in stage

        for (int delayIndex = 0; delayIndex < config->getDelaysNb(); delayIndex++)
        {
            int currDelay = delays[delayIndex];

            std::vector<ffast_complex> binTimeDomain = std::vector<ffast_complex>(B);
            for (int bin_iter = 0; bin_iter < B; bin_iter++)
            {
                int mlInt = mapToInt(bin_iter, b, binIndices, signalBitLength);
                int signalIndex = currDelay ^ mlInt;

                neededSamples.insert(signalIndex);
            }
        }     
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0x6c18
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x6ce2
testl %eax, %eax
jle 0x8c2b
leaq 0x50(%r15), %rax
movq %rax, 0x38(%rsp)
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r15, 0x20(%rsp)
movq 0x10(%r15), %rdi
movl %ebx, %esi
callq 0x6c3c
movl %eax, %r12d
movq 0x10(%r15), %rdi
movl %ebx, 0x1c(%rsp)
movl %ebx, %esi
callq 0x6c94
movsd 0x55b8(%rip), %xmm0     # 0xe0e8
movl %eax, %edi
callq 0x33c0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rdi
callq 0x6cf0
testl %eax, %eax
jle 0x8c14
cvttsd2si 0x10(%rsp), %ebx
movslq %ebx, %rax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %r13, 0x10(%rsp)
movl (%rax,%r13,4), %r13d
leaq 0x40(%rsp), %rdi
movq 0x30(%rsp), %r15
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x8c96
testl %r15d, %r15d
jle 0x8bdc
xorl %r15d, %r15d
movl $0x0, %eax
testl %ebp, %ebp
jle 0x8bbe
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movl $0x1, %esi
shll %cl, %esi
btl %ecx, %r12d
jae 0x8bb8
btl %edx, %r15d
leal 0x1(%rdx), %edx
cmovael %r14d, %esi
addl %esi, %eax
incl %ecx
cmpl %ecx, %ebp
jne 0x8b9e
xorl %r13d, %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x8d0c
incl %r15d
cmpl %ebx, %r15d
jne 0x8b8f
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8bf3
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq 0x10(%rsp), %r13
incq %r13
movq 0x20(%rsp), %r15
movq 0x10(%r15), %rdi
callq 0x6cf0
cltq
cmpq %rax, %r13
jl 0x8b5f
movl 0x1c(%rsp), %ebx
incl %ebx
movq 0x10(%r15), %rdi
callq 0x6ce2
cmpl %eax, %ebx
jl 0x8b0b
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8c54
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::ExperimentInput(Chrono*, Config const*)
ExperimentInput::ExperimentInput(Chrono* newChrono, const Config* newConfig): Input(newChrono, newConfig)
{
    // set the signal amplitudes to 1 and change
    // the noise variance to account for SNR
    signalMagnitude = 1;
    noiseStdDeviation = pow(10,-config->getSNRdB()/20);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xce10
leaq 0xb739(%rip), %rax      # 0x14c38
movq %rax, (%rbx)
leaq 0x18(%rbx), %r14
leaq 0x48(%rbx), %rax
movq %rax, 0x18(%rbx)
movl $0x1, %eax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x38(%rbx)
movups %xmm0, 0x40(%rbx)
leaq 0x58(%rbx), %rdx
movl $0x0, 0x58(%rbx)
xorl %esi, %esi
movq %rsi, 0x60(%rbx)
movq %rdx, 0x68(%rbx)
movq %rdx, 0x70(%rbx)
movq %rsi, 0x78(%rbx)
leaq 0x88(%rbx), %r15
leaq 0xb8(%rbx), %rdx
movq %rdx, 0x88(%rbx)
movq %rax, 0x90(%rbx)
movups %xmm0, 0x98(%rbx)
movl %ecx, 0xa8(%rbx)
movups %xmm0, 0xb0(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0xc0(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6d00
divss 0x575b(%rip), %xmm0     # 0xecf4
cvtss2sd %xmm0, %xmm1
movsd 0x4b0b(%rip), %xmm0     # 0xe0b0
callq 0x3480
movsd %xmm0, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
addq $0x50, %rbx
movq %r15, %rdi
callq 0x43c0
movq %rbx, %rdi
callq 0x4370
movq %r14, %rdi
callq 0x43c0
movq %r12, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::process()
void ExperimentInput::process()
{
    chrono->start("Input");
    neededSamples.clear();
    for (int k = 0; k < config->getSignalLength(); k++)
    {
	   neededSamples.insert(k);
    }

    nonZeroFrequencies.clear();
    generateNonZeroFrequencies();

    for (auto t = neededSamples.cbegin(); t != neededSamples.cend(); ++t) {
        timeSignal[*t] =0;
    }
    
    frequencyToTime();
    
    if (config->isNoisy())
    {
        addNoise();
    }
    
    for (auto t = neededSamples.cbegin(); t != neededSamples.cend(); ++t)
    {
        timeSignal[*t] /= sqrt((ffast_complex)config->getSignalLengthOriginal());
    }
    chrono->stop("Input");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x55f8(%rip), %rsi      # 0xec4b
leaq 0x55f6(%rip), %rdx      # 0xec50
leaq 0x8(%rsp), %rdi
callq 0x4430
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5940
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9688
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0xa1fe
movl $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c28
testl %eax, %eax
jle 0x96d0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8d0c
movl 0x8(%rsp), %ebp
incl %ebp
movl %ebp, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c28
cmpl %eax, %ebp
jl 0x96ae
leaq 0x88(%rbx), %rdi
callq 0x43e6
movq %rbx, %rdi
callq 0x9828
movq 0x68(%rbx), %r14
leaq 0x58(%rbx), %rbp
cmpq %rbp, %r14
je 0x9717
leaq 0x18(%rbx), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8e1a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x96f5
movq %rbx, %rdi
callq 0x9a12
movq 0x10(%rbx), %rdi
callq 0x6cfc
testb %al, %al
je 0x9734
movq %rbx, %rdi
callq 0x9adc
movq 0x68(%rbx), %r14
cmpq %rbp, %r14
je 0x97ab
leaq 0x18(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x811c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
callq 0x3340
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8e1a
movq %rax, %r12
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x3140
movsd %xmm0, (%r12)
movsd %xmm1, 0x8(%r12)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x9741
movq 0x8(%rbx), %rbx
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x548d(%rip), %rsi      # 0xec4b
leaq 0x548b(%rip), %rdx      # 0xec50
callq 0x4430
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x59dc
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x97ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9801
jmp 0x981d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9820
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x9820
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::generateNonZeroFrequencies()
void ExperimentInput::generateNonZeroFrequencies()
{
    std::set<int> tempLocations;
    nonZeroFrequencies.clear();

    while((int) tempLocations.size() < config->getSignalSparsity())
    {
        int tempLocation = ((int) floor(config->getSignalLengthOriginal()*distribution((ffast_real) drand48(), config->getDistribution())))
                % config->getSignalLengthOriginal();
        tempLocations.insert(tempLocation);
    }

    for(auto it = tempLocations.cbegin(); it != tempLocations.cend(); ++it)
    {
        nonZeroFrequencies[*it] = std::polar(signalMagnitude, getRandomPhase());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
addq $0x88, %rdi
movq %rdi, 0x20(%rsp)
callq 0x43e6
leaq 0x28(%rsp), %r15
leaq 0x40(%rsp), %r12
leaq 0x1c(%rsp), %r13
movq 0x68(%rsp), %r14
movq 0x10(%rbx), %rdi
callq 0x6c30
cmpl %r14d, %eax
jle 0x9919
movq 0x10(%rbx), %rdi
callq 0x811c
movl %eax, %ebp
callq 0x3230
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x810a
movsd (%rsp), %xmm0
movq %r15, %rsi
callq 0xa02c
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x811c
movl %eax, %r14d
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x3460
cvttsd2si %xmm0, %eax
cltd
idivl %r14d
movl %edx, %ebp
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9905
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movl %ebp, 0x1c(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8d0c
jmp 0x9879
movq 0x58(%rsp), %r15
leaq 0x48(%rsp), %r14
cmpq %r14, %r15
movq 0x20(%rsp), %r12
je 0x99c0
movq %rbx, %rdi
callq 0xa096
movaps %xmm0, %xmm1
movups 0xc0(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, %xmm0
movsd %xmm1, (%rsp)
callq 0x34e0
movaps %xmm0, 0x80(%rsp)
movsd 0xc0(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
movsd (%rsp), %xmm0
callq 0x3060
movaps %xmm0, (%rsp)
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x8e1a
movapd 0x90(%rsp), %xmm0
unpcklpd 0x70(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movapd 0x80(%rsp), %xmm1
unpcklpd (%rsp), %xmm1           # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
movupd %xmm1, (%rax)
movq %r15, %rdi
callq 0x32c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x9931
leaq 0x40(%rsp), %rdi
callq 0x4370
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x99ff
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
jmp 0x99ff
jmp 0x99fc
jmp 0x99fc
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4370
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::addNoise()
void ExperimentInput::addNoise()
{
    ffast_real signalPower = signalMagnitude * signalMagnitude;
    ffast_real noisePower = 0;
    ffast_real noiseNormFactor;
    ffast_real noisePhase;

    for (auto t = neededSamples.cbegin(); t != neededSamples.cend(); ++t)
    {
        noiseNormFactor = (ffast_real) -2*log(drand48());
        noisePhase = (ffast_real) 2*M_PI*drand48();
        noisePower += noiseNormFactor; // Standard deviation added later.
        timeSignal[*t] += std::polar( noiseStdDeviation * ((ffast_real) sqrt( (double) noiseNormFactor ) ) / sqrt(2) , noisePhase );
    }

    noisePower *= noiseStdDeviation * noiseStdDeviation;
    realSNR = signalPower * config->getSignalLength()/noisePower;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movsd 0xc0(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rdi), %r14
leaq 0x58(%rdi), %r12
cmpq %r12, %r14
je 0x9c12
leaq 0x18(%rbx), %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x3230
callq 0x31d0
mulsd 0x51d0(%rip), %xmm0     # 0xecf8
movsd %xmm0, 0x20(%rsp)
callq 0x3230
movsd 0x20(%rsp), %xmm3
movapd %xmm0, %xmm2
mulsd 0x51bb(%rip), %xmm2     # 0xed00
movsd 0xd0(%rbx), %xmm1
ucomisd 0x51bb(%rip), %xmm3     # 0xed10
movsd %xmm2, 0x30(%rsp)
jb 0x9b66
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x9b87
movapd %xmm3, %xmm0
movapd %xmm1, 0x10(%rsp)
callq 0x31c0
movsd 0x20(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, (%rsp)
divsd 0x5167(%rip), %xmm1     # 0xed08
movapd %xmm1, 0x10(%rsp)
movapd %xmm2, %xmm0
callq 0x34e0
movapd %xmm0, 0x20(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x3060
movaps %xmm0, 0x30(%rsp)
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8e1a
movapd 0x20(%rsp), %xmm1
unpcklpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd 0x10(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
movapd %xmm0, %xmm1
movupd (%rax), %xmm0
addpd %xmm1, %xmm0
movupd %xmm0, (%rax)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %r12, %rax
jne 0x9b16
jmp 0x9c1b
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c28
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xc8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::process(std::vector<int, std::allocator<int>>)
void ExperimentInput::process(std::vector<int> delays)
{

    chrono->start("Input");
    findNeededSamples(delays);

    generateNonZeroFrequencies();
    

    // frequencyToTimeUsingFFT(delays);
    frequencyToTime();
        

    if (config->isNoisy())
    {
        addNoise();
    }

    for (auto t = neededSamples.cbegin(); t != neededSamples.cend(); ++t)
    {
        timeSignal[*t] /= sqrt((ffast_complex)config->getSignalLengthOriginal());
    }


    
    chrono->stop("Input");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4fb1(%rip), %rsi      # 0xec4b
leaq 0x4faf(%rip), %rdx      # 0xec50
movq %rsp, %rdi
callq 0x4430
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5940
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9cca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x539c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9e2a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9cfc
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x9828
movq %rbx, %rdi
callq 0x9a12
movq 0x10(%rbx), %rdi
callq 0x6cfc
testb %al, %al
je 0x9d21
movq %rbx, %rdi
callq 0x9adc
movq 0x68(%rbx), %r14
leaq 0x58(%rbx), %rbp
cmpq %rbp, %r14
je 0x9d9c
leaq 0x18(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x811c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
callq 0x3340
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8e1a
movq %rax, %r12
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
callq 0x3140
movsd %xmm0, (%r12)
movsd %xmm1, 0x8(%r12)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x9d32
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x4e9e(%rip), %rsi      # 0xec4b
leaq 0x4e9c(%rip), %rdx      # 0xec50
callq 0x4430
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x59dc
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9dda
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e04
jmp 0x9e1f
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9e22
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
jmp 0x9e18
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9e22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x9e22
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentinput.cpp
// Function: ExperimentInput::getRandomPhase() const
ffast_real ExperimentInput::getRandomPhase() const
{
    if (config->getPhasesNb() < 1)
    {
       return 2*M_PI*drand48();
    }
    else if (config->getPhasesNb() == 1)
    {
        return 0;
    }
    else if (config->getPhasesNb() == 2)
    {
        return M_PI*std::round(drand48());
    }
    else
    {
        return (std::floor(config->getPhasesNb()*drand48())*2 + 1)*M_PI/config->getPhasesNb();
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6d10
testl %eax, %eax
jle 0xa0e3
movq 0x10(%rbx), %rdi
callq 0x6d10
xorpd %xmm0, %xmm0
cmpl $0x1, %eax
je 0xa150
movq 0x10(%rbx), %rdi
callq 0x6d10
cmpl $0x2, %eax
jne 0xa0f2
callq 0x3230
callq 0x30e0
mulsd 0x4c37(%rip), %xmm0     # 0xed18
jmp 0xa150
callq 0x3230
mulsd 0x4c10(%rip), %xmm0     # 0xed00
jmp 0xa150
movq 0x10(%rbx), %rdi
callq 0x6d10
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3230
mulsd 0x8(%rsp), %xmm0
callq 0x3460
addsd %xmm0, %xmm0
addsd 0x3fc4(%rip), %xmm0     # 0xe0e8
mulsd 0x4bec(%rip), %xmm0     # 0xed18
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d10
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::checkFalseDetections()
void ExperimentOutput::checkFalseDetections()
{
    // number of false detections in the current iteration of the algorithm
    falseDetectionsIterationNb = 0;

    // go over the decoded frequencies by the backEnd
    for (auto it = backEnd->getDecodedFrequencies().cbegin(); it != backEnd->getDecodedFrequencies().cend(); ++it)
    {
        // if decoded frequency is a false detection
        if (input->getNonZeroFrequencies().count(it->first) == 0)
        {
            falseDetectionsIterationNb++;
        }
    }

    // addd the results of current iteration to the global couter
    falseDetectionsNbs.push_back(falseDetectionsIterationNb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdi
callq 0x4222
movq 0x10(%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x4222
testq %r14, %r14
je 0xa6c7
movq 0x20(%rbx), %rdi
callq 0x9ff8
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x44c6
testq %rax, %rax
jne 0xa6c2
incl 0x38(%rbx)
movq (%r14), %r14
jmp 0xa697
movl 0x38(%rbx), %eax
movl %eax, 0x4(%rsp)
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0xa6e4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x60(%rbx)
jmp 0xa6f5
addq $0x58, %rbx
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xb96e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::computeMSEErrorAmplitude()
void ExperimentOutput::computeMSEErrorAmplitude()
{
    if (falseDetectionsIterationNb == 0 && missedLocationsIterationNb == 0 && binningFailure == false)
    {
        ffast_real denominator = 0, numerator = 0;
        for (auto i = input->getNonZeroFrequencies().cbegin(); i != input->getNonZeroFrequencies().cend(); ++i)
        {
            numerator+=std::norm(i->second-backEnd->getDecodedFrequencies().at(i->first));
            denominator+=std::norm(i->second);
        }
        MSEerrorsAmplitude.push_back(numerator/denominator);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x38(%rdi)
jne 0xa9c2
movq %rdi, %rbx
cmpl $0x0, 0x3c(%rdi)
jne 0xa9c2
cmpb $0x0, 0x40(%rbx)
jne 0xa9c2
movq 0x20(%rbx), %rdi
callq 0x9ff8
movq 0x10(%rax), %r15
movq 0x20(%rbx), %rdi
callq 0x9ff8
testq %r15, %r15
je 0xa97f
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
leaq 0x8(%r15), %r14
movq 0x18(%rbx), %rdi
callq 0x4222
movq %rax, %rdi
movq %r14, %rsi
callq 0x44c6
testq %rax, %rax
je 0xa9cc
movsd 0x10(%r15), %xmm0
movapd %xmm0, %xmm1
subsd 0x10(%rax), %xmm1
movsd 0x18(%r15), %xmm2
movapd %xmm2, %xmm3
subsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
mulpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm1, %xmm1
addpd %xmm3, %xmm1
movapd (%rsp), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, (%rsp)
movq (%r15), %r15
movq 0x20(%rbx), %rdi
callq 0x9ff8
testq %r15, %r15
jne 0xa8fa
movapd (%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
divsd %xmm0, %xmm1
jmp 0xa987
movsd 0x43b1(%rip), %xmm1     # 0xed38
movsd %xmm1, 0x18(%rsp)
movq 0xe8(%rbx), %rsi
cmpq 0xf0(%rbx), %rsi
je 0xa9ae
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xe8(%rbx)
jmp 0xa9c2
addq $0xe0, %rbx
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x47d4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4298(%rip), %rdi      # 0xec6b
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::computeMSEerror()
void ExperimentOutput::computeMSEerror()
{
    if (falseDetectionsIterationNb == 0 && missedLocationsIterationNb == 0 && binningFailure == false)
    {
        ffast_real MSEerror = 0;
        for (auto i = backEnd->getRealFrequenciesIndices().cbegin(); i != backEnd->getRealFrequenciesIndices().cend(); ++i)
        {
            bool found = false;
            auto it = input->getNonZeroFrequencies().cbegin();
            while (!found && it != input->getNonZeroFrequencies().cend())
            {
                if(std::abs((double)it->first-(*i))<=3)
                {
                    MSEerror += std::abs( it->first-(*i) );
                    found = true;
                }
                ++it;
            }
        }
        MSEerrors.push_back(MSEerror/config->getSignalSparsity());
    }
}

// Assembly:
cmpl $0x0, 0x38(%rdi)
jne 0xaaf4
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x3c(%rdi)
jne 0xaaeb
cmpb $0x0, 0x40(%rbx)
jne 0xaaeb
movq 0x18(%rbx), %rdi
callq 0x421c
movq (%rax), %r15
movq 0x18(%rbx), %rdi
callq 0x421c
cmpq 0x8(%rax), %r15
je 0xaa8e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
callq 0x9ff8
movq %rax, %r14
addq $0x10, %r14
movq (%r14), %r14
movq 0x20(%rbx), %rdi
callq 0x9ff8
testq %r14, %r14
je 0xaa79
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%r14), %xmm0
subsd (%r15), %xmm0
andpd 0x42f3(%rip), %xmm0     # 0xed50
movsd 0x3673(%rip), %xmm1     # 0xe0d8
ucomisd %xmm0, %xmm1
jb 0xaa36
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
addq $0x8, %r15
movq 0x18(%rbx), %rdi
callq 0x421c
cmpq 0x8(%rax), %r15
jne 0xaa26
jmp 0xaa97
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6c30
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x90(%rbx), %rsi
cmpq 0x98(%rbx), %rsi
je 0xaad7
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x90(%rbx)
jmp 0xaaeb
addq $0x88, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x47d4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::displayIterationResults() const
void ExperimentOutput::displayIterationResults() const
    {
        std::cout << MSEerrorAmplitude << " -> MSE error Amplitude" << std::endl;

        if (falseDetectionsIterationNb > 0)
        {
            std::cout << falseDetectionsIterationNb << " -> false detections" << std::endl;
        }
        else if (missedLocationsIterationNb > 0)
        {
            std::cout << missedLocationsIterationNb << " -> missed locations" << std::endl;
        }
        else if (binningFailure)
        {
         std::cout << "Binning failure" << std::endl;
     }
     else
     {
        std::cout << "Full recovery" << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movsd 0x48(%rdi), %xmm0
movq 0xa4be(%rip), %rbx      # 0x14fc8
movq %rbx, %rdi
callq 0x3400
movq %rax, %r15
leaq 0x4274(%rip), %rsi      # 0xed90
movl $0x17, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movl 0x38(%r14), %esi
testl %esi, %esi
jle 0xab70
movq 0xa469(%rip), %rdi      # 0x14fc8
callq 0x3470
movq %rax, %rbx
leaq 0x423a(%rip), %rsi      # 0xeda8
jmp 0xab8e
movl 0x3c(%r14), %esi
testl %esi, %esi
jle 0xabc7
movq 0xa449(%rip), %rdi      # 0x14fc8
callq 0x3470
movq %rax, %rbx
leaq 0x422f(%rip), %rsi      # 0xedbd
movl $0x14, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3170
cmpb $0x1, 0x40(%r14)
jne 0xabe3
movq 0xa3f3(%rip), %rbx      # 0x14fc8
leaq 0x41f6(%rip), %rsi      # 0xedd2
movl $0xf, %edx
jmp 0xabef
leaq 0x41f8(%rip), %rsi      # 0xede2
movl $0xd, %edx
movq %rbx, %rdi
jmp 0xab96
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::isBinningFailure(std::set<int, std::less<int>, std::allocator<int>>) const
bool ExperimentOutput::isBinningFailure(std::set<int> missedLocations) const
{
    /*
        if at least one of the missed locations appear in a singleton bin, that is,
        it could have been peeled, declare NOT a bining failure. If all of the missed
        locations appear in multiton bins, than it is a binning failure.
    */
    for (int stage=0; stage<config->getBinsNb(); stage++)
    {
        // std::vector<int> binStatus(config->getOldBinSize(stage), 0);
        std::vector<int> binStatus(config->getBinNumItems(stage), 0);


        for (auto it = missedLocations.cbegin(); it != missedLocations.cend(); ++it)
        {
            // binStatus[*it % config->getOldBinSize(stage)]++;
            binStatus[*it % config->getBinNumItems(stage)]++;
        }

        for (unsigned int index=0; index<binStatus.size(); index++)
        {
            if (binStatus[index] == 1)
            {
                return false;
            }
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0x6ce2
movb $0x1, %cl
testl %eax, %eax
jle 0xb2e5
leaq 0x8(%r14), %rbx
xorl %r12d, %r12d
movq 0x10(%r15), %rdi
movl %r12d, %esi
callq 0x6c48
movslq %eax, %rsi
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0xb(%rsp), %rcx
callq 0xb318
movq 0x18(%r14), %r13
cmpq %rbx, %r13
je 0xb279
movl 0x20(%r13), %ebp
movq 0x10(%r15), %rdi
movl %r12d, %esi
callq 0x6c48
movl %eax, %ecx
movl %ebp, %eax
cltd
idivl %ecx
movslq %edx, %rax
movq 0x10(%rsp), %rbp
incl (%rbp,%rax,4)
movq %r13, %rdi
callq 0x32c0
movq %rax, %r13
cmpq %rbx, %rax
jne 0xb244
jmp 0xb27e
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rax
subq %rbp, %rax
je 0xb2a5
sarq $0x2, %rax
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x1, (%rbp,%rdx,4)
je 0xb2d3
movl %ecx, %edx
incl %ecx
cmpq %rdx, %rax
ja 0xb293
jmp 0xb2aa
testq %rbp, %rbp
je 0xb2ba
movq 0x20(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0x3270
incl %r12d
movq 0x10(%r15), %rdi
callq 0x6ce2
cmpl %eax, %r12d
jl 0xb210
movb $0x1, %cl
jmp 0xb2e5
movq 0x20(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0x3270
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb310
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: void ExperimentOutput::setAverageAndMax<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&, double&, double&, int*)
void ExperimentOutput::setAverageAndMax(tempVector& array, ffast_real& average, ffast_real& max, int* counter)
    {
        for (unsigned int i=0; i<array.size(); i++)
        {
            average += array[i];

            if (max < array[i])
            {
                max = array[i];
            }

            if (counter != NULL && array[i] > 0)
            {
                (*counter)++;
            }
        }
        if (array.size() > 0)
        {
            average /= array.size();
        }
    }

// Assembly:
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rsi, %rax
subq %rdi, %rax
je 0xb504
sarq $0x3, %rax
xorl %r9d, %r9d
xorpd %xmm0, %xmm0
movsd (%rdi,%r9,8), %xmm1
addsd (%rdx), %xmm1
movsd %xmm1, (%rdx)
movsd (%rdi,%r9,8), %xmm1
ucomisd (%rcx), %xmm1
jbe 0xb4cc
movsd %xmm1, (%rcx)
testq %r8, %r8
je 0xb4e0
movsd (%rdi,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xb4e0
incl (%r8)
incq %r9
movl %r9d, %r10d
cmpq %r10, %rax
ja 0xb4ae
cmpq %rdi, %rsi
je 0xb504
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rdx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/frontend.cpp
// Function: FrontEnd::FrontEnd(Chrono*, Config const*, Input const*)
FrontEnd::FrontEnd(Chrono* newChrono, const Config* newConfig, const Input* newInput):
	Step(newChrono, newConfig),countSamplesDone(false),input(newInput)
{
    signalLength = config->getSignalLength();
    observationMatrix = (ffast_complex**) malloc(config->getBinsSum() * sizeof(ffast_complex*));

    for (int binAbsoluteIndex=0; binAbsoluteIndex<config->getBinsSum(); binAbsoluteIndex++)
    {
        observationMatrix[binAbsoluteIndex] = (ffast_complex*) malloc(config->getDelaysNb() * sizeof(ffast_complex));
    }
    for (int binAbsoluteIndex=0; binAbsoluteIndex<config->getBinsSum(); binAbsoluteIndex++)
        for (int delayNb = 0; delayNb < config->getBinsSum(); delayNb++)
            observationMatrix[binAbsoluteIndex][delayNb] = 0;

    computeDelays();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x8f2a(%rip), %rax      # 0x14ce0
movq %rax, (%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000
movups %xmm0, 0x40(%rdi)
movb $0x0, 0x5c(%rdi)
movups %xmm0, 0x60(%rdi)
xorl %eax, %eax
movq %rax, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
leaq 0x88(%rdi), %rcx
movl $0x0, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rcx, 0x98(%rdi)
movq %rcx, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movq %rdx, %rdi
callq 0x6c28
movl %eax, 0x58(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6cde
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3320
movq %rax, 0x50(%rbx)
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x6cde
cltq
cmpq %rax, %r14
jge 0xbe73
movq 0x10(%rbx), %rdi
callq 0x6cf0
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0x3320
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0xbe41
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x6cde
cltq
cmpq %rax, %r14
jge 0xbeba
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
callq 0x6cde
cltq
cmpq %rax, %r12
jge 0xbeb5
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rax
incq %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r15)
addq $0x10, %r15
jmp 0xbe8c
incq %r14
jmp 0xbe76
movq %rbx, %rdi
callq 0xbf10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbed4
jmp 0xbed4
jmp 0xbed4
movq %rax, %r14
leaq 0x18(%rbx), %r15
leaq 0x60(%rbx), %r12
leaq 0x80(%rbx), %rdi
callq 0x4370
movq (%r12), %rdi
testq %rdi, %rdi
je 0xbf00
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
movq %r15, %rdi
callq 0x43c0
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/split.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string>& split(const std::string& string, char delimeter, std::vector<std::string>& elements)
{
    std::stringstream stringStream(string);
    std::string item;

    while (std::getline(stringStream, item, delimeter))
    {
        elements.push_back(item);
    }

    return elements;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x33f0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x34d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xd2ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd40e
jmp 0xd2a2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd2e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x7cb0(%rip), %rsi      # 0x14f98
leaq 0x28(%rsp), %rdi
callq 0x31a0
leaq 0xa8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd32c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x7c65(%rip), %rsi      # 0x14f98
leaq 0x28(%rsp), %rdi
callq 0x31a0
leaq 0xa8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/spright.cpp
// Function: SPRIGHT::SPRIGHT(Config const*, Input*, Output*)
SPRIGHT::SPRIGHT(const Config* newConfig, Input* newInput, Output* newOutput): config(newConfig), input(newInput), output(newOutput)
{
    chrono    = new Chrono();
    frontEnd  = new FrontEnd(chrono, config, input);
    backEnd   = new BackEnd(chrono, config, frontEnd);
    output->setBackEnd(backEnd);
    iteration = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movl $0xa0, %edi
callq 0x3260
movq %rax, %r13
addq $0x18, %rax
xorl %ecx, %ecx
movl %ecx, 0x18(%r13)
movq %rcx, 0x20(%r13)
movq %rax, 0x28(%r13)
movq %rax, 0x30(%r13)
movq %rcx, 0x38(%r13)
leaq 0x48(%r13), %rax
movl %ecx, 0x48(%r13)
movq %rcx, 0x50(%r13)
movq %rax, 0x58(%r13)
movq %rax, 0x60(%r13)
movq %rcx, 0x68(%r13)
leaq 0x78(%r13), %rax
movl %ecx, 0x78(%r13)
movq %rcx, 0x80(%r13)
movq %rax, 0x88(%r13)
movq %rax, 0x90(%r13)
movq %rcx, 0x98(%r13)
movq %r13, 0x8(%rbx)
movl $0xb0, %edi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbd9c
movq %r12, 0x30(%rbx)
movl $0xc0, %edi
callq 0x3260
movq %rax, %r14
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq %rax, %rdi
movq %r12, %rcx
callq 0x39dc
movq %r14, 0x28(%rbx)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd244
movl $0x0, 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xc0, %esi
movq %r14, %rdi
jmp 0xd756
movq %rax, %rbx
movl $0xb0, %esi
movq %r12, %rdi
callq 0x3270
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/spright.cpp
// Function: SPRIGHT::~SPRIGHT()
SPRIGHT::~SPRIGHT()
{
    delete output;
    delete backEnd;
    delete frontEnd;
    delete input;
    delete config;
    delete chrono;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xd77a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xd789
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xd798
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xd7a7
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %r14
testq %r14, %r14
je 0xd80c
movq 0xb8(%r14), %rdi
testq %rdi, %rdi
je 0xd7ca
movq 0xc8(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0xd7e2
movq 0x88(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0xd7f7
movq 0x50(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xd80c
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movl $0xd0, %esi
movq %r14, %rdi
callq 0x3270
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xd83d
leaq 0x70(%rbx), %rdi
callq 0xde18
leaq 0x40(%rbx), %rdi
callq 0xde18
leaq 0x10(%rbx), %rdi
callq 0xde18
movl $0xa0, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3270
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/spright.cpp
// Function: SPRIGHT::process()
void SPRIGHT::process()
{
    chrono->start("Global");

    iteration++;
    frontEnd->process();
    backEnd->process();

    chrono->stop("Global");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x176c(%rip), %rsi      # 0xefde
leaq 0x176b(%rip), %rdx      # 0xefe4
movq %rsp, %rdi
callq 0x4430
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5940
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xd8a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
incl 0x20(%rbx)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1714(%rip), %rsi      # 0xefde
leaq 0x1713(%rip), %rdx      # 0xefe4
callq 0x4430
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x59dc
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xd8f7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd905
jmp 0xd920
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xd923
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xd923
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/spright.cpp
// Function: SPRIGHT::displayExecutionTime(double, double, double) const
void SPRIGHT::displayExecutionTime(double frontEndTime, double backEndTime, double globalTime) const
{
    double SPRIGHTtime = frontEndTime+backEndTime;

    std::cout << std::setprecision(3) << std::scientific
              << frontEndTime << " -> execution of the front-end"  << std::endl
              << backEndTime << " -> execution of the back-end"  << std::endl
              << SPRIGHTtime << " -> total execution of SPRIGHT"  << std::endl;

    std::cout << globalTime << " -> global execution" << std::endl;

    std::cout.unsetf(std::ios_base::floatfield);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
movapd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movq 0x7329(%rip), %rbx      # 0x14fc8
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x8(%rbx,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ebp       # imm = 0xFFFFFEFB
movl 0x18(%rbx,%rax), %ecx
andl %ebp, %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
callq 0x3400
movq %rax, %r14
leaq 0x1376(%rip), %rsi      # 0xf050
movl $0x1e, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3400
movq %rax, %r14
leaq 0x1349(%rip), %rsi      # 0xf06f
movl $0x1d, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3400
movq %rax, %r14
leaq 0x131b(%rip), %rsi      # 0xf08d
movl $0x1e, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x3400
movq %rax, %r14
leaq 0x12ee(%rip), %rsi      # 0xf0ac
movl $0x14, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl %ebp, 0x18(%rbx,%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_NEW_ARRAY()
DEF_FUNC(NEW_ARRAY)
{
    v_stack.add();
    STOP.type=T_ARRAY;
    STOP.v_array=newArray();
    reg_this=STOP;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
incq %rsi
callq 0xb010
movq 0x70(%rbx), %rax
movl $0x5, -0x20(%rax)
callq 0x10dfc
movq 0x70(%rbx), %rcx
movq %rax, -0x18(%rcx)
movq 0x70(%rbx), %rax
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, 0x468(%rbx)
movups %xmm1, 0x478(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_NEW_OBJECT()
DEF_FUNC(NEW_OBJECT)
{
    v_stack.add();
    STOP.type=T_OBJECT;
    STOP.v_object=newObject();
    reg_this=STOP;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
incq %rsi
callq 0xb010
movq 0x70(%rbx), %rax
movl $0x6, -0x20(%rax)
callq 0x10e9c
movq 0x70(%rbx), %rcx
movq %rax, -0x18(%rcx)
movq 0x70(%rbx), %rax
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, 0x468(%rbx)
movups %xmm1, 0x478(%rbx)
popq %rbx
retq