LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
xorl %edx, %edx
divl 0x238(%rcx)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x14(%rcx), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
xorl %edx, %edx
divl 0x238(%rcx)
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x238(%rax), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0xe079
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x238(%rax), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rdx
movq 0x58(%rdx), %rdx
imull 0x238(%rdx), %ecx
movq -0x18(%rbp), %rdx
subl 0x10(%rdx), %ecx
subl %ecx, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq $-0x1, %rdx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0xe0dc
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x238(%rax), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rdx
movq 0x58(%rdx), %rdx
imull 0x238(%rdx), %ecx
movq -0x18(%rbp), %rdx
movl 0x10(%rdx), %edx
movq -0x18(%rbp), %rsi
addl 0x14(%rsi), %edx
subl %edx, %ecx
subl %ecx, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq $-0x1, %rdx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4ef0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x58(%rcx), %rcx
cmpl 0x98(%rcx), %eax
jae 0xe1bf
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe1b2
movq -0x20(%rbp), %rdi
callq 0xe6e0
movq -0x20(%rbp), %rdi
movl $0x60, %esi
callq 0x2140
jmp 0xe1b4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe16b
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe1e2
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe20b
movq -0x30(%rbp), %rdi
callq 0xe790
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xe22b
movq -0x38(%rbp), %rdi
movl $0x350, %esi            # imm = 0x350
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xe257
movq -0x40(%rbp), %rdi
callq 0x44a0
movq -0x40(%rbp), %rdi
movl $0x1d0, %esi            # imm = 0x1D0
callq 0x2140
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xe2c2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x68(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe2b4
movq -0x20(%rbp), %rdi
callq 0x8ce0
movq -0x20(%rbp), %rdi
movl $0xa0, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0xe274
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: narges64[P]SIMBA/./common.hh
// Function: request::request()
request(){
		app_id = 0;
		io_num = 0;
		time = 0;
		size = 0;
		operation = 0;
		begin_time = 0;
		response_time = 0;
		next_node = NULL;
		subs = NULL;
		critical_sub = NULL;

		subs = NULL;
		complete_lsn_count = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x30(%rax)
movl $0x0, 0x1c(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: narges64[P]SIMBA/./common.hh
// Function: request::print_to_file(_IO_FILE*)
void print_to_file(FILE * tracefile) {
		if (operation == 0) 
			//fprintf(tracefile, "%d\t%lld\t0\t0\tWrite\t%d\t%d\t1\n" , io_num , time, lsn, size ); 
			fprintf(tracefile, "%lld\tWrite\t%d\t%d\n" , time, lsn, size ); 
		else
			//fprintf(tracefile, "%d\t%lld\t0\t0\tRead\t%d\t%d\t1\n" , io_num , time, lsn, size ); 
			fprintf(tracefile, "%lld\tRead\t%d\t%d\n" , time, lsn, size ); 
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x18(%rax)
jne 0xe391
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
movl 0x14(%rax), %r8d
leaq 0x1cac(%rip), %rsi      # 0x10034
movb $0x0, %al
callq 0x21f0
jmp 0xe3b2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
movl 0x14(%rax), %r8d
leaq 0x1c9b(%rip), %rsi      # 0x10046
movb $0x0, %al
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x18(%rcx), %rax
jle 0xe3fc
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
jge 0xe416
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rax
imulq %rdx, %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: narges64[P]SIMBA/./common.hh
// Function: Tuple::add_time(long, long)
void add_time(int64_t start, int64_t end) {
		if (start <=  last_time  && end >= last_time){
			active_time += end - last_time;
			last_time = end;
		}
		else if (start > last_time && end > last_time) {
			active_time += end - start;
			last_time = end;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jg 0xe4bc
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x18(%rcx), %rax
jl 0xe4bc
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq 0x18(%rax), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0xe4f4
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jle 0xe4f2
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x18(%rcx), %rax
jle 0xe4f2
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0xe4f4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: narges64[P]SIMBA/./common.hh
// Function: Stat::get_variance()
int64_t get_variance(){ // use different unit for variance
		if (count == 0) return 0; 
		int64_t avg = get_average(); 
		return (squared_sum / count) - ( (avg / 1000) * (avg / 1000)); 
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jne 0xe5a3
movq $0x0, -0x8(%rbp)
jmp 0xe5f5
movq -0x20(%rbp), %rdi
callq 0xe540
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq 0x10(%rcx), %rax
movslq (%rcx), %rcx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
imulq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xe744
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe737
movq -0x20(%rbp), %rdi
callq 0xe7d0
movq -0x20(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2140
jmp 0xe739
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe6fb
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe764
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe784
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0xe82e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe821
movq -0x20(%rbp), %rdi
callq 0xe880
movq -0x20(%rbp), %rdi
movl $0x78, %esi
callq 0x2140
jmp 0xe823
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe7eb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe84d
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe870
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x28(%rcx), %rax
jge 0xe8e7
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe8da
movq -0x20(%rbp), %rdi
callq 0xe930
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x2140
jmp 0xe8dc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe89b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe907
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe927
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42f0
cmpq $0x0, %rax
ja 0x3171
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4310
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4380
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4340
testb $0x1, %al
jne 0x31a1
jmp 0x3299
leaq -0x18(%rbp), %rdi
callq 0x43b0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq 0xae0b(%rip), %rdi      # 0xdfc8
leaq 0x5edd(%rip), %rsi      # 0x90a1
callq 0x2200
movq %rax, -0x80(%rbp)
jmp 0x31cf
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21b0
movq %rax, -0x88(%rbp)
jmp 0x31e5
movq -0x88(%rbp), %rdi
movq 0xadbd(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x31fa
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x20e0
jmp 0x3209
leaq -0x70(%rbp), %rdi
callq 0x25a0
jmp 0x3214
leaq -0x70(%rbp), %rdi
callq 0x2130
movq 0xada4(%rip), %rdi      # 0xdfc8
leaq 0x5e92(%rip), %rsi      # 0x90bd
callq 0x2200
movq %rax, -0x90(%rbp)
jmp 0x3239
movq -0x90(%rbp), %rdi
movq 0xad69(%rip), %rsi      # 0xdfb0
callq 0x2240
jmp 0x324e
leaq -0x40(%rbp), %rdi
callq 0x2130
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x43d0
movq %rax, -0x78(%rbp)
jmp 0x317e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x328e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x329b
ud2
movq -0x48(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: waltersharpWEI[P]CommentEliminator/main.cpp
// Function: sum(std::vector<FileRecord, std::allocator<FileRecord>>)
int sum(vector<FileRecord> FileList) {
    int Result = 0;
    for (vector<FileRecord>::iterator It = FileList.begin();It != FileList.end(); It++) {
        Result += It->size;
    }
    return Result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x41f0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4260
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4220
testb $0x1, %al
jne 0x35d0
jmp 0x35f3
leaq -0x18(%rbp), %rdi
callq 0x4290
movl 0x20(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x42b0
movq %rax, -0x28(%rbp)
jmp 0x35b0
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3642
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x3635
movb $0x0, -0x1(%rbp)
jmp 0x364e
jmp 0x3637
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3619
cmpl $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/literals.cc
// Function: main
int main() 
{
	std::cout << "Hello World!";  // simple character string literal
	std::cout << "";              // empty character string literal
	// literal using newlines and tabs
	std::cout << "\nCC\toptions\tfile.[cC]\n";

    // multiline string literal
    std::cout << "a really, really long string literal "
	             "that spans two lines" << std::endl;

	// three ways to print a capital M
	std::cout << 'M' << " " << '\115' << " " << '\x4d' << std::endl;

    unsigned long long bigVal = -1ULL;
    std::cout << bigVal << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2df2(%rip), %rdi      # 0x3fd8
leaq 0xe17(%rip), %rsi       # 0x2004
callq 0x1050
movq 0x2ddf(%rip), %rdi      # 0x3fd8
leaq 0xe27(%rip), %rsi       # 0x2027
callq 0x1050
movq 0x2dcc(%rip), %rdi      # 0x3fd8
leaq 0xdfe(%rip), %rsi       # 0x2011
callq 0x1050
movq 0x2db9(%rip), %rdi      # 0x3fd8
leaq 0xe02(%rip), %rsi       # 0x2028
callq 0x1050
movq %rax, %rdi
movq 0x2d93(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2d97(%rip), %rdi      # 0x3fd8
movl $0x4d, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xe0d(%rip), %rsi       # 0x2062
callq 0x1050
movq %rax, %rdi
movl $0x4d, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xdf1(%rip), %rsi       # 0x2062
callq 0x1050
movq %rax, %rdi
movl $0x4d, %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d3b(%rip), %rsi      # 0x3fc8
callq 0x1060
movq $-0x1, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x2d33(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
movq 0x2d14(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: mororo18[P]simplex-method/src/model.cpp
// Function: Model::Model(void (*)(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&), int)
Model::Model(solver_func func, int qnt){
    solver = func;

    var_qnt = qnt;

    main_func = nullptr;
    solved = false;
    analysed = false;
    analysed_mod = false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
callq 0x106e0
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0x106e0
movq 0x8(%rsp), %rdi
addq $0x88, %rdi
callq 0x106f0
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x106f0
movq 0x8(%rsp), %rdi
addq $0xb8, %rdi
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0xd0, %rdi
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0xe8, %rdi
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x10700
movq 0x8(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x10700
movq 0x8(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x10700
movq 0x8(%rsp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x10700
movq 0x8(%rsp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x10710
movq 0x8(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x106f0
movq 0x8(%rsp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x6c90
movq 0x8(%rsp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x2290
movq 0x8(%rsp), %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0x2290
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movq $0x0, 0x50(%rax)
movb $0x0, 0x40(%rax)
movb $0x0, 0x41(%rax)
movb $0x0, 0x42(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x12892(%rip), %rsi     # 0x1b0a1
callq 0x20a0
cmpl $0x0, %eax
jne 0x883a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rdi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0x889c
movq 0x8(%rsp), %rdi
leaq 0x12832(%rip), %rsi     # 0x1b078
callq 0x20a0
cmpl $0x0, %eax
jne 0x8871
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rdi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0x1, 0x28(%rax)
jmp 0x889a
movq 0x1b760(%rip), %rdi     # 0x23fd8
leaq 0x12a61(%rip), %rsi     # 0x1b2e0
callq 0x21f0
movq %rax, %rdi
movq 0x1b73a(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
jmp 0x889c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mororo18[P]simplex-method/src/model.cpp
// Function: Model::func_add(Model::obj_func)
void Model::func_add(Model::obj_func func){

    if(func.size() != var_qnt){
        std::cout << "Invalid OF size" << std::endl;
        exit(0);
    }

    if(main_func != nullptr)
        delete main_func;
            
    main_func = new Model::obj_func (var_qnt);

    *main_func = func;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x89b0
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
je 0x8911
movq 0x1b6e9(%rip), %rdi     # 0x23fd8
leaq 0x12a02(%rip), %rsi     # 0x1b2f8
callq 0x21f0
movq %rax, %rdi
movq 0x1b6c3(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq 0x20(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x8947
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8945
movq 0x8(%rsp), %rdi
callq 0x56e0
movq 0x8(%rsp), %rdi
callq 0x21d0
jmp 0x8947
movl $0x38, %edi
callq 0x2200
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movl (%rax), %esi
callq 0x102d0
jmp 0x8969
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rdi
callq 0x10920
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x21d0
movq 0x30(%rsp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8a60
leaq 0x20(%rsp), %rdi
callq 0x6420
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movslq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6bc0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x8a47
movq 0x1b5b3(%rip), %rdi     # 0x23fd8
leaq 0x128dc(%rip), %rsi     # 0x1b308
callq 0x21f0
movq %rax, %rdi
movq 0x1b58d(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
callq 0x10980
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8a60
leaq 0x20(%rsp), %rdi
callq 0x6420
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movslq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6bc0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x8b17
movq 0x1b4e3(%rip), %rdi     # 0x23fd8
leaq 0x1282b(%rip), %rsi     # 0x1b327
callq 0x21f0
movq %rax, %rdi
movq 0x1b4bd(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0x10980
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x6420
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x8be6
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd 0x1270c(%rip), %xmm0    # 0x1b290
ucomisd (%rax), %xmm0
jb 0x8bad
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd 0x126f3(%rip), %xmm1    # 0x1b298
ucomisd %xmm1, %xmm0
jb 0x8bad
jmp 0x8bd6
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x8b4c
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x190, %rdi            # imm = 0x190
movq %rdi, 0x28(%rsp)
callq 0x59a0
movq 0x28(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x59a0
movq %rax, 0x38(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x6ce0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x10c40
jmp 0x9306
leaq 0x5b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x10cc0
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x10cd0
jmp 0x9333
movq 0x20(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
leaq 0x88(%rsp), %rsi
callq 0x10d50
leaq 0x88(%rsp), %rdi
callq 0x10800
leaq 0x5b(%rsp), %rdi
callq 0x10d90
leaq 0x70(%rsp), %rdi
callq 0x6bc0
leaq 0x6f(%rsp), %rdi
callq 0x64e0
movl $0x0, 0x54(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x190, %rdi            # imm = 0x190
callq 0x59a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x94b8
movq 0x20(%rsp), %rdi
addq $0x190, %rdi            # imm = 0x190
movslq 0x54(%rsp), %rsi
callq 0x59c0
movl (%rax), %eax
movl %eax, 0x50(%rsp)
movl $0x1, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x4c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x94a6
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x50(%rsp), %rsi
callq 0x109f0
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
movl 0x4c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x54(%rsp), %rsi
callq 0x109f0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x93cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x949a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x5b(%rsp), %rdi
callq 0x10d90
leaq 0x70(%rsp), %rdi
callq 0x6bc0
leaq 0x6f(%rsp), %rdi
callq 0x64e0
jmp 0x94c0
jmp 0x94a8
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x937f
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x88, %rdi
callq 0x10760
decq %rax
movq %rax, 0x38(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x6ce0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x10c40
jmp 0x9525
leaq 0x67(%rsp), %rdi
callq 0x64e0
movl $0x0, 0x50(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x96aa
movq 0x30(%rsp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
movslq 0x50(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9698
jp 0x9698
movl $0x1, 0x4c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x4c(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x88, %rdi
callq 0x10760
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x9696
movq 0x30(%rsp), %rdi
addq $0x88, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x50(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd 0x11a45(%rip), %xmm1    # 0x1b050
ucomisd %xmm1, %xmm0
jne 0x9684
jp 0x9684
movq 0x30(%rsp), %rdi
imull $0xffffffff, 0x28(%rdi), %eax # imm = 0xFFFFFFFF
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x1c0, %rdi            # imm = 0x1C0
movslq 0x50(%rsp), %rsi
callq 0x109f0
movsd 0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x68(%rsp), %rdi
callq 0x109f0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x9684
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x64e0
jmp 0x96fb
jmp 0x9686
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x95b0
jmp 0x9698
jmp 0x969a
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x9537
movq 0x30(%rsp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq %rdi, 0x8(%rsp)
callq 0x10720
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x10da0
jmp 0x96d1
leaq 0x68(%rsp), %rdi
callq 0x6bc0
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6bc0
movq 0x58(%rsp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11060
testb $0x1, %al
jne 0x9740
movq 0x38(%rsp), %rdi
callq 0x10720
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
subq $0x1, %rax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl (%rcx), %eax
jge 0x989a
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9870
jp 0x9870
movl $0x1, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x88, %rdi
callq 0x10760
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x986e
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd 0x11836(%rip), %xmm1    # 0x1b050
ucomisd %xmm1, %xmm0
jne 0x985c
jp 0x985c
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x109f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x10ba0
jmp 0x985e
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x97bf
jmp 0x9888
movq 0x38(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x10b70
jmp 0x988a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x976d
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11060
testb $0x1, %al
jne 0x98d0
movq 0x38(%rsp), %rdi
callq 0x10720
movq 0x18(%rsp), %rdi
callq 0x92a0
movq 0x18(%rsp), %rdi
callq 0x94d0
movl $0x0, 0x34(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x10760
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x9a0c
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x99c0
movq 0x18(%rsp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq 0x24(%rsp), %rsi
callq 0x109f0
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
movslq 0x24(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x109f0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9929
movsd 0x118c8(%rip), %xmm0    # 0x1b290
ucomisd 0x28(%rsp), %xmm0
jbe 0x99ed
movsd 0x28(%rsp), %xmm0
movsd 0x118ba(%rip), %xmm1    # 0x1b298
ucomisd %xmm1, %xmm0
jbe 0x99ed
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10ba0
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x98ec
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x118, %rdi            # imm = 0x118
callq 0x11060
testb $0x1, %al
jne 0x9a54
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x10720
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
subq $0x1, %rax
movl %eax, 0x1c(%rsp)
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9af2
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, (%rsp)
addq $0x88, %rdi
movslq 0x18(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x10ba0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x9a81
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x40(%rax)
jne 0xa0f3
movq 0x19ef8(%rip), %rdi     # 0x23fd8
leaq 0x11265(%rip), %rsi     # 0x1b34c
callq 0x21f0
xorl %edi, %edi
callq 0x2240
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
addq $0x88, %rdi
callq 0x11240
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x9b00
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x160, %rsi            # imm = 0x160
callq 0x9ce0
movq 0x8(%rsp), %rdi
movb $0x1, 0x41(%rdi)
callq 0xa150
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x40(%rax)
jne 0xcf7c
movq 0x1706f(%rip), %rdi     # 0x23fd8
leaq 0xe3dc(%rip), %rsi      # 0x1b34c
callq 0x21f0
xorl %edi, %edi
callq 0x2240
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
callq 0x115f0
testb $0x1, %al
jne 0xcf90
jmp 0xcfb9
movq 0x17041(%rip), %rdi     # 0x23fd8
leaq 0xe3dd(%rip), %rsi      # 0x1b37b
callq 0x21f0
movq %rax, %rdi
movq 0x1701b(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
addq $0x88, %rdi
callq 0x11240
jmp 0xcfd6
movl $0x0, 0x7c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x7c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x70, %rdi
callq 0x10a80
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xd06d
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
movslq 0x7c(%rsp), %rsi
callq 0x10b50
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5740
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc730
jmp 0xd039
leaq 0x30(%rsp), %rdi
callq 0x57b0
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xcfde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x57b0
jmp 0xd0f4
movq 0x18(%rsp), %rdi
movq 0x48(%rdi), %rax
addq $0x88, %rdi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0xd100
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x38(%rdi)
movq %rdi, %rsi
addq $0xd0, %rsi
callq 0x9710
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0x100, %rsi            # imm = 0x100
callq 0x98a0
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0x148, %rsi            # imm = 0x148
callq 0x9b00
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0x178, %rsi            # imm = 0x178
callq 0x9ce0
movq 0x18(%rsp), %rdi
movb $0x1, 0x42(%rdi)
callq 0xd170
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2350
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rdi
callq 0x5ce0
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xfd85
movq 0x14275(%rip), %rdi     # 0x23fd8
leaq 0xb814(%rip), %rsi      # 0x1b57e
callq 0x21f0
movq %rax, %rdi
movq 0x1424f(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x11ff0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x20f0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8d30
movq 0x8(%rsp), %rdi
movq 0x48(%rdi), %rax
addq $0x88, %rdi
callq *%rax
movq 0x8(%rsp), %rdi
callq 0xfe50
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
addq $0xa0, %rdi
callq 0x11240
movq 0x8(%rsp), %rdi
callq 0xd100
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x30(%rdi)
movq %rdi, %rsi
addq $0xb8, %rsi
callq 0x9710
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0xe8, %rsi
callq 0x98a0
movq 0x8(%rsp), %rdi
movb $0x1, 0x40(%rdi)
callq 0xa150
addq $0x18, %rsp
retq
nopl (%rax)
// File: mororo18[P]simplex-method/src/model.cpp
// Function: Model::tableau_print()
void Model::tableau_print(){
    for(int i = 0; i < tableau.size(); i++){
        for(int j = 0; j < tableau[i].size(); j++){
            std::cout << tableau[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xff47
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x88, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
callq 0x6420
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xff24
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movq 0x140d8(%rip), %rdi     # 0x23fd8
callq 0x2370
movq %rax, %rdi
leaq 0xb4eb(%rip), %rsi      # 0x1b3fa
callq 0x21f0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xfe9f
movq 0x140ad(%rip), %rdi     # 0x23fd8
movq 0x14096(%rip), %rsi     # 0x23fc8
callq 0x2210
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xfe6b
addq $0x28, %rsp
retq
nopl (%rax)
// File: mororo18[P]simplex-method/src/model.cpp
// Function: Model::obj_func::var_add(char*)
void Model::obj_func::var_add(char name[]){
    
    if(var_name.size() + 1 > var_qnt){
        std::cout << "Invalid OF size" << std::endl;
        exit(0);
    }

    std::string var_new (name);

    var_name.push_back(var_new);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0x5ce0
movq 0x18(%rsp), %rcx
addq $0x1, %rax
movslq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x1036b
movq 0x13c8f(%rip), %rdi     # 0x23fd8
leaq 0xafa8(%rip), %rsi      # 0x1b2f8
callq 0x21f0
movq %rax, %rdi
movq 0x13c69(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2360
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2280
jmp 0x1039a
leaq 0x37(%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
leaq 0x38(%rsp), %rsi
callq 0x11f80
jmp 0x103b9
leaq 0x38(%rsp), %rdi
callq 0x2140
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x2220
jmp 0x103fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2140
movq 0x28(%rsp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: mororo18[P]simplex-method/src/model.cpp
// Function: Model::obj_func::coef_add(double)
void Model::obj_func::coef_add(double var_coef){

    if(coef.size() + 1 > var_qnt){
        std::cout << "Invalid OF size" << std::endl;
        exit(0);
    }

    coef.push_back(var_coef);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x6420
movq (%rsp), %rcx
addq $0x1, %rax
movslq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x1046a
movq 0x13b90(%rip), %rdi     # 0x23fd8
leaq 0xaea9(%rip), %rsi      # 0x1b2f8
callq 0x21f0
movq %rax, %rdi
movq 0x13b6a(%rip), %rsi     # 0x23fc8
callq 0x2210
xorl %edi, %edi
callq 0x2240
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10ba0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)