LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::keyword_while()
Instruction* Parser::keyword_while() {
	Instruction* ins = new Instruction(Ins::WHILE);

	ins->left = this->read_until(std::vector<lexer::Token>{
		lexer::Token::OPERATOR("{")
	});

	this->advance();
	ins->right = this->read_until(std::vector<lexer::Token>{
		lexer::Token::OPERATOR("}")
	});

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0xd, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x7b, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x6d74
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x11680
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %r14, %rsi
callq 0xde4a
movq 0x38(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq %rdi, 0x10(%rsp)
movups 0x40(%rbx), %xmm1
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movups %xmm1, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x10f94
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x10fa3
callq 0x3230
leaq 0x70(%rsp), %rdi
callq 0x116c2
leaq 0x48(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x10fc1
callq 0x3230
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10fd3
callq 0x3230
cmpb $0x1, 0x20(%r14)
jne 0x10fe0
incl 0x18(%r14)
jmp 0x10fe5
movb $0x1, 0x20(%r14)
leaq 0x98(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x7d, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x6d74
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x11680
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movq %r14, %rsi
callq 0xde4a
movq 0x50(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq %rdi, 0x10(%rsp)
movups 0x58(%rbx), %xmm1
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movups %xmm1, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x1107b
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1108a
callq 0x3230
leaq 0x58(%rsp), %rdi
callq 0x116c2
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x110a3
callq 0x3230
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0x110b5
callq 0x3230
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x116c2
jmp 0x110d9
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x110ed
callq 0x3230
jmp 0x110ed
movq %rax, %rbx
movq 0x88(%rsp), %rdi
jmp 0x11129
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x116c2
jmp 0x11109
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11121
callq 0x3230
jmp 0x11121
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11133
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::boolean_init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Instruction* Parser::boolean_init(std::string val) {
	Instruction* ins = new Instruction(Ins::LITERAL);

	if (val == "true") {
		ins->value = new Value(Type::BOOL, 1);
	} else {
		ins->value = new Value(Type::BOOL, 0);
	}

	return ins;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x2, %eax
movl %eax, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
movl %eax, 0x30(%rbx)
leaq 0x1f79(%rip), %rsi      # 0x132ff
movq %r14, %rdi
callq 0x30a0
movl %eax, %ebp
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
testl %ebp, %ebp
je 0x113b3
xorps %xmm0, %xmm0
movq %r14, %rdi
movl $0x3, %esi
callq 0xceac
jmp 0x113c8
movsd 0x2135(%rip), %xmm0     # 0x134f0
movq %r14, %rdi
movl $0x3, %esi
callq 0xceac
movq %r14, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x113d6
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::initialize()
void BackEnd::initialize()
{
    decodedFrequencies.clear();
    realFrequenciesIndices.clear();

    // peeling engine checks for singletons only in the updated (changed) bins
    // initialize all to true so that all the bins are check on the first run through
    for (int binAbsoluteIndex = 0; binAbsoluteIndex < config->getBinsSum(); binAbsoluteIndex++)
    {
        changed[binAbsoluteIndex] = true;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
callq 0x4478
movq 0x68(%rbx), %rax
cmpq %rax, 0x70(%rbx)
je 0x3ee2
movq %rax, 0x70(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6e18
testl %eax, %eax
jle 0x3f11
xorl %r14d, %r14d
movq 0x80(%rbx), %rax
movb $0x1, (%rax,%r14)
incq %r14
movq 0x10(%rbx), %rdi
callq 0x6e18
cltq
cmpq %rax, %r14
jl 0x3ef2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::printObservations()
void BackEnd::printObservations() {
    for (int stagePrint = 0; stagePrint < config->getBinsNb(); stagePrint++) {
        std::cout<< "-------------------------------" << std::endl;
        for (int r = 0; r < config->getBinNumItems(stagePrint); r++) {
            for (int c = 0; c < config->getDelaysNb(); c++) {
                std::cout << observationMatrix[r + config->getBinOffset(stagePrint)][c] << ", ";
            }
            std::cout << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6e1c
testl %eax, %eax
jle 0x4293
xorl %r14d, %r14d
movq 0x11e5a(%rip), %r15     # 0x15fc8
movl $0x1f, %edx
movq %r15, %rdi
leaq 0xaebb(%rip), %rsi      # 0xf038
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
movq 0x10(%rbx), %rdi
movl %r14d, %esi
callq 0x6d82
testl %eax, %eax
jle 0x427e
xorl %eax, %eax
movq %r14, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6e2a
testl %eax, %eax
leaq 0xbd21(%rip), %rbp      # 0xfefb
jle 0x4236
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
movq %r15, %r14
movq 0x28(%rbx), %r15
movq 0x10(%rsp), %rsi
callq 0x6e0c
addl 0xc(%rsp), %eax
cltq
movq (%r15,%rax,8), %rsi
movq %r14, %r15
addq %r12, %rsi
movq %r14, %rdi
callq 0x32d0
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x32b0
incq %r13
movq 0x10(%rbx), %rdi
callq 0x6e2a
cltq
addq $0x10, %r12
cmpq %rax, %r13
jl 0x41e2
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 0xc(%rsp), %ebp
incl %ebp
movq 0x10(%rbx), %rdi
movq 0x10(%rsp), %r14
movl %r14d, %esi
callq 0x6d82
cmpl %eax, %ebp
movl %ebp, %eax
jl 0x41c4
incl %r14d
movq 0x10(%rbx), %rdi
callq 0x6e1c
cmpl %eax, %r14d
jl 0x416e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::getHash(int, int)
int BackEnd::getHash(int stage, int spectralIndex)
{
    bool** subsamplingMatrix = config->getSubsamplingMatrix(stage);
    int ret = 0;

    for (int r = 0; r < config->getBinNumIndices(stage); r++) {
        bool currState = false;
        for (int c = 0; c < config->getSignalBitLength(); c++) {
            // currState = currState ^ (subsamplingMatrix[r][c] & (spectralIndexBinary[c] == 1));
            int shifted = 1 << (config->getSignalBitLength() - c - 1);
            currState = currState ^ (subsamplingMatrix[r][c] & ( (spectralIndex & shifted) == shifted));

        }
        if (currState)
            ret += 1<< (config->getBinNumIndices(stage)- r-1);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r12
movq 0x10(%rdi), %rdi
callq 0x6e5e
movq %rax, %r14
movq 0x10(%r12), %rdi
movl %ebx, %esi
callq 0x6dce
testl %eax, %eax
jle 0x43cf
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
movl %ebx, 0x10(%rsp)
movq %r14, 0x20(%rsp)
movl %r15d, 0x14(%rsp)
movq 0x10(%r12), %rdi
callq 0x6d52
testl %eax, %eax
jle 0x43b3
movq %r12, %r14
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r13, 0x18(%rsp)
movq 0x10(%r14), %rdi
callq 0x6d52
leal (%rax,%r12), %ecx
movzbl %bl, %r15d
andl $0x1, %r15d
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movzbl (%rax,%rbp), %eax
movl 0x14(%rsp), %r13d
shrl %cl, %r13d
andl %eax, %r13d
cmpl %r15d, %r13d
setne %bl
incq %rbp
movq 0x10(%r14), %rdi
callq 0x6d52
cltq
decl %r12d
cmpq %rax, %rbp
jl 0x432b
movq 0x18(%rsp), %rbp
movq %r14, %r12
cmpl %r15d, %r13d
je 0x43ac
movq 0x10(%r12), %rdi
movl 0x10(%rsp), %ebx
movl %ebx, %esi
callq 0x6dce
movq %rbp, %r13
movl %ebp, %ecx
notl %ecx
addl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
addl %eax, 0xc(%rsp)
jmp 0x43b3
movl 0x10(%rsp), %ebx
movq %rbp, %r13
incq %r13
movq 0x10(%r12), %rdi
movl %ebx, %esi
callq 0x6dce
cltq
cmpq %rax, %r13
jl 0x4307
jmp 0x43d7
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::BinProcessor(Chrono*, Config const*, std::complex<double>**, std::vector<int, std::allocator<int>> const&)
BinProcessor::BinProcessor(Chrono *newChrono, const Config* newConfig, ffast_complex** newObservationMatrix, const std::vector<int>& newDelays):
    Step(newChrono, newConfig), observationMatrix(newObservationMatrix), delays(newDelays)
{
    signalLength     = config->getSignalLength();
    delaysNb         = config->getDelaysNb();
    chainsNb         = config->getChainsNb();
    delaysPerBunchNb = config->getDelaysPerBunchNb();

    MLdetection         = config->needToUseMaximumLikelihoodDetection();

    signalVector    = (ffast_complex*) malloc(delaysNb * sizeof(ffast_complex));
    thresholds      = (ffast_real*) malloc(config->getBinsNb() * sizeof(ffast_real));
    directionVector = (ffast_complex*) malloc(delaysNb * sizeof(ffast_complex));
    computeThresholds();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x10e6d(%rip), %rax     # 0x158f8
movq %rax, (%rdi)
movq %rcx, 0x18(%rdi)
leaq 0x88(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %r14, %rdi
movq %r8, %rsi
callq 0x5488
movq 0x10(%rbx), %rdi
callq 0x6d62
movl %eax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6e2a
movl %eax, 0x24(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6e2e
movl %eax, 0x28(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6e32
movl %eax, 0x2c(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6d66
movb %al, 0x68(%rbx)
movslq 0x24(%rbx), %rdi
shlq $0x4, %rdi
callq 0x3320
movq %rax, 0x50(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6e1c
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3320
movq %rax, 0x78(%rbx)
movslq 0x24(%rbx), %rdi
shlq $0x4, %rdi
callq 0x3320
movq %rax, 0x80(%rbx)
movq %rbx, %rdi
callq 0x4b56
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4b4d
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
movq %r15, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::process()
void BinProcessor::process()
{
    if (MLdetection)
    {
        // MLprocess tries out all possible locations and estimates bin signal
        MLprocess();
    }
    else
    {
        computeLocation();
        estimateBinSignal();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x4ec9
movq %rbx, %rdi
popq %rbx
jmp 0x4eda
movq %rbx, %rdi
callq 0x50a2
movq %rbx, %rdi
popq %rbx
jmp 0x51be
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::computeLocation()
void BinProcessor::computeLocation()
{
    int tempLoc = 0;

    for(int q = 0; q < config->getSignalBitLength(); q++) {
        int runningSum = 0;
        for (int i = 0; i <config->getChainsNb(); i++) {
            ffast_complex Dp = observationMatrix[binAbsoluteIndex][(config->getSignalBitLength()+1)*i];
            ffast_complex Dpq = observationMatrix[binAbsoluteIndex][(config->getSignalBitLength()+1)*i+q+1];
            bool sgn1 = std::real(Dp) > 0;
            bool sgn2 = std::real(Dpq) > 0;
            bool sgn = sgn1 ^ sgn2;
            runningSum+= 2*sgn - 1;            
        }
        if (runningSum >=0)
            tempLoc += 1<<(config->getSignalBitLength() - 1- q);
    }
    location = tempLoc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6d52
xorl %ebp, %ebp
testl %eax, %eax
jle 0x51ac
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x6e2e
testl %eax, %eax
jle 0x517e
movl %ebp, 0xc(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
movslq 0x58(%rbx), %rcx
movq (%rax,%rcx,8), %r13
callq 0x6d52
incl %eax
imull %r15d, %eax
cltq
shlq $0x4, %rax
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rcx
movslq 0x58(%rbx), %rdx
movq (%rcx,%rdx,8), %rbp
movsd (%r13,%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
callq 0x6d52
incl %eax
imull %r15d, %eax
addl %r14d, %eax
cltq
shlq $0x4, %rax
xorpd %xmm0, %xmm0
cmpltpd 0x10(%rsp), %xmm0
movsd 0x10(%rbp,%rax), %xmm1
xorpd %xmm2, %xmm2
cmpltpd %xmm1, %xmm2
xorpd %xmm0, %xmm2
movd %xmm2, %eax
notl %eax
orl $0x1, %eax
addl %eax, %r12d
incl %r15d
movq 0x10(%rbx), %rdi
callq 0x6e2e
cmpl %eax, %r15d
jl 0x50e4
testl %r12d, %r12d
movl 0xc(%rsp), %ebp
js 0x5197
movq 0x10(%rbx), %rdi
callq 0x6d52
movl %r14d, %ecx
notl %ecx
addl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
addl %eax, %ebp
incl %r14d
movq 0x10(%rbx), %rdi
callq 0x6d52
cmpl %eax, %r14d
jl 0x50c9
movl %ebp, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::adjustTo(int, int, int)
void BinProcessor::adjustTo(int newBinAbsoluteIndex, int newBinRelativeIndex, int newStage)
{
    binAbsoluteIndex = newBinAbsoluteIndex;
    binRelativeIndex = newBinRelativeIndex;
    stage   = newStage;
    samplingPattern = config->getSamplingPattern(stage);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x58(%rdi)
movl %edx, 0x5c(%rdi)
movl %ecx, 0x60(%rdi)
movq 0x10(%rdi), %rdi
movl %ecx, %esi
callq 0x6d76
movl %eax, 0x64(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::isSingleton()
bool BinProcessor::isSingleton()
{
    // a singleton is not zero-ton
    if (isZeroTon())
    {
        return false;
    }
    process();
    
    // if the bin is a singleton, when we peel the frequency from the bin
    // the remaining power should be coming from noise only
    // also we need the singleton to have energy larger than a threshold (minimumEnergy)

    if (noise / delaysNb <= thresholds[stage] && config->getDelaysNb()*std::norm(amplitude) > minimumEnergy)
    {
        // The bin is a singleton
        return true;
    }

    // The bin is a 'multi-ton'
    return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5402
testb %al, %al
jne 0x53fe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movsd 0x70(%rbx), %xmm0
cvtsi2sdl 0x24(%rbx), %xmm1
divsd %xmm1, %xmm0
movq 0x78(%rbx), %rax
movslq 0x60(%rbx), %rcx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x53fe
movq 0x10(%rbx), %rdi
callq 0x6e2a
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x40(%rbx), %xmm1
movsd 0x48(%rbx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movb $0x1, %al
ucomisd 0x30(%rbx), %xmm1
ja 0x5400
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::isZeroTon() const
bool BinProcessor::isZeroTon() const
{
    ffast_real energy = 0;

    for (int delayIndex=0; delayIndex<delaysNb; delayIndex++)
    {
        energy += std::norm(observationMatrix[binAbsoluteIndex][delayIndex]);
    }
    if (energy <= thresholds[stage])
    {
        return true;
    }

    return false;
}

// Assembly:
movslq 0x24(%rdi), %rax
testq %rax, %rax
jle 0x5447
movq 0x18(%rdi), %rcx
movslq 0x58(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x4, %rax
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx), %xmm1
movsd 0x8(%rcx,%rdx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x5421
jmp 0x544b
xorpd %xmm0, %xmm0
movq 0x78(%rdi), %rax
movslq 0x60(%rdi), %rcx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/chrono.cpp
// Function: Chrono::average(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double Chrono::average(const std::string& section)
{
    if (notEmpty(section))
    {
        double sum = 0;
        unsigned int timesNb = getSectionStopTimes(section).size();

        for (unsigned int i=0; i<timesNb; i++)
        {

	    sum += getSectionTime(section, i);
        }

        return sum/timesNb;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x5d4c
leaq 0x48(%r14), %rcx
cmpq %rcx, %rax
je 0x5cbc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5cd0
movq 0x8(%rax), %r15
subq (%rax), %r15
shrq $0x3, %r15
xorpd %xmm1, %xmm1
testl %r15d, %r15d
je 0x5cab
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5bc2
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
incl %ebp
cmpl %ebp, %r15d
jne 0x5c89
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x5cc0
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/config.cpp
// Function: Config::Config(int, char**)
Config::Config(int newArgc, char** newArgv):argc(newArgc), argv(newArgv), helpDisplayed(false)
{
    bins.clear();
    setDefaultOptions();

    setOptionsFromCommandLine();

    if(distribution.size() == 0)
    {
      preprocessDistribution((char*) "1");
    }

    setBinOffsetsAndBinsSum();
    setSubsamplingMatrices();

    maxSNRdB = (maxSNRdB < SNRdB) ? SNRdB : maxSNRdB;


    chainsNb = (chainsNb >= 1) ? chainsNb : 1;
    if (!noisy)
      chainsNb = 1;

    delaysPerBunchNb = getSignalBitLength()+1;
    delaysNb = chainsNb * delaysPerBunchNb;
    


   assert( signalLength >= signalSparsity );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movb $0x0, 0x11(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rdi)
xorl %eax, %eax
movq %rax, 0x88(%rdi)
movups %xmm0, 0xb8(%rdi)
movq %rax, 0xc8(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
cmpq %rax, 0x30(%rdi)
je 0x6264
movq $0x0, 0x30(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x40(%rbx), %r15
leaq 0x78(%rbx), %r12
leaq 0xb8(%rbx), %rbp
movq %rbx, %rdi
callq 0x635c
movq %rbx, %rdi
callq 0x63e4
movq 0x80(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x62a3
leaq 0x8f49(%rip), %rsi      # 0xf1e4
movq %rbx, %rdi
callq 0x658a
movq %rbx, %rdi
callq 0x6736
movq %rbx, %rdi
callq 0x6b26
movss 0x6c(%rbx), %xmm0
maxss 0x94(%rbx), %xmm0
movss %xmm0, 0x94(%rbx)
movl 0x18(%rbx), %eax
movl 0x60(%rbx), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovll %edx, %ecx
cmpb $0x0, 0x68(%rbx)
cmovel %edx, %ecx
movl %ecx, 0x60(%rbx)
movl 0xb0(%rbx), %edx
incl %edx
movl %edx, 0x64(%rbx)
imull %ecx, %edx
movl %edx, 0x5c(%rbx)
cmpl 0x24(%rbx), %eax
jl 0x6308
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ed7(%rip), %rdi      # 0xf1e6
leaq 0x8eef(%rip), %rsi      # 0xf205
leaq 0x8ef7(%rip), %rcx      # 0xf214
movl $0x2d, %edx
callq 0x3160
movq %rax, %r13
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x6342
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3555
movq %r13, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8338
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x20, %edx
callq 0xd4ba
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x65ed
movq %rax, 0x80(%rbx)
leaq 0x78(%rbx), %r14
movq $0x0, 0x8(%rsp)
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x661e
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x662b
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x486a
movq 0x38(%rsp), %r12
subq 0x30(%rsp), %r12
movq %r12, %r13
shrq $0x5, %r13
incl %r13d
cmpl $0x2, %r13d
jl 0x66af
movl %r13d, %ebp
decq %rbp
xorl %r15d, %r15d
movq 0x78(%rbx), %rax
movsd (%rax,%r15), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax,%r15,4), %rdi
callq 0x3300
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x6699
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x80(%rbx)
jmp 0x66a6
movq %r14, %rdi
leaq 0x8(%rsp), %rdx
callq 0x486a
addq $0x8, %r15
decq %rbp
jne 0x664e
cmpl $0x2, %r13d
jl 0x66e0
movq (%r14), %rax
shlq $0x1b, %r12
sarq $0x1d, %r12
movl %r13d, %ecx
movl $0x1, %edx
movsd (%rax,%rdx,8), %xmm0
divsd (%rax,%r12), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x66c8
leaq 0x30(%rsp), %rdi
callq 0x825c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6720
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x672d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x672d
movq %rax, %rbx
jmp 0x672d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x825c
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x8182
movq %rax, 0x30(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0xd4fa
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x81a4
movq %rax, 0x30(%rbx)
movq 0x8(%rsp), %rax
cmpq %rax, 0x10(%rsp)
je 0x820c
leaq 0x28(%rbx), %r14
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x4(%rsp), %r15
shlq $0x5, %rcx
movq (%rax,%rcx), %rdi
callq 0x33e0
movl %eax, 0x4(%rsp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x81e7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x81f2
movq %r14, %rdi
movq %r15, %rdx
callq 0x8376
movl %ebp, %ecx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x81c0
leaq 0x8(%rsp), %rdi
callq 0x825c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x825c
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d1(%rip), %rsi      # 0xfc4b
leaq 0x74cf(%rip), %rdx      # 0xfc50
movq %rsp, %rdi
callq 0x44c2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5a48
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x87aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movl $0x0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d62
testl %eax, %eax
jle 0x87e5
leaq 0x50(%rbx), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e48
movl (%rsp), %ebp
incl %ebp
movl %ebp, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d62
cmpl %eax, %ebp
jl 0x87c5
movq %rbx, %rdi
callq 0x8862
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x744d(%rip), %rsi      # 0xfc4b
leaq 0x744b(%rip), %rdx      # 0xfc50
callq 0x44c2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ae4
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x882b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x883c
jmp 0x8857
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x885a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x885a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O1/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 0x712f(%rip), %rsi      # 0xfc4b
leaq 0x712d(%rip), %rdx      # 0xfc50
movq %rsp, %rdi
callq 0x44c2
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5a48
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8b4c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5488
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c12
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8b7e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x8862
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x70b4(%rip), %rsi      # 0xfc4b
leaq 0x70b2(%rip), %rdx      # 0xfc50
callq 0x44c2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ae4
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8bc4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8beb
jmp 0x8c06
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8c09
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
jmp 0x8bff
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8c09
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x8c09
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d52
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x6e1c
testl %eax, %eax
jle 0x8d77
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 0x6d76
movl %eax, %r12d
movq 0x10(%r15), %rdi
movl %ebx, 0x1c(%rsp)
movl %ebx, %esi
callq 0x6dce
movsd 0x646c(%rip), %xmm0     # 0xf0e8
movl %eax, %edi
callq 0x33c0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rdi
callq 0x6e2a
testl %eax, %eax
jle 0x8d60
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 0x8dd0
testl %r15d, %r15d
jle 0x8d28
xorl %r15d, %r15d
movl $0x0, %eax
testl %ebp, %ebp
jle 0x8d0a
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movl $0x1, %esi
shll %cl, %esi
btl %ecx, %r12d
jae 0x8d04
btl %edx, %r15d
leal 0x1(%rdx), %edx
cmovael %r14d, %esi
addl %esi, %eax
incl %ecx
cmpl %ecx, %ebp
jne 0x8cea
xorl %r13d, %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x8e48
incl %r15d
cmpl %ebx, %r15d
jne 0x8cdb
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8d3f
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq 0x10(%rsp), %r13
incq %r13
movq 0x20(%rsp), %r15
movq 0x10(%r15), %rdi
callq 0x6e2a
cltq
cmpq %rax, %r13
jl 0x8cab
movl 0x1c(%rsp), %ebx
incl %ebx
movq 0x10(%r15), %rdi
callq 0x6e1c
cmpl %eax, %ebx
jl 0x8c57
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 0x8da0
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcf78
leaq 0xc5dd(%rip), %rax      # 0x15c38
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 0x6e3a
divss 0x65ff(%rip), %xmm0     # 0xfcf4
cvtss2sd %xmm0, %xmm1
movsd 0x59af(%rip), %xmm0     # 0xf0b0
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 0x4452
movq %rbx, %rdi
callq 0x4402
movq %r14, %rdi
callq 0x4452
movq %r12, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x649c(%rip), %rsi      # 0xfc4b
leaq 0x649a(%rip), %rdx      # 0xfc50
leaq 0x8(%rsp), %rdi
callq 0x44c2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5a48
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x97e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0xa38c
movl $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d62
testl %eax, %eax
jle 0x982c
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e48
movl 0x8(%rsp), %ebp
incl %ebp
movl %ebp, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d62
cmpl %eax, %ebp
jl 0x980a
leaq 0x88(%rbx), %rdi
callq 0x4478
movq %rbx, %rdi
callq 0x9984
movq 0x68(%rbx), %r14
leaq 0x58(%rbx), %rbp
cmpq %rbp, %r14
je 0x9873
leaq 0x18(%rbx), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8f9a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x9851
movq %rbx, %rdi
callq 0x9b62
movq 0x10(%rbx), %rdi
callq 0x6e36
testb %al, %al
je 0x9890
movq %rbx, %rdi
callq 0x9c7e
movq 0x68(%rbx), %r14
cmpq %rbp, %r14
je 0x9907
leaq 0x18(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x8248
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 0x8f9a
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 0x989d
movq 0x8(%rbx), %rbx
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x6331(%rip), %rsi      # 0xfc4b
leaq 0x632f(%rip), %rdx      # 0xfc50
callq 0x44c2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ae4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x994a
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 0x995d
jmp 0x9979
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x997c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x997c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
leaq 0x50(%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, 0x10(%rsp)
callq 0x4478
leaq 0x30(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0xc(%rsp), %r13
movq 0x70(%rsp), %r14
movq 0x10(%rbx), %rdi
callq 0x6d6a
cmpl %r14d, %eax
jle 0x9a72
movq 0x10(%rbx), %rdi
callq 0x8248
movl %eax, %ebp
callq 0x3230
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x8236
movsd (%rsp), %xmm0
movq %r15, %rsi
callq 0xa1ba
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x8248
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 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9a5e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movl %ebp, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8e48
jmp 0x99d2
movq 0x60(%rsp), %r15
leaq 0x50(%rsp), %r14
cmpq %r14, %r15
movq 0x10(%rsp), %r12
je 0x9b13
movq %rbx, %rdi
callq 0xa224
movaps %xmm0, %xmm1
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x28(%rsp)
movaps %xmm1, %xmm0
movsd %xmm1, (%rsp)
callq 0x34e0
movsd %xmm0, 0x18(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x3060
movsd %xmm0, (%rsp)
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x8f9a
movsd 0x20(%rsp), %xmm1
mulsd (%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movq %r15, %rdi
callq 0x32c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x9a8a
leaq 0x48(%rsp), %rdi
callq 0x4402
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9b4f
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
jmp 0x9b4f
jmp 0x9b4c
jmp 0x9b4c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4402
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
movsd 0xc0(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x68(%rdi), %r14
leaq 0x58(%rdi), %r12
cmpq %r12, %r14
je 0x9db1
leaq 0x18(%rbx), %r15
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3230
callq 0x31d0
mulsd 0x602d(%rip), %xmm0     # 0xfcf8
movsd %xmm0, 0x10(%rsp)
callq 0x3230
movsd 0x10(%rsp), %xmm3
movapd %xmm0, %xmm2
mulsd 0x6018(%rip), %xmm2     # 0xfd00
movsd 0xd0(%rbx), %xmm1
ucomisd 0x6018(%rip), %xmm3     # 0xfd10
movsd %xmm2, 0x20(%rsp)
jb 0x9d09
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x9d28
movapd %xmm3, %xmm0
movsd %xmm1, (%rsp)
callq 0x31c0
movsd 0x10(%rsp), %xmm3
movsd 0x20(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rsp)
divsd 0x5fc4(%rip), %xmm1     # 0xfd08
movsd %xmm1, (%rsp)
movapd %xmm2, %xmm0
callq 0x34e0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x3060
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x8f9a
movsd 0x10(%rsp), %xmm0
addsd (%rax), %xmm0
movsd (%rsp), %xmm1
addsd 0x8(%rax), %xmm1
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
cmpq %r12, %rax
jne 0x9cb9
jmp 0x9dbb
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rdi
callq 0x6d62
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x18(%rsp), %xmm0
divsd (%rsp), %xmm0
movsd %xmm0, 0xc8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e11(%rip), %rsi      # 0xfc4b
leaq 0x5e0f(%rip), %rdx      # 0xfc50
movq %rsp, %rdi
callq 0x44c2
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5a48
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9e6a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5488
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9fca
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9e9c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x9984
movq %rbx, %rdi
callq 0x9b62
movq 0x10(%rbx), %rdi
callq 0x6e36
testb %al, %al
je 0x9ec1
movq %rbx, %rdi
callq 0x9c7e
movq 0x68(%rbx), %r14
leaq 0x58(%rbx), %rbp
cmpq %rbp, %r14
je 0x9f3c
leaq 0x18(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x8248
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 0x8f9a
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 0x9ed2
movq 0x8(%rbx), %rbx
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x5cfe(%rip), %rsi      # 0xfc4b
leaq 0x5cfc(%rip), %rdx      # 0xfc50
callq 0x44c2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ae4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9f7a
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 0x9fa4
jmp 0x9fbf
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9fc2
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
jmp 0x9fb8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9fc2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x9fc2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e4a
testl %eax, %eax
jle 0xa271
movq 0x10(%rbx), %rdi
callq 0x6e4a
xorpd %xmm0, %xmm0
cmpl $0x1, %eax
je 0xa2de
movq 0x10(%rbx), %rdi
callq 0x6e4a
cmpl $0x2, %eax
jne 0xa280
callq 0x3230
callq 0x30e0
mulsd 0x5aa9(%rip), %xmm0     # 0xfd18
jmp 0xa2de
callq 0x3230
mulsd 0x5a82(%rip), %xmm0     # 0xfd00
jmp 0xa2de
movq 0x10(%rbx), %rdi
callq 0x6e4a
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3230
mulsd 0x8(%rsp), %xmm0
callq 0x3460
addsd %xmm0, %xmm0
addsd 0x4e36(%rip), %xmm0     # 0xf0e8
mulsd 0x5a5e(%rip), %xmm0     # 0xfd18
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6e4a
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_O1/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 0x42a8
movq 0x10(%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x42a8
testq %r14, %r14
je 0xa859
movq 0x20(%rbx), %rdi
callq 0xa186
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4552
testq %rax, %rax
jne 0xa854
incl 0x38(%rbx)
movq (%r14), %r14
jmp 0xa829
movl 0x38(%rbx), %eax
movl %eax, 0x4(%rsp)
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0xa876
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x60(%rbx)
jmp 0xa887
addq $0x58, %rbx
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xbabe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UCBASiCS[P]SPRIGHT/src/experimentoutput.cpp
// Function: ExperimentOutput::checkFullRecovery()
void ExperimentOutput::checkFullRecovery()
{
    if (falseDetectionsIterationNb == 0 && missedLocationsIterationNb == 0 && binningFailure == false)
    {
       fullRecovery = true;
       fullRecoveriesNb++;
   }
   else
   {
    fullRecovery = false;
}
}

// Assembly:
cmpl $0x0, 0x38(%rdi)
jne 0xaa8d
cmpl $0x0, 0x3c(%rdi)
jne 0xaa8d
cmpb $0x0, 0x40(%rdi)
jne 0xaa8d
movb $0x1, 0x50(%rdi)
incl 0xf8(%rdi)
retq
movb $0x0, 0x50(%rdi)
retq