LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: icemiliang[P]vot/src/vot/v_compute.cc
// Function: voro::voro_compute<voro::container>::scan_all(int, double, double, double, int, int, int, voro::particle_record&, double&)
inline void voro_compute<c_class>::scan_all(int ijk,double x,double y,double z,int di,int dj,int dk,particle_record &w,double &mrs) {
	double x1,y1,z1,rs;bool in_block=false;
	for(int l=0;l<co[ijk];l++) {
		x1=p[ijk][ps*l]-x;
		y1=p[ijk][ps*l+1]-y;
		z1=p[ijk][ps*l+2]-z;
		rs=con.r_current_sub(x1*x1+y1*y1+z1*z1,ijk,l);
		if(rs<mrs) {mrs=rs;w.l=l;in_block=true;}
	}
	if(in_block) {w.ijk=ijk;w.di=di;w.dj=dj,w.dk=dk;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq %r9, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x61(%rbp)
movl $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movl -0x68(%rbp), %eax
movq 0x60(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x64153
movq -0x70(%rbp), %rax
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq (%rax), %rdi
movsd -0x48(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x50(%rbp), %xmm0
mulsd -0x50(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movl -0xc(%rbp), %esi
movl -0x68(%rbp), %edx
callq 0x83870
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm1
movq 0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x64143
movsd -0x60(%rbp), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x68(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x61(%rbp)
jmp 0x64145
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x64043
testb $0x1, -0x61(%rbp)
je 0x64180
movl -0xc(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x30(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x34(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/c_loops.cc
// Function: voro::particle_order::add_ordering_memory()
void particle_order::add_ordering_memory() {
	int *no=new int[size<<2],*nop=no,*opp=o;
	while(opp<op) *(nop++)=*(opp++);
	delete [] o;
	size<<=1;o=no;op=nop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %eax
shll $0x2, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xa030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x84569
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
jmp 0x84537
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x84583
movq -0x30(%rbp), %rdi
callq 0xa660
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: icemiliang[P]vot/src/vot/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x148(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x85866
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x85859
movq -0x18(%rbp), %rax
movq 0x158(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x85831
movq -0x20(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x85857
movq -0x28(%rbp), %rdi
callq 0xa660
jmp 0x85859
jmp 0x8585b
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x857f0
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x85884
movq -0x30(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x858a2
movq -0x38(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x858c0
movq -0x40(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x858de
movq -0x48(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rax
movq 0x158(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x858fc
movq -0x50(%rbp), %rdi
callq 0xa660
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x58720
movq -0x18(%rbp), %rdi
callq 0x892e0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: icemiliang[P]vot/src/vot/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);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x2c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x85be0
movq -0x40(%rbp), %rcx
movl -0xc(%rbp), %esi
movq 0x150(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x160(%rcx), %rdx
movslq -0x2c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movq 0x158(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x160(%rcx), %rdx
movslq -0x2c(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: icemiliang[P]vot/src/vot/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);
	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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x85be0
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x150(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x158(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rsi
movslq -0x34(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x188(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8603a
movq -0x48(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x188(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: icemiliang[P]vot/src/vot/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);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r10
movq -0x40(%rbp), %rax
leaq -0x44(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x86140
movq -0x58(%rbp), %rcx
movl -0xc(%rbp), %esi
movq 0x150(%rcx), %rax
movslq -0x44(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x160(%rcx), %rdx
movslq -0x44(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movq 0x158(%rcx), %rax
movslq -0x44(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x160(%rcx), %rdx
movslq -0x44(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: icemiliang[P]vot/src/vot/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);
	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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq -0x48(%rbp), %rax
leaq -0x4c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x86140
movq -0x60(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x150(%rax), %rcx
movslq -0x4c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rdx
movslq -0x4c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x158(%rax), %rcx
movslq -0x4c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rsi
movslq -0x4c(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x20(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x188(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8661b
movq -0x60(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x188(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x85be0
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x150(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movq 0x160(%rax), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x58770
movq -0x48(%rbp), %rcx
movq 0x158(%rcx), %rax
movslq -0x34(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x160(%rcx), %rdx
movslq -0x34(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x85be0
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x150(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rdx
movslq -0x3c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq 0x160(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x58770
movq -0x50(%rbp), %rax
movq 0x158(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x160(%rax), %rsi
movslq -0x3c(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x38(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x188(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8686c
movq -0x50(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x188(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic::import(_IO_FILE*)
void container_periodic::import(FILE *fp) {
	int i,j;
	double x,y,z;
	while((j=fscanf(fp,"%d %lg %lg %lg",&i,&x,&y,&z))==4) put(i,x,y,z);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd74f(%rip), %rsi      # 0x94732
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
movb $0x0, %al
callq 0xa9a0
movl %eax, -0x18(%rbp)
cmpl $0x4, %eax
jne 0x8701f
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
callq 0x85b00
jmp 0x86fd8
cmpl $-0x1, -0x18(%rbp)
je 0x87036
leaq 0xd715(%rip), %rdi      # 0x94741
movl $0x1, %esi
callq 0x4c000
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic::import(voro::particle_order&, _IO_FILE*)
void container_periodic::import(particle_order &vo,FILE *fp) {
	int i,j;
	double x,y,z;
	while((j=fscanf(fp,"%d %lg %lg %lg",&i,&x,&y,&z))==4) put(vo,i,x,y,z);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd6cb(%rip), %rsi      # 0x94732
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
movb $0x0, %al
callq 0xa9a0
movl %eax, -0x20(%rbp)
cmpl $0x4, %eax
jne 0x870a7
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x86630
jmp 0x8705c
cmpl $-0x1, -0x20(%rbp)
je 0x870be
leaq 0xd68d(%rip), %rdi      # 0x94741
movl $0x1, %esi
callq 0x4c000
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic_poly::import(_IO_FILE*)
void container_periodic_poly::import(FILE *fp) {
	int i,j;
	double x,y,z,r;
	while((j=fscanf(fp,"%d %lg %lg %lg %lg",&i,&x,&y,&z,&r))==5) put(i,x,y,z,r);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd660(%rip), %rsi      # 0x94753
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0xa9a0
movl %eax, -0x18(%rbp)
cmpl $0x5, %eax
jne 0x8713c
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
callq 0x85f20
jmp 0x870e8
cmpl $-0x1, -0x18(%rbp)
je 0x87153
leaq 0xd5f8(%rip), %rdi      # 0x94741
movl $0x1, %esi
callq 0x4c000
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: icemiliang[P]vot/src/vot/container_prd.cc
// Function: voro::container_periodic_poly::import(voro::particle_order&, _IO_FILE*)
void container_periodic_poly::import(particle_order &vo,FILE *fp) {
	int i,j;
	double x,y,z,r;
	while((j=fscanf(fp,"%d %lg %lg %lg %lg",&i,&x,&y,&z,&r))==5) put(vo,i,x,y,z,r);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd5cc(%rip), %rsi      # 0x94753
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0xa9a0
movl %eax, -0x20(%rbp)
cmpl $0x5, %eax
jne 0x871d4
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
callq 0x86730
jmp 0x8717c
cmpl $-0x1, -0x20(%rbp)
je 0x871eb
leaq 0xd560(%rip), %rdi      # 0x94741
movl $0x1, %esi
callq 0x4c000
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x23520
movq -0x120(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x896a0
jmp 0x8750b
leaq -0x108(%rbp), %rdi
callq 0x89d20
movb %al, -0x121(%rbp)
jmp 0x8751f
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x8752b
jmp 0x8758d
jmp 0x8752d
movq -0x120(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x89d90
jmp 0x87549
jmp 0x8754b
leaq -0x108(%rbp), %rdi
callq 0x89df0
movb %al, -0x122(%rbp)
jmp 0x8755f
movb -0x122(%rbp), %al
testb $0x1, %al
jne 0x8752d
jmp 0x8756b
jmp 0x8758d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x236a0
jmp 0x875a2
leaq -0xa8(%rbp), %rdi
callq 0x236a0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0xa950
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x23520
movq -0x128(%rbp), %rsi
movq $0x0, -0xb0(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x896a0
jmp 0x876d6
leaq -0x110(%rbp), %rdi
callq 0x89d20
movb %al, -0x129(%rbp)
jmp 0x876ea
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x876f9
jmp 0x877a1
jmp 0x876fb
movq -0x128(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0x89d90
movb %al, -0x12a(%rbp)
jmp 0x8771d
movb -0x12a(%rbp), %al
testb $0x1, %al
jne 0x87729
jmp 0x87779
leaq -0xa8(%rbp), %rdi
callq 0x43b70
movsd %xmm0, -0x138(%rbp)
jmp 0x8773f
movsd -0x138(%rbp), %xmm0
addsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
jmp 0x87779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x236a0
jmp 0x877ce
jmp 0x8777b
leaq -0x110(%rbp), %rdi
callq 0x89df0
movb %al, -0x139(%rbp)
jmp 0x8778f
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x876fb
jmp 0x8779f
jmp 0x877a1
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0x148(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x236a0
movsd -0x148(%rbp), %xmm0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0xa950
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x23520
movq -0x128(%rbp), %rsi
movq $0x0, -0xb0(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x899e0
jmp 0x87826
leaq -0x110(%rbp), %rdi
callq 0x89d20
movb %al, -0x129(%rbp)
jmp 0x8783a
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x87849
jmp 0x878f1
jmp 0x8784b
movq -0x128(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0x89e60
movb %al, -0x12a(%rbp)
jmp 0x8786d
movb -0x12a(%rbp), %al
testb $0x1, %al
jne 0x87879
jmp 0x878c9
leaq -0xa8(%rbp), %rdi
callq 0x43b70
movsd %xmm0, -0x138(%rbp)
jmp 0x8788f
movsd -0x138(%rbp), %xmm0
addsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
jmp 0x878c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x236a0
jmp 0x8791e
jmp 0x878cb
leaq -0x110(%rbp), %rdi
callq 0x89df0
movb %al, -0x139(%rbp)
jmp 0x878df
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x8784b
jmp 0x878ef
jmp 0x878f1
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0x148(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x236a0
movsd -0x148(%rbp), %xmm0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0xa950
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x160(%rcx), %rax
movslq -0xc(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x168(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x88186
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x86880
movq -0x48(%rbp), %rax
movq 0x158(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x17c(%rax), %edx
movq 0x160(%rax), %rsi
movslq -0xc(%rbp), %rdi
imull (%rsi,%rdi,4), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x158(%rax), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x17c(%rax), %edx
imull -0x14(%rbp), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd (%rcx), %xmm0
addsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x38(%rbp)
movsd %xmm0, (%rcx)
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd (%rcx), %xmm0
addsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x38(%rbp)
movsd %xmm0, (%rcx)
movq -0x40(%rbp), %rcx
movsd (%rcx), %xmm0
addsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x4, 0x17c(%rax)
jne 0x8827f
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd 0x8(%rax), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq 0x150(%rcx), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq -0x14(%rbp), %rdx
movl (%rax,%rdx,4), %edx
movq 0x150(%rcx), %rax
movslq -0xc(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq 0x160(%rcx), %rsi
movslq -0xc(%rbp), %rdi
movl (%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x24d8
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x5b0c(%rip), %rdi      # 0x7fd0
callq 0x21a0
movq %rax, %rdi
leaq 0x2b4e(%rip), %rsi      # 0x5021
callq 0x21a0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2be0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2c10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b40
movq -0x8(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x2534
movq 0x5ab8(%rip), %rdi      # 0x7fd0
leaq 0x2af5(%rip), %rsi      # 0x5014
callq 0x21a0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
callq 0x2180
movq 0x5a95(%rip), %rdi      # 0x7fd0
leaq 0x2ad4(%rip), %rsi      # 0x5016
callq 0x21a0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2be0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2c10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x2be0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c10
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %r8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x2c40
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x2d50
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24a0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x2260
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x2d70
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x262b
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
callq 0x2d70
jmp 0x2603
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24a0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x2260
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2df0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2e20
leaq -0x30(%rbp), %rdi
callq 0x2e50
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2ee0
cmpq $0x0, %rax
je 0x270e
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2f70
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2f90
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x2f00
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/xml-lister.cpp
// Function: char const* find_backward_if_not<char const*, int (*)(int) noexcept>(char const*, char const*, int (*)(int) noexcept)
I find_backward_if_not(I f, I l, P p)
{
    if (f == l) return l;
    while (f != --l) {
        if (!p(*l)) break;
    }
    return ++l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x4588
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45c5
jmp 0x458a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq %rcx, %rax
je 0x45b5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %edi
callq *%rax
cmpl $0x0, %eax
jne 0x45b3
jmp 0x45b5
jmp 0x458a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x1adb1(%rip), %rax     # 0x2ffe0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x58, %rdi
movq %rdi, 0x18(%rsp)
callq 0x14610
movq 0x28(%rsp), %rdi
addq $0x88, %rdi
movq %rdi, 0x20(%rsp)
callq 0x14bf0
movq 0x28(%rsp), %rdi
addq $0xe8, %rdi
movq %rdi, 0x30(%rsp)
callq 0x13e50
leaq 0x12d91(%rip), %rdi     # 0x28008
xorl %eax, %eax
callq 0x13070
jmp 0x15280
movq 0x28(%rsp), %rdi
movl $0x0, 0x8(%rdi)
movq $0x0, 0xd0(%rdi)
movq $0x0, 0xd8(%rdi)
movq $0x0, 0xe0(%rdi)
movq $0x0, 0x10(%rdi)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x1c(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
movl $0x0, 0x28(%rdi)
movl $0xffffffff, 0x24(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0xb0(%rdi)
movq $0x0, 0xb8(%rdi)
movl $0xffffffff, 0xc0(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc4(%rdi) # imm = 0xFFFFFFFF
movl $0x0, 0x118(%rdi)
movq $0x0, 0x120(%rdi)
movq $0x0, 0x128(%rdi)
movl $0x0, 0x130(%rdi)
movq $0x0, 0x138(%rdi)
callq 0x13470
jmp 0x1535f
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0xc8(%rax)
movl $0x0, 0x20(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
cmpq $0x0, 0xc8(%rax)
je 0x15436
movq 0x28(%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x14620
movl %eax, 0x14(%rsp)
jmp 0x153b2
movq 0x28(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl $0x1, 0x38(%rsp)
movq 0x28(%rsp), %rcx
movl 0x38(%rsp), %eax
cmpl 0x20(%rcx), %eax
jg 0x15434
movq 0x28(%rsp), %rdi
addq $0x58, %rdi
leaq 0x38(%rsp), %rsi
callq 0x138d0
movq %rax, 0x8(%rsp)
jmp 0x153ee
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x153c6
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x14560
movq 0x20(%rsp), %rdi
callq 0x14f00
movq 0x18(%rsp), %rdi
callq 0x14c80
jmp 0x1543b
jmp 0x15436
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x14d20
nopw %cs:(%rax,%rax)
// File: nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::NotifyPositionInFile(long)
int inTec_Zone::NotifyPositionInFile( long ipos_ )
{
   // reject reseting of position if it is already set
   if( ipos != 0 ) {
      return(1);
   } else {   // this is for when a zone is created but not read from a file
      ipos = ipos_;
      return(0);
   }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, 0xd0(%rax)
je 0x15d38
movl $0x1, -0x4(%rsp)
jmp 0x15d51
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, 0xd0(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0xd8(%rax)
je 0x15dac
movl $0x1, 0x24(%rsp)
jmp 0x15dda
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0xd8(%rax)
movq 0xd8(%rax), %rsi
leaq 0x123c9(%rip), %rdi     # 0x28194
movb $0x0, %al
callq 0x13070
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x8(%rax)
je 0x15e13
movl $0x1, 0x24(%rsp)
jmp 0x15e46
movq 0x8(%rsp), %rdi
callq 0x144e0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x15e3e
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
movl $0x0, 0x24(%rsp)
jmp 0x15e46
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::CheckCharForNum(char) const
int inTec_Zone::CheckCharForNum( char c ) const
{
   if( c == '0' ) {
      return(1);
   } else if( c == '1' ) {
      return(1);
   } else if( c == '2' ) {
      return(1);
   } else if( c == '3' ) {
      return(1);
   } else if( c == '4' ) {
      return(1);
   } else if( c == '5' ) {
      return(1);
   } else if( c == '6' ) {
      return(1);
   } else if( c == '7' ) {
      return(1);
   } else if( c == '8' ) {
      return(1);
   } else if( c == '9' ) {
      return(1);
   } else if( c == '-' ) {
      return(1);
   } else if( c == '+' ) {
      return(1);
   } else if( c == '.' ) {
      return(1);
   } else {
      return(0);
   }
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movsbl -0x11(%rsp), %eax
cmpl $0x30, %eax
jne 0x17063
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x31, %eax
jne 0x1707a
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x32, %eax
jne 0x17091
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x33, %eax
jne 0x170a8
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x34, %eax
jne 0x170bf
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x35, %eax
jne 0x170d6
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x36, %eax
jne 0x170ed
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x37, %eax
jne 0x17101
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x38, %eax
jne 0x17115
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x39, %eax
jne 0x17129
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x2d, %eax
jne 0x1713d
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x2b, %eax
jne 0x17151
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movsbl -0x11(%rsp), %eax
cmpl $0x2e, %eax
jne 0x17165
movl $0x1, -0x4(%rsp)
jmp 0x1716d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x18742
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1874c
jmp 0x1875c
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x18711
movq 0x18(%rsp), %rdi
shlq $0x0, %rdi
callq 0x145f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18781
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x187ab
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x13c70
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x18812
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1881c
jmp 0x1882c
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x187e1
movq 0x8(%rsp), %rax
movl $0x3e7, 0xc0(%rax)      # imm = 0x3E7
cmpq $0x5, 0x10(%rsp)
jne 0x1886f
movq 0x18(%rsp), %rdi
leaq 0x100bd(%rip), %rsi     # 0x2890c
movl $0x5, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1886d
movq 0x8(%rsp), %rax
movl $0x6, 0xc0(%rax)
jmp 0x1886f
cmpq $0x8, 0x10(%rsp)
jne 0x188a3
movq 0x18(%rsp), %rdi
leaq 0x100a5(%rip), %rsi     # 0x28928
movl $0x8, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x188a1
movq 0x8(%rsp), %rax
movl $0x2, 0xc0(%rax)
jmp 0x188a3
cmpq $0xb, 0x10(%rsp)
jne 0x188d7
movq 0x18(%rsp), %rdi
leaq 0x10089(%rip), %rsi     # 0x28940
movl $0xb, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x188d5
movq 0x8(%rsp), %rax
movl $0x5, 0xc0(%rax)
jmp 0x188d7
cmpq $0xd, 0x10(%rsp)
jne 0x1890b
movq 0x18(%rsp), %rdi
leaq 0x10063(%rip), %rsi     # 0x2894e
movl $0xd, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x18909
movq 0x8(%rsp), %rax
movl $0x3, 0xc0(%rax)
jmp 0x1890b
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xf204(%rip), %rdi      # 0x28823
movb $0x0, %al
callq 0x13070
movl $0x1, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x19668
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x19672
jmp 0x19682
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x19637
cmpq $0x5, 0x10(%rsp)
jae 0x19697
movl $0x1, 0x34(%rsp)
jmp 0x19748
movq 0x20(%rsp), %rdi
leaq 0xf1a8(%rip), %rsi      # 0x2884b
movl $0x5, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x196d6
leaq 0xf198(%rip), %rdi      # 0x28851
movb $0x0, %al
callq 0x13070
movq 0x8(%rsp), %rax
movl $0x1, 0x1c(%rax)
movl $0x0, 0x1c(%rsp)
jmp 0x19732
movq 0x20(%rsp), %rdi
leaq 0xea8c(%rip), %rsi      # 0x2816e
movl $0x5, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x19715
leaq 0xf178(%rip), %rdi      # 0x28870
movb $0x0, %al
callq 0x13070
movq 0x8(%rsp), %rax
movl $0x2, 0x1c(%rax)
movl $0x0, 0x1c(%rsp)
jmp 0x19730
movq 0x20(%rsp), %rsi
leaq 0xf170(%rip), %rdi      # 0x28891
movb $0x0, %al
callq 0x13070
movl $0x2, 0x1c(%rsp)
jmp 0x19732
leaq 0xf183(%rip), %rdi      # 0x288bc
movb $0x0, %al
callq 0x13070
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)