LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq %rax, %rdx
leaq 0x20(%rsp), %r14
movsd %xmm1, (%r14)
leaq 0x18(%rsp), %r15
movsd %xmm2, (%r15)
leaq 0x14(%rsp), %rbx
movq %rbx, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x3952e
movslq (%rbx), %rbx
movq 0x150(%r12), %rax
movq 0x160(%r12), %rcx
movq (%rax,%rbx,8), %rax
movslq (%rcx,%rbx,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%rbx,4), %edx
movq %r13, %rdi
movl %ebx, %esi
callq 0x223bc
movq 0x158(%r12), %rax
movq 0x160(%r12), %rcx
movq (%rax,%rbx,8), %rax
movslq (%rcx,%rbx,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%rbx,4)
imulq $0x18, %rdx, %rcx
leaq 0x8(%rsp), %rdx
movsd (%rdx), %xmm0
movsd %xmm0, (%rax,%rcx)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rax,%rcx)
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rax,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, (%rsp)
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq %rax, %rdx
leaq 0x20(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x18(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x14(%rsp), %r14
movq %r14, %rsi
movq %r15, %rcx
movq %r12, %r8
callq 0x3952e
movslq (%r14), %r14
movq 0x150(%rbx), %rax
movq 0x160(%rbx), %rcx
movq (%rax,%r14,8), %rax
movslq (%rcx,%r14,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%r14,4), %edx
movq %r13, %rdi
movl %r14d, %esi
callq 0x223bc
movsd (%rsp), %xmm1
movq 0x158(%rbx), %rax
movq 0x160(%rbx), %rcx
movq (%rax,%r14,8), %rax
movslq (%rcx,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%r14,4)
shlq $0x5, %rdx
leaq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax,%rdx)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rax,%rdx)
movsd (%r12), %xmm0
movsd %xmm0, 0x10(%rax,%rdx)
movsd %xmm1, 0x18(%rax,%rdx)
ucomisd 0x188(%rbx), %xmm1
jbe 0x39d0f
movsd %xmm1, 0x188(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/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
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x168(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
testl %ebp, %ebp
je 0x39e4a
addl %ebp, %ebp
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x39d5e
leaq 0xafac(%rip), %rdi      # 0x44d02
pushq $0x2
popq %rsi
callq 0x1c1ae
movslq %ebp, %rdi
shlq $0x2, %rdi
testl %ebp, %ebp
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x7030
movq %rax, %r14
movq 0x150(%rbx), %r13
movq %rbx, 0x8(%rsp)
movq 0x160(%rbx), %rax
movslq (%rax,%r12,4), %rbx
xorl %eax, %eax
cmpq %rbx, %rax
jge 0x39da6
movq (%r13,%r12,8), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0x39d90
movq 0x8(%rsp), %rax
movl 0x17c(%rax), %eax
movl %eax, 0x14(%rsp)
imull %ebp, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x7030
movq %rax, %r15
imull 0x14(%rsp), %ebx
movq 0x8(%rsp), %rax
movq 0x158(%rax), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x39e01
movq (%rax,%r12,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
incq %rcx
jmp 0x39de8
movq 0x8(%rsp), %rbx
movq 0x168(%rbx), %rax
movl %ebp, (%rax,%r12,4)
movq (%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x39e27
callq 0x7470
movq 0x150(%rbx), %r13
movq %r14, (%r13,%r12,8)
movq 0x158(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x39ea2
callq 0x7470
movq 0x158(%rbx), %rax
jmp 0x39ea2
movq %rbx, %r13
movslq 0x178(%rbx), %rbx
leaq (,%rbx,4), %rdi
testq %rbx, %rbx
movl %ebx, (%rax,%r12,4)
pushq $-0x1
popq %r14
cmovsq %r14, %rdi
callq 0x7030
movq 0x150(%r13), %rcx
movq %rax, (%rcx,%r12,8)
movslq 0x17c(%r13), %rax
imulq %rbx, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %r14, %rdi
callq 0x7030
movq %rax, %r15
movq 0x158(%r13), %rax
movq %r15, (%rax,%r12,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic::compute_all_cells()
void container_periodic::compute_all_cells() {
	voronoicell c;
	c_loop_all_periodic vl(*this);
	if(vl.start()) do compute_cell(c,vl);
	while(vl.inc());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf846
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3bab2
movq %rsp, %rdi
callq 0x3be6e
testb %al, %al
je 0x3a6cc
leaq 0x60(%rsp), %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3beb2
movq %r15, %rdi
callq 0x3bed8
testb %al, %al
jne 0x3a6b2
leaq 0x60(%rsp), %rdi
callq 0x16e1a
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3a6e5
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x16e1a
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic::sum_cell_volumes()
double container_periodic::sum_cell_volumes() {
	voronoicell c;
	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 %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf846
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x3bab2
leaq 0x10(%rsp), %rdi
callq 0x3be6e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testb %al, %al
je 0x3a7fe
movsd %xmm0, 0x8(%rsp)
leaq 0x70(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3beb2
testb %al, %al
je 0x3a7f2
movq %r14, %rdi
callq 0x1780a
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0x3bed8
testb %al, %al
jne 0x3a7c8
leaq 0x70(%rsp), %rdi
callq 0x16e1a
movsd 0x8(%rsp), %xmm0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3a81d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x16e1a
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic_poly::sum_cell_volumes()
double container_periodic_poly::sum_cell_volumes() {
	voronoicell c;
	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 %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf846
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x3bc92
leaq 0x10(%rsp), %rdi
callq 0x3be6e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testb %al, %al
je 0x3a8b6
movsd %xmm0, 0x8(%rsp)
leaq 0x70(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3bf14
testb %al, %al
je 0x3a8aa
movq %r14, %rdi
callq 0x1780a
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0x3bed8
testb %al, %al
jne 0x3a880
leaq 0x70(%rsp), %rdi
callq 0x16e1a
movsd 0x8(%rsp), %xmm0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3a8d5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x16e1a
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/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 0x160(%rdi), %rax
movq 0x168(%rdi), %rdx
movslq %esi, %r14
movl (%rax,%r14,4), %ecx
cmpl (%rdx,%r14,4), %ecx
jne 0x3ae94
movq %r15, %rdi
movl %r14d, %esi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x39d1e
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x160(%r15), %rax
movl (%rax,%r14,4), %ecx
movq 0x158(%r15), %r8
movq (%r8,%r14,8), %rdx
movl 0x17c(%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 0x3aef8
movsd 0x18(%r8,%r9,8), %xmm0
movsd %xmm0, 0x18(%rdx,%rdi,8)
movq 0x150(%r15), %rdx
movq (%rdx,%rsi,8), %rsi
movslq %ebx, %rdi
movl (%rsi,%rdi,4), %esi
movq (%rdx,%r14,8), %rdx
leal 0x1(%rcx), %edi
movl %edi, (%rax,%r14,4)
movslq %ecx, %rax
movl %esi, (%rdx,%rax,4)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/unitcell.cc
// Function: voro::unitcell::unit_voro_intersect(int)
bool unitcell::unit_voro_intersect(int l) {
	int i,j;
	if(unit_voro_test(l,0,0)) return true;
	for(i=1;i<l;i++) {
		if(unit_voro_test(l,i,0)) return true;
		if(unit_voro_test(-l,i,0)) return true;
	}
	for(i=-l;i<=l;i++) if(unit_voro_test(i,l,0)) return true;
	for(i=1;i<l;i++) for(j=-l+1;j<=l;j++) {
		if(unit_voro_test(l,j,i)) return true;
		if(unit_voro_test(-j,l,i)) return true;
		if(unit_voro_test(-l,-j,i)) return true;
		if(unit_voro_test(j,-l,i)) return true;
	}
	for(i=-l;i<=l;i++) for(j=-l;j<=l;j++) if(unit_voro_test(i,j,l)) return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3cefe
movb $0x1, %r12b
testb %al, %al
jne 0x3c486
movl %r14d, %ebp
negl %ebp
pushq $0x1
popq %rbx
cmpl %r14d, %ebx
jge 0x3c3b2
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x3cefe
testb %al, %al
jne 0x3c486
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x3cefe
incl %ebx
testb %al, %al
je 0x3c37d
jmp 0x3c486
movl %ebp, %ebx
cmpl %r14d, %ebx
jg 0x3c3d3
movq %r15, %rdi
movl %ebx, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x3cefe
incl %ebx
testb %al, %al
je 0x3c3b4
jmp 0x3c486
pushq $0x1
popq %r12
movl %r12d, %ebx
subl %r14d, %ebx
leal -0x1(%r14), %r13d
movl %ebx, 0x4(%rsp)
movl %r13d, (%rsp)
cmpl %r14d, %r12d
jge 0x3c457
cmpl %r14d, %ebx
jg 0x3c44a
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r12d, %ecx
callq 0x3cefe
testb %al, %al
jne 0x3c483
movq %r15, %rdi
movl %r13d, %esi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x3cefe
testb %al, %al
jne 0x3c483
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x3cefe
testb %al, %al
jne 0x3c483
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x3cefe
incl %ebx
decl %r13d
testb %al, %al
je 0x3c3ee
jmp 0x3c483
incl %r12d
movl 0x4(%rsp), %ebx
movl (%rsp), %r13d
jmp 0x3c3e9
movl %ebp, %ebx
cmpl %r14d, %ebx
jg 0x3c498
movl %ebp, %r12d
cmpl %r14d, %r12d
jg 0x3c47f
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x3cefe
incl %r12d
testb %al, %al
je 0x3c461
jmp 0x3c483
incl %ebx
jmp 0x3c459
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x3c486
nop
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: print_element(user_data*)
void print_element(user_data* data)
{
    if (data->show_filename) std::cout << data->filename << ": ";
    print_stack(data->stack.begin(), data->stack.end());
    if (!data->keys_only) {
        std::cout << "\t" << data->current;
    }
    std::cout << "\n";

    print_atts(data->stack.begin(), data->stack.end(), data->atts.begin(), data->atts.end(), data);
    data->atts.clear();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x5c(%rdi)
je 0x23c7
movq (%rbx), %rsi
movq 0x2c1d(%rip), %rdi      # 0x4fd0
callq 0x2150
leaq 0xc52(%rip), %rsi       # 0x3011
movq %rax, %rdi
callq 0x2150
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x27b1
cmpl $0x0, 0x58(%rbx)
jne 0x23f9
movq 0x2bef(%rip), %rdi      # 0x4fd0
leaq 0xc1c(%rip), %rsi       # 0x3004
callq 0x2150
leaq 0x38(%rbx), %rsi
movq %rax, %rdi
callq 0x2130
movq 0x2bd0(%rip), %rdi      # 0x4fd0
leaq 0xbff(%rip), %rsi       # 0x3006
callq 0x2150
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq %rbx, %r8
callq 0x2812
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28e0
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts)
{
    user_data* data = (user_data*)udata;

    // print previous element
    print_element(data);
    data->current.clear();

    data->stack.emplace_back(name);
    while (*atts) data->atts.emplace_back(*atts++);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
callq 0x239c
andq $0x0, 0x40(%rbx)
movq 0x38(%rbx), %rax
movb $0x0, (%rax)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x28e8
addq $0x20, %rbx
cmpq $0x0, (%r14)
je 0x2489
leaq 0x8(%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e8
movq %r15, %r14
jmp 0x246f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: root_end_element_handler(void*, char const*)
void root_end_element_handler(void* udata, const XML_Char* name)
{
    user_data* data = (user_data*)udata;
    print_element(data);
    data->current.clear();
    data->stack.pop_back();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x239c
andq $0x0, 0x40(%rbx)
movq 0x38(%rbx), %rax
movb $0x0, (%rax)
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2922
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: character_data_handler(void*, char const*, int)
void character_data_handler(void* udata, const XML_Char* s, int len)
{
    user_data* data = (user_data*)udata;
    string_view x{s, size_t(len)};

    auto trimmed = trim(x);

    if (trimmed.size())
        data->current.append(trimmed.begin(), trimmed.end());
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %edx, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
callq 0x2936
testq %rax, %rax
je 0x24e9
addq $0x38, %rbx
addq %rdx, %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x296c
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: void print_atts<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, user_data*)
void print_atts(I f0, I l0, I f1, I l1, user_data* data)
{
    while (f1 != l1) {

        if (data->show_filename)
            std::cout << data->filename << ": ";

        print_stack(f0, l0);
        std::cout << "@" << *f1;
        ++f1;

        if (!data->keys_only)
            std::cout << "\t" << *f1;

        ++f1;
        std::cout << "\n";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x279d(%rip), %rbp      # 0x4fd0
movq %rcx, (%rsp)
cmpq %r14, %r15
je 0x28d1
cmpl $0x0, 0x5c(%rbx)
je 0x2860
movq (%rbx), %rsi
movq %rbp, %rdi
callq 0x2150
movq %rax, %rdi
leaq 0x7b6(%rip), %rsi       # 0x3011
callq 0x2150
movq %r13, %rdi
movq %r12, %rsi
callq 0x27b1
movq %rbp, %rdi
leaq 0x7b3(%rip), %rsi       # 0x3028
callq 0x2150
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
cmpl $0x0, 0x58(%rbx)
jne 0x28b9
movq %r13, %r14
movq %r12, %r13
leaq 0x20(%r15), %r12
movq %rbp, %rdi
leaq 0x765(%rip), %rsi       # 0x3004
callq 0x2150
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %r12
movq %r14, %r13
movq (%rsp), %r14
callq 0x2130
addq $0x40, %r15
movq %rbp, %rdi
leaq 0x73f(%rip), %rsi       # 0x3006
callq 0x2150
jmp 0x2837
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::inTec_Zone(inTec_File*)
inTec_Zone::inTec_Zone( inTec_File* file_ )
{
#ifdef _DEBUG_
   printf(" i Zone object instantiated\n");
#endif
   istate = 0;
   ipos = 0;
   ipos_data = 0;
   ipos_conn = 0;

   // keyword-based variables
   tkey = NULL;
   ietype = -1;
   idatapack = -1;
   im = 0;
   jm = 0;
   km = 0;
   nodes = 0;
   elems = 0;
   nv = 0;
   parent_zone = -1;

   // old-style variables
   iold_n = 0;
   iold_e = 0;
   iold_et = -1;
   iold_f = -1;

   // utility variables
   iparse_num = 0;
   node_cnt = 0;
   elem_cnt = 0;
   var_cnt = 0;
   icon_cnt = 0;

   InitKeywords();

   file = file_;
   num_var = 0;
   icon = NULL;
   ncon = 0;
   // if the zone has a parent file, get the number of variables, etc
   if( file != NULL ) {
      num_var = file->GetNumVariables();
      // default all variables to nodal
      for(int n=1;n<=num_var;++n) ivar_loc[n] = 1;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xd4ef(%rip), %rax      # 0x14fe0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x58(%rdi), %rbx
leaq 0x60(%rdi), %rax
andl $0x0, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
andl $0x0, 0xf0(%rdi)
leaq 0xf0(%rdi), %rax
andq $0x0, 0xf8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movq %rax, 0x100(%rdi)
movq %rax, 0x108(%rdi)
andq $0x0, 0x110(%rdi)
leaq 0x84a0(%rip), %rdi      # 0xfff5
callq 0x77b0
andl $0x0, 0x8(%r14)
andq $0x0, 0x10(%r14)
andq $0x0, 0xe0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r14)
orq $-0x1, 0x18(%r14)
andq $0x0, 0x50(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x24(%r14)
movups %xmm0, 0xb0(%r14)
orq $-0x1, 0xc0(%r14)
andl $0x0, 0x118(%r14)
andq $0x0, 0x138(%r14)
movups %xmm0, 0x120(%r14)
andl $0x0, 0x130(%r14)
movq %r14, %rdi
callq 0x71a0
movq %r15, 0xc8(%r14)
andl $0x0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
testq %r15, %r15
je 0x7c2b
movq 0x168(%r15), %rax
subq 0x160(%r15), %rax
shrq $0x5, %rax
movl %eax, 0x20(%r14)
pushq $0x1
popq %rcx
leaq 0x4(%rsp), %r15
movl %ecx, 0x4(%rsp)
cmpl %eax, %ecx
jg 0x7c2b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72d0
movl $0x1, (%rax)
movl 0x4(%rsp), %ecx
incl %ecx
movl 0x20(%r14), %eax
jmp 0x7c06
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7c39
movq %rax, %r15
leaq 0x88(%r14), %r12
addq $0xe8, %r14
movq %r14, %rdi
callq 0x7410
movq %r12, %rdi
callq 0x7130
movq %rbx, %rdi
callq 0x7220
movq %r15, %rdi
callq 0x78d0
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::InitKeywords()
void inTec_Zone::InitKeywords()
{
   // add TecPlot keywords with default values
// keywords["T"] = "";
   keywords["ZONETYPE"] = "ORDERED";
// keywords["I"] = "";
// keywords["J"] = "";
// keywords["K"] = "";
// keywords["NODES"] = "";
// keywords["ELEMENTS"] = "";
// keywords["FACES"] = "";
// keywords["TOTALNUMFACENODES"] = "";
// keywords["NUMCONNECTEDBOUNDARYFACES"] = "";
// keywords["TOTALNUMBOUNDARYCONNECTIONS"] = "";
// keywords["FACENEIGBORMODE"] = "LOCALONETOONE";
// keywords["FACENEIGHBORCONNECTIONS"] = "";
   keywords["DT"] = "SINGLE";
   keywords["DATAPACKING"] = "BLOCK";
   keywords["VARLOCATION"] = "(NODAL)";
// keywords["VARSHARELIST"] = "";
// keywords["NV"] = "";
// keywords["CONNECTIVITYSHAREZONE"] = "";
// keywords["STRANDID"] = "";
// keywords["SOLUTIONTIME"] = "";
// keywords["PARENTZONE"] = "";
// keywords["PASSIVEVARLIST"] = "";
// keywords["AUXDATA"] = "";
// keywords[""] = "";

   // keywords from the old format
// keywords["E"] = "";
// keywords["N"] = "";
// keywords["ET"] = "";

}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x761b(%rip), %rsi      # 0xf294
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7890
addq $0xe8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7950
leaq 0x75e9(%rip), %rsi      # 0xf28c
movq %rax, %rdi
callq 0x7990
leaq 0x10(%rsp), %rdi
callq 0x7200
leaq 0x75e8(%rip), %rsi      # 0xf2a4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7890
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7950
leaq 0x75be(%rip), %rsi      # 0xf29d
movq %rax, %rdi
callq 0x7990
leaq 0x10(%rsp), %rdi
callq 0x7200
leaq 0x75b5(%rip), %rsi      # 0xf2ad
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7890
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7950
leaq 0x758c(%rip), %rsi      # 0xf2a7
movq %rax, %rdi
callq 0x7990
leaq 0x10(%rsp), %rdi
callq 0x7200
leaq 0x758d(%rip), %rsi      # 0xf2c1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7890
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7950
leaq 0x7562(%rip), %rsi      # 0xf2b9
movq %rax, %rdi
callq 0x7990
leaq 0x10(%rsp), %rdi
callq 0x7200
addq $0x30, %rsp
popq %rbx
retq
jmp 0x7d75
jmp 0x7d75
jmp 0x7d75
movq %rax, %rbx
jmp 0x7d8d
jmp 0x7d80
jmp 0x7d80
jmp 0x7d80
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x78d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::~inTec_Zone()
inTec_Zone::~inTec_Zone()
{
#ifdef _DEBUG_
   printf(" i Zone object deconstructed\n");
#endif

   clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd22b(%rip), %rax      # 0x14fe0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x824e(%rip), %rdi      # 0x10011
callq 0x77b0
movq %rbx, %rdi
callq 0x79a0
leaq 0xe8(%rbx), %rdi
callq 0x7410
leaq 0x88(%rbx), %rdi
callq 0x7130
addq $0x58, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7220
movq %rax, %rdi
callq 0xd4c6
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::NotifyDataPositionInFile(long)
int inTec_Zone::NotifyDataPositionInFile( long ipos_data_ )
{
   // reject reseting of position if it is already set
   if( ipos_data != 0 ) {
      return(1);
   } else {   // this is for when a zone is created but not read from a file
      ipos_data = ipos_data_;
#ifdef _DEBUG_
      printf(" --- Zone's data position at: %ld \n", ipos_data );
#endif
      return(0);
   }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0xd8(%rdi)
je 0x8094
pushq $0x1
popq %rbx
jmp 0x80ab
movq %rsi, 0xd8(%rdi)
leaq 0x722b(%rip), %rdi      # 0xf2cd
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x7060
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::SetState_Reading()
int inTec_Zone::SetState_Reading( void )
{
   if( istate != 0 ) {
      // this is an error code that implies prior setting of the state
      return(1);
   }

   // use whatever keywords hava been collected to manage the internal state
   int iret = ManageInternals();
   if( iret == 0 ) {
      istate = 1;
      return(0);
   } else {
      // this is an error code that should imply an inconsistency
      return(2);
   }
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
je 0x80ba
pushq $0x1
popq %rax
retq
pushq %rbx
movq %rdi, %rbx
callq 0x7670
testl %eax, %eax
je 0x80cc
pushq $0x2
popq %rax
jmp 0x80d5
movl $0x1, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_T(char const*)
int inTec_Zone::HandleKeyword_T( const char *string )
{
   // make a duplicate buffer
   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;
   char *buf = (char *) malloc(is*sizeof(char));
   if( buf == NULL ) return(-1);

   memcpy( buf, string, is );
   tkey = buf;

   return(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x92d4
cmpl $0xa, %eax
je 0x92d4
incq %r15
jmp 0x92c1
movq %r15, %rdi
callq 0x76e0
testq %rax, %rax
je 0x92fa
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73e0
movq %r12, 0x10(%rbx)
xorl %eax, %eax
jmp 0x92fd
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_ET(char const*)
int inTec_Zone::HandleKeyword_ET( const char *string )
{
   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;

   // default is to place a number so that it is know ET was set
   iold_et = 999;

   if( is == 5 ) {
      if( strncasecmp( string, "BRICK", 5 ) == 0 ) iold_et = FEBRICK;
   }

   if( is == 8 ) {
      if( strncasecmp( string, "TRIANGLE", 8 ) == 0 ) iold_et = FETRIANGLE;
   }

   if( is == 11 ) {
      if( strncasecmp( string, "TETRAHEDRON", 11 ) == 0 )
         iold_et = FETETRAHEDRON;
   }

   if( is == 13 ) {
      if( strncasecmp( string, "QUADRILATERAL", 13 ) == 0 )
         iold_et = FEQUADRILATERAL;
   }

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0x9322
cmpl $0xa, %ecx
je 0x9322
incq %rax
jmp 0x9310
movl $0x3e7, 0xc0(%rbx)      # imm = 0x3E7
addq $-0x5, %rax
cmpq $0x8, %rax
ja 0x93c3
leaq 0x5d93(%rip), %rcx      # 0xf0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x63fe(%rip), %rax      # 0xf74f
pushq $0x5
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x7650
testl %eax, %eax
jne 0x93c3
pushq $0x6
jmp 0x93bc
leaq 0x6415(%rip), %rax      # 0xf783
pushq $0xb
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x7650
testl %eax, %eax
jne 0x93c3
pushq $0x5
jmp 0x93bc
leaq 0x63e0(%rip), %rax      # 0xf76b
pushq $0x8
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x7650
testl %eax, %eax
jne 0x93c3
pushq $0x2
jmp 0x93bc
leaq 0x63e9(%rip), %rax      # 0xf791
pushq $0xd
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x7650
testl %eax, %eax
jne 0x93c3
pushq $0x3
popq %rax
movl %eax, 0xc0(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_Datapacking(char const*)
int inTec_Zone::HandleKeyword_Datapacking( const char *string )
{
#ifdef _DEBUG_
   printf(" i Inside HandleKeyword_Datapacking() \n");
#endif
   int iret=1;

   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;
   if( is < 5 ) return(1);

   if( strncasecmp( string, "POINT", 5 ) == 0 ) {
#ifdef _DEBUG_
      printf(" --- Data is in POINT format \n");
#endif
      idatapack = 1;
      iret = 0;
   } else if( strncasecmp( string, "BLOCK", 5 ) == 0 ) {
#ifdef _DEBUG_
      printf("   --- Data is in BLOCK format \n");
#endif
      idatapack = 2;
      iret = 0;
   } else {
#ifdef _DEBUG_
      printf(" i Unrecognized datapacking format: \"%s\" \n", string );
      iret = 2;
#endif
   }

#ifdef _DEBUG_
   printf(" i Exiting HandleKeyword_Datapacking() \n");
#endif
   return( iret );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6923(%rip), %rdi      # 0x102cc
callq 0x77b0
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
testl %ecx, %ecx
je 0x99c3
cmpl $0xa, %ecx
je 0x99c3
incq %rax
jmp 0x99b0
cmpq $0x5, %rax
jae 0x99ce
pushq $0x1
popq %rbx
jmp 0x9a46
leaq 0x5d47(%rip), %rsi      # 0xf71c
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x7650
testl %eax, %eax
je 0x9a10
leaq 0x58bc(%rip), %rsi      # 0xf2a7
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x7650
testl %eax, %eax
je 0x9a25
leaq 0x5d21(%rip), %rdi      # 0xf722
movq %r14, %rsi
xorl %eax, %eax
callq 0x7060
pushq $0x2
popq %rbx
jmp 0x9a3a
leaq 0x68fc(%rip), %rdi      # 0x10313
callq 0x77b0
movl $0x1, 0x1c(%rbx)
jmp 0x9a38
leaq 0x68c7(%rip), %rdi      # 0x102f3
callq 0x77b0
movl $0x2, 0x1c(%rbx)
xorl %ebx, %ebx
leaq 0x68f0(%rip), %rdi      # 0x10331
callq 0x77b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::GetElementNodes(unsigned long, int&, unsigned long*)
int inTec_Zone::GetElementNodes( unsigned long n,
                                 int & ik, unsigned long *icon_ )
{
   long off,k;


   if( ietype == FELINESEG ) {
      ik = 2;
   } else if( ietype == FETRIANGLE ) {
      ik = 3;
   } else if( ietype == FETETRAHEDRON ) {
      ik = 4;
   } else if( ietype == FEQUADRILATERAL ) {
      ik = 4;
   } else if( ietype == FEBRICK ) {
      ik = 8;
   } else {
      return(1);
   }

   off = ik*(n - 1);

   for(k=0;k<ik;++k) {
      icon_[k] = icon[off + k];
   }

   return(0);
}

// Assembly:
movl 0x18(%rdi), %r8d
decl %r8d
pushq $0x1
popq %rax
cmpl $0x5, %r8d
ja 0xc122
pushq $0x37
popq %r9
btl %r8d, %r9d
jae 0xc122
movl %r8d, %eax
leaq 0x308c(%rip), %r8       # 0xf174
movl (%r8,%rax,4), %r9d
leaq 0x309d(%rip), %r8       # 0xf190
movq (%r8,%rax,8), %r8
movl %r9d, (%rdx)
decq %rsi
imulq %r8, %rsi
shlq $0x3, %rsi
addq 0xa0(%rdi), %rsi
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %r8
je 0xc122
movq (%rsi,%rdx,8), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
jmp 0xc110
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::GetNumIndices(int) const
unsigned long inTec_Zone::GetNumIndices( int idir ) const
{
   if( idir == 1 ) {
      return im;
   } else if( idir == 2 ) {
      return jm;
   } else if( idir == 3 ) {
      return km;
   } else {
      return 0;
   }
}

// Assembly:
cmpl $0x3, %esi
je 0xc141
cmpl $0x2, %esi
je 0xc13c
cmpl $0x1, %esi
jne 0xc146
movq 0x30(%rdi), %rax
retq
movq 0x38(%rdi), %rax
retq
movq 0x40(%rdi), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::inTec_File(char*)
inTec_File::inTec_File( char *fname_ )
{
#ifdef _DEBUG_
   printf("File object instantiated \"%s\" \n", fname_ );
#endif

   memset( name, '\0', 256 );
   sprintf( name, "%s", fname_ );
   fp = NULL;
   istate = 0;
   nline = 0;
   iline = 0;
   ipos = 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8e2c(%rip), %rax      # 0x14fc8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x138(%rdi), %rax
andl $0x0, 0x138(%rdi)
andq $0x0, 0x140(%rdi)
movq %rax, 0x148(%rdi)
movq %rax, 0x150(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
andq $0x0, 0x188(%rdi)
leaq 0x3a07(%rip), %rdi      # 0xfbf5
xorl %eax, %eax
callq 0x7060
leaq 0xc(%rbx), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x72a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x7450
andl $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x120(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::OpenRead()
int inTec_File::OpenRead()
{
#ifdef _DEBUG_
   printf(" i Opening file object \"%s\" \n", name );
#endif

   if( istate != 0 ) {
      printf(" e File object is not in the right state (%d)\n", istate);
      return(1);
   }

   fp = fopen( name, "r" );
   if( fp == NULL ) {
      printf(" e Could not open file \"%s\"\n", name );
      return(2);
   }

   istate = 1;
   iline = 0;

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc(%rdi), %rbx
leaq 0x38bf(%rip), %rdi      # 0xfd2b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7060
movl 0x8(%r14), %esi
testl %esi, %esi
je 0xc491
leaq 0x38c4(%rip), %rdi      # 0xfd49
xorl %eax, %eax
callq 0x7060
pushq $0x1
popq %rax
jmp 0xc4be
leaq 0x38e0(%rip), %rsi      # 0xfd78
movq %rbx, %rdi
callq 0x75a0
movq %rax, 0x110(%r14)
testq %rax, %rax
je 0xc4c6
movl $0x1, 0x8(%r14)
andq $0x0, 0x120(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38ad(%rip), %rdi      # 0xfd7a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7060
pushq $0x2
jmp 0xc48e
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::Close()
int inTec_File::Close()
{
#ifdef _DEBUG_
   printf(" i Closing file object \"%s\" \n", name );
#endif

   if( istate == 0 || istate == 1000 ) {
      return(0);
   }

   fclose( fp );

   istate = 1000;
   iline = 0;
   ipos = 0;

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0x38ac(%rip), %rdi      # 0xfd97
xorl %eax, %eax
callq 0x7060
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xc51d
cmpl $0x3e8, %eax            # imm = 0x3E8
je 0xc51d
movq 0x110(%rbx), %rdi
callq 0x74c0
movl $0x3e8, 0x8(%rbx)       # imm = 0x3E8
xorps %xmm0, %xmm0
movups %xmm0, 0x120(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::Parse()
int inTec_File::Parse()
{
#ifdef _DEBUG_
   printf(" i Parsing file \"%s\" \n", name );
#endif

   if( istate != 1 ) {
      printf(" e File not in a reading state\n");
      return(1);
   }

   int iret = ParseLoop();

   if( iret != 0 ) {
      return(2);
   }

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0x3878(%rip), %rdi      # 0xfdb5
xorl %eax, %eax
callq 0x7060
cmpl $0x1, 0x8(%rbx)
jne 0xc556
movq %rbx, %rdi
callq 0x7930
addl %eax, %eax
jmp 0xc565
leaq 0x429b(%rip), %rdi      # 0x107f8
callq 0x77b0
pushq $0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::IdentifyComponent(char*)
int inTec_File::IdentifyComponent( char *buf )
{
#ifdef _DEBUG2_
   printf(" i Inside \"IdentifyComponent()\" \n");
#endif

   if( buf == NULL ) return(-1);
#ifdef _DEBUG3_
   printf("BUF: -->|%s", buf );
#endif

   size_t isize=0;
   while( buf[isize] != '\n' && buf[isize] != '\0' ) ++isize;
#ifdef _DEBUG3_
   printf(" i Size of buffer: %d \n", (int) isize);
#endif

   if( buf[0] == '\n' ) return(0);

   if( buf[0] == '#' ) return( Comment );

   if( isize >= 9 ) {
      if( strncasecmp( "VARIABLES", buf, 9 ) == 0 ) return( Variables );

   }

   if( isize >= 8 ) {
      if( strncasecmp( "FILETYPE", buf, 8 ) == 0 ) return( Filetype );
      if( strncasecmp( "GEOMETRY", buf, 8 ) == 0 ) return( Geometry );
   }

   if( isize >= 5 ) {
      if( strncasecmp( "TITLE", buf, 5 ) == 0 ) return( Title );
   }

   if( isize >= 4 ) {
      if( strncasecmp( "ZONE", buf, 4 ) == 0 ) return( Zone );
      if( strncasecmp( "TEXT", buf, 4 ) == 0 ) return( Text );
   }




   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc7d1
movq %rsi, %r14
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
testl %ecx, %ecx
je 0xc7bd
cmpl $0xa, %ecx
je 0xc7bd
incq %rax
jmp 0xc7aa
movzbl (%r14), %ecx
xorl %ebx, %ebx
cmpl $0xa, %ecx
je 0xc7d4
cmpl $0x23, %ecx
jne 0xc7de
pushq $0x64
jmp 0xc7d3
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x9, %rax
jb 0xc7fe
leaq 0x360e(%rip), %rdi      # 0xfdf9
pushq $0x9
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
jne 0xc804
pushq $0xd
jmp 0xc7d3
cmpq $0x8, %rax
jne 0xc834
leaq 0x35f8(%rip), %rdi      # 0xfe03
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
je 0xc857
leaq 0x35eb(%rip), %rdi      # 0xfe0c
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
jne 0xc83a
pushq $0x29
jmp 0xc7d3
cmpq $0x5, %rax
jb 0xc85e
leaq 0x35d4(%rip), %rdi      # 0xfe15
pushq $0x5
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
jne 0xc868
pushq $0xb
jmp 0xc7d3
pushq $0xc
jmp 0xc7d3
cmpq $0x4, %rax
jne 0xc7d4
leaq 0x2d6e(%rip), %rdi      # 0xf5dd
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
je 0xc89f
leaq 0x3596(%rip), %rdi      # 0xfe1b
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x7650
testl %eax, %eax
jne 0xc7d4
pushq $0x1f
jmp 0xc7d3
pushq $0x15
jmp 0xc7d3
// File: /workspace/github_cpp_makefile_star2_O2/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::ParseComponent_Header(int, char*)
int inTec_File::ParseComponent_Header( int iop, char *buf )
{
#ifdef _DEBUG_
   if( iop == 1 ) printf(" i Inside \"ParseComponent_Header(Title)\" \n");
   if( iop == 2 ) printf(" i Inside \"ParseComponent_Header(Filetype)\" \n");
   if( iop == 3 ) printf(" i Inside \"ParseComponent_Header(Variables)\" \n");
#endif

   switch( iop ) {
    case(1):   // title

#ifdef _DEBUG_
      printf(" i Parsing header \"title\" line \n");
#endif

    break;
    case(2):   // filetype

#ifdef _DEBUG_
      printf(" i Parsing header \"filetype\" line \n");
#endif

    break;
    case(3):   // variables

#ifdef _DEBUG_
      printf(" i Parsing header \"variables\" line \n");
#endif
      return( ParseComponent_HeaderVariables( buf ) );

    break;

    default:
      printf(" e Error parsing header component\n");
      return(1);
   }

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
je 0xc8ea
cmpl $0x2, %esi
je 0xc8ce
cmpl $0x1, %esi
jne 0xc91a
leaq 0x3f57(%rip), %rdi      # 0x10817
callq 0x77b0
leaq 0x4017(%rip), %rdi      # 0x108e3
jmp 0xc8e1
leaq 0x3f6c(%rip), %rdi      # 0x10841
callq 0x77b0
leaq 0x3fdf(%rip), %rdi      # 0x108c0
callq 0x77b0
xorl %eax, %eax
jmp 0xc929
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x3f77(%rip), %rdi      # 0x1086e
callq 0x77b0
leaq 0x3f99(%rip), %rdi      # 0x1089c
callq 0x77b0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76f0
leaq 0x3fe2(%rip), %rdi      # 0x10903
callq 0x77b0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::DFS(int)
bool CBottleneckDistance::DFS(int v)
{
    if (v < 0)
        return true;

    // for every adjacent vertex u of v
    for (unsigned int i = 0; i < Connections[v].size(); ++i) {
        int u = Connections[v][i];
        if (Layers[Pair[u] + 1] == Layers[v + 1] + 1) {
            if (DFS( Pair[u])) {
                Pair[u] = v;
                Pair[v] = u;
                return true;
            }
        }
    }

    Layers[v + 1] = -1;

    return false;
}

// Assembly:
movb $0x1, %al
testl %esi, %esi
js 0x17a1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
xorl %r12d, %r12d
imulq $0x18, %r15, %r13
movl %r12d, %r12d
movq 0x88(%r14), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1775
movl (%rax,%r12,4), %eax
movslq %eax, %rbx
movq 0x70(%r14), %rax
movq 0xa0(%r14), %rcx
movslq (%rax,%rbx,4), %rsi
movl 0x4(%rcx,%r15,4), %eax
incl %eax
cmpl %eax, 0x4(%rcx,%rsi,4)
jne 0x1770
movq %r14, %rdi
callq 0x16fe
testb %al, %al
jne 0x1786
incl %r12d
jmp 0x1722
movq 0xa0(%r14), %rax
orl $-0x1, 0x4(%rax,%r15,4)
xorl %eax, %eax
jmp 0x1793
movq 0x70(%r14), %rax
movl %ebp, (%rax,%rbx,4)
movl %ebx, (%rax,%r15,4)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::BFS()
bool CBottleneckDistance::BFS()
{
    std::queue<int> vertex_queue;

    // For every vertex v given by Generators1
    for (unsigned int v = 0; v < Max_Size; v++) {
        // If its not paired to vertex in Generators2
        if (Pair[v] < 0) {
            // Set its layer to 0 and put it in the queue
            Layers[v + 1] = 0;
            vertex_queue.push(v);
        }
        else {
            // Otherwise mark it as matched (set Layer to NILL)
            Layers[v + 1] = -1;
        }
    }

    // Set layer for NIL
    Layers[0] = -1;

    // Search the vertices in the queue
    while (!vertex_queue.empty()) {
        int v = vertex_queue.front();
        vertex_queue.pop();
        if (Layers[ v + 1 ] > Layers[ 0 ]) {
            for(unsigned int i = 0; i < Connections[ v ].size(); ++i) {
                int u = Connections[ v ][ i ];
                // Check if the vertex has an edge to the match vertex
                if (Layers[ Pair[ u ] + 1 ] < 0) {
                    // Set the layer of the vertex (it can be NILL) which is matched to the matched vertex u
                    Layers[ Pair[ u ] + 1 ] = Layers[ v + 1 ] + 1;
                    // If the pairing vertex is not NIL add it into the queue
                    if(Pair[ u ] != -1)
                        vertex_queue.push(Pair[u]);
                }
            }
        }
    }

    return Layers[0] != -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1c4c
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movl 0x50(%rbx), %eax
cmpq %rax, %r12
jae 0x1804
movq 0x70(%rbx), %rcx
movq 0xa0(%rbx), %rax
cmpl $0x0, (%rcx,%r12,4)
js 0x17e9
orl $-0x1, 0x4(%rax,%r12,4)
jmp 0x17ff
andl $0x0, 0x4(%rax,%r12,4)
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x28c6
incq %r12
jmp 0x17c7
movq 0xa0(%rbx), %rax
orl $-0x1, (%rax)
leaq 0x10(%rsp), %r14
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0x189b
movslq (%rax), %r15
movq %r14, %rdi
callq 0x2b20
movq 0xa0(%rbx), %rax
movl 0x4(%rax,%r15,4), %ecx
cmpl (%rax), %ecx
jle 0x1813
xorl %r12d, %r12d
imulq $0x18, %r15, %r13
movl %r12d, %r12d
movq 0x88(%rbx), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1813
movslq (%rax,%r12,4), %rdx
movq 0x70(%rbx), %rsi
movq 0xa0(%rbx), %rax
movslq (%rsi,%rdx,4), %rcx
cmpl $0x0, 0x4(%rax,%rcx,4)
jns 0x1896
leaq (%rsi,%rdx,4), %rsi
movl 0x4(%rax,%r15,4), %edx
incl %edx
movl %edx, 0x4(%rax,%rcx,4)
cmpl $-0x1, (%rsi)
je 0x1896
movq %r14, %rdi
callq 0x2b76
incl %r12d
jmp 0x1841
movq 0xa0(%rbx), %rax
cmpl $-0x1, (%rax)
setne %bl
leaq 0x10(%rsp), %rdi
callq 0x1dcc
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x18c4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1dcc
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::Hopcroft_Karp(unsigned int&)
void CBottleneckDistance::Hopcroft_Karp(unsigned int &matching)
{
    while (BFS() == true)
        for (unsigned int vertex = 0; vertex < Max_Size; ++vertex) {
            if (Pair[ vertex ] == -1) {
                if (DFS(vertex)) {
                    ++matching;
                }
            }
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x17a2
testb %al, %al
je 0x191e
xorl %r15d, %r15d
movl 0x50(%r14), %eax
cmpq %rax, %r15
jae 0x18e5
movq 0x70(%r14), %rax
cmpl $-0x1, (%rax,%r15,4)
jne 0x1919
movq %r14, %rdi
movl %r15d, %esi
callq 0x16fe
testb %al, %al
je 0x1919
incl (%rbx)
incq %r15
jmp 0x18f4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::Distance(char const*, char const*, double)
double CBottleneckDistance::Distance(const char* diagram_1, const char* diagram_2, double maxLevel)
{
    // Load the diagrams
    LoadGeneratorsFromFile(diagram_1, Generators1, maxLevel);
    LoadGeneratorsFromFile(diagram_2, Generators2, maxLevel);
    return Distance(maxLevel);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rdx
callq 0x13ae
leaq 0x38(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x13ae
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1952
nop