LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: manikandan5[P]Image-Matching-Stitching-Warping/./SiftHelpers.h
// Function: Image::Image(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Image(string Name)
	{
		name = Name;
		CImg<double> imageData(name.c_str());
		input_image = imageData;
		CImg<double> gray = imageData.get_RGBtoHSI().get_channel(2);
		descriptors = Sift::compute_sift(gray);
	}

// Assembly:
subq $0xe8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x5710
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
callq 0x609f0
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x28(%rsp)
callq 0xb6c0
jmp 0xc02e
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, (%rsp)
callq 0x609f0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5060
jmp 0xc051
movq 0x10(%rsp), %rdi
callq 0x51f0
movq %rax, %rsi
leaq 0xa8(%rsp), %rdi
callq 0x60a00
jmp 0xc06d
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
leaq 0xa8(%rsp), %rsi
callq 0xb700
jmp 0xc085
leaq 0x68(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x60a50
jmp 0xc099
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movl $0x2, %edx
callq 0x60ae0
jmp 0xc0b2
leaq 0x68(%rsp), %rdi
callq 0xa540
leaq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x61130
jmp 0xc0d0
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x60b20
jmp 0xc0e1
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x50(%rsp), %rsi
callq 0xcc20
leaq 0x50(%rsp), %rdi
callq 0xcc60
leaq 0x30(%rsp), %rdi
callq 0x31710
leaq 0x88(%rsp), %rdi
callq 0xa540
leaq 0xa8(%rsp), %rdi
callq 0xa540
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xc1f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xc1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xc1d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xa540
jmp 0xc1d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0xc1c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31710
leaq 0x88(%rsp), %rdi
callq 0xa540
leaq 0xa8(%rsp), %rdi
callq 0xa540
movq (%rsp), %rdi
callq 0xcc60
movq 0x28(%rsp), %rdi
callq 0xa540
movq 0x18(%rsp), %rdi
callq 0xcc60
movq 0x20(%rsp), %rdi
callq 0x5ae8
movq 0xd0(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::move_to(cimg_library::CImg<double>&)
CImg<T>& move_to(CImg<T>& img) {
      if (_is_shared || img._is_shared) img.assign(*this);
      else swap(img);
      assign();
      return img;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x10(%rax)
jne 0x10f78
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x10f88
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x5e300
jmp 0x10f96
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5e350
movq (%rsp), %rdi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::warn(char const*, ...)
inline void warn(const char *const format, ...) {
      if (cimg::exception_mode()>=1) {
        char message[16384] = { 0 };
        std::va_list ap;
        va_start(ap,format);
        cimg_vsnprintf(message,sizeof(message),format,ap);
        va_end(ap);
#ifdef cimg_strict_warnings
        throw CImgWarningException(message);
#else
        std::fprintf(cimg::output(),"\n%s[CImg] *** Warning ***%s%s",cimg::t_red,cimg::t_normal,message);
#endif
      }
    }

// Assembly:
subq $0x40d8, %rsp           # imm = 0x40D8
testb %al, %al
je 0x1181c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x40d0(%rsp)
callq 0x124b0
cmpl $0x1, (%rax)
jb 0x118dd
leaq 0xd0(%rsp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x52a0
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x40e0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq 0xd0(%rsp), %rdi
movq 0x40d0(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0x4000, %esi           # imm = 0x4000
callq 0x5310
leaq 0xb0(%rsp), %rax
xorl %eax, %eax
movl %eax, %edi
callq 0x124c0
movq %rax, %rdi
leaq 0xd0(%rsp), %r8
leaq 0xd76d8(%rip), %rsi     # 0xe8fa4
leaq 0xb6e25(%rip), %rcx     # 0xc86f8
movq %rcx, %rdx
movb $0x0, %al
callq 0x5750
addq $0x40d8, %rsp           # imm = 0x40D8
retq
nopw %cs:(%rax,%rax)
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::output(_IO_FILE*)
inline std::FILE* output(std::FILE *file) {
      cimg::mutex(1);
      static std::FILE *res = stderr;
      if (file) res = file;
      cimg::mutex(1,0);
      return res;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movl $0x1, %esi
movl %esi, %edi
callq 0x12d30
cmpb $0x0, 0xee5f0(%rip)     # 0x100ac8
jne 0x12508
leaq 0xee5e7(%rip), %rdi     # 0x100ac8
callq 0x59d0
cmpl $0x0, %eax
je 0x12508
movq 0xedade(%rip), %rax     # 0xfffd0
movq (%rax), %rax
movq %rax, 0xee5c4(%rip)     # 0x100ac0
leaq 0xee5c5(%rip), %rdi     # 0x100ac8
callq 0x5340
cmpq $0x0, (%rsp)
je 0x1251a
movq (%rsp), %rax
movq %rax, 0xee5a6(%rip)     # 0x100ac0
movl $0x1, %edi
xorl %esi, %esi
callq 0x12d30
movq 0xee593(%rip), %rax     # 0x100ac0
popq %rcx
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::_exception_mode(unsigned int, bool)
inline unsigned int& _exception_mode(const unsigned int value, const bool is_set) {
      static unsigned int mode = cimg_verbosity;
      cimg::mutex(0);
      if (is_set) mode = value;
      cimg::mutex(0,0);
      return mode;
    }

// Assembly:
pushq %rax
movb %sil, %al
movl %edi, 0x4(%rsp)
andb $0x1, %al
movb %al, 0x3(%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x3(%rsp)
je 0x12d1b
movl 0x4(%rsp), %eax
movl %eax, 0xed865(%rip)     # 0x100580
xorl %esi, %esi
movl %esi, %edi
callq 0x12d30
leaq 0xed855(%rip), %rax     # 0x100580
popq %rcx
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::mutex(unsigned int, int)
inline int mutex(const unsigned int n, const int lock_mode) {
      switch (lock_mode) {
      case 0 : cimg::Mutex_attr().unlock(n); return 0;
      case 1 : cimg::Mutex_attr().lock(n); return 0;
      default : return cimg::Mutex_attr().trylock(n);
      }
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x12d55
jmp 0x12d4a
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x12d70
jmp 0x12d8b
callq 0x12db0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x12e20
movl $0x0, 0x14(%rsp)
jmp 0x12da0
callq 0x12db0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x12e50
movl $0x0, 0x14(%rsp)
jmp 0x12da0
callq 0x12db0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x12e80
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>::_logo40x38()
static CImg<T> _logo40x38() {
      CImg<T> res(40,38,1,3);
      const unsigned char *ptrs = cimg::logo40x38;
      T *ptr1 = res.data(0,0,0,0), *ptr2 = res.data(0,0,0,1), *ptr3 = res.data(0,0,0,2);
      for (unsigned long off = 0; off<(unsigned long)res._width*res._height;) {
        const unsigned char n = *(ptrs++), r = *(ptrs++), g = *(ptrs++), b = *(ptrs++);
        for (unsigned int l = 0; l<n; ++off, ++l) { *(ptr1++) = (T)r; *(ptr2++) = (T)g; *(ptr3++) = (T)b; }
      }
      return res;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
movl $0x28, %esi
movl $0x26, %edx
movl $0x1, %ecx
movl $0x3, %r8d
callq 0x15df0
movq 0x10(%rsp), %rdi
leaq 0xb322f(%rip), %rax     # 0xc8710
movq %rax, 0x40(%rsp)
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x21a70
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
xorl %ecx, %ecx
movl $0x1, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq 0x21a70
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
xorl %ecx, %ecx
movl $0x2, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq 0x21a70
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movl (%rdx), %ecx
movl 0x4(%rdx), %edx
imulq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1562d
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rsp)
movb (%rax), %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rsp)
movb (%rax), %al
movb %al, 0x1e(%rsp)
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rsp)
movb (%rax), %al
movb %al, 0x1d(%rsp)
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rsp)
movb (%rax), %al
movb %al, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movzbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
jae 0x15628
movb 0x1e(%rsp), %cl
movq 0x38(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x38(%rsp)
movb %cl, (%rax)
movb 0x1d(%rsp), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, (%rax)
movb 0x1c(%rsp), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x155bb
jmp 0x1553b
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x15643
movq 0x10(%rsp), %rdi
callq 0x15650
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::draw_text<unsigned char, unsigned char>(int, int, char const*, unsigned char const*, unsigned char const*, float, unsigned int, ...)
CImg<T>& draw_text(const int x0, const int y0,
                       const char *const text,
                       const tc1 *const foreground_color, const tc2 *const background_color,
                       const float opacity=1, const unsigned int font_height=13, ...) {
      if (!font_height) return *this;
      char tmp[2048] = { 0 };
      std::va_list ap; va_start(ap,font_height); cimg_vsnprintf(tmp,sizeof(tmp),text,ap); va_end(ap);
      const CImgList<ucharT>& font = CImgList<ucharT>::font(font_height,true);
      _draw_text(x0,y0,tmp,foreground_color,background_color,opacity,font,true);
      return *this;
    }

// Assembly:
subq $0x938, %rsp            # imm = 0x938
testb %al, %al
je 0x1572d
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl 0x940(%rsp), %eax
movq %rdi, 0x928(%rsp)
movl %esi, 0x924(%rsp)
movl %edx, 0x920(%rsp)
movq %rcx, 0x918(%rsp)
movq %r8, 0x910(%rsp)
movq %r9, 0x908(%rsp)
movss %xmm0, 0x904(%rsp)
movq 0x928(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x940(%rsp)
jne 0x15794
movq 0x18(%rsp), %rax
movq %rax, 0x930(%rsp)
jmp 0x1586f
leaq 0x100(%rsp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x52a0
leaq 0xe0(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x948(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x40, 0x4(%rax)
movl $0x30, (%rax)
leaq 0x100(%rsp), %rdi
movq 0x918(%rsp), %rdx
leaq 0xe0(%rsp), %rcx
movl $0x800, %esi            # imm = 0x800
callq 0x5310
leaq 0xe0(%rsp), %rax
movl 0x940(%rsp), %edi
movl $0x1, %esi
callq 0x18390
movq 0x18(%rsp), %rdi
movq %rax, 0xd8(%rsp)
movl 0x924(%rsp), %esi
movl 0x920(%rsp), %edx
leaq 0x100(%rsp), %rcx
movq 0x910(%rsp), %r8
movq 0x908(%rsp), %r9
movss 0x904(%rsp), %xmm0
movq 0xd8(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x19090
movq 0x18(%rsp), %rax
movq %rax, 0x930(%rsp)
movq 0x930(%rsp), %rax
addq $0x938, %rsp            # imm = 0x938
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::draw_text<unsigned char>(int, int, char const*, unsigned char const*, int, float, unsigned int, ...)
CImg<T>& draw_text(const int x0, const int y0,
                       const char *const text,
                       const tc *const foreground_color, const int background_color=0,
                       const float opacity=1, const unsigned int font_height=13, ...) {
      if (!font_height) return *this;
      cimg::unused(background_color);
      char tmp[2048] = { 0 };
      std::va_list ap; va_start(ap,font_height); cimg_vsnprintf(tmp,sizeof(tmp),text,ap); va_end(ap);
      return draw_text(x0,y0,"%s",foreground_color,(const tc*)0,opacity,font_height,tmp);
    }

// Assembly:
subq $0x928, %rsp            # imm = 0x928
testb %al, %al
je 0x174ad
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl 0x930(%rsp), %eax
movq %rdi, 0x918(%rsp)
movl %esi, 0x914(%rsp)
movl %edx, 0x910(%rsp)
movq %rcx, 0x908(%rsp)
movq %r8, 0x900(%rsp)
movl %r9d, 0x8fc(%rsp)
movss %xmm0, 0x8f8(%rsp)
movq 0x918(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x930(%rsp)
jne 0x17514
movq 0x18(%rsp), %rax
movq %rax, 0x920(%rsp)
jmp 0x175e1
leaq 0x8fc(%rsp), %rdi
movb $0x0, %al
callq 0x32860
leaq 0xf0(%rsp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x52a0
leaq 0xd0(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x938(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x40, 0x4(%rax)
movl $0x30, (%rax)
leaq 0xf0(%rsp), %rdi
movq 0x908(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
movl $0x800, %esi            # imm = 0x800
callq 0x5310
movq 0x18(%rsp), %rdi
leaq 0xd0(%rsp), %rax
movl 0x914(%rsp), %esi
movl 0x910(%rsp), %edx
movq 0x900(%rsp), %r8
movss 0x8f8(%rsp), %xmm0
movl 0x930(%rsp), %r10d
leaq 0xf0(%rsp), %rax
leaq 0xd31e6(%rip), %rcx     # 0xea7ac
xorl %r9d, %r9d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x1, %al
callq 0x156f0
movq %rax, 0x920(%rsp)
movq 0x920(%rsp), %rax
addq $0x928, %rsp            # imm = 0x928
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::operator*=<int>(int)
CImg<T>& operator*=(const t value) {
      if (is_empty()) return *this;
#ifdef cimg_use_openmp
#pragma omp parallel for if (size()>=262144)
#endif
      cimg_rof(*this,ptrd,T) *ptrd = (T)(*ptrd * value);
      return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1f750
testb $0x1, %al
jne 0x17622
jmp 0x1762e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x17695
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
callq 0x1c2b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x18(%rcx), %rax
jb 0x1768b
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
imull 0x24(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x17655
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::operator+=<int>(int)
CImg<T>& operator+=(const t value) {
      if (is_empty()) return *this;
#ifdef cimg_use_openmp
#pragma omp parallel for if (size()>=524288)
#endif
      cimg_rof(*this,ptrd,T) *ptrd = (T)(*ptrd + value);
      return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1f750
testb $0x1, %al
jne 0x176c2
jmp 0x176ce
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x17734
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
callq 0x1c2b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x18(%rcx), %rax
jb 0x1772a
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
addl 0x24(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x176f5
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::move(int, int)
CImgDisplay& move(const int posx, const int posy) {
      if (is_empty()) return *this;
      show();
      Display *const dpy = cimg::X11_attr().display;
      XLockDisplay(dpy);
      XMoveWindow(dpy,_window,posx,posy);
      _window_x = posx; _window_y = posy;
      _is_moved = false;
      XUnlockDisplay(dpy);
      return paint();
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x37140
testb $0x1, %al
jne 0x178f5
jmp 0x17900
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1797d
movq (%rsp), %rdi
callq 0x5b0a0
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5290
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x4d0(%rax), %rsi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
callq 0x5450
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x44c(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0x450(%rax)
movb $0x0, 0x462(%rax)
movq 0x8(%rsp), %rdi
callq 0x5220
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x370c0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::screen_width()
static int screen_width() {
      Display *const dpy = cimg::X11_attr().display;
      int res = 0;
      if (!dpy) {
        Display *const _dpy = XOpenDisplay(0);
        if (!_dpy)
          throw CImgDisplayException("CImgDisplay::screen_width(): Failed to open X11 display.");
        res = DisplayWidth(_dpy,DefaultScreen(_dpy));
        XCloseDisplay(_dpy);
      } else {
#ifdef cimg_use_xrandr
        if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution)
          res = cimg::X11_attr().resolutions[cimg::X11_attr().curr_resolution].width;
        else res = DisplayWidth(dpy,DefaultScreen(dpy));
#else
        res = DisplayWidth(dpy,DefaultScreen(dpy));
#endif
      }
      return res;
    }

// Assembly:
subq $0x38, %rsp
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x17a58
xorl %eax, %eax
movl %eax, %edi
callq 0x56e0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x17a26
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xd0edc(%rip), %rsi     # 0xe88c7
xorl %eax, %eax
callq 0x3b160
jmp 0x179f4
movq 0x8(%rsp), %rdi
leaq 0xe8228(%rip), %rsi     # 0xffc28
leaq 0x238d9(%rip), %rdx     # 0x3b2e0
callq 0x5920
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x53a0
jmp 0x17a87
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5a50
jmp 0x17a7e
movq 0x30(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::screen_height()
static int screen_height() {
      Display *const dpy = cimg::X11_attr().display;
      int res = 0;
      if (!dpy) {
        Display *const _dpy = XOpenDisplay(0);
        if (!_dpy)
          throw CImgDisplayException("CImgDisplay::screen_height(): Failed to open X11 display.");
        res = DisplayHeight(_dpy,DefaultScreen(_dpy));
        XCloseDisplay(_dpy);
      } else {
#ifdef cimg_use_xrandr
        if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution)
          res = cimg::X11_attr().resolutions[cimg::X11_attr().curr_resolution].height;
        else res = DisplayHeight(dpy,DefaultScreen(dpy));
#else
        res = DisplayHeight(dpy,DefaultScreen(dpy));
#endif
      }
      return res;
    }

// Assembly:
subq $0x38, %rsp
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x17b78
xorl %eax, %eax
movl %eax, %edi
callq 0x56e0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x17b46
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xd0df5(%rip), %rsi     # 0xe8900
xorl %eax, %eax
callq 0x3b160
jmp 0x17b14
movq 0x8(%rsp), %rdi
leaq 0xe8108(%rip), %rsi     # 0xffc28
leaq 0x237b9(%rip), %rdx     # 0x3b2e0
callq 0x5920
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x53a0
jmp 0x17ba7
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5a50
jmp 0x17b9e
movq 0x30(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<unsigned char>::insert(unsigned int, unsigned int)
CImgList<T>& insert(const unsigned int n, const unsigned int pos=~0U) {
      CImg<T> empty;
      if (!n) return *this;
      const unsigned int npos = pos==~0U?_width:pos;
      for (unsigned int i = 0; i<n; ++i) insert(empty,npos+i);
      return *this;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movl %edx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x156b0
cmpl $0x0, 0x54(%rsp)
jne 0x1c0a3
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x1c131
cmpl $-0x1, 0x50(%rsp)
jne 0x1c0b7
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x1c0bf
movl 0x50(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x1c11f
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %eax
addl %eax, %edx
leaq 0x30(%rsp), %rsi
xorl %ecx, %ecx
callq 0x23210
jmp 0x1c0f6
jmp 0x1c0f8
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1c0cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15650
jmp 0x1c145
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15650
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5970
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<unsigned char>::assign()
CImgList<T>& assign() {
      delete[] _data;
      _width = _allocated_width = 0;
      _data = 0;
      return *this;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x1c21c
movq 0x28(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x18(%rsp)
je 0x1c212
movq 0x18(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x15650
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x1c1eb
movq 0x10(%rsp), %rdi
callq 0x5680
movq 0x20(%rsp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<char>::assign(unsigned int)
CImgList<T>& assign(const unsigned int n) {
      if (!n) return assign();
      if (_allocated_width<n || _allocated_width>(n<<2)) {
        delete[] _data;
        _data = new CImg<T>[_allocated_width=cimg::max(16UL,cimg::nearest_pow2(n))];
      }
      _width = n;
      return *this;
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpl $0x0, 0x94(%rsp)
jne 0x1c3f4
movq 0x68(%rsp), %rdi
callq 0x1c660
movq %rax, 0xa0(%rsp)
jmp 0x1c5da
movq 0x68(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x94(%rsp), %eax
jb 0x1c41f
movq 0x68(%rsp), %rax
movl 0x4(%rax), %eax
movl 0x94(%rsp), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jbe 0x1c5c4
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, %rax
je 0x1c48d
movq 0x60(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x50(%rsp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x58(%rsp)
je 0x1c483
movq 0x58(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x48(%rsp)
callq 0x1a320
movq 0x60(%rsp), %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x58(%rsp)
jne 0x1c45c
movq 0x50(%rsp), %rdi
callq 0x5680
movq $0x10, 0x88(%rsp)
movl 0x94(%rsp), %edi
callq 0x1c740
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1c700
movq 0x68(%rsp), %rcx
movl %eax, 0x4(%rcx)
movl %eax, %eax
movq %rax, 0x30(%rsp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5040
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x40(%rsp)
cmpq $0x0, %rax
je 0x1c561
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x19e80
jmp 0x1c549
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1c538
movq 0x68(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1c5c4
movq 0x40(%rsp), %rcx
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
cmpq %rax, %rcx
movq %rax, 0x10(%rsp)
je 0x1c5b8
movq 0x10(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1a320
movq 0x40(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x1c591
movq 0x38(%rsp), %rdi
callq 0x5680
jmp 0x1c5ea
movq 0x68(%rsp), %rax
movl 0x94(%rsp), %ecx
movl %ecx, (%rax)
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<char>::fill(char)
CImg<T>& fill(const T val) {
      if (is_empty()) return *this;
      if (val && sizeof(T)!=1) cimg_for(*this,ptrd,T) *ptrd = val;
      else std::memset(_data,(int)val,sizeof(T)*size());
      return *this;
    }

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1f240
testb $0x1, %al
jne 0x1f185
jmp 0x1f194
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1f234
cmpb $0x0, 0x37(%rsp)
je 0x1f1f8
xorl %eax, %eax
testb $0x1, %al
jne 0x1f1a3
jmp 0x1f1f8
movq 0x18(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x1cec0
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1f1f6
movb 0x37(%rsp), %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1f1cf
jmp 0x1f22a
movq 0x18(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, (%rsp)
movsbl 0x37(%rsp), %eax
movb %al, 0xf(%rsp)
callq 0x1cec0
movq (%rsp), %rdi
movq %rax, %rdx
movb 0xf(%rsp), %al
shlq $0x0, %rdx
movzbl %al, %esi
callq 0x52a0
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<char>::swap(cimg_library::CImg<char>&)
CImg<T>& swap(CImg<T>& img) {
      cimg::swap(_width,img._width);
      cimg::swap(_height,img._height);
      cimg::swap(_depth,img._depth);
      cimg::swap(_spectrum,img._spectrum);
      cimg::swap(_data,img._data);
      cimg::swap(_is_shared,img._is_shared);
      return img;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x1f6a0
movq (%rsp), %rdi
addq $0x4, %rdi
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
callq 0x1f6a0
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x1f6a0
movq (%rsp), %rdi
addq $0xc, %rdi
movq 0x8(%rsp), %rsi
addq $0xc, %rsi
callq 0x1f6a0
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x1f6d0
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x1f710
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<unsigned char>::assign(cimg_library::CImgList<unsigned char> const&, bool)
CImgList<T>& assign(const CImgList<T>& list, const bool is_shared=false) {
      if (this==&list) return *this;
      CImgList<T> res(list._width);
      cimglist_for(res,l) res[l].assign(list[l],is_shared);
      return res.move_to(*this);
    }

// Assembly:
subq $0x78, %rsp
movb %dl, %al
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq 0x60(%rsp), %rax
jne 0x22636
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2270d
movq 0x60(%rsp), %rax
movl (%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x22730
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x226e3
leaq 0x48(%rsp), %rdi
callq 0x15910
movq %rax, 0x20(%rsp)
jmp 0x2266e
movq 0x20(%rsp), %rax
movslq 0x44(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x228b0
movq %rax, 0x18(%rsp)
jmp 0x22695
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x44(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movzbl 0x5f(%rsp), %edx
andl $0x1, %edx
callq 0x21a10
jmp 0x226ba
jmp 0x226bc
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2264f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18310
jmp 0x22717
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x228c0
movq %rax, 0x8(%rsp)
jmp 0x226f9
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18310
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<unsigned char>& cimg_library::CImgList<unsigned char>::move_to<unsigned char>(cimg_library::CImgList<unsigned char>&)
CImgList<t>& move_to(CImgList<t>& list) {
      list.assign(_width);
      bool is_one_shared_element = false;
      cimglist_for(*this,l) is_one_shared_element|=_data[l]._is_shared;
      if (is_one_shared_element) cimglist_for(*this,l) list[l].assign(_data[l]);
      else cimglist_for(*this,l) _data[l].move_to(list[l]);
      assign();
      return list;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl (%rax), %esi
callq 0x206f0
movb $0x0, 0x27(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl (%rcx), %eax
jge 0x2293f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x20(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x228f1
testb $0x1, 0x27(%rsp)
je 0x2299d
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x2299b
movq 0x28(%rsp), %rdi
callq 0x15910
movq %rax, %rdi
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movslq 0x1c(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x22a20
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2294e
jmp 0x229fe
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl (%rcx), %eax
jge 0x229fc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x18(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15910
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movslq 0x18(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x17410
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x229a5
jmp 0x229fe
movq 0x10(%rsp), %rdi
callq 0x1c1a0
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::assign<float>(float const*, unsigned int, unsigned int, unsigned int, unsigned int)
CImg<T>& assign(const t *const values, const unsigned int size_x, const unsigned int size_y=1,
                    const unsigned int size_z=1, const unsigned int size_c=1) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (!values || !siz) return assign();
      assign(size_x,size_y,size_z,size_c);
      const t *ptrs = values; cimg_for(*this,ptrd,T) *ptrd = (T)*(ptrs++);
      return *this;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movl %r9d, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl 0x38(%rsp), %ecx
imulq %rcx, %rax
movl 0x34(%rsp), %ecx
imulq %rcx, %rax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x3236b
cmpq $0x0, 0x28(%rsp)
jne 0x3237f
movq 0x8(%rsp), %rdi
callq 0x1c240
movq %rax, 0x50(%rsp)
jmp 0x32412
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
callq 0x199a0
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rdi), %rax
movq %rax, (%rsp)
callq 0x1c2b0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x32408
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x20(%rsp)
cvttss2si (%rax), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x323ce
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::draw_rectangle<unsigned char>(int, int, int, int, int, int, unsigned char const*, float)
CImg<T>& draw_rectangle(const int x0, const int y0, const int z0,
                            const int x1, const int y1, const int z1,
                            const tc *const color, const float opacity=1) {
      if (is_empty()) return *this;
      if (!color)
        throw CImgArgumentException(_cimg_instance
                                    "draw_rectangle(): Specified color is (null).",
                                    cimg_instance);
      cimg_forC(*this,c) draw_rectangle(x0,y0,z0,c,x1,y1,z1,c,(T)color[c],opacity);
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq 0xb8(%rsp), %rax
movl 0xb0(%rsp), %eax
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movl %edx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movl %r8d, 0x78(%rsp)
movl %r9d, 0x74(%rsp)
movss %xmm0, 0x70(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x1f750
testb $0x1, %al
jne 0x3259b
jmp 0x325ad
movq 0x58(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x3272b
cmpq $0x0, 0xb8(%rsp)
jne 0x32699
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 0xb63d1(%rip), %rcx     # 0xe89d2
leaq 0x974d9(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x1c2e0
movq %rax, 0x50(%rsp)
jmp 0x32620
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 0xb5e22(%rip), %rsi     # 0xe847d
xorl %eax, %eax
callq 0x12220
jmp 0x32664
movq 0x28(%rsp), %rdi
leaq 0xcd4f0(%rip), %rsi     # 0xffb60
leaq -0x20217(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x53a0
jmp 0x3273e
movl $0x0, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movl 0x60(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3271e
movq 0x58(%rsp), %rdi
movl 0x84(%rsp), %esi
movl 0x80(%rsp), %edx
movl 0x7c(%rsp), %ecx
movl 0x60(%rsp), %r8d
movl 0x78(%rsp), %r9d
movl 0x74(%rsp), %ebx
movl 0xb0(%rsp), %r11d
movl 0x60(%rsp), %r10d
movq 0xb8(%rsp), %rax
movslq 0x60(%rsp), %r14
movb (%rax,%r14), %al
movss 0x70(%rsp), %xmm0
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movzbl %al, %eax
movl %eax, 0x18(%rsp)
callq 0x23ce0
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x326a1
movq 0x58(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq 0x68(%rsp), %rdi
callq 0x5970
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: unsigned char const& cimg_library::CImg<unsigned char>::min_max<float>(float&) const
const T& min_max(t& max_val) const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "min_max(): Empty instance.",
                                    cimg_instance);
      const T *ptr_min = _data;
      T min_value = *ptr_min, max_value = min_value;
      cimg_for(*this,ptrs,T) {
        const T val = *ptrs;
        if (val<min_value) { min_value = val; ptr_min = ptrs; }
        if (val>max_value) max_value = val;
      }
      max_val = (t)max_value;
      return *ptr_min;
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x1f750
testb $0x1, %al
jne 0x340b2
jmp 0x34195
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 0xb48db(%rip), %rcx     # 0xe89d2
leaq 0x959e3(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x1c2e0
movq %rax, 0x50(%rsp)
jmp 0x34116
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 0xb4614(%rip), %rsi     # 0xe8765
xorl %eax, %eax
callq 0x11fd0
jmp 0x3415a
movq 0x28(%rsp), %rdi
leaq 0xcb9e2(%rip), %rsi     # 0xffb48
leaq -0x21f5d(%rip), %rdx    # 0x12210
callq 0x5920
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x53a0
jmp 0x3426a
movq 0x58(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movb (%rax), %al
movb %al, 0x7f(%rsp)
movb 0x7f(%rsp), %al
movb %al, 0x7e(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x70(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
callq 0x1c2b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x34245
movq 0x70(%rsp), %rax
movb (%rax), %al
movb %al, 0x67(%rsp)
movzbl 0x67(%rsp), %eax
movzbl 0x7f(%rsp), %ecx
cmpl %ecx, %eax
jge 0x3421d
movb 0x67(%rsp), %al
movb %al, 0x7f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movzbl 0x67(%rsp), %eax
movzbl 0x7e(%rsp), %ecx
cmpl %ecx, %eax
jle 0x34233
movb 0x67(%rsp), %al
movb %al, 0x7e(%rsp)
jmp 0x34235
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x341e3
movzbl 0x7e(%rsp), %eax
cvtsi2ss %eax, %xmm0
movq 0x98(%rsp), %rax
movss %xmm0, (%rax)
movq 0x80(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x5970
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::paint(bool)
CImgDisplay& paint(const bool wait_expose=true) {
      if (is_empty()) return *this;
      Display *const dpy = cimg::X11_attr().display;
      XLockDisplay(dpy);
      _paint(wait_expose);
      XUnlockDisplay(dpy);
      return *this;
    }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x37140
testb $0x1, %al
jne 0x370e6
jmp 0x370f1
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x37131
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5290
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3c5f0
movq 0x8(%rsp), %rdi
callq 0x5220
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::flush()
CImgDisplay& flush() {
      set_key().set_button().set_wheel();
      _is_resized = _is_moved = _is_event = false;
      _fps_timer = _fps_frames = _timer = 0;
      _fps_fps = 0;
      return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17d40
movq %rax, %rdi
callq 0x37310
movq %rax, %rdi
callq 0x37350
movq 0x8(%rsp), %rax
movb $0x0, 0x463(%rax)
movb 0x463(%rax), %cl
andb $0x1, %cl
movb %cl, 0x462(%rax)
movb 0x462(%rax), %cl
andb $0x1, %cl
movb %cl, 0x461(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::_desinit_fullscreen()
void _desinit_fullscreen() {
      if (!_is_fullscreen) return;
      Display *const dpy = cimg::X11_attr().display;
      XUngrabKeyboard(dpy,CurrentTime);
#ifdef cimg_use_xrandr
      if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution) {
        XRRScreenConfiguration *config = XRRGetScreenInfo(dpy,DefaultRootWindow(dpy));
        XRRSetScreenConfig(dpy,config,DefaultRootWindow(dpy),0,cimg::X11_attr().curr_rotation,CurrentTime);
        XRRFreeScreenConfigInfo(config);
        XSync(dpy,0);
        cimg::X11_attr().curr_resolution = 0;
      }
#endif
      if (_background_window) XDestroyWindow(dpy,_background_window);
      _background_window = 0;
      _is_fullscreen = false;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x30(%rax)
jne 0x372aa
jmp 0x372ff
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5670
movq (%rsp), %rax
cmpq $0x0, 0x4d8(%rax)
je 0x372ec
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x4d8(%rax), %rsi
callq 0x5880
movq (%rsp), %rax
movq $0x0, 0x4d8(%rax)
movb $0x0, 0x30(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::set_button()
CImgDisplay& set_button() {
      _button = 0;
      _is_event = true;
#if cimg_display==1
      pthread_cond_broadcast(&cimg::X11_attr().wait_event);
#elif cimg_display==2
      SetEvent(cimg::Win32_attr().wait_event);
#endif
      return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x48(%rax)
movb $0x1, 0x463(%rax)
callq 0x37200
movq %rax, %rdi
addq $0x10, %rdi
callq 0x51a0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::set_wheel()
CImgDisplay& set_wheel() {
      _wheel = 0;
      _is_event = true;
#if cimg_display==1
      pthread_cond_broadcast(&cimg::X11_attr().wait_event);
#elif cimg_display==2
      SetEvent(cimg::Win32_attr().wait_event);
#endif
      return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x45c(%rax)
movb $0x1, 0x463(%rax)
callq 0x37200
movq %rax, %rdi
addq $0x10, %rdi
callq 0x51a0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::X11_info::X11_info()
X11_info():nb_wins(0),events_thread(0),display(0),
                 nb_bits(0),is_blue_first(false),is_shm_enabled(false),byte_order(false) {
        XInitThreads();
        pthread_mutex_init(&wait_event_mutex,0);
        pthread_cond_init(&wait_event,0);
#ifdef cimg_use_xrandr
        resolutions = 0;
        curr_rotation = 0;
        curr_resolution = nb_resolutions = 0;
#endif
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x2068(%rax)
movl $0x0, 0x2070(%rax)
movb $0x0, 0x2074(%rax)
movb $0x0, 0x2075(%rax)
movb $0x0, 0x2076(%rax)
callq 0x5440
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x57c0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55d0
addq $0x18, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::X11_info::~X11_info()
~X11_info() {
        if (events_thread) {
          pthread_cancel(*events_thread);
          delete events_thread;
        }
        if (display) { } // XLockDisplay(display); XCloseDisplay(display); }
        pthread_cond_destroy(&wait_event);
        pthread_mutex_unlock(&wait_event_mutex);
        pthread_mutex_destroy(&wait_event_mutex);
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x3745b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x5720
jmp 0x3743d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x37459
movq (%rsp), %rdi
callq 0x54e0
jmp 0x3745b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x2068(%rax)
je 0x3746c
jmp 0x3746c
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x5a90
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x53d0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x55b0
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xcb20
nopw %cs:(%rax,%rax)
nopl (%rax)