LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::inormal()
inline point *poly::inormal( void ) {
  point *r;
  point o( 0.0, 0.0, 0.0 );
  
  r = new point(0.0,0.0,1.0);
  r->transform( toi );
  o.transform( toi );
  *r -= o;
  r->unitize();
  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x4c(%rsp), %r13
xorl %r15d, %r15d
movq %r15, (%r13)
movl $0x0, 0x8(%r13)
movl $0x20, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x7294(%rip), %rax      # 0xb848
movq %rax, (%rbx)
movl $0x3, 0x8(%rbx)
movq %r15, 0xc(%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%rbx)
addq $0xc0, %r14
movl 0x14(%rbx), %ecx
movq %rsp, %r12
movl %ecx, 0x8(%r12)
movq 0xc(%rbx), %rcx
movq %rcx, (%r12)
movl %eax, 0xc(%r12)
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
movss %xmm0, 0xc(%rbx,%r15,4)
incq %r15
cmpq $0x3, %r15
jne 0x45e9
movl 0x8(%r13), %eax
movq %rsp, %r15
movl %eax, 0x8(%r15)
movq (%r13), %rax
movq %rax, (%r15)
movl $0x3f800000, 0xc(%r15)  # imm = 0x3F800000
xorl %r12d, %r12d
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq *0x20(%rax)
movss %xmm0, 0x4c(%rsp,%r12,4)
incq %r12
cmpq $0x3, %r12
jne 0x4625
leaq 0xc(%rsp), %rax
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%rax)
movq (%r13), %rcx
movq %rcx, (%rax)
movl $0x3, %ecx
movaps 0x39dd(%rip), %xmm0     # 0x8040
movss (%rsp,%rcx,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rsp,%rcx,4)
incq %rcx
cmpq $0x6, %rcx
jne 0x4663
movl 0x8(%rax), %ecx
movl %ecx, 0x34(%rsp)
movq (%rax), %rax
movq %rax, 0x2c(%rsp)
movl $0x3, %eax
movss 0x20(%rsp,%rax,4), %xmm0
addss (%rbx,%rax,4), %xmm0
movss %xmm0, (%rbx,%rax,4)
incq %rax
cmpq $0x6, %rax
jne 0x468d
movq %rbx, %rdi
callq 0x33cc
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
ucomisd 0x39b3(%rip), %xmm1     # 0x8070
jbe 0x46e8
movss 0x3991(%rip), %xmm1     # 0x8058
divss %xmm0, %xmm1
movq (%rbx), %rax
movq %rbx, %rdi
movaps %xmm1, %xmm0
callq *0x70(%rax)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3aec(%rip), %rdi      # 0x81db
leaq 0x39b0(%rip), %rsi      # 0x80a6
leaq 0x3ae7(%rip), %rcx      # 0x81e4
movl $0xc9, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::set(int, point&)
inline poly & poly::set( int i, point & f ) {
  point **p = ref(i);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x48(%rax)
cmpq $0x0, (%rax)
jne 0x47ae
movq %rax, %r15
movl 0x1c(%rbx), %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0xe8(%rax)
testl %ebp, %ebp
je 0x475f
cmpl %eax, %ebp
je 0x4762
leaq 0x3ca3(%rip), %rdi      # 0x83ea
leaq 0x3b77(%rip), %rsi      # 0x82c5
leaq 0x3c6f(%rip), %rcx      # 0x83c4
movl $0xe0, %edx
callq 0x2080
movl %eax, 0x1c(%rbx)
movl $0x20, %edi
callq 0x20f0
movq %rax, %r12
leaq 0x70d2(%rip), %rax      # 0xb848
movq %rax, (%r12)
movslq 0x8(%r14), %rdx
movl %edx, 0x8(%r12)
testq %rdx, %rdx
jle 0x479f
addq $0xc, %r14
movq %r12, %rdi
addq $0xc, %rdi
shlq $0x2, %rdx
movq %r14, %rsi
callq 0x20a0
movq %r12, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c09(%rip), %rdi      # 0x83be
leaq 0x3b09(%rip), %rsi      # 0x82c5
leaq 0x3c01(%rip), %rcx      # 0x83c4
movl $0xde, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/poly.cc
// Function: poly::dilate(float)
inline void poly::dilate( float n ) {
  int i;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
jle 0x4861
xorl %r14d, %r14d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4856
movq (%rdi), %rax
callq *0xe0(%rax)
movl 0x18(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x483d
decl 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::xform(xform_types)
xform::xform( enum xform_types t ) {
  int i, j;

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

// Assembly:
pushq %rax
leaq 0x71ec(%rip), %rax      # 0xba60
movq %rax, (%rdi)
testl %esi, %esi
jne 0x48e2
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movdqa 0x3b6b(%rip), %xmm0     # 0x8400
movdqa 0x3b73(%rip), %xmm1     # 0x8410
movaps 0x3b7c(%rip), %xmm2     # 0x8420
movq %rcx, %xmm3
pshufd $0x44, %xmm3, %xmm3     # xmm3 = xmm3[0,1,0,1]
movdqa %xmm3, %xmm4
pcmpeqd %xmm0, %xmm4
pcmpeqd %xmm1, %xmm3
movdqa %xmm3, %xmm5
shufps $0xdd, %xmm4, %xmm5     # xmm5 = xmm5[1,3],xmm4[1,3]
shufps $0x88, %xmm4, %xmm3     # xmm3 = xmm3[0,2],xmm4[0,2]
andps %xmm5, %xmm3
andps %xmm2, %xmm3
movups %xmm3, -0x40(%rax)
movups %xmm3, (%rax)
incq %rcx
addq $0x10, %rax
cmpq $0x4, %rcx
jne 0x48a4
popq %rax
retq
leaq 0x3b57(%rip), %rdi      # 0x8440
leaq 0x3b64(%rip), %rsi      # 0x8454
leaq 0x3b66(%rip), %rcx      # 0x845d
movl $0xe, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::xform(xform const&)
xform::xform( const xform &t ) {
  int i, j;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6a91(%rip), %rax      # 0xb848
movq %rax, (%rdi)
movl $0x4, 0x8(%rdi)
movslq %edx, %r12
shlq $0x4, %r12
xorl %r15d, %r15d
movq 0x8(%r14), %rax
addq %r12, %rax
movss (%rax,%r15,4), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r15
cmpq $0x4, %r15
jne 0x4dcb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/xform.cc
// Function: xform::col(int)
inline point xform::col( int j ) {
  int i;
  point p(4);

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x63e4
cmpq $0x0, 0x78(%r14)
je 0x6403
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq 0x78(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r14
movl $0x80, %edi
callq 0x20f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6218
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2183(%rip), %rdi      # 0x856e
leaq 0x2188(%rip), %rsi      # 0x857a
leaq 0x2192(%rip), %rcx      # 0x858b
movl $0x1d, %edx
callq 0x2080
leaq 0x21b7(%rip), %rdi      # 0x85c1
leaq 0x2169(%rip), %rsi      # 0x857a
leaq 0x2173(%rip), %rcx      # 0x858b
movl $0x1e, %edx
callq 0x2080
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/board_texture.cc
// Function: board_texture::value(point&, point&, point&, model&, int)
inline point board_texture::value( point &at, point &gc, point &normal,
 model &m, int depth ) {
  int x = (int) floor( X( at ) );
  int y = (int) floor( Y( at ) );

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6833
movq (%r15), %rax
movq %r15, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r12d
movq (%r15), %rax
movq %r15, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6852
movq (%r15), %rax
movq %r15, %rdi
movl $0x1, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6871
movq (%r15), %rax
movq %r15, %rdi
movl $0x2, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl %ebp, 0x8(%rbx)
jle 0x6814
cmpl %ebp, 0x20(%rbx)
jne 0x6814
cmpl %r14d, 0x24(%rbx)
jne 0x6814
movl %eax, %r15d
incl %ebp
movl %ebp, 0x20(%rbx)
movzbl %r12b, %edi
movq 0x18(%rbx), %rsi
callq 0x2120
movzbl %r13b, %edi
movq 0x18(%rbx), %rsi
callq 0x2120
movzbl %r15b, %edi
movq 0x18(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
leaq 0x1e24(%rip), %rdi      # 0x863f
leaq 0x1f17(%rip), %rsi      # 0x8739
leaq 0x1e3a(%rip), %rcx      # 0x8663
movl $0x3b, %edx
callq 0x2080
leaq 0x1e5e(%rip), %rdi      # 0x8698
leaq 0x1865(%rip), %rsi      # 0x80a6
leaq 0x1e5b(%rip), %rcx      # 0x86a3
movl $0x118, %edx            # imm = 0x118
callq 0x2080
leaq 0x1e3f(%rip), %rdi      # 0x8698
leaq 0x1846(%rip), %rsi      # 0x80a6
leaq 0x1e4d(%rip), %rcx      # 0x86b4
movl $0x11d, %edx            # imm = 0x11D
callq 0x2080
leaq 0x1e20(%rip), %rdi      # 0x8698
leaq 0x1827(%rip), %rsi      # 0x80a6
leaq 0x1e3f(%rip), %rcx      # 0x86c5
movl $0x122, %edx            # imm = 0x122
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/ppm_output.cc
// Function: ppm_output::flushrow(int)
inline void ppm_output::flushrow( int y ) {
  assert( y < ysize && cury == y );
  cury++;
  curx = 0;
#if DEBUGLEVEL == 2
  if( !(y % 10) )
#endif
#if DEBUGLEVEL >= 2
    printf( "output row: %d\n", y );
#endif
}

// Assembly:
cmpl %esi, 0xc(%rdi)
jle 0x68a7
cmpl %esi, 0x24(%rdi)
jne 0x68a7
incl %esi
movl %esi, 0x24(%rdi)
movl $0x0, 0x20(%rdi)
retq
pushq %rax
leaq 0x1e27(%rip), %rdi      # 0x86d6
leaq 0x1e83(%rip), %rsi      # 0x8739
leaq 0x1e30(%rip), %rcx      # 0x86ed
movl $0x2a, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/oldppm_output.cc
// Function: oldppm_output::putpixel(int, int, point&)
inline void oldppm_output::putpixel( int x, int y, point &c ) {
  unsigned char r = gamma(R(c));
  unsigned char g = gamma(G(c));
  unsigned char b = gamma(B(c));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a56
movq (%r12), %rax
movq %r12, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r15d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a75
movq (%r12), %rax
movq %r12, %rdi
movl $0x1, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %r13d
movq (%r12), %rax
movq %r12, %rdi
callq *0xe8(%rax)
cmpl $0x2, %eax
jle 0x6a94
movq (%r12), %rax
movq %r12, %rdi
movl $0x2, %esi
callq *0x30(%rax)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl %ebp, 0x8(%rbx)
jle 0x6a37
cmpl %ebp, 0x20(%rbx)
jne 0x6a37
cmpl %r14d, 0x24(%rbx)
jne 0x6a37
movl %eax, %r12d
incl %ebp
movl %ebp, 0x20(%rbx)
movq 0x18(%rbx), %rdi
movzbl %r15b, %edx
leaq 0x1d84(%rip), %r14      # 0x877f
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x18(%rbx), %rdi
movzbl %r13b, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x18(%rbx), %rdi
movzbl %r12b, %edx
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
leaq 0x1c01(%rip), %rdi      # 0x863f
leaq 0x1cf1(%rip), %rsi      # 0x8736
leaq 0x1cfb(%rip), %rcx      # 0x8747
movl $0x24, %edx
callq 0x2080
leaq 0x1c3b(%rip), %rdi      # 0x8698
leaq 0x1642(%rip), %rsi      # 0x80a6
leaq 0x1c38(%rip), %rcx      # 0x86a3
movl $0x118, %edx            # imm = 0x118
callq 0x2080
leaq 0x1c1c(%rip), %rdi      # 0x8698
leaq 0x1623(%rip), %rsi      # 0x80a6
leaq 0x1c2a(%rip), %rcx      # 0x86b4
movl $0x11d, %edx            # imm = 0x11D
callq 0x2080
leaq 0x1bfd(%rip), %rdi      # 0x8698
leaq 0x1604(%rip), %rsi      # 0x80a6
leaq 0x1c1c(%rip), %rcx      # 0x86c5
movl $0x122, %edx            # imm = 0x122
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/oldppm_output.cc
// Function: oldppm_output::flushrow(int)
inline void oldppm_output::flushrow( int y ) {
  assert( y < ysize && cury == y );
  cury++;
  curx = 0;
#if DEBUGLEVEL == 2
  if( !(y % 10) )
#endif
#if DEBUGLEVEL >= 2
    printf( "output row: %d\n", y );
#endif
  fprintf( outfile, "\n" );
}

// Assembly:
cmpl %esi, 0xc(%rdi)
jle 0x6ad8
cmpl %esi, 0x24(%rdi)
jne 0x6ad8
incl %esi
movl %esi, 0x24(%rdi)
movl $0x0, 0x20(%rdi)
movq 0x18(%rdi), %rsi
movl $0xa, %edi
jmp 0x2120
pushq %rax
leaq 0x1bf6(%rip), %rdi      # 0x86d6
leaq 0x1c4f(%rip), %rsi      # 0x8736
leaq 0x1c96(%rip), %rcx      # 0x8784
movl $0x30, %edx
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O3/BartMassey[P]ancient-raytracer/frandom.c
// Function: fnurandom2
double fnurandom2( double centricity ) {
  double x = frandom() * 2;
  int sign = 1;

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

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x2060
movq %rax, %rcx
shrq $0x3, %rcx
movabsq $0xa7c53e53e3eeb47, %rdx # imm = 0xA7C53E53E3EEB47
movq %rcx, %rax
mulq %rdx
shrq $0xc, %rdx
imulq $0x186a1, %rdx, %rax    # imm = 0x186A1
subq %rax, %rcx
movsd 0x801(%rip), %xmm0      # 0x85e0
movapd %xmm0, %xmm1
cmpq $0x186a0, %rcx          # imm = 0x186A0
jae 0x7df0
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm1
movapd %xmm1, %xmm2
movapd %xmm1, 0x10(%rsp)
movsd 0xafa(%rip), %xmm1      # 0x8900
addsd %xmm2, %xmm1
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movapd %xmm3, %xmm2
subsd 0x8(%rsp), %xmm2
movapd %xmm3, %xmm1
divsd %xmm2, %xmm1
callq 0x2190
movapd 0x10(%rsp), %xmm1
ucomisd 0x79c(%rip), %xmm1      # 0x85e0
jbe 0x7e4e
xorpd 0xac2(%rip), %xmm0      # 0x8910
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/aes_upload.cpp
// Function: rsa_encrypt(char*, unsigned char*, int, unsigned char*, unsigned int&)
int rsa_encrypt(char *public_key_filename, unsigned char *data, int data_len, unsigned char *encrypted, unsigned int &encrypted_length)
{
	unsigned char *pubkey = NULL;
	unsigned int size;

	pubkey = (unsigned char *)get_file(public_key_filename, &size);
	if (pubkey == NULL)
	{
		printf("Failed to open public key\r\n");
		return -1;
	}

	if (data_len > 245)
	{
		printf("Cannot encrypt more than 245 bytes with RSA 2048 bit key\r\n");
		delete [] pubkey;
		return -1;
	}

	RSA *rsa = createRSA(pubkey, true);
	encrypted_length = RSA_public_encrypt(data_len, data, encrypted, rsa, RSA_PKCS1_PADDING);
	if (encrypted_length == -1)
	{
		char err[130];

		ERR_load_crypto_strings();
		ERR_error_string(ERR_get_error(), err);
		printf("ERROR: %s\n", err);
		delete [] pubkey;
		return -1;
	}
	RSA_free(rsa);
	delete [] pubkey;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movl %edx, %r13d
movq %rsi, %r12
leaq -0x2c(%rbp), %rsi
callq 0x24c1
testq %rax, %rax
je 0x2647
movq %rax, %rbx
cmpl $0xf6, %r13d
jl 0x2655
leaq 0xb33(%rip), %rdi       # 0x3170
callq 0x22a0
jmp 0x26cc
leaq 0xb5c(%rip), %rdi       # 0x31aa
callq 0x22a0
jmp 0x26d4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2573
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r15
movq %rax, %rcx
movl $0x1, %r8d
callq 0x2190
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x2698
movq %r15, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2260
xorl %eax, %eax
jmp 0x26d9
movl $0x2, %edi
xorl %esi, %esi
callq 0x2110
callq 0x2270
leaq -0xb0(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
leaq 0x978(%rip), %rdi       # 0x303a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2260
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/aes_upload.cpp
// Function: aes_encrypt(unsigned char*, unsigned char*, unsigned char*, int, unsigned char*&, unsigned int&)
int aes_encrypt(unsigned char *key, unsigned char *iv, unsigned char *data, int data_size, unsigned char *&ciphertext, unsigned int &ciphertext_len)
{
	ciphertext = (unsigned char *)malloc( (data_size / 16 + 1) * 16 );
	if (ciphertext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	printf("Using key %s iv %s\r\n", key, iv);

	ciphertext_len = encrypt(data, data_size, key, iv, ciphertext);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r13
movl %ecx, %r15d
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
leal 0xf(%r15), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movq %rdi, %rbx
andl $-0x10, %eax
addl $0x10, %eax
movslq %eax, %rdi
callq 0x2280
movq %rax, (%r13)
testq %rax, %rax
je 0x2831
leaq 0x85a(%rip), %rdi       # 0x3053
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq (%r13), %r8
movq -0x30(%rbp), %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2703
movl %eax, (%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80d(%rip), %rdi       # 0x3045
callq 0x21c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2822
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/aes_upload.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;

	if (argc < 5)
	{
		printf("Usage: aes_upload filename port key iv public_key\r\n");
		printf("Example: aes_upload file.tgz 65535 01234567890123456789012345678901 0123456789012345 id_rsa.openssl.pub\r\n");
		return 0;
	}

	port = atoi(argv[2]);
	unsigned char *key = (unsigned char *)argv[3];
	unsigned char *iv = (unsigned char *)argv[4];
	unsigned char *pubkey = (unsigned char *)argv[5];

	printf("Attempting to upload %s to client connecting on port %d\r\n", argv[1], (int)port);
	aes_file_upload(argv[1], port, key, iv, pubkey);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jg 0x2c4d
leaq 0x603(%rip), %rdi       # 0x323d
callq 0x22a0
leaq 0x62a(%rip), %rdi       # 0x3270
callq 0x22a0
jmp 0x2c93
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x22b0
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movzwl %ax, %r13d
leaq 0x4c2(%rip), %rdi       # 0x3136
movl %r13d, %edx
xorl %eax, %eax
callq 0x2050
movq 0x8(%rbx), %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x2844
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/inits.cc
// Function: main
int main() {

	int v1(1024);    // direct-initialization, functional form
	int v2{1024};    // direct-initialization, list initializer form
	int v3 = 1024;   // copy-initialization
	int v4 = {1024}; // copy-initialization, list initializer form


	// alternative ways to initialize string from a character string literal
	std::string titleA = "C++ Primer, 5th Ed.";
	std::string titleB("C++ Primer, 5th Ed.");
	std::string all_nines(10, '9');  // all_nines = "9999999999"

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xb29(%rip), %rbx       # 0x2006
leaq 0xb35(%rip), %r14       # 0x2019
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x164c
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x164c
leaq -0x70(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x80(%rbp), %rdi
movl $0xa, %esi
movl $0x39, %edx
callq 0x10a0
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x153b
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x1080
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1550
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x1565
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1080
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1591
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
jmp 0x1591
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x15a6
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30_main.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	TextQuery tq(infile);

	while (true) {
		cout << "enter word to look for, or q to quite: ";
		string s;

		if (!(cin >> s) || s == "q")
			break;
		print(cout, tq.query(s)) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x2868
leaq -0x38(%rbp), %r15
movq 0x4b4e(%rip), %r14      # 0x6fc8
leaq -0x48(%rbp), %r13
leaq -0x88(%rbp), %rbx
movq %rbx, %r12
movl $0x27, %edx
movq %r14, %rdi
leaq 0x1b6d(%rip), %rsi      # 0x4004
callq 0x21d0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x4b25(%rip), %rdi      # 0x6fd8
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x24d0
xorl %ebx, %ebx
jmp 0x2564
movq %r13, %rdi
leaq 0x1b52(%rip), %rsi      # 0x402c
callq 0x2080
testl %eax, %eax
je 0x24c9
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movq %r13, %rdx
callq 0x2bda
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2efc
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2538
callq 0x2748
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2546
callq 0x2748
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2562
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2579
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
movq %r12, %rbx
jne 0x2488
leaq -0xb8(%rbp), %rbx
movq %rbx, %rdi
callq 0x27c2
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x25a1
callq 0x2748
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25cb
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x26d4
jmp 0x25ce
movq %rax, %rbx
jmp 0x25e3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x25e3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0xc8(%rbp), %rdi
callq 0x271e
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	ifstream infile;

	// Test data CH12_DynamicMemory/examples/data/storyDataFile
	if (argc < 2 || !(infile.open(argv[1]), infile)) {
		cerr << "No input file!" << endl;
		return EXIT_FAILURE;
	}
	runQueries(infile);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x218(%rbp), %rdi
callq 0x21c0
cmpl $0x2, %r14d
jl 0x2647
movq 0x8(%rbx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x20d0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x26ac
movq 0x49a2(%rip), %rbx      # 0x6ff0
leaq 0x19d9(%rip), %rsi      # 0x402e
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0x4970(%rip), %rdi      # 0x6ff0
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2110
leaq -0x218(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x218(%rbp), %rdi
callq 0x244c
jmp 0x2692
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: TextQuery::clean_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string TextQuery::clean_str(const string& word)
{
	string ret;
	for (auto it = word.begin(); it != word.end(); ++it) {
		if (!ispunct(*it))
			ret += tolower(*it);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x2ba0
movq %rsi, %r14
movq (%rsi), %rbx
movq %rbx, %r13
movsbl (%r13), %r15d
movl %r15d, %edi
callq 0x22c0
testl %eax, %eax
jne 0x2b94
movl %r15d, %edi
callq 0x2220
movsbl %al, %esi
movq -0x30(%rbp), %rdi
callq 0x2160
movq (%r14), %rbx
movq 0x8(%r14), %r12
incq %r13
leaq (%rbx,%r12), %rax
cmpq %rax, %r13
jne 0x2b68
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x2bd2
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
		<< "time(s)" << endl;

	for (auto num : *qr.lines) {
		os << "\t(line " << num + 1 << ") "
			<< qr.file->at(num) << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x21d0
movq %rax, %r15
leaq 0x1117(%rip), %rsi      # 0x403d
movl $0x8, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x20(%r14), %rax
movq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %r15
leaq 0x110a(%rip), %rsi      # 0x4057
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
leaq 0x10e5(%rip), %rsi      # 0x4046
movl $0x7, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r14, -0x30(%rbp)
movq 0x20(%r14), %r14
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x3058
movq 0x20(%r15), %r12
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x108d(%rip), %rsi      # 0x404e
callq 0x21d0
leaq 0x1(%r12), %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1071(%rip), %rsi      # 0x4056
callq 0x21d0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r12, %rdx
jbe 0x306a
shlq $0x5, %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r13, %rdi
callq 0x21d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
cmpq %r14, %rax
jne 0x2fae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x103c(%rip), %rdi      # 0x40ad
movq %r12, %rsi
xorl %eax, %eax
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: TextQuery::display_map()
void TextQuery::display_map()
{
	// auto iter = wm.cbegin();
	// auto iter_end = wm.cend();

	for (auto iter = wm.cbegin(); iter != wm.cend(); ++iter) {
		cout << "word: " << iter->first << " {";

		// auto text_locs = iter->second;
		// auto loc_iter = text_locs->cbeing()

		for (auto loc_iter = iter->second->cbegin();
			loc_iter != iter->second->cend(); ++loc_iter) {

			cout << *loc_iter << ", ";
		}

		cout << "}\n";

	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
addq $0x18, %rbx
cmpq %rbx, %r14
je 0x314b
movq 0x3f23(%rip), %r15      # 0x6fc8
leaq 0xfb7(%rip), %r13       # 0x4063
movl $0x6, %edx
movq %r15, %rdi
leaq 0xf9e(%rip), %rsi       # 0x4059
callq 0x21d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x21d0
movl $0x2, %edx
movq %rax, %rdi
leaq 0xf81(%rip), %rsi       # 0x4060
callq 0x21d0
movq 0x40(%r14), %rax
movq 0x18(%rax), %r12
addq $0x8, %rax
cmpq %rax, %r12
je 0x3123
movq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x2100
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
movq 0x40(%r14), %rax
jmp 0x30ec
movl $0x2, %edx
movq %r15, %rdi
leaq 0xf34(%rip), %rsi       # 0x4066
callq 0x21d0
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x30ac
movq 0x3e76(%rip), %rbx      # 0x6fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::~time_wheel()
time_wheel::~time_wheel() {
    // 遍历每一个槽，并销毁其中的定时器
    for(int i = 0; i < N; ++i) {
        tw_timer* tmp = slots[i];
        while(tmp) {
            slots[i] = tmp->next;
            delete tmp;
            tmp = slots[i];
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x3e47
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rbx,%r14,8)
movl $0x28, %esi
callq 0x33a0
jmp 0x3e28
incq %r14
cmpq $0x3c, %r14
jne 0x3e28
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::add_timer(tw_timer*, int)
void time_wheel::add_timer(tw_timer* timer, int timesolt) {
    if (timesolt < 0) {
        return;
    }

    int ticks = 0;
    /* 根据插入定时器的超时值计算它将在时间轮转动多少个滴答后被触发，并将
    该滴答数存于变量 ticks 中 */
    if (timesolt < SI) {
        ticks = 1;
    } else {
        ticks = timesolt / SI;
    }

    int rotation  = ticks / N; // 计算圈数
    int ts = (cur_slot + (ticks % N)) % N; // 计算待插入定时器的槽位

    timer->ratation = rotation;
    timer->time_slot = ts;

    // 插入合适的位置
    // 圈数大的放在最前面，即链表的前端
    if(!slots[ts]) {    // 头节点
        slots[ts] = timer;
    } else {    // 非头节点   
        timer->next = slots[ts];
        slots[ts]->prev = timer;
        slots[ts] = timer;
    }
}

// Assembly:
testl %edx, %edx
js 0x3ebc
cmpl $0x1, %edx
adcl $0x0, %edx
movl $0x88888889, %eax       # imm = 0x88888889
imulq %rdx, %rax
shrq $0x25, %rax
imull $0x3c, %eax, %ecx
subl %ecx, %edx
addl (%rdi), %edx
movslq %edx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %edx
addl %r8d, %edx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movslq %ecx, %rax
movq 0x8(%rdi,%rax,8), %rcx
testq %rcx, %rcx
je 0x3eb7
movq %rcx, 0x18(%rsi)
movq 0x8(%rdi,%rax,8), %rcx
movq %rsi, 0x20(%rcx)
movq %rsi, 0x8(%rdi,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::del_timer(tw_timer*)
void time_wheel::del_timer(tw_timer* timer) {
    if(!timer) {
        return;
    } 
    int ts = timer->time_slot;
    // 如果是头节点
    if(slots[ts] == timer) {
        slots[ts] = slots[ts]->next;
        if(slots[ts]) {
            slots[ts]->prev = NULL;
        }
        delete timer;
    } else {
        timer->prev->next = timer->next;
        if(timer->next) {
            timer->next->prev = timer->prev;
        }
        delete timer;
    }
}

// Assembly:
testq %rsi, %rsi
je 0x3ee7
movq %rsi, %rax
movslq 0x4(%rsi), %rdx
movq 0x8(%rdi,%rdx,8), %rcx
cmpq %rsi, %rcx
je 0x3ee8
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq %rcx, 0x18(%rdx)
testq %rcx, %rcx
jne 0x3ef8
jmp 0x3efc
retq
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rdi,%rdx,8)
testq %rcx, %rcx
je 0x3efc
xorl %edx, %edx
movq %rdx, 0x20(%rcx)
movl $0x28, %esi
movq %rax, %rdi
jmp 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::adjust_timer(tw_timer*, int)
void time_wheel::adjust_timer(tw_timer* timer,int timeslot) {
    if(!timer) {
        return;
    }
    // 先断开原位置的联系
    // 头节点
    /*
    if(timer == slots[timer->time_slot]) {
        slots[timer->time_slot] = slots[timer->time_slot]->next;
        slots[timer->time_slot]->prev = NULL;
        timer->next = NULL;
        //add_timer(timer,slots[timer->time_slot]);
    } else if(!timer->next) {  // 尾节点
        timer->prev->next = NULL;
        timer->prev = NULL;
    } else { // 中间节点
        timer->prev->next = timer->next;
        timer->next->prev = timer->prev;
        //add_timer(timer,slots[timer->time_slot]->next);
    } */
    int ts = timer->time_slot;
    // 如果是头节点
    if(slots[ts] == timer) {
        slots[ts] = slots[ts]->next;
        if(slots[ts]) {
            slots[ts]->prev = NULL;
        }
        timer->prev = NULL;
        timer->next = NULL;
    } else {
        timer->prev->next = timer->next;
        if(timer->next) {
            timer->next->prev = timer->prev;
        }
        timer->prev = NULL;
        timer->next = NULL;
    }
    // 调整新的圈数和槽位
    //timer->ratation += timeslot / SI / N;
    //timer->time_slot = (cur_slot + (timeslot / SI % N)) % N;
    
    // 添加到新的位置
    add_timer(timer,timeslot); 
}

// Assembly:
testq %rsi, %rsi
je 0x3fc0
movslq 0x4(%rsi), %rax
movq 0x8(%rdi,%rax,8), %rcx
cmpq %rsi, %rcx
je 0x3f3c
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %r8
movq %rcx, 0x18(%r8)
testq %rcx, %rcx
je 0x3f56
movq %r8, 0x20(%rcx)
jmp 0x3f56
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rdi,%rax,8)
testq %rcx, %rcx
je 0x3f52
movq $0x0, 0x20(%rcx)
leaq 0x18(%rsi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testl %edx, %edx
js 0x3fc0
cmpl $0x1, %edx
adcl $0x0, %edx
movl $0x88888889, %eax       # imm = 0x88888889
imulq %rdx, %rax
shrq $0x25, %rax
imull $0x3c, %eax, %ecx
subl %ecx, %edx
addl (%rdi), %edx
movslq %edx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %edx
addl %r8d, %edx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movslq %ecx, %rax
movq 0x8(%rdi,%rax,8), %rcx
testq %rcx, %rcx
je 0x3fbb
movq %rcx, 0x18(%rsi)
movq 0x8(%rdi,%rax,8), %rcx
movq %rsi, 0x20(%rcx)
movq %rsi, 0x8(%rdi,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::tick()
void time_wheel::tick() {
    tw_timer* tmp = slots[cur_slot]; // 取得时间轮上当前槽的头节点
    while(tmp) {
        // 将当前槽位上的定时器链表遍历一遍，对它们的圈数标记-1，表示新的一轮计时开始；
        if(tmp->ratation > 0) {
            tmp->ratation--;
            tmp = tmp->next;
        } else {
        // 说明定时器到期，执行定时任务，然后删除定时器
            tmp->cb_func(tmp->user_data);
            if(tmp == slots[cur_slot]) {
                slots[cur_slot] = tmp->next;
                delete tmp;
                if(slots[cur_slot]) {
                    slots[cur_slot]->prev = NULL;
                }
                tmp = slots[cur_slot];
            } else {
                tmp->prev->next = tmp->next;
                if(tmp->next) {
                    tmp->next->prev = tmp->prev;
                }
                tw_timer* tmp2 = tmp->next;
                delete tmp;
                tmp = tmp2;
            }
        }
    }
    cur_slot = ++cur_slot % N; // 更新时间轮的当前槽，以反映时间轮的转动
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
movq 0x8(%rdi,%rax,8), %r14
testq %r14, %r14
je 0x4055
movl (%r14), %eax
testl %eax, %eax
jle 0x3fe9
decl %eax
movl %eax, (%r14)
movq 0x18(%r14), %r15
jmp 0x404b
movq 0x10(%r14), %rdi
callq *0x8(%r14)
movslq (%rbx), %rax
movq 0x18(%r14), %r15
cmpq 0x8(%rbx,%rax,8), %r14
je 0x401f
movq 0x20(%r14), %rax
movq %r15, 0x18(%rax)
testq %r15, %r15
je 0x4010
movq %rax, 0x20(%r15)
movl $0x28, %esi
movq %r14, %rdi
callq 0x33a0
jmp 0x404b
movq %r15, 0x8(%rbx,%rax,8)
movl $0x28, %esi
movq %r14, %rdi
callq 0x33a0
movslq (%rbx), %rax
movq 0x8(%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x4053
movq $0x0, 0x20(%rcx)
movq 0x8(%rbx,%rax,8), %r15
movq %r15, %r14
testq %r15, %r15
jne 0x3fd7
movl (%rbx), %eax
movl %eax, %ecx
incl %ecx
movslq %ecx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %edx, %eax
incl %eax
movl %eax, %edx
shrl $0x1f, %edx
sarl $0x5, %eax
addl %edx, %eax
imull $0x3c, %eax, %eax
subl %eax, %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: Utils::addfd(int, int, bool, int)
void Utils::addfd(int epollfd, int fd, bool one_shot, int TRIGMode)
{
    epoll_event event;
    event.data.fd = fd;

    if (1 == TRIGMode)
        event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
    else
        event.events = EPOLLIN | EPOLLRDHUP;

    if (one_shot)
        event.events |= EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %edi
leaq 0x4(%rsp), %rax
movl %edx, 0x4(%rax)
xorl %edx, %edx
cmpl $0x1, %r8d
setne %dl
shll $0x1f, %edx
shll $0x1e, %ecx
addl %edx, %ecx
addl $0x80002001, %ecx       # imm = 0x80002001
movl %ecx, (%rax)
movl $0x1, %esi
movl %ebx, %edx
movq %rax, %rcx
callq 0x34e0
movl %ebx, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x3240
orl $0x800, %eax            # imm = 0x800
movl %ebx, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3240
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: Utils::sig_handler(int)
void Utils::sig_handler(int sig)
{
    //为保证函数的可重入性，保留原来的errno
    int save_errno = errno;
    int msg = sig;
    send(u_pipefd[1], (char *)&msg, 1, 0);
    errno = save_errno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
callq 0x3050
movq %rax, %r14
movl (%rax), %ebp
leaq 0xc(%rsp), %rsi
movl %ebx, (%rsi)
movq 0x9296(%rip), %rax      # 0xd3d8
movl 0x4(%rax), %edi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x31b0
movl %ebp, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: Utils::addsig(int, void (*)(int), bool)
void Utils::addsig(int sig, void(handler)(int), bool restart)
{
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = handler;
    if (restart)
        sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
leaq 0x8(%rsp), %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3220
movq %r14, -0x8(%r15)
testl %ebp, %ebp
je 0x4199
movl $0x10000000, 0x88(%rsp) # imm = 0x10000000
leaq 0x8(%rsp), %rdi
callq 0x30f0
movq %rsp, %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x3490
cmpl $-0x1, %eax
je 0x41c2
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e73(%rip), %rdi      # 0x903c
leaq 0x4e8c(%rip), %rsi      # 0x905c
leaq 0x4e9f(%rip), %rcx      # 0x9076
movl $0xed, %edx
callq 0x3290
nop