LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::max()
T& max() {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "max(): Empty instance.",
                                    cimg_instance);
      T *ptr_max = _data;
      T max_value = *ptr_max;
      cimg_for(*this,ptrs,T) if (*ptrs>max_value) max_value = *(ptr_max=ptrs);
      return *ptr_max;
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x10320
testb $0x1, %al
jne 0xbfdaa
jmp 0xbfe8d
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x28(%rsp)
movl (%rax), %ecx
movl %ecx, 0x30(%rsp)
movl 0x4(%rax), %ecx
movl %ecx, 0x34(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x38(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rsp)
movb 0x10(%rax), %dl
leaq 0x28be3(%rip), %rcx     # 0xe89d2
leaq 0x9ceb(%rip), %rax      # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x118f0
movq %rax, 0x50(%rsp)
jmp 0xbfe0e
movl 0x3c(%rsp), %r9d
movl 0x38(%rsp), %r8d
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %r10
movq 0x50(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x2c36a(%rip), %rsi     # 0xec1b3
xorl %eax, %eax
callq 0x11fd0
jmp 0xbfe52
movq 0x28(%rsp), %rdi
leaq 0x3fcea(%rip), %rsi     # 0xffb48
leaq -0xadc55(%rip), %rdx    # 0x12210
callq 0x5920
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x53a0
jmp 0xbff25
movq 0x58(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x68(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
callq 0x117b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0xbff18
movq 0x68(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x70(%rsp), %xmm0
jbe 0xbff06
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0xbff08
movq 0x68(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x68(%rsp)
jmp 0xbfed5
movq 0x78(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Detail::operator>>(std::istream&, VL::Detail::_cmnt&)
std::istream& 
operator>>(std::istream& is, _cmnt& manip)
{
  char c ;
  char b [1024] ; 
  is>>c ;
  if( c != '#' ) 
    return is.putback(c) ;
  is.getline(b,1024) ;
  return is ;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x418(%rsp)
movq %rsi, 0x410(%rsp)
movq 0x418(%rsp), %rdi
leaq 0x40f(%rsp), %rsi
callq 0x5690
movsbl 0x40f(%rsp), %eax
cmpl $0x23, %eax
je 0xbff98
movq 0x418(%rsp), %rdi
movsbl 0x40f(%rsp), %esi
callq 0x5a40
movq %rax, 0x420(%rsp)
jmp 0xbffbd
movq 0x418(%rsp), %rdi
movq %rsp, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x5160
movq 0x418(%rsp), %rax
movq %rax, 0x420(%rsp)
movq 0x420(%rsp), %rax
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::insertPgm(std::ostream&, float const*, int, int)
std::ostream& 
insertPgm(std::ostream& os, pixel_t const* im, int width, int height)
{
  os<< "P5"   << "\n"
    << width  << " "
    << height << "\n"
    << "255"  << "\n" ;
  for(int y = 0 ; y < height ; ++y) {
    for(int x = 0 ; x < width ; ++x) {
      unsigned char v = 
        (unsigned char)
        (std::max(std::min(*im++, 1.0f),0.f) * 255.0f) ;
      os << v ;
    }
  }
  return os ;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2d4f6(%rip), %rsi     # 0xed4e8
callq 0x5520
movq %rax, %rdi
leaq 0x289d0(%rip), %rsi     # 0xe89d1
callq 0x5520
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x5940
movq %rax, %rdi
leaq 0x2b8b3(%rip), %rsi     # 0xeb8cf
callq 0x5520
movq %rax, %rdi
movl 0x20(%rsp), %esi
callq 0x5940
movq %rax, %rdi
leaq 0x2899a(%rip), %rsi     # 0xe89d1
callq 0x5520
movq %rax, %rdi
leaq 0x2d4a5(%rip), %rsi     # 0xed4eb
callq 0x5520
movq %rax, %rdi
leaq 0x2897c(%rip), %rsi     # 0xe89d1
callq 0x5520
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xc0100
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xc00ee
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movl $0x3f800000, 0x10(%rsp) # imm = 0x3F800000
leaq 0x10(%rsp), %rsi
callq 0xc5800
movq %rax, %rdi
movl $0x0, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0xc57c0
movss (%rax), %xmm0
movss 0x806e(%rip), %xmm1     # 0xc8134
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movzbl 0x17(%rsp), %esi
callq 0x5810
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xc0078
jmp 0xc00f0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc0062
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Detail::copyAndUpsampleRows(float*, float const*, int, int)
void 
copyAndUpsampleRows
(pixel_t* dst, pixel_t const* src, int width, int height)
{
  for(int y = 0 ; y < height ; ++y) {
    pixel_t b, a ;
    b = a = *src++ ;
    for(int x = 0 ; x < width-1 ; ++x) {
      b = *src++ ;
      *dst = a ;         dst += height ;
      *dst = 0.5*(a+b) ; dst += height ;
      a = b ;
    }
    *dst = b ; dst += height ;
    *dst = b ; dst += height ;
    dst += 1 - width * 2 * height ;
  }  
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0xc0fe7
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movss (%rax), %xmm0
movss %xmm0, -0x24(%rsp)
movss %xmm0, -0x20(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc0f63
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movss (%rax), %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x24(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x24(%rsp), %xmm0
addss -0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x712a(%rip), %xmm0     # 0xc8048
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x20(%rsp), %xmm0
movss %xmm0, -0x24(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0xc0eb1
movss -0x20(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x20(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0x14(%rsp), %eax
shll %eax
imull -0x18(%rsp), %eax
movl $0x1, %ecx
subl %eax, %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xc0e7a
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Detail::copyAndDownsample(float*, float const*, int, int, int)
void 
copyAndDownsample(pixel_t* dst, pixel_t const* src, 
                  int width, int height, int d)
{
  if(width < d || height < d)
    throw std::string("in siftpp: image too small");

  for(int y = 0 ; y < height ; y+=d) {
    pixel_t const * srcrowp = src + y * width ;    
    for(int x = 0 ; x < width - (d-1) ; x+=d) {     
      *dst++ = *srcrowp ;
      srcrowp += d ;
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jl 0xc1023
movl 0x50(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xc10b5
movb $0x1, 0x3b(%rsp)
movl $0x20, %edi
callq 0x5240
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5980
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2c534(%rip), %rsi     # 0xed590
callq 0x56d0
jmp 0xc1063
movq 0x8(%rsp), %rdi
movb $0x0, 0x3b(%rsp)
leaq 0x3eaac(%rip), %rsi     # 0xffb20
movq 0x3ef2d(%rip), %rdx     # 0xfffa8
callq 0x5920
jmp 0xc116b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0x5590
testb $0x1, 0x3b(%rsp)
jne 0xc10a6
jmp 0xc10b0
movq 0x8(%rsp), %rdi
callq 0x53a0
jmp 0xc1161
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0xc115c
movq 0x58(%rsp), %rax
movl 0x34(%rsp), %ecx
imull 0x54(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl 0x54(%rsp), %ecx
movl 0x4c(%rsp), %edx
subl $0x1, %edx
subl %edx, %ecx
cmpl %ecx, %eax
jge 0xc1149
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
movq 0x60(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x60(%rsp)
movss %xmm0, (%rax)
movl 0x4c(%rsp), %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x4c(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xc10f0
jmp 0xc114b
movl 0x4c(%rsp), %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xc10bd
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5970
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Sift::smooth(float*, float*, float const*, int, int, float)
void
Sift::smooth
(pixel_t* dst, pixel_t* temp, 
 pixel_t const* src, int width, int height, 
 VL::float_t s)
{
  // make sure a buffer larege enough has been allocated
  // to hold the filter
  int W = int( ceil( VL::float_t(4.0) * s ) ) ;
  if( ! filter ) {
    filterReserved = 0 ;
  }
  
  if( filterReserved < W ) {
    filterReserved = W ;
    if( filter ) delete [] filter ;
    filter = new pixel_t [ 2* filterReserved + 1 ] ;
  }
  
  // pre-compute filter
  for(int j = 0 ; j < 2*W+1 ; ++j) 
    filter[j] = VL::pixel_t
      (std::exp
       (VL::float_t
        (-0.5 * (j-W) * (j-W) / (s*s) ))) ;
  
  // normalize to one
  normalize(filter, W) ;
  
  // convolve
  econvolve(temp, src, width, height, filter, W) ;
  econvolve(dst, temp, height, width, filter, W) ;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0x6fa2(%rip), %xmm0     # 0xc814c
mulss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x5080
movq 0x8(%rsp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x18(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0xc11d9
movq 0x8(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movl 0x58(%rax), %eax
cmpl 0x18(%rsp), %eax
jge 0xc1254
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, 0x58(%rax)
cmpq $0x0, 0x50(%rax)
je 0xc1218
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc1216
movq (%rsp), %rdi
callq 0x5680
jmp 0xc1218
movq 0x8(%rsp), %rax
movl 0x58(%rax), %eax
shll %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x18(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc12d2
movl 0x14(%rsp), %eax
subl 0x18(%rsp), %eax
cvtsi2sd %eax, %xmm1
movsd 0x2c1ef(%rip), %xmm0    # 0xed470
mulsd %xmm1, %xmm0
movl 0x14(%rsp), %eax
subl 0x18(%rsp), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movss 0x1c(%rsp), %xmm1
mulss 0x1c(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xc5890
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x14(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc125c
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movl 0x18(%rsp), %esi
callq 0xc58b0
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movq 0x50(%rax), %r8
movl 0x18(%rsp), %r9d
callq 0xc5960
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x20(%rsp), %edx
movl 0x24(%rsp), %ecx
movq 0x50(%rax), %r8
movl 0x18(%rsp), %r9d
callq 0xc5960
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Detail::normalize_histogram(float*, float*)
void
normalize_histogram(VL::float_t* L_begin, VL::float_t* L_end)
{
  VL::float_t* L_iter ;
  VL::float_t norm = 0.0 ;

  for(L_iter = L_begin; L_iter != L_end ; ++L_iter)
    norm += (*L_iter) * (*L_iter) ;

  norm = fast_sqrt(norm) ;

  for(L_iter = L_begin; L_iter != L_end ; ++L_iter)
    *L_iter /= (norm + std::numeric_limits<VL::float_t>::epsilon() ) ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xc4cf3
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rax
movss (%rax), %xmm2
movss 0xc(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0xc4cb1
movss 0xc(%rsp), %xmm0
callq 0xc62f0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xc4d56
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
callq 0xc6490
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0xc4d0e
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/KmerHash.cc
// Function: KmerHash::calculateHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
unsigned int KmerHash::calculateHash(const string& Kmer, unsigned int KmerSize) {
	assert (KmerSize <= Kmer.size() );
	
	//Clear hashVal
	hashVal = 0;
	//Fill different Lv of the hash
	unsigned long bpVal = 0;
	this->KmerSize = KmerSize;

	unsigned int tempHashVal = 0;

	for (int i = 0; i < this->KmerSize; i++) {

		//cout << Kmer[i];

		switch (Kmer[i]) {
		case 'A':
			bpVal = 0;
			break;
		case 'C':
			bpVal = 1;
			break;
		case 'G':
			bpVal = 2;
			break;
		case 'T':
			bpVal = 3;
			break;
		case 'N':
		default:
			bpVal = 0;
		}

		hashVal = (hashVal << 2) | bpVal;
	}
	return hashVal;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2070
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x26ce
jmp 0x26ed
leaq 0xa0c(%rip), %rdi       # 0x30e1
leaq 0xa1d(%rip), %rsi       # 0x30f9
movl $0x40, %edx
leaq 0xa1d(%rip), %rcx       # 0x3105
callq 0x2060
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x28(%rsp)
movl 0x34(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x4(%rcx), %eax
jae 0x27ba
movq 0x38(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x20f0
movsbl (%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x13, %eax
ja 0x278e
movq 0x8(%rsp), %rax
leaq 0x905(%rip), %rcx       # 0x305c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, 0x28(%rsp)
jmp 0x2797
movq $0x1, 0x28(%rsp)
jmp 0x2797
movq $0x2, 0x28(%rsp)
jmp 0x2797
movq $0x3, 0x28(%rsp)
jmp 0x2797
jmp 0x278e
movq $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
orq 0x28(%rsp), %rcx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2718
movq 0x10(%rsp), %rax
movl (%rax), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/ARINC/ARINC_Com.cpp
// Function: QueuingPort::SendQueuingMsg(char*, int)
int QueuingPort::SendQueuingMsg (char* s_t, int ls_t) {

                int nbeff;
                if ((nbeff = sendto(s_d,s_t,ls_t,0,(struct sockaddr *)&s_a, sizeof(s_a)))== SOCK_ERR) {
                        perror("C-> sendto");
                        bye(s_d);
                        }
//                else
//                        cout << "C-> Number of char sent = " << nbeff << endl;
                return(nbeff); // returns the number of char effectively sent
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %r8
movq %r8, -0x20(%rbp)
movl 0x404(%r8), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
addq $0x408, %r8             # imm = 0x408
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x3070
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x3c61
leaq 0x449b(%rip), %rdi      # 0x80e8
callq 0x3200
movq -0x20(%rbp), %rax
movl 0x404(%rax), %edi
callq 0x38e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/ARINC/ARINC_Com.cpp
// Function: QueuingPort::RecvQueuingMsg(char*)
int QueuingPort::RecvQueuingMsg (char* e_t){;

                int lc_a = sizeof(c_a);
                int le_t;

                cout << "Waiting for input message..." << endl;
                if ((le_t = recvfrom(s_d,e_t,MAXLGMSG,0,(struct sockaddr *)&c_a,(socklen_t *)&lc_a)) == SOCK_ERR) {
                        perror("S-> recvfrom");
                        bye(s_d);
                        }       
                else {
                        h_emetteur = gethostbyaddr(&c_a.sin_addr,sizeof(&c_a.sin_addr),c_a.sin_family); 
                        cout << "S-> client port : " << c_a.sin_port << endl;;
                        cout << "S-> client host : " << h_emetteur->h_name << endl;
                        *(e_t+le_t)='\0';
                        cout << "S-> Buffer(" << le_t << ") : " << e_t << endl;
                }
                return(le_t); // returns the number of char effectively received 
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x10, -0x14(%rbp)
movq 0x733a(%rip), %rdi      # 0xafd0
leaq 0x4456(%rip), %rsi      # 0x80f3
callq 0x3280
movq %rax, %rdi
movq 0x7314(%rip), %rsi      # 0xafc0
callq 0x32b0
movq -0x20(%rbp), %r8
movl 0x404(%r8), %edi
movq -0x10(%rbp), %rsi
addq $0x418, %r8             # imm = 0x418
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
leaq -0x14(%rbp), %r9
callq 0x31d0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x3cff
leaq 0x442a(%rip), %rdi      # 0x8110
callq 0x3200
movq -0x20(%rbp), %rax
movl 0x404(%rax), %edi
callq 0x38e0
jmp 0x3df1
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x418, %rdi            # imm = 0x418
addq $0x4, %rdi
movzwl 0x418(%rax), %edx
movl $0x8, %esi
callq 0x3360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x4b8(%rax)
movq 0x7299(%rip), %rdi      # 0xafd0
leaq 0x43df(%rip), %rsi      # 0x811d
callq 0x3280
movq %rax, %rdi
movq -0x20(%rbp), %rax
movzwl 0x41a(%rax), %esi
callq 0x3470
movq %rax, %rdi
movq 0x7260(%rip), %rsi      # 0xafc0
callq 0x32b0
movq 0x7264(%rip), %rdi      # 0xafd0
leaq 0x43bd(%rip), %rsi      # 0x8130
callq 0x3280
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x4b8(%rax), %rax
movq (%rax), %rsi
callq 0x3280
movq %rax, %rdi
movq 0x7228(%rip), %rsi      # 0xafc0
callq 0x32b0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x7220(%rip), %rdi      # 0xafd0
leaq 0x438c(%rip), %rsi      # 0x8143
callq 0x3280
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3490
movq %rax, %rdi
leaq 0x437e(%rip), %rsi      # 0x814f
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
movq %rax, %rdi
movq 0x71d4(%rip), %rsi      # 0xafc0
callq 0x32b0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/ARINC/ARINC_Com.cpp
// Function: SamplingPort::SamplingPort(long, int, int, char*)
SamplingPort::SamplingPort(long d, int m, int p, char* S):QueuingPort(m, p, S){
us_delay=d;
timeout.tv_sec = 0;
timeout.tv_usec = d;
nds = getdtablesize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x39a0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x660(%rax)
movq $0x0, 0x4c8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x4d0(%rax)
callq 0x3460
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4d8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/genericInstruction.cpp
// Function: GenericInstruction::GenericInstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
GenericInstruction::GenericInstruction(string base) 
{
	string time = base.substr(0,6);
	
	hour =  atoi(time.c_str())/10000;
	min =  (atoi(time.c_str())%10000)/100;
	sec =  atoi(time.c_str())%100;
	
	type = base.substr(6,1).c_str()[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x6a8a(%rip), %rcx      # 0xad30
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x6, %ecx
movq %rcx, -0x70(%rbp)
callq 0x32a0
movq -0x80(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0x80(%rbp), %rdi
movl %eax, %ecx
movq -0x68(%rbp), %rax
movslq %ecx, %rcx
imulq $0x68db8bad, %rcx, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
movl %ecx, 0x8(%rax)
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0x80(%rbp), %rdi
movl %eax, %ecx
movq -0x68(%rbp), %rax
movslq %ecx, %rdx
imulq $0x68db8bad, %rdx, %rdx # imm = 0x68DB8BAD
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2c, %rdx
addl %esi, %edx
imull $0x2710, %edx, %edx     # imm = 0x2710
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x51eb851f, %rcx, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
movl %ecx, 0xc(%rax)
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movl %eax, %ecx
movq -0x68(%rbp), %rax
movslq %ecx, %rdi
imulq $0x51eb851f, %rdi, %rdi # imm = 0x51EB851F
movq %rdi, %r8
shrq $0x3f, %r8
sarq $0x25, %rdi
addl %r8d, %edi
imull $0x64, %edi, %edi
subl %edi, %ecx
movl %ecx, 0x10(%rax)
leaq -0x50(%rbp), %rdi
movl $0x1, %ecx
callq 0x32a0
jmp 0x4393
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rax, %rcx
movq -0x68(%rbp), %rax
movb (%rcx), %cl
movb %cl, 0x14(%rax)
leaq -0x50(%rbp), %rdi
callq 0x3180
leaq -0x30(%rbp), %rdi
callq 0x3180
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x58(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/genericInstruction.cpp
// Function: PhotoInstruction::PhotoInstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
PhotoInstruction::PhotoInstruction(string base):GenericInstruction(base)
{
/*  	For a photo shoot :    string instruction = "HHMMSSpEXPOUNomImage In"	*/

	string exposure = base.substr(7,5);
	this->exposure = atoi(exposure.c_str());

	string cut = base.substr(12,base.length()-12);
	this->photoName = cut.substr(0, cut.find(" "));

	string leftover = base.substr(13+this->photoName.length(), 2);
	this->index = atoi( leftover.c_str()  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3130
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x4280
jmp 0x456a
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0xd0(%rbp), %rdi
leaq 0x67c7(%rip), %rax      # 0xad48
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3380
movq -0xd8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x7, %edx
movl $0x5, %ecx
callq 0x32a0
jmp 0x45b0
leaq -0x60(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0xd8(%rbp), %rdi
movl %eax, %ecx
movq -0xd0(%rbp), %rax
movl %ecx, 0x40(%rax)
callq 0x3400
movq -0xd8(%rbp), %rsi
movq %rax, %rcx
addq $-0xc, %rcx
leaq -0x80(%rbp), %rdi
movl $0xc, %edx
callq 0x32a0
jmp 0x45f7
leaq 0x3ac9(%rip), %rsi      # 0x80c7
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xe8(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3500
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq %rax, %rcx
leaq -0xa0(%rbp), %rdi
callq 0x32a0
jmp 0x4638
movq -0xd0(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xf8(%rbp)
leaq -0xa0(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0x3330
movq -0x100(%rbp), %rdi
callq 0x3180
movq -0xf8(%rbp), %rdi
callq 0x3400
movq -0xd8(%rbp), %rsi
movq %rax, %rdx
addq $0xd, %rdx
leaq -0xc0(%rbp), %rdi
movl $0x2, %ecx
callq 0x32a0
jmp 0x4696
leaq -0xc0(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3430
movl %eax, %ecx
movq -0xd0(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0xc0(%rbp), %rdi
callq 0x3180
leaq -0x80(%rbp), %rdi
callq 0x3180
leaq -0x60(%rbp), %rdi
callq 0x3180
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0x473a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x472e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4725
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3180
leaq -0x60(%rbp), %rdi
callq 0x3180
movq -0xe0(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/genericInstruction.cpp
// Function: PhotoInstruction::printInstruction()
void PhotoInstruction::printInstruction ()
{
	printf("Time: %02d:%02d:%02d ", this->hour, this->min, this->sec);
	printf("Type: %c ", this->type );
	printf("Ph. Name: %s \t", this->photoName.c_str()); 
	printf("Expo.: %d \t", this->exposure); 
	printf("Index: %d \n", this->index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movl 0x10(%rax), %ecx
leaq 0x3a77(%rip), %rdi      # 0x81eb
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movsbl 0x14(%rax), %esi
leaq 0x3a77(%rip), %rdi      # 0x8201
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x3a63(%rip), %rdi      # 0x820b
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
leaq 0x3a5d(%rip), %rdi      # 0x821a
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x3a54(%rip), %rdi      # 0x8226
movb $0x0, %al
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/genericInstruction.cpp
// Function: AttitudeInstruction::AttitudeInstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AttitudeInstruction::AttitudeInstruction(string base):GenericInstruction(base)
{
/*      For a attitude change: string instruction[ ]="HHMMSSaAAABBBCCC In"	*/
	string att = base.substr(7,9);
	
	this->roll =  atoi(att.c_str())/1000000;
	this->yaw =  atoi(att.c_str())%1000;
	this->pitch =  (atoi(att.c_str())%1000000)/1000;

	string leftover = base.substr(17,2);
	this->index = atoi( leftover.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3130
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4280
jmp 0x48ba
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rsi
leaq 0x6488(%rip), %rcx      # 0xad60
movq %rcx, (%rax)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x7, %edx
movl $0x9, %ecx
callq 0x32a0
movq -0xa0(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movq -0x90(%rbp), %rax
movslq %ecx, %rcx
imulq $0x431bde83, %rcx, %rcx # imm = 0x431BDE83
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x32, %rcx
addl %edx, %ecx
movl %ecx, 0x24(%rax)
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movq -0x90(%rbp), %rax
movslq %ecx, %rdx
imulq $0x10624dd3, %rdx, %rdx # imm = 0x10624DD3
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x26, %rdx
addl %esi, %edx
imull $0x3e8, %edx, %edx      # imm = 0x3E8
subl %edx, %ecx
movl %ecx, 0x20(%rax)
callq 0x3110
movq %rax, %rdi
callq 0x3430
movq -0x98(%rbp), %rsi
movl %eax, %ecx
movq -0x90(%rbp), %rax
movslq %ecx, %rdx
imulq $0x431bde83, %rdx, %rdx # imm = 0x431BDE83
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x32, %rdx
addl %edi, %edx
imull $0xf4240, %edx, %edx    # imm = 0xF4240
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movl %ecx, 0x1c(%rax)
leaq -0x80(%rbp), %rdi
movl $0x11, %edx
movl $0x2, %ecx
callq 0x32a0
jmp 0x49dd
leaq -0x80(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3430
movl %eax, %ecx
movq -0x90(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0x80(%rbp), %rdi
callq 0x3180
leaq -0x60(%rbp), %rdi
callq 0x3180
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0x4a41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/genericInstruction.cpp
// Function: AttitudeInstruction::printInstruction()
void AttitudeInstruction::printInstruction ()
{
	printf("Time: %02d:%02d:%02d ", this->hour, this->min, this->sec);
	printf("Type: %c ", this->type );
	printf("Attitude: %03d:%03d:%03d \t\t\t", this->roll, this->pitch, this->yaw );	
	printf("Index: %d \n", this->index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movl 0x10(%rax), %ecx
leaq 0x3777(%rip), %rdi      # 0x81eb
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movsbl 0x14(%rax), %esi
leaq 0x3777(%rip), %rdi      # 0x8201
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
movl 0x1c(%rax), %edx
movl 0x20(%rax), %ecx
leaq 0x378d(%rip), %rdi      # 0x8232
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x376c(%rip), %rdi      # 0x8226
movb $0x0, %al
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/plan.cpp
// Function: Plan::stockInstruction(GenericInstruction*)
bool Plan::stockInstruction(GenericInstruction * newInstruction)
{
	if (nInstructions == maxInstructions)
	{
		return false;
	}
	else
	{
		ActivityList[nInstructions] = newInstruction;
		nInstructions++;
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x64, 0x320(%rax)
jne 0x4bd3
movb $0x0, -0x1(%rbp)
jmp 0x4bf9
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq 0x320(%rax), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x320(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x320(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/planManager.cpp
// Function: PlanManager::destructPlan()
void PlanManager::destructPlan()
{
	if(plan!=NULL)
	{
		delete plan;
		plan=NULL;
	}
	for (int k=0; k< 100; k++) bannedInstructions[k] = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x5b5f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5b54
movq -0x20(%rbp), %rdi
callq 0x3260
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x5b84
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5b66
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/planManager.cpp
// Function: PlanManager::generatePlan(char const*)
void PlanManager::generatePlan(const char* filepath)
{
	cout << "GENERATE PLAN" << endl;

	string s = filepath;
	plan = new Plan();
	plan->loadPlan(filepath);

	for (int k=0; k< 100; k++) bannedInstructions[k] = false;

	cout<<"Plan ajouté"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x5421(%rip), %rdi      # 0xafd0
leaq 0x28ce(%rip), %rsi      # 0x8484
callq 0x3280
movq %rax, %rdi
movq 0x53fb(%rip), %rsi      # 0xafc0
callq 0x32b0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3370
jmp 0x5bf2
leaq -0x31(%rbp), %rdi
callq 0x32c0
movl $0x328, %edi            # imm = 0x328
callq 0x3290
movq %rax, -0x68(%rbp)
jmp 0x5c0b
movq -0x68(%rbp), %rdi
callq 0x4b30
jmp 0x5c16
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c00
jmp 0x5c2f
movl $0x0, -0x48(%rbp)
cmpl $0x64, -0x48(%rbp)
jge 0x5c90
movq -0x60(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5c36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32c0
jmp 0x5cd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5cca
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3260
jmp 0x5cca
movq 0x5339(%rip), %rdi      # 0xafd0
leaq 0x27f4(%rip), %rsi      # 0x8492
callq 0x3280
movq %rax, -0x70(%rbp)
jmp 0x5ca9
movq -0x70(%rbp), %rdi
movq 0x530c(%rip), %rsi      # 0xafc0
callq 0x32b0
jmp 0x5cbb
leaq -0x30(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x40(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/communication/statusManager.cpp
// Function: StatusManager::newNotification(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void StatusManager::newNotification(int errorID, string description)
{
	ofstream writeFile;
	writeFile.open(this->pathLogFile.c_str(), ofstream::app);
	
	time_t rawtime;

	struct tm * timeinfo;
	time (&rawtime);
	timeinfo = localtime (&rawtime);	
	
	cout << "Adding notification in file log : "<< this->pathLogFile << endl;

	if(writeFile.is_open())
	{
		char logLine[1000];
		sprintf(logLine, "Error %d:\t%s%s\n\n",errorID, asctime(timeinfo),description.c_str());
		printf("Error %d:\t%s%s\n\n", errorID,asctime(timeinfo), description.c_str());
		writeFile << logLine;
		writeFile.close();
	}

	else
	{
		cout << "Could not open the log error file " << this->pathLogFile << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x690, %rsp            # imm = 0x690
movq %rdx, -0x638(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x630(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x628(%rbp)
callq 0x3480
movq -0x630(%rbp), %rdi
callq 0x3110
movq -0x628(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x3060
jmp 0x5f7d
leaq -0x230(%rbp), %rdi
movq %rdi, -0x648(%rbp)
callq 0x3240
movq -0x648(%rbp), %rdi
callq 0x31b0
movq %rax, -0x238(%rbp)
movq 0x5026(%rip), %rdi      # 0xafd0
leaq 0x250c(%rip), %rsi      # 0x84bd
callq 0x3280
movq %rax, -0x640(%rbp)
jmp 0x5fbf
movq -0x630(%rbp), %rsi
movq -0x640(%rbp), %rdi
callq 0x3230
movq %rax, -0x650(%rbp)
jmp 0x5fdb
movq -0x650(%rbp), %rdi
movq 0x4fd7(%rip), %rsi      # 0xafc0
callq 0x32b0
jmp 0x5ff0
leaq -0x218(%rbp), %rdi
callq 0x31e0
movb %al, -0x651(%rbp)
jmp 0x6004
movb -0x651(%rbp), %al
testb $0x1, %al
jne 0x6013
jmp 0x60fe
movl -0xc(%rbp), %eax
movl %eax, -0x67c(%rbp)
movq -0x238(%rbp), %rdi
callq 0x3120
movq -0x638(%rbp), %rdi
movq %rax, -0x678(%rbp)
callq 0x3110
movl -0x67c(%rbp), %edx
movq -0x678(%rbp), %rcx
movq %rax, %r8
leaq 0x248e(%rip), %rsi      # 0x84e0
movq %rsi, -0x670(%rbp)
xorl %eax, %eax
movb %al, -0x652(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x3090
movl -0xc(%rbp), %eax
movl %eax, -0x664(%rbp)
movq -0x238(%rbp), %rdi
callq 0x3120
movq -0x638(%rbp), %rdi
movq %rax, -0x660(%rbp)
callq 0x3110
movq -0x670(%rbp), %rdi
movl -0x664(%rbp), %esi
movq -0x660(%rbp), %rdx
movq %rax, %rcx
movb -0x652(%rbp), %al
callq 0x3050
jmp 0x60b9
leaq -0x218(%rbp), %rdi
leaq -0x620(%rbp), %rsi
callq 0x3280
jmp 0x60ce
leaq -0x218(%rbp), %rdi
callq 0x33a0
jmp 0x60dc
jmp 0x614d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x33f0
jmp 0x6162
movq 0x4ecb(%rip), %rdi      # 0xafd0
leaq 0x23e5(%rip), %rsi      # 0x84f1
callq 0x3280
movq %rax, -0x688(%rbp)
jmp 0x611a
movq -0x630(%rbp), %rsi
movq -0x688(%rbp), %rdi
callq 0x3230
movq %rax, -0x690(%rbp)
jmp 0x6136
movq -0x690(%rbp), %rdi
movq 0x4e7c(%rip), %rsi      # 0xafc0
callq 0x32b0
jmp 0x614b
jmp 0x614d
leaq -0x218(%rbp), %rdi
callq 0x33f0
addq $0x690, %rsp            # imm = 0x690
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x34b0
nop
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/attitudeController.cpp
// Function: AttitudeController::attitudeChange(int, int, int)
bool AttitudeController::attitudeChange(int roll, int pitch, int yaw) 
{
	char cmde_pitch[] = {"                                "};
	char cmde_yaw[]   = {"                                "};

	sprintf(cmde_pitch, "echo \"5=%d\" > /dev/servoblaster", pitch);
	sprintf(cmde_yaw, "echo \"2=%d\" > /dev/servoblaster", yaw);

	//cout << cmde_pitch<< endl;
	//cout << cmde_yaw  << endl;

	if (system(cmde_pitch) != 0)
	{
		//cout << "Error in the pitch mouvement \n\n";
		return false;
	}

	if (system(cmde_yaw) != 0 )
	{
		//cout << "Error in the yaw mouvement \n\n";
		return false;
	}

	/*
	try
	{
		cout << system(cmde_pitch)<< endl;
		cout << system(cmde_yaw)<< endl;
	}
	catch (exception& e)
	{
		cout << "exception caught:" << e.what()<<endl;
	}
	*/

	return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x2380(%rip), %rsi      # 0x8520
movl $0x21, %edx
callq 0x31f0
leaq -0x70(%rbp), %rdi
leaq 0x236b(%rip), %rsi      # 0x8520
movl $0x21, %edx
callq 0x31f0
leaq -0x40(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x2374(%rip), %rsi      # 0x8541
movb $0x0, %al
callq 0x3090
leaq -0x70(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x237f(%rip), %rsi      # 0x8561
movb $0x0, %al
callq 0x3090
leaq -0x40(%rbp), %rdi
callq 0x3210
cmpl $0x0, %eax
je 0x61fd
movb $0x0, -0x1(%rbp)
jmp 0x6215
leaq -0x70(%rbp), %rdi
callq 0x3210
cmpl $0x0, %eax
je 0x6211
movb $0x0, -0x1(%rbp)
jmp 0x6215
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: CDISC2020[P]Projet_satellite_agile/src/planManager/cameraController.cpp
// Function: CameraController::photoShoot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool CameraController::photoShoot(string fileName, int exposure) 
{
	char cmde[1024];

	sprintf(cmde, "raspistill -rot 90 -o %s.jpg -t %d", fileName.c_str(), exposure);

	//cout << cmde <<endl;

	if (system(cmde) != 0)
	{
		//cout << "Error in the photo shoot \n\n";
		return false;
	}

	/*
	try
	{
		system(cmde);
	}
	catch (exception& e)
	{
		cout << "exception caught:" << e.what()<< endl;
	}
	*/	

	return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rsi, -0x430(%rbp)
movq %rdi, %rax
movq -0x430(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
callq 0x3110
movq -0x428(%rbp), %rdi
movq %rax, %rdx
movl -0x1c(%rbp), %ecx
leaq 0x2303(%rip), %rsi      # 0x8581
movb $0x0, %al
callq 0x3090
leaq -0x420(%rbp), %rdi
callq 0x3210
cmpl $0x0, %eax
je 0x629c
movb $0x0, -0x1(%rbp)
jmp 0x62a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nop
// File: CDISC2020[P]Projet_satellite_agile/src/GPIO.cpp
// Function: GPIOExport(int)
int GPIOExport(int pin)
{
#define BUFFER_MAX 3
	char buffer[BUFFER_MAX];
	ssize_t bytes_written;
	int fd;
 
	fd = open("/sys/class/gpio/export", O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open export for writing!\n");
		return(-1);
	}
 
	bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
	write(fd, buffer, bytes_written);
	close(fd);
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0x22e2(%rip), %rdi      # 0x85a4
movl $0x1, %esi
movb $0x0, %al
callq 0x31a0
movl %eax, -0x1c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x1c(%rbp), %eax
jne 0x62fc
movq 0x4cf6(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x22cf(%rip), %rsi      # 0x85bb
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x633b
leaq -0xb(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x3, %esi
leaq 0x2292(%rip), %rdx      # 0x85a1
movb $0x0, %al
callq 0x3440
cltq
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
leaq -0xb(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3100
movl -0x1c(%rbp), %edi
callq 0x34f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/GPIO.cpp
// Function: GPIOUnexport(int)
int GPIOUnexport(int pin)
{
	char buffer[BUFFER_MAX];
	ssize_t bytes_written;
	int fd;
 
	fd = open("/sys/class/gpio/unexport", O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open unexport for writing!\n");
		return(-1);
	}
 
	bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
	write(fd, buffer, bytes_written);
	close(fd);
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0x227d(%rip), %rdi      # 0x85df
movl $0x1, %esi
movb $0x0, %al
callq 0x31a0
movl %eax, -0x1c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x1c(%rbp), %eax
jne 0x639c
movq 0x4c56(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x226c(%rip), %rsi      # 0x85f8
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x63db
leaq -0xb(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x3, %esi
leaq 0x21f2(%rip), %rdx      # 0x85a1
movb $0x0, %al
callq 0x3440
cltq
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
leaq -0xb(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3100
movl -0x1c(%rbp), %edi
callq 0x34f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/GPIO.cpp
// Function: GPIODirection(int, int)
int GPIODirection(int pin, int dir)
{
	static const char s_directions_str[]  = "in\0out";
 
#define DIRECTION_MAX 35
	char path[DIRECTION_MAX];
	int fd;
 
	snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
	fd = open(path, O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio direction for writing!\n");
		return(-1);
	}
 
	if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
		fprintf(stderr, "Failed to set direction!\n");
		return(-1);
	}
 
	close(fd);
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x23, %esi
leaq 0x220d(%rip), %rdx      # 0x861e
movb $0x0, %al
callq 0x3440
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x31a0
movl %eax, -0x34(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x34(%rbp), %eax
jne 0x6456
movq 0x4b9c(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x21f9(%rip), %rsi      # 0x863f
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x64d1
movl -0x34(%rbp), %edi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x3, %eax
cmpl %edx, %ecx
cmovel %ecx, %eax
cltq
leaq 0x22b0(%rip), %rsi      # 0x8721
addq %rax, %rsi
movl -0xc(%rbp), %r8d
xorl %edx, %edx
movl $0x3, %eax
movl $0x2, %ecx
cmpl %r8d, %edx
cmovel %ecx, %eax
movslq %eax, %rdx
callq 0x3100
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x64c2
movq 0x4b30(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x21b9(%rip), %rsi      # 0x866b
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x64d1
movl -0x34(%rbp), %edi
callq 0x34f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/GPIO.cpp
// Function: GPIORead(int)
int GPIORead(int pin)
{
#define VALUE_MAX 30
	char path[VALUE_MAX];
	char value_str[3];
	int fd;
 
	snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
	fd = open(path, O_RDONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio value for reading!\n");
		return(-1);
	}
 
	if (-1 == read(fd, value_str, 3)) {
		fprintf(stderr, "Failed to read value!\n");
		return(-1);
	}
 
	close(fd);
 
	return(atoi(value_str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x1e, %esi
leaq 0x2187(%rip), %rdx      # 0x8685
movb $0x0, %al
callq 0x3440
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x31a0
movl %eax, -0x38(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x38(%rbp), %eax
jne 0x6540
movq 0x4ab2(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x2172(%rip), %rsi      # 0x86a2
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6595
movl -0x38(%rbp), %edi
leaq -0x33(%rbp), %rsi
movl $0x3, %edx
callq 0x33c0
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x6581
movq 0x4a71(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x2159(%rip), %rsi      # 0x86ca
movb $0x0, %al
callq 0x33b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6595
movl -0x38(%rbp), %edi
callq 0x34f0
leaq -0x33(%rbp), %rdi
callq 0x3430
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop