LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: simulate(ssd_info*)
ssd_info *simulate(ssd_info *ssd){

	int flag=0;
	unsigned int a=0,b=0;
	static int second = 0;

	printf("\n");
	printf("begin simulating.......................\n");
	printf("\n");

	int i = 0;
	while(flag!=100)
	{
		flag=get_requests_consolidation(ssd);
		if(flag == 1)
		{
			distribute(ssd); // in ssd.cpp
		}
		process(ssd); // in ftl.cpp
		trace_output(ssd);
		if(flag == 0 && ssd->request_queue == NULL){
			flag = 100;
		}
		if (ssd->current_time != MAX_INT64 && ssd->current_time / EPOCH_LENGTH  > second){
			print_epoch_statistics(ssd, 1);
			while (ssd->current_time / (EPOCH_LENGTH) > second)
				second++;
		}

//		if (!ssd->dram->buffer->check_buffer()) {
//			cout << "BUFFER FAIL " << endl;
//			break;
//		}
	}

	return ssd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edi
callq 0x2260
leaq 0x2f5b(%rip), %rdi      # 0xb0da
callq 0x22a0
movl $0xa, %edi
callq 0x2260
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x36f9bfb3af7b757, %r14 # imm = 0x36F9BFB3AF7B757
movq %rbx, %rdi
callq 0x8a29
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x81b9
movq %rbx, %rdi
callq 0x4b70
movq %rbx, %rdi
callq 0x51aa
movq %rbx, %rdi
callq 0x8a58
testl %ebp, %ebp
je 0x81d1
xorl %ebp, %ebp
jmp 0x81da
cmpq $0x0, 0x68(%rbx)
sete %bpl
movq (%rbx), %rax
cmpq %r15, %rax
je 0x822d
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1b, %rdx
addq %rax, %rdx
movslq 0x5fba(%rip), %rax      # 0xe1b4
cmpq %rax, %rdx
jle 0x822d
movq %rbx, %rdi
callq 0x8245
movq %r14, %rax
imulq (%rbx)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1b, %rdx
addq %rax, %rdx
movslq 0x5f92(%rip), %rax      # 0xe1b4
cmpq %rax, %rdx
jle 0x822d
movl %edx, 0x5f87(%rip)      # 0xe1b4
testb %bpl, %bpl
je 0x81a2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: trace_output(ssd_info*)
void trace_output(ssd_info* ssd){
	int flag = 1;
	int64_t start_time, end_time;
	request *req, *pre_node;
	sub_request *sub, *tmp;

	pre_node=NULL;
	req = ssd->request_queue;

	if(req == NULL)
		return;

	while(req != NULL)
	{
		if(req->response_time != 0)
		{

			collect_statistics(ssd, req);
			remove_request(ssd, &req, &pre_node);
		}
		else
		{
			sub = req->subs;
			flag = 1;
			start_time = 0;
			end_time = 0;

			while(sub != NULL)
			{
				if(start_time == 0)
					start_time = sub->begin_time;
				if(start_time > sub->begin_time)
					start_time = sub->begin_time;
				if (end_time < sub->complete_time){
					end_time = sub->complete_time;
					req->critical_sub = sub;
				}

				// if any sub-request is not completed, the request is not completed
				if( find_subrequest_state(ssd, sub) == SR_MODE_COMPLETE )
				{
					sub = sub->next_subs;
				}
				else
				{
					flag=0;
					break;
				}

			}

			if (flag == 1)
			{
				req->response_time = end_time;
				req->begin_time = start_time;
				collect_statistics(ssd, req );
				remove_request(ssd, &req, &pre_node);

			}
			else
			{
				// request is not complete yet, go to the next node
				pre_node = req;
				req = req->next_node;
			}
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
movq 0x68(%rdi), %r12
movq %r12, 0x10(%rsp)
testq %r12, %r12
je 0x8b3f
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x28(%r12)
jne 0x8afd
movq %r14, %r15
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x8ae6
xorl %r14d, %r14d
xorl %ebp, %ebp
testq %rbp, %rbp
movq 0x48(%r13), %rcx
movq 0x58(%r13), %rax
cmoveq %rcx, %rbp
cmpq %rcx, %rbp
cmovgeq %rcx, %rbp
cmpq %rax, %r14
jge 0x8acb
movq %r13, 0x40(%r12)
movq %rax, %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6d68
cmpl $0x9, %eax
jne 0x8b26
movq 0x68(%r13), %r13
testq %r13, %r13
jne 0x8aa8
jmp 0x8aeb
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %r14, 0x28(%r12)
movq %rbp, 0x20(%r12)
movq %r15, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9444
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x95ca
movq 0x10(%rsp), %r12
testq %r12, %r12
jne 0x8a8e
jmp 0x8b3f
movq %r12, 0x8(%rsp)
movq 0x38(%r12), %r12
movq %r12, 0x10(%rsp)
movq %r15, %r14
leaq 0x8(%rsp), %r15
jmp 0x8b1b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: norm_dist(double, double)
double norm_dist(double mu, double sigma ) {
	const double epsilon = std::numeric_limits<double>::min(); 
	const double two_pi = 2.0 * 3.14159265358979323846; 
	
	static double z0, z1 = 0; 
	static bool generate = false; 
	generate = !generate; 
	
	if (!generate) 
		return z1 * sigma + mu; 

	double u1, u2; 
	do 
	{
		u1 = rand() * (1.0 / RAND_MAX); 
		u2 = rand() * (1.0 / RAND_MAX); 

	}while (u1 <= epsilon); 

	z0 = sqrt(-2.0 * log(u1)) * cos(two_pi * u2); 
	z1 = sqrt(-2.0 * log(u1)) * sin(two_pi * u2); 
	
	return z0 * sigma + mu; 

}

// Assembly:
subq $0x28, %rsp
movb 0x5394(%rip), %al       # 0xe1c8
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x5389(%rip)       # 0xe1c8
testb %al, %al
je 0x8e4f
leaq 0x5376(%rip), %rax      # 0xe1c0
jmp 0x8f47
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
callq 0x20a0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x1db9(%rip), %xmm0     # 0xac28
movsd %xmm0, (%rsp)
callq 0x20a0
movsd (%rsp), %xmm0
movsd 0x1daa(%rip), %xmm1     # 0xac30
ucomisd %xmm0, %xmm1
jae 0x8e5b
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x1d8d(%rip), %xmm1     # 0xac28
movsd %xmm1, 0x8(%rsp)
callq 0x2110
mulsd 0x1d8a(%rip), %xmm0     # 0xac38
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8ebe
sqrtsd %xmm0, %xmm0
jmp 0x8ec3
callq 0x2100
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x1d69(%rip), %xmm0     # 0xac40
movsd %xmm0, 0x8(%rsp)
callq 0x2300
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x52c8(%rip)     # 0xe1b8
movsd (%rsp), %xmm0
callq 0x2110
mulsd 0x1d36(%rip), %xmm0     # 0xac38
ucomisd 0x1d3e(%rip), %xmm0     # 0xac48
jb 0x8f12
sqrtsd %xmm0, %xmm0
jmp 0x8f17
callq 0x2100
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2090
mulsd (%rsp), %xmm0
movsd %xmm0, 0x528c(%rip)     # 0xe1c0
leaq 0x527d(%rip), %rax      # 0xe1b8
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
mulsd (%rax), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: find_nearest_event(ssd_info*)
int64_t find_nearest_event(ssd_info *ssd) {
	unsigned int i,j;
	int64_t time=MAX_INT64;
	int64_t time1=MAX_INT64;
	int64_t time2=MAX_INT64;



	for (i=0;i<ssd->parameter->channel_number;i++)
	{
		if (ssd->channel_head[i]->next_state==CHANNEL_MODE_IDLE)
			if(time1>ssd->channel_head[i]->next_state_predict_time)
				if (ssd->channel_head[i]->next_state_predict_time > ssd->current_time)
					time1=ssd->channel_head[i]->next_state_predict_time;
		for (j=0;j<ssd->parameter->lun_channel[i];j++)
		{
			if (ssd->channel_head[i]->lun_head[j]->next_state==LUN_MODE_IDLE)
				if(time2>ssd->channel_head[i]->lun_head[j]->next_state_predict_time)
					if (ssd->channel_head[i]->lun_head[j]->next_state_predict_time>ssd->current_time)
						time2=ssd->channel_head[i]->lun_head[j]->next_state_predict_time;

		}
	}


	time=(time1>time2)?time2:time1;


	return time;
}

// Assembly:
pushq %r14
pushq %rbx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq 0x58(%rdi), %rcx
movl 0x98(%rcx), %edx
testq %rdx, %rdx
je 0x9215
movq 0x90(%rdi), %r8
xorl %r9d, %r9d
movq %rax, %rsi
movq (%r8,%r9,8), %r11
cmpl $0x0, 0x3c(%r11)
jne 0x91d5
movq 0x48(%r11), %r10
cmpq %r10, %rsi
jle 0x91d5
cmpq (%rdi), %r10
cmovgq %r10, %rsi
movl 0x9c(%rcx,%r9,4), %r10d
testq %r10, %r10
je 0x920b
movq 0x50(%r11), %r11
xorl %ebx, %ebx
movq (%r11,%rbx,8), %r14
cmpl $0x0, 0x20(%r14)
jne 0x9203
movq 0x28(%r14), %r14
cmpq %r14, %rax
jle 0x9203
cmpq (%rdi), %r14
cmovgq %r14, %rax
incq %rbx
cmpq %rbx, %r10
jne 0x91e8
incq %r9
cmpq %rdx, %r9
jne 0x91ba
jmp 0x9218
movq %rax, %rsi
cmpq %rax, %rsi
cmovlq %rsi, %rax
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: collect_statistics(ssd_info*, request*)
void collect_statistics(ssd_info * ssd, request * req){

	sub_request * sub;
	sub = req->subs; //  critical_sub;

	while (sub != NULL)
	{
		if (sub->complete_time != req->response_time) { sub = sub->next_subs; continue;  }
	for (unsigned int i = 0; i < SR_MODE_NUM; i++){
			ssd->stats->subreq_state_time[i] += sub->state_time[i];
		}

		sub = sub->next_subs;

	}

	if(req->response_time-req->begin_time==0)
	{
		printf("1. the response time is 0?? %lld %lld \n", req->response_time, req->begin_time);
		getchar();
	}
	
	if (req->operation==READ)
	{
		ssd->stats->read_request_size[req->app_id] += req->size;
		ssd->stats->read_RT.update(req->response_time - req->begin_time); 
		ssd->stats->read_throughput.add_time(req->begin_time, req->response_time); // changed 
		ssd->stats->read_throughput.add_capacity(req->size);
		ssd->stats->read_throughput.add_count(1);
	}
	else
	{
		ssd->stats->write_request_size[req->app_id] += req->size; 
		ssd->stats->write_RT.update(req->response_time - req->begin_time); 
		ssd->stats->write_throughput.add_time(req->begin_time, req->response_time); 
		ssd->stats->write_throughput.add_capacity(req->size);
		ssd->stats->write_throughput.add_count(1);
	}

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x948f
movq 0x58(%rax), %rcx
cmpq 0x28(%rbx), %rcx
jne 0x9489
movq 0x80(%rax), %rcx
movq 0x98(%r14), %rdx
movq 0x188(%rdx), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
addq %rdi, (%rdx,%rsi,8)
incq %rsi
cmpq $0xa, %rsi
jne 0x9478
movq 0x68(%rax), %rax
jmp 0x9452
movq 0x28(%rbx), %rdx
cmpq 0x20(%rbx), %rdx
jne 0x94af
leaq 0x1876(%rip), %rdi      # 0xad16
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2060
callq 0x2250
cmpl $0x1, 0x18(%rbx)
movl (%rbx), %eax
movl 0x14(%rbx), %ecx
movq 0x98(%r14), %rdi
jne 0x9518
movq 0x58(%rdi), %rdx
addq %rcx, (%rdx,%rax,8)
addq $0x8, %rdi
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
callq 0x984c
movq 0x98(%r14), %rax
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq 0x1a8(%rax), %rsi
cmpq %rdx, %rsi
setge %dil
cmpq %rcx, %rsi
setle %r8b
testb %r8b, %dil
jne 0x956f
cmpq %rdx, %rsi
setge %dil
cmpq %rcx, %rsi
setge %sil
orb %dil, %sil
je 0x9572
jmp 0x9586
movq 0x68(%rdi), %rdx
addq %rcx, (%rdx,%rax,8)
addq $0x30, %rdi
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
callq 0x984c
movq 0x98(%r14), %rax
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq 0x1c8(%rax), %rsi
cmpq %rdx, %rsi
setge %dil
cmpq %rcx, %rsi
setle %r8b
testb %r8b, %dil
jne 0x9598
cmpq %rdx, %rsi
setge %dil
cmpq %rcx, %rsi
setge %sil
orb %dil, %sil
je 0x959b
jmp 0x95af
movq %rsi, %rdx
movq %rcx, %rsi
subq %rdx, %rsi
addq %rsi, 0x190(%rax)
movq %rcx, 0x1a8(%rax)
movl 0x14(%rbx), %ecx
addq %rcx, 0x198(%rax)
addq $0x1a0, %rax            # imm = 0x1A0
jmp 0x95bf
movq %rsi, %rdx
movq %rcx, %rsi
subq %rdx, %rsi
addq %rsi, 0x1b0(%rax)
movq %rcx, 0x1c8(%rax)
movl 0x14(%rbx), %ecx
addq %rcx, 0x1b8(%rax)
addq $0x1c0, %rax            # imm = 0x1C0
incq (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: remove_request(ssd_info*, request**, request**)
void remove_request(ssd_info * ssd, request ** req, request ** pre_node){
	if(*pre_node == NULL)
	{
		if((*req)->next_node == NULL)
		{
			delete (*req);
			*req = NULL;
			ssd->request_queue = NULL;
			ssd->request_tail = NULL;
			ssd->request_queue_length--;
		}
		else
		{
			ssd->request_queue = (*req)->next_node;
			(*pre_node) = (*req);
			(*req) = (*req)->next_node;
			delete (*pre_node);
			*pre_node = NULL;
			ssd->request_queue_length--;
		}
	}
	else
	{
		if((*req)->next_node == NULL)
		{
			(*pre_node)->next_node = NULL;
			delete (*req);
			*req = NULL;
			ssd->request_tail = (*pre_node);
			ssd->request_queue_length--;
		}
		else
		{
			(*pre_node)->next_node = (*req)->next_node;
			delete (*req);
			(*req) = (*pre_node)->next_node;
			ssd->request_queue_length--;
		}
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rcx
movq (%rsi), %r12
movq 0x38(%r12), %rax
testq %rcx, %rcx
je 0x9620
testq %rax, %rax
je 0x965c
movq %rax, 0x38(%rcx)
movq (%r15), %r12
testq %r12, %r12
je 0x9604
movq %r12, %rdi
callq 0x9810
movl $0x48, %esi
movq %r12, %rdi
callq 0x21a0
movq (%r14), %rax
movq 0x38(%rax), %rax
movq %rax, (%r15)
jmp 0x96b4
testq %rax, %rax
je 0x9691
movq %rax, 0x68(%rbx)
movq (%r15), %rax
movq %rax, (%r14)
movq 0x38(%rax), %rax
movq %rax, (%r15)
movq (%r14), %r15
testq %r15, %r15
je 0x9646
movq %r15, %rdi
callq 0x9810
movl $0x48, %esi
movq %r15, %rdi
callq 0x21a0
movq $0x0, (%r14)
jmp 0x96b4
movq $0x0, 0x38(%rcx)
movq (%r15), %r12
testq %r12, %r12
je 0x9674
movq %r12, %rdi
callq 0x9810
movl $0x48, %esi
movq %r12, %rdi
callq 0x21a0
movq $0x0, (%r15)
movq (%r14), %rax
movq %rax, 0x70(%rbx)
jmp 0x96b4
movq %r12, %rdi
callq 0x9810
movl $0x48, %esi
movq %r12, %rdi
callq 0x21a0
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
decl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/ssd.cpp
// Function: transfer_size(ssd_info*, unsigned int, request*)
unsigned int transfer_size(ssd_info *ssd,unsigned int lpn,request *req){
	unsigned int first_lpn,last_lpn,trans_size;
	uint64_t state;
	uint64_t mask=0,offset1=0,offset2=0;

	first_lpn=req->lsn/ssd->parameter->subpage_page;
	last_lpn=(req->lsn+req->size-1)/ssd->parameter->subpage_page;

	mask=~(0xffffffffffffffff<<(ssd->parameter->subpage_page));
	state=mask;
	if(lpn==first_lpn)
	{
		offset1=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-req->lsn);
		state=state&(0xffffffffffffffff<<offset1);
	}
	if(lpn==last_lpn)
	{
		offset2=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-(req->lsn+req->size));
		state=state&(~(0xffffffffffffffff<<offset2));
	}

	trans_size=size(state);

	return trans_size;
}

// Assembly:
movl 0x10(%rdx), %r10d
movl 0x14(%rdx), %r8d
movq 0x58(%rdi), %rax
movl 0x238(%rax), %r9d
movl %r10d, %eax
xorl %edx, %edx
divl %r9d
movl %eax, %r11d
movq $-0x1, %rdi
movl %r9d, %ecx
shlq %cl, %rdi
leal (%r8,%r10), %eax
decl %eax
xorl %edx, %edx
divl %r9d
notq %rdi
cmpl %esi, %r11d
jne 0x9715
movl %esi, %ecx
notl %ecx
imull %r9d, %ecx
addl %r9d, %ecx
addl %r10d, %ecx
shrq %cl, %rdi
shlq %cl, %rdi
cmpl %esi, %eax
jne 0x440f
addl %r10d, %r8d
imull %esi, %r9d
subl %r9d, %r8d
movq $-0x1, %rax
movl %r8d, %ecx
shlq %cl, %rax
notq %rax
andq %rax, %rdi
jmp 0x440f
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: ssd_info::~ssd_info()
~ssd_info(){
		for (int i=0;i<parameter->channel_number;i++)
		{
			delete channel_head[i];
		}
		delete channel_head;
		delete dram;
		delete parameter;
		delete stats;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpl $0x0, 0x98(%rax)
je 0x97ad
xorl %r15d, %r15d
movq 0x90(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x978e
movq %r14, %rdi
callq 0x98ac
movl $0x60, %esi
movq %r14, %rdi
callq 0x21a0
incq %r15
movq 0x58(%rbx), %rax
movl 0x98(%rax), %eax
cmpq %rax, %r15
jb 0x9776
movq 0x90(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x97cf
movq %r14, %rdi
callq 0x990a
movl $0x28, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x58(%rbx), %rdi
movl $0x350, %esi            # imm = 0x350
callq 0x21a0
movq 0x98(%rbx), %rbx
testq %rbx, %rbx
je 0x97fe
movq %rbx, %rdi
callq 0x3e5a
movl $0x1d0, %esi            # imm = 0x1D0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: request::~request()
~request(){

		sub_request * tmp;
		while(subs!=NULL)
		{
			tmp = subs->next_subs;
			delete subs;
			subs = tmp;
		}

	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x9846
movq %rdi, %rbx
movq 0x68(%r14), %r15
movq %r14, %rdi
callq 0x65d0
movl $0xa0, %esi
movq %r14, %rdi
callq 0x21a0
movq %r15, 0x30(%rbx)
movq %r15, %r14
testq %r15, %r15
jne 0x9821
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: Stat::update(long)
void update(int64_t value){
		int64_t temp_value = value / 1000; // convert ns to us 
		if (temp_value > max) max = temp_value; 
		if (temp_value < min) min = temp_value; 
		count++; 
		sum += temp_value; 
		squared_sum += (temp_value / 1000) * (temp_value / 1000); 
	}

// Assembly:
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
cmpq 0x18(%rdi), %rdx
jle 0x9874
movq %rdx, 0x18(%rdi)
cmpq 0x20(%rdi), %rdx
jge 0x987e
movq %rdx, 0x20(%rdi)
incl (%rdi)
addq %rdx, 0x8(%rdi)
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %rsi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq %rdx, %rdx
addq %rdx, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: channel_info::~channel_info()
~channel_info(){
		for (int i = 0; i < lun_num; i++){
			delete lun_head[i];
		}
		delete lun_head;
		delete state_time;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x98e9
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x98d1
movq %r14, %rdi
callq 0x9930
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x21a0
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x98bc
movq 0x50(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x58(%rbx), %rdi
movl $0x8, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: lun_info::~lun_info()
~lun_info(){
		for (int i = 0; i < 2; i++){
			delete plane_head[i];
		}
		delete plane_head;
		delete state_time;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
xorl %eax, %eax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x9950
movq %r14, %rdi
callq 0x9990
movl $0x78, %esi
movq %r14, %rdi
callq 0x21a0
movl $0x1, %eax
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x993c
movq (%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x90(%rbx), %rdi
movl $0x8, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/narges64[P]SIMBA/./common.hh
// Function: plane_info::~plane_info()
~plane_info(){
		for (int i = 0; i < block_num; i++){
			delete blk_head[i];
		}
		delete blk_head;
		delete state_time;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jle 0x99cd
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x99b7
movq %r14, %rdi
callq 0x99ee
movl $0x28, %esi
movq %r14, %rdi
callq 0x21a0
incq %r15
cmpq %r15, 0x28(%rbx)
jg 0x99a2
movq 0x20(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x60(%rbx), %rdi
movl $0x8, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/waltersharpWEI[P]CommentEliminator/main.cpp
// Function: isSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isSource(string Name) {
    //The last 2 suffix
    string Bisuf = Name.c_str() + (Name.length() - 2);
    //The last 3 suffix
    string Trisuf = Name.c_str() + (Name.length() - 3);
    //The last 4 suffix
    string Fousuf = Name.c_str() + (Name.length() - 4);

    if (Bisuf == ".c" || Bisuf == ".h") {
        return true;
    }
    if (Trisuf == ".cc" || Trisuf ==".hh") {
        return true;
    }
    if (Fousuf == ".hpp" || Fousuf == ".cpp") {
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x2, %rsi
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3a94
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x3, %rsi
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x3a94
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x4, %rsi
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3a94
leaq 0x26d7(%rip), %rsi      # 0x5037
leaq -0x50(%rbp), %rdi
callq 0x2070
movb $0x1, %bl
testl %eax, %eax
je 0x29d4
leaq 0x26c4(%rip), %rsi      # 0x503a
leaq -0x50(%rbp), %rdi
callq 0x2070
testl %eax, %eax
je 0x29d4
leaq 0x26b3(%rip), %rsi      # 0x503d
leaq -0x30(%rbp), %rdi
callq 0x2070
testl %eax, %eax
je 0x29d4
leaq 0x26a3(%rip), %rsi      # 0x5041
leaq -0x30(%rbp), %rdi
callq 0x2070
testl %eax, %eax
je 0x29d4
leaq 0x2693(%rip), %rsi      # 0x5045
leaq -0x70(%rbp), %rdi
callq 0x2070
testl %eax, %eax
je 0x29d4
leaq 0x2684(%rip), %rsi      # 0x504a
leaq -0x70(%rbp), %rdi
callq 0x2070
testl %eax, %eax
sete %bl
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29ed
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21d0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a06
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21d0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a1f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a49
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2a49
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a62
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/waltersharpWEI[P]CommentEliminator/main.cpp
// Function: threadEliminator(void*)
void* threadEliminator(void* FilesPointer) {
    vector<string> *Files = (vector<string> *)FilesPointer;
    if (Files->size() <= 0) {
        return NULL;
    }
    for (vector<string>::iterator It = Files->begin(); It != Files->end(); It++) {
        string FilePath = *It;
        cout << "Removing comment from file " << FilePath << endl;
        removeComment(FilePath);
        cout << "Comment removed" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r13
cmpq %r13, 0x8(%rdi)
jne 0x3073
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x58(%rbp), %r15
movq 0x4f4a(%rip), %r14      # 0x7fc8
leaq -0x68(%rbp), %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3d2c
movl $0x1b, %edx
movq %r14, %rdi
leaq 0x1ff1(%rip), %rsi      # 0x509e
callq 0x21f0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x21f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq %r15, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3d2c
movq %r12, %rdi
callq 0x25cc
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3120
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movl $0xf, %edx
movq %r14, %rdi
leaq 0x1f8b(%rip), %rsi      # 0x50ba
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3174
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
addq $0x20, %r13
jmp 0x3082
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x319a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
jmp 0x319a
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x31b3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/waltersharpWEI[P]CommentEliminator/main.cpp
// Function: completeDistribute(bool*, int)
bool completeDistribute(bool* used,int size) {
    int Result = true;
    for (int I = 0;I < size;I++) {
        if (!used[I]) {
            return false;
        }
    }
    return Result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x3400
cmpb $0x1, (%rdi)
jne 0x3404
movl %esi, %eax
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x33f8
leaq 0x1(%rcx), %rdx
cmpb $0x0, (%rdi,%rcx)
jne 0x33e6
cmpq %rax, %rcx
setae %al
jmp 0x3406
movb $0x1, %al
jmp 0x3406
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/waltersharpWEI[P]CommentEliminator/main.cpp
// Function: showHelp()
void showHelp() {
    cout << "Use -a to choose algorithm 0:greedy 1:random\n"
            "Use -t to set the number of threads you want to use\n"
            "Use Directory of Project as Argument"
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x4795(%rip), %rbx      # 0x7fc8
leaq 0x18db(%rip), %rsi      # 0x5115
movl $0x85, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::def(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Model::def(std::string model_type){
    /*
        max -> 1
        min -> -1
    */

    if(!model_type.compare("max")){
        type = model_type;
        // for 'max problem' the coefs have the opposite sign on the tableau
        type_id = -1; 
    }else if(!model_type.compare("min")){
        type = model_type;
        type_id = 1;
    }else{
        std::cout << "Invalid constraint type" << std::endl; 
        exit(0);
    }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xab34(%rip), %rsi      # 0x100b9
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x55cb
leaq 0xaaf8(%rip), %rsi      # 0x10090
movq %r14, %rdi
callq 0x2090
movl $0x1, %ebp
testl %eax, %eax
je 0x55d0
movq 0xfa28(%rip), %rdi      # 0x14fd8
leaq 0xad49(%rip), %rsi      # 0x10300
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2120
movl %ebp, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::cstr_add(Model::cstr)
void Model::cstr_add(Model::cstr constraint){

    if(constraint.coef_get().size() != var_qnt){
        std::cout << "Invalid constraint's variables" << std::endl;
        exit(0);
    }
        
    cstr_vec.push_back(constraint);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4ae4
movq (%r15), %rdi
movq 0x8(%r15), %r15
subq %rdi, %r15
sarq $0x3, %r15
movslq (%r14), %r12
testq %rdi, %rdi
je 0x56e1
callq 0x21c0
cmpq %r12, %r15
jne 0x5701
addq $0x58, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd5fe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf8d0(%rip), %rdi      # 0x14fd8
leaq 0xac19(%rip), %rsi      # 0x10328
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse_add(Model::cstr)
void Model::analyse_add(Model::cstr cstr_new){

    if(cstr_new.coef_get().size() != var_qnt){
        std::cout << "Invalid constraint added to analysis" << std::endl;
        exit(0);
    }

    cstr_vec_new.push_back(cstr_new); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4ae4
movq (%r15), %rdi
movq 0x8(%r15), %r15
subq %rdi, %r15
sarq $0x3, %r15
movslq (%r14), %r12
testq %rdi, %rdi
je 0x5771
callq 0x21c0
cmpq %r12, %r15
jne 0x5791
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd5fe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf840(%rip), %rdi      # 0x14fd8
leaq 0xaba8(%rip), %rsi      # 0x10347
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::vec_multiply_scalar(std::vector<double, std::allocator<double>>&, double)
void Model::vec_multiply_scalar(std::vector<double> & vec, double scalar){
    for(int i = 0; i < vec.size(); i++){
        if(vec[i] <= DBL_EPSILON && vec[i] >= -DBL_EPSILON) //eq to 0
            continue;

        vec[i] *= scalar;
    }
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x5802
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movapd 0xaaca(%rip), %xmm1     # 0x102a0
movsd 0xaaf2(%rip), %xmm2     # 0x102d0
movsd (%rax,%rdx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
ucomisd %xmm4, %xmm2
jae 0x57fa
mulsd %xmm0, %xmm3
movsd %xmm3, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x57de
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::inverse_matrix_store()
void Model::inverse_matrix_store(){
    inverse_matrix = std::vector<std::vector<double>> (I_index.size(), std::vector<double> (I_index.size()));

    for(int i = 0; i < I_index.size(); i++){
        int col = I_index[i];
        for(int j = 1; j < tableau.size(); j++){
            inverse_matrix[j-1][i] = tableau[j][col]; 
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x198(%rdi), %r14
subq 0x190(%rdi), %r14
sarq $0x2, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd654
leaq 0x20(%rsp), %rdi
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0xd6e2
movq 0x1b8(%rbx), %rax
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x1b8(%rbx)
movups 0x1a8(%rbx), %xmm1
movups %xmm0, 0x1a8(%rbx)
leaq 0x40(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0xd590
movq %r14, %rdi
callq 0xd590
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5f20
callq 0x21c0
movq 0x190(%rbx), %rax
movq 0x198(%rbx), %rcx
subq %rax, %rcx
je 0x5fa5
sarq $0x2, %rcx
movq 0x88(%rbx), %rdx
movq 0x90(%rbx), %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rsi
movq 0x1a8(%rbx), %rdi
cmpq $0x1, %rcx
adcq $0x0, %rcx
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
cmpq $0x2, %rsi
jb 0x5f9d
movslq (%rax,%r9,4), %r10
movq %r8, %r11
xorl %ebx, %ebx
movq 0x18(%rdx,%rbx), %r14
movsd (%r14,%r10,8), %xmm0
movq (%rdi,%rbx), %r14
movsd %xmm0, (%r14,%r9,8)
addq $0x18, %rbx
decq %r11
jne 0x5f7f
incq %r9
cmpq %rcx, %r9
jne 0x5f70
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5fc1
callq 0x21c0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::basic_coef_get()
void Model::basic_coef_get(){
    std::vector<double> coef (tableau.size() - 1);
    for(int col = 0; col < tableau[0].size(); col++){
        if(tableau[0][col] == 0){
            for(int row = 1; row < tableau.size(); row++){
                if(tableau[row][col] == 1)
                    coef[row-1] = -1 * type_id * original_coef[col];
            }
        }
    }

    basic_coef.clear();
    basic_coef = coef;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
subq 0x88(%rdi), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r14, %rsi
decq %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd654
movq 0x88(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
je 0x60be
sarq $0x3, %rdx
movq 0x90(%rbx), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r14, %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x18, %rax
leaq -0x1(%rsi), %rdi
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
movsd 0x9ffc(%rip), %xmm1     # 0x10050
movsd (%rcx,%r8,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x60b6
jp 0x60b6
cmpq $0x2, %rsi
jb 0x60b6
xorl %r9d, %r9d
subl 0x28(%rbx), %r9d
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
movq 0x1c0(%rbx), %r9
movq 0x8(%rsp), %r10
xorl %r11d, %r11d
movq %rax, %r14
movq (%r14), %r15
movsd (%r15,%r8,8), %xmm3
ucomisd %xmm1, %xmm3
jne 0x60aa
jp 0x60aa
movsd (%r9,%r8,8), %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, (%r10,%r11,8)
addq $0x18, %r14
incq %r11
cmpq %r11, %rdi
jne 0x6089
incq %r8
cmpq %rdx, %r8
jne 0x6054
leaq 0x1d8(%rbx), %rdi
movq 0x1d8(%rbx), %rax
cmpq %rax, 0x1e0(%rbx)
je 0x60dc
movq %rax, 0x1e0(%rbx)
leaq 0x8(%rsp), %rsi
callq 0xd772
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x60f5
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6111
callq 0x21c0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solution_primal_get(std::vector<double, std::allocator<double>>&)
void Model::solution_primal_get(std::vector<double> & solution_primal){
    if(!solution_primal.empty())
        solution_primal.clear();

    const int s_col = tableau[0].size() - 1;
    
    for(int i = 0; i < var_qnt; i++){
        if(tableau[0][i] == 0){
            for(int j = 1; j < tableau.size(); j++){
                if(tableau[j][i] == 1)
                    solution_primal.push_back(tableau[j][s_col]);
            }
        }else
            solution_primal.push_back(0);
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x6138
movq %rax, 0x8(%rbx)
cmpl $0x0, (%r14)
jle 0x628c
movq 0x88(%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shlq $0x1d, %rcx
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
addq %rcx, %r12
sarq $0x1d, %r12
xorl %r13d, %r13d
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
movsd 0x9ed6(%rip), %xmm1     # 0x10050
movq 0x88(%r14), %rax
movq (%rax), %rcx
movsd (%rcx,%r13,8), %xmm0
ucomisd 0xa14e(%rip), %xmm0     # 0x102e0
jne 0x623d
jp 0x623d
movq 0x90(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
cmpq $0x2, %rdx
jb 0x627d
movl $0x1, %r15d
movl $0x18, %ebp
movq (%rax,%rbp), %rdx
movsd (%rdx,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x6221
jp 0x6221
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x61f9
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6221
movq %rbx, %rdi
callq 0xe528
movsd 0x9e47(%rip), %xmm1     # 0x10050
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
addq $0x18, %rbp
cmpq %r15, %rdx
ja 0x61c8
jmp 0x627d
movq $0x0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6260
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x627d
movq %rbx, %rdi
movq %rsp, %rdx
callq 0xe40c
movsd 0x9ddd(%rip), %xmm1     # 0x10050
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x617a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solution_dual_get(std::vector<double, std::allocator<double>>&)
void Model::solution_dual_get(std::vector<double> & solution_dual){
    if(!solution_dual.empty())
        solution_dual.clear();
        
    inverse_matrix_store();
    basic_coef_get();
    
    for(int i = 0; i < inverse_matrix.size(); i++){
        double sum = 0;
        for(int j = 0; j < inverse_matrix.size(); j++){
            sum += basic_coef[j] * inverse_matrix[j][i]; 
        }

        if(sum < DBL_EPSILON && sum > -DBL_EPSILON)
            sum = 0;

        solution_dual.push_back(sum);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x62bc
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x5e78
movq %r14, %rdi
callq 0x5fca
movq 0x1a8(%r14), %rax
movq 0x1b0(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x63cd
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rdx
xorl %r13d, %r13d
movapd 0x9f9d(%rip), %xmm2     # 0x102a0
movsd 0x9fc5(%rip), %xmm3     # 0x102d0
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%rsp)
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq 0x1d8(%r14), %rsi
xorpd %xmm0, %xmm0
movq %rax, %rdi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
movq (%rdi), %r9
mulsd (%r9,%r13,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r8
addq $0x18, %rdi
cmpq %r8, %rdx
jne 0x6332
movapd %xmm0, %xmm1
andpd %xmm2, %xmm1
ucomisd %xmm1, %xmm3
jbe 0x6372
movq $0x0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x638a
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x63b3
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe528
movsd 0x9f33(%rip), %xmm3     # 0x102d0
movapd 0x9efb(%rip), %xmm2     # 0x102a0
movq 0x1a8(%r14), %rax
movq 0x1b0(%r14), %rcx
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %r13, %rdx
ja 0x6310
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::b_opt_store()
void Model::b_opt_store(){
    if(!b_opt.empty())
        b_opt.clear();
            
    const int s_col = tableau[0].size() - 1;
    for(int j = 1; j < tableau.size(); j++)
        b_opt.push_back(tableau[j][s_col]);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %rax
cmpq 0x120(%rdi), %rax
je 0x6401
movq %rax, 0x120(%rbx)
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rdx
cmpq $0x2, %rdx
jb 0x64bb
leaq 0x118(%rbx), %r14
movq 0x8(%rax), %rdx
subq (%rax), %rdx
shlq $0x1d, %rdx
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
addq %rdx, %r12
sarq $0x1d, %r12
movl $0x1, %r13d
movl $0x18, %ebp
movq (%rax,%rbp), %rdx
addq %r12, %rdx
movq 0x120(%rbx), %rsi
cmpq 0x128(%rbx), %rsi
je 0x648b
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x120(%rbx)
jmp 0x64a1
movq %r14, %rdi
callq 0xe528
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
addq $0x18, %rbp
cmpq %r13, %rdx
ja 0x645f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::b_range_calc(std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>&)
void Model::b_range_calc(std::vector<std::pair<double, double>> & b_range){
    b_opt_store();    
    
    if(!b_range.empty())
        b_range.clear();

    //std::cout << "inve size " << inverse_matrix.size() << std::endl;
    for(int col = 0; col < inverse_matrix[0].size(); col++){
        double upper_bound = INFINITE; 
        double lower_bound = -INFINITE;


        //if(col == 6)
            //vec_print_dbl(b_opt);
        for(int row = 0; row < inverse_matrix.size(); row++){
            double coef =  inverse_matrix[row][col];
            double coef_inv = 1.0f / coef;
            double value = -1.0 * b_opt[row];

            value = value * coef_inv;

            if(coef_inv < 0 && value < upper_bound){
                upper_bound = value; 

            }else if(value > lower_bound){
                lower_bound = value;
            }

        }

        std::pair<double, double> range;
        range.first = lower_bound;
        range.second = upper_bound;

        b_range.push_back(range);

        //std::cout << "cstr n" << col << "  de " << lower_bound << " a " << upper_bound << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x63dc
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x64ef
movq %rax, 0x8(%rbx)
movq 0x1a8(%r14), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x6627
xorl %r12d, %r12d
movsd 0x9dca(%rip), %xmm4     # 0x102d8
movsd 0x9dd2(%rip), %xmm5     # 0x102e8
movq %rsp, %r15
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movsd 0x9b25(%rip), %xmm6     # 0x10050
movapd 0x9d7d(%rip), %xmm7     # 0x102b0
xorpd %xmm8, %xmm8
movq 0x1b0(%r14), %rcx
movapd %xmm5, %xmm0
movapd %xmm4, %xmm1
subq %rax, %rcx
je 0x65b4
sarq $0x3, %rcx
imulq %r13, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movq 0x118(%r14), %rdx
xorl %esi, %esi
movapd %xmm4, %xmm2
movapd %xmm5, %xmm0
movq (%rax), %rdi
movapd %xmm6, %xmm3
divsd (%rdi,%r12,8), %xmm3
movsd (%rdx,%rsi,8), %xmm1
xorpd %xmm7, %xmm1
mulsd %xmm3, %xmm1
ucomisd %xmm3, %xmm8
jbe 0x659a
ucomisd %xmm1, %xmm0
jbe 0x659a
movapd %xmm1, %xmm0
jmp 0x65a0
ucomisd %xmm2, %xmm1
ja 0x65a4
movapd %xmm2, %xmm1
incq %rsi
addq $0x18, %rax
movapd %xmm1, %xmm2
cmpq %rsi, %rcx
jne 0x656d
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x65d9
movupd (%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x6609
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe79a
xorpd %xmm8, %xmm8
movapd 0x9cbf(%rip), %xmm7     # 0x102b0
movsd 0x9a57(%rip), %xmm6     # 0x10050
movsd 0x9ce7(%rip), %xmm5     # 0x102e8
movsd 0x9ccf(%rip), %xmm4     # 0x102d8
incq %r12
movq 0x1a8(%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x6538
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse()
void Model::analyse(){
    if(!solved){
        std::cout << "The Model wasnt already solved to be analysed\n";
        exit(0);
    }
    
    tableau = solution_tableau;

    // right hand
    b_range_calc(b_range);
    c_range_calc(c_range);

    analysed = true;

    output_generate();
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x40(%rdi)
je 0x686a
movq %rdi, %rbx
leaq 0xa0(%rdi), %rsi
addq $0x88, %rdi
callq 0xd84e
leaq 0x130(%rbx), %rsi
movq %rbx, %rdi
callq 0x64ca
leaq 0x160(%rbx), %rsi
movq %rbx, %rdi
callq 0x6636
movb $0x1, 0x41(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6884
movq 0xe767(%rip), %rdi      # 0x14fd8
leaq 0x9af4(%rip), %rsi      # 0x1036c
callq 0x21e0
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse_reopt()
void Model::analyse_reopt(){
    if(!solved){
        std::cout << "The Model wasnt already solved to be analysed\n";
        exit(0);
    }else if(cstr_vec_new.empty()){
        std::cout << "No constraints added for re-optimal analysis" << std::endl;
        exit(0);
    }else
        tableau = solution_tableau;

    for(int i = 0; i < cstr_vec_new.size(); i++){
        tableau_resize(cstr_vec_new[i]);
    }

    //tableau_print();
    solver(tableau);
    
    obj_value_mod = obj_value_get();
    solution_primal_get(solution_primal_mod);
    solution_dual_get(solution_dual_mod);

    // right hand
    b_range_calc(b_range_mod);
    c_range_calc(c_range_mod);
    analysed_mod = true;
    output_mod_generate();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpb $0x0, 0x40(%rdi)
je 0x9ade
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0x9af3
leaq 0xa0(%rbx), %rsi
leaq 0x88(%rbx), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd84e
movq 0x70(%rbx), %r12
cmpq %r12, 0x78(%rbx)
je 0x9a49
movl $0x30, %r14d
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbp
leaq (%r12,%r14), %r13
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq -0x30(%r12,%r14), %rsi
movq -0x28(%r12,%r14), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4c78
movups -0x10(%r12,%r14), %xmm0
leaq 0x20(%rsp), %rax
movups %xmm0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x4ae4
movq %rbx, %rdi
movq %rbp, %r13
movq %rbp, %rsi
callq 0x9412
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x9a05
callq 0x21c0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9a19
callq 0x21c0
incq %r15
movq 0x70(%rbx), %r12
movq 0x78(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
addq $0x48, %r14
cmpq %r15, %rax
movq %r13, %rbp
ja 0x99a9
movq 0x8(%rsp), %rdi
callq *0x48(%rbx)
movq 0x88(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
shlq $0x1d, %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x1d, %rdx
movsd (%rcx,%rdx), %xmm0
andps 0x681d(%rip), %xmm0     # 0x102a0
movlps %xmm0, 0x38(%rbx)
leaq 0xd0(%rbx), %rsi
movq %rbx, %rdi
callq 0x611a
leaq 0x100(%rbx), %rsi
movq %rbx, %rdi
callq 0x629c
leaq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x64ca
leaq 0x178(%rbx), %rsi
movq %rbx, %rdi
callq 0x6636
movb $0x1, 0x42(%rbx)
movq %rbx, %rdi
callq 0x9b78
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb4f3(%rip), %rdi      # 0x14fd8
leaq 0x6880(%rip), %rsi      # 0x1036c
callq 0x21e0
jmp 0x9b0e
movq 0xb4de(%rip), %rdi      # 0x14fd8
leaq 0x689a(%rip), %rsi      # 0x1039b
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9b3b
callq 0x21c0
jmp 0x9b3b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4974
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::obj_func::var_name_get[abi:cxx11](int)
std::string Model::obj_func::var_name_get(int n){
    if(n > var_name.size() - 1){
        std::cout << "Missing some var_name" << std::endl;
        exit(0);
    }
    return var_name[n];
}

// Assembly:
pushq %rbx
movslq %edx, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
decq %rdx
cmpq %rax, %rdx
jb 0xcd77
movq %rdi, %rbx
shlq $0x5, %rax
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
callq 0x4c78
movq %rbx, %rax
popq %rbx
retq
movq 0x825a(%rip), %rdi      # 0x14fd8
leaq 0x3819(%rip), %rsi      # 0x1059e
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solve()
void Model::solve(){
    tableau_generate();
    solver(tableau);
    tableau_print();
    solution_tableau = tableau;
    
    obj_value = obj_value_get();
    solution_primal_get(solution_primal);
    solution_dual_get(solution_dual);
    solved = true;

    output_generate();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x58d0
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq *0x48(%rbx)
movq %rbx, %rdi
callq 0xce32
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0xd84e
movq 0x88(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
shlq $0x1d, %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x1d, %rdx
movsd (%rcx,%rdx), %xmm0
andps 0x34a4(%rip), %xmm0     # 0x102a0
movlps %xmm0, 0x30(%rbx)
leaq 0xb8(%rbx), %rsi
movq %rbx, %rdi
callq 0x611a
leaq 0xe8(%rbx), %rsi
movq %rbx, %rdi
callq 0x629c
movb $0x1, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6884
nop