LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::sum_cell_volumes()
double container_periodic::sum_cell_volumes() {
	voronoicell c(*this);
	double vol=0;
	c_loop_all_periodic vl(*this);
	if(vl.start()) do if(compute_cell(c,vl)) vol+=c.volume();while(vl.inc());
	return vol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r15
movsd 0x178(%rdi), %xmm0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x6c50
leaq 0x1393c(%rip), %rax     # 0x45bc8
movq %rax, (%r14)
movl 0x128(%r15), %r12d
movl 0x180(%r15), %r14d
movq 0x1b0(%r15), %rbx
movl 0x184(%r15), %r13d
movl 0x188(%r15), %eax
movl %eax, 0x1c(%rsp)
movl 0x18c(%r15), %eax
movl %eax, 0x18(%rsp)
movq %r15, 0x28(%rsp)
movl 0x190(%r15), %r15d
imull %r13d, %r15d
addl %r14d, %r15d
imull %r12d, %r15d
movl %r12d, %eax
imull %r14d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x14(%rsp)
movslq %r15d, %rax
xorl %ebp, %ebp
cmpl $0x0, (%rbx,%rax,4)
setne %al
movl %r14d, 0x10(%rsp)
jne 0x32344
xorl %eax, %eax
xorl %ebp, %ebp
incl %ebp
movl $0x1, %ecx
cmpl %r12d, %ebp
jne 0x3232e
incl %r14d
xorl %ebp, %ebp
cmpl 0x1c(%rsp), %r14d
jne 0x3232e
incl %r13d
xorl %ebp, %ebp
movl 0x10(%rsp), %r14d
movl 0x14(%rsp), %ecx
cmpl 0x18(%rsp), %r13d
je 0x3233f
addl %ecx, %r15d
movslq %r15d, %rax
cmpl $0x0, (%rbx,%rax,4)
setne %al
je 0x32301
jmp 0x32344
movl 0x10(%rsp), %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
testb $0x1, %al
je 0x32426
addq $0x1d0, 0x28(%rsp)      # imm = 0x1D0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl %r13d, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %r15d, %edx
movl 0xc(%rsp), %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x22e18
testb %al, %al
je 0x323ab
leaq 0x30(%rsp), %rdi
callq 0x84ce
movsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
movl 0xc(%rsp), %edx
incl %edx
movslq %r15d, %rcx
movb $0x1, %al
movl %edx, 0xc(%rsp)
cmpl (%rbx,%rcx,4), %edx
jl 0x32405
movl %r15d, %ecx
incl %ebp
movl $0x1, %r15d
cmpl %r12d, %ebp
jne 0x323f1
incl %r14d
xorl %ebp, %ebp
cmpl 0x1c(%rsp), %r14d
jne 0x323f1
incl %r13d
xorl %ebp, %ebp
cmpl 0x18(%rsp), %r13d
je 0x32415
movl 0x10(%rsp), %r14d
movl 0x14(%rsp), %r15d
addl %ecx, %r15d
movslq %r15d, %rcx
cmpl $0x0, (%rbx,%rcx,4)
je 0x323bf
movl $0x0, 0xc(%rsp)
movl %r15d, %ecx
movl %ecx, %r15d
testb %al, %al
jne 0x3236d
jmp 0x32426
movl 0x10(%rsp), %r14d
movl $0x0, 0xc(%rsp)
xorl %eax, %eax
jmp 0x32408
leaq 0x30(%rsp), %rdi
callq 0x6eca
movsd 0x20(%rsp), %xmm0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6eca
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::put_image(int, int, int, double, double, double)
void container_periodic_base::put_image(int reg,int fijk,int l,double dx,double dy,double dz) {
	if(co[reg]==mem[reg]) add_particle_memory(reg);
	double *p1=p[reg]+ps*co[reg],*p2=p[fijk]+ps*l;
	*(p1++)=*(p2++)+dx;
	*(p1++)=*(p2++)+dy;
	*p1=*p2+dz;
	if(ps==4) *(++p1)=*(++p2);
	id[reg][co[reg]++]=id[fijk][l];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %r15
movq 0x1b0(%rdi), %rax
movq 0x1b8(%rdi), %rcx
movl (%rax,%r15,4), %eax
cmpl (%rcx,%r15,4), %eax
jne 0x32cfe
movq %r14, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x3144a
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x1a8(%r14), %r8
movq 0x1b0(%r14), %rax
movq (%r8,%r15,8), %rdx
movslq 0x1cc(%r14), %r10
movslq (%rax,%r15,4), %rcx
movq %rcx, %rsi
imulq %r10, %rsi
movl %r10d, %r9d
imull %ebx, %r9d
movslq %ebp, %rdi
movq (%r8,%rdi,8), %r8
movslq %r9d, %r9
addsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
addsd 0x8(%r8,%r9,8), %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
addsd 0x10(%r8,%r9,8), %xmm2
movsd %xmm2, 0x10(%rdx,%rsi,8)
cmpq $0x4, %r10
jne 0x32d6b
movsd 0x18(%r8,%r9,8), %xmm0
movsd %xmm0, 0x18(%rdx,%rsi,8)
movq 0x1a0(%r14), %rdx
movq (%rdx,%rdi,8), %rsi
movslq %ebx, %rdi
movl (%rsi,%rdi,4), %esi
movq (%rdx,%r15,8), %rdx
leal 0x1(%rcx), %edi
movl %edi, (%rax,%r15,4)
movl %esi, (%rdx,%rcx,4)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/unitcell.cc
// Function: voro::unitcell::draw_domain_gnuplot(_IO_FILE*)
void unitcell::draw_domain_gnuplot(FILE *fp) {
	fprintf(fp,"0 0 0\n%g 0 0\n%g %g 0\n%g %g 0\n",bx,bx+bxy,by,bxy,by);
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",bxy+bxz,by+byz,bz,bx+bxy+bxz,by+byz,bz,bx+bxz,byz,bz,bxz,byz,bz);
	fprintf(fp,"0 0 0\n%g %g 0\n\n%g %g %g\n%g %g %g\n\n",bxy,by,bxz,byz,bz,bxy+bxz,by+byz,bz);
	fprintf(fp,"%g 0 0\n%g %g %g\n\n%g %g 0\n%g %g %g\n\n",bx,bx+bxz,byz,bz,bx+bxy,by,bx+bxy+bxz,by+byz,bz);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm3
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd 0x10(%rdi), %xmm2
leaq 0x78fd(%rip), %rsi      # 0x3d5e9
movq %rbx, %rdi
movaps %xmm2, %xmm4
movb $0x5, %al
callq 0x21b0
movsd (%r14), %xmm6
movsd 0x8(%r14), %xmm3
movsd 0x18(%r14), %xmm4
movapd %xmm3, %xmm0
addsd %xmm4, %xmm0
movsd 0x20(%r14), %xmm7
movsd 0x10(%r14), %xmm1
addsd %xmm7, %xmm1
movsd 0x28(%r14), %xmm2
addsd %xmm6, %xmm3
addsd %xmm4, %xmm3
addsd %xmm4, %xmm6
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x3436(%rip), %rsi      # 0x39188
movq %rbx, %rdi
movapd %xmm1, %xmm4
movaps %xmm2, %xmm5
movb $0x8, %al
callq 0x21b0
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x18(%r14), %xmm2
movsd 0x20(%r14), %xmm3
movsd 0x28(%r14), %xmm4
movapd %xmm0, %xmm5
addsd %xmm2, %xmm5
movapd %xmm1, %xmm6
addsd %xmm3, %xmm6
leaq 0x786f(%rip), %rsi      # 0x3d607
movq %rbx, %rdi
movaps %xmm4, %xmm7
movb $0x8, %al
callq 0x21b0
movsd 0x18(%r14), %xmm6
movsd (%r14), %xmm0
movsd 0x10(%r14), %xmm5
movapd %xmm0, %xmm1
addsd %xmm6, %xmm1
movsd 0x20(%r14), %xmm2
movsd 0x28(%r14), %xmm3
movsd 0x8(%r14), %xmm4
addsd %xmm0, %xmm4
addsd %xmm4, %xmm6
movapd %xmm2, %xmm7
addsd %xmm5, %xmm7
movsd %xmm3, (%rsp)
leaq 0x783e(%rip), %rsi      # 0x3d62a
movq %rbx, %rdi
movb $0x8, %al
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/operators.h
// Function: operator==(Object, Object)
bool operator ==(Object a, Object b) {
	if (a.s->type == UNDEFINED && b.s->type == UNDEFINED) {
		return true;
	}
	if (a.s->type == NUMBER && b.s->type == NUMBER) {
		return a.s->n == b.s->n;
	}
	if (a.s->type == STRING && b.s->type == STRING) {
		return a.s->s == b.s->s;
	}
	return a.s == b.s;
}

// Assembly:
movq 0x10(%rdi), %rcx
movl 0x38(%rcx), %edx
testl %edx, %edx
je 0x567d
cmpl $0x1, %edx
je 0x568c
cmpl $0x3, %edx
jne 0x56bd
movq 0x10(%rsi), %rdi
movb $0x1, %al
cmpl $0x3, 0x38(%rdi)
je 0x56bc
cmpl $0x1, %edx
je 0x568c
testl %edx, %edx
jne 0x56bd
movq 0x10(%rsi), %rax
cmpl $0x0, 0x38(%rax)
je 0x56c5
cmpl $0x1, %edx
jne 0x56bd
movq 0x10(%rsi), %rax
cmpl $0x1, 0x38(%rax)
jne 0x56bd
movq 0x50(%rcx), %rdx
cmpq 0x50(%rax), %rdx
jne 0x56d9
testq %rdx, %rdx
je 0x56dc
pushq %rax
movq 0x48(%rax), %rsi
movq 0x48(%rcx), %rdi
callq 0x21c0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
cmpq 0x10(%rsi), %rcx
sete %al
retq
movsd 0x40(%rax), %xmm0
cmpeqsd 0x40(%rcx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/operators.h
// Function: Object::operator[](Object)
Object& Object::operator[](Object key) {
	std::string key_str = key.toString();
	Object& ret = get_key(key_str);
	ret.self = this;
	ret.write = &s->map[key_str];
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x256e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x9a7c
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6200
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x617e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %r14, (%rbx)
movq 0x10(%r14), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9194
movq %rax, 0x8(%rbx)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61b2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x61dd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x61dd
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61f8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/operators.h
// Function: Object::get_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Object& Object::get_key(std::string key) {
	Object& ret = s->map[key];
	if (ret == undefined && s->map["__proto__"] != undefined) {
		return s->map["__proto__"].get_key(key);
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
addq $0x8, %rdi
callq 0x9194
movq %rax, %r14
movq (%rax), %rax
leaq 0x80(%rsp), %rdi
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rdi)
incl (%rax)
movq 0x8f46(%rip), %rax      # 0xf190
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x8f43(%rip), %rax      # 0xf1a0
movq %rax, 0x10(%rsi)
incl (%rax)
callq 0x5653
movl %eax, %ebp
testb %al, %al
je 0x62ed
movq 0x10(%r15), %r12
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4f19(%rip), %rsi      # 0xb19b
leaq 0x4f1b(%rip), %rdx      # 0xb1a4
leaq 0x48(%rsp), %rdi
callq 0x9b0c
addq $0x8, %r12
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x9210
movq (%rax), %rcx
leaq 0xb0(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdi, 0x8(%rdi)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
incl (%rax)
movq 0x8ec9(%rip), %rax      # 0xf190
leaq 0x98(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x8ec3(%rip), %rax      # 0xf1a0
movq %rax, 0x10(%rsi)
incl (%rax)
callq 0x56df
movl %eax, %r12d
jmp 0x62f0
xorl %r12d, %r12d
testb %bpl, %bpl
je 0x632a
leaq 0x98(%rsp), %rdi
callq 0x9092
leaq 0xb0(%rsp), %rdi
callq 0x9092
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x632a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21b0
leaq 0x68(%rsp), %rdi
callq 0x9092
leaq 0x80(%rsp), %rdi
callq 0x9092
testb %r12b, %r12b
je 0x63df
movq 0x10(%r15), %r14
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4e3d(%rip), %rsi      # 0xb19b
leaq 0x4e3f(%rip), %rdx      # 0xb1a4
leaq 0x28(%rsp), %rdi
callq 0x9b0c
addq $0x8, %r14
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x9210
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x9a7c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6200
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x63c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x63df
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6450
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x6450
movq %rax, %rbx
jmp 0x6467
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x6434
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x6434
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x9092
leaq 0x80(%rsp), %rdi
callq 0x9092
jmp 0x6467
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6467
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/constructors.h
// Function: Object::operator|=(Object)
Object& Object::operator|= (Object o) {
	write->s->refcount += 1;
	
	write->s->type = o.s->type;
	write->s->s = o.s->s;
	write->s->n = o.s->n;
	write->s->map = o.s->map;
	write->s->kv = o.s->kv;

	write->s->f = o.s->f;
	write->s->f0 = o.s->f0;
	write->s->f1 = o.s->f1;
	write->s->f2 = o.s->f2;
	write->s->f3 = o.s->f3;
	write->s->f4 = o.s->f4;
	write->s->f5 = o.s->f5;

	return *write;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
incl (%rdi)
movq 0x10(%rsi), %rsi
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x2100
movq 0x10(%r14), %rsi
movsd 0x40(%rsi), %xmm0
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
movsd %xmm0, 0x40(%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x963e
movq 0x10(%r14), %rsi
movq 0x130(%rsi), %rax
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rdi
movq %rax, 0x130(%rdi)
movl 0x68(%rsi), %eax
movl %eax, 0x68(%rdi)
addq $0x70, %rsi
addq $0x70, %rdi
callq 0x928c
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x92fa
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x9368
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x93d6
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x9444
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x94b2
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/constructors.h
// Function: New(Object)
Object New(Object o) {
	Object n;

	n.s->type = FUNCTION;
	n.s->f = o.s->f;
	n.s->f0 = o.s->f0;
	n.s->f1 = o.s->f1;
	n.s->f2 = o.s->f2;
	n.s->f3 = o.s->f3;
	n.s->f4 = o.s->f4;
	n.s->f5 = o.s->f5;

	n.self = &n;
	n["__proto__"] = o["prototype"];

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x83ee(%rip), %rax      # 0xf190
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movl $0x138, %edi            # imm = 0x138
callq 0x21a0
movq %rax, %r15
movl $0x1, (%rax)
addq $0x10, %rax
movl $0x0, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %rcx, 0x30(%r15)
leaq 0x58(%r15), %rax
movq %rax, 0x48(%r15)
movq %rcx, 0x50(%r15)
movb $0x0, 0x58(%r15)
leaq 0x70(%r15), %r12
movl $0xc0, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
movq %r15, 0x10(%rbx)
movl $0x2, 0x38(%r15)
movq 0x10(%r14), %rsi
movl 0x68(%rsi), %eax
movl %eax, 0x68(%r15)
addq $0x70, %rsi
movq %r12, %rdi
callq 0x928c
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x92fa
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x9368
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x93d6
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x9444
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x94b2
movq %rbx, (%rbx)
leaq 0x4311(%rip), %rsi      # 0xb1a5
leaq 0x18(%rsp), %rdi
callq 0x67a4
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x6126
movq (%rax), %rcx
leaq 0x30(%rsp), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rdx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdx)
incl (%rax)
leaq 0x42d0(%rip), %rsi      # 0xb19b
movq %rsp, %rdi
callq 0x67a4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6126
leaq 0x30(%rsp), %r14
movq 0x10(%r14), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
incl (%rcx)
movq %rsp, %rdi
callq 0x9092
movq %r14, %rdi
callq 0x9092
leaq 0x18(%rsp), %rdi
callq 0x9092
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x9092
jmp 0x6f2a
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x9092
jmp 0x6f39
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x9092
jmp 0x6f48
movq %rax, %r14
movq %rbx, %rdi
callq 0x9092
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/../src/object.h
// Function: Object::~Object()
~Object() {
		if (s->refcount == 1) {
			delete s;
		} else {
			s->refcount -= 1;
		}
	}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x917c
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x90bf
leaq 0x110(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x100(%rbx), %rax
testq %rax, %rax
je 0x90dc
leaq 0xf0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe0(%rbx), %rax
testq %rax, %rax
je 0x90f9
leaq 0xd0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xc0(%rbx), %rax
testq %rax, %rax
je 0x9116
leaq 0xb0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa0(%rbx), %rax
testq %rax, %rax
je 0x9133
leaq 0x90(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x914d
leaq 0x70(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x9165
movq (%rax), %rsi
incq %rsi
callq 0x21b0
leaq 0x8(%rbx), %rdi
callq 0x95ba
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
popq %rbx
jmp 0x21b0
decl %eax
movl %eax, (%rbx)
popq %rbx
retq
jmp 0x918c
jmp 0x918c
jmp 0x918c
jmp 0x918c
jmp 0x918c
movq %rax, %rdi
callq 0x95af
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment1.hpp
// Function: assignment1::scheduling_problem::computeScoreDiff(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int>>> const&)
std::vector<std::tuple<int, job>> computeScoreDiff(const std::vector<job>& jobs)
        {
            std::vector<std::tuple<int, job>> scores;	// we'll assign score for each job

            for (auto job : jobs)
            {
                int score = std::get<0>(job) - std::get<1>(job);
                scores.push_back(std::make_tuple(score, job));
            }

            return scores;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x27b2
leaq 0x8(%rsp), %r14
movq (%r15), %rax
movq %rax, %rcx
shrq $0x20, %rcx
subl %eax, %ecx
movq %rax, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaf7a
addq $0x8, %r15
cmpq %r12, %r15
jne 0x2789
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27d1
callq 0x2200
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment1.hpp
// Function: assignment1::scheduling_problem::computeScoreRatio(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int>>> const&)
std::vector<std::tuple<double, job>> computeScoreRatio(const std::vector<job>& jobs)
        {
            std::vector<std::tuple<double, job>> scores;	// we'll assign score for each job

            for (auto job : jobs)
            {
                double score = (double)std::get<0>(job) / std::get<1>(job);	// wj / lj
                scores.push_back(std::make_tuple(score, job));
            }

            return scores;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x2840
leaq 0x8(%rsp), %r14
movq (%r15), %rax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %rax, 0x8(%rsp)
shrq $0x20, %rax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb124
addq $0x8, %r15
cmpq %r12, %r15
jne 0x2808
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x285f
callq 0x2200
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment1.hpp
// Function: assignment1::scheduling_problem::schedule_by_difference(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int>>> const&)
long long schedule_by_difference(const std::vector<job>& jobs)
        {
            auto scores = computeScoreDiff(jobs);
            // schedule jobs by decreasing value of scores
            std::sort(scores.begin(), scores.end(), [](std::tuple<int, job> a, std::tuple<int, job> b)
            {
                return a > b;
            });

            long long weighted_sum = 0;
            int total_length = 0;

            for (auto sorted_jobs : scores)	// we get the job
            {
                auto job = std::get<1>(sorted_jobs);
                total_length += std::get<1>(job);
                weighted_sum += std::get<0>(job) * total_length;	// wj*cj
            }

            return weighted_sum;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x275c
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x28f8
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7831
cmpq $0xc1, %r15
jl 0x28ed
leaq 0xc0(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c8f
cmpq %rbx, %r15
je 0x28f8
movq %r15, %rdi
callq 0x7d69
addq $0xc, %r15
jmp 0x28da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7c8f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x2929
movq %rdi, %rdx
movq (%rdx), %rsi
addl %esi, %ecx
shrq $0x20, %rsi
imull %ecx, %esi
movslq %esi, %rsi
addq %rsi, %rbx
addq $0xc, %rdx
cmpq %rax, %rdx
jne 0x290e
testq %rdi, %rdi
je 0x2933
callq 0x2200
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment1.hpp
// Function: assignment1::scheduling_problem::schedule_by_ratio(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int>>> const&)
long long schedule_by_ratio(const std::vector<job>& jobs)
        {
            auto scores = computeScoreRatio(jobs);
            // schedule jobs by decreasing value of scores
            std::sort(scores.begin(), scores.end(), [](std::tuple<double, job> a, std::tuple<double, job> b)
            {
                return a > b;
            });

            long long weighted_sum = 0;
            int total_length = 0;

            for (auto sorted_jobs : scores)	// we get the job
            {
                auto job = std::get<1>(sorted_jobs);
                total_length += std::get<1>(job);
                weighted_sum += std::get<0>(job) * total_length;	// wj*cj
            }

            return weighted_sum;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x27d9
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x29c3
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7da3
cmpq $0x101, %r15            # imm = 0x101
jl 0x29b8
leaq 0x100(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x822e
cmpq %rbx, %r15
je 0x29c3
movq %r15, %rdi
callq 0x82f7
addq $0x10, %r15
jmp 0x29a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x822e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x29f4
movq %rdi, %rdx
movq (%rdx), %rsi
addl %esi, %ecx
shrq $0x20, %rsi
imull %ecx, %esi
movslq %esi, %rsi
addq %rsi, %rbx
addq $0x10, %rdx
cmpq %rax, %rdx
jne 0x29d9
testq %rdi, %rdi
je 0x29fe
callq 0x2200
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::TestCase2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TestCase2(const std::string inputFile)
    {
        std::ifstream file(inputFile, std::ios::in);

        if (file.is_open())
        {
            int n, x, y;
            file >> n;
            UnionFind uf(n);

            while (file >> x >> y)
            {
                uf.Union(x, y);
            }
            file.close();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rsi
leaq 0x30(%rsp), %rdi
movl $0x8, %edx
callq 0x2300
leaq 0xa8(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x3820
leaq 0x30(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x2160
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x8a78
leaq 0x30(%rsp), %rbx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x380c
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movq %r12, %rdi
callq 0x8b72
jmp 0x37d6
leaq 0x30(%rsp), %rdi
callq 0x2090
leaq 0x18(%rsp), %rdi
callq 0x8bba
leaq 0x30(%rsp), %rdi
callq 0x20c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3842
jmp 0x383d
movq %rax, %rbx
jmp 0x384f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8bba
leaq 0x30(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment2.hpp
// Function: assignment2::clustering_big::generateHammingDistances(int, int)
std::vector<int> generateHammingDistances(int numBits, int d)
        {
            std::vector<int> distances;
            // we're interested only in 1 and 2 edge weights
            if (d == 1)
            {
                int dist = 1;
                for (int i = 0; i < numBits; i++)
                {
                    distances.push_back(dist);
                    dist = dist << 1;
                }
            }
            if (d == 2)
            {
                int dist = 1; // 000...001
                int mask = 1; // 000...001
                for (int i = 0; i < numBits; i++)
                {
                    for (int j = i + 1; j < numBits; j++)
                    {
                        dist = mask | (1 << j);
                        distances.push_back(dist);
                    }
                    mask = mask << 1;
                }
            }

            return distances;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x2, %edx
je 0x3c1a
movl %edx, %r14d
cmpl $0x1, %edx
jne 0x3c7b
movl $0x1, (%rsp)
testl %ebp, %ebp
jle 0x3c14
movq %rsp, %r15
movl %ebp, %r12d
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3c01
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3c0c
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb8d2
shll (%rsp)
decl %r12d
jne 0x3be8
cmpl $0x2, %r14d
jne 0x3c7b
movl $0x1, 0x4(%rsp)
testl %ebp, %ebp
jle 0x3c7b
movl $0x1, %r15d
xorl %r12d, %r12d
leaq 0x4(%rsp), %r14
incl %r12d
movl %r12d, %r13d
cmpl %ebp, %r12d
jge 0x3c73
movl %r15d, %eax
btsl %r13d, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3c60
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3c6b
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb8d2
incl %r13d
cmpl %r13d, %ebp
jne 0x3c3f
addl %r15d, %r15d
cmpl %ebp, %r12d
jne 0x3c34
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c8f
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c9f
callq 0x2200
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::read_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int&)
void read_file(const std::string& fileName, std::vector<int>& values, std::vector<int>& weights, int& W)
    {
        PROFILE("Read file for " + fileName);
        std::ifstream file(fileName, std::ios::in);
        if (file.is_open())
        {
            int n;
            file >> W >> n; // knapsack size, number of items

            int v, w;
            while (file >> v >> w)
            {
                values.push_back(v);
                weights.push_back(w);
            }
            file.close();
        }
        PROFILE_STOP();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x88b8
movq %rax, %r13
leaq 0x99ff(%rip), %rsi      # 0xe58d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rdx
callq 0x8c8e
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8904
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bbc
callq 0x2200
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x2300
leaq 0x88(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x4c86
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2160
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4c7c
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x4c4a
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x4c55
movq %r14, %rdi
movq %r12, %rdx
callq 0xb8d2
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4c6f
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4c0c
movq %rbx, %rdi
movq %r13, %rdx
callq 0xb8d2
jmp 0x4c0c
leaq 0x10(%rsp), %rdi
callq 0x2090
callq 0x88b8
movq %rax, %rdi
callq 0x894e
leaq 0x10(%rsp), %rdi
callq 0x20c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ccd
jmp 0x4ccd
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cda
callq 0x2200
jmp 0x4cda
jmp 0x4ccd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_1::testCase1()
bool testCase1()
        {
            std::vector<int> test_v = { 3,2,4,4 };
            std::vector<int> test_wt = { 4,3,2,3 };
            int test_W = 6;
            int optimal_value = knapsack(test_v, test_wt, test_W);

            assert(optimal_value == 8);
            return true;
        }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movaps 0x9285(%rip), %xmm0     # 0xe0d0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x8770
movaps 0x926f(%rip), %xmm0     # 0xe0e0
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
callq 0x8770
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x6, %edx
callq 0x4ce2
cmpl $0x8, %eax
jne 0x4ecc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4eb5
callq 0x2200
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4ec4
callq 0x2200
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0x975a(%rip), %rdi      # 0xe62d
leaq 0x96e2(%rip), %rsi      # 0xe5bc
leaq 0x975f(%rip), %rcx      # 0xe640
movl $0x6d, %edx
callq 0x2170
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4f02
callq 0x2200
jmp 0x4f02
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f11
callq 0x2200
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_big::knapsack_rec_memoization(int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
int knapsack_rec_memoization(int n, std::vector<int>& values, std::vector<int>& weights, const int W)
        {
            if (saved.count(W) > 0)
            {
                for (auto el : saved[W])
                {
                    if (std::get<0>(el) == n)   // if we have item's value for the given W and item number, let's return it
                        return std::get<1>(el);
                }
            }
            int withLastItem = -1;
            int withoutLastItem = -1;
            if (n <= 0)
                return 0;
           
            if (W < weights[n-1]) // last item
                withLastItem = -1;
            else
            {
                withLastItem = values[n - 1] + knapsack_rec_memoization(n - 1, values, weights, W - weights[n - 1]);
            }
            withoutLastItem = knapsack_rec_memoization(n - 1, values, weights, W);
            saved[W].push_back(std::make_tuple(n, std::max(withLastItem, withoutLastItem)));
            return std::max(withLastItem, withoutLastItem);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
leaq 0xc(%rsp), %rsi
movl %ecx, (%rsi)
leaq 0x10177(%rip), %rdi     # 0x15200
callq 0xc19c
testq %rax, %rax
je 0x50e9
leaq 0x10166(%rip), %rdi     # 0x15200
leaq 0xc(%rsp), %rsi
callq 0xc216
movq (%rax), %rcx
movq 0x8(%rax), %rdx
cmpq %rdx, %rcx
sete %al
je 0x50e5
movq (%rcx), %r12
movq %r12, %rsi
shrq $0x20, %rsi
cmpl %ebx, %esi
je 0x50e5
addq $0x8, %rcx
cmpq %rdx, %rcx
sete %al
je 0x50e5
movq (%rcx), %rsi
movq %rsi, %rdi
shrq $0x20, %rdi
addq $0x8, %rcx
cmpl %ebx, %edi
cmovel %esi, %r12d
jne 0x50c5
jmp 0x50e5
testb %al, %al
je 0x5168
testl %ebx, %ebx
jle 0x5165
movl 0xc(%rsp), %ecx
leal -0x1(%rbx), %r12d
movq (%r14), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl (%rax,%r12,4), %ecx
jl 0x5120
movslq %r12d, %rdi
movq (%r15), %rdx
movl (%rdx,%rdi,4), %r13d
subl (%rax,%rdi,4), %ecx
movq %r15, %rsi
movq %r14, %rdx
callq 0x5065
movl %eax, %ebp
addl %r13d, %ebp
leaq 0xc(%rsp), %r13
movl (%r13), %ecx
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5065
movl %eax, %r12d
leaq 0x100bf(%rip), %rdi     # 0x15200
movq %r13, %rsi
callq 0xc216
cmpl %r12d, %ebp
cmovgl %ebp, %r12d
leaq 0x10(%rsp), %rsi
movl %r12d, (%rsi)
movl %ebx, 0x4(%rsi)
movq %rax, %rdi
callq 0xc4ce
jmp 0x5168
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_big::testCase1()
bool testCase1()
        {
            std::vector<int> test_v = { 3,2,4,4 };
            std::vector<int> test_wt = { 4,3,2,3 };
            int test_W = 6;
            int optimal_value = knapsack_smallArray(test_v, test_wt, test_W); //knapsack_rec_memoization(4, test_v, test_wt, test_W);

            assert(optimal_value == 8);
            return true;
        }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movaps 0x8e1c(%rip), %xmm0     # 0xe0d0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x8770
movaps 0x8e06(%rip), %xmm0     # 0xe0e0
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
callq 0x8770
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x6, %edx
callq 0x517a
cmpl $0x8, %eax
jne 0x5335
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x531e
callq 0x2200
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x532d
callq 0x2200
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0x92f1(%rip), %rdi      # 0xe62d
leaq 0x9279(%rip), %rsi      # 0xe5bc
leaq 0x9353(%rip), %rcx      # 0xe69d
movl $0xe7, %edx
callq 0x2170
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x536b
callq 0x2200
jmp 0x536b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x537a
callq 0x2200
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::load_graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int load_graph(const std::string& fileName)
    {
        if (!g.empty())
            g.clear();

        std::fstream file(fileName, std::ios::in);
        int n, m;
        
        if (file.is_open())
        {
            file >> n >> m;
            int source, dest, cost;
            while (file >> source >> dest >> cost)
            {
                g[source].push_back(std::make_pair(dest, cost));
            }
            file.close();
        }
        return n;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
cmpq $0x0, 0xf92f(%rip)      # 0x15250
je 0x592f
leaq 0xf90e(%rip), %rdi      # 0x15238
callq 0xa670
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x2340
leaq 0xa8(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x5a0b
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x2160
leaq 0x24(%rsp), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x28(%rsp), %rbx
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0xf8ab(%rip), %r13      # 0x15238
leaq 0x18(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5a01
movq %r13, %rdi
movq %r14, %rsi
callq 0xc7a4
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x59f4
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x5992
movq %rax, %rdi
movq %rbp, %rdx
callq 0xcaa2
jmp 0x5992
leaq 0x28(%rsp), %rdi
callq 0x2050
movl 0x14(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a33
jmp 0x5a33
jmp 0x5a33
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::ijConnected(int, int, std::unordered_map<int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>> const&, int&)
bool ijConnected(int i, int j, const Graph& graph, int& cst)
    {
        std::vector<std::pair<int, int>> neighbors = graph.at(i);
        for (const auto& n : neighbors)
        {
            if (n.first == j)
            {
                cst = n.second;
                return true;
            }
        }
        cst = 0;   // assuming no loops are permitted, we return 0 if they are not connected!
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %esi, %r14d
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movq %rdx, %rdi
callq 0xcbe0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x8f44
movq (%r15), %rdi
movq 0x8(%r15), %rcx
xorl %eax, %eax
cmpq %rcx, %rdi
setne %bpl
je 0x5ab1
movq %rdi, %rdx
cmpl %r14d, (%rdi)
je 0x5aae
leaq 0x8(%rdi), %rsi
cmpq %rcx, %rsi
setne %bpl
je 0x5ab1
leaq 0x8(%rsi), %rdx
cmpl %r14d, (%rsi)
movq %rdx, %rsi
jne 0x5a95
addq $-0x8, %rdx
movl 0x4(%rdx), %eax
movl %eax, (%rbx)
testq %rdi, %rdi
je 0x5abd
callq 0x2200
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment4.hpp
// Function: assignment4::run_algorithm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_algorithm(const std::string& fileName)
    {
        int n = load_graph(fileName);
        int shortest_shortest_path = INT32_MAX;
        if (floyd_warshall(assignment4::g, n, shortest_shortest_path))
        {
            std::cout << "Shortest of all shortest paths is: " << shortest_shortest_path << std::endl;
            assert(shortest_shortest_path == -19);
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x5905
leaq 0x4(%rsp), %rdx
movl $0x7fffffff, (%rdx)     # imm = 0x7FFFFFFF
leaq 0xf380(%rip), %rdi      # 0x15238
movl %eax, %esi
callq 0x5aca
testb %al, %al
je 0x5f1b
movq 0xf10e(%rip), %rbx      # 0x14fd8
leaq 0x89a0(%rip), %rsi      # 0xe871
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2250
movl 0x4(%rsp), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2350
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
cmpl $-0x13, %ebp
jne 0x5f22
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x896c(%rip), %rdi      # 0xe895
leaq 0x8983(%rip), %rsi      # 0xe8b3
leaq 0x898e(%rip), %rcx      # 0xe8c5
movl $0xa2, %edx
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment6.hpp
// Function: assignment6::DFSFillStack(std::unordered_map<int, std::vector<int, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
void DFSFillStack(Graph& g, int u)
    {
        _explored[u] = true;           // mark  as seen

        // for every edge (s, v)
        for (int v : g[u])
        {
            if (!_explored[v])   // if v is not yet explored
            {
                DFSFillStack(g, v);
            }
        }
        _S.push(u);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %esi, (%r14)
leaq 0xf03a(%rip), %rdi      # 0x152c0
movq %r14, %rsi
callq 0xbd5a
movb $0x1, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd514
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x62e1
leaq 0xf011(%rip), %r14      # 0x152c0
leaq 0x8(%rsp), %r15
movl (%r12), %eax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd5a
cmpb $0x0, (%rax)
jne 0x62d8
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x6267
addq $0x4, %r12
cmpq %r13, %r12
jne 0x62b4
movq 0xefb8(%rip), %rax      # 0x152a0
movq 0xefc1(%rip), %rcx      # 0x152b0
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x630b
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xef97(%rip)      # 0x152a0
jmp 0x631c
leaq 0xef5e(%rip), %rdi      # 0x15270
leaq 0xc(%rsp), %rsi
callq 0xd6aa
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./assignment6.hpp
// Function: assignment6::DFSSCC(std::unordered_map<int, std::vector<int, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int, std::vector<int, std::allocator<int>>&)
void DFSSCC(Graph& g, int u, std::vector<int>& scc)
    {
        _explored[u] = true;           // mark  as seen

        // for every edge (u, v)
        for (int v : g[u])
        {
            if (!_explored[v])   // if v is not yet explored
            {
                DFSSCC(g, v, scc);
            }
        }
        scc.push_back(u);   // add node to scc
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0xef76(%rip), %rdi      # 0x152c0
movq %r15, %rsi
callq 0xbd5a
movb $0x1, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd514
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x63a4
leaq 0xef4d(%rip), %r15      # 0x152c0
movq %rsp, %r12
movl (%r13), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xbd5a
cmpb $0x0, (%rax)
jne 0x639b
movl (%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x632a
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x6376
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x63be
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x63cb
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xb8d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./lib/profile.hpp
// Function: tools::Profile::stop()
void stop()
        {
            _end = std::chrono::steady_clock::now();
            _duration = std::chrono::duration_cast<std::chrono::milliseconds>(_end - _startTimes.top()).count();
            _startTimes.pop();

            std::cout << "[PROFILE] " << _profileNames.top() << " took " << _duration << "ms" << " to run." << std::endl;
            _profileNames.pop();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2290
movq %rax, 0x8(%rbx)
leaq 0x68(%rbx), %rdi
movq 0x98(%rbx), %rcx
cmpq 0xa0(%rbx), %rcx
jne 0x8983
movq 0xb0(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movq -0x8(%rcx), %rcx
subq %rcx, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rbx)
callq 0xa49c
movq 0xc623(%rip), %rdi      # 0x14fd8
leaq 0x63f6(%rip), %rsi      # 0xedb2
movl $0xa, %edx
callq 0x2250
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x89dd
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x18(%rbx), %r14
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq 0xc5e8(%rip), %rdi      # 0x14fd8
callq 0x2250
movq %rax, %r15
leaq 0x63be(%rip), %rsi      # 0xedbd
movl $0x6, %edx
movq %rax, %rdi
callq 0x2250
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x5dae(%rip), %rsi      # 0xe7d0
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
leaq 0x638e(%rip), %rsi      # 0xedc4
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2190
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
nop
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::UnionFind::UnionFind(int)
UnionFind(int n)
        {
           // _parent.resize(n);
           // _rank.resize(n);
            _parent = new int[n];
            _rank = new int[n];

            _count = n;

            for (int i = 0; i < n; i++)
            {
                _parent[i] = i;
                _rank[i] = 0;
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movslq %esi, %r13
leaq (,%r13,4), %rax
testl %r13d, %r13d
movq $-0x1, %r12
cmovnsq %rax, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, (%r15)
movq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%r15)
movl %r13d, 0x10(%r15)
testl %r13d, %r13d
jle 0x8b67
movl %ebx, %r12d
leaq (,%r12,4), %rdx
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
callq 0x2140
incl %ebx
andl $-0x2, %ebx
decq %r12
movq %r12, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x5578(%rip), %xmm1     # 0xe070
movdqa 0x5580(%rip), %xmm2     # 0xe080
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x5580(%rip), %xmm4     # 0xe090
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %eax
notl %eax
testb $0x1, %al
je 0x8b44
movl %r15d, (%r14,%r15,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %eax
testb $0x1, %al
je 0x8b5a
leal 0x1(%r15), %eax
movl %eax, 0x4(%r14,%r15,4)
addq $0x2, %r15
paddq %xmm4, %xmm1
cmpq %r15, %rbx
jne 0x8b10
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop