LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x39(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
callq 0x4270
movq (%rbx), %rsi
leaq 0x20(%rsp), %rdi
movq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rdi)
callq 0x384a0
leaq 0x38(%rbx), %rdi
movq 0x38(%rsp), %rsi
movl 0x20(%rsp), %edx
movl 0x24(%rsp), %ecx
movl 0x28(%rsp), %r8d
movl 0x2c(%rsp), %r9d
callq 0xb880
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x37fd8
movq %rsp, %rsi
movl (%rsi), %eax
movl 0x4(%rsi), %r10d
decl %eax
decl %r10d
movl 0x8(%rsi), %r11d
decl %r11d
subq $0x8, %rsp
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x2, %r9d
pushq $0x0
pushq $0x2
pushq %r11
pushq %r10
pushq %rax
callq 0x44cfc
addq $0x30, %rsp
cmpb $0x0, 0x10(%rsp)
jne 0x982d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x982d
callq 0x4690
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x382e0
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x38046
movq 0x30(%rbx), %rax
leaq 0x60(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x30(%rbx)
movups 0x20(%rbx), %xmm1
movups %xmm0, 0x20(%rbx)
leaq 0x80(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0xa038
movq %r14, %rdi
callq 0xa038
cmpb $0x0, 0x10(%rsp)
jne 0x98a5
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x98a5
callq 0x4690
cmpb $0x0, 0x50(%rsp)
jne 0x98bb
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x98bb
callq 0x4690
cmpb $0x0, 0x30(%rsp)
jne 0x98d1
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x98d1
callq 0x4690
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
cmpb $0x0, 0x10(%rsp)
jne 0x98fe
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x98fe
callq 0x4690
jmp 0x98fe
movq %rax, %r14
cmpb $0x0, 0x50(%rsp)
jne 0x9931
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x9931
jmp 0x9925
movq %rax, %r14
cmpb $0x0, 0x10(%rsp)
jne 0x9931
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9931
callq 0x4690
jmp 0x9931
jmp 0x992e
movq %rax, %r14
cmpb $0x0, 0x30(%rsp)
jne 0x994e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x994e
callq 0x4690
jmp 0x994e
jmp 0x994b
movq %rax, %r14
leaq 0x20(%rbx), %r15
leaq 0x58(%rbx), %rdi
callq 0xa038
cmpb $0x0, 0x48(%rbx)
jne 0x9972
leaq 0x50(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9972
callq 0x4690
movq %r15, %rdi
callq 0xa038
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x9987
callq 0x44f0
movq %r14, %rdi
callq 0x4960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdi)
jne 0xb68e
cmpb $0x1, 0x10(%rbx)
jne 0xb6ab
movq 0x18(%r14), %rsi
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
movq %rbx, %rdi
callq 0xb880
jmp 0xb6b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37468
cmpb $0x0, 0x10(%r14)
jne 0xb6cb
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb6cb
callq 0x4690
movq $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::assign(double const*, unsigned int, unsigned int, unsigned int, unsigned int, bool)
CImg<T>& assign(const T *const values, const unsigned int size_x, const unsigned int size_y,
                    const unsigned int size_z, const unsigned int size_c, const bool is_shared) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (!values || !siz) return assign();
      if (!is_shared) { if (_is_shared) assign(); assign(values,size_x,size_y,size_z,size_c); }
      else {
        if (!_is_shared) {
          if (values+siz<_data || values>=_data+size()) assign();
          else cimg::warn(_cimg_instance
                          "assign(): Shared image instance has overlapping memory.",
                          cimg_instance);
        }
        _width = size_x; _height = size_y; _depth = size_z; _spectrum = size_c; _is_shared = true;
        _data = const_cast<T*>(values);
      }
      return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %eax
movl %ecx, %ecx
imulq %rax, %rcx
movl %r8d, %edx
movl %r9d, %eax
imulq %rdx, %rax
imulq %rcx, %rax
testq %rsi, %rsi
setne %dl
testq %rax, %rax
setne %sil
movb 0x10(%rdi), %cl
testb %sil, %dl
je 0xb7f5
movl %r9d, %ebp
movl %r8d, %r14d
cmpb $0x0, 0x40(%rsp)
je 0xb81b
testb %cl, %cl
jne 0xb857
leaq (%r15,%rax,8), %rax
movq 0x18(%rbx), %r9
cmpq %r9, %rax
jb 0xb84a
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq %rdx, %rax
imulq %rsi, %rax
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movq %rcx, %rdi
imulq %r8, %rdi
imulq %rax, %rdi
leaq (%r9,%rdi,8), %rax
cmpq %r15, %rax
jbe 0xb84a
leaq 0x83949(%rip), %r10     # 0x8f11f
leaq 0x64465(%rip), %r11     # 0x6fc42
leaq 0x643f8(%rip), %rdi     # 0x6fbdc
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0xbb10
addq $0x10, %rsp
jmp 0xb857
testb %cl, %cl
jne 0xb807
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb807
callq 0x4690
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
jmp 0xb86d
testb %cl, %cl
je 0xb831
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xb880
jmp 0xb86d
testq %r9, %r9
je 0xb857
movq %r9, %rdi
callq 0x4690
movl %r13d, (%rbx)
movl %r12d, 0x4(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movb $0x1, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x40d8, %rsp           # imm = 0x40D8
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xbb71
movaps %xmm0, 0x50(%rsp)
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)
xorl %edi, %edi
xorl %esi, %esi
callq 0xc7e5
cmpl $0x0, (%rax)
je 0xbbf0
leaq 0xd0(%rsp), %r14
movl $0x4000, %edx           # imm = 0x4000
movq %r14, %rdi
xorl %esi, %esi
callq 0x4290
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x40f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4300
xorl %edi, %edi
callq 0xc328
leaq 0x83528(%rip), %rsi     # 0x8f101
leaq 0x62c88(%rip), %rcx     # 0x6e868
movq %rax, %rdi
movq %rcx, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x4750
addq $0x40d8, %rsp           # imm = 0x40D8
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::strbuffersize(unsigned long)
inline const char *strbuffersize(const unsigned long size) {
      static char res[256] = { 0 };
      cimg::mutex(5);
      if (size<1024LU) cimg_snprintf(res,sizeof(res),"%lu byte%s",size,size>1?"s":"");
      else if (size<1024*1024LU) { const float nsize = size/1024.0f; cimg_snprintf(res,sizeof(res),"%.1f Kio",nsize); }
      else if (size<1024*1024*1024LU) {
        const float nsize = size/(1024*1024.0f); cimg_snprintf(res,sizeof(res),"%.1f Mio",nsize);
      } else { const float nsize = size/(1024*1024*1024.0f); cimg_snprintf(res,sizeof(res),"%.1f Gio",nsize); }
      cimg::mutex(5,0);
      return res;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x9cc1a(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xbf9a
leaq 0x9c7d3(%rip), %rdi     # 0xa8670
callq 0x47a0
cmpq $0x3ff, %rbx            # imm = 0x3FF
ja 0xbee3
cmpq $0x2, %rbx
leaq 0x84a7c(%rip), %rax     # 0x90932
leaq 0x629ab(%rip), %r8      # 0x6e868
cmovaeq %rax, %r8
leaq 0x9eef8(%rip), %rdi     # 0xaadc0
leaq 0x831f6(%rip), %rdx     # 0x8f0c5
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4890
jmp 0xbf7b
cmpq $0xfffff, %rbx          # imm = 0xFFFFF
ja 0xbf0d
cvtsi2ss %rbx, %xmm0
mulss 0x623c3(%rip), %xmm0    # 0x6e2bc
cvtss2sd %xmm0, %xmm0
leaq 0x9eebc(%rip), %rdi     # 0xaadc0
leaq 0x831c5(%rip), %rdx     # 0x8f0d0
jmp 0xbf6f
testq %rbx, %rbx
js 0xbf19
cvtsi2ss %rbx, %xmm0
jmp 0xbf30
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cmpq $0x3fffffff, %rbx       # imm = 0x3FFFFFFF
ja 0xbf55
mulss 0x62377(%rip), %xmm0    # 0x6e2b8
cvtss2sd %xmm0, %xmm0
leaq 0x9ee74(%rip), %rdi     # 0xaadc0
leaq 0x83186(%rip), %rdx     # 0x8f0d9
jmp 0xbf6f
mulss 0x62357(%rip), %xmm0    # 0x6e2b4
cvtss2sd %xmm0, %xmm0
leaq 0x9ee58(%rip), %rdi     # 0xaadc0
leaq 0x83173(%rip), %rdx     # 0x8f0e2
movl $0x100, %esi            # imm = 0x100
movb $0x1, %al
callq 0x4890
movb 0x9cb27(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xbfa4
leaq 0x9c6e4(%rip), %rdi     # 0xa8670
callq 0x43f0
leaq 0x9ee28(%rip), %rax     # 0xaadc0
popq %rbx
retq
callq 0x4b05
jmp 0xbe96
callq 0x4b55
jmp 0xbf85
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movb 0x9c776(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xc377
leaq 0x9c293(%rip), %rdi     # 0xa85d0
callq 0x47a0
movb 0x9c770(%rip), %al      # 0xa8ab8
testb %al, %al
je 0xc37e
testq %rbx, %rbx
je 0xc358
movq %rbx, 0x9c758(%rip)     # 0xa8ab0
movb 0x9c74a(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xc385
leaq 0x9c267(%rip), %rdi     # 0xa85d0
callq 0x43f0
movq 0x9c73b(%rip), %rax     # 0xa8ab0
popq %rbx
retq
callq 0x4ba5
jmp 0xc336
callq 0x4bf5
jmp 0xc34c
callq 0x4c26
jmp 0xc362
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movb 0x9c2b6(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xc831
leaq 0x9bdab(%rip), %rdi     # 0xa85a8
callq 0x47a0
testb %bpl, %bpl
je 0xc80d
movl %ebx, 0x9bd5b(%rip)     # 0xa8568
movb 0x9c295(%rip), %al      # 0xa8aa8
testb %al, %al
je 0xc838
leaq 0x9bd8a(%rip), %rdi     # 0xa85a8
callq 0x43f0
leaq 0x9bd3e(%rip), %rax     # 0xa8568
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4c76
jmp 0xc7f6
callq 0x4cc6
jmp 0xc817
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movl %edi, %ebx
movb 0x9c260(%rip), %al      # 0xa8aa8
cmpl $0x1, %esi
je 0xc86d
testl %esi, %esi
jne 0xc88b
testb %al, %al
je 0xc8a6
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0x9bd46(%rip), %rcx     # 0xa85a8
leaq (%rcx,%rax,8), %rdi
callq 0x43f0
jmp 0xc887
testb %al, %al
je 0xc8ad
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0x9bd2a(%rip), %rcx     # 0xa85a8
leaq (%rcx,%rax,8), %rdi
callq 0x47a0
xorl %eax, %eax
popq %rbx
retq
testb %al, %al
je 0xc8b4
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0x9bd0c(%rip), %rcx     # 0xa85a8
leaq (%rcx,%rax,8), %rdi
popq %rbx
jmp 0x4090
callq 0x4d66
jmp 0xc855
callq 0x4d16
jmp 0xc871
callq 0x4db6
jmp 0xc88f
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %esi
movl $0x26, %edx
movl $0x1, %ecx
movl $0x3, %r8d
callq 0xe578
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movq %r9, %rax
imulq %r8, %rax
testq %rax, %rax
je 0xe20f
movq 0x18(%rbx), %rcx
movl 0x8(%rbx), %edx
imulq %rdx, %rax
leaq (%rcx,%rax,2), %rdx
addq %rcx, %rax
leaq 0x606b3(%rip), %rsi     # 0x6e870
xorl %edi, %edi
movzbl (%rsi), %r10d
testl %r10d, %r10d
je 0xe1fc
movb 0x1(%rsi), %r8b
movb 0x2(%rsi), %r9b
movb 0x3(%rsi), %r11b
leal -0x1(%r10), %r14d
movb %r8b, (%rcx)
incq %rcx
movb %r9b, (%rax)
incq %rax
movb %r11b, (%rdx)
incq %rdx
decl %r10d
jne 0xe1d8
addq %r14, %rdi
incq %rdi
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
addq $0x4, %rsi
movl %r8d, %r10d
movl %r9d, %r11d
imulq %r10, %r11
cmpq %r11, %rdi
jb 0xe1bf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
sete %r8b
movl (%rdi), %edi
movl 0x4(%rax), %edx
testl %edi, %edi
sete %r9b
orb %r8b, %r9b
testl %edx, %edx
sete %r10b
movl 0x8(%rax), %r8d
testl %r8d, %r8d
sete %r11b
orb %r10b, %r11b
orb %r9b, %r11b
movl 0xc(%rax), %r9d
testl %r9d, %r9d
sete %r10b
orb %r11b, %r10b
jne 0xf131
movl %edi, %edi
movl %edx, %edx
imulq %rdi, %rdx
movl %r8d, %edi
movl %r9d, %r8d
imulq %rdi, %r8
imulq %rdx, %r8
leaq (%rcx,%r8), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0xf131
addb %sil, (%rdx)
decq %rdx
cmpq 0x18(%rax), %rdx
jae 0xf125
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0xf217
cmpl $0x0, 0x1c(%rbx)
je 0xf217
movl %edx, %ebp
movl %esi, %r14d
movq %rbx, %rdi
callq 0x35406
movb 0x9bb43(%rip), %al      # 0xaad00
testb %al, %al
je 0xf225
movq 0x9bb28(%rip), %r15     # 0xaacf0
movq %r15, %rdi
callq 0x4280
movq 0x4d0(%rbx), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4470
movl %r14d, 0x44c(%rbx)
movl %ebp, 0x450(%rbx)
movb $0x0, 0x462(%rbx)
movq %r15, %rdi
callq 0x41f0
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20ec2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9bad4(%rip), %rdi     # 0xaad00
callq 0x49c0
testl %eax, %eax
je 0xf1c1
leaq 0x99a4c(%rip), %rdi     # 0xa8c88
callq 0x211ec
leaq 0x11fe2(%rip), %rdi     # 0x2122a
leaq 0x99a39(%rip), %rsi     # 0xa8c88
leaq 0x9930a(%rip), %rdx     # 0xa8560
callq 0x44c0
leaq 0x9ba9e(%rip), %rdi     # 0xaad00
callq 0x4330
jmp 0xf1c1
movq %rax, %rbx
leaq 0x9ba8a(%rip), %rdi     # 0xaad00
callq 0x4310
movq %rbx, %rdi
callq 0x4960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $0x0, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
testl %esi, %esi
je 0x11ec5
movl %edx, %r14d
movl %esi, %ebp
cmpl $-0x1, %edx
jne 0x11e95
movl (%rbx), %r14d
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x14cba
incl %r14d
decl %ebp
jne 0x11e98
testb $0x1, 0x10(%rsp)
jne 0x11ec5
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x11ec5
callq 0x4690
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x11eec
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x11eec
callq 0x4690
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x11f3a
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x11f32
shlq $0x5, %r15
cmpb $0x0, -0x8(%r14,%r15)
jne 0x11f2c
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x11f2c
callq 0x4690
addq $-0x20, %r15
jne 0x11f16
movq %r14, %rdi
callq 0x4690
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x120ab
movl %esi, %r14d
movl 0x4(%rbx), %eax
cmpl %esi, %eax
setae %cl
leal (,%r14,4), %edx
cmpl %edx, %eax
setbe %al
testb %al, %cl
jne 0x12099
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x1202f
movq -0x8(%r15), %r12
addq $-0x8, %r15
testq %r12, %r12
je 0x12027
shlq $0x5, %r12
cmpb $0x0, -0x8(%r15,%r12)
jne 0x12021
movq (%r15,%r12), %rdi
testq %rdi, %rdi
je 0x12021
callq 0x4690
addq $-0x20, %r12
jne 0x1200b
movq %r15, %rdi
callq 0x4690
movl %r14d, %eax
movl $0x1, %edx
movq %rdx, %rcx
addq %rdx, %rdx
cmpq %rax, %rcx
jb 0x12037
cmpq $0x11, %rcx
movl $0x10, %eax
cmovaeq %rcx, %rax
movl %eax, 0x4(%rbx)
movl %eax, %r12d
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rdi
callq 0x4040
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testq %r12, %r12
je 0x12095
addq $0x20, %rax
xorl %edx, %edx
xorps %xmm0, %xmm0
movq $0x0, (%rax,%rdx)
movups %xmm0, -0x18(%rax,%rdx)
movb $0x0, -0x8(%rax,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r15
jne 0x1207a
movq %rcx, 0x8(%rbx)
movl %r14d, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x120e2
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<float>::fill(float)
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:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %dl
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
testl %ecx, %ecx
sete %sil
orb %dl, %sil
testl %eax, %eax
sete %r8b
movl 0x8(%rbx), %edx
testl %edx, %edx
sete %r9b
orb %r8b, %r9b
orb %sil, %r9b
movl 0xc(%rbx), %esi
testl %esi, %esi
sete %r8b
orb %r9b, %r8b
jne 0x1e182
movl %ecx, %ecx
movl %eax, %eax
movl %edx, %edx
movl %esi, %esi
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1e047
jnp 0x1e16b
imulq %rcx, %rax
imulq %rsi, %rdx
imulq %rax, %rdx
testq %rdx, %rdx
jle 0x1e182
leaq (%rdi,%rdx,4), %rax
leaq 0x4(%rdi), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rdi, %rax
notq %rax
addq %rcx, %rax
movq %rax, %xmm1
shrq $0x2, %rax
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psrlq $0x2, %xmm1
addq $0x4, %rax
andq $-0x4, %rax
xorl %ecx, %ecx
movdqa 0x50107(%rip), %xmm2    # 0x6e1a0
movdqa 0x500cf(%rip), %xmm3    # 0x6e170
movdqa 0x500d7(%rip), %xmm4    # 0x6e180
pxor %xmm4, %xmm1
pcmpeqd %xmm5, %xmm5
movq %rcx, %xmm6
pshufd $0x44, %xmm6, %xmm6     # xmm6 = xmm6[0,1,0,1]
movdqa %xmm6, %xmm7
por %xmm3, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm1, %xmm8
pcmpeqd %xmm1, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %edx
notl %edx
testb $0x1, %dl
je 0x1e0fb
movss %xmm0, (%rdi,%rcx,4)
pxor %xmm5, %xmm7
pextrw $0x4, %xmm7, %edx
testb $0x1, %dl
je 0x1e10f
movss %xmm0, 0x4(%rdi,%rcx,4)
por %xmm2, %xmm6
pxor %xmm4, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm5, %xmm6
pextrw $0x0, %xmm6, %edx
testb $0x1, %dl
je 0x1e14c
movss %xmm0, 0x8(%rdi,%rcx,4)
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x1e15c
movss %xmm0, 0xc(%rdi,%rcx,4)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x1e0b1
jmp 0x1e182
imulq %rax, %rcx
imulq %rsi, %rdx
imulq %rcx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x4290
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x14757
movl %edx, %ebp
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1477e
cmpl $0x0, (%r15)
jle 0x1473d
xorl %r15d, %r15d
movzbl %bpl, %ebp
xorl %r12d, %r12d
movq 0x18(%rsp), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rax
movq 0x18(%rax,%r15), %rsi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
movl 0x8(%rax,%r15), %r8d
movl 0xc(%rax,%r15), %r9d
movl %ebp, (%rsp)
callq 0x14334
incq %r12
movslq 0x10(%rsp), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x14700
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x14806
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfa04
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14769
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfa04
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x13a26
movslq (%r14), %rax
testq %rax, %rax
jle 0x148bb
movq 0x8(%r14), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
xorl %edi, %edi
andb $0x1, %dil
orb 0x10(%rcx,%rsi), %dil
addq $0x20, %rsi
cmpq %rsi, %rdx
jne 0x14839
testb %dil, %dil
je 0x1488f
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rax
movq 0x18(%rax,%r15), %rsi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
movl 0x8(%rax,%r15), %r8d
movl 0xc(%rax,%r15), %r9d
callq 0x14476
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x14856
jmp 0x148bb
testl %eax, %eax
jle 0x148bb
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq 0x8(%rbx), %rsi
addq %r15, %rsi
callq 0xeed2
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x14899
movq %r14, %rdi
callq 0x11ef4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>::get_shared_channels(unsigned int, unsigned int)
CImg<T> get_shared_channels(const unsigned int c0, const unsigned int c1) {
      const unsigned int beg = offset(0,0,0,c0), end = offset(0,0,0,c1);
      if (beg>end || beg>=size() || end>=size())
        throw CImgArgumentException(_cimg_instance
                                    "get_shared_channels(): Invalid request of a shared-memory subset "
                                    "(0->%u,0->%u,0->%u,%u->%u).",
                                    cimg_instance,
                                    _width-1,_height-1,_depth-1,c0,c1);

      return CImg<T>(_data+beg,_width,_height,_depth,c1-c0+1,true);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
movl %edx, %r9d
movl 0x8(%rsi), %edx
movq %rcx, %rsi
imulq %rax, %rsi
imulq %rdx, %r9
imulq %rsi, %r9
movl %ebx, %r8d
imulq %rdx, %r8
imulq %rsi, %r8
cmpl %r8d, %r9d
ja 0x153cf
movl %r9d, %r9d
imulq %rdx, %rsi
movl 0xc(%r14), %r10d
imulq %rsi, %r10
cmpq %r10, %r9
jae 0x153cf
movl %r8d, %r8d
cmpq %r10, %r8
jae 0x153cf
movq 0x18(%r14), %r8
subl %r15d, %ebx
incl %ebx
imulq %rbx, %rsi
testq %r8, %r8
sete %r10b
testq %rsi, %rsi
sete %sil
orb %r10b, %sil
jne 0x1539d
addq %r9, %r8
movb $0x1, %sil
jmp 0x153aa
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %r8d, %r8d
movl %eax, (%rdi)
movl %ecx, 0x4(%rdi)
movl %edx, 0x8(%rdi)
movl %ebx, 0xc(%rdi)
movb %sil, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r12
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
leaq 0x5947a(%rip), %rax     # 0x6e868
leaq 0x5a84d(%rip), %r10     # 0x6fc42
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
movl 0xc(%r14), %r9d
leal -0x1(%rdx), %r11d
leal -0x1(%rcx), %r13d
leal -0x1(%r8), %ebp
leaq 0x78f56(%rip), %rsi     # 0x8e36b
movq %r12, %rdi
xorl %eax, %eax
pushq %rbx
pushq %r15
pushq %rbp
pushq %r13
pushq %r11
leaq 0x653de(%rip), %r11     # 0x7a807
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0xc16a
addq $0x40, %rsp
leaq 0x9280f(%rip), %rsi     # 0xa7c50
movq 0x92b88(%rip), %rdx     # 0xa7fd0
movq %r12, %rdi
callq 0x4910
movq %rax, %rbx
movq %r12, %rdi
callq 0x43c0
movq %rbx, %rdi
callq 0x4960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1e1fc
movq %rsi, %r14
movl %edx, %eax
movl %ecx, %esi
imulq %rax, %rsi
movl %r8d, %eax
movl %r9d, %edi
imulq %rax, %rdi
imulq %rsi, %rdi
testq %rdi, %rdi
je 0x1e1fc
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %r9d, %r8d
callq 0x104de
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
imulq %rax, %rcx
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %eax
imulq %rdx, %rax
imulq %rcx, %rax
testq %rax, %rax
jle 0x1e222
movq 0x18(%rbx), %rcx
addq %rcx, %rax
cvttss2si (%r14), %edx
addq $0x4, %r14
movb %dl, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x1e1e7
jmp 0x1e222
cmpb $0x0, 0x10(%rbx)
jne 0x1e210
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1e210
callq 0x4690
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x1e320
movdqu (%rbx), %xmm2
pxor %xmm1, %xmm1
pcmpeqd %xmm2, %xmm1
movmskps %xmm1, %eax
testb %al, %al
jne 0x1e320
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1e332
pshufd $0xff, %xmm2, %xmm1     # xmm1 = xmm2[3,3,3,3]
movd %xmm1, %eax
testl %eax, %eax
jle 0x1e320
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
xorl %r14d, %r14d
movss %xmm0, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movzbl (%rdi,%r14), %eax
movq %rbx, %rdi
movl %esi, %ebx
movl %r13d, %edx
movl %r12d, %ecx
movl %r14d, %r8d
movl %r15d, %r9d
pushq %rax
pushq %r14
movl 0x60(%rsp), %eax
pushq %rax
pushq %rbp
callq 0x1505e
movq 0x78(%rsp), %rdi
movl %ebx, %esi
movq 0x30(%rsp), %rbx
movss 0x2c(%rsp), %xmm0
addq $0x20, %rsp
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x1e2da
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
leaq 0x50515(%rip), %rax     # 0x6e868
leaq 0x518e8(%rip), %r10     # 0x6fc42
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x5c49a(%rip), %r11     # 0x7a807
leaq 0x7026a(%rip), %rsi     # 0x8e5de
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xc16a
addq $0x20, %rsp
leaq 0x898c0(%rip), %rsi     # 0xa7c50
movq 0x89c39(%rip), %rdx     # 0xa7fd0
movq %r14, %rdi
callq 0x4910
movq %rax, %rbx
movq %r14, %rdi
callq 0x43c0
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay& cimg_library::CImgDisplay::assign<unsigned char>(cimg_library::CImg<unsigned char> const&, char const*, unsigned int, bool, bool)
CImgDisplay& assign(const CImg<T>& img, const char *const title=0,
                        const unsigned int normalization_type=3,
                        const bool fullscreen_flag=false, const bool closed_flag=false) {
      if (!img) return assign();
      CImg<T> tmp;
      const CImg<T>& nimg = (img._depth==1)?img:(tmp=img.get_projections2d((img._width-1)/2,
                                                                           (img._height-1)/2,
                                                                           (img._depth-1)/2));
      _assign(nimg._width,nimg._height,title,normalization_type,fullscreen_flag,closed_flag);
      if (_normalization==2) _min = (float)nimg.min_max(_max);
      return render(nimg).paint();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0x1e4cc
movl %r9d, %r13d
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq $0x0, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
movl 0x8(%rsi), %r8d
cmpl $0x1, %r8d
je 0x1e446
movl (%r14), %edx
movl 0x4(%r14), %ecx
decl %edx
shrl %edx
decl %ecx
shrl %ecx
decl %r8d
shrl %r8d
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x1e952
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1ed3a
movq %rax, %r14
cmpb $0x0, 0x48(%rsp)
jne 0x1e446
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1e446
callq 0x4690
movl (%r14), %esi
movl 0x4(%r14), %edx
movzbl %r13b, %eax
movl %eax, (%rsp)
movzbl %r12b, %r9d
movq %rbx, %rdi
movq %r15, %rcx
movl %ebp, %r8d
callq 0x1ed6a
cmpl $0x2, 0x20(%rbx)
jne 0x1e487
leaq 0x2c(%rbx), %rsi
movq %r14, %rdi
callq 0x1f9ac
movzbl (%rax), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1fab2
movq %rax, %rdi
movl $0x1, %esi
callq 0x20ec2
movq %rax, %rbx
cmpb $0x0, 0x20(%rsp)
jne 0x1e4ba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1e4ba
callq 0x4690
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e520
movq %rax, %rbx
cmpb $0x0, 0x48(%rsp)
jne 0x1e502
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1e502
callq 0x4690
jmp 0x1e502
jmp 0x1e4ff
movq %rax, %rbx
cmpb $0x0, 0x20(%rsp)
jne 0x1e518
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1e518
callq 0x4690
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: unsigned int const& cimg_library::CImg<unsigned int>::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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x315a6
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x315a6
movl 0x4(%rbx), %edx
testl %edx, %edx
je 0x315a6
movl 0x8(%rbx), %r8d
testl %r8d, %r8d
je 0x315a6
movl 0xc(%rbx), %edi
testl %edi, %edi
je 0x315a6
imulq %rcx, %rdx
imulq %r8, %rdi
movl (%rax), %ecx
imulq %rdx, %rdi
testq %rdi, %rdi
jle 0x31591
leaq (%rax,%rdi,4), %rdi
movq %rax, %r8
movl %ecx, %edx
movl (%r8), %r9d
cmpl %ecx, %r9d
cmovbl %r9d, %ecx
cmovbq %r8, %rax
cmpl %edx, %r9d
cmoval %r9d, %edx
addq $0x4, %r8
cmpq %rdi, %r8
jb 0x31571
jmp 0x31593
movl %ecx, %edx
movl %edx, %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
leaq 0x3d2a1(%rip), %rax     # 0x6e868
leaq 0x3e674(%rip), %r10     # 0x6fc42
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x5cff0(%rip), %r11     # 0x8e5d1
leaq 0x5d2de(%rip), %rsi     # 0x8e8c6
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xbfac
addq $0x20, %rsp
leaq 0x76634(%rip), %rsi     # 0xa7c38
movq 0x769c5(%rip), %rdx     # 0xa7fd0
movq %r14, %rdi
callq 0x4910
movq %rax, %rbx
movq %r14, %rdi
callq 0x43c0
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x20f04
cmpl $0x0, 0x1c(%rbx)
je 0x20f04
movl %esi, %ebp
movb 0x89e23(%rip), %al      # 0xaad00
testb %al, %al
je 0x20f0c
movq 0x89e08(%rip), %r14     # 0xaacf0
movq %r14, %rdi
callq 0x4280
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x2421a
movq %r14, %rdi
callq 0x41f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x89ded(%rip), %rdi     # 0xaad00
callq 0x49c0
testl %eax, %eax
je 0x20ee1
leaq 0x87d65(%rip), %rdi     # 0xa8c88
callq 0x211ec
leaq 0x2fb(%rip), %rdi       # 0x2122a
leaq 0x87d52(%rip), %rsi     # 0xa8c88
leaq 0x87623(%rip), %rdx     # 0xa8560
callq 0x44c0
leaq 0x89db7(%rip), %rdi     # 0xaad00
callq 0x4330
jmp 0x20ee1
movq %rax, %rbx
leaq 0x89da6(%rip), %rdi     # 0xaad00
callq 0x4310
movq %rbx, %rdi
callq 0x4960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
callq 0xf558
movq %rax, %rdi
callq 0x210d8
movq %rax, %rdi
callq 0x21160
movb $0x0, 0x463(%rbx)
movb 0x463(%rbx), %al
movb %al, 0x462(%rbx)
movb 0x462(%rbx), %al
movb %al, 0x461(%rbx)
movl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x30(%rdi)
jne 0x21075
movq %rdi, %rbx
movb 0x89cc3(%rip), %al      # 0xaad00
testb %al, %al
je 0x2107d
movq 0x89ca8(%rip), %r14     # 0xaacf0
movq %r14, %rdi
xorl %esi, %esi
callq 0x4680
movq 0x4d8(%rbx), %rsi
testq %rsi, %rsi
je 0x21066
movq %r14, %rdi
callq 0x4870
movq $0x0, 0x4d8(%rbx)
movb $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x89c7c(%rip), %rdi     # 0xaad00
callq 0x49c0
testl %eax, %eax
je 0x21041
leaq 0x87bf4(%rip), %rdi     # 0xa8c88
callq 0x211ec
leaq 0x18a(%rip), %rdi       # 0x2122a
leaq 0x87be1(%rip), %rsi     # 0xa8c88
leaq 0x874b2(%rip), %rdx     # 0xa8560
callq 0x44c0
leaq 0x89c46(%rip), %rdi     # 0xaad00
callq 0x4330
jmp 0x21041
movq %rax, %rbx
leaq 0x89c35(%rip), %rdi     # 0xaad00
callq 0x4310
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x48(%rdi)
movb $0x1, 0x463(%rdi)
movb 0x89c10(%rip), %al      # 0xaad00
testb %al, %al
je 0x21105
leaq 0x87b9d(%rip), %rdi     # 0xa8c98
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x89bf4(%rip), %rdi     # 0xaad00
callq 0x49c0
testl %eax, %eax
je 0x210f4
leaq 0x87b6c(%rip), %rdi     # 0xa8c88
callq 0x211ec
leaq 0x102(%rip), %rdi       # 0x2122a
leaq 0x87b59(%rip), %rsi     # 0xa8c88
leaq 0x8742a(%rip), %rdx     # 0xa8560
callq 0x44c0
leaq 0x89bbe(%rip), %rdi     # 0xaad00
callq 0x4330
jmp 0x210f4
movq %rax, %rbx
leaq 0x89bad(%rip), %rdi     # 0xaad00
callq 0x4310
movq %rbx, %rdi
callq 0x4960
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x45c(%rdi)
movb $0x1, 0x463(%rdi)
movb 0x89b85(%rip), %al      # 0xaad00
testb %al, %al
je 0x21190
leaq 0x87b12(%rip), %rdi     # 0xa8c98
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x89b69(%rip), %rdi     # 0xaad00
callq 0x49c0
testl %eax, %eax
je 0x2117f
leaq 0x87ae1(%rip), %rdi     # 0xa8c88
callq 0x211ec
leaq 0x77(%rip), %rdi        # 0x2122a
leaq 0x87ace(%rip), %rsi     # 0xa8c88
leaq 0x8739f(%rip), %rdx     # 0xa8560
callq 0x44c0
leaq 0x89b33(%rip), %rdi     # 0xaad00
callq 0x4330
jmp 0x2117f
movq %rax, %rbx
leaq 0x89b22(%rip), %rdi     # 0xaad00
callq 0x4310
movq %rbx, %rdi
callq 0x4960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x2068(%rdi)
movq %rax, 0x206f(%rdi)
callq 0x4460
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0x47c0
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x45e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x21248
movq (%rax), %rdi
callq 0x4720
movq 0x8(%rbx), %rdi
callq 0x44f0
leaq 0x10(%rbx), %rdi
callq 0x4a70
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x43f0
movq %rbx, %rdi
popq %rbx
jmp 0x45c0
movq %rax, %rdi
callq 0xa02c
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>::min() const
const T& min() const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "min(): Empty instance.",
                                    cimg_instance);
      const T *ptr_min = _data;
      T min_value = *ptr_min;
      cimg_for(*this,ptrs,T) if (*ptrs<min_value) min_value = *(ptr_min=ptrs);
      return *ptr_min;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x21348
movl (%rbx), %esi
testl %esi, %esi
je 0x21348
movl 0x4(%rbx), %edx
testl %edx, %edx
je 0x21348
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x21348
movl 0xc(%rbx), %ecx
testl %ecx, %ecx
je 0x21348
imulq %rsi, %rdx
imulq %rdi, %rcx
imulq %rdx, %rcx
testq %rcx, %rcx
jle 0x21340
addq %rax, %rcx
movb (%rax), %dl
movq %rax, %rsi
movzbl (%rsi), %edi
cmpb %dl, %dil
movzbl %dl, %edx
cmovbl %edi, %edx
cmovbq %rsi, %rax
incq %rsi
cmpq %rcx, %rsi
jb 0x21328
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
leaq 0x4d4ff(%rip), %rax     # 0x6e868
leaq 0x4e8d2(%rip), %r10     # 0x6fc42
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x59484(%rip), %r11     # 0x7a807
leaq 0x6d3df(%rip), %rsi     # 0x8e769
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xbfac
addq $0x20, %rsp
leaq 0x86892(%rip), %rsi     # 0xa7c38
movq 0x86c23(%rip), %rdx     # 0xa7fd0
movq %r14, %rdi
callq 0x4910
movq %rax, %rbx
movq %r14, %rdi
callq 0x43c0
movq %rbx, %rdi
callq 0x4960