LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::~container_periodic_base()
container_periodic_base::~container_periodic_base() {
	for(int l=oxyz-1;l>=0;l--) if(mem[l]>0) {
		delete [] p[l];
		delete [] id[l];
	}
	delete [] img;
	delete [] mem;
	delete [] co;
	delete [] id;
	delete [] p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x198(%rdi), %r14
testq %r14, %r14
jle 0x30cdc
incq %r14
movq 0x1b8(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x30cd3
movq 0x1a8(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x30cbd
callq 0x2180
movq 0x1a0(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x30cd3
callq 0x2180
decq %r14
cmpq $0x1, %r14
ja 0x30c98
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x30ced
callq 0x2180
movq 0x1b8(%rbx), %rdi
testq %rdi, %rdi
je 0x30cfe
callq 0x2180
movq 0x1b0(%rbx), %rdi
testq %rdi, %rdi
je 0x30d0f
callq 0x2180
movq 0x1a0(%rbx), %rdi
testq %rdi, %rdi
je 0x30d20
callq 0x2180
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x30d31
callq 0x2180
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x30d42
callq 0x2180
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6ed4
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double)
void container_periodic::put(int n,double x,double y,double z) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x28(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x20(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x1c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x30f56
movslq (%r13), %r13
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
movsd (%r14), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
testq %rcx, %rcx
jle 0x30f0e
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x13358
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
incq %r15
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
addq $0x18, %r14
cmpq %rcx, %r15
jl 0x30eb1
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
leaq (%rdx,%rdx,2), %rax
movsd %xmm0, (%rcx,%rax,8)
movsd %xmm1, 0x8(%rcx,%rax,8)
movsd %xmm2, 0x10(%rcx,%rax,8)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::put_locate_block(int&, double&, double&, double&)
void container_periodic_base::put_locate_block(int &ijk,double &x,double &y,double &z) {

	// Remap particle in the z direction if necessary
	int k=step_int(z*zsp);
	if(k<0||k>=nz) {
		int ak=step_div(k,nz);
		z-=ak*bz;y-=ak*byz;x-=ak*bxz;k-=ak*nz;
	}

	// Remap particle in the y direction if necessary
	int j=step_int(y*ysp);
	if(j<0||j>=ny) {
		int aj=step_div(j,ny);
		y-=aj*by;x-=aj*bxy;j-=aj*ny;
	}

	// Remap particle in the x direction if necessary
	ijk=step_int(x*xsp);
	if(ijk<0||ijk>=nx) {
		int ai=step_div(ijk,nx);
		x-=ai*bx;ijk-=ai*nx;
	}

	// Compute the block index and check memory allocation
	j+=ey;k+=ez;
	ijk+=nx*(j+oy*k);
	if(co[ijk]==mem[ijk]) add_particle_memory(ijk);
}

// Assembly:
movq %rdx, %r11
movsd (%r8), %xmm1
movsd 0x168(%rdi), %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
cvttsd2si %xmm2, %r10d
subl %eax, %r10d
setns %al
movl 0x130(%rdi), %r9d
cmpl %r9d, %r10d
setl %dl
testb %dl, %al
jne 0x30ff3
testl %r10d, %r10d
js 0x30fa1
movl %r10d, %eax
cltd
idivl %r9d
jmp 0x30fab
leal 0x1(%r10), %eax
cltd
idivl %r9d
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd 0x28(%rdi), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, (%r8)
movsd (%rcx), %xmm1
movsd 0x20(%rdi), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, (%rcx)
movsd (%r11), %xmm1
mulsd 0x18(%rdi), %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%r11)
imull %eax, %r9d
subl %r9d, %r10d
movsd (%rcx), %xmm1
movsd 0x160(%rdi), %xmm2
mulsd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
cvttsd2si %xmm2, %r9d
subl %eax, %r9d
setns %al
movl 0x12c(%rdi), %r8d
cmpl %r8d, %r9d
setl %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x31032
movsd (%r11), %xmm0
jmp 0x3107c
testl %r9d, %r9d
js 0x31040
movl %r9d, %eax
cltd
idivl %r8d
jmp 0x3104a
leal 0x1(%r9), %eax
cltd
idivl %r8d
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd 0x10(%rdi), %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movsd (%r11), %xmm0
mulsd 0x8(%rdi), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%r11)
imull %eax, %r8d
subl %r8d, %r9d
movsd 0x158(%rdi), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
movl %ecx, (%rsi)
setns %al
movl 0x128(%rdi), %r8d
cmpl %r8d, %ecx
setl %dl
testb %dl, %al
jne 0x310ea
testl %ecx, %ecx
js 0x310bd
movl %ecx, %eax
cltd
idivl %r8d
jmp 0x310c6
leal 0x1(%rcx), %eax
cltd
idivl %r8d
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd (%rdi), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r11)
imull %eax, %r8d
subl %r8d, %ecx
movl %ecx, (%rsi)
movl 0x128(%rdi), %r8d
addl 0x180(%rdi), %r9d
addl 0x184(%rdi), %r10d
imull 0x190(%rdi), %r10d
addl %r9d, %r10d
imull %r8d, %r10d
addl %ecx, %r10d
movl %r10d, (%rsi)
movslq %r10d, %rax
movq 0x1b0(%rdi), %rcx
movq 0x1b8(%rdi), %rdx
movl (%rcx,%rax,4), %ecx
cmpl (%rdx,%rax,4), %ecx
jne 0x3112e
movl %r10d, %esi
jmp 0x31900
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double)
void container_periodic_poly::put(int n,double x,double y,double z,double r) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);
	id[ijk][co[ijk]]=n;
	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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm3, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x38(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x30(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x2c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x30f56
movslq (%r13), %r13
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
movsd (%r14), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
testq %rcx, %rcx
jle 0x31219
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x13358
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
incq %r15
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x311ba
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
shlq $0x5, %rdx
movsd %xmm0, (%rcx,%rdx)
movsd %xmm1, 0x8(%rcx,%rdx)
movsd %xmm2, 0x10(%rcx,%rdx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x31270
movsd %xmm0, 0x1d8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double, int&, int&, int&)
void container_periodic::put(int n,double x,double y,double z,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x28(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x20(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x1c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
pushq %rax
pushq %r10
callq 0x313b8
addq $0x10, %rsp
movslq (%r13), %r13
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
movsd (%r14), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
testq %rcx, %rcx
jle 0x31370
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x13358
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
incq %r15
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
addq $0x18, %r14
cmpq %rcx, %r15
jl 0x31313
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
leaq (%rdx,%rdx,2), %rax
movsd %xmm0, (%rcx,%rax,8)
movsd %xmm1, 0x8(%rcx,%rax,8)
movsd %xmm2, 0x10(%rcx,%rax,8)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double, int&, int&, int&)
void container_periodic_poly::put(int n,double x,double y,double z,double r,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);

	id[ijk][co[ijk]]=n;
	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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movsd %xmm3, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x38(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x30(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x2c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
pushq %rax
pushq %r10
callq 0x313b8
addq $0x10, %rsp
movslq (%r13), %r13
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
movsd (%r14), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
testq %rcx, %rcx
jle 0x316bf
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x13358
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
incq %r15
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x31660
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
shlq $0x5, %rdx
movsd %xmm0, (%rcx,%rdx)
movsd %xmm1, 0x8(%rcx,%rdx)
movsd %xmm2, 0x10(%rcx,%rdx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x31716
movsd %xmm0, 0x1d8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x24(%rsp), %r15
movq %r15, %rsi
callq 0x30f56
movl (%r15), %eax
movslq %eax, %r15
movq 0x1a0(%rbx), %rcx
movq 0x1b0(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movslq (%rax,%r15,4), %rdx
movl %ebp, (%rcx,%rdx,4)
movl (%rax,%r15,4), %ebp
movq 0x8(%r14), %rcx
movslq 0x10(%r14), %rdx
shlq $0x2, %rdx
addq (%r14), %rdx
cmpq %rdx, %rcx
jne 0x317ab
movq %r14, %rdi
callq 0x2f102
movq 0x8(%r14), %rcx
movq 0x1b0(%rbx), %rax
movl %r15d, (%rcx)
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl %ebp, 0x4(%rcx)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movslq (%rax,%r15,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r15,4)
leaq (%rdx,%rdx,2), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax,8)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax,8)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x24(%rsp), %r15
movq %r15, %rsi
callq 0x30f56
movl (%r15), %eax
movslq %eax, %r15
movq 0x1a0(%rbx), %rcx
movq 0x1b0(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movslq (%rax,%r15,4), %rdx
movl %ebp, (%rcx,%rdx,4)
movl (%rax,%r15,4), %ebp
movq 0x8(%r14), %rcx
movslq 0x10(%r14), %rdx
shlq $0x2, %rdx
addq (%r14), %rdx
cmpq %rdx, %rcx
jne 0x3188c
movq %r14, %rdi
callq 0x2f102
movq 0x8(%r14), %rcx
movq 0x1b0(%rbx), %rax
movl %r15d, (%rcx)
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl %ebp, 0x4(%rcx)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movslq (%rax,%r15,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r15,4)
shlq $0x5, %rdx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rdx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x318f4
movsd %xmm0, 0x1d8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::add_particle_memory(int)
void container_periodic_base::add_particle_memory(int i) {

	// Handle the case when no memory has been allocated for this block
	if(mem[i]==0) {
		mem[i]=init_mem;
		id[i]=new int[init_mem];
		p[i]=new double[ps*init_mem];
		return;
	}

	// Otherwise, double the memory allocation for this block. Carry out a
	// check on the memory allocation size, and print a status message if
	// requested.
	int l,nmem(mem[i]<<1);
	if(nmem>max_particle_memory)
		voro_fatal_error("Absolute maximum memory allocation exceeded",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=3
	fprintf(stderr,"Particle memory in region %d scaled up to %d\n",i,nmem);
#endif

	// Allocate new memory and copy in the contents of the old arrays
	int *idp=new int[nmem];
	for(l=0;l<co[i];l++) idp[l]=id[i][l];
	double *pp=new double[ps*nmem];
	for(l=0;l<ps*co[i];l++) pp[l]=p[i][l];

	// Update pointers and delete old arrays
	mem[i]=nmem;
	delete [] id[i];id[i]=idp;
	delete [] p[i];p[i]=pp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
testl %ebp, %ebp
je 0x31a22
addl %ebp, %ebp
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x3193f
leaq 0x785b(%rip), %rdi      # 0x39190
movl $0x2, %esi
callq 0x133c5
movslq %ebp, %rdi
shlq $0x2, %rdi
testl %ebp, %ebp
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0x1b0(%rbx), %rax
movslq (%rax,%r12,4), %r13
testq %r13, %r13
jle 0x31987
movq 0x1a0(%rbx), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %r13, %rcx
jb 0x31978
movq %r12, (%rsp)
movl 0x1cc(%rbx), %r12d
movl %r12d, %eax
imull %ebp, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull %r12d, %r13d
movq (%rsp), %r12
testl %r13d, %r13d
jle 0x319e0
movq 0x1a8(%rbx), %rax
movq (%rax,%r12,8), %rax
movl %r13d, %ecx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x319cd
movq 0x1b8(%rbx), %rax
movl %ebp, (%rax,%r12,4)
movq 0x1a0(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x31a07
callq 0x2180
movq 0x1a0(%rbx), %rax
movq %r14, (%rax,%r12,8)
movq 0x1a8(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x31a7a
callq 0x2180
jmp 0x31a73
movslq 0x1c8(%rbx), %r14
leaq (,%r14,4), %rdi
testq %r14, %r14
movl %r14d, (%rax,%r12,4)
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq 0x1a0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movslq 0x1cc(%rbx), %rax
imulq %r14, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
movq 0x1a8(%rbx), %rax
movq %r15, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r15
movsd 0x178(%rdi), %xmm0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x6c5c
leaq 0x1265e(%rip), %rax     # 0x44bc8
movq %rax, (%r14)
movl 0x128(%r15), %edx
movl 0x180(%r15), %eax
movq 0x1b0(%r15), %rbx
movl 0x184(%r15), %r12d
movl 0x188(%r15), %ecx
movl %ecx, 0x20(%rsp)
movl 0x18c(%r15), %ecx
movl %ecx, 0x18(%rsp)
movq %r15, 0x28(%rsp)
movl 0x190(%r15), %ebp
movl %eax, %r15d
imull %r12d, %ebp
addl %eax, %ebp
imull %edx, %ebp
movl %edx, 0x24(%rsp)
movl %edx, %eax
imull %r15d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x14(%rsp)
movslq %ebp, %rax
xorl %r13d, %r13d
cmpl $0x0, (%rbx,%rax,4)
movl %r15d, 0x1c(%rsp)
je 0x325e2
xorl %r14d, %r14d
jmp 0x3261f
xorl %r14d, %r14d
incl %r14d
movl $0x1, %eax
cmpl 0x24(%rsp), %r14d
jne 0x32614
incl %r15d
xorl %r14d, %r14d
cmpl 0x20(%rsp), %r15d
jne 0x32614
incl %r12d
movl 0x1c(%rsp), %r15d
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %r12d
je 0x32691
addl %eax, %ebp
movslq %ebp, %rax
cmpl $0x0, (%rbx,%rax,4)
je 0x325e5
addq $0x1d0, 0x28(%rsp)      # imm = 0x1D0
movl %r12d, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x233aa
incl %r13d
movslq %ebp, %rax
cmpl (%rbx,%rax,4), %r13d
jl 0x32628
incl %r14d
movl $0x1, %eax
cmpl 0x24(%rsp), %r14d
jne 0x32681
incl %r15d
xorl %r14d, %r14d
cmpl 0x20(%rsp), %r15d
jne 0x32681
incl %r12d
movl 0x1c(%rsp), %r15d
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %r12d
je 0x32691
addl %eax, %ebp
movslq %ebp, %rax
cmpl $0x0, (%rbx,%rax,4)
je 0x32652
xorl %r13d, %r13d
jmp 0x32628
leaq 0x30(%rsp), %rdi
callq 0x6ed4
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6ed4
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::sum_cell_volumes()
double container_periodic::sum_cell_volumes() {
	voronoicell c(*this);
	double vol=0;
	c_loop_all_periodic vl(*this);
	if(vl.start()) do if(compute_cell(c,vl)) vol+=c.volume();while(vl.inc());
	return vol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r15
movsd 0x178(%rdi), %xmm0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x6c5c
leaq 0x1234e(%rip), %rax     # 0x44bc8
movq %rax, (%r14)
movl 0x128(%r15), %edx
movl 0x180(%r15), %eax
movq 0x1b0(%r15), %rbx
movl 0x184(%r15), %r12d
movl 0x188(%r15), %ecx
movl %ecx, 0x14(%rsp)
movl 0x18c(%r15), %ecx
movl %ecx, 0xc(%rsp)
movl %edx, %ecx
movq %r15, 0x28(%rsp)
movl 0x190(%r15), %ebp
movl %eax, %r15d
imull %r12d, %ebp
addl %eax, %ebp
imull %edx, %ebp
movl %edx, %eax
imull %r15d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x8(%rsp)
movslq %ebp, %rax
cmpl $0x0, (%rbx,%rax,4)
movl %r15d, 0x10(%rsp)
je 0x328ed
xorl %r14d, %r14d
jmp 0x3292c
xorl %r14d, %r14d
incl %r14d
movl $0x1, %eax
cmpl %ecx, %r14d
jne 0x32921
incl %r15d
xorl %r14d, %r14d
cmpl 0x14(%rsp), %r15d
jne 0x32921
incl %r12d
movl 0x10(%rsp), %r15d
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %r12d
je 0x329cf
addl %eax, %ebp
movslq %ebp, %rax
cmpl $0x0, (%rbx,%rax,4)
je 0x328f0
movl %ecx, 0x24(%rsp)
addq $0x1d0, 0x28(%rsp)      # imm = 0x1D0
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %ecx, %ecx
movl %r12d, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %edx
movl %ecx, %r13d
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x233aa
testb %al, %al
je 0x32981
leaq 0x30(%rsp), %rdi
callq 0x843c
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movl %r13d, %ecx
incl %ecx
movslq %ebp, %rax
cmpl (%rbx,%rax,4), %ecx
jl 0x32945
movl 0x24(%rsp), %ecx
incl %r14d
movl $0x1, %eax
cmpl %ecx, %r14d
jne 0x329bf
incl %r15d
xorl %r14d, %r14d
cmpl 0x14(%rsp), %r15d
jne 0x329bf
incl %r12d
movl 0x10(%rsp), %r15d
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %r12d
je 0x329d9
addl %eax, %ebp
movslq %ebp, %rax
cmpl $0x0, (%rbx,%rax,4)
je 0x32992
jmp 0x32943
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6ed4
movsd 0x18(%rsp), %xmm0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6ed4
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33270
movq %r15, %rdi
movl %r14d, %esi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x31900
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 0x332d4
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_O3/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 0x7721(%rip), %rsi      # 0x3d691
movq %rbx, %rdi
movaps %xmm2, %xmm4
movb $0x5, %al
callq 0x21b0
movsd (%r14), %xmm6
movsd 0x8(%r14), %xmm3
movsd 0x18(%r14), %xmm4
movapd %xmm3, %xmm0
addsd %xmm4, %xmm0
movsd 0x20(%r14), %xmm7
movsd 0x10(%r14), %xmm1
addsd %xmm7, %xmm1
movsd 0x28(%r14), %xmm2
addsd %xmm6, %xmm3
addsd %xmm4, %xmm3
addsd %xmm4, %xmm6
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x323b(%rip), %rsi      # 0x39211
movq %rbx, %rdi
movapd %xmm1, %xmm4
movaps %xmm2, %xmm5
movb $0x8, %al
callq 0x21b0
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x18(%r14), %xmm2
movsd 0x20(%r14), %xmm3
movsd 0x28(%r14), %xmm4
movapd %xmm0, %xmm5
addsd %xmm2, %xmm5
movapd %xmm1, %xmm6
addsd %xmm3, %xmm6
leaq 0x7693(%rip), %rsi      # 0x3d6af
movq %rbx, %rdi
movaps %xmm4, %xmm7
movb $0x8, %al
callq 0x21b0
movsd 0x18(%r14), %xmm6
movsd (%r14), %xmm0
movsd 0x10(%r14), %xmm5
movapd %xmm0, %xmm1
addsd %xmm6, %xmm1
movsd 0x20(%r14), %xmm2
movsd 0x28(%r14), %xmm3
movsd 0x8(%r14), %xmm4
addsd %xmm0, %xmm4
addsd %xmm4, %xmm6
movapd %xmm2, %xmm7
addsd %xmm5, %xmm7
movsd %xmm3, (%rsp)
leaq 0x7662(%rip), %rsi      # 0x3d6d2
movq %rbx, %rdi
movb $0x8, %al
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/vjeux[P]jspp/example/../src/operators.h
// Function: operator==(Object, Object)
bool operator ==(Object a, Object b) {
	if (a.s->type == UNDEFINED && b.s->type == UNDEFINED) {
		return true;
	}
	if (a.s->type == NUMBER && b.s->type == NUMBER) {
		return a.s->n == b.s->n;
	}
	if (a.s->type == STRING && b.s->type == STRING) {
		return a.s->s == b.s->s;
	}
	return a.s == b.s;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x256e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x9700
movq %rsp, %rsi
movq %r14, %rdi
callq 0x60d0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x604e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %r14, (%rbx)
movq 0x10(%r14), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
callq 0x8e4a
movq %rax, 0x8(%rbx)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6082
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x60ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x60ad
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60c8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
addq $0x8, %rdi
callq 0x8e4a
movq %rax, %rbx
movq (%rax), %rax
leaq 0x60(%rsp), %rdi
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
incl (%rax)
movq 0x9079(%rip), %rax      # 0xf190
leaq 0x48(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x9076(%rip), %rax      # 0xf1a0
movq %rax, 0x10(%rsi)
incl (%rax)
callq 0x552e
testb %al, %al
je 0x6299
movq 0x10(%r15), %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x504a(%rip), %rsi      # 0xb19b
leaq 0x504c(%rip), %rdx      # 0xb1a4
leaq 0x8(%rsp), %rdi
callq 0x9796
addq $0x8, %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x8ec6
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 0x8ff7(%rip), %rax      # 0xf190
leaq 0x78(%rsp), %r13
movq %rax, (%r13)
movq %r13, 0x8(%r13)
movq 0x8ff3(%rip), %rax      # 0xf1a0
movq %rax, 0x10(%r13)
incl (%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x55a4
movl %eax, %ebp
movq %r13, %rdi
callq 0x8d48
movq %r12, %rdi
callq 0x8d48
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x61ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
leaq 0x48(%rsp), %rdi
callq 0x8d48
leaq 0x60(%rsp), %rdi
callq 0x8d48
testb %bpl, %bpl
je 0x62ad
movq 0x10(%r15), %rbx
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x4f7f(%rip), %rsi      # 0xb19b
leaq 0x4f81(%rip), %rdx      # 0xb1a4
callq 0x9796
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8ec6
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x9700
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x60d0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6280
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x62ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x62ad
leaq 0x48(%rsp), %rdi
callq 0x8d48
leaq 0x60(%rsp), %rdi
callq 0x8d48
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x62e6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x62e6
movq %rax, %rbx
jmp 0x633c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x633c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x633c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6328
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x6328
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8d48
leaq 0x60(%rsp), %rdi
callq 0x8d48
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/vjeux[P]jspp/example/../src/constructors.h
// Function: Object::operator|=(Object)
Object& Object::operator|= (Object o) {
	write->s->refcount += 1;
	
	write->s->type = o.s->type;
	write->s->s = o.s->s;
	write->s->n = o.s->n;
	write->s->map = o.s->map;
	write->s->kv = o.s->kv;

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

	return *write;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
incl (%rdi)
movq 0x10(%rsi), %rsi
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x2100
movq 0x10(%r14), %rsi
movsd 0x40(%rsi), %xmm0
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
movsd %xmm0, 0x40(%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x92c4
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 0x8f42
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x8fa8
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x900e
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x9074
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x90da
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
movq 0x8(%rbx), %rax
addq 0x10(%rax), %rdi
callq 0x9140
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/vjeux[P]jspp/example/../src/constructors.h
// Function: New(Object)
Object New(Object o) {
	Object n;

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

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

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8522(%rip), %rax      # 0xf190
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movl $0x138, %edi            # imm = 0x138
callq 0x21a0
movq %rax, %r15
movl $0x1, (%rax)
addq $0x10, %rax
movl $0x0, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %rcx, 0x30(%r15)
leaq 0x58(%r15), %rax
movq %rax, 0x48(%r15)
movq %rcx, 0x50(%r15)
movb $0x0, 0x58(%r15)
leaq 0x70(%r15), %r12
movl $0xc0, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
movq %r15, 0x10(%rbx)
movl $0x2, 0x38(%r15)
movq 0x10(%r14), %rsi
movl 0x68(%rsi), %eax
movl %eax, 0x68(%r15)
addq $0x70, %rsi
movq %r12, %rdi
callq 0x8f42
movl $0x90, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x8fa8
movl $0xb0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x900e
movl $0xd0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x9074
movl $0xf0, %edi
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x90da
movl $0x110, %edi            # imm = 0x110
movq 0x10(%r14), %rsi
addq %rdi, %rsi
addq 0x10(%rbx), %rdi
callq 0x9140
movq %rbx, (%rbx)
leaq 0x4445(%rip), %rsi      # 0xb1a5
leaq 0x18(%rsp), %rdi
callq 0x6678
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x5ff6
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 0x4404(%rip), %rsi      # 0xb19b
movq %rsp, %rdi
callq 0x6678
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ff6
leaq 0x30(%rsp), %r14
movq 0x10(%r14), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
incl (%rcx)
movq %rsp, %rdi
callq 0x8d48
movq %r14, %rdi
callq 0x8d48
leaq 0x18(%rsp), %rdi
callq 0x8d48
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x8d48
jmp 0x6df6
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x8d48
jmp 0x6e05
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x8d48
jmp 0x6e14
movq %rax, %r14
movq %rbx, %rdi
callq 0x8d48
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8e32
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x8d75
leaq 0x110(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x100(%rbx), %rax
testq %rax, %rax
je 0x8d92
leaq 0xf0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe0(%rbx), %rax
testq %rax, %rax
je 0x8daf
leaq 0xd0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xc0(%rbx), %rax
testq %rax, %rax
je 0x8dcc
leaq 0xb0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa0(%rbx), %rax
testq %rax, %rax
je 0x8de9
leaq 0x90(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x8e03
leaq 0x70(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x8e1b
movq (%rax), %rsi
incq %rsi
callq 0x21b0
leaq 0x8(%rbx), %rdi
callq 0x9240
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
popq %rbx
jmp 0x21b0
decl %eax
movl %eax, (%rbx)
popq %rbx
retq
jmp 0x8e42
jmp 0x8e42
jmp 0x8e42
jmp 0x8e42
jmp 0x8e42
movq %rax, %rdi
callq 0x9235
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./assignment1.hpp
// Function: assignment1::scheduling_problem::computeScoreDiff(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int>>> const&)
std::vector<std::tuple<int, job>> computeScoreDiff(const std::vector<job>& jobs)
        {
            std::vector<std::tuple<int, job>> scores;	// we'll assign score for each job

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

            return scores;
        }

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

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

            return scores;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x2830
leaq 0x8(%rsp), %r14
movq (%r15), %rax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %rax, 0x8(%rsp)
shrq $0x20, %rax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb160
addq $0x8, %r15
cmpq %r12, %r15
jne 0x27f8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x284f
callq 0x21f0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
movq %r14, %rdi
callq 0x274c
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r14, %rbx
je 0x2920
movq %r14, %r15
subq %rbx, %r15
movq %r15, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x770a
cmpq $0xc1, %r15
jl 0x28e1
leaq 0xc0(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c47
cmpq %r14, %r15
je 0x28ec
movq %r15, %rdi
callq 0x7d21
addq $0xc, %r15
jmp 0x28ce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c47
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq %rax, %rbx
je 0x2920
xorl %r14d, %r14d
movq %rbx, %rdx
movq (%rdx), %rsi
addl %esi, %ecx
shrq $0x20, %rsi
imull %ecx, %esi
movslq %esi, %rsi
addq %rsi, %r14
addq $0xc, %rdx
cmpq %rax, %rdx
jne 0x2903
jmp 0x2923
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2930
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
movq %r14, %rdi
callq 0x27c9
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r14, %rbx
je 0x29f8
movq %r14, %r15
subq %rbx, %r15
movq %r15, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d5f
cmpq $0x101, %r15            # imm = 0x101
jl 0x29b9
leaq 0x100(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8296
cmpq %r14, %r15
je 0x29c4
movq %r15, %rdi
callq 0x835a
addq $0x10, %r15
jmp 0x29a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8296
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq %rax, %rbx
je 0x29f8
xorl %r14d, %r14d
movq %rbx, %rdx
movq (%rdx), %rsi
addl %esi, %ecx
shrq $0x20, %rsi
imull %ecx, %esi
movslq %esi, %rsi
addq %rsi, %r14
addq $0x10, %rdx
cmpq %rax, %rdx
jne 0x29db
jmp 0x29fb
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2a08
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::TestCase2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TestCase2(const std::string inputFile)
    {
        std::ifstream file(inputFile, std::ios::in);

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

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

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

            return distances;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x2, %edx
je 0x3bf9
cmpl $0x1, %edx
jne 0x3c52
movl $0x1, (%rsp)
testl %ebp, %ebp
jle 0x3c52
movl $0x1, %eax
movq %rsp, %r14
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3be0
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3beb
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb90c
movl (%rsp), %eax
addl %eax, %eax
movl %eax, (%rsp)
decl %ebp
jne 0x3bca
jmp 0x3c52
testl %ebp, %ebp
jle 0x3c52
movl $0x1, %r15d
xorl %r12d, %r12d
leaq 0x4(%rsp), %r14
incl %r12d
movl %r12d, %r13d
cmpl %ebp, %r12d
jge 0x3c4a
movl %r15d, %eax
btsl %r13d, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3c37
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3c42
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb90c
incl %r13d
cmpl %r13d, %ebp
jne 0x3c16
addl %r15d, %r15d
cmpl %ebp, %r12d
jne 0x3c0b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c66
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c76
callq 0x21f0
movq %r14, %rdi
callq 0x2350