LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, 0x8(%rax)
je 0xbae3
jmp 0xbb02
leaq 0xc06f(%rip), %rdi      # 0x17b59
leaq 0xb97f(%rip), %rsi      # 0x17470
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0xbc89(%rip), %rcx      # 0x17786
callq 0x3100
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3290
movq -0x60(%rbp), %rdx
leaq 0xbc84(%rip), %rsi      # 0x177b1
leaq -0x38(%rbp), %rdi
callq 0x3200
jmp 0xbb38
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9ed0
jmp 0xbb47
leaq -0x38(%rbp), %rdi
callq 0x30f0
leaq -0x39(%rbp), %rdi
callq 0x31d0
movq -0x18(%rbp), %rdi
leaq 0xbc53(%rip), %rsi      # 0x177b7
callq 0x31a0
movq %rax, %rdi
movq 0x12435(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xbc3e(%rip), %rsi      # 0x177c0
callq 0x31a0
movq %rax, %rdi
movq 0x12417(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xbc5e(%rip), %rsi      # 0x177fe
callq 0x31a0
movq -0x58(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x30, %rdi
callq 0x13470
movq -0x78(%rbp), %rdi
movss (%rax), %xmm0
callq 0x3120
movq %rax, %rdi
leaq 0xba68(%rip), %rsi      # 0x17635
callq 0x31a0
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x13470
movq -0x70(%rbp), %rdi
movss 0x4(%rax), %xmm0
callq 0x3120
movq %rax, %rdi
leaq 0xba41(%rip), %rsi      # 0x1763c
callq 0x31a0
movq %rax, %rdi
movq -0x58(%rbp), %rax
movss 0x20(%rax), %xmm0
callq 0x3120
movq %rax, %rdi
leaq 0xbbe1(%rip), %rsi      # 0x177fc
callq 0x31a0
movq %rax, %rdi
movq 0x1237e(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xb71e(%rip), %rsi      # 0x17357
callq 0x31a0
movq %rax, %rdi
movq 0x12360(%rip), %rsi     # 0x1dfa8
callq 0x31c0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xbc79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30f0
leaq -0x39(%rbp), %rdi
callq 0x31d0
movq -0x48(%rbp), %rdi
callq 0x3280
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xb040
movq -0x68(%rbp), %rdi
leaq 0x10da0(%rip), %rax     # 0x1d878
movq %rax, (%rdi)
movb $0x1, 0x38(%rdi)
movb $0x0, 0x3a(%rdi)
movb $0x0, 0x39(%rdi)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x28(%rdi)
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x13cc0
jmp 0xcb11
movq -0x68(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b90
movss %xmm1, -0x84(%rbp)
movaps %xmm0, -0x80(%rbp)
jmp 0xcb3b
movss -0x84(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
movlpd %xmm1, -0x60(%rbp)
movss %xmm0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8e00
jmp 0xcb6e
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13b60
jmp 0xcb80
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb2d0
movq -0x30(%rbp), %rdi
callq 0x3280
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xb040
movq -0x48(%rbp), %rax
leaq 0x10c9c(%rip), %rcx     # 0x1d878
movq %rcx, (%rax)
movb $0x1, 0x38(%rax)
movb $0x0, 0x3a(%rax)
movb $0x0, 0x39(%rax)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x8c30
jmp 0xcc17
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x28(%rdi)
movq -0x24(%rbp), %rax
movq %rax, 0x20(%rdi)
movl $0x3be56042, 0x3c(%rdi) # imm = 0x3BE56042
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x13cc0
jmp 0xcc3f
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x13cc0
jmp 0xcc52
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xb2d0
movq -0x38(%rbp), %rdi
callq 0x3280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb040
movq -0x38(%rbp), %rdi
leaq 0x10bc7(%rip), %rax     # 0x1d878
movq %rax, (%rdi)
movb $0x1, 0x38(%rdi)
movb $0x0, 0x3a(%rdi)
movb $0x0, 0x39(%rdi)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movl %ecx, 0x28(%rdi)
movq 0x28(%rax), %rax
movq %rax, 0x20(%rdi)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
addq $0x1c, %rsi
callq 0x13cc0
jmp 0xccef
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
addq $0x1c, %rsi
callq 0x13cc0
jmp 0xcd06
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xb2d0
movq -0x28(%rbp), %rdi
callq 0x3280
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xb040
movq -0x58(%rbp), %rdi
leaq 0xf084(%rip), %rax      # 0x1d938
movq %rax, (%rdi)
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x13cc0
jmp 0xe8c6
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x13cc0
jmp 0xe8d9
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq -0x28(%rbp), %rsi
callq 0x13cc0
jmp 0xe8ec
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq -0x20(%rbp), %rsi
callq 0x13cc0
jmp 0xe8ff
movq -0x58(%rbp), %rax
movb $0x0, 0x38(%rax)
movb $0x0, 0x39(%rax)
movb $0x1, 0x3a(%rax)
movl $0x3e4ccccd, 0x40(%rax) # imm = 0x3E4CCCCD
movl $0x3f800000, -0x44(%rbp) # imm = 0x3F800000
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
callq 0x8c30
jmp 0xe942
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movl -0x38(%rbp), %ecx
movl %ecx, 0x34(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb2d0
movq -0x30(%rbp), %rdi
callq 0x3280
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xb5b0
movq -0x98(%rbp), %rax
leaq 0xefa0(%rip), %rcx      # 0x1d958
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x13790
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x13790
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jne 0xe9f8
jmp 0xea17
leaq 0x8e1a(%rip), %rdi      # 0x17819
leaq 0x8a6a(%rip), %rsi      # 0x17470
movl $0x2ef, %edx            # imm = 0x2EF
leaq 0x8e1f(%rip), %rcx      # 0x17831
callq 0x3100
movl $0x0, -0x34(%rbp)
movl $0x3f333333, -0x38(%rbp) # imm = 0x3F333333
movl $0x3f800000, -0x3c(%rbp) # imm = 0x3F800000
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
callq 0x8c30
jmp 0xea43
movss 0x87dd(%rip), %xmm0     # 0x17228
movss %xmm0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xeb90
movl $0x98, %edi
callq 0x31b0
movq %rax, -0xa0(%rbp)
jmp 0xea76
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x13d30
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x13d30
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x13d30
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x8d60
movss %xmm1, -0xb4(%rbp)
movaps %xmm0, -0xb0(%rbp)
jmp 0xeada
movss -0xb4(%rbp), %xmm0
movaps -0xb0(%rbp), %xmm1
movlpd %xmm1, -0x88(%rbp)
movss %xmm0, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x6c(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8e00
jmp 0xeb16
movq -0xc8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
leaq -0x6c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movss 0x86f4(%rip), %xmm0     # 0x17228
callq 0xcaa0
jmp 0xeb3b
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0xb660
jmp 0xeb58
jmp 0xeb5a
movl -0xc(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0xea57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xeb99
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3190
jmp 0xeb99
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xb5f0
movq -0x48(%rbp), %rdi
callq 0x3280
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xb5b0
movq -0xa0(%rbp), %rax
leaq 0xe7f4(%rip), %rcx      # 0x1d9b8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x13790
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jge 0xf1e4
jmp 0xf203
leaq 0x8691(%rip), %rdi      # 0x1787c
leaq 0x827e(%rip), %rsi      # 0x17470
movl $0x318, %edx            # imm = 0x318
leaq 0x8684(%rip), %rcx      # 0x17882
callq 0x3100
movl $0x0, -0x2c(%rbp)
movl $0x3f333333, -0x30(%rbp) # imm = 0x3F333333
movl $0x3f800000, -0x34(%rbp) # imm = 0x3F800000
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x8c30
jmp 0xf22f
movss 0x7ff1(%rip), %xmm0     # 0x17228
movss %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xf394
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x13d30
movl 0x8(%rax), %ecx
movl %ecx, -0x50(%rbp)
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8f10
movq %rax, -0xa8(%rbp)
jmp 0xf287
movq -0xa8(%rbp), %rdx
addq $0x4, %rdx
movl $0x0, -0x6c(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x6c(%rbp), %rcx
callq 0x8c30
jmp 0xf2ac
movl $0x98, %edi
callq 0x31b0
movq %rax, -0xb0(%rbp)
jmp 0xf2bf
leaq -0x58(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x8d60
movss %xmm1, -0xc4(%rbp)
movaps %xmm0, -0xc0(%rbp)
jmp 0xf2dd
movss -0xc4(%rbp), %xmm0
movaps -0xc0(%rbp), %xmm1
movlpd %xmm1, -0x98(%rbp)
movss %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x80(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8e00
jmp 0xf325
movq -0xb0(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x78(%rbp), %rdx
leaq -0x28(%rbp), %rcx
movss 0x7ee8(%rip), %xmm0     # 0x17228
callq 0xcaa0
jmp 0xf347
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0xb660
jmp 0xf35c
jmp 0xf35e
movl -0xc(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0xf243
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf39d
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3190
jmp 0xf39d
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0xb5f0
movq -0x40(%rbp), %rdi
callq 0x3280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x9470
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jae 0x13c9e
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9480
movss -0x40(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x93d0
movss -0x3c(%rbp), %xmm0
movl -0x24(%rbp), %ecx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13c50
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2484
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x3c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2454
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jge 0x253c
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2514
movl -0x44(%rbp), %eax
subl -0x48(%rbp), %eax
cmpl $0x0, %eax
jl 0x24d6
movl -0x44(%rbp), %eax
subl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x24d8
jmp 0x2509
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x48(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movl -0x44(%rbp), %ecx
subl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x24b8
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x44(%rbp), %ecx
subl -0x40(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2498
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %r9, -0x258(%rbp)
movq %rdi, %rax
movq -0x258(%rbp), %rdi
movq %rdi, -0x250(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x2080(%rip), %rsi      # 0x5060
callq 0x2150
leaq -0x228(%rbp), %rdi
callq 0x2270
movq -0x250(%rbp), %rdi
callq 0x20a0
movq %rax, -0x248(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x4410
movl %eax, -0x23c(%rbp)
jmp 0x301b
movl -0x23c(%rbp), %edx
movq -0x248(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0x2040
jmp 0x3036
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x2200
jmp 0x304c
movl $0x0, -0x238(%rbp)
movl -0x238(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x30b5
movq -0x8(%rbp), %rax
movslq -0x238(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x2200
jmp 0x3082
jmp 0x3084
movl -0x238(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x238(%rbp)
jmp 0x3056
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2240
jmp 0x30d8
leaq -0x228(%rbp), %rdi
callq 0x2220
jmp 0x30c3
leaq -0x228(%rbp), %rdi
callq 0x2240
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xc7d7(%rip), %rdx      # 0x1007e
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xbc50
movq -0x68(%rbp), %rsi
leaq 0x12a51(%rip), %rdx     # 0x16310
leaq -0x30(%rbp), %rdi
callq 0xbc00
jmp 0x38ca
leaq -0x50(%rbp), %rdi
callq 0x35c8
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3970
movb %al, -0x69(%rbp)
jmp 0x38e6
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x38ef
jmp 0x393c
movq -0x10(%rbp), %rsi
leaq 0x12a36(%rip), %rdi     # 0x16330
callq 0x3030
jmp 0x3901
movb $0x1, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x3953
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35c8
jmp 0x3967
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35c8
jmp 0x3967
leaq 0x129ed(%rip), %rdi     # 0x16330
callq 0x33b0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35c8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3500
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x398b
cmpl $0x7, -0xc(%rbp)
jle 0x39db
movl $0x10, %edi
callq 0x3170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0xc986(%rip), %rsi      # 0x1032c
callq 0x30f0
jmp 0x39ad
movq -0x28(%rbp), %rdi
movq 0x12638(%rip), %rsi     # 0x15ff0
movq 0x125f9(%rip), %rdx     # 0x15fb8
callq 0x34d0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3210
jmp 0x39fd
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x34a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc659(%rip), %rsi      # 0x10080
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
je 0x3af0
leaq 0xc643(%rip), %rdi      # 0x10084
callq 0x3360
cmpq $0x0, %rax
jne 0x3af0
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x3170
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3510
movq -0x48(%rbp), %rdx
leaq 0xc612(%rip), %rsi      # 0x1008c
leaq -0x28(%rbp), %rdi
callq 0xbb50
jmp 0x3a85
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbcd0
jmp 0x3a94
movq -0x50(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x122a5(%rip), %rsi     # 0x15d48
leaq 0x8266(%rip), %rdx      # 0xbd10
callq 0x34d0
jmp 0x3b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3ad4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35c8
leaq -0x29(%rbp), %rdi
callq 0x32f0
testb $0x1, -0x3d(%rbp)
jne 0x3ae5
jmp 0x3aee
movq -0x50(%rbp), %rdi
callq 0x3210
jmp 0x3b06
movq -0x8(%rbp), %rsi
leaq 0x12855(%rip), %rdi     # 0x16350
callq 0x3030
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3500
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x3400
movl %eax, -0xc(%rbp)
jmp 0x3b31
movl -0xc(%rbp), %eax
cmpl $-0x1, %eax
jne 0x3b66
movq 0x124a8(%rip), %rdi     # 0x15fe8
leaq 0xc561(%rip), %rsi      # 0x100a8
callq 0x3280
movq %rax, -0x20(%rbp)
jmp 0x3b52
movq -0x20(%rbp), %rdi
movq 0x12443(%rip), %rsi     # 0x15fa0
callq 0x32d0
jmp 0x3b64
jmp 0x3b66
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0xbd40
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x35c8
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x35c8
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xbd30
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, 0xc(%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0xc4ee(%rip), %rsi      # 0x100e4
leaq -0x28(%rbp), %rdi
callq 0xbb50
jmp 0x3c01
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3d00
jmp 0x3c10
leaq -0x28(%rbp), %rdi
callq 0x35c8
leaq -0x29(%rbp), %rdi
callq 0x32f0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3510
movq -0x80(%rbp), %rdx
leaq 0xc4b0(%rip), %rsi      # 0x100ea
leaq -0x60(%rbp), %rdi
callq 0xbb50
jmp 0x3c45
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3d00
jmp 0x3c54
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0x61(%rbp), %rdi
callq 0x32f0
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
leaq 0xcac2(%rip), %rsi      # 0x10737
callq 0x33e0
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
callq 0x33b0
movq -0x78(%rbp), %rdi
callq 0x3e10
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35c8
leaq -0x29(%rbp), %rdi
callq 0x32f0
jmp 0x3cf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0x61(%rbp), %rdi
callq 0x32f0
movq -0x38(%rbp), %rdi
callq 0x3500
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x8(%rax)
jne 0x3d2b
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3df3
movq -0x18(%rbp), %rsi
leaq 0xc574(%rip), %rdx      # 0x102aa
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xbc50
movq -0x58(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rsi
callq 0x3330
jmp 0x3d5d
leaq -0x38(%rbp), %rdi
callq 0x35c8
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x3340
movq -0x18(%rbp), %rdi
leaq 0xc52f(%rip), %rsi      # 0x102ac
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
je 0x3dba
movq -0x50(%rbp), %rax
movb $0x0, 0x9(%rax)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq %rax, -0x8(%rbp)
jmp 0x3df3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x3dfd
movq -0x18(%rbp), %rdi
leaq 0xcb5c(%rip), %rsi      # 0x10921
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
je 0x3deb
movq -0x50(%rbp), %rax
movb $0x1, 0x9(%rax)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq %rax, -0x8(%rbp)
jmp 0x3df3
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc16d(%rip), %rsi      # 0x100f0
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x3fef
movq -0x10(%rbp), %rdi
leaq 0xc15a(%rip), %rsi      # 0x100f7
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x3fef
movq -0x10(%rbp), %rdi
leaq 0xc14a(%rip), %rsi      # 0x10101
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x3fef
movq -0x10(%rbp), %rdi
leaq 0xc139(%rip), %rsi      # 0x1010a
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x3fef
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x33b0
jmp 0x4000
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rdi
callq 0x3030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x33d0
movq -0x218(%rbp), %rdi
leaq 0xc0c9(%rip), %rsi      # 0x1011c
callq 0x3280
movq %rax, -0x210(%rbp)
jmp 0x4061
movq -0x210(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3270
jmp 0x4073
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x32b0
jmp 0x4088
movq -0x220(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3d00
jmp 0x409d
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
leaq -0x1e1(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x3510
movq -0x228(%rbp), %rdx
leaq 0xc1e1(%rip), %rsi      # 0x102ab
leaq -0x1e0(%rbp), %rdi
callq 0xbb50
jmp 0x40d8
leaq -0x190(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3160
jmp 0x40ed
leaq -0x1e0(%rbp), %rdi
callq 0x35c8
leaq -0x1e1(%rbp), %rdi
callq 0x32f0
leaq 0xc01e(%rip), %rsi      # 0x1012a
leaq -0x190(%rbp), %rdi
callq 0x3280
movq %rax, -0x230(%rbp)
jmp 0x4121
movq -0x230(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3270
movq %rax, -0x238(%rbp)
jmp 0x413a
movq -0x238(%rbp), %rdi
leaq 0xc25d(%rip), %rsi      # 0x103a5
callq 0x3280
jmp 0x414f
leaq -0x208(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x32b0
jmp 0x4164
movq -0x220(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x3d00
movq %rax, -0x240(%rbp)
jmp 0x4180
leaq -0x208(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x240(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x423a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
jmp 0x423a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x420e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x35c8
leaq -0x1e1(%rbp), %rdi
callq 0x32f0
jmp 0x423a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x198(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xb7d7(%rip), %rsi      # 0x101ad
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x4aae
movq -0x18(%rbp), %rdi
leaq 0xbf45(%rip), %rsi      # 0x10939
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x4aae
movq -0x18(%rbp), %rdi
leaq 0xb78a(%rip), %rsi      # 0x1019c
xorl %eax, %eax
movl %eax, %edx
callq 0x35b0
cmpq $-0x1, %rax
jne 0x4aae
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3510
movq -0x80(%rbp), %rdx
leaq 0xb764(%rip), %rsi      # 0x101a1
leaq -0x38(%rbp), %rdi
callq 0xbb50
jmp 0x4a48
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3d00
movq %rax, -0x88(%rbp)
jmp 0x4a5e
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq -0x39(%rbp), %rdi
callq 0x32f0
jmp 0x4b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4aa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq -0x39(%rbp), %rdi
callq 0x32f0
jmp 0x4b1c
movq -0x18(%rbp), %rdx
leaq 0xb6f9(%rip), %rsi      # 0x101b2
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xbdd0
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3d00
movq %rax, -0x90(%rbp)
jmp 0x4ae2
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35c8
jmp 0x4b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35c8
jmp 0x4b1c
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x33d0
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x56dd
movq -0x1c8(%rbp), %rax
movb 0x9(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x56dd
leaq 0xab65(%rip), %rsi      # 0x1021b
leaq -0x190(%rbp), %rdi
callq 0x3280
jmp 0x56c4
jmp 0x56f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x5824
leaq 0xab39(%rip), %rsi      # 0x1021d
leaq -0x190(%rbp), %rdi
callq 0x3280
jmp 0x56f2
jmp 0x56f4
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x3270
jmp 0x5706
movq -0x18(%rbp), %rdi
callq 0x3490
testb $0x1, %al
jne 0x5715
jmp 0x572c
leaq 0xab1f(%rip), %rsi      # 0x1023b
leaq -0x190(%rbp), %rdi
callq 0x3280
jmp 0x572a
jmp 0x5778
leaq 0xab6e(%rip), %rsi      # 0x102a1
leaq -0x190(%rbp), %rdi
callq 0x3280
movq %rax, -0x1d0(%rbp)
jmp 0x5748
movq -0x1d0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3270
movq %rax, -0x1d8(%rbp)
jmp 0x5761
movq -0x1d8(%rbp), %rdi
leaq 0xac36(%rip), %rsi      # 0x103a5
callq 0x3280
jmp 0x5776
jmp 0x5778
leaq 0xaab5(%rip), %rsi      # 0x10234
leaq -0x190(%rbp), %rdi
callq 0x3280
movq %rax, -0x1e0(%rbp)
jmp 0x5794
movq -0x1e0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
addq $0x10, %rsi
callq 0x3270
jmp 0x57ad
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x32b0
jmp 0x57c2
movq -0x1c8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3d00
movq %rax, -0x1e8(%rbp)
jmp 0x57de
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x1e8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x198(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_equation3d(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_equation3d(const std::string &equation,
                                  const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == false)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "splot ";
    }

    cmdstr << equation << " title \"";

    if (title.empty())
    {
        cmdstr << "f(x,y) = " << equation;
    }
    else
    {
        cmdstr << title;
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x33d0
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x58bd
movq -0x1c8(%rbp), %rax
movb 0x9(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x58bd
leaq 0xa985(%rip), %rsi      # 0x1021b
leaq -0x190(%rbp), %rdi
callq 0x3280
jmp 0x58a4
jmp 0x58d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x5a01
leaq 0xa980(%rip), %rsi      # 0x10244
leaq -0x190(%rbp), %rdi
callq 0x3280
jmp 0x58d2
jmp 0x58d4
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x3270
movq %rax, -0x1d0(%rbp)
jmp 0x58ed
movq -0x1d0(%rbp), %rdi
leaq 0xa9a6(%rip), %rsi      # 0x102a1
callq 0x3280
jmp 0x5902
movq -0x18(%rbp), %rdi
callq 0x3490
testb $0x1, %al
jne 0x5911
jmp 0x5941
leaq 0xa933(%rip), %rsi      # 0x1024b
leaq -0x190(%rbp), %rdi
callq 0x3280
movq %rax, -0x1d8(%rbp)
jmp 0x592d
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3270
jmp 0x593f
jmp 0x5955
movq -0x18(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x3270
jmp 0x5953
jmp 0x5955
leaq 0xa8d7(%rip), %rsi      # 0x10233
leaq -0x190(%rbp), %rdi
callq 0x3280
movq %rax, -0x1e0(%rbp)
jmp 0x5971
movq -0x1e0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
addq $0x10, %rsi
callq 0x3270
jmp 0x598a
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x32b0
jmp 0x599f
movq -0x1c8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3d00
movq %rax, -0x1e8(%rbp)
jmp 0x59bb
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x1e8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x35c8
leaq -0x190(%rbp), %rdi
callq 0x3090
movq -0x198(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::remove_tmpfiles()
void Gnuplot::remove_tmpfiles(void)
{
    if ((tmpfile_list).size() > 0)
    {
        for (unsigned int i = 0U; i < tmpfile_list.size(); ++i)
        {

            if( remove( tmpfile_list[i].c_str() ) != 0 )
            {
                std::ostringstream except;
                except << "Cannot remove temporary file \"" << tmpfile_list[i] << "\"";
                throw GnuplotException(except.str());
            }
        }

        Gnuplot::tmpfile_num -= static_cast<int>(tmpfile_list.size());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
addq $0x50, %rdi
callq 0xc1e0
cmpq $0x0, %rax
jbe 0x7b95
movl $0x0, -0xc(%rbp)
movq -0x1c8(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x1d0(%rbp)
addq $0x50, %rdi
callq 0xc1e0
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
cmpq %rcx, %rax
jae 0x7b75
movq -0x1c8(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xc200
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3530
cmpl $0x0, %eax
je 0x7b65
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x33d0
movq -0x1e0(%rbp), %rdi
leaq 0x89dd(%rip), %rsi      # 0x1041d
callq 0x3280
movq %rax, -0x1d8(%rbp)
jmp 0x7a4e
movq -0x1c8(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xc200
movq -0x1d8(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
movq %rax, -0x1e8(%rbp)
jmp 0x7a7b
movq -0x1e8(%rbp), %rdi
leaq 0x891c(%rip), %rsi      # 0x103a5
callq 0x3280
jmp 0x7a90
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x3170
movq %rax, -0x1f0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x32b0
jmp 0x7abd
movq -0x1f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xbcd0
jmp 0x7ad2
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
leaq 0xe261(%rip), %rsi      # 0x15d48
leaq 0x4222(%rip), %rdx      # 0xbd10
callq 0x34d0
jmp 0x7baa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x7b57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x7b3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x35c8
testb $0x1, -0x1b9(%rbp)
jne 0x7b49
jmp 0x7b55
movq -0x1f0(%rbp), %rdi
callq 0x3210
jmp 0x7b57
leaq -0x188(%rbp), %rdi
callq 0x3090
jmp 0x7b9e
jmp 0x7b67
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x79c4
movq -0x1c8(%rbp), %rdi
addq $0x50, %rdi
callq 0xc1e0
movl %eax, %ecx
movl 0xe77f(%rip), %eax      # 0x1630c
subl %ecx, %eax
movl %eax, 0xe777(%rip)      # 0x1630c
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: orbitcowboy[P]gnuplot-cpp/example.cc
// Function: wait_for_key()
static void wait_for_key (void)
{
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)  // every keypress registered, also arrow keys
    std::cout << std::endl << "Press any key to continue..." << std::endl;

    FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE));
    (void)_getch();
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
    std::cout << std::endl << "Press ENTER to continue..." << std::endl;

    std::cin.clear();
    std::cin.ignore(std::cin.rdbuf()->in_avail());
    (void)std::cin.get();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa4f5(%rip), %rdi      # 0x15fc0
movq 0xa4ce(%rip), %rsi      # 0x15fa0
callq 0x32d0
movq %rax, %rdi
leaq 0x4e6a(%rip), %rsi      # 0x1094b
callq 0x3280
movq %rax, %rdi
movq 0xa4b0(%rip), %rsi      # 0x15fa0
callq 0x32d0
movq 0xa4d4(%rip), %rax      # 0x15fd0
movq (%rax), %rax
movq 0xa4ca(%rip), %rdi      # 0x15fd0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x34b0
movq 0xa4b8(%rip), %rax      # 0x15fd0
movq (%rax), %rax
movq 0xa4ae(%rip), %rdi      # 0x15fd0
addq -0x18(%rax), %rdi
callq 0x3140
movq %rax, %rdi
callq 0x3550
movq %rax, %rsi
movq 0xa493(%rip), %rdi      # 0x15fd0
callq 0x3050
movq 0xa487(%rip), %rdi      # 0x15fd0
callq 0x3350
popq %rbp
retq