LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1b948
leaq 0x1d0ba(%rip), %rax     # 0x61c48
movq %rax, (%r14)
movl 0xe0(%r15), %eax
movl 0x130(%r15), %r14d
movq 0x160(%r15), %rbx
movl 0x134(%r15), %r12d
movl 0x138(%r15), %ecx
movl %ecx, 0x18(%rsp)
movl 0x13c(%r15), %ecx
movl %ecx, 0x14(%rsp)
movq %r15, 0x20(%rsp)
movl 0x140(%r15), %r15d
imull %r12d, %r15d
addl %r14d, %r15d
imull %eax, %r15d
movl %eax, 0x1c(%rsp)
imull %r14d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x10(%rsp)
movslq %r15d, %rax
xorl %ebp, %ebp
cmpl $0x0, (%rbx,%rax,4)
setne %al
movl %r14d, 0xc(%rsp)
jne 0x44c48
xorl %eax, %eax
xorl %ebp, %ebp
incl %ebp
movl $0x1, %ecx
cmpl 0x1c(%rsp), %ebp
jne 0x44c32
incl %r14d
xorl %ebp, %ebp
cmpl 0x18(%rsp), %r14d
jne 0x44c32
incl %r12d
xorl %ebp, %ebp
movl 0xc(%rsp), %r14d
movl 0x10(%rsp), %ecx
cmpl 0x14(%rsp), %r12d
je 0x44c43
addl %ecx, %r15d
movslq %r15d, %rax
cmpl $0x0, (%rbx,%rax,4)
setne %al
je 0x44c04
jmp 0x44c48
movl 0xc(%rsp), %r14d
testb $0x1, %al
je 0x44ce3
addq $0x180, 0x20(%rsp)      # imm = 0x180
xorl %r13d, %r13d
movl %r12d, (%rsp)
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x36e14
incl %r13d
movslq %r15d, %rcx
movb $0x1, %al
cmpl (%rbx,%rcx,4), %r13d
jl 0x44ccb
movl %r15d, %ecx
incl %ebp
movl $0x1, %r15d
cmpl 0x1c(%rsp), %ebp
jne 0x44cbc
incl %r14d
xorl %ebp, %ebp
cmpl 0x18(%rsp), %r14d
jne 0x44cbc
incl %r12d
xorl %ebp, %ebp
cmpl 0x14(%rsp), %r12d
je 0x44cd7
movl 0xc(%rsp), %r14d
movl 0x10(%rsp), %r15d
addl %ecx, %r15d
movslq %r15d, %rcx
cmpl $0x0, (%rbx,%rcx,4)
je 0x44c89
xorl %r13d, %r13d
movl %r15d, %ecx
movl %ecx, %r15d
testb %al, %al
jne 0x44c5c
jmp 0x44ce3
movl 0xc(%rsp), %r14d
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x44cce
leaq 0x28(%rsp), %rdi
callq 0x1bad4
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1bad4
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x1b948
leaq 0x1cd5e(%rip), %rax     # 0x61c48
movq %rax, (%r14)
movl 0xe0(%r15), %r12d
movl 0x130(%r15), %r14d
movq 0x160(%r15), %rbx
movl 0x134(%r15), %r13d
movl 0x138(%r15), %eax
movl %eax, 0x24(%rsp)
movl 0x13c(%r15), %eax
movl %eax, 0x20(%rsp)
movq %r15, 0x30(%rsp)
movl 0x140(%r15), %r15d
imull %r13d, %r15d
addl %r14d, %r15d
imull %r12d, %r15d
movl %r12d, %eax
imull %r14d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x1c(%rsp)
movslq %r15d, %rax
xorl %ebp, %ebp
cmpl $0x0, (%rbx,%rax,4)
setne %al
movl %r14d, 0x18(%rsp)
jne 0x44fa2
xorl %eax, %eax
xorl %ebp, %ebp
incl %ebp
movl $0x1, %ecx
cmpl %r12d, %ebp
jne 0x44f8c
incl %r14d
xorl %ebp, %ebp
cmpl 0x24(%rsp), %r14d
jne 0x44f8c
incl %r13d
xorl %ebp, %ebp
movl 0x18(%rsp), %r14d
movl 0x1c(%rsp), %ecx
cmpl 0x20(%rsp), %r13d
je 0x44f9d
addl %ecx, %r15d
movslq %r15d, %rax
cmpl $0x0, (%rbx,%rax,4)
setne %al
je 0x44f5f
jmp 0x44fa2
movl 0x18(%rsp), %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
testb $0x1, %al
je 0x45084
addq $0x180, 0x30(%rsp)      # imm = 0x180
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movl %r13d, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl %r15d, %edx
movl 0x14(%rsp), %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x36e14
testb %al, %al
je 0x45009
leaq 0x38(%rsp), %rdi
callq 0x1c58e
movsd 0x28(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movl 0x14(%rsp), %edx
incl %edx
movslq %r15d, %rcx
movb $0x1, %al
movl %edx, 0x14(%rsp)
cmpl (%rbx,%rcx,4), %edx
jl 0x45063
movl %r15d, %ecx
incl %ebp
movl $0x1, %r15d
cmpl %r12d, %ebp
jne 0x4504f
incl %r14d
xorl %ebp, %ebp
cmpl 0x24(%rsp), %r14d
jne 0x4504f
incl %r13d
xorl %ebp, %ebp
cmpl 0x20(%rsp), %r13d
je 0x45073
movl 0x18(%rsp), %r14d
movl 0x1c(%rsp), %r15d
addl %ecx, %r15d
movslq %r15d, %rcx
cmpl $0x0, (%rbx,%rcx,4)
je 0x4501d
movl $0x0, 0x14(%rsp)
movl %r15d, %ecx
movl %ecx, %r15d
testb %al, %al
jne 0x44fcb
jmp 0x45084
movl 0x18(%rsp), %r14d
movl $0x0, 0x14(%rsp)
xorl %eax, %eax
jmp 0x45066
leaq 0x38(%rsp), %rdi
callq 0x1bad4
movsd 0x28(%rsp), %xmm0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1bad4
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x1b948
leaq 0x1cb64(%rip), %rax     # 0x61c48
movq %rax, (%r14)
movl 0xe0(%r15), %r12d
movl 0x130(%r15), %r14d
movq 0x160(%r15), %rbx
movl 0x134(%r15), %r13d
movl 0x138(%r15), %eax
movl %eax, 0x24(%rsp)
movl 0x13c(%r15), %eax
movl %eax, 0x20(%rsp)
movq %r15, 0x30(%rsp)
movl 0x140(%r15), %r15d
imull %r13d, %r15d
addl %r14d, %r15d
imull %r12d, %r15d
movl %r12d, %eax
imull %r14d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x1c(%rsp)
movslq %r15d, %rax
xorl %ebp, %ebp
cmpl $0x0, (%rbx,%rax,4)
setne %al
movl %r14d, 0x18(%rsp)
jne 0x4519c
xorl %eax, %eax
xorl %ebp, %ebp
incl %ebp
movl $0x1, %ecx
cmpl %r12d, %ebp
jne 0x45186
incl %r14d
xorl %ebp, %ebp
cmpl 0x24(%rsp), %r14d
jne 0x45186
incl %r13d
xorl %ebp, %ebp
movl 0x18(%rsp), %r14d
movl 0x1c(%rsp), %ecx
cmpl 0x20(%rsp), %r13d
je 0x45197
addl %ecx, %r15d
movslq %r15d, %rax
cmpl $0x0, (%rbx,%rax,4)
setne %al
je 0x45159
jmp 0x4519c
movl 0x18(%rsp), %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
testb $0x1, %al
je 0x4527e
addq $0x1a8, 0x30(%rsp)      # imm = 0x1A8
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movl %r13d, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl %r15d, %edx
movl 0x14(%rsp), %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x3bd6c
testb %al, %al
je 0x45203
leaq 0x38(%rsp), %rdi
callq 0x1c58e
movsd 0x28(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movl 0x14(%rsp), %edx
incl %edx
movslq %r15d, %rcx
movb $0x1, %al
movl %edx, 0x14(%rsp)
cmpl (%rbx,%rcx,4), %edx
jl 0x4525d
movl %r15d, %ecx
incl %ebp
movl $0x1, %r15d
cmpl %r12d, %ebp
jne 0x45249
incl %r14d
xorl %ebp, %ebp
cmpl 0x24(%rsp), %r14d
jne 0x45249
incl %r13d
xorl %ebp, %ebp
cmpl 0x20(%rsp), %r13d
je 0x4526d
movl 0x18(%rsp), %r14d
movl 0x1c(%rsp), %r15d
addl %ecx, %r15d
movslq %r15d, %rcx
cmpl $0x0, (%rbx,%rcx,4)
je 0x45217
movl $0x0, 0x14(%rsp)
movl %r15d, %ecx
movl %ecx, %r15d
testb %al, %al
jne 0x451c5
jmp 0x4527e
movl 0x18(%rsp), %r14d
movl $0x0, 0x14(%rsp)
xorl %eax, %eax
jmp 0x45260
leaq 0x38(%rsp), %rdi
callq 0x1bad4
movsd 0x28(%rsp), %xmm0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1bad4
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movslq %esi, %r15
movq 0x160(%rdi), %rax
movq 0x168(%rdi), %rcx
movl (%rax,%r15,4), %eax
cmpl (%rcx,%r15,4), %eax
jne 0x4593e
movq %r14, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x440b4
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x158(%r14), %r8
movq 0x160(%r14), %rax
movq (%r8,%r15,8), %rdx
movslq 0x17c(%r14), %r10
movslq (%rax,%r15,4), %rcx
movq %rcx, %rsi
imulq %r10, %rsi
movl %r10d, %r9d
imull %ebx, %r9d
movslq %ebp, %rdi
movq (%r8,%rdi,8), %r8
movslq %r9d, %r9
addsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
addsd 0x8(%r8,%r9,8), %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
addsd 0x10(%r8,%r9,8), %xmm2
movsd %xmm2, 0x10(%rdx,%rsi,8)
cmpq $0x4, %r10
jne 0x459ab
movsd 0x18(%r8,%r9,8), %xmm0
movsd %xmm0, 0x18(%rdx,%rsi,8)
movq 0x150(%r14), %rdx
movq (%rdx,%rdi,8), %rsi
movslq %ebx, %rdi
movl (%rsi,%rdi,4), %esi
movq (%rdx,%r15,8), %rdx
leal 0x1(%rcx), %edi
movl %edi, (%rax,%r15,4)
movl %esi, (%rdx,%rcx,4)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2403
movq (%rbx), %r14
testq %r14, %r14
je 0x23cd
movq %r14, %rdi
callq 0x20a0
movq 0x2c10(%rip), %rdi      # 0x4fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x23eb
movq 0x2bfc(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x21f0
movq 0x2bde(%rip), %rdi      # 0x4fd0
leaq 0xc18(%rip), %rsi       # 0x3011
movl $0x2, %edx
callq 0x2170
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x28f1
cmpl $0x0, 0x58(%rbx)
jne 0x2441
movq 0x2bb3(%rip), %r14      # 0x4fd0
leaq 0xbe0(%rip), %rsi       # 0x3004
movl $0x1, %edx
movq %r14, %rdi
callq 0x2170
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq %r14, %rdi
callq 0x2170
movq 0x2b88(%rip), %rdi      # 0x4fd0
leaq 0xbb7(%rip), %rsi       # 0x3006
movl $0x1, %edx
callq 0x2170
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq %rbx, %r8
callq 0x2962
movq 0x20(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2bb2
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
callq 0x239c
movq $0x0, 0x40(%r14)
movq 0x38(%r14), %rax
movb $0x0, (%rax)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x2a76
cmpq $0x0, (%rbx)
je 0x24e2
addq $0x20, %r14
leaq 0x8(%rbx), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a76
cmpq $0x0, 0x8(%rbx)
movq %r15, %rbx
jne 0x24c9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, 0x40(%rbx)
movq 0x38(%rbx), %rax
movb $0x0, (%rax)
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2529
movq (%rax), %rsi
incq %rsi
popq %rbx
jmp 0x2140
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2abb
testq %rax, %rax
je 0x2562
movq %rdx, %rcx
movq 0x40(%rbx), %rsi
addq $0x38, %rbx
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %r8
callq 0x2160
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd78f(%rip), %rax      # 0x12fe0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x58(%rdi), %rbx
leaq 0x60(%rdi), %rax
xorl %r12d, %r12d
movl %r12d, 0x60(%rdi)
movq %r12, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
leaq 0xf0(%rdi), %rax
movl %r12d, 0xf0(%rdi)
movq %r12, 0xf8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movq %rax, 0x100(%rdi)
movq %rax, 0x108(%rdi)
movq %r12, 0x110(%rdi)
leaq 0x96a8(%rip), %rdi      # 0xef5d
callq 0x5580
movl %r12d, 0x8(%r14)
movq %r12, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r14)
movq %r12, 0xe0(%r14)
movq $-0x1, %rax
movq %rax, 0x18(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movq %r12, 0x50(%r14)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x24(%r14)
movups %xmm0, 0xb0(%r14)
movq %rax, 0xc0(%r14)
movl %r12d, 0x118(%r14)
movq %r12, 0x138(%r14)
movups %xmm0, 0x120(%r14)
movl %r12d, 0x130(%r14)
movq %r14, %rdi
callq 0x50f0
movq %r15, 0xc8(%r14)
movl $0x0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
testq %r15, %r15
je 0x5992
movq 0x168(%r15), %rax
subq 0x160(%r15), %rax
shrq $0x5, %rax
movl %eax, 0x20(%r14)
movl $0x1, 0x4(%rsp)
testl %eax, %eax
jle 0x5992
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51f0
movl $0x1, (%rax)
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl 0x20(%r14), %eax
jl 0x5970
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x59a0
movq %rax, %r15
leaq 0xe8(%r14), %rdi
callq 0x5300
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x59ca
movq 0x98(%r14), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5170
movq %r15, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8808(%rip), %rsi      # 0xe1fc
leaq 0x8809(%rip), %rdx      # 0xe204
leaq 0x8(%rsp), %rdi
callq 0x5110
addq $0xe8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq 0x8(%rax), %rdx
leaq 0x87d0(%rip), %rcx      # 0xe1f4
movl $0x7, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5590
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x87b2(%rip), %rsi      # 0xe20c
leaq 0x87ad(%rip), %rdx      # 0xe20e
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq 0x8(%rax), %rdx
leaq 0x8787(%rip), %rcx      # 0xe205
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5590
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5aa5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x8761(%rip), %rsi      # 0xe215
leaq 0x8765(%rip), %rdx      # 0xe220
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq 0x8(%rax), %rdx
leaq 0x8737(%rip), %rcx      # 0xe20f
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5590
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5aff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x871b(%rip), %rsi      # 0xe229
leaq 0x871f(%rip), %rdx      # 0xe234
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56b0
movq 0x8(%rax), %rdx
leaq 0x86ef(%rip), %rcx      # 0xe221
movl $0x7, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5590
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b59
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5b67
jmp 0x5b67
jmp 0x5b67
movq %rax, %rbx
jmp 0x5b8c
jmp 0x5b72
jmp 0x5b72
jmp 0x5b72
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd42d(%rip), %rax      # 0x12fe0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x93b8(%rip), %rdi      # 0xef79
callq 0x5580
movq %rbx, %rdi
callq 0x56d0
leaq 0xe8(%rbx), %rdi
callq 0x5300
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5bf5
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x5390
addq $0x58, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x5170
movq %rax, %rdi
callq 0xc07e
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %ebx
cmpq $0x0, 0xd8(%rdi)
jne 0x5ed9
movq %rsi, 0xd8(%rdi)
leaq 0x8365(%rip), %rdi      # 0xe235
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5060
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x1, %eax
cmpl $0x0, 0x8(%rdi)
je 0x5eea
retq
pushq %rbx
movq %rdi, %rbx
callq 0x54b0
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x5f07
movl $0x1, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7578
cmpl $0xa, %eax
je 0x7578
incq %r15
jmp 0x7565
movq %r15, %rdi
callq 0x54f0
testq %rax, %rax
je 0x759e
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x52f0
movq %r12, 0x10(%rbx)
xorl %eax, %eax
jmp 0x75a3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x75d1
cmpl $0xa, %eax
je 0x75d1
incq %r15
jmp 0x75be
movl $0x3e7, 0xc0(%rbx)      # imm = 0x3E7
leaq -0x5(%r15), %rax
cmpq $0x8, %rax
ja 0x76a5
leaq 0x6a84(%rip), %rcx      # 0xe074
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x70b7(%rip), %rsi      # 0xe6b7
movl $0x5, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
jne 0x761b
movl $0x6, 0xc0(%rbx)
cmpq $0xd, %r15
je 0x7683
cmpq $0xb, %r15
je 0x765b
cmpq $0x8, %r15
jne 0x76a5
leaq 0x709f(%rip), %rsi      # 0xe6d3
movl $0x8, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
jne 0x764f
movl $0x2, 0xc0(%rbx)
cmpq $0xd, %r15
je 0x7683
cmpq $0xb, %r15
jne 0x76a5
leaq 0x7089(%rip), %rsi      # 0xe6eb
movl $0xb, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
jne 0x767d
movl $0x5, 0xc0(%rbx)
cmpq $0xd, %r15
jne 0x76a5
leaq 0x706f(%rip), %rsi      # 0xe6f9
movl $0xd, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
jne 0x76a5
movl $0x3, 0xc0(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7505(%rip), %rdi      # 0xf234
callq 0x5580
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
testl %ecx, %ecx
je 0x7d49
cmpl $0xa, %ecx
je 0x7d49
incq %rax
jmp 0x7d36
movl $0x1, %ebp
cmpq $0x5, %rax
jb 0x7dd2
leaq 0x6929(%rip), %rsi      # 0xe684
movl $0x5, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
je 0x7d9c
leaq 0x649c(%rip), %rsi      # 0xe20f
movl $0x5, %edx
movq %r14, %rdi
callq 0x54a0
testl %eax, %eax
je 0x7db1
leaq 0x68ff(%rip), %rdi      # 0xe68a
movq %r14, %rsi
xorl %eax, %eax
callq 0x5060
movl $0x2, %ebp
jmp 0x7dc6
leaq 0x74d8(%rip), %rdi      # 0xf27b
callq 0x5580
movl $0x1, 0x1c(%rbx)
jmp 0x7dc4
leaq 0x74a3(%rip), %rdi      # 0xf25b
callq 0x5580
movl $0x2, 0x1c(%rbx)
xorl %ebp, %ebp
leaq 0x74cc(%rip), %rdi      # 0xf299
callq 0x5580
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa98f
cmpl $0x2, %esi
je 0xa98a
cmpl $0x1, %esi
jne 0xa994
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x85db(%rip), %rax      # 0x12fc8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x138(%rdi), %rax
xorl %r12d, %r12d
movl %r12d, 0x138(%rdi)
movq %r12, 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)
movq %r12, 0x188(%rdi)
leaq 0x411d(%rip), %rdi      # 0xeb5d
xorl %eax, %eax
callq 0x5060
leaq 0xc(%rbx), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x51e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x5320
movl %r12d, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f8f(%rip), %rdi      # 0xec93
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movl 0x8(%r14), %esi
testl %esi, %esi
je 0xad2b
leaq 0x3f94(%rip), %rdi      # 0xecb1
xorl %eax, %eax
callq 0x5060
movl $0x1, %eax
jmp 0xad73
leaq 0x3fae(%rip), %rsi      # 0xece0
movq %rbx, %rdi
callq 0x5420
movq %rax, 0x110(%r14)
testq %rax, %rax
je 0xad5d
movl $0x1, 0x8(%r14)
movq $0x0, 0x120(%r14)
xorl %eax, %eax
jmp 0xad73
leaq 0x3f7e(%rip), %rdi      # 0xece2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f74(%rip), %rdi      # 0xecff
xorl %eax, %eax
callq 0x5060
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xadbd
cmpl $0x3e8, %eax            # imm = 0x3E8
je 0xadbd
movq 0x110(%rbx), %rdi
callq 0x5370
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_O1/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 0x3f40(%rip), %rdi      # 0xed1d
xorl %eax, %eax
callq 0x5060
cmpl $0x1, 0x8(%rbx)
jne 0xadf6
movq %rbx, %rdi
callq 0x56a0
addl %eax, %eax
jmp 0xae07
leaq 0x4963(%rip), %rdi      # 0xf760
callq 0x5580
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xb0f0
movq %rsi, %r14
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0xb0d9
cmpl $0xa, %eax
je 0xb0d9
incq %r15
jmp 0xb0c6
movzbl (%r14), %eax
xorl %ebx, %ebx
cmpl $0xa, %eax
je 0xb0f5
cmpl $0x23, %eax
jne 0xb0fd
movl $0x64, %ebx
jmp 0xb0f5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x9, %r15
jb 0xb11f
leaq 0x3c57(%rip), %rdi      # 0xed61
movl $0x9, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
je 0xb1c3
cmpq $0x8, %r15
jb 0xb15d
leaq 0x3c3f(%rip), %rdi      # 0xed6b
movl $0x8, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
je 0xb1cd
leaq 0x3c2c(%rip), %rdi      # 0xed74
movl $0x8, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
je 0xb1e1
cmpq $0x5, %r15
jb 0xb17b
leaq 0x3c13(%rip), %rdi      # 0xed7d
movl $0x5, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
je 0xb1d7
cmpq $0x4, %r15
jb 0xb0f5
leaq 0x33b9(%rip), %rdi      # 0xe545
movl $0x4, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
je 0xb1eb
leaq 0x3bdf(%rip), %rdi      # 0xed83
movl $0x4, %edx
movq %r14, %rsi
callq 0x54a0
testl %eax, %eax
jne 0xb0f5
movl $0x1f, %ebx
jmp 0xb0f5
movl $0xd, %ebx
jmp 0xb0f5
movl $0xc, %ebx
jmp 0xb0f5
movl $0xb, %ebx
jmp 0xb0f5
movl $0x29, %ebx
jmp 0xb0f5
movl $0x15, %ebx
jmp 0xb0f5
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb23a
cmpl $0x2, %esi
je 0xb21e
cmpl $0x1, %esi
jne 0xb26a
leaq 0x456f(%rip), %rdi      # 0xf77f
callq 0x5580
leaq 0x462f(%rip), %rdi      # 0xf84b
jmp 0xb231
leaq 0x4584(%rip), %rdi      # 0xf7a9
callq 0x5580
leaq 0x45f7(%rip), %rdi      # 0xf828
callq 0x5580
xorl %eax, %eax
jmp 0xb27b
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x458f(%rip), %rdi      # 0xf7d6
callq 0x5580
leaq 0x45b1(%rip), %rdi      # 0xf804
callq 0x5580
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5500
leaq 0x45fa(%rip), %rdi      # 0xf86b
callq 0x5580
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %al
movl %eax, (%rsp)
testl %esi, %esi
js 0x1a77
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movl %esi, %r15d
movq 0x88(%rdi), %rcx
leaq (%r15,%r15,2), %r12
movq (%rcx,%r12,8), %rax
cmpq %rax, 0x8(%rcx,%r12,8)
setne %bl
je 0x1a60
movl $0x1, %r13d
xorl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movslq %eax, %rbp
movq 0x70(%r14), %rax
movq 0xa0(%r14), %rcx
movslq (%rax,%rbp,4), %rsi
movl 0x4(%rcx,%r15,4), %eax
incl %eax
cmpl %eax, 0x4(%rcx,%rsi,4)
jne 0x1a25
movq %r14, %rdi
callq 0x19b4
testb %al, %al
jne 0x1a4c
movl %r13d, %ecx
movq 0x88(%r14), %rdx
movq (%rdx,%r12,8), %rax
movq 0x8(%rdx,%r12,8), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r13d
cmpq %rcx, %rdx
seta %bl
ja 0x19f7
jmp 0x1a60
movq 0x70(%r14), %rax
movl 0x4(%rsp), %ecx
movl %ecx, (%rax,%rbp,4)
movl %ebp, (%rax,%r15,4)
testb $0x1, %bl
jne 0x1a77
movq 0xa0(%r14), %rax
movl $0xffffffff, 0x4(%rax,%r15,4) # imm = 0xFFFFFFFF
movl $0x0, (%rsp)
movl (%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
callq 0x1a8a
testb %al, %al
je 0x1ccf
cmpl $0x0, 0x50(%r14)
je 0x1cca
xorl %r15d, %r15d
movq 0x70(%r14), %rax
cmpl $-0x1, (%rax,%r15,4)
jne 0x1cbe
movq %r14, %rdi
movl %r15d, %esi
callq 0x19b4
testb %al, %al
je 0x1cbe
incl (%rbx)
incq %r15
movl 0x50(%r14), %eax
cmpq %rax, %r15
jb 0x1ca2
movq %r14, %rdi
jmp 0x1c8f
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14da
leaq 0x38(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x14da
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d04
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelvinabrokwa[P]bottleneck/bottleneckDist.cpp
// Function: main
int main(int argc, char* argv[])
{
    // must pass in two args, one for each persdia file, so #argc = 1 + 2
    // may also want to pass in max_gen later
    if (argc < 3 || argc > 4) {
        cout
            << endl
            << "Must pass in filename1 and filename2"
            << endl
            << "to find the distance between diagrams."
            << endl;
        return -1;
    }

    // file names
    char* file1 = argv[1];
    char* file2 = argv[2];

    CBottleneckDistance d;

    double max_gen = 1;

    // compute the distance between persistence diagrams
    double distance = d.Distance(file1, file2, max_gen);

    cout << distance << endl;

    return 0;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
addl $-0x5, %edi
cmpl $-0x3, %edi
ja 0x1ffc
movq 0x5089(%rip), %rbx      # 0x6fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x213b(%rip), %rsi      # 0x40bb
movl $0x24, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x2122(%rip), %rsi      # 0x40e0
movl $0x26, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x209b
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq 0x4d8d(%rip), %rcx      # 0x6d98
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movw $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa8(%rdi)
movsd 0x1fc7(%rip), %xmm0     # 0x4018
movq %rax, %rsi
callq 0x1edc
movq 0x4f78(%rip), %rdi      # 0x6fd8
callq 0x1160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x1432
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1432
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/vec_init.cc
// Function: main
int main()
{
    
    vector<int> ivec;                // empty vector
    int cnt = 10;
    // add elements 10 . . . 1 to ivec
    while (cnt > 0)
        ivec.push_back(cnt--);       // int postfix decrement

    auto iter = ivec.begin();
    // prints 10 9 8 . . . 1 
    while (iter != ivec.end())
        cout << *iter++ << endl; // iterator postfix increment

	vector<int> vec2(10, 0);  // ten elements initially all 0
    cnt = vec2.size();
    // assign values from size . . . 1 to the elements in vec2
    for(vector<int>::size_type ix = 0; 
                    ix != vec2.size(); ++ix, --cnt)   
        vec2[ix] = cnt;

    iter = vec2.begin();
    // prints 10 9 8 . . . 1 
    while (iter != vec2.end())
        cout << *iter++ << endl; // iterator postfix increment

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0xb, %r15d
leaq -0x24(%rbp), %r14
decl %r15d
movl %r15d, -0x24(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x1295
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x12a0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x13d8
cmpl $0x1, %r15d
ja 0x1277
movq -0x40(%rbp), %r15
movq 0x2d27(%rip), %rbx      # 0x3fd8
cmpq -0x38(%rbp), %r15
je 0x12f2
movl (%r15), %esi
movq %rbx, %rdi
callq 0x10e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
addq $0x4, %r15
movq %rax, %rdi
callq 0x1060
jmp 0x12b1
movl $0x28, %edi
callq 0x10a0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movl $0xa, %eax
movq %rbx, %rcx
movl %eax, (%rcx)
addq $0x4, %rcx
decq %rax
jne 0x1319
xorl %r12d, %r12d
movq 0x2caa(%rip), %r14      # 0x3fd8
cmpq $0x28, %r12
je 0x1370
movl (%rbx,%r12), %esi
movq %r14, %rdi
callq 0x10e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
addq $0x4, %r12
movq %rax, %rdi
callq 0x1060
jmp 0x132e
movl $0x28, %esi
movq %rbx, %rdi
callq 0x10b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1392
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b7
jmp 0x13b7
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x10b0
jmp 0x13ba
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13cf
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %r14, %rdi
callq 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipafolio/genipafolio.cpp
// Function: solverThread(void*)
void* solverThread(void* solver) {
	int res = ipasir_solve(solver);
	printf("c [genipafolio] solver stopped, res = %d\n", res);
	if (res != 0) {
		result = res;
	}
	return NULL;
}

// Assembly:
pushq %rbx
callq 0x20d3
movl %eax, %ebx
leaq 0xe6a7(%rip), %rdi      # 0x10004
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
testl %ebx, %ebx
je 0x1970
movl %ebx, 0x157dc(%rip)     # 0x1714c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ostafen[P]Fast-Insertion-Sort/src/test.cpp
// Function: compare(int*, int*, int)
bool compare(int *A, int *B, int size)
{
    for (int i = 0; i < size; i++)
    {
        if (A[i] != B[i])
        {
            return false;
        }
    }
    return true;
}

// Assembly:
testl %edx, %edx
setle %al
jle 0x235c
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0x235c
movl %edx, %eax
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x2356
movl (%rdi,%rcx,4), %r8d
leaq 0x1(%rcx), %rdx
cmpl (%rsi,%rcx,4), %r8d
je 0x2340
cmpq %rax, %rcx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/menu.cpp
// Function: string2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int string2int( const std::string& a )
{
    // Convert a string representation of a number into a floating point value.
    // Throws an int if the string contains anything but whitespace and a valid
    // numeric representation.
    //
    int result;
    std::string s( a );

    // Get rid of any trailing whitespace
    s.erase( s.find_last_not_of( " \f\n\r\t\v" ) + 1 );

    // Read it into the target type
    std::istringstream ss( s );
    ss >> result;

    // Check to see that there is nothing left over
    if (!ss.eof())
        throw 1;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3b58
leaq 0x177e(%rip), %rsi      # 0x51a9
movl $0x6, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x2290
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x3ad9
leaq -0x38(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq (%rsi), %rcx
movb $0x0, (%rcx,%rax)
leaq -0x1b8(%rbp), %rdi
movl $0x8, %edx
callq 0x22c0
leaq -0x1b8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x20c0
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x198(%rbp,%rax)
je 0x3af1
movl -0x14(%rbp), %ebx
movq 0x352a(%rip), %rsi      # 0x6fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x2060
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3acb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x16e4(%rip), %rdi      # 0x51c4
leaq 0x16c9(%rip), %rsi      # 0x51b0
movq %rax, %rdx
xorl %eax, %eax
callq 0x2250
movl $0x4, %edi
callq 0x20a0
movl $0x1, (%rax)
movq 0x34a0(%rip), %rsi      # 0x6fa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
jmp 0x3b14
movq %rax, %rbx
jmp 0x3b3b
movq %rax, %rbx
movq 0x34a5(%rip), %rsi      # 0x6fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x2060
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3b50
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/myPtrace.cpp
// Function: attach(int)
int attach(pid_t pid)
{
    int status;
    if(ptrace(PTRACE_ATTACH, pid, NULL, NULL))
    {
        perror("PTRACE_ATTACH");
        return 1;
    }
    std::cout << "attached to " << pid << std::endl << "wait for child" << std::endl;
    wait(&status);
    std::cout << "Status: " << status << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r15d
xorl %ebx, %ebx
movl $0x10, %edi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
testq %rax, %rax
jne 0x3d0f
movq 0x33aa(%rip), %r14      # 0x6fd0
leaq 0x15dc(%rip), %rsi      # 0x5209
movl $0xc, %edx
movq %r14, %rdi
callq 0x21e0
movq %r14, %rdi
movl %r15d, %esi
callq 0x22e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rax, %r15
leaq 0x159d(%rip), %rsi      # 0x5216
movl $0xe, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq -0x1c(%rbp), %r15
movq %r15, %rdi
callq 0x2220
leaq 0x1565(%rip), %rsi      # 0x5225
movl $0x8, %edx
movq %r14, %rdi
callq 0x21e0
movl (%r15), %esi
movq %r14, %rdi
callq 0x22e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14e5(%rip), %rdi      # 0x51fb
callq 0x2140
movl $0x1, %ebx
jmp 0x3d02