LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::check_compartmentalized()
void container_periodic_base::check_compartmentalized() {
	int c,l,i,j,k;
	double mix,miy,miz,max,may,maz,*pp;
	for(k=l=0;k<oz;k++) for(j=0;j<oy;j++) for(i=0;i<nx;i++,l++) if(mem[l]>0) {

		// Compute the block's bounds, adding in a small tolerance
		mix=i*boxx-tolerance;max=mix+boxx+tolerance;
		miy=(j-ey)*boxy-tolerance;may=miy+boxy+tolerance;
		miz=(k-ez)*boxz-tolerance;maz=miz+boxz+tolerance;

		// Print entries for any particles that lie outside the block's
		// bounds
		for(pp=p[l],c=0;c<co[l];c++,pp+=ps) if(*pp<mix||*pp>max||pp[1]<miy||pp[1]>may||pp[2]<miz||pp[2]>maz)
			printf("%d %d %d %d %f %f %f %f %f %f %f %f %f\n",
			       id[l][c],i,j,k,*pp,pp[1],pp[2],mix,max,miy,may,miz,maz);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %rdi, 0x40(%rsp)
cmpl 0x194(%rdi), %ebp
jge 0x2b63b
xorl %r12d, %r12d
cmpl 0x190(%rdi), %r12d
jge 0x2b634
movslq %ebx, %rbx
xorl %r13d, %r13d
cmpl 0x128(%rdi), %r13d
jge 0x2b62c
movq 0x1b8(%rdi), %rax
cmpl $0x0, (%rax,%rbx,4)
jle 0x2b621
cvtsi2sd %r13d, %xmm3
movsd 0x140(%rdi), %xmm2
movsd 0x148(%rdi), %xmm4
mulsd %xmm2, %xmm3
movsd 0xa0f4(%rip), %xmm0     # 0x355c0
addsd %xmm0, %xmm3
addsd %xmm3, %xmm2
movl %r12d, %eax
subl 0x180(%rdi), %eax
movsd 0x3b23(%rip), %xmm1     # 0x2f008
addsd %xmm1, %xmm2
movsd %xmm2, 0x30(%rsp)
cvtsi2sd %eax, %xmm2
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
addsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x20(%rsp)
movl %ebp, %eax
subl 0x184(%rdi), %eax
cvtsi2sd %eax, %xmm2
movsd 0x150(%rdi), %xmm4
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
addsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x10(%rsp)
movq 0x1a8(%rdi), %rax
movq (%rax,%rbx,8), %r15
xorl %r14d, %r14d
movsd %xmm3, 0x38(%rsp)
movq 0x1b0(%rdi), %rax
movslq (%rax,%rbx,4), %rax
cmpq %rax, %r14
jge 0x2b621
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
ucomisd %xmm0, %xmm3
ja 0x2b5ae
ucomisd 0x30(%rsp), %xmm0
ja 0x2b5ae
movsd 0x28(%rsp), %xmm2
ucomisd %xmm1, %xmm2
ja 0x2b5ae
ucomisd 0x20(%rsp), %xmm1
ja 0x2b5ae
movsd 0x10(%r15), %xmm2
movsd 0x18(%rsp), %xmm4
ucomisd %xmm2, %xmm4
ja 0x2b5ae
ucomisd 0x10(%rsp), %xmm2
jbe 0x2b60e
movq 0x1a0(%rdi), %rax
movq (%rax,%rbx,8), %rax
movl (%rax,%r14,4), %esi
movsd 0x10(%r15), %xmm2
movsd 0x10(%rsp), %xmm4
movsd %xmm4, (%rsp)
leaq 0x9ff3(%rip), %rdi      # 0x355c8
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x38(%rsp), %xmm3
movsd 0x30(%rsp), %xmm4
movsd 0x28(%rsp), %xmm5
movsd 0x20(%rsp), %xmm6
movsd 0x18(%rsp), %xmm7
movb $0x8, %al
callq 0x2040
movsd 0x38(%rsp), %xmm3
movq 0x40(%rsp), %rdi
incq %r14
movslq 0x1cc(%rdi), %rax
leaq (%r15,%rax,8), %r15
jmp 0x2b553
incl %r13d
incq %rbx
jmp 0x2b48d
incl %r12d
jmp 0x2b47a
incl %ebp
jmp 0x2b46b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq 0x1b0(%rdi), %rax
movq 0x1b8(%rdi), %rdx
movslq %esi, %r14
movl (%rax,%r14,4), %ecx
cmpl (%rdx,%r14,4), %ecx
jne 0x2b9a8
movq %r15, %rdi
movl %r14d, %esi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x2a822
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x1b0(%r15), %rax
movl (%rax,%r14,4), %ecx
movq 0x1a8(%r15), %r8
movq (%r8,%r14,8), %rdx
movl 0x1cc(%r15), %r10d
movl %ecx, %esi
imull %r10d, %esi
movslq %esi, %rdi
movslq %ebp, %rsi
movq (%r8,%rsi,8), %r8
movl %r10d, %r9d
imull %ebx, %r9d
movslq %r9d, %r9
addsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
addsd 0x8(%r8,%r9,8), %xmm1
movsd %xmm1, 0x8(%rdx,%rdi,8)
addsd 0x10(%r8,%r9,8), %xmm2
movsd %xmm2, 0x10(%rdx,%rdi,8)
cmpl $0x4, %r10d
jne 0x2ba0c
movsd 0x18(%r8,%r9,8), %xmm0
movsd %xmm0, 0x18(%rdx,%rdi,8)
movq 0x1a0(%r15), %rdx
movq (%rdx,%rsi,8), %rsi
movslq %ebx, %rdi
movl (%rsi,%rdi,4), %esi
movq (%rdx,%r14,8), %rdx
leal 0x1(%rcx), %edi
movl %edi, (%rax,%r14,4)
movslq %ecx, %rax
movl %esi, (%rdx,%rax,4)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_all_periodic::start()
inline bool start() {
			i=0;
			j=ey;
			k=ez;
			ijk=ijk0;
			q=0;
			while(co[ijk]==0) if(!next_block()) return false;
			return true;
		}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x30(%rdi)
movq 0x44(%rdi), %rax
movq %rax, 0x34(%rdi)
movl 0x54(%rdi), %eax
movl %eax, 0x3c(%rdi)
andl $0x0, 0x40(%rdi)
movq 0x28(%rbx), %rax
movslq 0x3c(%rbx), %rcx
movl (%rax,%rcx,4), %ebp
testl %ebp, %ebp
jne 0x2c9fb
movq %rbx, %rdi
callq 0x2caae
testb %al, %al
jne 0x2c9e0
testl %ebp, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./c_loops.hh
// Function: voro::c_loop_all_periodic::next_block()
inline bool next_block() {
			i++;
			if(i==nx) {
				i=0;j++;
				if(j==wy) {
					j=ey;k++;
					if(k==wz) return false;
					ijk+=inc2;
				} else ijk++;
			} else ijk++;
			return true;
		}

// Assembly:
movl 0x30(%rdi), %ecx
incl %ecx
movl %ecx, 0x30(%rdi)
pushq $0x1
popq %rax
cmpl (%rdi), %ecx
jne 0x2cae7
andl $0x0, 0x30(%rdi)
movl 0x34(%rdi), %ecx
incl %ecx
movl %ecx, 0x34(%rdi)
cmpl 0x4c(%rdi), %ecx
jne 0x2cae7
movl 0x38(%rdi), %eax
movl 0x44(%rdi), %ecx
movl %ecx, 0x34(%rdi)
incl %eax
movl %eax, 0x38(%rdi)
cmpl 0x50(%rdi), %eax
jne 0x2cae4
xorl %eax, %eax
retq
movl 0x58(%rdi), %eax
addl %eax, 0x3c(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/unitcell.cc
// Function: voro::unitcell::unit_voro_intersect(int)
bool unitcell::unit_voro_intersect(int l) {
	int i,j;
	if(unit_voro_test(l,0,0)) return true;
	for(i=1;i<l;i++) {
		if(unit_voro_test(l,i,0)) return true;
		if(unit_voro_test(-l,i,0)) return true;
	}
	for(i=-l;i<=l;i++) if(unit_voro_test(i,l,0)) return true;
	for(i=1;i<l;i++) for(j=-l+1;j<=l;j++) {
		if(unit_voro_test(l,j,i)) return true;
		if(unit_voro_test(-j,l,i)) return true;
		if(unit_voro_test(-l,-j,i)) return true;
		if(unit_voro_test(j,-l,i)) return true;
	}
	for(i=-l;i<=l;i++) for(j=-l;j<=l;j++) if(unit_voro_test(i,j,l)) return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2db66
movb $0x1, %r12b
testb %al, %al
jne 0x2d098
movl %r14d, %ebp
negl %ebp
pushq $0x1
popq %rbx
cmpl %r14d, %ebx
jge 0x2cfc4
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2db66
testb %al, %al
jne 0x2d098
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2db66
incl %ebx
testb %al, %al
je 0x2cf8f
jmp 0x2d098
movl %ebp, %ebx
cmpl %r14d, %ebx
jg 0x2cfe5
movq %r15, %rdi
movl %ebx, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x2db66
incl %ebx
testb %al, %al
je 0x2cfc6
jmp 0x2d098
pushq $0x1
popq %r12
movl %r12d, %ebx
subl %r14d, %ebx
leal -0x1(%r14), %r13d
movl %ebx, 0x4(%rsp)
movl %r13d, (%rsp)
cmpl %r14d, %r12d
jge 0x2d069
cmpl %r14d, %ebx
jg 0x2d05c
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r12d, %ecx
callq 0x2db66
testb %al, %al
jne 0x2d095
movq %r15, %rdi
movl %r13d, %esi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x2db66
testb %al, %al
jne 0x2d095
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x2db66
testb %al, %al
jne 0x2d095
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x2db66
incl %ebx
decl %r13d
testb %al, %al
je 0x2d000
jmp 0x2d095
incl %r12d
movl 0x4(%rsp), %ebx
movl (%rsp), %r13d
jmp 0x2cffb
movl %ebp, %ebx
cmpl %r14d, %ebx
jg 0x2d0aa
movl %ebp, %r12d
cmpl %r14d, %r12d
jg 0x2d091
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x2db66
incl %r12d
testb %al, %al
je 0x2d073
jmp 0x2d095
incl %ebx
jmp 0x2d06b
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x2d098
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7f63(%rip), %rsi      # 0x35629
movq %rbx, %rdi
movaps %xmm2, %xmm4
movb $0x5, %al
callq 0x21a0
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 0x3a9c(%rip), %rsi      # 0x311c8
movq %rbx, %rdi
movapd %xmm1, %xmm4
movaps %xmm2, %xmm5
movb $0x8, %al
callq 0x21a0
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 0x7ed5(%rip), %rsi      # 0x35647
movq %rbx, %rdi
movaps %xmm4, %xmm7
movb $0x8, %al
callq 0x21a0
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 0x7ea4(%rip), %rsi      # 0x3566a
movq %rbx, %rdi
movb $0x8, %al
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
movl 0x38(%rdi), %eax
movq 0x10(%rsi), %rsi
testl %eax, %eax
je 0x4d38
cmpl $0x1, %eax
je 0x4d25
cmpl $0x3, %eax
jne 0x4d3e
movb $0x1, %al
cmpl $0x3, 0x38(%rsi)
jne 0x4d3e
retq
cmpl $0x1, 0x38(%rsi)
jne 0x4d3e
addq $0x48, %rdi
addq $0x48, %rsi
jmp 0x7b39
cmpl $0x0, 0x38(%rsi)
je 0x4d45
cmpq %rsi, %rdi
sete %al
retq
movsd 0x40(%rsi), %xmm0
cmpeqsd 0x40(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2488
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x546a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, (%r14)
movq 0x10(%rbx), %rdi
addq $0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0x7bc6
movq %rax, 0x8(%r14)
leaq 0x28(%rsp), %rdi
callq 0x20c0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x5458
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
addq $0x8, %rdi
callq 0x7bc6
movq %rax, %r14
movq (%rax), %rax
leaq 0x40(%rsp), %rdi
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rdi)
incl (%rax)
movq 0x7ce7(%rip), %rax      # 0xd198
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x7ce4(%rip), %rax      # 0xd1a8
movq %rax, 0x10(%rsi)
incl (%rax)
callq 0x4d03
testb %al, %al
je 0x55e3
movq 0x10(%r15), %r12
leaq 0x3ca9(%rip), %rsi      # 0x918b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7b8a
addq $0x8, %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x7c2c
movq (%rax), %rcx
leaq 0x90(%rsp), %r12
movq %rcx, (%r12)
movq %r12, 0x8(%r12)
movq 0x10(%rax), %rax
movq %rax, 0x10(%r12)
incl (%rax)
movq 0x7c70(%rip), %rax      # 0xd198
leaq 0x78(%rsp), %r13
movq %rax, (%r13)
movq %r13, 0x8(%r13)
movq 0x7c6c(%rip), %rax      # 0xd1a8
movq %rax, 0x10(%r13)
incl (%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4d59
movl %eax, %ebp
movq %r13, %rdi
callq 0x79fc
movq %r12, %rdi
callq 0x79fc
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x79fc
leaq 0x40(%rsp), %rdi
callq 0x79fc
testb %bpl, %bpl
je 0x55f7
movq 0x10(%r15), %r14
leaq 0x3bfe(%rip), %rsi      # 0x918b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7b8a
addq $0x8, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7c2c
movq %rax, %r14
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0x2200
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
callq 0x546a
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x55f7
leaq 0x28(%rsp), %rdi
callq 0x79fc
leaq 0x40(%rsp), %rdi
callq 0x79fc
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20c0
jmp 0x5623
movq %rax, %rbx
jmp 0x5655
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x5655
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x5641
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x79fc
leaq 0x40(%rsp), %rdi
callq 0x79fc
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20f0
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 0x8050
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 0x7c92
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x7ce0
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x7d2e
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x7d7c
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x7dca
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x7e18
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/vjeux[P]jspp/example/../src/constructors.h
// Function: Object::Object(std::initializer_list<Object>)
Object::Object(std::initializer_list<Object> list) : self(&undefined), write(this), s(new State) {
	int length = 0;

	for (auto elem : list)
		if (elem.s->type == KEYVALUE) {
			(*this)[elem.s->kv->key] = elem.s->kv->value;
		} else {
			(*this)[length++] = elem;
		}

	if (length > 0) {
		(*this)["length"] = length;
		s->type = ARRAY;
	} else {
		s->type = OBJECT;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x77f3(%rip), %rax      # 0xd198
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movl $0x138, %edi            # imm = 0x138
callq 0x21a0
movq %rax, %r12
movq %rax, %rdi
callq 0x7e66
movq %rbx, 0x8(%rsp)
movq %r12, 0x10(%rbx)
imulq $0x18, %r15, %r13
xorl %ebp, %ebp
leaq 0x58(%rsp), %rbx
leaq 0x28(%rsp), %r12
leaq 0x10(%rsp), %r15
testq %r13, %r13
je 0x5aea
movq (%r14), %rcx
movq %rcx, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x68(%rsp)
movl (%rax), %edx
movl 0x38(%rax), %esi
leal 0x1(%rdx), %edi
movl %edi, (%rax)
cmpl $0x7, %esi
jne 0x5a79
movq %r14, %r15
movq %r13, %r14
movl %ebp, %r13d
movq %rbx, %rbp
movq 0x130(%rax), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0x38(%rsp)
incl (%rcx)
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, 0x48(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x50(%rsp)
incl (%rax)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x53da
movq %rbx, %rdi
movq %rbp, %rbx
movl %r13d, %ebp
movq %r14, %r13
movq %r15, %r14
leaq 0x10(%rsp), %r15
jmp 0x5ab4
movq %rcx, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %rax, 0x20(%rsp)
addl $0x2, %edx
movl %edx, (%rax)
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x5802
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x53da
incl %ebp
movq %r12, %rdi
movq %r15, %r12
movq 0x10(%r12), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
incl (%rcx)
callq 0x79fc
movq %r12, %rdi
callq 0x79fc
movq %rbx, %rdi
callq 0x79fc
addq $0x18, %r14
addq $-0x18, %r13
leaq 0x28(%rsp), %r12
jmp 0x59df
testl %ebp, %ebp
jle 0x5b49
leaq 0x88(%rsp), %rdi
movl %ebp, %esi
callq 0x5802
leaq 0x366f(%rip), %rsi      # 0x9173
leaq 0x70(%rsp), %rdi
callq 0x588e
leaq 0x70(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x53da
leaq 0x88(%rsp), %r14
movq 0x10(%r14), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
incl (%rcx)
leaq 0x70(%rsp), %rdi
callq 0x79fc
movq %r14, %rdi
callq 0x79fc
pushq $0x6
jmp 0x5b4b
pushq $0x5
popq %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl %eax, 0x38(%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x79fc
jmp 0x5b7c
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x5bbe
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x79fc
jmp 0x5b9b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x5bb4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x79fc
leaq 0x28(%rsp), %rdi
callq 0x79fc
leaq 0x58(%rsp), %rdi
callq 0x79fc
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5778
movq 0x10(%rbx), %rdi
movl $0x2, 0x38(%rdi)
movq 0x10(%r14), %rsi
movl 0x68(%rsi), %eax
movl %eax, 0x68(%rdi)
addq $0x70, %rsi
addq $0x70, %rdi
callq 0x7c92
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x7ce0
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x7d2e
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x7d7c
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x7dca
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x7e18
movq %rbx, (%rbx)
leaq 0x34db(%rip), %rsi      # 0x9195
leaq 0x18(%rsp), %rdi
callq 0x588e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x53da
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 0x349a(%rip), %rsi      # 0x918b
movq %rsp, %rdi
callq 0x588e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x53da
leaq 0x30(%rsp), %r14
movq 0x10(%r14), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
incl (%rcx)
movq %rsp, %rdi
callq 0x79fc
movq %r14, %rdi
callq 0x79fc
leaq 0x18(%rsp), %rdi
callq 0x79fc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x79fc
jmp 0x5d4c
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x79fc
jmp 0x5d5b
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x79fc
jmp 0x5d6a
movq %rax, %r14
movq %rbx, %rdi
callq 0x79fc
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7a1e
movq %rbx, %rdi
callq 0x7f5a
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
popq %rbx
jmp 0x21b0
decl %eax
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x8(%rsp), %r14
cmpq %r12, %r15
je 0x262c
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 0x9674
addq $0x8, %r15
jmp 0x2601
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9666
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
movupd %xmm0, (%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x8(%rsp), %r14
cmpq %r12, %r15
je 0x26a9
movq (%r15), %rax
cvtsi2sd %eax, %xmm0
movq %rax, 0x8(%rsp)
shrq $0x20, %rax
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x981a
addq $0x8, %r15
jmp 0x2675
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x980c
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25dc
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x2752
movq %rbx, %r15
subq %r14, %r15
pushq $0xc
popq %rcx
movq %r15, %rax
cqto
idivq %rcx
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6548
cmpq $0xc1, %r15
jl 0x2747
leaq 0xc0(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x68ac
cmpq %rbx, %r15
je 0x2752
movq %r15, %rdi
callq 0x690d
addq $0xc, %r15
jmp 0x2734
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68ac
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x277d
movq (%rax), %rsi
addl %esi, %edx
shrq $0x20, %rsi
imull %edx, %esi
movslq %esi, %rsi
addq %rsi, %rbx
addq $0xc, %rax
jmp 0x2760
leaq 0x8(%rsp), %rdi
callq 0x9666
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2796
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9666
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x264e
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x282e
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 0x698b
cmpq $0x101, %r15            # imm = 0x101
jl 0x2823
leaq 0x100(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cc8
cmpq %rbx, %r15
je 0x282e
movq %r15, %rdi
callq 0x6d3a
addq $0x10, %r15
jmp 0x2810
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6cc8
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x2859
movq (%rax), %rsi
addl %esi, %edx
shrq $0x20, %rsi
imull %edx, %esi
movslq %esi, %rsi
addq %rsi, %rbx
addq $0x10, %rax
jmp 0x283c
leaq 0x8(%rsp), %rdi
callq 0x980c
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2872
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x980c
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
callq 0x2320
leaq 0xa8(%rsp), %rdi
callq 0x20c0
testb %al, %al
je 0x33c5
leaq 0x30(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x21a0
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x73a0
leaq 0x30(%rsp), %rbx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x33b1
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movq %r12, %rdi
callq 0x741e
jmp 0x337b
leaq 0x30(%rsp), %rdi
callq 0x2090
leaq 0x18(%rsp), %rdi
callq 0x746c
leaq 0x30(%rsp), %rdi
callq 0x20e0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x33e7
jmp 0x33e2
movq %rax, %rbx
jmp 0x33f4
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x746c
leaq 0x30(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
cmpl $0x2, %edx
je 0x3755
cmpl $0x1, %edx
jne 0x37a1
leaq 0x14(%rsp), %r14
movl $0x1, (%r14)
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
subl $0x1, %r15d
jb 0x37a1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71b6
shll 0x14(%rsp)
jmp 0x373e
xorl %r12d, %r12d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
movl %eax, 0xc(%rsp)
pushq $0x1
popq %r13
leaq 0x10(%rsp), %r14
cmpl 0xc(%rsp), %r12d
je 0x37a1
incl %r12d
movl %r12d, %r15d
cmpl %ebp, %r15d
jge 0x379c
movl %r13d, %eax
btsl %r15d, %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71b6
incl %r15d
jmp 0x377c
addl %r13d, %r13d
jmp 0x376f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37b5
movq %rax, %r14
movq %rbx, %rdi
callq 0x9cda
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x725c
movq %rax, %r13
leaq 0x929e(%rip), %rsi      # 0xd53d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rdx
callq 0x75fa
movq %r13, %rdi
movq %rbp, %rsi
callq 0x72a6
leaq 0x10(%rsp), %rdi
callq 0x2150
leaq 0x10(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r12, %rsi
callq 0x2320
leaq 0x88(%rsp), %rdi
callq 0x20c0
testb %al, %al
je 0x4354
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x21a0
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x21a0
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x434a
movq %r14, %rdi
movq %r12, %rsi
callq 0x71b6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71b6
jmp 0x430e
leaq 0x10(%rsp), %rdi
callq 0x2090
callq 0x725c
movq %rax, %rdi
callq 0x72c8
leaq 0x10(%rsp), %rdi
callq 0x20e0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4392
jmp 0x4392
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2150
jmp 0x439f
jmp 0x4392
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movaps 0x8baa(%rip), %xmm0     # 0xd0a0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rbx
leaq 0x40(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x710e
movaps 0x8b93(%rip), %xmm0     # 0xd0b0
movaps %xmm0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdx
callq 0x710e
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x6
popq %rdx
callq 0x43a7
cmpl $0x8, %eax
jne 0x456d
leaq 0x10(%rsp), %rdi
callq 0x9cda
leaq 0x28(%rsp), %rdi
callq 0x9cda
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x9069(%rip), %rdi      # 0xd5dd
leaq 0x8ff1(%rip), %rsi      # 0xd56c
leaq 0x906e(%rip), %rcx      # 0xd5f0
pushq $0x6d
popq %rdx
callq 0x21b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9cda
jmp 0x459c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9cda
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11b42(%rip), %rdi     # 0x16208
callq 0xac94
testq %rax, %rax
je 0x4701
leaq 0x11b31(%rip), %rdi     # 0x16208
leaq 0xc(%rsp), %rsi
callq 0xad24
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x4701
movq (%rcx), %r12
movq %r12, %rdx
shrq $0x20, %rdx
addq $0x8, %rcx
cmpl %ebx, %edx
jne 0x46e8
jmp 0x477e
testl %ebx, %ebx
jle 0x471d
movl 0xc(%rsp), %ecx
leal -0x1(%rbx), %r12d
movq (%r14), %rdx
movl %ecx, %eax
subl (%rdx,%r12,4), %eax
jge 0x4722
pushq $-0x1
popq %rbp
jmp 0x4742
xorl %r12d, %r12d
jmp 0x477e
movq (%r15), %rcx
movl (%rcx,%r12,4), %r13d
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0x46a2
movl %eax, %ebp
addl %r13d, %ebp
movl 0xc(%rsp), %ecx
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x46a2
movl %eax, %r12d
leaq 0x11aae(%rip), %rdi     # 0x16208
leaq 0xc(%rsp), %rsi
callq 0xad24
cmpl %r12d, %ebp
cmovgl %ebp, %r12d
leaq 0x10(%rsp), %rsi
movl %r12d, (%rsi)
movl %ebx, 0x4(%rsi)
movq %rax, %rdi
callq 0xb01c
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_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movaps 0x880a(%rip), %xmm0     # 0xd0a0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rbx
leaq 0x40(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x710e
movaps 0x87f3(%rip), %xmm0     # 0xd0b0
movaps %xmm0, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdx
callq 0x710e
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x6
popq %rdx
callq 0x4790
cmpl $0x8, %eax
jne 0x490d
leaq 0x10(%rsp), %rdi
callq 0x9cda
leaq 0x28(%rsp), %rdi
callq 0x9cda
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x8cc9(%rip), %rdi      # 0xd5dd
leaq 0x8c51(%rip), %rsi      # 0xd56c
leaq 0x8d2b(%rip), %rcx      # 0xd64d
movl $0xe7, %edx
callq 0x21b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9cda
jmp 0x493e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9cda
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x114e8(%rip)     # 0x16258
je 0x4d7e
leaq 0x114c7(%rip), %rdi     # 0x16240
callq 0x8c7a
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x2360
leaq 0xa8(%rsp), %rdi
callq 0x20c0
testb %al, %al
je 0x4e48
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x21a0
leaq 0x24(%rsp), %rsi
movq %rax, %rdi
callq 0x21a0
leaq 0x28(%rsp), %rbx
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0x11466(%rip), %r13     # 0x16240
leaq 0x18(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4e3a
movq %r13, %rdi
movq %r14, %rsi
callq 0xb3c8
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %edx
shlq $0x20, %rdx
orq %rcx, %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdi
movq %rbp, %rsi
callq 0xb71e
jmp 0x4ddf
leaq 0x28(%rsp), %rdi
callq 0x2040
movl 0x14(%rsp), %ebx
leaq 0x28(%rsp), %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e6c
jmp 0x4e6c
jmp 0x4e6c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %esi, %ebp
leaq 0x4(%rsp), %rsi
movl %edi, (%rsi)
movq %rdx, %rdi
callq 0xb87a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x7824
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x4ec3
cmpl %ebp, (%rax)
je 0x4ec7
addq $0x8, %rax
jmp 0x4eb4
xorl %edx, %edx
jmp 0x4eca
movl 0x4(%rax), %edx
cmpq %rcx, %rax
setne %bpl
movl %edx, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xb8b6
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
callq 0x4d54
leaq 0xc(%rsp), %rdx
movl $0x7fffffff, (%rdx)     # imm = 0x7FFFFFFF
leaq 0x11011(%rip), %rdi     # 0x16240
movl %eax, %esi
callq 0x4ee8
testb %al, %al
je 0x5268
movq 0x10d97(%rip), %rdi     # 0x15fd8
leaq 0x85d9(%rip), %rsi      # 0xd821
callq 0x2230
movl 0xc(%rsp), %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x2370
movq %rax, %rdi
callq 0x2160
cmpl $-0x13, %ebx
jne 0x526e
addq $0x10, %rsp
popq %rbx
retq
leaq 0x85d0(%rip), %rdi      # 0xd845
leaq 0x85e7(%rip), %rsi      # 0xd863
leaq 0x85f2(%rip), %rcx      # 0xd875
movl $0xa2, %edx
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
movl %esi, (%r15)
leaq 0x10d3b(%rip), %r14     # 0x162c8
movq %r14, %rdi
movq %r15, %rsi
callq 0xa62a
movb $0x1, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc346
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x55e1
movl (%r12), %eax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa62a
cmpb $0x0, (%rax)
jne 0x55db
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x556e
addq $0x4, %r12
jmp 0x55b2
leaq 0x10c90(%rip), %rdi     # 0x16278
leaq 0xc(%rsp), %rsi
callq 0xc54e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movl %esi, (%r12)
leaq 0x10ca7(%rip), %r15     # 0x162c8
movq %r15, %rdi
movq %r12, %rsi
callq 0xa62a
movb $0x1, (%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0xc346
movq (%rax), %r13
movq 0x8(%rax), %rbp
movq %rsp, %r12
cmpq %rbp, %r13
je 0x5674
movl (%r13), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa62a
cmpb $0x0, (%rax)
jne 0x566e
movl (%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5600
addq $0x4, %r13
jmp 0x5644
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x71b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq