LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Albuso0[P]support/./commandline.h
// Function: std::CommandLine::UserItem<double>::Parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CommandLine::UserItem<T>::Parse (const std::string value)
	{
		std::string src = value;
		std::transform(src.begin(), src.end(), src.begin(), ::tolower);
		std::istringstream iss;
		iss.str (src);
		iss >> (*m_valuePtr);
		return !iss.bad () && !iss.fail ();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4d7a
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x4f0c
movq (%rsp), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x32f0
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r14
jne 0x4ef6
leaq 0x20(%rsp), %rdi
callq 0x3190
leaq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x3310
movq 0x48(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3150
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x40(%rsp,%rax), %ebx
movq 0x4080(%rip), %rsi      # 0x8fc8
callq 0x32e0
leaq 0x98(%rsp), %rdi
callq 0x30b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4f70
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
testb $0x5, %bl
sete %al
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x4fad
movq %rax, %rbx
movq 0x4032(%rip), %rsi      # 0x8fc8
leaq 0x20(%rsp), %rdi
callq 0x32e0
leaq 0x98(%rsp), %rdi
callq 0x30b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4fc3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/src/annotate.cpp
// Function: qStartSort(BamTools::BamAlignment, BamTools::BamAlignment)
bool qStartSort(const BamAlignment L,
                const BamAlignment R ){

    int  lp;
    int  rp;

    if(!L.GetTag<int>( "QS", lp )){
        exit(1);
    }
    if(!R.GetTag<int>( "QS", rp )){
        exit(1);
    }

    if(lp < rp){
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2f7c4(%rip), %rsi     # 0x39020
leaq 0x2f7bf(%rip), %rdx     # 0x39022
leaq 0x18(%rsp), %rdi
callq 0xbe08
cmpb $0x0, 0x130(%r14)
jne 0x98e0
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x98e0
movq 0x88(%r14), %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
leaq 0x14(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x10(%rsp), %r8
movl $0x0, (%r8)
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x1693a
testb %al, %al
je 0x98e0
movq (%rsp), %rsi
movzbl -0x1(%rsi), %eax
xorl %ebp, %ebp
cmpl $0x68, %eax
jg 0x99ba
movl $0x1, %edx
cmpl $0x41, %eax
je 0x99e5
cmpl $0x63, %eax
je 0x99e5
jmp 0x98e2
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x98f9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5470
testb %bpl, %bpl
je 0x9a19
leaq 0x18(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x2f70f(%rip), %rsi     # 0x39020
leaq 0x2f70a(%rip), %rdx     # 0x39022
callq 0xbe08
cmpb $0x0, 0x130(%rbx)
jne 0x9987
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x9987
movq 0x88(%rbx), %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
leaq 0x14(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x10(%rsp), %r8
movl $0x0, (%r8)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x1693a
testb %al, %al
je 0x9987
movq (%rsp), %rsi
movzbl -0x1(%rsi), %eax
xorl %ebx, %ebx
cmpl $0x68, %eax
jg 0x99cf
movl $0x1, %edx
cmpl $0x41, %eax
je 0x9a02
cmpl $0x63, %eax
je 0x9a02
jmp 0x9989
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x99a0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5470
testb %bl, %bl
je 0x9a19
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
setl %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x69, %eax
je 0x99e0
cmpl $0x73, %eax
jne 0x98e2
movl $0x2, %edx
jmp 0x99e5
cmpl $0x69, %eax
je 0x99fd
cmpl $0x73, %eax
jne 0x9989
movl $0x2, %edx
jmp 0x9a02
movl $0x4, %edx
leaq 0xc(%rsp), %rdi
movl $0x0, (%rdi)
callq 0x5380
movb $0x1, %bpl
jmp 0x98e2
movl $0x4, %edx
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
callq 0x5380
movb $0x1, %bl
jmp 0x9989
movl $0x1, %edi
callq 0x5560
jmp 0x9a25
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a46
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5470
jmp 0x9a46
jmp 0x9a43
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57b0
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/src/chain.cpp
// Function: chain::addAlignment(int, int, int)
bool chain::addAlignment(int s, int e, int m){

    node * n = new node;
    n->matches      = double(m);
    n->overallScore = double(m);
    n->start        = s;
    n->end          = e;
    n->index        = current_index;

    nodes.push_back(n);

    current_index++;

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x38, %edi
callq 0x5460
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %rax, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rax)
movsd %xmm0, 0x8(%rax)
movl %r15d, 0x10(%rax)
movl %r14d, 0x14(%rax)
movl (%rbx), %ecx
movl %ecx, 0x18(%rax)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0xe12c
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0xe138
leaq 0x10(%rbx), %rdi
movq %rsp, %rdx
callq 0xe628
incl (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/src/chain.cpp
// Function: chain::traceback(std::vector<int, std::allocator<int>>&)
bool chain::traceback(std::vector<int> & alns){

    if(last != nodes.front() && last != nodes.back() ){
        alns.push_back(last->index);
    }

    if( last->children.empty() ){
        return false;
    }

    double max = last->children.front()->overallScore;
    node * current = last->children.front();

    for(std::vector<node *>::iterator it = last->children.begin();
        it != last->children.end(); it++){

        if((*it)->overallScore > max ){

            max       = (*it)->overallScore;
            current   =  *it ;
        }
    }



    std::cerr << "  best child : "
              << " " << current->index
              << " " << current->start
              << " " << current->end
              << " " << current->matches
              << " " << current->overallScore
              << std::endl;




    last = current;

    return traceback(alns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x2c1b2(%rip), %rbp     # 0x3a653
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rax
cmpq (%rax), %rdx
je 0xe4dd
movq 0x18(%r15), %rax
cmpq -0x8(%rax), %rdx
je 0xe4dd
addq $0x18, %rdx
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xe4d8
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xe4dd
callq 0xeaf8
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rax
movq 0x28(%rcx), %rcx
cmpq %rcx, %rax
je 0xe610
movq (%rax), %r12
movsd 0x8(%r12), %xmm0
movq (%rax), %rdx
movsd 0x8(%rdx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rdx, %r12
maxsd %xmm0, %xmm1
addq $0x8, %rax
movapd %xmm1, %xmm0
cmpq %rcx, %rax
jne 0xe4fc
movl $0xf, %edx
movq 0x41ac7(%rip), %r13     # 0x4fff0
movq %r13, %rdi
leaq 0x2ac66(%rip), %rsi     # 0x39199
callq 0x54f0
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x54f0
movl 0x18(%r12), %esi
movq %r13, %rdi
callq 0x5780
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x54f0
movl 0x10(%r12), %esi
movq %r13, %rdi
callq 0x5780
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x54f0
movl 0x14(%r12), %esi
movq %r13, %rdi
callq 0x5780
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x54f0
movsd (%r12), %xmm0
movq %r13, %rdi
callq 0x56e0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x54f0
movsd 0x8(%r12), %xmm0
movq %r13, %rdi
callq 0x56e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5430
movsbl %al, %esi
movq %r13, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x52e0
movq %r12, 0x8(%r15)
andb %bl, %r14b
movb $0x1, %bl
jmp 0xe4a1
andb %r14b, %bl
andb $0x1, %bl
movl %ebx, %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/zeeev[P]DASVC/src/cigar.cpp
// Function: qlen(std::vector<BamTools::CigarOp, std::allocator<BamTools::CigarOp>>&)
long int qlen(std::vector< CigarOp > & cigs)
{
    long int qLength = 0;
    for(std::vector<CigarOp>::iterator it = cigs.begin();
        it != cigs.end(); it++){
        advanceQuery(it->Type, it->Length, &qLength, true);
    }
    return qLength;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0xed18
leaq 0x8(%rsp), %rbx
movsbl (%r14), %edi
movl 0x4(%r14), %esi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xecad
addq $0x8, %r14
cmpq %r15, %r14
jne 0xecfa
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/src/split.hpp
// Function: void tokenize<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void tokenize(const std::string& str, ContainerT& tokens,
              const std::string& delimiters = " ", const bool trimEmpty = false)
{

    std::string::size_type pos, lastPos = 0;
    while(true)
    {
	pos = str.find_first_of(delimiters, lastPos);
	if(pos == std::string::npos)
	{

	    pos = str.length();

	    if(pos != lastPos || !trimEmpty) {
		tokens.push_back(typename ContainerT::value_type(str.data()+lastPos, (typename ContainerT::value_type::size_type)pos-lastPos));
	    }

	    break;
	}
	else
	{
	    if(pos != lastPos || !trimEmpty) {
		tokens.push_back(typename ContainerT::value_type(str.data()+lastPos, (typename ContainerT::value_type::size_type)pos-lastPos));
	    }
	}

	lastPos = pos + 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x5660
cmpq $-0x1, %rax
je 0x100df
movq %rax, %rbx
xorl %r12d, %r12d
movq %rsp, %r13
cmpq %r12, %rbx
sete %al
testb %bpl, %al
jne 0x100be
movq (%r14), %rdx
addq %rdx, %r12
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq %rbx, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0xbe08
movq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0xf0fc
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x100be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5470
movq %rbx, %r12
incq %r12
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %r12, %rdx
callq 0x5660
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x1006e
movq 0x8(%r14), %rdx
cmpq %r12, %rdx
sete %al
testb %bpl, %al
jne 0x1012e
movq (%r14), %rax
addq %rax, %r12
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rax, %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0xbe08
movq %rsp, %rsi
movq 0x20(%rsp), %rdi
callq 0xf0fc
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1012e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5470
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x10163
jmp 0x10170
jmp 0x1014d
movq %rax, %rbx
jmp 0x10170
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x10170
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5470
movq %rbx, %rdi
callq 0x57b0
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::operator*(point)
inline float point::operator* ( point p ) {
  int i;
  float r;
  
  assert( nc == p.nc );
  r = 0.0;
  for( i = 0; i < nc ; i++ )
    r += c[i] * p.c[i];
  return r;
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x2df2
xorps %xmm0, %xmm0
testl %eax, %eax
jle 0x2df1
xorl %ecx, %ecx
movss 0xc(%rdi,%rcx,4), %xmm1
mulss 0xc(%rsi,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x2dd9
retq
pushq %rax
leaq 0x629e(%rip), %rdi      # 0x9098
leaq 0x626d(%rip), %rsi      # 0x906e
leaq 0x629b(%rip), %rcx      # 0x90a3
movl $0x4f, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::operator+=(point)
inline void point::operator+= ( point p ) {
  int i;
  
  assert( nc == p.nc );
  for( i = 0; i < nc ; i++ )
    c[i] += p.c[i];
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x30a5
testl %eax, %eax
jle 0x30a4
xorl %ecx, %ecx
movss 0xc(%rsi,%rcx,4), %xmm0
addss 0xc(%rdi,%rcx,4), %xmm0
movss %xmm0, 0xc(%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x308a
retq
pushq %rax
leaq 0x5feb(%rip), %rdi      # 0x9098
leaq 0x5fba(%rip), %rsi      # 0x906e
leaq 0x600e(%rip), %rcx      # 0x90c9
movl $0x66, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::transform(xform&)
inline void point::transform ( xform &m ) {
  int i, n;
  float t[4];

  assert( nc < 5 );
  for( n = 0; n < nc; n++ )
    t[n] = c[n];
  while( n < 3 )
    t[n++] = 0;
  if( n < 4 )
    t[n++] = 1;
  for( i = 0; i < nc; i++ )
    c[i] = m.rowmult( i, t );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x8(%rdi), %r15
cmpq $0x4, %r15
jg 0x32a7
movq %rsi, %rbx
movq %rdi, %r14
testl %r15d, %r15d
jle 0x3231
leaq 0xc(%r14), %rsi
movq %r15, %rdx
shlq $0x2, %rdx
movq %rsp, %rdi
callq 0x20a0
jmp 0x3234
xorl %r15d, %r15d
cmpl $0x2, %r15d
ja 0x325e
movl %r15d, %eax
leaq (%rsp,%rax,4), %rdi
movl $0x2, %eax
subl %r15d, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x2070
movl $0x3, %r15d
cmpl $0x3, %r15d
jne 0x326c
movl $0x3f800000, 0xc(%rsp)  # imm = 0x3F800000
cmpl $0x0, 0x8(%r14)
jle 0x329b
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
movss %xmm0, 0xc(%r14,%r15,4)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x3279
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5e41(%rip), %rdi      # 0x90ef
leaq 0x5db9(%rip), %rsi      # 0x906e
leaq 0x5e3a(%rip), %rcx      # 0x90f6
movl $0x92, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::vproduct(point)
inline point point::vproduct( point p ) {
  int i;
  point r(nc);

  assert( nc == p.nc );
  for( i = 0; i < nc; i++ )
    r.c[i] = c[i] * p.c[i];
  return r;
}

// Assembly:
pushq %rax
movl 0x8(%rsi), %eax
leaq 0x9481(%rip), %rcx      # 0xc848
movq %rcx, (%rdi)
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0x33ff
movl %eax, 0x8(%rdi)
cmpl 0x8(%rdx), %eax
jne 0x341e
testl %eax, %eax
jle 0x33fa
xorl %ecx, %ecx
movss 0xc(%rsi,%rcx,4), %xmm0
mulss 0xc(%rdx,%rcx,4), %xmm0
movss %xmm0, 0xc(%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x33e0
movq %rdi, %rax
popq %rcx
retq
leaq 0x5d52(%rip), %rdi      # 0x9158
leaq 0x5c61(%rip), %rsi      # 0x906e
leaq 0x5d58(%rip), %rcx      # 0x916c
movl $0x1a, %edx
callq 0x2080
leaq 0x5c73(%rip), %rdi      # 0x9098
leaq 0x5c42(%rip), %rsi      # 0x906e
leaq 0x5d4b(%rip), %rcx      # 0x917e
movl $0xb2, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::mag2()
inline float point::mag2( void ) {
  int i;
  float r;

  r = 0.0;
  for( i = 0; i < nc ; i++ )
    r += c[i] * c[i];
  return r;
}

// Assembly:
movslq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
testq %rax, %rax
jle 0x3480
xorl %ecx, %ecx
movss 0xc(%rdi,%rcx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x346a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::dilation(float)
inline point point::dilation( float n ) {
  int i;
  point r(nc + 1);

  for( i = 0; i < nc; i++ )
    r.c[i] = c[i];
  r.c[nc] = n;
  return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rsi), %r14d
leaq 0x91e1(%rip), %rax      # 0xc848
movq %rax, (%rdi)
cmpq $0x4, %r14
jae 0x36b2
movq %rdi, %rbx
leal 0x1(%r14), %eax
movl %eax, 0x8(%rdi)
testq %r14, %r14
je 0x36a0
addq $0xc, %rsi
leaq 0xc(%rbx), %rdi
leaq (,%r14,4), %rdx
movss %xmm0, 0x4(%rsp)
callq 0x20a0
movss 0x4(%rsp), %xmm0
movss %xmm0, 0xc(%rbx,%r14,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5a9f(%rip), %rdi      # 0x9158
leaq 0x59ae(%rip), %rsi      # 0x906e
leaq 0x5aa5(%rip), %rcx      # 0x916c
movl $0x1a, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/./point.cc
// Function: point::contraction()
inline point point::contraction( void ) {
  int i;
  point r( nc - 1 );

  for( i = 0; i < nc - 1; i++ )
    r.c[i] = c[i];
  return r;
}

// Assembly:
pushq %rbx
movl 0x8(%rsi), %eax
leaq 0x916b(%rip), %rcx      # 0xc848
movq %rcx, (%rdi)
leal -0x2(%rax), %ecx
cmpl $0x4, %ecx
jae 0x3711
movq %rdi, %rbx
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x2, %eax
jl 0x370c
addq $0xc, %rsi
movq %rbx, %rdi
addq $0xc, %rdi
movl %ecx, %edx
shlq $0x2, %rdx
callq 0x20a0
movq %rbx, %rax
popq %rbx
retq
leaq 0x5a40(%rip), %rdi      # 0x9158
leaq 0x594f(%rip), %rsi      # 0x906e
leaq 0x5a46(%rip), %rcx      # 0x916c
movl $0x1a, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::poly(int, texture*)
poly::poly( int n, texture *t )
 : object( t ), to( XFORM_IDENTITY ), toi( XFORM_IDENTITY ) {
  int i;
  typedef point *pp;

  np = n;
  dp = 0;
  p = new pp[ np ];
  for( i = 0; i < np; i++ )
    p[i] = 0;
  cnormal = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x5170
leaq 0x8a0c(%rip), %rax      # 0xc998
movq %rax, (%rbx)
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x4880
leaq 0xc0(%rbx), %rdi
xorl %esi, %esi
callq 0x4880
movl %ebp, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
movslq %ebp, %r14
leaq (,%r14,8), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
testl %r14d, %r14d
jle 0x3ff1
movl %ebp, %eax
xorl %ecx, %ecx
movq 0x20(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3fdd
movq $0x0, 0x158(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::poly(poly const&)
poly::poly( const poly &q ) : object( q.ot ), to( q.to ), toi( q.toi ) {
  int i;
  typedef point *pp;

  np = q.np;
  dp = q.dp;
  p = new pp[ np ];
  for( i = 0; i < np; i++ )
    if( q.p[i] )
      p[i] = new point( *q.p[i] );
    else
      p[i] = 0;
  cnormal = 0;
  if( q.cnormal )
    cnormal = new point( *q.cnormal );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x5170
leaq 0x8975(%rip), %rax      # 0xc998
movq %rax, (%rbx)
leaq 0x28(%rbx), %rdi
leaq 0x28(%r14), %rsi
callq 0x4d3a
movl $0xc0, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x4d3a
movslq 0x18(%r14), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x18(%rbx)
movl 0x1c(%r14), %ecx
movl %ecx, 0x1c(%rbx)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
leaq 0x87cf(%rip), %r12      # 0xc848
testq %r15, %r15
jle 0x40d5
xorl %r13d, %r13d
movq 0x20(%r14), %rbp
cmpq $0x0, (%rbp,%r13,8)
je 0x40c3
movl $0x20, %edi
callq 0x20f0
movq (%rbp,%r13,8), %rcx
movq %r12, (%rax)
movslq 0x8(%rcx), %rdx
movl %edx, 0x8(%rax)
testq %rdx, %rdx
jle 0x40c5
xorl %esi, %esi
movss 0xc(%rcx,%rsi,4), %xmm0
movss %xmm0, 0xc(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x40ad
jmp 0x40c5
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r15, %r13
jne 0x4081
movq $0x0, 0x158(%rbx)
movq 0x158(%r14), %r14
testq %r14, %r14
je 0x4123
movl $0x20, %edi
callq 0x20f0
movq %r12, (%rax)
movslq 0x8(%r14), %rcx
movl %ecx, 0x8(%rax)
testq %rcx, %rcx
jle 0x411c
xorl %edx, %edx
movss 0xc(%r14,%rdx,4), %xmm0
movss %xmm0, 0xc(%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x4107
movq %rax, 0x158(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::operator=(poly const&)
void poly::operator= ( const poly &q ) {
  int i;
  typedef point *pp;

  // out with the old
  for( i = 0; i < np; i++ )
    if( p[i] )
      delete p[i];
  delete p;
  if( cnormal )
    delete cnormal;
  // in with the new
  np = q.np;
  dp = q.dp;
  p = new pp[ np ];
  for( i = 0; i < np; i++ )
    if( q.p[i] )
      p[i] = new point( *q.p[i] );
    else
      p[i] = 0;
  cnormal = 0;
  if( q.cnormal )
    cnormal = new point( *q.cnormal );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x416b
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x415f
movq (%rdi), %rax
callq *0x18(%rax)
incq %r15
movslq 0x18(%rbx), %rax
cmpq %rax, %r15
jl 0x414c
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x417e
movl $0x8, %esi
callq 0x2100
movq 0x158(%rbx), %rdi
testq %rdi, %rdi
je 0x4190
movq (%rdi), %rax
callq *0x18(%rax)
movslq 0x18(%r14), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x18(%rbx)
movl 0x1c(%r14), %ecx
movl %ecx, 0x1c(%rbx)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
leaq 0x8683(%rip), %r12      # 0xc848
testq %r15, %r15
jle 0x4221
xorl %r13d, %r13d
movq 0x20(%r14), %rbp
cmpq $0x0, (%rbp,%r13,8)
je 0x420f
movl $0x20, %edi
callq 0x20f0
movq (%rbp,%r13,8), %rcx
movq %r12, (%rax)
movslq 0x8(%rcx), %rdx
movl %edx, 0x8(%rax)
testq %rdx, %rdx
jle 0x4211
xorl %esi, %esi
movss 0xc(%rcx,%rsi,4), %xmm0
movss %xmm0, 0xc(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x41f9
jmp 0x4211
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r15, %r13
jne 0x41cd
movq $0x0, 0x158(%rbx)
movq 0x158(%r14), %r14
testq %r14, %r14
je 0x426f
movl $0x20, %edi
callq 0x20f0
movq %r12, (%rax)
movslq 0x8(%r14), %rcx
movl %ecx, 0x8(%rax)
testq %rcx, %rcx
jle 0x4268
xorl %edx, %edx
movss 0xc(%r14,%rdx,4), %xmm0
movss %xmm0, 0xc(%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x4253
movq %rax, 0x158(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::complete()
void poly::complete( void ) {
  int i;

  for( i = 0; i < np; i++ )
    assert( p[i] );
  cnormal = inormal();
#if DEBUGLEVEL > 2
  printf( "new poly: %d\n", np );
  for( i = 0; i < np; i++ ) {
    point q( *p[i] );

    q.dilate( 0 );
    q.transform( to );
    printf( "\t%f %f %f\n", q[0], q[1], q[2] );
  }
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
testq %rax, %rax
jle 0x42a0
movq 0x20(%rbx), %rcx
xorl %edx, %edx
cmpq $0x0, (%rcx,%rdx,8)
je 0x42b2
incq %rdx
cmpq %rdx, %rax
jne 0x4291
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movq %rax, 0x158(%rbx)
popq %rbx
retq
leaq 0x4fd7(%rip), %rdi      # 0x9290
leaq 0x4fd5(%rip), %rsi      # 0x9295
leaq 0x4fd6(%rip), %rcx      # 0x929d
movl $0xb0, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::~poly()
inline poly::~poly() {
  int i;

  if( np ) {
    for( i = 0; i < np; i++ )
      if( p[i] )
        delete p[i];
    delete p;
  }
  if( cnormal )
    delete( cnormal );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x86b8(%rip), %rax      # 0xc998
movq %rax, (%rdi)
cmpl $0x0, 0x18(%rdi)
je 0x4324
cmpl $0x0, 0x18(%rbx)
jle 0x4311
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4305
movq (%rdi), %rax
callq *0x18(%rax)
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x42f2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4324
movl $0x8, %esi
callq 0x2100
movq 0x158(%rbx), %rdi
testq %rdi, %rdi
je 0x433d
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::inormal()
inline point *poly::inormal( void ) {
  point *r;
  point o( 0.0, 0.0, 0.0 );
  
  r = new point(0.0,0.0,1.0);
  r->transform( toi );
  o.transform( toi );
  *r -= o;
  r->unitize();
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x822e(%rip), %rbp      # 0xc848
leaq 0x24(%rsp), %r13
movq %rbp, -0xc(%r13)
movl $0x3, %r12d
movl %r12d, -0x4(%r13)
xorl %r15d, %r15d
movq %r15, (%r13)
movl $0x0, 0x8(%r13)
movl $0x20, %edi
callq 0x20f0
movq %rax, %rbx
movq %rbp, (%rax)
movl %r12d, 0x8(%rax)
movq %r15, 0xc(%rax)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%rbx)
addq $0xc0, %r14
movl 0x14(%rbx), %ecx
movq %rsp, %r12
movl %ecx, 0x8(%r12)
movq 0xc(%rbx), %rcx
movq %rcx, (%r12)
movl %eax, 0xc(%r12)
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
movss %xmm0, 0xc(%rbx,%r15,4)
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x467b
movl 0x8(%r13), %eax
movq %rsp, %r15
movl %eax, 0x8(%r15)
movq (%r13), %rax
movq %rax, (%r15)
movl $0x3f800000, 0xc(%r15)  # imm = 0x3F800000
xorl %r12d, %r12d
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq *0x20(%rax)
movss %xmm0, 0x24(%rsp,%r12,4)
incq %r12
cmpq $0x3, %r12
jne 0x46ba
leaq 0x38(%rsp), %rsi
movq %rbp, (%rsi)
movl $0x3, 0x8(%rsi)
movq (%r13), %rax
movq %rax, 0xc(%rsi)
movl 0x8(%r13), %eax
movl %eax, 0x14(%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::set(int, point&)
inline poly & poly::set( int i, point & f ) {
  point **p = ref(i);

  assert( !(*p) );
  if( dp )
    assert( dp == f.d() );
  else
    dp = f.d();
  *p = new point( f );
  return (*this);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, (%rax)
jne 0x47c4
movq %rax, %r15
movl 0x1c(%rbx), %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0xe8(%rax)
testl %ebp, %ebp
je 0x4775
cmpl %eax, %ebp
je 0x4778
leaq 0x4c5d(%rip), %rdi      # 0x93ba
leaq 0x4b31(%rip), %rsi      # 0x9295
leaq 0x4c29(%rip), %rcx      # 0x9394
movl $0xe0, %edx
callq 0x2080
movl %eax, 0x1c(%rbx)
movl $0x20, %edi
callq 0x20f0
movq %rax, %r12
leaq 0x80bc(%rip), %rax      # 0xc848
movq %rax, (%r12)
movslq 0x8(%r14), %rdx
movl %edx, 0x8(%r12)
testq %rdx, %rdx
jle 0x47b5
addq $0xc, %r14
movq %r12, %rdi
addq $0xc, %rdi
shlq $0x2, %rdx
movq %r14, %rsi
callq 0x20a0
movq %r12, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4bc3(%rip), %rdi      # 0x938e
leaq 0x4ac3(%rip), %rsi      # 0x9295
leaq 0x4bbb(%rip), %rcx      # 0x9394
movl $0xde, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::dilate(float)
inline void poly::dilate( float n ) {
  int i;

  for( i = 0; i < np; i++ )
    if( p[i] )
      p[i]->dilate( n );
  dp++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x4834
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4828
movq (%rdi), %rax
movss 0x4(%rsp), %xmm0
callq *0xd0(%rax)
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x480c
incl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::contract()
inline void poly::contract( void ) {
  int i;

  for( i = 0; i < np; i++ )
    if( p[i] )
      p[i]->contract();
  dp--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x4872
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4866
movq (%rdi), %rax
callq *0xe0(%rax)
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x4850
decl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::xform(xform_types)
xform::xform( enum xform_types t ) {
  int i, j;

  assert( t == XFORM_IDENTITY );
  m = &mv;
  mi = &miv;
  for( i = 0; i < 4; i++ )
    for( j = 0; j < 4; j++ ) {
      (*m)[i][j] = (i == j);
      (*mi)[i][j] = (i == j);
    }
}

// Assembly:
pushq %rax
leaq 0x81d8(%rip), %rax      # 0xca60
movq %rax, (%rdi)
testl %esi, %esi
jne 0x48d9
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x475f(%rip), %xmm0     # 0x9008
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x48b6
xorps %xmm1, %xmm1
movss %xmm1, -0x40(%rax,%rdx,4)
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x48ab
incq %rcx
addq $0x10, %rax
cmpq $0x4, %rcx
jne 0x48a9
popq %rax
retq
leaq 0x4aec(%rip), %rdi      # 0x93cc
leaq 0x4af9(%rip), %rsi      # 0x93e0
leaq 0x4afb(%rip), %rcx      # 0x93e9
movl $0xe, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::xform(xform const&)
xform::xform( const xform &t ) {
  int i, j;

  m = &mv;
  mi = &miv;
  for( i = 0; i < 4; i++ )
    for( j = 0; j < 4; j++ ) {
      (*m)[i][j] = (*t.m)[i][j];
      (*mi)[i][j] = (*t.mi)[i][j];
    }
}

// Assembly:
leaq 0x7d1f(%rip), %rax      # 0xca60
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, -0x40(%rax,%rdi,4)
movss (%rdx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,4)
incq %rdi
cmpq $0x4, %rdi
jne 0x4d60
incq %rsi
addq $0x10, %rcx
addq $0x10, %rax
addq $0x10, %rdx
cmpq $0x4, %rsi
jne 0x4d5e
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::row(int)
inline point xform::row( int i ) {
  int k;
  point p(4);

  for( k = 0; k < 4; k++ )
    p.set( k, (*m)[i][k] );
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7a7f(%rip), %rax      # 0xc848
movq %rax, (%rdi)
movl $0x4, 0x8(%rdi)
movslq %edx, %r12
shlq $0x4, %r12
xorl %r15d, %r15d
movq 0x8(%r14), %rax
addq %r12, %rax
movss (%rax,%r15,4), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r15
cmpq $0x4, %r15
jne 0x4ddd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::rowmult(int, float*)
inline float xform::rowmult( int i, float t[4] ) {
  // inline expand for speed
  return
      (*m)[i][0] * t[0]
    + (*m)[i][1] * t[1]
    + (*m)[i][2] * t[2]
    + (*m)[i][3] * t[3];
}

// Assembly:
movq 0x8(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
movss (%rax,%rcx), %xmm0
movss 0x4(%rax,%rcx), %xmm1
mulss 0x4(%rdx), %xmm1
mulss (%rdx), %xmm0
addss %xmm1, %xmm0
movss 0x8(%rax,%rcx), %xmm1
mulss 0x8(%rdx), %xmm1
addss %xmm0, %xmm1
movss 0xc(%rax,%rcx), %xmm0
mulss 0xc(%rdx), %xmm0
addss %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::col(int)
inline point xform::col( int j ) {
  int i;
  point p(4);

  for( i = 0; i < 4; i++ )
    p.set( j, (*m)[i][j] );
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x79cc(%rip), %rax      # 0xc848
movq %rax, (%rdi)
movl $0x4, 0x8(%rdi)
movslq %edx, %r12
shlq $0x2, %r12
xorl %r13d, %r13d
movq 0x8(%r15), %rax
addq %r12, %rax
movss (%r13,%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
addq $0x10, %r13
cmpq $0x40, %r13
jne 0x4e90
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::operator*=(xform)
inline void xform::operator*= ( xform n ) {
  int i, j, k;
  xform l(*this);

  for( i = 0; i < 4; i++ )
    for( j = 0; j < 4; j++ ) {
      (*m)[i][j] = (*n.m)[i][0] * (*l.m)[0][j];
      for( k = 1; k < 4; k++ )
        (*m)[i][j] += (*n.m)[i][k] * (*l.m)[k][j];
    }
  for( i = 0; i < 4; i++ )
    for( j = 0; j < 4; j++ ) {
      (*mi)[i][j] = (*l.mi)[i][0] * (*n.mi)[0][j];
      for( k = 1; k < 4; k++ )
        (*mi)[i][j] += (*l.mi)[i][k] * (*n.mi)[k][j];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d3a
movq 0x8(%r14), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rbx), %rdx
leaq 0x4(%rax), %rsi
leaq 0x10(%rcx), %rdi
xorl %r8d, %r8d
movq %r8, %r9
shlq $0x4, %r9
leaq (%rax,%r9), %r10
addq %rdx, %r9
movq %rdi, %r11
xorl %r15d, %r15d
movss (%r10), %xmm0
mulss (%rcx,%r15,4), %xmm0
leaq (%r9,%r15,4), %r12
movss %xmm0, (%r12)
xorl %r13d, %r13d
movss (%rsi,%r13), %xmm1
mulss (%r11,%r13,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%r12)
addq $0x4, %r13
cmpq $0xc, %r13
jne 0x4f3d
incq %r15
addq $0x4, %r11
cmpq $0x4, %r15
jne 0x4f25
incq %r8
addq $0x10, %rsi
cmpq $0x4, %r8
jne 0x4f11
movq 0x18(%rsp), %rax
movq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
leaq 0x4(%rax), %rsi
leaq 0x10(%rcx), %rdi
xorl %r8d, %r8d
movq %r8, %r9
shlq $0x4, %r9
leaq (%rax,%r9), %r10
addq %rdx, %r9
movq %rdi, %r11
xorl %ebx, %ebx
movss (%r10), %xmm0
mulss (%rcx,%rbx,4), %xmm0
leaq (%r9,%rbx,4), %r14
movss %xmm0, (%r14)
xorl %r15d, %r15d
movss (%rsi,%r15), %xmm1
mulss (%r11,%r15,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%r14)
addq $0x4, %r15
cmpq $0xc, %r15
jne 0x4fb8
incq %rbx
addq $0x4, %r11
cmpq $0x4, %rbx
jne 0x4fa2
incq %r8
addq $0x10, %rsi
cmpq $0x4, %r8
jne 0x4f8f
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/board_texture.cc
// Function: board_texture::tune_texture(model&)
texture *board_texture::tune_texture( model &m ) {
  assert( red_texture );
  assert( black_texture );

  texture *nr = red_texture->tune_texture( m );
  texture *nb = black_texture->tune_texture( m );
  return new board_texture( nr, nb );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x65c0
cmpq $0x0, 0x78(%r14)
je 0x65df
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq 0x78(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r14
movl $0x80, %edi
callq 0x20f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x63f4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2f33(%rip), %rdi      # 0x94fa
leaq 0x2f38(%rip), %rsi      # 0x9506
leaq 0x2f42(%rip), %rcx      # 0x9517
movl $0x1d, %edx
callq 0x2080
leaq 0x2f67(%rip), %rdi      # 0x954d
leaq 0x2f19(%rip), %rsi      # 0x9506
leaq 0x2f23(%rip), %rcx      # 0x9517
movl $0x1e, %edx
callq 0x2080
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/board_texture.cc
// Function: board_texture::value(point&, point&, point&, model&, int)
inline point board_texture::value( point &at, point &gc, point &normal,
 model &m, int depth ) {
  int x = (int) floor( X( at ) );
  int y = (int) floor( Y( at ) );

  if( (x & 1) ^ (y & 1) )
    return red_texture->value( at, gc, normal, m, depth );
  else
    return black_texture->value( at, gc, normal, m, depth );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq %rdx, %rdi
callq *0xe8(%rax)
testl %eax, %eax
jle 0x66e7
movq %rbx, 0x10(%rsp)
movq (%r13), %rax
movq %r13, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0xe8(%rax)
cmpl $0x1, %eax
jle 0x6706
movss 0xc(%rsp), %xmm0
callq 0x2040
cvttss2si %xmm0, %ebx
movq (%r13), %rax
movq %r13, %rdi
movl $0x1, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
callq 0x2040
cvttss2si %xmm0, %eax
xorl %ebx, %eax
xorl %ecx, %ecx
testb $0x1, %al
sete %cl
movq 0x10(%rsp), %rax
movq 0x70(%rax,%rcx,8), %rsi
movq (%rsi), %rax
movl 0x50(%rsp), %ecx
movl %ecx, (%rsp)
movq %r14, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq *0x18(%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bcd(%rip), %rdi      # 0x92bb
leaq 0x2979(%rip), %rsi      # 0x906e
leaq 0x2bc9(%rip), %rcx      # 0x92c5
movl $0x104, %edx            # imm = 0x104
callq 0x2080
leaq 0x2bc9(%rip), %rdi      # 0x92d6
leaq 0x295a(%rip), %rsi      # 0x906e
leaq 0x2bc5(%rip), %rcx      # 0x92e0
movl $0x109, %edx            # imm = 0x109
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/output.cc
// Function: output::output(char*, char*, int, int)
output::output( char *fn, char *ext, int w, int h ) {
  xsize = w;
  ysize = h;
  name = new char[ strlen( fn ) + strlen( ext ) + 1 ];
  (void) strcpy( name, fn );
  (void) strcat( name, ext );
  outfile = fopen( name, "w" );
  if( !outfile ) {
    perror( "fopen" );
    assert( 0 );
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x64bc(%rip), %rax      # 0xcc60
movq %rax, (%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movq %rsi, %rdi
callq 0x2050
movq %rax, %r12
movq %r14, %rdi
callq 0x2050
leaq (%r12,%rax), %rdi
incq %rdi
callq 0x2030
movq %rax, %r12
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x20d0
movq %r12, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x2d93(%rip), %rsi      # 0x9584
movq %r12, %rdi
callq 0x2110
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x680e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x221e
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/ppm_output.cc
// Function: ppm_output::putpixel(int, int, point&)
inline void ppm_output::putpixel( int x, int y, point &c ) {
  unsigned char r = gamma(R(c));
  unsigned char g = gamma(G(c));
  unsigned char b = gamma(B(c));

  assert( x < xsize && curx == x && cury == y );
  curx++;
#if DEBUGLEVEL > 3
  printf( "output: %f %f %f\n", c[0], c[1], c[2] );
#endif
  fputc( r, outfile );
  fputc( g, outfile );
  fputc( b, outfile );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a17
movq (%r12), %rax
movq %r12, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r15d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a36
movq (%r12), %rax
movq %r12, %rdi
movl $0x1, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r13d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a55
movq (%r12), %rax
movq %r12, %rdi
movl $0x2, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl %r14d, 0x8(%rbx)
jle 0x69f8
movl %eax, %r12d
movl 0x20(%rbx), %eax
cmpl %r14d, %eax
jne 0x69f8
cmpl %ebp, 0x24(%rbx)
jne 0x69f8
incl %eax
movl %eax, 0x20(%rbx)
movzbl %r15b, %edi
movq 0x18(%rbx), %rsi
callq 0x2120
movzbl %r13b, %edi
movq 0x18(%rbx), %rsi
callq 0x2120
movzbl %r12b, %edi
movq 0x18(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
leaq 0x2bd0(%rip), %rdi      # 0x95cf
leaq 0x2cc3(%rip), %rsi      # 0x96c9
leaq 0x2be6(%rip), %rcx      # 0x95f3
movl $0x3b, %edx
callq 0x2080
leaq 0x2c0a(%rip), %rdi      # 0x9628
leaq 0x2649(%rip), %rsi      # 0x906e
leaq 0x2c07(%rip), %rcx      # 0x9633
movl $0x118, %edx            # imm = 0x118
callq 0x2080
leaq 0x2beb(%rip), %rdi      # 0x9628
leaq 0x262a(%rip), %rsi      # 0x906e
leaq 0x2bf9(%rip), %rcx      # 0x9644
movl $0x11d, %edx            # imm = 0x11D
callq 0x2080
leaq 0x2bcc(%rip), %rdi      # 0x9628
leaq 0x260b(%rip), %rsi      # 0x906e
leaq 0x2beb(%rip), %rcx      # 0x9655
movl $0x122, %edx            # imm = 0x122
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/ppm_output.cc
// Function: ppm_output::flushrow(int)
inline void ppm_output::flushrow( int y ) {
  assert( y < ysize && cury == y );
  cury++;
  curx = 0;
#if DEBUGLEVEL == 2
  if( !(y % 10) )
#endif
#if DEBUGLEVEL >= 2
    printf( "output row: %d\n", y );
#endif
}

// Assembly:
cmpl %esi, 0xc(%rdi)
jle 0x6a8d
movl 0x24(%rdi), %eax
cmpl %esi, %eax
jne 0x6a8d
incl %eax
movl %eax, 0x24(%rdi)
movl $0x0, 0x20(%rdi)
retq
pushq %rax
leaq 0x2bd1(%rip), %rdi      # 0x9666
leaq 0x2c2d(%rip), %rsi      # 0x96c9
leaq 0x2bda(%rip), %rcx      # 0x967d
movl $0x2a, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/oldppm_output.cc
// Function: oldppm_output::putpixel(int, int, point&)
inline void oldppm_output::putpixel( int x, int y, point &c ) {
  unsigned char r = gamma(R(c));
  unsigned char g = gamma(G(c));
  unsigned char b = gamma(B(c));

  assert( x < xsize && curx == x && cury == y );
  curx++;
#if DEBUGLEVEL > 3
  printf( "output: %f %f %f\n", c[0], c[1], c[2] );
#endif
  fprintf( outfile, "%3d ", r );
  fprintf( outfile, "%3d ", g );
  fprintf( outfile, "%3d ", b );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6c41
movq (%r12), %rax
movq %r12, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r15d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6c60
movq (%r12), %rax
movq %r12, %rdi
movl $0x1, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r13d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6c7f
movq (%r12), %rax
movq %r12, %rdi
movl $0x2, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl %r14d, 0x8(%rbx)
jle 0x6c22
movl %eax, %r12d
movl 0x20(%rbx), %eax
cmpl %r14d, %eax
jne 0x6c22
cmpl %ebp, 0x24(%rbx)
jne 0x6c22
incl %eax
movl %eax, 0x20(%rbx)
movq 0x18(%rbx), %rdi
movzbl %r15b, %edx
leaq 0x2b29(%rip), %r14      # 0x970f
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x18(%rbx), %rdi
movzbl %r13b, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x18(%rbx), %rdi
movzbl %r12b, %edx
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
leaq 0x29a6(%rip), %rdi      # 0x95cf
leaq 0x2a96(%rip), %rsi      # 0x96c6
leaq 0x2aa0(%rip), %rcx      # 0x96d7
movl $0x24, %edx
callq 0x2080
leaq 0x29e0(%rip), %rdi      # 0x9628
leaq 0x241f(%rip), %rsi      # 0x906e
leaq 0x29dd(%rip), %rcx      # 0x9633
movl $0x118, %edx            # imm = 0x118
callq 0x2080
leaq 0x29c1(%rip), %rdi      # 0x9628
leaq 0x2400(%rip), %rsi      # 0x906e
leaq 0x29cf(%rip), %rcx      # 0x9644
movl $0x11d, %edx            # imm = 0x11D
callq 0x2080
leaq 0x29a2(%rip), %rdi      # 0x9628
leaq 0x23e1(%rip), %rsi      # 0x906e
leaq 0x29c1(%rip), %rcx      # 0x9655
movl $0x122, %edx            # imm = 0x122
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/oldppm_output.cc
// Function: oldppm_output::flushrow(int)
inline void oldppm_output::flushrow( int y ) {
  assert( y < ysize && cury == y );
  cury++;
  curx = 0;
#if DEBUGLEVEL == 2
  if( !(y % 10) )
#endif
#if DEBUGLEVEL >= 2
    printf( "output row: %d\n", y );
#endif
  fprintf( outfile, "\n" );
}

// Assembly:
cmpl %esi, 0xc(%rdi)
jle 0x6cc4
movl 0x24(%rdi), %eax
cmpl %esi, %eax
jne 0x6cc4
incl %eax
movl %eax, 0x24(%rdi)
movl $0x0, 0x20(%rdi)
movq 0x18(%rdi), %rsi
movl $0xa, %edi
jmp 0x2120
pushq %rax
leaq 0x299a(%rip), %rdi      # 0x9666
leaq 0x29f3(%rip), %rsi      # 0x96c6
leaq 0x2a3a(%rip), %rcx      # 0x9714
movl $0x30, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/BartMassey[P]ancient-raytracer/frandom.c
// Function: fnurandom2
double fnurandom2( double centricity ) {
  double x = frandom() * 2;
  int sign = 1;

  if( x > 1 ) {
    x -= 1;
    sign = -1;
  }
  return sign * pow( x, 1 / (1 - centricity) );
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x2060
movq %rax, %rbx
shrq $0x3, %rbx
movabsq $0xa7c53e53e3eeb47, %rcx # imm = 0xA7C53E53E3EEB47
movq %rbx, %rax
mulq %rcx
shrq $0xc, %rdx
imulq $0x186a1, %rdx, %rax    # imm = 0x186A1
subq %rax, %rbx
movabsq $0xa7c5ac471b48, %rcx   # imm = 0xA7C5AC471B48
movq %rbx, %rax
mulq %rcx
cmpq $0x186a0, %rbx          # imm = 0x186A0
jb 0x810d
leal -0x1(,%rdx,2), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0x8116
addl %edx, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd 0x1452(%rip), %xmm1     # 0x9570
movapd %xmm1, %xmm2
subsd 0x8(%rsp), %xmm2
divsd %xmm2, %xmm1
callq 0x2190
cmpq $0x186a0, %rbx          # imm = 0x186A0
jb 0x8142
xorpd 0x167e(%rip), %xmm0     # 0x97c0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/aes_upload.cpp
// Function: md5sum(char*, int, char*)
void md5sum(char *data, int size, char *hash)
{
	MD5_CTX ctx;
	unsigned char digest[16] = { 0 };

	memset(&ctx, 0, sizeof(MD5_CTX));
	MD5_Init(&ctx);
	MD5_Update(&ctx, data, size);
	MD5_Final(digest, &ctx);

	for (int i = 0; i < 16; ++i)
	{
		sprintf(&hash[i * 2], "%02x", (unsigned int)digest[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r12
movaps %xmm0, (%r12)
leaq -0xa0(%rbp), %r13
movaps %xmm0, (%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x30(%r13)
movaps %xmm0, 0x40(%r13)
movups %xmm0, 0x4c(%r13)
movq %r13, %rdi
callq 0x21a0
movslq %r14d, %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x22f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2250
leaq 0xb75(%rip), %r14       # 0x3004
xorl %r15d, %r15d
movzbl -0x40(%rbp,%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2080
incq %r15
addq $0x2, %rbx
cmpq $0x10, %r15
jne 0x2492
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq