LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x24(%rdi), %rsi
movq %rax, %rdi
callq 0x6b62
movlps %xmm0, 0x30(%rbx)
movss 0x1c(%rbx), %xmm0
movss %xmm0, 0x20(%rbx)
movb $0x1, 0x8(%rbx)
movss %xmm0, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
xorl %eax, %eax
movss 0x30(%rbx,%rax,4), %xmm1
subss -0x10(%rbp,%rax,4), %xmm1
movss %xmm1, -0x18(%rbp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x773b
movsd -0x18(%rbp), %xmm1
movss %xmm1, 0xc(%rbx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss %xmm1, 0x10(%rbx)
movss %xmm0, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
xorl %eax, %eax
movss 0x30(%rbx,%rax,4), %xmm0
addss -0x10(%rbp,%rax,4), %xmm0
movss %xmm0, -0x18(%rbp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x7775
movsd -0x18(%rbp), %xmm0
movss %xmm0, 0x14(%rbx)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7979
movq %rdi, %rbx
movq (%rsi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6018(%rip), %rsi      # 0xd7f1
leaq 0x6016(%rip), %rdx      # 0xd7f6
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xc45a
movq %r14, %rdi
movq %r15, %rsi
callq 0x61e8
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7805
callq 0x31a0
leaq 0x5feb(%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 0x5fb6(%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 0x5fb6(%rip), %rsi      # 0xd83e
movl $0x7, %edx
movq %rax, %rdi
callq 0x31e0
cvtss2sd 0x30(%rbx), %xmm0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x5dc9(%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 0x5da9(%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 0x5f42(%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 0x5a5f(%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 0x6219(%rip), %rdi      # 0xdb99
leaq 0x5b29(%rip), %rsi      # 0xd4b0
leaq 0x5e38(%rip), %rcx      # 0xd7c6
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x3120
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x79a9
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x940e(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c48
leaq 0x68(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x9515(%rip), %rax      # 0x11890
movq %rax, (%rbx)
movw $0x1, 0x38(%rbx)
movb %r14b, 0x3a(%rbx)
movq (%r13), %rax
movq %rax, 0x20(%rbx)
movl 0x8(%r13), %eax
movl %eax, 0x28(%rbx)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x3c(%rbx)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x83c1
movl 0x8(%r12), %eax
movl %eax, 0x8(%rsi)
movq (%r12), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x83cf
movq %rdi, %r14
movq %r12, %rdx
callq 0xc67c
movq %r14, %rdi
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 0x83d1
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 0x8427
movl -0x30(%rbp), %eax
movl %eax, 0x8(%rsi)
movq -0x38(%rbp), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x8430
leaq -0x38(%rbp), %rdx
callq 0xc4f4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8441
movq %rax, %r14
movq %rbx, %rdi
callq 0xbe68
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x92e7(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c48
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
leaq 0x93ee(%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 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x84e5
movl 0x8(%r12), %eax
movl %eax, 0x8(%rsi)
movq (%r12), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x84f0
movq %r15, %rdi
movq %r12, %rdx
callq 0xc67c
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x850e
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x8519
movq %r15, %rdi
movq %r14, %rdx
callq 0xc67c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbe68
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x91fa(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c48
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x9301(%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 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x85db
movl 0x8(%r12), %eax
movl %eax, 0x8(%rsi)
movq (%r12), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x85e6
movq %r15, %rdi
movq %r12, %rdx
callq 0xc67c
addq $0x1c, %r14
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x8608
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x8613
movq %r15, %rdi
movq %r14, %rdx
callq 0xc67c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xbe68
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8189(%rip), %rax      # 0x11760
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6c48
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
leaq 0x8350(%rip), %rax      # 0x11950
movq %rax, (%rbx)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x9621
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x962c
movq %r15, %rdi
movq %r14, %rdx
callq 0xc67c
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x964b
movl 0x8(%r13), %eax
movl %eax, 0x8(%rsi)
movq (%r13), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x9656
movq %r15, %rdi
movq %r13, %rdx
callq 0xc67c
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x9676
movl 0x8(%r12), %eax
movl %eax, 0x8(%rsi)
movq (%r12), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x9681
movq %r15, %rdi
movq %r12, %rdx
callq 0xc67c
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x96a2
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rsi)
movq (%rcx), %rax
movq %rax, (%rsi)
addq $0xc, 0x70(%rbx)
jmp 0x96ae
movq %r15, %rdi
movq -0x30(%rbp), %rdx
callq 0xc67c
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 0xbe68
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x825c(%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 0x9826
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
movq %rax, -0x5c(%rbp)
movl $0x3f800000, -0x54(%rbp) # imm = 0x3F800000
testl %r12d, %r12d
je 0x9817
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 0x97b1
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 0x3aae(%rip), %xmm0     # 0xd2a8
callq 0x8322
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x7568
addl -0x2c(%rbp), %ebx
cmpl %r12d, %ebx
jb 0x9781
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x402c(%rip), %rdi      # 0xd859
leaq 0x3c7c(%rip), %rsi      # 0xd4b0
leaq 0x4036(%rip), %rcx      # 0xd871
movl $0x2ef, %edx            # imm = 0x2EF
callq 0x3120
movq %rax, %r14
movq %r13, %rdi
callq 0x31a0
jmp 0x9855
movq %rax, %r14
leaq 0x7f34(%rip), %rax      # 0x11790
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x9871
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ea7(%rip), %rax      # 0x119e0
movq %rdi, -0x40(%rbp)
movq %rax, (%rdi)
movq 0x70(%rdx), %rax
movq %rdx, -0x68(%rbp)
subq 0x68(%rdx), %rax
movl %esi, -0x2c(%rbp)
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %r12d # imm = 0xAAAAAAAB
testl %r12d, %r12d
jle 0x9c45
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, -0x38(%rbp)
movss -0x4c(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movl %ebx, -0x30(%rbp)
movl $0x98, %edi
callq 0x31d0
movq %rax, %r13
xorl %eax, %eax
movss -0x50(%rbp,%rax,4), %xmm0
subss -0x38(%rbp,%rax,4), %xmm0
movss %xmm0, -0x78(%rbp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x9bc0
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)
movb $0x1, %r15b
movq %r13, %rdi
leaq -0x38(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
leaq -0x84(%rbp), %rcx
movss 0x3693(%rip), %xmm0     # 0xd2a8
callq 0x8322
xorl %r15d, %r15d
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x7568
addl -0x2c(%rbp), %r14d
cmpl %r12d, %r14d
jb 0x9b83
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c70(%rip), %rdi      # 0xd8bc
leaq 0x385d(%rip), %rsi      # 0xd4b0
leaq 0x3c68(%rip), %rcx      # 0xd8c2
movl $0x318, %edx            # imm = 0x318
callq 0x3120
movq %rax, %r14
jmp 0x9c79
movq %rax, %r14
testb %r15b, %r15b
je 0x9c79
movq %r13, %rdi
callq 0x31a0
leaq 0x7b10(%rip), %rax      # 0x11790
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x9c95
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x30, %rsp
movb $0x0, 0x8(%rdi)
movq $0x0, 0x1c(%rdi)
xorl %eax, %eax
movl %eax, 0x24(%rdi)
movss 0x1cde(%rip), %xmm0     # 0xd008
movlpd %xmm0, 0x28(%rdi)
movl %eax, 0x30(%rdi)
movl $0x3cf5c28f, 0x3c(%rdi) # imm = 0x3CF5C28F
leaq 0x67f0(%rip), %rax      # 0x11b30
movq %rax, (%rdi)
cmpb $0x1, 0x8(%rsi)
je 0xb433
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 0xb359
cvtsd2ss %xmm0, %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xb387
sqrtss %xmm0, %xmm0
jmp 0xb38c
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 0xb38e
movsd -0x20(%rbp), %xmm3
movss -0x18(%rbp), %xmm2
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xb3d9
sqrtss %xmm0, %xmm0
jmp 0xb3f8
movss %xmm2, -0x14(%rbp)
movaps %xmm3, -0x40(%rbp)
movaps %xmm4, -0x30(%rbp)
callq 0x32d0
movaps -0x30(%rbp), %xmm4
movaps -0x40(%rbp), %xmm3
movss -0x14(%rbp), %xmm2
movss 0x1c08(%rip), %xmm1     # 0xd008
divss %xmm0, %xmm1
mulss %xmm1, %xmm3
mulss %xmm1, %xmm2
movss %xmm3, 0x1c(%rbx)
movss %xmm4, 0x20(%rbx)
movss %xmm2, 0x24(%rbx)
movq $0x3f800000, 0x28(%rbx) # imm = 0x3F800000
movl $0x0, 0x30(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2756(%rip), %rdi      # 0xdb90
leaq 0x206f(%rip), %rsi      # 0xd4b0
leaq 0x275b(%rip), %rcx      # 0xdba3
movl $0x446, %edx            # imm = 0x446
callq 0x3120
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl %esi, %edx
movq %rsp, %r13
leaq 0xf(,%rdx,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testl %esi, %esi
jle 0x2370
movq (%r12), %rsi
shlq $0x3, %rdx
movq %r13, %rdi
callq 0x20d0
testl %r15d, %r15d
jle 0x23ec
movl %ebx, %eax
shrl $0x1f, %eax
addl %ebx, %eax
sarl %eax
leal (%rax,%r15), %esi
movq (%r12), %rcx
movslq %eax, %rdx
movslq %esi, %rsi
movl %ebx, %edi
leaq (,%rdx,8), %r8
addq %r13, %r8
negq %rdi
movq %rdx, %r9
xorpd %xmm0, %xmm0
testl %ebx, %ebx
jle 0x23d1
movq %r14, %r10
xorl %r11d, %r11d
leal (%rax,%r11), %r12d
cmpl %r15d, %r12d
jae 0x23c5
movsd (%r10), %xmm1
mulsd (%r8,%r11,8), %xmm1
addsd %xmm1, %xmm0
decq %r11
addq $0x8, %r10
cmpq %r11, %rdi
jne 0x23ad
movq %r9, %r10
subq %rdx, %r10
movsd %xmm0, (%rcx,%r10,8)
incq %r9
incq %rax
addq $0x8, %r8
cmpq %rsi, %r9
jl 0x239f
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x248d
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 0x2481
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 0x2468
cmpl $0x0, -0x38(%rbp)
jle 0x254b
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 0x253a
cmpl $0x0, -0x2c(%rbp)
jle 0x251b
xorpd %xmm0, %xmm0
movq %r11, %r13
movl %r12d, %edi
xorl %ebx, %ebx
cmpl %r15d, %edi
jae 0x250c
movsd (%r14,%rbx,8), %xmm1
mulsd (%r13), %xmm1
addsd %xmm1, %xmm0
incq %rbx
decl %edi
addq %r9, %r13
cmpq %rbx, %rsi
jne 0x24f7
jmp 0x251f
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 0x24e5
incq %r10
movq -0x38(%rbp), %r11
addq $0x8, %r11
cmpq -0x40(%rbp), %r10
jne 0x24d9
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x161d(%rip), %rsi      # 0x4020
movq %r9, %rdi
callq 0x21f0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21c0
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 0x2a64
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 0x2a4d
leaq 0x8(%rsp), %rdi
callq 0x2180
movq 0x355b(%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 0x2ab4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc10e
leaq 0x99de(%rip), %rsi      # 0xd07e
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), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36e7
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x36ee
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x371d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x3380
movl %eax, %ebp
testl %eax, %eax
je 0x3749
movq $0x0, 0xdb3b(%rip) # 0x11278
movq 0xdb2c(%rip), %rax      # 0x11270
movb $0x0, (%rax)
jmp 0x3758
leaq 0xdb20(%rip), %rdi      # 0x11270
movq %rbx, %rsi
callq 0x3150
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x376f
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 0x37af
movq 0x38(%rsp), %rsi
jmp 0x37a7
jmp 0x3795
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37d6
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 0x9b2f(%rip), %rsi      # 0xd319
movq %rax, %rdi
callq 0x30e0
movq 0xd7f7(%rip), %rsi      # 0x10ff0
movq 0xd7a8(%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_O1/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 0x9850(%rip), %rsi      # 0xd080
movl $0x3, %ecx
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x3853
leaq 0x983b(%rip), %rdi      # 0xd084
callq 0x3280
testq %rax, %rax
je 0x386c
leaq 0xda36(%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 0x9803(%rip), %rsi      # 0xd08c
leaq 0x9817(%rip), %rdx      # 0xd0a7
leaq 0x8(%rsp), %rdi
callq 0xc19e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32a0
leaq 0xd4af(%rip), %rax      # 0x10d60
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd47b(%rip), %rsi      # 0x10d38
movq 0xd6f4(%rip), %rdx      # 0x10fb8
movq %rbx, %rdi
callq 0x33c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x38ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x38ee
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x38fb
movq %rbx, %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x395e
movq 0xd6c9(%rip), %r14      # 0x10fe8
leaq 0x9782(%rip), %rsi      # 0xd0a8
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 0xd697(%rip), %rdi      # 0x10fe8
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x50(%rbx), %rdi
callq 0xaeec
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x397f
movq (%rax), %rsi
incq %rsi
callq 0x3210
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x399e
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 0xaee0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9709(%rip), %rsi      # 0xd0e4
leaq 0x9707(%rip), %rdx      # 0xd0e9
leaq 0x8(%rsp), %rdi
callq 0xc19e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ab8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x96cb(%rip), %rsi      # 0xd0ea
leaq 0x96c9(%rip), %rdx      # 0xd0ef
callq 0xc19e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ab8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a4f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x9cc6(%rip), %rcx      # 0xd724
movl $0x6, %r8d
xorl %esi, %esi
callq 0x3320
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x3ba6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x3a91
jmp 0x3aad
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ab0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x3ab0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::cmd(const std::string &cmdstr)
{
    if( !(valid) )
    {
        return *this;
    }


    // int fputs ( const char * str, FILE * stream );
    // writes the string str to the stream.
    // The function begins copying from the address specified (str) until it
    // reaches the terminating null character ('\0'). This final
    // null-character is not copied to the stream.
    fputs( (cmdstr + "\n").c_str(), gnucmd );

    // int fflush ( FILE * stream );
    // If the given stream was open for writing and the last i/o operation was
    // an output operation, any unwritten data in the output buffer is written
    // to the file.  If the argument is a null pointer, all open files are
    // flushed.  The stream remains open after this call.
    fflush(gnucmd);

    if( cmdstr.find("splot") != std::string::npos )
    {
        two_dim = false;
        ++nplots;
        return *this;
    }
    else if( cmdstr.find("plot") != std::string::npos )
    {
        two_dim = true;
        ++nplots;
        return *this;
    }
    else
    {
        return *this;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x3b74
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc10e
leaq 0x97af(%rip), %rsi      # 0xd2aa
movq %r15, %rdi
callq 0x3420
movq 0x8(%rsp), %rdi
movq (%rbx), %rsi
callq 0x3240
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq (%rbx), %rdi
callq 0x3260
leaq 0x9776(%rip), %rsi      # 0xd2ac
xorl %r15d, %r15d
movl $0x5, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3b6d
leaq 0x9db9(%rip), %rsi      # 0xd90e
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
movb $0x1, %r15b
cmpq $-0x1, %rax
je 0x3b74
movb %r15b, 0x9(%rbx)
incl 0xc(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b9d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_smooth(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::set_smooth(const std::string &stylestr)
{
    if (stylestr.find("unique")    == std::string::npos  &&
            stylestr.find("frequency") == std::string::npos  &&
            stylestr.find("csplines")  == std::string::npos  &&
            stylestr.find("bezier")    == std::string::npos  )
    {
        smooth.clear();
    }
    else
    {
        smooth = stylestr;
    }

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9423(%rip), %rsi      # 0xd0f0
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d36
leaq 0x940e(%rip), %rsi      # 0xd0f7
movl $0x9, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d36
leaq 0x93fc(%rip), %rsi      # 0xd101
movl $0x8, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d36
leaq 0x93e9(%rip), %rsi      # 0xd10a
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x3d4d
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x3150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
jmp 0x3d42
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::savetofigure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::savetofigure(const std::string &filename,
                               const std::string &terminal)
{
    std::ostringstream cmdstr;
    cmdstr << "set terminal " << terminal;
    (void)cmd(cmdstr.str() );

    cmdstr.str("");     // Clear cmdstr
    cmdstr << "set output \"" << filename << "\"";
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
leaq 0x9393(%rip), %rsi      # 0xd11c
movl $0xd, %edx
movq %r12, %rdi
callq 0x3250
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x28(%rsp), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3ab8
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x3dde
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x94c0(%rip), %rdx      # 0xd2ab
movq %rdx, %rsi
callq 0xc19e
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x930f(%rip), %rsi      # 0xd12a
leaq 0x20(%rsp), %rdi
movl $0xc, %edx
callq 0x3250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x9550(%rip), %rsi      # 0xd392
movl $0x1, %edx
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3ab8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e7b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xd12e(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3eaf
jmp 0x3ee1
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x3ed0
jmp 0x3ee4
jmp 0x3ee1
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ee4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x3ee4
jmp 0x3ee1
movq %rax, %rbx
movq 0xd0c5(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_contour(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::set_contour(const std::string &position)
{
    if (position.find("base")    == std::string::npos  &&
            position.find("surface") == std::string::npos  &&
            position.find("both")    == std::string::npos  )
    {
        return cmd("set contour base");
    }

    return cmd("set contour " + position);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8bf9(%rip), %rsi      # 0xd1ad
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x4601
leaq 0x9356(%rip), %rsi      # 0xd926
movl $0x7, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x4601
leaq 0x8bb0(%rip), %rsi      # 0xd19c
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x4649
leaq 0x8baa(%rip), %rsi      # 0xd1b2
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xaf47
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ab8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x463c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8b48(%rip), %rsi      # 0xd1a1
leaq 0x8b51(%rip), %rdx      # 0xd1b1
movq %rsp, %rdi
callq 0xc19e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3ab8
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x462f
jmp 0x463c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x46a2
jmp 0x46af
movq %rax, %rbx
jmp 0x46af
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_slope(double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::plot_slope(const double a,
                             const double b,
                             const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == true)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "plot ";
    }

    cmdstr << a << " * x + " << b << " title \"";

    if (title.empty())
    {
        cmdstr << "f(x) = " << a << " * x + " << b;
    }
    else
    {
        cmdstr << title;
    }

    cmdstr << "\" with " << pstyle;

    //
    // Do the actual plot
    //
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x32b0
cmpl $0x0, 0xc(%rbx)
setg %al
andb 0x9(%rbx), %al
leaq 0x834f(%rip), %rcx      # 0xd21b
leaq 0x834a(%rip), %rsi      # 0xd21d
cmovneq %rcx, %rsi
movzbl %al, %eax
leaq 0x5(,%rax,2), %rdx
movq %r15, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3350
movq %rax, %r15
leaq 0x831f(%rip), %rsi      # 0xd223
movl $0x7, %edx
movq %rax, %rdi
callq 0x3250
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3350
leaq 0x837b(%rip), %rsi      # 0xd2a1
movl $0x8, %edx
movq %rax, %rdi
callq 0x3250
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4f4b
movq (%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x3250
jmp 0x4f96
leaq 0x82d9(%rip), %rsi      # 0xd22b
leaq 0x38(%rsp), %rdi
movl $0x7, %edx
callq 0x3250
leaq 0x38(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3350
movq %rax, %r14
leaq 0x82a8(%rip), %rsi      # 0xd223
movl $0x7, %edx
movq %rax, %rdi
callq 0x3250
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3350
leaq 0x8296(%rip), %rsi      # 0xd233
leaq 0x38(%rsp), %rdi
movl $0x7, %edx
callq 0x3250
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x38(%rsp), %rdi
callq 0x3250
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3340
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ab8
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ff5
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xbfb4(%rip), %rsi      # 0x10fb0
leaq 0x38(%rsp), %rdi
callq 0x3140
leaq 0xa8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5048
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x5048
jmp 0x5045
movq %rax, %rbx
movq 0xbf61(%rip), %rsi      # 0x10fb0
leaq 0x38(%rsp), %rdi
callq 0x3140
leaq 0xa8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_equation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::plot_equation(const std::string &equation,
                                const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == true)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "plot ";
    }

    cmdstr << equation;

    if (title.empty())
    {
        cmdstr << " notitle";
    }
    else
    {
        cmdstr << " title \"" << title << "\"";
    }

    cmdstr << " with " << pstyle;

    //
    // Do the actual plot
    //
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
cmpl $0x0, 0xc(%rbx)
setg %al
andb 0x9(%rbx), %al
leaq 0x8178(%rip), %rcx      # 0xd21b
leaq 0x8173(%rip), %rsi      # 0xd21d
cmovneq %rcx, %rsi
movzbl %al, %eax
leaq 0x5(,%rax,2), %rdx
movq %r12, %rdi
callq 0x3250
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3250
cmpq $0x0, 0x8(%r14)
je 0x5114
leaq 0x81be(%rip), %rsi      # 0xd2a1
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x3250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
movq %rax, %r15
movl $0x1, %edx
leaq 0x8280(%rip), %rsi      # 0xd392
jmp 0x5120
movl $0x8, %edx
leaq 0x811b(%rip), %rsi      # 0xd23b
movq %r15, %rdi
callq 0x3250
leaq 0x8105(%rip), %rsi      # 0xd234
leaq 0x20(%rsp), %rdi
movl $0x6, %edx
callq 0x3250
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3ab8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5183
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xbe26(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51d8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x51d8
jmp 0x51d5
movq %rax, %rbx
movq 0xbdd1(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0