LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(voro::particle_order&, int, double, double, double)
void container_periodic::put(particle_order &vo,int n,double x,double y,double z) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	id[ijk][co[ijk]]=n;
	vo.add(ijk,co[ijk]);
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x4e3c0
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x1a0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movq 0x1b0(%rax), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x1e910
movq -0x48(%rbp), %rcx
movq 0x1a8(%rcx), %rax
movslq -0x34(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x1b0(%rcx), %rdx
movslq -0x34(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(voro::particle_order&, int, double, double, double, double)
void container_periodic_poly::put(particle_order &vo,int n,double x,double y,double z,double r) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	id[ijk][co[ijk]]=n;
	vo.add(ijk,co[ijk]);
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x4e3c0
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x1a0(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rdx
movslq -0x3c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq 0x1b0(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x1e910
movq -0x50(%rbp), %rax
movq 0x1a8(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rsi
movslq -0x3c(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x38(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x1d8(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f1bc
movq -0x50(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x1d8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::compute_all_cells()
void container_periodic::compute_all_cells() {
	voronoicell c(*this);
	c_loop_all_periodic vl(*this);
	if(vl.start()) do compute_cell(c,vl);
	while(vl.inc());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x168(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x52680
movq -0x168(%rbp), %rsi
leaq -0x150(%rbp), %rdi
callq 0x51ff0
jmp 0x4fe5b
leaq -0x150(%rbp), %rdi
callq 0x526d0
movb %al, -0x169(%rbp)
jmp 0x4fe6f
movb -0x169(%rbp), %al
testb $0x1, %al
jne 0x4fe7b
jmp 0x4fedd
jmp 0x4fe7d
movq -0x168(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x150(%rbp), %rdx
callq 0x52740
jmp 0x4fe99
jmp 0x4fe9b
leaq -0x150(%rbp), %rdi
callq 0x527a0
movb %al, -0x16a(%rbp)
jmp 0x4feaf
movb -0x16a(%rbp), %al
testb $0x1, %al
jne 0x4fe7d
jmp 0x4febb
jmp 0x4fedd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x158(%rbp)
movl %eax, -0x15c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
jmp 0x4fef2
leaq -0xf0(%rbp), %rdi
callq 0x6810
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x158(%rbp), %rdi
callq 0x2220
nop
// File: 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
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x170(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x52680
movq -0x170(%rbp), %rsi
movq $0x0, -0xf8(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x51ff0
jmp 0x50026
leaq -0x158(%rbp), %rdi
callq 0x526d0
movb %al, -0x171(%rbp)
jmp 0x5003a
movb -0x171(%rbp), %al
testb $0x1, %al
jne 0x50049
jmp 0x500f1
jmp 0x5004b
movq -0x170(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x158(%rbp), %rdx
callq 0x52740
movb %al, -0x172(%rbp)
jmp 0x5006d
movb -0x172(%rbp), %al
testb $0x1, %al
jne 0x50079
jmp 0x500c9
leaq -0xf0(%rbp), %rdi
callq 0x9c90
movsd %xmm0, -0x180(%rbp)
jmp 0x5008f
movsd -0x180(%rbp), %xmm0
addsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
jmp 0x500c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
jmp 0x5011e
jmp 0x500cb
leaq -0x158(%rbp), %rdi
callq 0x527a0
movb %al, -0x181(%rbp)
jmp 0x500df
movb -0x181(%rbp), %al
testb $0x1, %al
jne 0x5004b
jmp 0x500ef
jmp 0x500f1
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0x190(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
movsd -0x190(%rbp), %xmm0
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x1b0(%rcx), %rax
movslq -0xc(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x1b8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x50ad6
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4f1d0
movq -0x48(%rbp), %rax
movq 0x1a8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x1cc(%rax), %edx
movq 0x1b0(%rax), %rsi
movslq -0xc(%rbp), %rdi
imull (%rsi,%rdi,4), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x1a8(%rax), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x1cc(%rax), %edx
imull -0x14(%rbp), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd (%rcx), %xmm0
addsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x38(%rbp)
movsd %xmm0, (%rcx)
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd (%rcx), %xmm0
addsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x38(%rbp)
movsd %xmm0, (%rcx)
movq -0x40(%rbp), %rcx
movsd (%rcx), %xmm0
addsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x4, 0x1cc(%rax)
jne 0x50bcf
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd 0x8(%rax), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq 0x1a0(%rcx), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq -0x14(%rbp), %rdx
movl (%rax,%rdx,4), %edx
movq 0x1a0(%rcx), %rax
movslq -0xc(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq 0x1b0(%rcx), %rsi
movslq -0xc(%rbp), %rdi
movl (%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x30(%rax)
movl 0x44(%rax), %ecx
movl %ecx, 0x34(%rax)
movl 0x48(%rax), %ecx
movl %ecx, 0x38(%rax)
movl 0x54(%rax), %ecx
movl %ecx, 0x3c(%rax)
movl $0x0, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movslq 0x3c(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x5272b
movq -0x18(%rbp), %rdi
callq 0x528c0
testb $0x1, %al
jne 0x52729
movb $0x0, -0x1(%rbp)
jmp 0x5272f
jmp 0x52704
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x30(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x30(%rcx)
movl 0x30(%rcx), %eax
cmpl (%rcx), %eax
jne 0x5293b
movq -0x18(%rbp), %rcx
movl $0x0, 0x30(%rcx)
movl 0x34(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x34(%rcx)
movl 0x34(%rcx), %eax
cmpl 0x4c(%rcx), %eax
jne 0x5292c
movq -0x18(%rbp), %rcx
movl 0x44(%rcx), %eax
movl %eax, 0x34(%rcx)
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl 0x38(%rcx), %eax
cmpl 0x50(%rcx), %eax
jne 0x5291d
movb $0x0, -0x1(%rbp)
jmp 0x5294c
movq -0x18(%rbp), %rax
movl 0x58(%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
jmp 0x52939
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x52948
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
movsd (%rax), %xmm1
addsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x8(%rax), %xmm3
movsd 0x10(%rax), %xmm4
leaq 0x86a2(%rip), %rsi      # 0x5c331
movb $0x5, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x8(%rax), %xmm0
addsd 0x18(%rax), %xmm0
movsd 0x10(%rax), %xmm1
addsd 0x20(%rax), %xmm1
movsd 0x28(%rax), %xmm2
movsd (%rax), %xmm3
addsd 0x8(%rax), %xmm3
addsd 0x18(%rax), %xmm3
movsd 0x10(%rax), %xmm4
addsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movsd (%rax), %xmm6
addsd 0x18(%rax), %xmm6
movsd 0x20(%rax), %xmm7
movsd 0x28(%rax), %xmm11
movsd 0x18(%rax), %xmm10
movsd 0x20(%rax), %xmm9
movsd 0x28(%rax), %xmm8
leaq 0x41d7(%rip), %rsi      # 0x57ed8
movsd %xmm11, (%rsp)
movsd %xmm10, 0x8(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x18(%rsp)
movb $0x8, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
movsd 0x18(%rax), %xmm2
movsd 0x20(%rax), %xmm3
movsd 0x28(%rax), %xmm4
movsd 0x8(%rax), %xmm5
addsd 0x18(%rax), %xmm5
movsd 0x10(%rax), %xmm6
addsd 0x20(%rax), %xmm6
movsd 0x28(%rax), %xmm7
leaq 0x85eb(%rip), %rsi      # 0x5c34f
movb $0x8, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
movsd (%rax), %xmm1
addsd 0x18(%rax), %xmm1
movsd 0x20(%rax), %xmm2
movsd 0x28(%rax), %xmm3
movsd (%rax), %xmm4
addsd 0x8(%rax), %xmm4
movsd 0x10(%rax), %xmm5
movsd (%rax), %xmm6
addsd 0x8(%rax), %xmm6
addsd 0x18(%rax), %xmm6
movsd 0x10(%rax), %xmm7
addsd 0x20(%rax), %xmm7
movsd 0x28(%rax), %xmm8
leaq 0x85b5(%rip), %rsi      # 0x5c372
movsd %xmm8, (%rsp)
movb $0x8, %al
callq 0x21a0
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x10(%rdi), %rax
cmpl $0x3, 0x38(%rax)
jne 0x6799
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x3, 0x38(%rax)
jne 0x6799
movb $0x1, -0x1(%rbp)
jmp 0x6836
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x38(%rax)
jne 0x67de
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x38(%rax)
jne 0x67de
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movsd 0x40(%rcx), %xmm0
movq 0x10(%rax), %rax
ucomisd 0x40(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6836
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x38(%rax)
jne 0x681e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x38(%rax)
jne 0x681e
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rdi
addq $0x48, %rdi
movq 0x10(%rax), %rsi
addq $0x48, %rsi
callq 0xcaa0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6836
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x25c0
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x20d0
jmp 0x7207
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x72c0
movq %rax, -0x80(%rbp)
jmp 0x721a
leaq -0x58(%rbp), %rdi
callq 0x2130
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq 0x10(%rax), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xcd40
movq %rax, -0x88(%rbp)
jmp 0x7250
movq -0x88(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x72a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x60(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq 0x10(%rsi), %rcx
movl 0x38(%rcx), %edx
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movl %edx, 0x38(%rcx)
movq 0x10(%rsi), %rsi
addq $0x48, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x48, %rdi
callq 0x2050
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rcx
movsd 0x40(%rcx), %xmm0
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movsd %xmm0, 0x40(%rcx)
movq 0x10(%rsi), %rsi
addq $0x8, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x8, %rdi
callq 0xcf00
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rcx
movq 0x130(%rcx), %rdx
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, 0x130(%rcx)
movq 0x10(%rsi), %rcx
movl 0x68(%rcx), %edx
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movl %edx, 0x68(%rcx)
movq 0x10(%rsi), %rsi
addq $0x70, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x70, %rdi
callq 0xcf30
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rsi
addq $0x90, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x90, %rdi
callq 0xcf80
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rsi
addq $0xb0, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0xb0, %rdi
callq 0xcfd0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rsi
addq $0xd0, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0xd0, %rdi
callq 0xd020
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rsi
addq $0xf0, %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0xf0, %rdi
callq 0xd070
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rsi), %rsi
addq $0x110, %rsi            # imm = 0x110
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0xd0c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7880
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq 0x10(%rdi), %rax
movl $0x2, 0x38(%rax)
movq 0x10(%rsi), %rax
movl 0x68(%rax), %ecx
movq 0x10(%rdi), %rax
movl %ecx, 0x68(%rax)
movq 0x10(%rsi), %rsi
addq $0x70, %rsi
movq 0x10(%rdi), %rdi
addq $0x70, %rdi
callq 0xcf30
jmp 0x8166
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rsi
addq $0x90, %rsi
movq 0x10(%rax), %rdi
addq $0x90, %rdi
callq 0xcf80
jmp 0x818b
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rsi
addq $0xb0, %rsi
movq 0x10(%rax), %rdi
addq $0xb0, %rdi
callq 0xcfd0
jmp 0x81b0
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rsi
addq $0xd0, %rsi
movq 0x10(%rax), %rdi
addq $0xd0, %rdi
callq 0xd020
jmp 0x81d5
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rsi
addq $0xf0, %rsi
movq 0x10(%rax), %rdi
addq $0xf0, %rdi
callq 0xd070
jmp 0x81fa
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rsi
addq $0x110, %rsi            # imm = 0x110
movq 0x10(%rax), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0xd0c0
jmp 0x821f
movq -0x78(%rbp), %rax
movq %rax, (%rax)
leaq 0x8f04(%rip), %rsi      # 0x11131
leaq -0x58(%rbp), %rdi
callq 0x7b00
jmp 0x8238
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x71d0
movq %rax, -0x90(%rbp)
jmp 0x824e
movq -0x90(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x7840
jmp 0x8260
leaq 0x8ec0(%rip), %rsi      # 0x11127
leaq -0x70(%rbp), %rdi
callq 0x7b00
jmp 0x8272
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x71d0
movq %rax, -0x98(%rbp)
jmp 0x8288
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6aa0
leaq -0x70(%rbp), %rdi
callq 0xc620
leaq -0x40(%rbp), %rdi
callq 0xc620
leaq -0x58(%rbp), %rdi
callq 0xc620
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x831b
jmp 0x8312
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x832b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x82fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc620
leaq -0x40(%rbp), %rdi
callq 0xc620
leaq -0x58(%rbp), %rdi
callq 0xc620
jmp 0x832b
movq -0x78(%rbp), %rdi
callq 0xc620
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xc620
movq -0x20(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: vjeux[P]jspp/example/../src/object.h
// Function: Object::~Object()
~Object() {
		if (s->refcount == 1) {
			delete s;
		} else {
			s->refcount -= 1;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
jne 0xc668
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc666
movq -0x18(%rbp), %rdi
callq 0xd320
movq -0x18(%rbp), %rdi
movl $0x138, %esi            # imm = 0x138
callq 0x2210
jmp 0xc677
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0xfc50
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xfc60
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0xfc90
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xfcc0
testb $0x1, %al
jne 0x3735
jmp 0x37c4
leaq 0x50(%rsp), %rdi
callq 0xfd00
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xfd10
movq (%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
callq 0xfd20
movq (%rsp), %rdx
movq %rax, %rcx
movl 0xc(%rsp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
movl %eax, 0x3c(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0xfd60
jmp 0x3788
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfd30
jmp 0x3799
jmp 0x379b
leaq 0x50(%rsp), %rdi
callq 0xfda0
jmp 0x371d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xfdc0
jmp 0x37e4
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x37da
movq 0x10(%rsp), %rdi
callq 0xfdc0
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3460
nop
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xfe20
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0xfc60
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0xfc90
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xfcc0
testb $0x1, %al
jne 0x385b
jmp 0x38f6
leaq 0x60(%rsp), %rdi
callq 0xfd00
movq (%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xfd10
movq 0x10(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xfd20
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xfe60
jmp 0x38ba
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xfe30
jmp 0x38cb
jmp 0x38cd
leaq 0x60(%rsp), %rdi
callq 0xfda0
jmp 0x3843
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xfea0
jmp 0x3919
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x390c
movq 0x18(%rsp), %rdi
callq 0xfea0
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x36d0
movq 0x8(%rsp), %rdi
callq 0xff00
movq 0x8(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0xff30
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3a90
jmp 0x3985
movq $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xff00
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xff30
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xff60
testb $0x1, %al
jne 0x39d6
jmp 0x3a58
leaq 0x30(%rsp), %rdi
callq 0xffa0
movq (%rax), %rcx
movq %rcx, 0x1c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0xffb0
movq (%rax), %rax
movq %rax, 0x14(%rsp)
leaq 0x14(%rsp), %rdi
callq 0xfd20
movl (%rax), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
leaq 0x14(%rsp), %rdi
callq 0xfd10
movl (%rax), %eax
imull 0x44(%rsp), %eax
cltq
addq 0x48(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xffc0
jmp 0x39be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xfdc0
jmp 0x3a77
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x78(%rsp), %rdi
callq 0xfdc0
movq (%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37f0
movq 0x8(%rsp), %rdi
callq 0xffe0
movq 0x8(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0x10010
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3c30
jmp 0x3b25
movq $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xffe0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x10010
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10040
testb $0x1, %al
jne 0x3b76
jmp 0x3bfd
leaq 0x30(%rsp), %rdi
callq 0x10080
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x10090
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xfd20
movl (%rax), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xfd10
movl (%rax), %eax
imull 0x44(%rsp), %eax
cltq
addq 0x48(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x100a0
jmp 0x3b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xfea0
jmp 0x3c1c
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x78(%rsp), %rdi
callq 0xfea0
movq (%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rsi
movq %rsi, 0x260(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x8, %edx
callq 0x33e0
movq 0x18(%rsp), %rdi
callq 0x33d0
movb %al, 0x27(%rsp)
jmp 0x52c6
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x52d3
jmp 0x539c
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x31e0
jmp 0x52e4
movl 0x48(%rsp), %esi
leaq 0x28(%rsp), %rdi
callq 0x10ca0
jmp 0x52f4
jmp 0x52f6
leaq 0x58(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x31e0
movq %rax, 0x10(%rsp)
jmp 0x530c
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x31e0
movq %rax, 0x8(%rsp)
jmp 0x5322
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, 0x7(%rsp)
jmp 0x533c
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x5346
jmp 0x5386
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
leaq 0x28(%rsp), %rdi
callq 0x10dc0
jmp 0x535a
jmp 0x52f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x53ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x10ec0
jmp 0x53ae
leaq 0x58(%rsp), %rdi
callq 0x30a0
jmp 0x5392
leaq 0x28(%rsp), %rdi
callq 0x10ec0
leaq 0x58(%rsp), %rdi
callq 0x30f0
addq $0x268, %rsp            # imm = 0x268
retq
leaq 0x58(%rsp), %rdi
callq 0x30f0
movq 0x50(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x10fd0
cmpl $0x1, 0x48(%rsp)
jne 0x5ae0
movl $0x1, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x5ade
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x106f0
jmp 0x5aaa
movl 0x40(%rsp), %eax
shll %eax
movl %eax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5a8f
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x107c0
jmp 0x5b8c
jmp 0x5ae0
cmpl $0x2, 0x48(%rsp)
jne 0x5b6c
movl $0x1, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x5b6a
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x5b53
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movb 0x1c(%rsp), %dl
movb %dl, %cl
btsl %ecx, %eax
movl %eax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x106f0
jmp 0x5b44
jmp 0x5b46
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5b18
movl 0x24(%rsp), %eax
shll %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x5b03
jmp 0x5b6c
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x5b82
movq 0x8(%rsp), %rdi
callq 0x107c0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movq %rdx, 0x2a0(%rsp)
movq %rcx, 0x298(%rsp)
callq 0x10a60
movq %rax, 0x40(%rsp)
movq 0x2b0(%rsp), %rdx
leaq 0x2923a(%rip), %rsi     # 0x304ea
leaq 0x278(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x11490
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x10ad0
jmp 0x72d3
leaq 0x278(%rsp), %rdi
callq 0x31f0
movq 0x2b0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x8, %edx
callq 0x33e0
movq 0x30(%rsp), %rdi
callq 0x33d0
movb %al, 0x3f(%rsp)
jmp 0x730c
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x7319
jmp 0x7410
movq 0x298(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x31e0
movq %rax, 0x28(%rsp)
jmp 0x7332
movq 0x28(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x31e0
jmp 0x7343
jmp 0x7345
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x31e0
movq %rax, 0x20(%rsp)
jmp 0x735b
movq 0x20(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0x31e0
movq %rax, 0x18(%rsp)
jmp 0x7371
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, 0x17(%rsp)
jmp 0x738b
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x7395
jmp 0x7402
movq 0x2a8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x106f0
jmp 0x73a9
movq 0x2a0(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0x106f0
jmp 0x73bd
jmp 0x7345
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
leaq 0x278(%rsp), %rdi
callq 0x31f0
jmp 0x743a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x270(%rsp)
movl %eax, 0x26c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x30f0
jmp 0x743a
leaq 0x60(%rsp), %rdi
callq 0x30a0
jmp 0x740e
jmp 0x7410
callq 0x10a60
movq %rax, 0x8(%rsp)
jmp 0x741c
movq 0x8(%rsp), %rdi
callq 0x10b90
jmp 0x7428
leaq 0x60(%rsp), %rdi
callq 0x30f0
addq $0x2b8, %rsp            # imm = 0x2B8
retq
movq 0x270(%rsp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movl $0x3, 0x80(%rsp)
movl $0x2, 0x84(%rsp)
movl $0x4, 0x88(%rsp)
movl $0x4, 0x8c(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x90(%rsp)
movq $0x4, 0x98(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x101e0
movq 0x18(%rsp), %rcx
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x101f0
jmp 0x7892
leaq 0x7f(%rsp), %rdi
callq 0x10280
movl $0x4, 0x30(%rsp)
movl $0x3, 0x34(%rsp)
movl $0x2, 0x38(%rsp)
movl $0x3, 0x3c(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x4, 0x48(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x101e0
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x101f0
jmp 0x78f9
leaq 0x2f(%rsp), %rdi
callq 0x10280
movl $0x6, 0x28(%rsp)
movl 0x28(%rsp), %edx
leaq 0xa0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7450
movl %eax, 0xc(%rsp)
jmp 0x7927
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpl $0x8, 0x24(%rsp)
jne 0x7938
jmp 0x79a5
leaq 0x28c4b(%rip), %rdi     # 0x3058a
leaq 0x28bd3(%rip), %rsi     # 0x30519
movl $0x6d, %edx
leaq 0x28c4b(%rip), %rcx     # 0x3059d
callq 0x3200
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x10280
jmp 0x79d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x10280
jmp 0x79c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x107c0
jmp 0x79c8
leaq 0x50(%rsp), %rdi
callq 0x107c0
leaq 0xa0(%rsp), %rdi
callq 0x107c0
movb $0x1, %al
andb $0x1, %al
addq $0xb8, %rsp
retq
leaq 0xa0(%rsp), %rdi
callq 0x107c0
movq 0x70(%rsp), %rdi
callq 0x3460
nop
// File: Manca[P]algorithms2/./assignment3.hpp
// Function: assignment3::knapsack_1::run_algorithm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_algorithm(const std::string& fileName)
        {
            std::vector<int> values;
            std::vector<int> weights;
            int W;

            read_file(fileName, values, weights, W);
            PROFILE("Knapsack 1")
            int optimal_value = knapsack(values, weights, W);
            PROFILE_STOP();
            std::cout << "Optimal value for knapsack problem is: " << optimal_value << std::endl;
        }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x10fd0
leaq 0x80(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x10fd0
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0xb0(%rsp), %rdi
leaq 0x7c(%rsp), %rcx
callq 0x7270
jmp 0x7a31
callq 0x10a60
movq %rax, 0x28(%rsp)
jmp 0x7a3d
leaq 0x47(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3470
movq 0x20(%rsp), %rdx
leaq 0x28b6f(%rip), %rsi     # 0x305c7
leaq 0x48(%rsp), %rdi
callq 0x3360
jmp 0x7a64
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x10ad0
jmp 0x7a75
leaq 0x48(%rsp), %rdi
callq 0x31f0
leaq 0x47(%rsp), %rdi
callq 0x3300
movl 0x7c(%rsp), %edx
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x7450
movl %eax, 0x1c(%rsp)
jmp 0x7aa8
movl 0x1c(%rsp), %eax
movl %eax, 0x40(%rsp)
callq 0x10a60
movq %rax, 0x10(%rsp)
jmp 0x7abc
movq 0x10(%rsp), %rdi
callq 0x10b90
jmp 0x7ac8
movq 0x3c509(%rip), %rdi     # 0x43fd8
leaq 0x28afc(%rip), %rsi     # 0x305d2
callq 0x32c0
movq %rax, 0x8(%rsp)
jmp 0x7ae2
movq 0x8(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x3440
movq %rax, (%rsp)
jmp 0x7af6
movq (%rsp), %rdi
movq 0x3c4c7(%rip), %rsi     # 0x43fc8
callq 0x32f0
jmp 0x7b08
leaq 0x80(%rsp), %rdi
callq 0x107c0
leaq 0x98(%rsp), %rdi
callq 0x107c0
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x7b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x7b62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x31f0
leaq 0x47(%rsp), %rdi
callq 0x3300
leaq 0x80(%rsp), %rdi
callq 0x107c0
leaq 0x98(%rsp), %rdi
callq 0x107c0
movq 0x70(%rsp), %rdi
callq 0x3460
// File: 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:
subq $0xb8, %rsp
movl $0x3, 0x80(%rsp)
movl $0x2, 0x84(%rsp)
movl $0x4, 0x88(%rsp)
movl $0x4, 0x8c(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x90(%rsp)
movq $0x4, 0x98(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x101e0
movq 0x18(%rsp), %rcx
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x101f0
jmp 0x8092
leaq 0x7f(%rsp), %rdi
callq 0x10280
movl $0x4, 0x30(%rsp)
movl $0x3, 0x34(%rsp)
movl $0x2, 0x38(%rsp)
movl $0x3, 0x3c(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x4, 0x48(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x101e0
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x101f0
jmp 0x80f9
leaq 0x2f(%rsp), %rdi
callq 0x10280
movl $0x6, 0x28(%rsp)
movl 0x28(%rsp), %edx
leaq 0xa0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7db0
movl %eax, 0xc(%rsp)
jmp 0x8127
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpl $0x8, 0x24(%rsp)
jne 0x8138
jmp 0x81a5
leaq 0x2844b(%rip), %rdi     # 0x3058a
leaq 0x283d3(%rip), %rsi     # 0x30519
movl $0xe7, %edx
leaq 0x284a8(%rip), %rcx     # 0x305fa
callq 0x3200
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x10280
jmp 0x81d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x10280
jmp 0x81c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x107c0
jmp 0x81c8
leaq 0x50(%rsp), %rdi
callq 0x107c0
leaq 0xa0(%rsp), %rdi
callq 0x107c0
movb $0x1, %al
andb $0x1, %al
addq $0xb8, %rsp
retq
leaq 0xa0(%rsp), %rdi
callq 0x107c0
movq 0x70(%rsp), %rdi
callq 0x3460
nop
// File: 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:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
leaq 0x3b672(%rip), %rdi     # 0x442c8
callq 0x11ce0
testb $0x1, %al
jne 0x8c6b
leaq 0x3b662(%rip), %rdi     # 0x442c8
callq 0x11d00
movq 0x290(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movl $0x8, %edx
callq 0x3410
movq 0x48(%rsp), %rdi
callq 0x3430
movb %al, 0x57(%rsp)
jmp 0x8c9a
movb 0x57(%rsp), %al
testb $0x1, %al
jne 0x8ca7
jmp 0x8db8
leaq 0x80(%rsp), %rdi
leaq 0x7c(%rsp), %rsi
callq 0x31e0
movq %rax, 0x40(%rsp)
jmp 0x8cc0
movq 0x40(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x31e0
jmp 0x8cd1
jmp 0x8cd3
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x31e0
movq %rax, 0x38(%rsp)
jmp 0x8cec
movq 0x38(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x31e0
movq %rax, 0x30(%rsp)
jmp 0x8d02
movq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x31e0
movq %rax, 0x28(%rsp)
jmp 0x8d18
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, 0x27(%rsp)
jmp 0x8d32
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x8d3c
jmp 0x8da7
leaq 0x3b585(%rip), %rdi     # 0x442c8
leaq 0x68(%rsp), %rsi
callq 0x11d10
movq %rax, 0x18(%rsp)
jmp 0x8d54
leaq 0x64(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x11d70
movq %rax, 0x10(%rsp)
jmp 0x8d6a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x11d40
jmp 0x8d85
jmp 0x8cd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x30c0
jmp 0x8dd9
leaq 0x80(%rsp), %rdi
callq 0x3040
jmp 0x8db6
jmp 0x8db8
movl 0x7c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x30c0
movl 0xc(%rsp), %eax
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x70(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)