LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]def2fgd/src/entity.cpp
// Function: operator<<(std::ostream&, Entity const&)
std::ostream& operator<<(std::ostream& out, const Entity& entity)
{
    out << entity.name << (entity.solid ? " solid" : " point");
    for (size_t i=0;i<6;++i)
        out << " " << entity.box[i];
    out << std::endl;
    for (size_t i=0; i<entity.keys.size(); ++i)
    {
        out << entity.keys[i].name << " ";
    }
    if (!entity.model.empty())
        out << "model=" <<entity.model;
    out << std::endl;
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x32c0
leaq 0x3501(%rip), %rcx      # 0xb8e4
leaq 0x3501(%rip), %rsi      # 0xb8eb
cmpb $0x0, 0x87c(%r14)
cmovneq %rcx, %rsi
movl $0x6, %edx
movq %rax, %rdi
callq 0x32c0
xorl %r12d, %r12d
leaq 0x2cdc(%rip), %r15      # 0xb0e9
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32c0
movl 0x864(%r14,%r12,4), %esi
movq %rbx, %rdi
callq 0x3400
incq %r12
cmpq $0x6, %r12
jne 0x840d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x40(%r14), %rax
cmpq %rax, 0x48(%r14)
je 0x84c1
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x2c72(%rip), %r15      # 0xb0e9
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x32c0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32c0
incq %r13
movq 0x40(%r14), %rax
movq 0x48(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
imulq %rbp, %rcx
addq $0x60, %r12
cmpq %rcx, %r13
jb 0x8481
cmpq $0x0, 0x888(%r14)
je 0x84f5
leaq 0x3420(%rip), %rsi      # 0xb8f2
movl $0x6, %edx
movq %rbx, %rdi
callq 0x32c0
movq 0x880(%r14), %rsi
movq 0x888(%r14), %rdx
movq %rbx, %rdi
callq 0x32c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_radial_gradient_def(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void write_radial_gradient_def( std::ostream & os, const std::string & name )
{
   using namespace std ;
   os << "<radialGradient id='" << name << "' cx='50%' cy='50%' r='50%' fx='25%' fy='75%'>" << endl
      << "   <stop offset='0%'   style='stop-color:rgb(100%,100%,100%); stop-opacity:0.2' />" << endl
      << "   <stop offset='100%' style='stop-color:rgb(20%,20%,20%);    stop-opacity:0.2' />" << endl
      << "</radialGradient>" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7098(%rip), %rsi      # 0xd2b0
movl $0x14, %edx
callq 0x31e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x708a(%rip), %rsi      # 0xd2c5
movl $0x2e, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x707b(%rip), %rsi      # 0xd2f4
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x7090(%rip), %rsi      # 0xd347
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x70a5(%rip), %rsi      # 0xd39a
movl $0x11, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_radial_gradient_def_blue(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void write_radial_gradient_def_blue( std::ostream & os, const std::string & name )
{
   using namespace std ;
   os << "<radialGradient id='" << name << "' cx='50%' cy='50%' r='50%' fx='50%' fy='50%'>" << endl
      << "   <stop offset='0%'   style='stop-color:rgb(100%,100%,100%); stop-opacity:0.2' />" << endl
      << "   <stop offset='100%' style='stop-color:rgb(0%,0%,50%);    stop-opacity:0.4' />" << endl
      << "</radialGradient>" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6f6f(%rip), %rsi      # 0xd2b0
movl $0x14, %edx
callq 0x31e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x7048(%rip), %rsi      # 0xd3ac
movl $0x2e, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x6f52(%rip), %rsi      # 0xd2f4
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x6ffb(%rip), %rsi      # 0xd3db
movl $0x50, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x6f7c(%rip), %rsi      # 0xd39a
movl $0x11, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_color(std::ostream&, VectorTempl3<float> const&)
void write_color( std::ostream & os, const vec3 & col )
{

  os << "rgb("
     << col[0]*100.0 << "%,"
     << col[1]*100.0 << "%,"
     << col[2]*100.0 << "%)"  ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6fcd(%rip), %rsi      # 0xd43a
movl $0x4, %edx
callq 0x31e0
cvtss2sd (%rbx), %xmm0
mulsd 0x6d4d(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x6f97(%rip), %r15      # 0xd42c
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x6d1b(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x6cf0(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
leaq 0x6f40(%rip), %rsi      # 0xd42f
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_stroke_color(std::ostream&, VectorTempl3<float> const&)
void write_stroke_color( std::ostream & os, const vec3 & col )
{

  os << "stroke='rgb("
     << col[0]*100.0 << "%,"
     << col[1]*100.0 << "%,"
     << col[2]*100.0 << "%)' " << std::endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6f15(%rip), %rsi      # 0xd432
movl $0xc, %edx
callq 0x31e0
cvtss2sd (%rbx), %xmm0
mulsd 0x6c9d(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x6ee7(%rip), %r15      # 0xd42c
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x6c6b(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x6c40(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %rbx
leaq 0x6e9d(%rip), %rsi      # 0xd43f
movl $0x4, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_coord2(std::ostream&, VectorTempl2<float> const&)
void write_coord2( std::ostream & os, const vec2 & p )
{
   using namespace std ;
   if ( isnan(p[0]) && isnan(p[1]) )
      cout << "warning: not a number found in vec2. Not written to SVG output file." << endl ;
   else
       os << p[0] << " " << p[1] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
ucomiss %xmm0, %xmm0
jnp 0x6643
movss 0x4(%rbx), %xmm1
ucomiss %xmm1, %xmm1
jnp 0x6643
movq 0xb9cc(%rip), %rbx      # 0x11fd0
leaq 0x6e39(%rip), %rsi      # 0xd444
movl $0x44, %edx
movq %rbx, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
cvtss2sd %xmm0, %xmm0
callq 0x3250
movq %rax, %r14
leaq 0x6dec(%rip), %rsi      # 0xd442
movl $0x1, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Point::drawSVG(SVGContext&)
void Point::drawSVG( SVGContext & ctx )
{
  assert( projected );
  using namespace std ;


  PathStyle e ;
  e.draw_lines   = false ;
  e.draw_filled  = true ;
  e.fill_color   = color ;
  e.fill_opacity = 1.0;

  assert( ctx.os != nullptr );
  std::ostream & os = *(ctx.os) ;

  os << "<circle cx='" << pos2D[0] << "' cy='" << pos2D[1]
     <<       "' r='" << radius << "' " ;
  e.writeSVG( ctx );
  os << "/>" << endl ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpb $0x0, 0x8(%rdi)
je 0x70c7
movq %rsi, %r14
movq %rdi, %r15
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x6c64
movb $0x0, 0x18(%rbx)
movb $0x1, 0x1a(%rbx)
movq 0x28(%r15), %rax
movq %rax, 0xc(%rbx)
movl 0x30(%r15), %eax
movl %eax, 0x14(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movq (%r14), %rbx
testq %rbx, %rbx
je 0x70e6
leaq 0x6686(%rip), %rsi      # 0xd668
movl $0xc, %edx
movq %rbx, %rdi
callq 0x31e0
cvtss2sd 0x34(%r15), %xmm0
movq %rbx, %rdi
callq 0x3250
movq %rax, %r12
leaq 0x666e(%rip), %rsi      # 0xd675
movl $0x6, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x38(%r15), %xmm0
movq %r12, %rdi
callq 0x3250
movq %rax, %r12
leaq 0x664d(%rip), %rsi      # 0xd67c
movl $0x5, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x3c(%r15), %xmm0
movq %r12, %rdi
callq 0x3250
leaq 0x63ed(%rip), %rsi      # 0xd441
movl $0x2, %edx
movq %rax, %rdi
callq 0x31e0
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x6cf8
leaq 0x6323(%rip), %rsi      # 0xd397
movl $0x2, %edx
movq %rbx, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70ba
callq 0x31a0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6acb(%rip), %rdi      # 0xdb99
leaq 0x63db(%rip), %rsi      # 0xd4b0
leaq 0x6550(%rip), %rcx      # 0xd62c
movl $0xf6, %edx
callq 0x3120
leaq 0x6569(%rip), %rdi      # 0xd656
leaq 0x63bc(%rip), %rsi      # 0xd4b0
leaq 0x6531(%rip), %rcx      # 0xd62c
movl $0x100, %edx            # imm = 0x100
callq 0x3120
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x711a
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Polygon::project(Camera const&)
void Polygon::project( const Camera & cam )
{
  bool primero = true ;
  points2D.clear() ;

  for( const vec3 & p3 : points3D )
  {
    const vec2 p2 = cam.project( p3 );
    if ( primero )
    { min = p2 ;
      max = p2 ;
      primero = false ;
    }
    else
    { min[0] = std::min( min[0], p2[0] );
      min[1] = std::min( min[1], p2[1] );
      max[0] = std::max( max[0], p2[0] );
      max[1] = std::max( max[1], p2[1] );
    }
    points2D.push_back( p2 );
    //using namespace std ;
    //cout << "min ==" << min << ", max == " << max << endl ;
  }
  projected = true ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rax, 0x88(%rdi)
je 0x71b8
movq %rax, 0x88(%rbx)
movq 0x68(%rbx), %r15
movq 0x70(%rbx), %r13
cmpq %r13, %r15
je 0x726b
leaq 0x80(%rbx), %rax
movq %rax, -0x30(%rbp)
movb $0x1, %r12b
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b7e
movlps %xmm0, -0x38(%rbp)
movaps %xmm0, %xmm1
testb $0x1, %r12b
je 0x71f8
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movups %xmm1, 0xc(%rbx)
jmp 0x7231
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm0, %xmm2
minss 0xc(%rbx), %xmm2
movss %xmm2, 0xc(%rbx)
movaps %xmm1, %xmm2
minss 0x10(%rbx), %xmm2
movss %xmm2, 0x10(%rbx)
movss 0x14(%rbx), %xmm2
movaps %xmm0, %xmm3
maxss %xmm2, %xmm3
movss %xmm3, 0x14(%rbx)
maxss 0x18(%rbx), %xmm1
movss %xmm1, 0x18(%rbx)
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x724e
movlps %xmm0, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x725b
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xbf30
addq $0xc, %r15
xorl %r12d, %r12d
cmpq %r13, %r15
jne 0x71d7
movb $0x1, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: ObjectsSet::project(Camera const&)
void ObjectsSet::project( const Camera & cam )
{
   bool primero = true ;

   for( Object * pobjeto : objetos )
   {
      assert( pobjeto != nullptr );
      pobjeto->project( cam );

      if ( primero )
      {
         min = pobjeto->min ;
         max = pobjeto->max ;
         primero = false ;
   }
   else
   {
      min[0] = std::min( min[0], pobjeto->min[0] );
      min[1] = std::min( min[1], pobjeto->min[1] );
      max[0] = std::max( max[0], pobjeto->max[0] );
      max[1] = std::max( max[1], pobjeto->max[1] );
   }
   //using namespace std ;
   //cout << "min ==" << min << ", max == " << max << endl ;
  }
  projected = true ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r13
cmpq %r13, %r12
je 0x7637
movb $0x1, %r14b
movq (%r12), %r15
testq %r15, %r15
je 0x764a
movq (%r15), %rax
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq *0x8(%rax)
testb $0x1, %r14b
je 0x75eb
movq 0xc(%r15), %rax
movq %rax, 0xc(%rbx)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rbx)
jmp 0x762b
movss 0xc(%r15), %xmm0
minss 0xc(%rbx), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x10(%r15), %xmm0
minss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movss 0x14(%r15), %xmm0
maxss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
movss 0x18(%r15), %xmm0
maxss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%rbx)
addq $0x8, %r12
xorl %r14d, %r14d
cmpq %r13, %r12
jne 0x75b9
movb $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6102(%rip), %rdi      # 0xd753
leaq 0x5e58(%rip), %rsi      # 0xd4b0
leaq 0x6107(%rip), %rcx      # 0xd766
movl $0x182, %edx            # imm = 0x182
callq 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Sphere::project(Camera const&)
void Sphere::project( const Camera & cam )
{
  center2D = cam.project( center3D );
  radius2D  = radius3D ; // this works fine only assuming parallel projection

  projected = true ;
  min = center2D-vec2(radius2D,radius2D);
  max = center2D+vec2(radius2D,radius2D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x24(%rdi), %rsi
movq %rax, %rdi
callq 0x6b7e
movlps %xmm0, 0x30(%rbx)
movss 0x1c(%rbx), %xmm1
movss %xmm1, 0x20(%rbx)
movb $0x1, 0x8(%rbx)
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movaps %xmm1, %xmm3
addss %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm4
subss %xmm1, %xmm4
movss %xmm2, 0xc(%rbx)
movss %xmm4, 0x10(%rbx)
addss %xmm1, %xmm0
movss %xmm3, 0x14(%rbx)
movss %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Sphere::drawSVG(SVGContext&)
void Sphere::drawSVG( SVGContext & ctx )
{
  assert( projected );

  using namespace std ;
  std::ostream & os = *(ctx.os) ;

  write_radial_gradient_def( os, "grad1" );

  os << "<circle " << endl
     << "   style='fill:url(#grad1); stroke:black; stroke-width:0.003'" << endl
     << "   cx='" << center2D[0] <<  "' cy='" << center2D[1] << "' r='" << radius2D << "'" << endl
     << "/>" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0x8(%rdi)
je 0x791f
movq %rdi, %rbx
movq (%rsi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6072(%rip), %rsi      # 0xd7f1
leaq 0x6070(%rip), %rdx      # 0xd7f6
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xc1a6
movq %r14, %rdi
movq %r15, %rsi
callq 0x6204
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x77ab
callq 0x31a0
leaq 0x6045(%rip), %rsi      # 0xd7f7
movl $0x8, %edx
movq %r14, %rdi
callq 0x31e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r14
leaq 0x6010(%rip), %rsi      # 0xd800
movl $0x3d, %edx
movq %rax, %rdi
callq 0x31e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r14
leaq 0x6010(%rip), %rsi      # 0xd83e
movl $0x7, %edx
movq %rax, %rdi
callq 0x31e0
cvtss2sd 0x30(%rbx), %xmm0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x5e23(%rip), %rsi      # 0xd675
movl $0x6, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x34(%rbx), %xmm0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x5e03(%rip), %rsi      # 0xd67c
movl $0x5, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x20(%rbx), %xmm0
movq %r14, %rdi
callq 0x3250
movq %rax, %rbx
leaq 0x5f9c(%rip), %rsi      # 0xd83c
movl $0x1, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x5ab9(%rip), %rsi      # 0xd397
movl $0x2, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6273(%rip), %rdi      # 0xdb99
leaq 0x5b83(%rip), %rsi      # 0xd4b0
leaq 0x5e92(%rip), %rcx      # 0xd7c6
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x3120
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x794f
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Segment::Segment(VectorTempl3<float> const&, VectorTempl3<float> const&, VectorTempl3<float> const&, float)
Segment::Segment( const vec3 & p0, const vec3 & vd, const vec3 & color, real width )
{
  style.draw_lines   = true ;
  style.draw_filled  = false ;
  style.close_lines  = false ;
  style.lines_color  = color ;
  style.lines_width  = width ;

  points3D.push_back( p0 );
  points3D.push_back( p0+vd );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, -0x2c(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %r14d, %r14d
movb %r14b, 0x8(%rdi)
leaq 0x9468(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c64
leaq 0x68(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x956f(%rip), %rax      # 0x11890
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb %r14b, 0x3a(%rbx)
movq %rcx, %r14
movq (%r13), %rax
movq %rax, 0x20(%rbx)
movl 0x8(%r13), %eax
movl %eax, 0x28(%rbx)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x3c(%rbx)
movq %rcx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xc3cc
xorl %eax, %eax
movss (%r12,%rax,4), %xmm0
addss (%r15,%rax,4), %xmm0
movss %xmm0, -0x48(%rbp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x8359
movsd -0x48(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
movss %xmm0, -0x38(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x83af
movl -0x30(%rbp), %eax
movl %eax, 0x8(%rsi)
movq -0x38(%rbp), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x83bb
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xc244
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83cc
movq %rax, %r14
movq %rbx, %rdi
callq 0xbbb4
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Segment::Segment(VectorTempl3<float> const&, VectorTempl3<float> const&)
Segment::Segment( const vec3 & p0, const vec3 & p1 )
{
  style.draw_lines   = true ;
  style.draw_filled  = false ;
  style.close_lines  = false ;
  style.lines_color  = vec3(0.0,0.0,0.0) ;
  style.lines_width  = 0.007 ;

  points3D.push_back( p0 );
  points3D.push_back( p1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %r13d, %r13d
movb %r13b, 0x8(%rdi)
leaq 0x935b(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c64
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x9462(%rip), %rax      # 0x11890
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb %r13b, 0x3a(%rbx)
movq $0x0, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
movl $0x3be56042, 0x3c(%rbx) # imm = 0x3BE56042
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xc3cc
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x847c
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x8487
movq %r15, %rdi
movq %r14, %rdx
callq 0xc3cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbbb4
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Segment::Segment(Point const&, Point const&, float)
Segment::Segment( const Point & p0, const Point & p1, real width )
{
  style.draw_lines   = true ;
  style.draw_filled  = false ;
  style.close_lines  = false ;
  style.lines_color  = p0.color ;
  style.lines_width  = width ;

  points3D.push_back( p0.pos3D );
  points3D.push_back( p1.pos3D );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, -0x2c(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %r13d, %r13d
movb %r13b, 0x8(%rdi)
leaq 0x928c(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c64
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x9393(%rip), %rax      # 0x11890
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb %r13b, 0x3a(%rbx)
movq 0x28(%r12), %rax
movq %rax, 0x20(%rbx)
movl 0x30(%r12), %eax
movl %eax, 0x28(%rbx)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x3c(%rbx)
addq $0x1c, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xc3cc
movq 0x70(%rbx), %rsi
addq $0x1c, %r14
cmpq 0x78(%rbx), %rsi
je 0x8558
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x8563
movq %r15, %rdi
movq %r14, %rdx
callq 0xc3cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbbb4
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: PolQuad::PolQuad(VectorTempl3<float> const&, VectorTempl3<float> const&, VectorTempl3<float> const&, VectorTempl3<float> const&)
PolQuad::PolQuad( const vec3 & p00, const vec3 & p01, const vec3 & p10, const vec3 & p11 )
{
  points3D.push_back( p00 );
  points3D.push_back( p01 );
  points3D.push_back( p11 );
  points3D.push_back( p10 );

  style.draw_lines    = false ;
  style.close_lines = false ;
  style.draw_filled     = true ;
  style.fill_opacity = 0.2 ;
  style.fill_color    = vec3( 1.0, 0.0, 0.0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x8(%rdi)
leaq 0x8289(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c64
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x8450(%rip), %rax      # 0x11950
movq %rax, (%rbx)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc3cc
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x9536
movl 0x8(%r13), %eax
movl %eax, 0x8(%rsi)
movq (%r13), %rax
movq %rax, (%rsi)
movq 0x70(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x9545
movq %r15, %rdi
movq %r13, %rdx
callq 0xc3cc
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x9568
movl 0x8(%r12), %eax
movl %eax, 0x8(%rsi)
movq (%r12), %rax
movq %rax, (%rsi)
movq 0x70(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x9577
movq %r15, %rdi
movq %r12, %rdx
callq 0xc3cc
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x9594
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rsi)
movq (%rcx), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x95a0
movq %r15, %rdi
movq -0x30(%rbp), %rdx
callq 0xc3cc
movw $0x0, 0x38(%rbx)
movb $0x1, 0x3a(%rbx)
movl $0x3e4ccccd, 0x40(%rbx) # imm = 0x3E4CCCCD
movq $0x3f800000, 0x2c(%rbx) # imm = 0x3F800000
movl $0x0, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbbb4
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: SegmentsVert::SegmentsVert(unsigned int, Polygon const&, Polygon const&)
SegmentsVert::SegmentsVert( unsigned dn, const Polygon & p1, const Polygon & p2 )
{
  const int n = p1.points3D.size() ;
  assert( n == p2.points3D.size() );

  const vec3 color = vec3( 0.0, 0.7, 1.0 );
  constexpr real width =  0.0025 ;

  for( unsigned i = 0 ; i < n ; i += dn )
  {
      Segment * psegmento = new Segment( p1.points3D[i], p2.points3D[i]-p1.points3D[i], color, width );
      add( psegmento );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, -0x2c(%rbp)
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
leaq 0x836a(%rip), %rax      # 0x11980
movq %rdi, -0x38(%rbp)
movq %rax, (%rdi)
movq 0x70(%rdx), %r12
subq 0x68(%rdx), %r12
sarq $0x2, %r12
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movq 0x70(%rcx), %rcx
subq 0x68(%r14), %rcx
movslq %r12d, %rdx
sarq $0x2, %rcx
imulq %rax, %rcx
cmpq %rcx, %rdx
jne 0x9718
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
movq %rax, -0x5c(%rbp)
movl $0x3f800000, -0x54(%rbp) # imm = 0x3F800000
testl %r12d, %r12d
je 0x9709
xorl %ebx, %ebx
movl $0x98, %edi
callq 0x31d0
movq %rax, %r13
movl %ebx, %edx
leaq (,%rdx,4), %rax
leaq (%rax,%rax,2), %rax
movq 0x68(%r15), %rcx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,4), %rsi
addq %rax, %rcx
addq 0x68(%r14), %rax
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm0
subss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x50(%rbp,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x96a3
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
movss %xmm0, -0x44(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x40(%rbp)
movss %xmm1, -0x3c(%rbp)
movq %r13, %rdi
leaq -0x44(%rbp), %rdx
leaq -0x5c(%rbp), %rcx
movss 0x3bbc(%rip), %xmm0     # 0xd2a8
callq 0x82c8
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x7554
addl -0x2c(%rbp), %ebx
cmpl %r12d, %ebx
jb 0x9673
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x413a(%rip), %rdi      # 0xd859
leaq 0x3d8a(%rip), %rsi      # 0xd4b0
leaq 0x4144(%rip), %rcx      # 0xd871
movl $0x2ef, %edx            # imm = 0x2EF
callq 0x3120
movq %rax, %r14
movq %r13, %rdi
callq 0x31a0
jmp 0x9747
movq %rax, %r14
leaq 0x8042(%rip), %rax      # 0x11790
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x9763
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: YAxisProjectorsSegments::YAxisProjectorsSegments(unsigned int, Polygon const&)
YAxisProjectorsSegments::YAxisProjectorsSegments( unsigned dn, const Polygon & p1 )
{
  const int n = p1.points3D.size() ;
  assert( 0 < n );
  const vec3 color = vec3( 0.0, 0.7, 1.0 );
  constexpr real width =  0.0025 ;

  for( unsigned i = 0 ; i < n ; i += dn )
  {
      const vec3 pesf = p1.points3D[i] ,
                 pyAxis = vec3(0.0,pesf[1],0.0);

      add( new Segment( pyAxis, pesf-pyAxis, color, width ));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
leaq 0x7fd5(%rip), %rax      # 0x119e0
movq %rdi, -0x40(%rbp)
movq %rax, (%rdi)
movq 0x70(%rdx), %rax
movq %rdx, -0x68(%rbp)
subq 0x68(%rdx), %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %r12d # imm = 0xAAAAAAAB
testl %r12d, %r12d
jle 0x9b10
movl %esi, %r15d
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
leaq -0x84(%rbp), %rcx
movq %rax, (%rcx)
movl $0x3f800000, 0x8(%rcx)  # imm = 0x3F800000
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %r14d, %eax
movq -0x68(%rbp), %rcx
movq 0x68(%rcx), %rcx
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,4), %edx
movl %edx, -0x48(%rbp)
movq (%rcx,%rax,4), %rax
movq %rax, -0x50(%rbp)
movl %ebx, -0x34(%rbp)
movss -0x4c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movl %ebx, -0x2c(%rbp)
movl $0x98, %edi
callq 0x31d0
movq %rax, %r13
xorl %eax, %eax
movss -0x50(%rbp,%rax,4), %xmm0
subss -0x34(%rbp,%rax,4), %xmm0
movss %xmm0, -0x78(%rbp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x9a92
movsd -0x78(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
movss %xmm0, -0x5c(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x58(%rbp)
movss %xmm1, -0x54(%rbp)
movq %r13, %rdi
leaq -0x34(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
leaq -0x84(%rbp), %rcx
movss 0x37c4(%rip), %xmm0     # 0xd2a8
callq 0x82c8
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x7554
addl %r15d, %r14d
cmpl %r12d, %r14d
jb 0x9a55
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3da5(%rip), %rdi      # 0xd8bc
leaq 0x3992(%rip), %rsi      # 0xd4b0
leaq 0x3d9d(%rip), %rcx      # 0xd8c2
movl $0x318, %edx            # imm = 0x318
callq 0x3120
jmp 0x9b3e
movq %rax, %r14
movq %r13, %rdi
callq 0x31a0
jmp 0x9b41
movq %rax, %r14
leaq 0x7c48(%rip), %rax      # 0x11790
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x9b5d
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: YCylinderPoint::YCylinderPoint(Point&)
YCylinderPoint::YCylinderPoint( Point & ppoint )

: Point(vec3(0,0,0),vec3(1.0,0.0,0.0))
{
  assert( ! ppoint.projected );

  vec3       pesf = ppoint.pos3D.normalized();
  const real f    = real(1.0)/real(sqrt( double( pesf[0]*pesf[0]+pesf[2]*pesf[2] )));

  pos3D = vec3(  f*pesf[0], pesf[1], f*pesf[2]) ;
  color = vec3(1.0,0.0,0.0) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x8(%rdi)
movq $0x0, 0x1c(%rdi)
xorl %eax, %eax
movl %eax, 0x24(%rdi)
movss 0x1ebc(%rip), %xmm0     # 0xd008
movlpd %xmm0, 0x28(%rdi)
movl %eax, 0x30(%rdi)
movl $0x3cf5c28f, 0x3c(%rdi) # imm = 0x3CF5C28F
leaq 0x69ce(%rip), %rax      # 0x11b30
movq %rax, (%rdi)
cmpb $0x1, 0x8(%rsi)
je 0xb22f
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtss2sd 0x1c(%r14,%rax,4), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0xb17b
cvtsd2ss %xmm0, %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xb1a9
sqrtss %xmm0, %xmm0
jmp 0xb1ae
callq 0x32d0
xorl %eax, %eax
movss 0x1c(%r14,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x20(%rbp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0xb1b0
movsd -0x20(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm1, %xmm3
mulss %xmm1, %xmm3
movaps %xmm0, %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
xorps %xmm3, %xmm3
sqrtss %xmm4, %xmm3
movss 0x1e0c(%rip), %xmm4     # 0xd008
divss %xmm3, %xmm4
mulss %xmm4, %xmm0
mulss %xmm1, %xmm4
movss %xmm0, 0x1c(%rbx)
movss %xmm2, 0x20(%rbx)
movss %xmm4, 0x24(%rbx)
movq $0x3f800000, 0x28(%rbx) # imm = 0x3F800000
movl $0x0, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x295a(%rip), %rdi      # 0xdb90
leaq 0x2273(%rip), %rsi      # 0xd4b0
leaq 0x295f(%rip), %rcx      # 0xdba3
movl $0x446, %edx            # imm = 0x446
callq 0x3120
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/main2.cpp
// Function: horizontal_convolution(double*&, int, double*, int)
void horizontal_convolution(double* &image, int image_length,  double* filter, int filter_length){
	double copy[image_length];
	double pass_value;
	for (int i=0; i<image_length;i++){
		copy[i] = image[i];
	}
	int offset = filter_length/2;

	for (int i = offset; i<image_length+offset; i++){
		pass_value = 0;		
		for (int j = 0; j<filter_length; j++){
			if (i-j < 0  || i-j >= image_length){
				continue;
			}
			pass_value +=filter[j]*copy[i-j];
		}
		image[i-offset]=pass_value;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %edx
movq %rsp, %r13
leaq 0xf(,%rdx,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testl %esi, %esi
jle 0x23d6
movl %ecx, %ebx
movl %esi, %r15d
movq (%rdi), %r12
shlq $0x3, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x20d0
movl %ebx, %eax
shrl $0x1f, %eax
addl %ebx, %eax
sarl %eax
leal (%rax,%r15), %edx
movslq %eax, %rcx
movslq %edx, %rdx
movl %ebx, %esi
leaq (,%rcx,8), %rdi
addq %r13, %rdi
negq %rsi
movq %rcx, %r8
xorpd %xmm0, %xmm0
testl %ebx, %ebx
jle 0x23bb
movq %r14, %r9
xorl %r10d, %r10d
leal (%rax,%r10), %r11d
cmpl %r15d, %r11d
jae 0x23af
movsd (%r9), %xmm1
mulsd (%rdi,%r10,8), %xmm1
addsd %xmm1, %xmm0
decq %r10
addq $0x8, %r9
cmpq %r10, %rsi
jne 0x2397
movq %r8, %r9
subq %rcx, %r9
movsd %xmm0, (%r12,%r9,8)
incq %r8
incq %rax
addq $0x8, %rdi
cmpq %rdx, %r8
jl 0x2389
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/main2.cpp
// Function: vertical_convolution(double**&, int, int, double*, int)
void vertical_convolution(double** &image, int height, int width,  double* filter, int filter_length){
	double copy[height][width];
	double pass_value;
	for (int i=0; i<height ;i++){
		for (int j = 0; j<width ; j++){
			copy[i][j] = image[i][j];
		}
	}
	int offset = filter_length/2;

	for (int i=0; i<width; i++){
		for(int j = offset ; j<height+offset; j++){
			pass_value=0;
			for (int k =0; k<filter_length; k++){
				if(j-k < 0  || j-k >= height){
					continue;
				}
				pass_value+=filter[k]*copy[j-k][i];
			}
			image[j-offset][i]=pass_value;
		}
	}


	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r14
movl %esi, %r15d
movq %rdi, -0x50(%rbp)
movl %esi, %esi
movl %edx, -0x38(%rbp)
movl %edx, %eax
movq %rax, -0x40(%rbp)
movq %rsi, -0x60(%rbp)
imulq %rsi, %rax
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
movq %rsp, %rcx
subq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
testl %r15d, %r15d
jle 0x2477
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
leaq (,%rax,8), %r12
xorl %ebx, %ebx
movq -0x48(%rbp), %r13
cmpl $0x0, -0x38(%rbp)
jle 0x246b
movq -0x58(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x20d0
incq %rbx
addq %r12, %r13
cmpq %rbx, -0x60(%rbp)
jne 0x2452
cmpl $0x0, -0x38(%rbp)
jle 0x2535
movl -0x2c(%rbp), %esi
movl %esi, %edx
shrl $0x1f, %edx
addl %esi, %edx
sarl %edx
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq %edx, %rcx
addl %r15d, %edx
movslq %edx, %rdx
movl %esi, %esi
movq %rcx, %rdi
movq -0x40(%rbp), %r8
imulq %r8, %rdi
movq -0x48(%rbp), %r9
leaq (%r9,%rdi,8), %r11
leaq (,%r8,8), %r8
movq %r8, %r9
negq %r9
xorl %r10d, %r10d
movq %r11, -0x38(%rbp)
movq %rcx, %r12
testl %r15d, %r15d
jle 0x2524
cmpl $0x0, -0x2c(%rbp)
jle 0x2505
xorpd %xmm0, %xmm0
movq %r11, %r13
movl %r12d, %edi
xorl %ebx, %ebx
cmpl %r15d, %edi
jae 0x24f6
movsd (%r14,%rbx,8), %xmm1
mulsd (%r13), %xmm1
addsd %xmm1, %xmm0
incq %rbx
decl %edi
addq %r9, %r13
cmpq %rbx, %rsi
jne 0x24e1
jmp 0x2509
xorpd %xmm0, %xmm0
movq %r12, %rdi
subq %rcx, %rdi
movq (%rax,%rdi,8), %rdi
movsd %xmm0, (%rdi,%r10,8)
incq %r12
addq %r8, %r11
cmpq %rdx, %r12
jl 0x24cf
incq %r10
movq -0x38(%rbp), %r11
addq $0x8, %r11
cmpq -0x40(%rbp), %r10
jne 0x24c3
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/main2.cpp
// Function: reconstruct(unsigned char**, int, int, unsigned char*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void reconstruct(unsigned char** image_data, int height, int width, 
	       	unsigned char* image_header_data, int bitmap_offset,
		std::string filename){

	filename+=".bmp";
	std::ofstream output_file;

	output_file.open(filename.c_str(), std::ofstream::out | std::ofstream::binary);
	output_file.write(reinterpret_cast<const char*>(image_header_data), bitmap_offset);
	

	for (int i = 0; i< height; i++){
		output_file.write(reinterpret_cast<const char*>(image_data[i]),width);
	}
	output_file.close();
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %r9, %r13
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x16b0(%rip), %rsi      # 0x4108
movq %r9, %rdi
callq 0x21e0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
movq (%r13), %rsi
movq %r14, %rdi
movl $0x14, %edx
callq 0x2050
movslq %r12d, %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2160
testl %ebp, %ebp
jle 0x2ab9
movslq 0x4(%rsp), %r14
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2160
incq %r13
cmpq %r13, %r12
jne 0x2aa2
leaq 0x8(%rsp), %rdi
callq 0x2180
movq 0x3506(%rip), %rax      # 0x5fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x20e0
leaq 0x100(%rsp), %rdi
callq 0x2080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b09
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_GNUPlotPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Gnuplot::set_GNUPlotPath(const std::string &path)
{
    const std::string tmp = path + "/" + Gnuplot::m_sGNUPlotFileName;
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)
    if ( Gnuplot::file_exists(tmp, 0) ) // check existence
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    if ( Gnuplot::file_exists(tmp, 1) ) // check existence and execution permission
#endif
    {
        Gnuplot::m_sGNUPlotPath = path;
        return true;
    }
    Gnuplot::m_sGNUPlotPath.clear();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc66a
leaq 0x9a8e(%rip), %rsi      # 0xd12e
movq %r14, %rdi
callq 0x3420
movq 0xdba1(%rip), %rsi      # 0x11250
movq 0xdba2(%rip), %rdx      # 0x11258
leaq 0x8(%rsp), %rdi
callq 0x30a0
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x36e7
movq %rdi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x36f1
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq %r15, %rax
je 0x3728
movq 0x18(%rsp), %rsi
incq %rsi
movq %rax, %rdi
callq 0x3210
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x3380
movl %eax, %ebp
testl %eax, %eax
je 0x374f
movq $0x0, 0xdb35(%rip) # 0x11278
movq 0xdb26(%rip), %rax      # 0x11270
movb $0x0, (%rax)
jmp 0x375e
leaq 0xdb1a(%rip), %rdi      # 0x11270
movq %rbx, %rsi
callq 0x3150
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3775
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3210
testl %ebp, %ebp
sete %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x37b5
movq 0x38(%rsp), %rsi
jmp 0x37ad
jmp 0x379b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::file_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool Gnuplot::file_exists(const std::string &filename, int mode)
{
    if ( mode < 0 || mode > 7)
    {
        throw std::runtime_error("In function \"Gnuplot::file_exists\": mode\
                has to be an integer between 0 and 7");
    }

    // int _access(const char *path, int mode);
    //  returns 0 if the file has the given mode,
    //  it returns -1 if the named file does not exist or is not accessible in
    //  the given mode
    // mode = 0 (F_OK) (default): checks file for existence only
    // mode = 1 (X_OK): execution permission
    // mode = 2 (W_OK): write permission
    // mode = 4 (R_OK): read permission
    // mode = 6       : read and write permission
    // mode = 7       : read, write and execution permission
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)
    return (_access(filename.c_str(), mode) == 0);
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    return (access(filename.c_str(), mode) == 0);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x8, %esi
jae 0x37dc
movq (%rdi), %rdi
callq 0x3380
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x9bd9(%rip), %rsi      # 0xd3c9
movq %rax, %rdi
callq 0x30e0
movq 0xd7f1(%rip), %rsi      # 0x10ff0
movq 0xd7a2(%rip), %rdx      # 0x10fa8
movq %rbx, %rdi
callq 0x33c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_terminal_std(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Gnuplot::set_terminal_std(const std::string &type)
{
#if defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    if (type.find("x11") != std::string::npos && getenv("DISPLAY") == nullptr)
    {
        throw GnuplotException("Can't find DISPLAY variable");
    }
#endif
    Gnuplot::terminal_std = type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x98fa(%rip), %rsi      # 0xd130
movl $0x3, %ecx
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x3859
leaq 0x98e5(%rip), %rdi      # 0xd134
callq 0x3280
testq %rax, %rax
je 0x3872
leaq 0xda30(%rip), %rdi      # 0x11290
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3150
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x98ad(%rip), %rsi      # 0xd13c
leaq 0x98c1(%rip), %rdx      # 0xd157
leaq 0x8(%rsp), %rdi
callq 0xc700
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32a0
leaq 0xd4a9(%rip), %rax      # 0x10d60
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd475(%rip), %rsi      # 0x10d38
movq 0xd6ee(%rip), %rdx      # 0x10fb8
movq %rbx, %rdi
callq 0x33c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x38ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x38f6
jmp 0x38fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::~Gnuplot()
Gnuplot::~Gnuplot(void)
{
    //  remove_tmpfiles();

    // A stream opened by popen() should be closed by pclose()
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)
    if (_pclose(gnucmd) == -1)
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    if (pclose(gnucmd) == -1)
#endif
    { std::cerr << "Gnuplot::~Gnuplot: Problem closing communication to gnuplot" << std::endl; }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x3960
movq 0xd6c7(%rip), %r14      # 0x10fe8
leaq 0x9830(%rip), %rsi      # 0xd158
movl $0x3b, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq 0xd695(%rip), %rdi      # 0x10fe8
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x50(%rbx), %rdi
callq 0xb446
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x3981
movq (%rax), %rsi
incq %rsi
callq 0x3210
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x39a0
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xb43b