LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/hybrid.cpp
// Function: hybrid::hybrid(long long, long long, long long, long long, btb*)
hybrid :: hybrid(ll bimodal_index_bits, ll ghr_index_bits, ll ghr_bits, ll chooser_table_index_bits, btb * branch_buffer)
{
	predictions = mispredictions = true_predictions = 0;
	index_mask = mask(chooser_table_index_bits + 2);				// 4-Byte instruction. Hence lowest 2 bits are always 0 for address. Hence ignored
	sets = (ll)pow(2.0, chooser_table_index_bits);
	for(ll i = 0; i<sets; i++)
		chooser_table.push_back(1);						// Initialize to choose GShare Prediction

	this->branch_buffer = branch_buffer;
	
	b = new bimodal(bimodal_index_bits, NULL);
	g = new gshare(ghr_index_bits, ghr_bits, NULL); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
leaq 0x2(%r8), %rsi
callq 0x410c
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movq %rax, 0x18(%r14)
cvtsi2sd %r15, %xmm0
callq 0x2160
cvttsd2si %xmm0, %rax
movq %rax, 0x38(%r14)
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
cmpq %rax, %r12
jge 0x41ad
movl $0x1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39e2
incq %r12
movq 0x38(%r14), %rax
jmp 0x418c
movq %rbp, 0x60(%r14)
pushq $0x60
popq %rdi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x352a
movq %r15, 0x68(%r14)
movl $0x88, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3b92
movq %r15, 0x70(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x88, %esi
jmp 0x4211
movq %rax, %r14
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x21a0
jmp 0x4220
jmp 0x421d
movq %rax, %r14
movq %rbx, %rdi
callq 0x39ae
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/hybrid.cpp
// Function: hybrid::update_chooser_table(long long, int, char)
void hybrid :: update_chooser_table(ll address, int chooser_table_prediction, char actual_branch)
{
	//ll index = calc_Index(address);

	if(actual_branch == 't')
	{
		if(gshare_prediction == 1 && bimodal_prediction == 0)
		{
			if(chooser_table.at(chooser_table_index) < 3)
				chooser_table.at(chooser_table_index) = chooser_table.at(chooser_table_index) + 1;
		}
		else if(bimodal_prediction == 1 && gshare_prediction == 0)
		{
			if(chooser_table.at(chooser_table_index) > 0)
				chooser_table.at(chooser_table_index) = chooser_table.at(chooser_table_index) - 1;

		}
		if(chooser_table_prediction == 0)
			mispredictions++;
		else
			true_predictions++;
	}		
	else if(actual_branch == 'n')
	{	
		if(gshare_prediction == 0 && bimodal_prediction == 1)
		{
			if(chooser_table.at(chooser_table_index) < 3)
				chooser_table.at(chooser_table_index) = chooser_table.at(chooser_table_index) + 1;
		}
		else if(bimodal_prediction == 0 && gshare_prediction == 1)
		{
			if(chooser_table.at(chooser_table_index) > 0)
				chooser_table.at(chooser_table_index) = chooser_table.at(chooser_table_index) - 1;

		}	

		if(chooser_table_prediction == 1)
			mispredictions++;
		else
			true_predictions++;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x6e, %ecx
je 0x42a5
cmpl $0x74, %ecx
jne 0x4353
movl 0x28(%rbx), %eax
movl 0x2c(%rbx), %ecx
movl %ecx, %edx
xorl $0x1, %edx
orl %eax, %edx
jne 0x42d6
leaq 0x40(%rbx), %r14
movslq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3982
xorl %r15d, %r15d
cmpl $0x3, (%rax)
jge 0x4346
leaq 0x20(%rbx), %r13
pushq $0x1
jmp 0x431b
movl 0x28(%rbx), %eax
movl 0x2c(%rbx), %ecx
movl %eax, %edx
xorl $0x1, %edx
orl %ecx, %edx
jne 0x42f5
leaq 0x40(%rbx), %r14
movslq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3982
pushq $0x1
popq %r12
cmpl $0x3, (%rax)
jge 0x433d
leaq 0x20(%rbx), %r13
movl %r12d, %r15d
jmp 0x431d
xorl $0x1, %eax
xorl %r15d, %r15d
orl %eax, %ecx
jne 0x4346
leaq 0x40(%rbx), %r14
movslq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3982
xorl %r15d, %r15d
jmp 0x4310
xorl $0x1, %ecx
orl %eax, %ecx
jne 0x4342
leaq 0x40(%rbx), %r14
movslq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3982
pushq $0x1
popq %r15
cmpl $0x0, (%rax)
jle 0x4346
leaq 0x20(%rbx), %r13
pushq $-0x1
popq %r12
movslq (%r13), %rsi
movq %r14, %rdi
callq 0x3982
addl (%rax), %r12d
movslq (%r13), %rsi
movq %r14, %rdi
callq 0x3982
movl %r12d, (%rax)
jmp 0x4346
movl %r12d, %r15d
jmp 0x4346
pushq $0x1
popq %r15
xorl %eax, %eax
cmpl %ebp, %r15d
setne %al
incq 0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/hybrid.cpp
// Function: hybrid::access(long long, char)
void hybrid :: access(ll address, char actual_branch)
{
	predictions++;
	this->choosen_predictor = predict(address, actual_branch);
	this->bimodal_prediction = b->predict(address, actual_branch);
	this->gshare_prediction = g->predict(address, actual_branch);
	if(choosen_predictor == 1)
	{
		g->update_prediction_table(address, gshare_prediction, actual_branch);	
		update_chooser_table(address, gshare_prediction, actual_branch);
	}
	else
	{
		update_chooser_table(address, bimodal_prediction, actual_branch);
		b->update_prediction_table(address, bimodal_prediction, actual_branch);
		g->update_ghr_register(actual_branch);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
incq (%rdi)
xorl %edx, %edx
callq 0x4230
movl %eax, 0x24(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x35c8
movl %eax, 0x28(%rbx)
movq 0x70(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3c3e
movl %eax, 0x2c(%rbx)
cmpl $0x1, 0x24(%rbx)
jne 0x43c8
movq 0x70(%rbx), %rdi
movsbl %bpl, %ebp
movq %r14, %rsi
movl %eax, %edx
movl %ebp, %ecx
callq 0x3c7c
movl 0x2c(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x4254
movl 0x28(%rbx), %edx
movsbl %bpl, %ebp
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x4254
movq 0x68(%rbx), %rdi
movl 0x28(%rbx), %edx
movq %r14, %rsi
movl %ebp, %ecx
callq 0x35e6
movq 0x70(%rbx), %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d2a
nop
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/hybrid.cpp
// Function: hybrid::display_table()
void hybrid :: display_table()
{
	if(branch_buffer != NULL)
		branch_buffer->display();
	
	b->display_table();
	g->display_table();

	cout << endl << "Final Chooser Table Contents:" << endl;
	for(it = chooser_table.begin(); it != chooser_table.end(); it++)
	{
		int index = distance(chooser_table.begin(), it); 
		cout << "Choice table[" << index << "]: " << chooser_table.at(index) << endl;	
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x4416
callq 0x322a
movq 0x68(%rbx), %rdi
callq 0x36aa
movq 0x70(%rbx), %rdi
callq 0x3d8c
movq 0x3ba9(%rip), %rdi      # 0x7fd8
callq 0x20d0
leaq 0xe8f(%rip), %rsi       # 0x52ca
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x40(%rbx), %r15
movq 0x40(%rbx), %rbp
leaq 0xe8e(%rip), %r12       # 0x52e8
leaq 0xcd9(%rip), %r13       # 0x513a
movq %rbp, 0x58(%rbx)
cmpq 0x48(%rbx), %rbp
je 0x44c1
subq 0x40(%rbx), %rbp
shrq $0x2, %rbp
movq 0x3b5e(%rip), %rdi      # 0x7fd8
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
movl %ebp, %esi
callq 0x2260
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %r14
movslq %ebp, %rsi
movq %r15, %rdi
callq 0x3982
movl (%rax), %esi
movq %r14, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x20d0
movq 0x58(%rbx), %rbp
addq $0x4, %rbp
jmp 0x4461
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/yehpatt.cpp
// Function: yehpatt::yehpatt(long long, long long, btb*)
yehpatt :: yehpatt(ll history_index_bits, ll predictor_index_bits, btb * branch_buffer)
{
	predictions = mispredictions = true_predictions = 0;
	this->history_index_bits = history_index_bits;
	this->predictor_index_bits = predictor_index_bits;

	index_mask = mask(history_index_bits + 2);				// 4-Byte instruction. Hence lowest 2 bits are always 0 for address. Hence ignored
	sets = (ll)pow(2.0, predictor_index_bits);
	for(ll i = 0; i<sets; i++)
		predictor_table.push_back(2);				// Initialize 'Weakly Taken' i.e 2

	history_sets = pow(2.0, history_index_bits);
	for(ll i = 0; i<history_sets; i++)
		history_table.push_back(0);
	
	this->branch_buffer = branch_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x58(%rdi), %rbx
leaq 0x70(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
andq $0x0, 0x88(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
addq $0x2, %rsi
callq 0x46e4
movq %rax, 0x18(%r12)
cvtsi2sd %rbp, %xmm0
callq 0x2160
cvttsd2si %xmm0, %rax
movq %rax, 0x48(%r12)
xorl %r15d, %r15d
leaq 0xc(%rsp), %rbp
cmpq %rax, %r15
jge 0x4795
movl $0x2, 0xc(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x39e2
incq %r15
movq 0x48(%r12), %rax
jmp 0x4773
cvtsi2sd %r13, %xmm0
callq 0x2160
cvttsd2si %xmm0, %rax
movq %rax, 0x50(%r12)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
cmpq %rax, %rbp
jge 0x47cf
andl $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x39e2
incq %rbp
movq 0x50(%r12), %rax
jmp 0x47b0
movq 0x10(%rsp), %rax
movq %rax, 0x90(%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47ed
movq %rax, %r15
movq %r14, %rdi
callq 0x39ae
movq %rbx, %rdi
callq 0x39ae
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/yehpatt.cpp
// Function: yehpatt::predict(long long, char)
int yehpatt :: predict(ll address, char actual_branch)
{	
	this->history_table_index = calc_Index(address);
	this->predictor_table_index = history_table.at(history_table_index);

	if(predictor_table.at(predictor_table_index) >= 2)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq 0x18(%rdi), %rsi
sarq $0x2, %rsi
movl %esi, 0x38(%rdi)
addq $0x70, %rdi
movslq %esi, %rsi
callq 0x3982
movslq (%rax), %rsi
movl %esi, 0x34(%rbx)
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x3982
xorl %ecx, %ecx
cmpl $0x2, (%rax)
setge %cl
movl %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chinmayachaudhry[P]Branch-Predictor/yehpatt.cpp
// Function: yehpatt::update(int, char)
void yehpatt :: update(int predicted_branch, char actual_branch)
{
//	ll index = calc_Index(address);
	history_table.at(history_table_index) = history_table.at(history_table_index) >> 1;
	if(actual_branch == 't')
	{
		if(predictor_table.at(predictor_table_index) < 3)
			predictor_table.at(predictor_table_index) = predictor_table.at(predictor_table_index) + 1;
		if(predicted_branch == 0)
			mispredictions++;
		else
			true_predictions++;
		history_table.at(history_table_index) |= (1U << (predictor_index_bits -1));
	}		
	else if(actual_branch == 'n')
	{	
		if(predictor_table.at(predictor_table_index) > 0)
			predictor_table.at(predictor_table_index) = predictor_table.at(predictor_table_index) - 1;
		if(predicted_branch == 1)
			mispredictions++;
		else
			true_predictions++;
		history_table.at(history_table_index) &= ~(1U << (predictor_index_bits -1));
	}


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x70(%rdi), %rbx
movslq 0x38(%rdi), %rsi
movq %rbx, %rdi
callq 0x3982
movl (%rax), %r12d
sarl %r12d
movslq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3982
movl %r12d, (%rax)
cmpl $0x6e, %r15d
je 0x48e4
cmpl $0x74, %r15d
jne 0x4940
leaq 0x58(%r14), %r15
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
cmpl $0x2, (%rax)
jg 0x48bd
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
movl (%rax), %r12d
incl %r12d
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
movl %r12d, (%rax)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
incq 0x8(%r14,%rax,8)
movb 0x28(%r14), %cl
decb %cl
pushq $0x1
popq %rbp
shll %cl, %ebp
movslq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3982
orl %ebp, (%rax)
jmp 0x4940
leaq 0x58(%r14), %r15
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
cmpl $0x0, (%rax)
jle 0x491a
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
movl (%rax), %r12d
decl %r12d
movslq 0x34(%r14), %rsi
movq %r15, %rdi
callq 0x3982
movl %r12d, (%rax)
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
incq 0x8(%r14,%rax,8)
movb 0x28(%r14), %cl
decb %cl
pushq $-0x2
popq %rbp
roll %cl, %ebp
movslq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3982
andl %ebp, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/gObject.cpp
// Function: GObject::destructAsSender()
void GObject::destructAsSender()
{
    list<GObject*>::iterator it = m_priv->receiverLstInSender.begin();
    while(it != m_priv->receiverLstInSender.end() )
    {
        GObject* receiver = *it;
        receiver->m_priv->spLstInReceiver.remove_if( Sender_Is(this) );
        ++it;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %r14
movq (%r14), %r14
addq $0x40, %rax
cmpq %rax, %r14
je 0x1317
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x17c6
movq 0x8(%rbx), %rax
jmp 0x12f1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/gObject.cpp
// Function: GObject::destructAsReceiver()
void GObject::destructAsReceiver()
{
    list<SenderPair >::iterator it = m_priv->spLstInReceiver.begin();
    while(it != m_priv->spLstInReceiver.end() )
    {
        it->signal->remove_if( Receiver_Is(this) );
        it->sender->m_priv->receiverLstInSender.remove_if( Receiver_Is(this) );
        ++it;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %r14
movq (%r14), %r14
addq $0x28, %rax
cmpq %rax, %r14
je 0x1361
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x1712
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x176c
movq 0x8(%rbx), %rax
jmp 0x132f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/gObject.cpp
// Function: GObject::privConnect(GObject*, std::__cxx11::list<Slot<void*>, std::allocator<Slot<void*>>>*, GObject*, void*)
int GObject::privConnect(GObject* sender, SIGNAL_POINTER(void*) signal, GObject* receiver, void* slot)
{
    if ( sender == 0 || receiver == 0 || signal == 0 || slot == 0 )
    {
        WARNING ( "can not connect %s::%p to %s::%p\n",
                  sender ? sender->name() : "(null)",
                  signal,
                  receiver ? receiver->name() : "(null)",
                  slot );
        return -1;
    }

    Slot<void*>  vslot(receiver, (void*)slot);
    SIGNAL_TYPE_ITERATOR(void*)  it = std::find(signal->begin(), signal->end(), vslot );
    if(it != signal->end() )
    {
        return 0;
    }

    signal->push_back( vslot );

    sender->saveReceiver(receiver);
    
    receiver->saveSenderPair( sender, signal );

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r8
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x1437
testq %r14, %r14
je 0x1437
testq %rbx, %rbx
je 0x1437
testq %r8, %r8
je 0x1437
movq %rsp, %rdx
movq %r14, (%rdx)
movq %r8, 0x8(%rdx)
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x1aee
cmpq %rbx, %rax
jne 0x1433
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1706
movq %r15, %rdi
movq %r14, %rsi
callq 0x1484
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1380
xorl %eax, %eax
jmp 0x146f
leaq 0x1be8(%rip), %rcx      # 0x3026
movq %rcx, %rsi
testq %r15, %r15
je 0x144e
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
testq %r14, %r14
je 0x145b
movq 0x8(%r14), %rax
movq 0x8(%rax), %rcx
leaq 0x1ba2(%rip), %rdi      # 0x3004
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/gObject.cpp
// Function: GObject::deleteReceiver(GObject*)
void GObject::deleteReceiver(GObject *receiver)
{
    list<GObject*>::iterator it = std::find(m_priv->receiverLstInSender.begin(), m_priv->receiverLstInSender.end(), receiver );
    if(it == m_priv->receiverLstInSender.end() )
    {
        return ;
    }

    m_priv->receiverLstInSender.erase(it);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rsi
movq 0x40(%rsi), %rdi
addq $0x40, %rsi
callq 0x1d25
movq 0x8(%rbx), %rdi
addq $0x40, %rdi
cmpq %rdi, %rax
je 0x14d4
movq %rax, %rsi
callq 0x182c
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/gObject.cpp
// Function: GObject::privDisconnect(GObject*, std::__cxx11::list<Slot<void*>, std::allocator<Slot<void*>>>*, GObject*, void*)
int GObject::privDisconnect(GObject* sender, SIGNAL_POINTER(void*) signal, GObject* receiver, void* slot)
{
    if ( sender == 0 || receiver == 0 || signal == 0 || slot == 0 )
    {
        WARNING ( "can not disconnect sender %s::%p from receiver %s::%p\n",
                  sender ? sender->name() : "(null)",
                  signal,
                  receiver ? receiver->name() : "(null)",
                  slot );
        return -1;
    }
    
    Slot<void*>  vslot(receiver, (void*)slot);
    SIGNAL_TYPE_ITERATOR(void*)  it = std::find(signal->begin(), signal->end(), vslot );
    if(it == signal->end() )
    {
        return 0;
    }

    signal->remove( vslot );

    sender->deleteReceiver(receiver);
    
    receiver->deleteSenderPair( sender, signal );

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r8
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x1545
testq %r14, %r14
je 0x1545
testq %rbx, %rbx
je 0x1545
testq %r8, %r8
je 0x1545
movq %rsp, %rdx
movq %r14, (%rdx)
movq %r8, 0x8(%rdx)
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x1aee
cmpq %rbx, %rax
je 0x1541
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x183a
movq %r15, %rdi
movq %r14, %rsi
callq 0x149e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13a6
xorl %eax, %eax
jmp 0x157d
leaq 0x1ada(%rip), %rcx      # 0x3026
movq %rcx, %rsi
testq %r15, %r15
je 0x155c
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
testq %r14, %r14
je 0x1569
movq 0x8(%r14), %rax
movq 0x8(%rax), %rcx
leaq 0x1abd(%rip), %rdi      # 0x302d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trigrass2[P]giveda_gobject_ansi_cpp/main.cpp
// Function: main
int main(int argc, char** argv)
{
    Sender* s = new Sender;
    s->sendMsg();
    printf("before connect\n");
    
    Receiver *r = new Receiver;
    GObject::connect(s, s->onClick(), r, Receiver::slotOnClick);
    GObject::connect(s, s->notify(), r, Receiver::slotOnNotify);
    printf("after connect\n");
    s->sendMsg();
    
    GObject::disconnect(s, s->onClick(), r, Receiver::slotOnClick);
    GObject::disconnect(s, s->notify(), r, Receiver::slotOnNotify);
    printf("after disconnect\n");
    s->sendMsg();
    
    GObject::connect(s, s->onClick(), r, Receiver::slotOnClick);
    GObject::connect(s, s->notify(), r, Receiver::slotOnNotify);
    delete r;
    printf("connect again, and delete receiver\n");
    s->sendMsg();
    
    delete s;
    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x40
popq %rdi
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1e9c
movq %rbx, %rdi
callq 0x1ed8
leaq 0x1358(%rip), %rdi      # 0x30dd
callq 0x1100
pushq $0x10
popq %rdi
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x1f20
leaq 0x10(%rbx), %r15
leaq 0x192(%rip), %r12       # 0x1f3a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x13cc
movq %rbx, %r13
addq $0x28, %r13
leaq 0x17f(%rip), %rbp       # 0x1f46
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x13cc
leaq 0x130d(%rip), %rdi      # 0x30ec
callq 0x1100
movq %rbx, %rdi
callq 0x1ed8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x14da
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x14da
leaq 0x12e5(%rip), %rdi      # 0x30fa
callq 0x1100
movq %rbx, %rdi
callq 0x1ed8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x13cc
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x13cc
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x12b7(%rip), %rdi      # 0x310b
callq 0x1100
movq %rbx, %rdi
callq 0x1ed8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r14, %rdi
jmp 0x1e8f
movq %rax, %r15
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x10f0
movq %r15, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/threads/part2/Exception.cpp
// Function: main
int main(){
    ConcurrentCounter counter;

    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([&](){
            for(int i = 0; i < 100; ++i){
                counter.increment();
            }
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << counter.counter.value << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x10(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x30(%rsp), %rax
andq $0x0, 0x10(%rbx)
vmovups %ymm0, 0xc(%rax)
vmovups %ymm0, (%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rbx)
pushq $0x5
popq %rbp
pushq $0x10
popq %r14
leaq 0x2acc(%rip), %r13      # 0x3d88
leaq 0x8(%rsp), %r15
movq %rsp, %r12
subl $0x1, %ebp
jb 0x131b
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
vzeroupper
callq 0x10f0
leaq 0x30(%rsp), %rcx
movq %r13, (%rax)
movq %rax, (%rsp)
movq %rcx, 0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1306
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1478
movq %r15, %rdi
callq 0x13e0
jmp 0x12c4
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x133b
movq %rbx, %rdi
vzeroupper
callq 0x1120
addq $0x8, %rbx
jmp 0x1325
movl 0x58(%rsp), %esi
movq 0x2c92(%rip), %rdi      # 0x3fd8
vzeroupper
callq 0x1130
movq %rax, %rdi
callq 0x1070
leaq 0x10(%rsp), %rdi
callq 0x13ee
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1375
jmp 0x1375
movq %rax, %rbx
jmp 0x139b
movq (%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x139b
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x139b
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x13e0
leaq 0x10(%rsp), %rdi
callq 0x13ee
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/burakbugrul[P]NginxLogParser/main.cpp
// Function: main
int main(int argc, char **argv){
	
	ios::sync_with_stdio(false); // For speed boost
	
	if( argc == 3 ){
		NginxParser parser(argv[1],argv[2]);
		parser.parse();
		parser.statistics();
	}
	else{
		
		string input_file, output_file;
		
		cerr << "Please enter path of the log file: ";
		cin >> input_file;
		cerr << "Please enter path of the output file: ";
		cin >> output_file;
		
		NginxParser parser(input_file,output_file);
		parser.parse();
		parser.statistics();
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x20b0
cmpl $0x3, %ebp
jne 0x2499
movq 0x8(%rbx), %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2090
movq 0x10(%rbx), %rsi
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2090
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x27d4
leaq 0x88(%rsp), %rdi
callq 0x20e0
leaq 0xa8(%rsp), %rdi
callq 0x20e0
leaq 0xc8(%rsp), %rdi
callq 0x2942
leaq 0xc8(%rsp), %rdi
callq 0x2f94
leaq 0xc8(%rsp), %rdi
callq 0x261a
jmp 0x2587
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movq 0x4b2e(%rip), %rdi      # 0x6ff0
leaq 0x1b3b(%rip), %rsi      # 0x4004
callq 0x2170
movq 0x4b03(%rip), %rdi      # 0x6fd8
leaq 0x28(%rsp), %rsi
callq 0x21b0
movq 0x4b0a(%rip), %rdi      # 0x6ff0
leaq 0x1b3b(%rip), %rsi      # 0x4028
callq 0x2170
movq 0x4adf(%rip), %rdi      # 0x6fd8
leaq 0x8(%rsp), %rsi
callq 0x21b0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21d0
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21d0
leaq 0xc8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x27d4
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x68(%rsp), %rdi
callq 0x20e0
leaq 0xc8(%rsp), %rdi
callq 0x2942
leaq 0xc8(%rsp), %rdi
callq 0x2f94
leaq 0xc8(%rsp), %rdi
callq 0x261a
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20e0
jmp 0x25a5
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20e0
jmp 0x25fe
jmp 0x25fb
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20e0
jmp 0x25c8
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
jmp 0x260d
movq %rax, %rbx
jmp 0x2612
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x261a
jmp 0x25fe
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x261a
jmp 0x2612
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/burakbugrul[P]NginxLogParser/NginxParser.cpp
// Function: NginxParser::findIP[abi:cxx11](char*)
inline string NginxParser::findIP(char *line){
	
	int number=0;
	int point_count = 0;
	string result;
	
	for( int i=0 ; line[i] != ' ' && line[i] != '-' && line[i] != '\0' ; i++ ){
		
		if( isdigit(line[i]) )
			number = number*10 + (line[i]-'0');
		else if( number > 255 )
			return "-1";
		else if( line[i] == '.' ){
			number = 0;
			point_count++;
		}
		else
			return "-1";
		
		result += line[i];
	}
	
	if( point_count == 3 )
		return result;
	return "-1";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movabsq $0x200100000001, %r13   # imm = 0x200100000001
xorl %ebp, %ebp
movzbl (%r14), %eax
cmpq $0x2d, %rax
ja 0x349b
btq %rax, %r13
jb 0x34d4
movsbl %al, %esi
leal -0x30(%rsi), %ecx
cmpl $0x9, %ecx
ja 0x34b1
imull $0xa, %r12d, %eax
addl %eax, %ecx
movl %ecx, %r12d
jmp 0x34c7
cmpl $0x100, %r12d           # imm = 0x100
jge 0x3534
cmpb $0x2e, %al
jne 0x354a
incl %ebp
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x2140
incq %r14
jmp 0x348b
cmpl $0x3, %ebp
jne 0x34fd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x3513
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x3519
leaq 0xb5c(%rip), %rsi       # 0x4060
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
jmp 0x355e
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
jmp 0x355e
leaq 0xb25(%rip), %rsi       # 0x4060
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
jmp 0x355e
leaq 0xb0f(%rip), %rsi       # 0x4060
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3580
jmp 0x3580
jmp 0x3580
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/burakbugrul[P]NginxLogParser/NginxParser.cpp
// Function: NginxParser::characterCount(char*, int, char)
inline int NginxParser::characterCount(char *line, int length, char character){
	
	int result = 0;
	
	for( int i=0 ; i<length ; i++ )
		result += (line[i] == character);
	
	return result;
}

// Assembly:
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
xorl %eax, %eax
cmpq %rdi, %rdx
je 0x35b6
xorl %r8d, %r8d
cmpb %cl, (%rsi,%rdi)
sete %r8b
addl %r8d, %eax
incq %rdi
jmp 0x359f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/burakbugrul[P]NginxLogParser/NginxParser.cpp
// Function: NginxParser::findCharacter(char*, int, int, char)
inline int NginxParser::findCharacter(char *line, int begin, int length, char character){
	
	for( int i=begin ; i<length ; i++ )
		if( line[i] == character )
			return i;
	
	return length;
}

// Assembly:
movl %ecx, %eax
movslq %edx, %rdx
movslq %ecx, %rdi
cmpl %edx, %edi
movl %edx, %ecx
cmovgl %eax, %ecx
cmpq %rdi, %rdx
jge 0x35d9
cmpb %r8b, (%rsi,%rdx)
je 0x35d7
incq %rdx
jmp 0x35c7
movl %edx, %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/sharpen.cpp
// Function: main
int main(int argc, char** argv) {

    int sz, fctr;
    imageP I1, I2, tmp_img, final_img; 
    
    cout << "in   : " << argv[1] << endl;
    cout << "sz   : " << argv[2] << endl;
    cout << "fctr : " << argv[3] << endl;
    cout << "out  : " << argv[4] << endl;


    I1 = IP_readImage(argv[1]);
    sz = atoi(argv[2]);
    fctr = atoi(argv[3]);

    I2 = NEWIMAGE;
    tmp_img = NEWIMAGE;
    final_img = NEWIMAGE;

    if ((sz & 1) == 0) {
        cerr << "sz: " << sz << "is not odd" << endl;
        exit(1);
    }


    blur(I1, tmp_img, sz, sz, I2);

    IP_freeImage(tmp_img);

    sharpen(I1, I2, fctr, final_img);

    IP_freeImage(I1);
    IP_freeImage(I2);

    IP_saveImage(final_img, argv[4]);
    IP_freeImage(final_img);

    cout << "done!" << endl;
    
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2cff(%rip), %r14      # 0x3fd0
leaq 0xd2c(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1090
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd11(%rip), %rsi       # 0x200c
movq %r14, %rdi
callq 0x1090
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xcf6(%rip), %rsi       # 0x2014
movq %r14, %rdi
callq 0x1090
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xcdb(%rip), %rsi       # 0x201c
movq %r14, %rdi
callq 0x1090
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq 0x8(%rbx), %rdi
callq 0x185c
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x1130
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0x1130
movl %eax, 0x4(%rsp)
pushq $0x10
popq %r12
movq %r12, %rdi
callq 0x10f0
movq %rax, %r15
movq %r12, %rdi
callq 0x10f0
movq %rax, %r13
movq %r12, %rdi
callq 0x10f0
testb $0x1, %bpl
je 0x142d
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
movl %ebp, %ecx
movq %r15, %r8
callq 0x1469
movq %r13, %rdi
callq 0x1b27
movq %r14, %rdi
movq %r15, %rsi
movl 0x4(%rsp), %edx
movq %r12, %rcx
callq 0x175a
movq %r14, %rdi
callq 0x1b27
movq %r15, %rdi
callq 0x1b27
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x1a26
movq %r12, %rdi
callq 0x1b27
movq 0x2bc9(%rip), %rdi      # 0x3fd0
leaq 0xc26(%rip), %rsi       # 0x2034
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2bbc(%rip), %rdi      # 0x3ff0
leaq 0xbe9(%rip), %rsi       # 0x2024
callq 0x1090
movq %rax, %rdi
movl %ebp, %esi
callq 0x1140
leaq 0xbd8(%rip), %rsi       # 0x2029
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/sharpen.cpp
// Function: sharpen(imageS*, imageS*, int, imageS*)
void sharpen(imageP I1, imageP I2, int fctr, imageP final_img) {
    /* I2 will be blurred image.
     * I1 will be the un-altered input image.
     * final will be final output image.
     */

    int i, total;
    unsigned char *original, *blurred, *fin_img;

    total = I1->width * I1->height;
    
    final_img->width = I1->width;
    final_img->height = I1->height;

    final_img->image = (unsigned char *) malloc(total);

    fin_img = final_img->image;
    original = I1->image;
    blurred = I2->image;

    if (final_img->image == NULL) {
        cerr << "not enough memory\n" << endl;
    }

    int w = I1->width;
    int h = I1->height;

    unsigned char difference[total];
    
    // subtract blurred image from original image to get difference.
    for (i=0; i<total; i++) {
        difference[i] = clip(fctr * (original[i] - blurred[i]));
    }

    for (i=0; i<total; i++) {
        fin_img[i] = clip(original[i] + difference[i]);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq %rdi, %r13
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
movl %eax, (%r15)
movl %ecx, 0x4(%r15)
movl %ecx, %r12d
imull %eax, %r12d
movslq %r12d, %rdi
callq 0x10f0
movq %rax, %rbx
movq %rax, 0x8(%r15)
movq 0x8(%r13), %r15
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r13
testq %rbx, %rbx
jne 0x17c3
movq 0x2841(%rip), %rdi      # 0x3ff0
leaq 0x884(%rip), %rsi       # 0x203a
callq 0x1090
movq %rax, %rdi
callq 0x1060
movl %r12d, %ecx
movq %rsp, %rax
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %rax
movq %rax, %rsp
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
xorl %edx, %edx
cmpq %rdx, %r12
je 0x1814
movzbl (%r15,%rdx), %esi
movzbl (%r13,%rdx), %edi
subl %edi, %esi
imull %r14d, %esi
testl %esi, %esi
cmovlel %ecx, %esi
movl $0xff, %edi
cmpl %edi, %esi
jl 0x180b
movl $0xff, %esi
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x17e2
xorl %ecx, %ecx
movl $0xff, %edx
cmpq %rcx, %r12
je 0x1839
movzbl (%r15,%rcx), %esi
movzbl (%rax,%rcx), %edi
addl %esi, %edi
cmpl %edx, %edi
cmovael %edx, %edi
movb %dil, (%rbx,%rcx)
incq %rcx
jmp 0x181b
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dekanfrus[P]pThreads/osproj2a.c
// Function: compute_pi(void*)
void *compute_pi( void *s )
{
  unsigned int seed;
  int ii;
  int *hit_pointer;
  int local_hits;
  double rand_no_x;
  double rand_no_y;

  hit_pointer = (int *) s;
  seed = *hit_pointer;
  local_hits = 0;


  for( ii=0; ii < sample_points_per_thread; ii++ )
    {
	  
      rand_no_x = (double) (rand_r( &seed ))/(double)RAND_MAX;
      rand_no_y = (double) (rand_r( &seed ))/(double)RAND_MAX;
      if(((rand_no_x - 0.5) * (rand_no_x - 0.5) +
	  (rand_no_y - 0.5) * (rand_no_y - 0.5)) < 0.25)
	local_hits++;
      seed *= ii;
	  
    }

  *hit_pointer = local_hits;
  pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
leaq -0x24(%rbp), %r14
movl %eax, (%r14)
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl 0x3535(%rip), %r12d     # 0x4890
jge 0x13d2
movq %r14, %rdi
callq 0x1070
cvtsi2sd %eax, %xmm1
movsd 0xca7(%rip), %xmm0      # 0x2018
divsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movq %r14, %rdi
callq 0x1070
cvtsi2sd %eax, %xmm0
divsd 0xc8a(%rip), %xmm0      # 0x2018
movsd 0xc8a(%rip), %xmm1      # 0x2020
movsd -0x30(%rbp), %xmm2
addsd %xmm1, %xmm2
addsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
xorl %eax, %eax
movsd 0xc6f(%rip), %xmm0      # 0x2028
ucomisd %xmm2, %xmm0
seta %al
addl %eax, %r15d
movl -0x24(%rbp), %eax
imull %r12d, %eax
movl %eax, -0x24(%rbp)
incl %r12d
jmp 0x1354
movl %r15d, (%rbx)
xorl %edi, %edi
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/StataHeader.cpp
// Function: StataHeader::showHeader[abi:cxx11]()
string StataHeader::showHeader() {
   std::ostringstream metadata;
   string textRelease;

   switch(fileRelease)
   {
       case R119: 
            textRelease = "119";
            break;
       case R118: 
            textRelease = "118";
            break;
       case R117: 
            textRelease = "117";
            break;
       case R115: 
            textRelease = "115";
            break;
       case R114: 
            textRelease = "114";
            break;
       case R113: 
            textRelease = "113";
            break;
       case R112:
            textRelease = "112";
            break;

   }

   
   metadata << "[Variables]: " << variables << endl
            << "[Observations]: " << observations << endl
            << "[Time Stamp]: " << ts << endl
            << "[Data Label]: " << datalabel << endl
            << "[Release]: " << textRelease << endl
            << "[Bitness]: " << (fileByteorder ? "Big Endian" : "Little Endian" ) << endl;


   return string(metadata.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x7440
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x58(%r14), %eax
cmpq $0x7, %rax
jae 0xa1f5
leaq 0x527f(%rip), %rcx      # 0xf464
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7610
leaq 0x51e9(%rip), %rsi      # 0xf3e5
leaq -0x1a8(%rbp), %rdi
callq 0x7300
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x7210
movq %rax, %rdi
callq 0x7160
leaq 0x51d0(%rip), %rsi      # 0xf3f3
movq %rax, %rdi
callq 0x7300
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x7210
movq %rax, %rdi
callq 0x7160
leaq 0x51be(%rip), %rsi      # 0xf404
movq %rax, %rdi
callq 0x7300
leaq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x72c0
movq %rax, %rdi
callq 0x7160
leaq 0x51aa(%rip), %rsi      # 0xf413
movq %rax, %rdi
callq 0x7300
leaq 0x38(%r14), %rsi
movq %rax, %rdi
callq 0x72c0
movq %rax, %rdi
callq 0x7160
leaq 0x5196(%rip), %rsi      # 0xf422
movq %rax, %rdi
callq 0x7300
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x72c0
movq %rax, %rdi
callq 0x7160
leaq 0x517f(%rip), %rsi      # 0xf42e
movq %rax, %rdi
callq 0x7300
cmpl $0x0, 0x5c(%r14)
leaq 0x5182(%rip), %rcx      # 0xf445
leaq 0x5170(%rip), %rsi      # 0xf43a
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x7300
movq %rax, %rdi
callq 0x7160
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x7520
leaq -0x30(%rbp), %rdi
callq 0x7150
leaq -0x1a8(%rbp), %rdi
callq 0x70a0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x7150
leaq -0x1a8(%rbp), %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x75b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::Context(char*, int)
Context::Context(char *cursor, int length) : start(0), strls(false)
{
  this->origin = cursor;
  this->cursor = cursor;
  this->length = length;
  this->currentState = new OpenDTA();
  this->buffer = new char[INITIAL_BUFFER];
  this->buffer_size = INITIAL_BUFFER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r15
leaq 0xcbaf(%rip), %rax      # 0x170d8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xa0e8
leaq 0x68(%r15), %r14
movq %r14, %rdi
callq 0xa334
movb $0x0, 0xb0(%r15)
leaq 0xc0(%r15), %rax
movq %rax, -0x38(%rbp)
andq $0x0, 0x108(%r15)
leaq 0xd8(%r15), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%r15)
movups %xmm0, 0xd0(%r15)
movups %xmm0, 0xe0(%r15)
movq %r13, 0xb8(%r15)
movq %r13, 0x100(%r15)
movl %r12d, 0x110(%r15)
pushq $0x8
popq %rdi
callq 0x7310
leaq 0xcb4f(%rip), %rcx      # 0x170f8
movq %rcx, (%rax)
movq %rax, 0xa8(%r15)
movl $0x400, %edi            # imm = 0x400
callq 0x7030
movq %rax, 0xf0(%r15)
movl $0x400, 0xf8(%r15) # imm = 0x400
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xa600
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0xc75e
movq -0x38(%rbp), %rdi
callq 0xbcb4
movq %r14, %rdi
callq 0xa388
movq %rbx, %rdi
callq 0xa156
movq %r15, %rdi
callq 0x75b0
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::~Context()
Context::~Context()
{
  if (currentState)
    delete currentState;
  
  if (buffer)
    delete buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xcab8(%rip), %rax      # 0x170d8
movq %rax, (%rdi)
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0xa635
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xa649
pushq $0x1
popq %rsi
callq 0x7320
leaq 0xd8(%rbx), %rdi
callq 0xc75e
leaq 0xc0(%rbx), %rdi
callq 0xbcb4
leaq 0x68(%rbx), %rdi
callq 0xa388
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa156
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::exportToDB(DatabaseTypes, void*)
int Context::exportToDB(DatabaseTypes db_type, void * params)
{
  Database * db_obj = NULL;

  switch(db_type) 
  {
    case SQLITE:
        db_obj = (Database *)new SQLite();
        break;
  }


  if (db_obj)
  {
      if (db_obj->connect((char*)params))
      {
        /* start writing the database */
        db_obj->write(*this);

        /* finished */
        db_obj->close();
      }

      delete db_obj;
      db_obj = NULL;
  }
  else
  {
    cout << "Couldn't create a database object to export the database"  << endl;
    return 0;
  }
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0xa6d4
movq 0xd90d(%rip), %rdi      # 0x17fc0
leaq 0x4f9e(%rip), %rsi      # 0xf658
callq 0x7300
movq %rax, %rdi
callq 0x7160
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x7310
movq %rax, %rbx
movq %rax, %rdi
callq 0xdc28
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
testb %al, %al
je 0xa711
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x7320
movq %r14, %rdi
callq 0x75b0
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advanceData(int)
void Context::advanceData(int c)
{
  int curr_length=0, curr_position = 0;
  char *prev_cursor = cursor;
 
  for (start = cursor; curr_position <= c; cursor++, curr_position++);
 
  curr_length = cursor - prev_cursor;

  if (curr_length > buffer_size)
    resizeBuffer(curr_length);

  memset(buffer, 0, buffer_size);
  strncpy(buffer, start, curr_length);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x100(%rdi), %rax
movq %rax, 0x108(%rdi)
incq %rax
xorl %r14d, %r14d
cmpl %esi, %r14d
jg 0xa763
leaq (%rax,%r14), %rcx
movq %rcx, 0x100(%rbx)
incq %r14
jmp 0xa74e
movl 0xf8(%rbx), %eax
cmpl %r14d, %eax
jge 0xa77f
movq %rbx, %rdi
movl %r14d, %esi
callq 0xbce0
movl 0xf8(%rbx), %eax
movq 0xf0(%rbx), %rdi
movslq %eax, %rdx
xorl %esi, %esi
callq 0x71d0
movq 0xf0(%rbx), %rdi
movq 0x108(%rbx), %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x7190
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advanceNoState()
void Context::advanceNoState()
{
  int curr_length=0;
  int i = 0;


  for (start = cursor; cursor && (cursor - origin) < length && *cursor != '>'; cursor++);

  if (cursor && *cursor++ == '>')
  {
    curr_length = cursor - start;
        
    if (curr_length > buffer_size)
      resizeBuffer(curr_length);

    memset(buffer, 0, buffer_size);
    strncpy(buffer, start, curr_length);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq 0x100(%rdi), %rax
movq %rax, 0x108(%rdi)
movslq 0x110(%rdi), %rdx
movq %rax, %rdi
subq 0xb8(%rbx), %rdi
pushq $0x1
popq %rsi
movq %rcx, %r14
testq %rax, %rax
je 0xa85d
cmpq %rdx, %rdi
jge 0xa806
cmpb $0x3e, (%rax)
je 0xa806
incq %rax
movq %rax, 0x100(%rbx)
addq %rcx, %r14
incl %esi
incq %rdi
jmp 0xa7e3
leaq 0x1(%rax), %rcx
movq %rcx, 0x100(%rbx)
cmpb $0x3e, (%rax)
jne 0xa85d
movl 0xf8(%rbx), %eax
cmpl %esi, %eax
jge 0xa82e
movq %rbx, %rdi
callq 0xbce0
movl 0xf8(%rbx), %eax
movq 0xf0(%rbx), %rdi
movslq %eax, %rdx
xorl %esi, %esi
callq 0x71d0
movq 0xf0(%rbx), %rdi
movq 0x108(%rbx), %rsi
sarq $0x20, %r14
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x7190
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advance()
void * Context::advance()
{
  advanceNoState();

  while (currentState && currentState->check(buffer))
  {
      currentState->process(*this);

      if (currentState)
      {
        State * newState = currentState->advanceState();
        delete currentState;
        currentState = newState;
      }
  }
  
  return (void *)(start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xa7aa
movq 0xa8(%rbx), %r14
testq %r14, %r14
je 0xa8ea
movq 0xf0(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %al, %al
je 0xa8ea
movq 0xa8(%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq 0xa8(%rbx), %rdi
movl $0x0, %r14d
testq %rdi, %rdi
je 0xa88c
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0xa8e1
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, 0xa8(%rbx)
jmp 0xa88c
movq 0x108(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: OpenRelease::process(Context&)
bool OpenRelease::process(Context &ctx)
{
  string version = ctx.getChars(3);
 
  switch (strtol(version.c_str(), NULL, 10))
  {
  case 119:
  case 118:
    ctx.hdr.fileRelease = R119;
    break;
  case 117:
    ctx.hdr.fileRelease = R117;
    break;

  default:
    ctx.hdr.fileRelease = R117;
    break;
  }

  ctx.advance(); // CONTENT
  ctx.advance(); // </release>
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq -0x30(%rbp), %r14
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0xbd1c
movq (%r14), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x7490
leaq -0x75(%rax), %rcx
cmpq $0x2, %rcx
ja 0xa9b2
leaq 0x4c73(%rip), %rcx      # 0xf61c
movl -0x1d4(%rcx,%rax,4), %eax
jmp 0xa9b5
pushq $0x2
popq %rax
movl %eax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xa876
movq %rbx, %rdi
callq 0xa876
leaq -0x30(%rbp), %rdi
callq 0x7150
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x7150
movq %rbx, %rdi
callq 0x75b0
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: OpenByteOrder::process(Context&)
bool OpenByteOrder::process(Context &ctx)
{
  string byteOrder = ctx.getChars(3);

  if (!strcasecmp(byteOrder.c_str(), XML_LSF))
    ctx.hdr.fileByteorder = LSF;
  else
    ctx.hdr.fileByteorder = MSF;

  ctx.advance(); // ORDER
  ctx.advance(); // </byteorder>
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq -0x30(%rbp), %r14
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0xbd1c
movq (%r14), %rdi
leaq 0x4c62(%rip), %rsi      # 0xf691
callq 0x7360
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0x64(%rbx)
movq %rbx, %rdi
callq 0xa876
movq %rbx, %rdi
callq 0xa876
leaq -0x30(%rbp), %rdi
callq 0x7150
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x7150
movq %rbx, %rdi
callq 0x75b0