LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Polygon::drawSVG(SVGContext&)
void Polygon::drawSVG( SVGContext & ctx )
{
   using namespace std ;
   assert( ctx.os != nullptr );


   if ( points3D.size() == 0 )
   {
      cout << "WARNING: attempting to draw an empty Polygon object" << endl ;
      return ;
   }

  assert( projected );
  assert( points3D.size() == points2D.size() );

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

  os << "<path " << endl
     << "   stroke-linecap='round' stroke-linejoin='round'" << endl ;

  style.writeSVG( ctx );

  os << "   d=' M " ;
  write_coord2( os, points2D[0] );
  for( unsigned i = 1 ; i < points2D.size() ; i++ )
  {
      os << " L " ;
      write_coord2( os, points2D[i] );
      os << " " ;
      //cout << points_proy[i] << endl ;
  }
  if ( style.close_lines )
    os << " Z" ;

  os << "'/>" << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x65b3
movq %rsi, %r15
movq %rdi, %r14
movq 0x70(%rdi), %rcx
movq 0x68(%rdi), %rsi
movq %rcx, %rax
subq %rsi, %rax
pushq $0xc
popq %rdi
cqto
idivq %rdi
cmpq %rsi, %rcx
je 0x658a
cmpb $0x0, 0x8(%r14)
je 0x65d2
movq 0x88(%r14), %rcx
subq 0x80(%r14), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jne 0x65f1
leaq 0x52bf(%rip), %rsi      # 0xb779
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x52af(%rip), %rsi      # 0xb780
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x5fce
leaq 0x52be(%rip), %rsi      # 0xb7b2
movq %rbx, %rdi
callq 0x31a0
movq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x5bcc
pushq $0x1
popq %rax
leaq 0x52a7(%rip), %r15      # 0xb7bc
leaq 0x4f9a(%rip), %r12      # 0xb4b6
movl %eax, %r13d
movq 0x88(%r14), %rax
subq 0x80(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jbe 0x6568
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31a0
movq %r13, %rsi
shlq $0x3, %rsi
addq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x5bcc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31a0
leal 0x1(%r13), %eax
jmp 0x651c
cmpb $0x0, 0x39(%r14)
je 0x657e
leaq 0x524a(%rip), %rsi      # 0xb7c0
movq %rbx, %rdi
callq 0x31a0
leaq 0x523e(%rip), %rsi      # 0xb7c3
movq %rbx, %rdi
jmp 0x6598
movq 0x9a37(%rip), %rdi      # 0xffc8
leaq 0x518a(%rip), %rsi      # 0xb722
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30d0
leaq 0x5110(%rip), %rdi      # 0xb6ca
leaq 0x4f63(%rip), %rsi      # 0xb524
leaq 0x512e(%rip), %rcx      # 0xb6f6
movl $0x141, %edx            # imm = 0x141
callq 0x3110
leaq 0x5634(%rip), %rdi      # 0xbc0d
leaq 0x4f44(%rip), %rsi      # 0xb524
leaq 0x510f(%rip), %rcx      # 0xb6f6
movl $0x14a, %edx            # imm = 0x14A
callq 0x3110
leaq 0x515e(%rip), %rdi      # 0xb756
leaq 0x4f25(%rip), %rsi      # 0xb524
leaq 0x50f0(%rip), %rcx      # 0xb6f6
movl $0x14b, %edx            # imm = 0x14B
callq 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, %r14b
cmpq %r13, %r12
je 0x6714
movq (%r12), %r15
testq %r15, %r15
je 0x6727
movq (%r15), %rax
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq *0x8(%rax)
testb $0x1, %r14b
je 0x66cb
movq 0xc(%r15), %rax
movq %rax, 0xc(%rbx)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rbx)
jmp 0x670b
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
jmp 0x6694
movb $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5099(%rip), %rdi      # 0xb7c7
leaq 0x4def(%rip), %rsi      # 0xb524
leaq 0x509e(%rip), %rcx      # 0xb7da
movl $0x182, %edx            # imm = 0x182
callq 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x24(%rdi), %rsi
movq %rax, %rdi
callq 0x5e9e
leaq 0x30(%rbx), %r14
movlps %xmm0, 0x30(%rbx)
movss 0x1c(%rbx), %xmm0
movss %xmm0, 0x20(%rbx)
movb $0x1, 0x8(%rbx)
leaq -0x20(%rbp), %r15
movss %xmm0, (%r15)
movss %xmm0, 0x4(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x97ce
movss %xmm0, 0xc(%rbx)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x10(%rbx)
movss 0x20(%rbx), %xmm0
movss %xmm0, (%r15)
movss %xmm0, 0x4(%r15)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x982e
movss %xmm0, 0x14(%rbx)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
cmpb $0x0, 0x8(%rdi)
je 0x6959
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x4feb(%rip), %rsi      # 0xb865
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x30a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x59b8
leaq -0x40(%rbp), %rdi
callq 0x30c0
leaq 0x4fc6(%rip), %rsi      # 0xb86b
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x4fb8(%rip), %rsi      # 0xb874
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x4fdf(%rip), %rsi      # 0xb8b2
movq %rax, %rdi
callq 0x31a0
movss 0x30(%rbx), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x4dfa(%rip), %rsi      # 0xb6e9
movq %rax, %rdi
callq 0x31a0
movss 0x34(%rbx), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x4de5(%rip), %rsi      # 0xb6f0
movq %rax, %rdi
callq 0x31a0
movss 0x20(%rbx), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x4f89(%rip), %rsi      # 0xb8b0
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x4acd(%rip), %rsi      # 0xb40b
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52ad(%rip), %rdi      # 0xbc0d
leaq 0x4bbd(%rip), %rsi      # 0xb524
leaq 0x4ecc(%rip), %rcx      # 0xb83a
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x3110
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x24(%rbp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x6332
leaq 0x893a(%rip), %rax      # 0xf888
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb $0x0, 0x3a(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x28(%rbx)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x3c(%rbx)
leaq 0x68(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x994e
movq %r12, %rdi
movq %r15, %rsi
callq 0x988e
leaq -0x30(%rbp), %rsi
movss %xmm0, (%rsi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x4(%rsi)
movss %xmm1, 0x8(%rsi)
movq %r14, %rdi
callq 0x9f14
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6fba
movq %rax, %r14
movq %rbx, %rdi
callq 0x973c
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x6332
leaq 0x889a(%rip), %rax      # 0xf888
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb $0x0, 0x3a(%rbx)
andq $0x0, 0x20(%rbx)
andl $0x0, 0x28(%rbx)
movl $0x3be56042, 0x3c(%rbx) # imm = 0x3BE56042
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x994e
movq %r15, %rdi
movq %r14, %rsi
callq 0x994e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x973c
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x24(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x6332
leaq 0x881d(%rip), %rax      # 0xf888
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb $0x0, 0x3a(%rbx)
movq 0x28(%r12), %rax
movq %rax, 0x20(%rbx)
movl 0x30(%r12), %eax
movl %eax, 0x28(%rbx)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x3c(%rbx)
leaq 0x68(%rbx), %r15
addq $0x1c, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x994e
addq $0x1c, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x994e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x973c
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Ellipse::Ellipse(unsigned int, VectorTempl3<float> const&, VectorTempl3<float> const&, VectorTempl3<float>)
Ellipse::Ellipse( unsigned n, const vec3 & center, const vec3 & eje1, const vec3 eje2 )
{
  for( unsigned i= 0 ; i < n ; i++ )
  {
    const real ang = real(i)*real(2.0)*real(M_PI)/real(n) ,
               c   = cos(double(ang)),
               s   = sin(double(ang));

    points3D.push_back( center + c*eje1 + s*eje2 ) ;
  }
  style.draw_filled = false ;
  style.draw_lines  = true ;
  style.close_lines = true ;
  style.lines_width = 0.006 ;
  style.lines_color = vec3( 0.0, 1.0, 0.0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
leaq -0x88(%rbp), %rax
movlps %xmm0, (%rax)
movss %xmm1, 0x8(%rax)
callq 0x6332
leaq 0x87aa(%rip), %rax      # 0xf8b8
movl %r12d, %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x34(%rbp)
movq %rax, (%rbx)
movq %rbx, -0x40(%rbp)
addq $0x68, %rbx
xorl %r13d, %r13d
cmpl %r13d, %r12d
je 0x71ed
movl %r13d, %eax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
mulss 0x41c2(%rip), %xmm0     # 0xb308
divss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x3270
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3050
movsd %xmm0, -0x30(%rbp)
movss -0x38(%rbp), %xmm0
movq %r14, %rdi
callq 0x52f1
movlps %xmm0, -0x68(%rbp)
movss %xmm1, -0x60(%rbp)
movq %r15, %rdi
leaq -0x68(%rbp), %rsi
callq 0x988e
cvtsd2ss -0x30(%rbp), %xmm2
movlps %xmm0, -0x78(%rbp)
movss %xmm1, -0x70(%rbp)
movaps %xmm2, %xmm0
leaq -0x88(%rbp), %rdi
callq 0x52f1
movlps %xmm0, -0x58(%rbp)
movss %xmm1, -0x50(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x988e
movss %xmm0, -0x4c(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x48(%rbp)
movss %xmm1, -0x44(%rbp)
movq %rbx, %rdi
leaq -0x4c(%rbp), %rsi
callq 0x9f14
incl %r13d
jmp 0x7129
movq -0x40(%rbp), %rcx
movb $0x0, 0x3a(%rcx)
movw $0x101, 0x38(%rcx)      # imm = 0x101
movl $0x3bc49ba6, 0x3c(%rcx) # imm = 0x3BC49BA6
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x20(%rcx)
andl $0x0, 0x28(%rcx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7225
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x973c
movq %rbx, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6332
leaq 0x7e5a(%rip), %rax      # 0xf948
movq %rax, (%rbx)
leaq 0x68(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x994e
movq %r12, %rdi
movq %r13, %rsi
callq 0x994e
movq %r12, %rdi
movq %r15, %rsi
callq 0x994e
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x994e
andw $0x0, 0x38(%rbx)
movb $0x1, 0x3a(%rbx)
movl $0x3e4ccccd, 0x40(%rbx) # imm = 0x3E4CCCCD
movq $0x3f800000, 0x2c(%rbx) # imm = 0x3F800000
andl $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 0x973c
movq %r14, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, -0x2c(%rbp)
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
leaq 0x7ded(%rip), %rax      # 0xf978
movq %rdi, -0x38(%rbp)
movq %rax, (%rdi)
movq 0x70(%rdx), %rax
movq %rdx, -0x50(%rbp)
subq 0x68(%rdx), %rax
pushq $0xc
popq %rdi
cqto
idivq %rdi
movq %rax, %r13
movslq %r13d, %rsi
movq 0x70(%rcx), %rax
subq 0x68(%rcx), %rax
cqto
idivq %rdi
cmpq %rax, %rsi
jne 0x7c5f
movq %rcx, %r15
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
leaq -0x5c(%rbp), %rcx
movq %rax, (%rcx)
movl $0x3f800000, 0x8(%rcx)  # imm = 0x3F800000
xorl %r14d, %r14d
cmpl %r13d, %r14d
jae 0x7c50
movl $0x98, %edi
callq 0x31b0
movq %rax, %rbx
movl %r14d, %eax
imulq $0xc, %rax, %rdi
movq -0x50(%rbp), %rax
movq 0x68(%rax), %r12
addq %rdi, %r12
addq 0x68(%r15), %rdi
movq %r12, %rsi
callq 0x530c
movss %xmm0, -0x44(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x40(%rbp)
movss %xmm1, -0x3c(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x44(%rbp), %rdx
leaq -0x5c(%rbp), %rcx
movss 0x36df(%rip), %xmm0     # 0xb318
callq 0x6f22
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x664c
addl -0x2c(%rbp), %r14d
jmp 0x7be0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c67(%rip), %rdi      # 0xb8cd
leaq 0x38b7(%rip), %rsi      # 0xb524
leaq 0x3c71(%rip), %rcx      # 0xb8e5
movl $0x2ef, %edx            # imm = 0x2EF
callq 0x3110
movq %rax, %r14
jmp 0x7c8e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq -0x38(%rbp), %rdi
callq 0x971e
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, %r14
movl %esi, -0x2c(%rbp)
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
leaq 0x7ab2(%rip), %rax      # 0xf9d8
movq %rdi, -0x38(%rbp)
movq %rax, (%rdi)
movq 0x70(%rdx), %rax
subq 0x68(%rdx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
testl %r12d, %r12d
jle 0x8008
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
leaq -0x6c(%rbp), %rcx
movq %rax, (%rcx)
movl $0x3f800000, 0x8(%rcx)  # imm = 0x3F800000
xorl %r15d, %r15d
leaq -0x60(%rbp), %r13
cmpl %r12d, %r15d
jae 0x7ff9
movl %r15d, %eax
movq 0x68(%r14), %rcx
imulq $0xc, %rax, %rax
movl 0x8(%rcx,%rax), %edx
movl %edx, -0x40(%rbp)
movq (%rcx,%rax), %rax
movq %rax, -0x48(%rbp)
andl $0x0, -0x60(%rbp)
movss -0x44(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
andl $0x0, -0x58(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x530c
movss %xmm0, -0x54(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x50(%rbp)
movss %xmm1, -0x4c(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x54(%rbp), %rdx
leaq -0x6c(%rbp), %rcx
movss 0x3339(%rip), %xmm0     # 0xb318
callq 0x6f22
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x664c
addl -0x2c(%rbp), %r15d
jmp 0x7f68
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3921(%rip), %rdi      # 0xb930
leaq 0x350e(%rip), %rsi      # 0xb524
leaq 0x3919(%rip), %rcx      # 0xb936
movl $0x318, %edx            # imm = 0x318
callq 0x3110
jmp 0x8029
movq %rax, %r14
jmp 0x8039
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq -0x38(%rbp), %rdi
callq 0x971e
movq %r14, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: JoiningQuads::JoiningQuads(Polygon const&, Polygon const&)
JoiningQuads::JoiningQuads( const Polygon & p1, const Polygon & p2 )
{
  const int n = p1.points3D.size() ;
  assert( n == p2.points3D.size() );

  for( unsigned i = 0 ; i < n-1 ; i++ )
  {
      // crear poligono y popularlo y añadirlo
      const vec3
        p00 = p1.points3D[i], p01 = p1.points3D[i+1],
        p10 = p2.points3D[i], p11 = p2.points3D[i+1] ;
      add( new PolQuad( p00, p01, p10, p11 ) );
  }
  // añadir cierre
  const vec3
    p00 = p1.points3D[n-1], p01 = p1.points3D[0],
    p10 = p2.points3D[n-1], p11 = p2.points3D[0] ;
  add( new PolQuad( p00, p01, p10, p11 ) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
leaq 0x7472(%rip), %rax      # 0xfa68
movq %rdi, -0x30(%rbp)
movq %rax, (%rdi)
movq 0x70(%rsi), %rax
subq 0x68(%rsi), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %rdi
movslq %edi, %rsi
movq 0x70(%r14), %rax
subq 0x68(%r14), %rax
cqto
idivq %rcx
cmpq %rax, %rsi
jne 0x874b
decl %edi
movq %rdi, -0x78(%rbp)
imulq $0xc, %rdi, %rbx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x86c3
movq 0x68(%r15), %rax
movl 0x8(%rax,%r13), %ecx
movl %ecx, -0x68(%rbp)
movq (%rax,%r13), %rcx
movq %rcx, -0x70(%rbp)
movl 0x14(%rax,%r13), %ecx
movl %ecx, -0x58(%rbp)
movq 0xc(%rax,%r13), %rax
movq %rax, -0x60(%rbp)
movq 0x68(%r14), %rax
movl 0x8(%rax,%r13), %ecx
movl %ecx, -0x48(%rbp)
movq (%rax,%r13), %rcx
movq %rcx, -0x50(%rbp)
movl 0x14(%rax,%r13), %ecx
movl %ecx, -0x38(%rbp)
movq 0xc(%rax,%r13), %rax
movq %rax, -0x40(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
leaq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x7ac4
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x664c
addq $0xc, %r13
jmp 0x8636
movslq -0x78(%rbp), %rax
movq 0x68(%r15), %rcx
imulq $0xc, %rax, %rax
movl 0x8(%rcx,%rax), %edx
movl %edx, -0x68(%rbp)
movq (%rcx,%rax), %rdx
movq %rdx, -0x70(%rbp)
movl 0x8(%rcx), %edx
movl %edx, -0x58(%rbp)
movq (%rcx), %rcx
movq %rcx, -0x60(%rbp)
movq 0x68(%r14), %rcx
movl 0x8(%rcx,%rax), %edx
movl %edx, -0x48(%rbp)
movq (%rcx,%rax), %rax
movq %rax, -0x50(%rbp)
movl 0x8(%rcx), %eax
movl %eax, -0x38(%rbp)
movq (%rcx), %rax
movq %rax, -0x40(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %r14
leaq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rax, %rdi
callq 0x7ac4
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x664c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x317b(%rip), %rdi      # 0xb8cd
leaq 0x2dcb(%rip), %rsi      # 0xb524
leaq 0x3226(%rip), %rcx      # 0xb986
movl $0x37b, %edx            # imm = 0x37B
callq 0x3110
movq %rax, %rbx
movq %r14, %rdi
jmp 0x877a
jmp 0x8781
movq %rax, %rbx
movq %r12, %rdi
callq 0x3190
jmp 0x8784
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x971e
movq %rbx, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: SpherePolygon::SpherePolygon(Polygon const&, bool)
SpherePolygon::SpherePolygon( const Polygon & orig, bool clip )
{
  style.draw_lines   = true ;
  style.draw_filled  = true ;
  style.close_lines  = true ;
  style.lines_width  = 0.004 ;
  style.fill_opacity = 0.2 ;
  style.lines_color  = vec3( 0.0, 0.0, 1.0 );
  style.fill_color   = vec3( 0.0, 0.0, 1.0 );

  assert( orig.points3D.size() > 0 );

  for( unsigned i = 0 ; i < orig.points3D.size() ; i++ )
  {
      vec3 pesf = orig.points3D[i].normalized();

      if ( clip && pesf[1] < 0.0 )
      {
         const vec3 pcirc = vec3( pesf[0], 0.0, pesf[2] ).normalized() ;
         points3D.push_back( pcirc );
      }
      else
         points3D.push_back( pesf );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6332
leaq 0x6f28(%rip), %rax      # 0xfa98
movq %rax, (%rbx)
movw $0x101, 0x38(%rbx)      # imm = 0x101
movb $0x1, 0x3a(%rbx)
movabsq $0x3e4ccccd3b83126f, %rax # imm = 0x3E4CCCCD3B83126F
movq %rax, 0x3c(%rbx)
movaps 0x273e(%rip), %xmm0     # 0xb2d0
movups %xmm0, 0x20(%rbx)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x30(%rbx)
movq 0x68(%r15), %rdi
movq 0x70(%r15), %rax
cmpq %rdi, %rax
je 0x8c67
movq %rbx, -0x58(%rbp)
leaq 0x68(%rbx), %r12
xorl %ebx, %ebx
pushq $0xc
popq %r13
movl %ebx, %ebx
subq %rdi, %rax
cqto
idivq %r13
cmpq %rbx, %rax
jbe 0x8c58
imulq $0xc, %rbx, %rax
addq %rax, %rdi
callq 0x5372
movss %xmm0, -0x4c(%rbp)
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movss %xmm2, -0x48(%rbp)
movss %xmm1, -0x44(%rbp)
testb %r14b, %r14b
je 0x8c3d
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jbe 0x8c3d
movss %xmm0, -0x34(%rbp)
andl $0x0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x5372
movss %xmm0, -0x40(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x3c(%rbp)
movss %xmm1, -0x38(%rbp)
movq %r12, %rdi
leaq -0x40(%rbp), %rsi
callq 0x994e
jmp 0x8c49
movq %r12, %rdi
leaq -0x4c(%rbp), %rsi
callq 0x994e
incl %ebx
movq 0x68(%r15), %rdi
movq 0x70(%r15), %rax
jmp 0x8bc3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e5e(%rip), %rdi      # 0xbacc
leaq 0x28af(%rip), %rsi      # 0xb524
leaq 0x2e69(%rip), %rcx      # 0xbae5
movl $0x3de, %edx            # imm = 0x3DE
callq 0x3110
jmp 0x8c8c
jmp 0x8c8c
jmp 0x8c8c
movq %rax, %rbx
movq -0x58(%rbp), %rdi
callq 0x973c
movq %rbx, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: HorPlanePolygon::HorPlanePolygon(Polygon const&, bool)
HorPlanePolygon::HorPlanePolygon( const Polygon & orig, bool clip_neg )
{
  style.draw_lines   = true ;
  style.draw_filled  = true ;
  style.close_lines  = true ;
  style.lines_width  = 0.004 ;
  style.fill_opacity = 0.2 ;
  style.lines_color  = vec3( 1.0, 0.0, 0.0 );
  style.fill_color   = vec3( 1.0, 0.0, 0.0 );

  assert( orig.points3D.size() > 0 );
  for( auto orig_pnt : orig.points3D )
  {
      // project onto sphere (normalize)
      const vec3 sph_pnt = orig_pnt.normalized() ,    // sphere point
                 pln_pnt = { sph_pnt[0], 0.0, sph_pnt[2] };   // plane point

      if ( !clip_neg || 0.0 <= sph_pnt[1] ) // if it is in upper hemisphere, just project
         points3D.push_back( pln_pnt );
      else // if in lower hemisphere, project to the circunference
         points3D.push_back( pln_pnt.normalized() );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r13
callq 0x6332
leaq 0x6e02(%rip), %rax      # 0xfac8
movq %rax, (%r13)
movw $0x101, 0x38(%r13)      # imm = 0x101
movb $0x1, 0x3a(%r13)
movabsq $0x3e4ccccd3b83126f, %rax # imm = 0x3E4CCCCD3B83126F
movq %rax, 0x3c(%r13)
movaps 0x25f5(%rip), %xmm0     # 0xb2e0
movups %xmm0, 0x20(%r13)
andq $0x0, 0x30(%r13)
movq 0x68(%r15), %rbx
movq 0x70(%r15), %r12
cmpq %rbx, %r12
je 0x8d96
movq %r13, -0x48(%rbp)
leaq 0x68(%r13), %r15
leaq -0x40(%rbp), %r13
cmpq %r12, %rbx
je 0x8d87
movl 0x8(%rbx), %eax
movl %eax, -0x50(%rbp)
movq (%rbx), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5372
movss %xmm0, -0x40(%rbp)
andl $0x0, -0x3c(%rbp)
movss %xmm1, -0x38(%rbp)
testb %r14b, %r14b
je 0x8d76
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
ucomiss 0x25d5(%rip), %xmm0     # 0xb320
jae 0x8d76
movq %r13, %rdi
callq 0x5372
movss %xmm0, -0x34(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
movq %r15, %rdi
leaq -0x34(%rbp), %rsi
callq 0x9f14
jmp 0x8d81
movq %r15, %rdi
movq %r13, %rsi
callq 0x994e
addq $0xc, %rbx
jmp 0x8d12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d2f(%rip), %rdi      # 0xbacc
leaq 0x2780(%rip), %rsi      # 0xb524
leaq 0x2d6e(%rip), %rcx      # 0xbb19
movl $0x3fc, %edx            # imm = 0x3FC
callq 0x3110
jmp 0x8db9
jmp 0x8db9
movq %rax, %rbx
movq -0x48(%rbp), %rdi
callq 0x973c
movq %rbx, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movb $0x0, 0x8(%rdi)
andq $0x0, 0x1c(%rdi)
andl $0x0, 0x24(%rdi)
movss 0x1fc9(%rip), %xmm0     # 0xb008
movlps %xmm0, 0x28(%rdi)
andl $0x0, 0x30(%rdi)
movl $0x3cf5c28f, 0x3c(%rdi) # imm = 0x3CF5C28F
leaq 0x6ad3(%rip), %rax      # 0xfb28
movq %rax, (%rdi)
cmpb $0x1, 0x8(%rsi)
je 0x90c0
movq %rdi, %rbx
addq $0x1c, %rsi
movq %rsi, %rdi
callq 0x5372
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
sqrtss %xmm4, %xmm3
movss 0x1f76(%rip), %xmm4     # 0xb008
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
andl $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2b3d(%rip), %rdi      # 0xbc04
leaq 0x2456(%rip), %rsi      # 0xb524
leaq 0x2b42(%rip), %rcx      # 0xbc17
movl $0x446, %edx            # imm = 0x446
callq 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: YCylinderPolygon::YCylinderPolygon(Polygon const&)
YCylinderPolygon::YCylinderPolygon( const Polygon & orig )
{
  style.draw_lines    = true ;
  style.draw_filled     = true ;
  style.close_lines = true ;
  style.lines_width  = 0.015 ;
  style.fill_opacity = 0.2 ;
  style.lines_color   = vec3( 1.0, 0.0, 0.0 );
  style.fill_color    = vec3( 1.0, 0.0, 0.0 );

  assert( orig.points3D.size() > 0 );
  for( unsigned i = 0 ; i < orig.points3D.size() ; i++ )
  {
    vec3       pesf = orig.points3D[i].normalized();
    const real f    = real(1.0)/real(sqrt( double( pesf[0]*pesf[0]+pesf[2]*pesf[2] )));
    vec3       pcil = vec3(  f*pesf[0], pesf[1], f*pesf[2]) ;

    points3D.push_back( pcil );
  }
}

// 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
callq 0x6332
leaq 0x6a55(%rip), %rax      # 0xfb58
movq %rax, (%rbx)
movw $0x101, 0x38(%rbx)      # imm = 0x101
movb $0x1, 0x3a(%rbx)
movabsq $0x3e4ccccd3c75c28f, %rax # imm = 0x3E4CCCCD3C75C28F
movq %rax, 0x3c(%rbx)
movaps 0x21bb(%rip), %xmm0     # 0xb2e0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rax
cmpq %rdi, %rax
je 0x91d4
movq %rbx, -0x40(%rbp)
leaq 0x68(%rbx), %r15
xorl %r13d, %r13d
pushq $0xc
popq %rbx
leaq -0x34(%rbp), %r12
movl %r13d, %r13d
subq %rdi, %rax
cqto
idivq %rbx
cmpq %r13, %rax
jbe 0x91c5
imulq $0xc, %r13, %rax
addq %rax, %rdi
callq 0x5372
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
sqrtss %xmm4, %xmm3
movss 0x1e76(%rip), %xmm4     # 0xb008
divss %xmm3, %xmm4
mulss %xmm4, %xmm0
mulss %xmm1, %xmm4
movss %xmm0, -0x34(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm4, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x994e
incl %r13d
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rax
jmp 0x9151
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28f1(%rip), %rdi      # 0xbacc
leaq 0x2342(%rip), %rsi      # 0xb524
leaq 0x2a56(%rip), %rcx      # 0xbc3f
movl $0x45c, %edx            # imm = 0x45C
callq 0x3110
jmp 0x91f5
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x973c
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: ZCylinderPolygon::ZCylinderPolygon(Polygon const&)
ZCylinderPolygon::ZCylinderPolygon( const Polygon & orig )
{
  style.draw_lines    = true ;
  style.draw_filled     = false ;
  style.close_lines = true ;
  style.lines_width  = 0.015 ;
  style.fill_opacity = 0.2 ;
  style.lines_color   = vec3( 1.0, 0.0, 0.0 );
  style.fill_color    = vec3( 1.0, 0.0, 0.0 );

  assert( orig.points3D.size() > 0 );
  for( unsigned i = 0 ; i < orig.points3D.size() ; i++ )
  {
    vec3       pesf = orig.points3D[i].normalized();
    const real f    = real(1.0)/real(sqrt( double( pesf[0]*pesf[0]+pesf[1]*pesf[1] )));
    vec3       pcil = vec3(  f*pesf[0], f*pesf[1], pesf[2]) ;

    points3D.push_back( pcil );
  }
}

// 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
callq 0x6332
leaq 0x695b(%rip), %rax      # 0xfb88
movq %rax, (%rbx)
movw $0x101, 0x38(%rbx)      # imm = 0x101
movb $0x0, 0x3a(%rbx)
movabsq $0x3e4ccccd3c75c28f, %rax # imm = 0x3E4CCCCD3C75C28F
movq %rax, 0x3c(%rbx)
movaps 0x2091(%rip), %xmm0     # 0xb2e0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rax
cmpq %rdi, %rax
je 0x92fe
movq %rbx, -0x40(%rbp)
leaq 0x68(%rbx), %r15
xorl %r13d, %r13d
pushq $0xc
popq %rbx
leaq -0x34(%rbp), %r12
movl %r13d, %r13d
subq %rdi, %rax
cqto
idivq %rbx
cmpq %r13, %rax
jbe 0x92ef
imulq $0xc, %r13, %rax
addq %rax, %rdi
callq 0x5372
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
movaps %xmm0, %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
sqrtss %xmm4, %xmm3
movss 0x1d4c(%rip), %xmm4     # 0xb008
divss %xmm3, %xmm4
mulss %xmm4, %xmm0
mulss %xmm2, %xmm4
movss %xmm0, -0x34(%rbp)
movss %xmm4, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x994e
incl %r13d
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rax
jmp 0x927b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27c7(%rip), %rdi      # 0xbacc
leaq 0x2218(%rip), %rsi      # 0xb524
leaq 0x2960(%rip), %rcx      # 0xbc73
movl $0x473, %edx            # imm = 0x473
callq 0x3110
jmp 0x931f
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x973c
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/./vector_templates_impl.hpp
// Function: VectorTempl<float, 3u> operator*<float, 3u>(float const&, VectorTempl<float, 3u> const&)
inline
VectorTempl<T,n> operator * ( const T & a, const VectorTempl<T,n> & der )
{
   VectorTempl<T,n> res ;
   for( unsigned i = 0 ; i < n ; i++ )
      res[i] = a*der(i) ;
   return res ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x9939
movss (%r14), %xmm0
movss %xmm0, -0x1c(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x54cc
movss -0x1c(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, -0x28(%rbp,%r15,4)
incq %r15
jmp 0x9909
movsd -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r8
movl %esi, %eax
movq %rsp, %r9
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r9
movq %r9, %rsp
movq (%rdi), %rdi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
cmpq %rax, %rdx
je 0x2344
movsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%r9,%rax,8)
incq %rax
jmp 0x232f
pushq $0x2
popq %r10
movl %ecx, %eax
cltd
idivl %r10d
leal (%rax,%rsi), %r10d
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movslq %esi, %rdx
cltq
movslq %r10d, %rsi
movq %rax, %r10
cmpq %rsi, %r10
jge 0x23b3
xorpd %xmm0, %xmm0
movq %r10, %r11
xorl %ebx, %ebx
cmpq %rbx, %rcx
je 0x23a2
testq %r11, %r11
sets %r14b
cmpq %rdx, %r11
setge %r15b
orb %r14b, %r15b
jne 0x239a
movsd (%r8,%rbx,8), %xmm1
mulsd (%r9,%r11,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
decq %r11
jmp 0x2372
movq %r10, %r11
subq %rax, %r11
movsd %xmm0, (%rdi,%r11,8)
incq %r10
jmp 0x2364
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %esi, %eax
movl %edx, %ebx
imulq %rbx, %rax
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
movq %rdi, -0x40(%rbp)
movq (%rdi), %rax
xorl %r10d, %r10d
testl %edx, %edx
cmovlel %r10d, %edx
movq %rdx, -0x38(%rbp)
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
leaq (,%rbx,8), %rdx
movq %rdx, -0x30(%rbp)
movq %r14, %r9
cmpq %rdi, %r10
je 0x2445
xorl %r11d, %r11d
cmpq %r11, -0x38(%rbp)
je 0x243c
movq (%rax,%r10,8), %r15
movsd (%r15,%r11,8), %xmm0
movsd %xmm0, (%r9,%r11,8)
incq %r11
jmp 0x2421
incq %r10
addq -0x30(%rbp), %r9
jmp 0x2419
pushq $0x2
popq %rdi
movl %r8d, %eax
cltd
idivl %edi
leal (%rax,%rsi), %r9d
movslq %esi, %rdx
xorl %esi, %esi
testl %r8d, %r8d
cmovlel %esi, %r8d
movslq %eax, %rdi
movslq %r9d, %rax
movq %rax, -0x50(%rbp)
imulq %rdi, %rbx
leaq (%r14,%rbx,8), %rbx
movq -0x30(%rbp), %r14
negq %r14
cmpq -0x38(%rbp), %rsi
je 0x24f7
movq -0x40(%rbp), %rax
movq (%rax), %r15
movq %rbx, -0x48(%rbp)
movq %rdi, %rax
cmpq -0x50(%rbp), %rax
jge 0x24ea
xorpd %xmm0, %xmm0
movq %rbx, %r12
movq %rax, %r13
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x24d1
testq %r13, %r13
sets %r10b
cmpq %rdx, %r13
setge %r11b
orb %r10b, %r11b
jne 0x24c6
movsd (%rcx,%r9,8), %xmm1
mulsd (%r12), %xmm1
addsd %xmm1, %xmm0
incq %r9
decq %r13
addq %r14, %r12
jmp 0x249e
movq %rax, %r9
subq %rdi, %r9
movq (%r15,%r9,8), %r9
movsd %xmm0, (%r9,%rsi,8)
incq %rax
addq -0x30(%rbp), %rbx
jmp 0x248b
incq %rsi
movq -0x48(%rbp), %rbx
addq $0x8, %rbx
jmp 0x2477
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movq %rdi, %r14
leaq 0x176d(%rip), %rsi      # 0x4060
movq %r9, %rdi
callq 0x21c0
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x2190
movq (%r13), %rsi
pushq $0x14
popq %rdx
movq %rbp, %rdi
callq 0x2040
movslq %r12d, %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2130
movslq 0x4(%rsp), %r15
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x8(%rsp), %r12
cmpq %r13, %rbx
je 0x2953
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2130
incq %r13
jmp 0x293a
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x8(%rsp), %rdi
callq 0x2170
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x297b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x6a60(%rip), %rdx      # 0xa07e
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7d24
leaq 0xbc1b(%rip), %rdx      # 0xf250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7d05
leaq 0x20(%rsp), %rdi
callq 0x3448
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x36ae
movl %eax, %ebp
testb %al, %al
je 0x366c
leaq 0xbc0e(%rip), %rdi      # 0xf270
movq %rbx, %rsi
callq 0x3140
jmp 0x367e
andq $0x0, 0xbc04(%rip)      # 0xf278
movq 0xbbf5(%rip), %rax      # 0xf270
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x3448
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x36a1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36cc
movq (%rdi), %rdi
callq 0x3360
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x3110
movq %rax, %rbx
leaq 0x6c3b(%rip), %rsi      # 0xa319
movq %rax, %rdi
callq 0x30c0
movq 0xb903(%rip), %rsi      # 0xeff0
movq 0xb8bc(%rip), %rdx      # 0xefb0
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x695e(%rip), %rsi      # 0xa080
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0x3740
leaq 0x694e(%rip), %rdi      # 0xa084
callq 0x3260
testq %rax, %rax
je 0x3757
leaq 0xbb49(%rip), %rdi      # 0xf290
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3140
pushq $0x10
popq %rdi
callq 0x3110
movq %rax, %rbx
leaq 0x6923(%rip), %rsi      # 0xa08c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7cca
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7d5c
xorl %ebp, %ebp
leaq 0xb5b7(%rip), %rsi      # 0xed48
movq 0xb820(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3448
testb %bpl, %bpl
jne 0x37b7
jmp 0x37bf
movq %rax, %r14
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x37f4
movq 0xb808(%rip), %rdi      # 0xefe8
leaq 0x68c1(%rip), %rsi      # 0xa0a8
callq 0x31f0
movq %rax, %rdi
callq 0x3100
leaq 0x50(%rbx), %rdi
callq 0x7d7c
leaq 0x30(%rbx), %rdi
callq 0x3448
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3448
movq %rax, %rdi
callq 0x7d71
nop
// File: /workspace/github_cpp_makefile_star2_O2/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::reset_all()
Gnuplot& Gnuplot::reset_all(void)
{
    //  remove_tmpfiles();

    nplots = 0;
    (void)cmd("reset");
    (void)cmd("clear");
    pstyle = "points";
    smooth.clear();
    showonscreen();

    return *this;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andl $0x0, 0xc(%rdi)
leaq 0x68ad(%rip), %rsi      # 0xa0e4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7cca
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x38d6
leaq 0x10(%rsp), %rdi
callq 0x3448
leaq 0x6886(%rip), %rsi      # 0xa0ea
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7cca
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x38d6
leaq 0x10(%rsp), %rdi
callq 0x3448
leaq 0x10(%rbx), %rdi
leaq 0x6e8f(%rip), %rsi      # 0xa724
callq 0x3400
andq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x3960
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x38bb
jmp 0x38ca
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3448
jmp 0x38cd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33b0
nop