LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::CImg(unsigned int, unsigned int, unsigned int, unsigned int, double)
CImg(const unsigned int size_x, const unsigned int size_y,
         const unsigned int size_z, const unsigned int size_c, const T value):
      _is_shared(false) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (siz) {
        _width = size_x; _height = size_y; _depth = size_z; _spectrum = size_c;
        try { _data = new T[siz]; } catch (...) {
          _width = _height = _depth = _spectrum = 0; _data = 0;
          throw CImgInstanceException(_cimg_instance
                                      "CImg(): Failed to allocate memory (%s) for image (%u,%u,%u,%u).",
                                      cimg_instance,
                                      cimg::strbuffersize(sizeof(T)*size_x*size_y*size_z*size_c),
                                      size_x,size_y,size_z,size_c);
        }
        fill(value);
      } else { _width = _height = _depth = _spectrum = 0; _data = 0; }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %r13
movb $0x0, 0x10(%rdi)
movl %esi, %eax
movl %edx, %ecx
movl %r15d, %edx
imulq %rcx, %rdx
movl %r8d, %ebp
imulq %rax, %rbp
imulq %rdx, %rbp
testq %rbp, %rbp
je 0x7256
movl %r8d, %r12d
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movl %esi, (%r13)
movl %r14d, 0x4(%r13)
movl %r15d, 0x8(%r13)
movl %r8d, 0xc(%r13)
movq %rbp, %rax
shrq $0x3d, %rax
shlq $0x3, %rbp
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbp, %rdi
callq 0x4040
movq %rax, 0x18(%r13)
movq %r13, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38fd2
movq $0x0, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x41d0
movq $0x0, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, 0x8(%rsp)
movl (%r13), %eax
movl %eax, 0x1c(%rsp)
movl 0x4(%r13), %eax
movl %eax, 0x18(%rsp)
movl 0x8(%r13), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%r13), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%r13), %rax
movq %rax, 0x20(%rsp)
movb 0x10(%r13), %r13b
movq %rbp, %rdi
callq 0xbeb1
movq %rax, %r10
leaq 0x6c05d(%rip), %rax     # 0x73338
leaq 0x6d430(%rip), %r11     # 0x74712
testb %r13b, %r13b
cmovneq %rax, %r11
leaq 0x8c8ff(%rip), %r13     # 0x93bef
leaq 0x8b953(%rip), %rsi     # 0x92c4a
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %r9d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r10
pushq %r13
pushq %r11
pushq 0x58(%rsp)
callq 0xbfd8
addq $0x40, %rsp
leaq 0xa58d7(%rip), %rsi     # 0xacc08
movq 0xa5c98(%rip), %rdx     # 0xacfd0
movq 0x8(%rsp), %rdi
callq 0x4900
movq %rax, %rbx
jmp 0x7354
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x43b0
callq 0x48c0
movq %rbx, %rdi
callq 0x4950
movq %rax, %rdi
callq 0xa08f
nop
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::CImg(unsigned int, unsigned int, unsigned int, unsigned int)
explicit CImg(const unsigned int size_x, const unsigned int size_y=1,
                  const unsigned int size_z=1, const unsigned int size_c=1):
      _is_shared(false) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (siz) {
        _width = size_x; _height = size_y; _depth = size_z; _spectrum = size_c;
        try { _data = new T[siz]; } catch (...) {
          _width = _height = _depth = _spectrum = 0; _data = 0;
          throw CImgInstanceException(_cimg_instance
                                      "CImg(): Failed to allocate memory (%s) for image (%u,%u,%u,%u).",
                                      cimg_instance,
                                      cimg::strbuffersize(sizeof(T)*size_x*size_y*size_z*size_c),
                                      size_x,size_y,size_z,size_c);
        }
      } else { _width = _height = _depth = _spectrum = 0; _data = 0; }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %r13
movb $0x0, 0x10(%rdi)
movl %esi, %eax
movl %edx, %ecx
movl %r15d, %edx
imulq %rcx, %rdx
movl %r8d, %ebp
imulq %rax, %rbp
imulq %rdx, %rbp
testq %rbp, %rbp
je 0x873e
movl %r8d, %r12d
movl %esi, %ebx
movl %esi, (%r13)
movl %r14d, 0x4(%r13)
movl %r15d, 0x8(%r13)
movl %r8d, 0xc(%r13)
movq %rbp, %rax
shrq $0x3d, %rax
shlq $0x3, %rbp
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbp, %rdi
callq 0x4040
movq %rax, 0x18(%r13)
jmp 0x874e
movq $0x0, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x41d0
movq $0x0, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, 0x8(%rsp)
movl (%r13), %eax
movl %eax, 0x1c(%rsp)
movl 0x4(%r13), %eax
movl %eax, 0x18(%rsp)
movl 0x8(%r13), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%r13), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%r13), %rax
movq %rax, 0x20(%rsp)
movb 0x10(%r13), %r13b
movq %rbp, %rdi
callq 0xbeb1
movq %rax, %r10
leaq 0x6ab75(%rip), %rax     # 0x73338
leaq 0x6bf48(%rip), %r11     # 0x74712
testb %r13b, %r13b
cmovneq %rax, %r11
leaq 0x8b417(%rip), %r13     # 0x93bef
leaq 0x8a46b(%rip), %rsi     # 0x92c4a
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %r9d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r10
pushq %r13
pushq %r11
pushq 0x58(%rsp)
callq 0xbfd8
addq $0x40, %rsp
leaq 0xa43ef(%rip), %rsi     # 0xacc08
movq 0xa47b0(%rip), %rdx     # 0xacfd0
movq 0x8(%rsp), %rdi
callq 0x4900
movq %rax, %rbx
jmp 0x883c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x43b0
callq 0x48c0
movq %rbx, %rdi
callq 0x4950
movq %rax, %rdi
callq 0xa08f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a1a4
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 0xb8ee
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x39cdc
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 0x46b8c
addq $0x30, %rsp
cmpb $0x0, 0x10(%rsp)
jne 0x9887
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9887
callq 0x4680
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x39fe4
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x39d4a
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movups 0x20(%rbx), %xmm0
movq 0x30(%rbx), %rax
leaq 0x60(%rsp), %r14
movaps (%r14), %xmm1
movups %xmm1, 0x20(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x30(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r14)
movq %rcx, 0x10(%r14)
callq 0xa09a
movq %r14, %rdi
callq 0xa09a
cmpb $0x0, 0x10(%rsp)
jne 0x990d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x990d
callq 0x4680
cmpb $0x0, 0x50(%rsp)
jne 0x9923
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x9923
callq 0x4680
cmpb $0x0, 0x30(%rsp)
jne 0x9939
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x9939
callq 0x4680
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
cmpb $0x0, 0x10(%rsp)
jne 0x9966
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9966
callq 0x4680
jmp 0x9966
movq %rax, %r14
cmpb $0x0, 0x50(%rsp)
jne 0x9999
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x9999
jmp 0x998d
movq %rax, %r14
cmpb $0x0, 0x10(%rsp)
jne 0x9999
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9999
callq 0x4680
jmp 0x9999
jmp 0x9996
movq %rax, %r14
cmpb $0x0, 0x30(%rsp)
jne 0x99b6
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x99b6
callq 0x4680
jmp 0x99b6
jmp 0x99b3
movq %rax, %r14
leaq 0x20(%rbx), %r15
leaq 0x58(%rbx), %rdi
callq 0xa09a
cmpb $0x0, 0x48(%rbx)
jne 0x99da
leaq 0x50(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x99da
callq 0x4680
movq %r15, %rdi
callq 0xa09a
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x99ef
callq 0x44e0
movq %r14, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb6ea
cmpb $0x1, 0x10(%rbx)
jne 0xb707
movq 0x18(%r14), %rsi
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
movq %rbx, %rdi
callq 0xb8ee
jmp 0xb712
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3910c
cmpb $0x0, 0x10(%r14)
jne 0xb727
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb727
callq 0x4680
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_O1/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 0xb851
movl %r9d, %ebp
movl %r8d, %r14d
cmpb $0x0, 0x40(%rsp)
je 0xb877
testb %cl, %cl
jne 0xb8c5
leaq (%r15,%rax,8), %rax
movq 0x18(%rbx), %r9
cmpq %r9, %rax
jb 0xb8a6
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 0xb8a6
leaq 0x883bd(%rip), %r10     # 0x93bef
leaq 0x68ed9(%rip), %r11     # 0x74712
leaq 0x68e6c(%rip), %rdi     # 0x746ac
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0xbb52
addq $0x10, %rsp
jmp 0xb8c5
testb %cl, %cl
jne 0xb863
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb863
callq 0x4680
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
jmp 0xb8db
testb %cl, %cl
je 0xb88d
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 0xb8ee
jmp 0xb8db
testq %r9, %r9
je 0xb8b3
movq %r9, %rdi
callq 0x4680
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
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_O1/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 0xbbb3
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 0xc824
cmpl $0x0, (%rax)
je 0xbc32
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 0xc354
leaq 0x87fb6(%rip), %rsi     # 0x93bd1
leaq 0x67716(%rip), %rcx     # 0x73338
movq %rax, %rdi
movq %rcx, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x4740
addq $0x40d8, %rsp           # imm = 0x40D8
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa1bdd(%rip), %al      # 0xada98
testb %al, %al
je 0xbfc7
leaq 0xa1796(%rip), %rdi     # 0xad660
callq 0x4790
cmpq $0x3ff, %rbx            # imm = 0x3FF
ja 0xbf10
cmpq $0x2, %rbx
leaq 0x8951f(%rip), %rax     # 0x95402
leaq 0x6744e(%rip), %r8      # 0x73338
cmovaeq %rax, %r8
leaq 0xa3ebb(%rip), %rdi     # 0xafdb0
leaq 0x87c99(%rip), %rdx     # 0x93b95
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4880
jmp 0xbfa8
cmpq $0xfffff, %rbx          # imm = 0xFFFFF
ja 0xbf3a
cvtsi2ss %rbx, %xmm0
mulss 0x65396(%rip), %xmm0    # 0x712bc
cvtss2sd %xmm0, %xmm0
leaq 0xa3e7f(%rip), %rdi     # 0xafdb0
leaq 0x87c68(%rip), %rdx     # 0x93ba0
jmp 0xbf9c
testq %rbx, %rbx
js 0xbf46
cvtsi2ss %rbx, %xmm0
jmp 0xbf5d
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 0xbf82
mulss 0x6534a(%rip), %xmm0    # 0x712b8
cvtss2sd %xmm0, %xmm0
leaq 0xa3e37(%rip), %rdi     # 0xafdb0
leaq 0x87c29(%rip), %rdx     # 0x93ba9
jmp 0xbf9c
mulss 0x6532a(%rip), %xmm0    # 0x712b4
cvtss2sd %xmm0, %xmm0
leaq 0xa3e1b(%rip), %rdi     # 0xafdb0
leaq 0x87c16(%rip), %rdx     # 0x93bb2
movl $0x100, %esi            # imm = 0x100
movb $0x1, %al
callq 0x4880
movb 0xa1aea(%rip), %al      # 0xada98
testb %al, %al
je 0xbfd1
leaq 0xa16a7(%rip), %rdi     # 0xad660
callq 0x43e0
leaq 0xa3deb(%rip), %rax     # 0xafdb0
popq %rbx
retq
callq 0x4af5
jmp 0xbec3
callq 0x4b45
jmp 0xbfb2
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa173a(%rip), %al      # 0xada98
testb %al, %al
je 0xc3a3
leaq 0xa1257(%rip), %rdi     # 0xad5c0
callq 0x4790
movb 0xa1734(%rip), %al      # 0xadaa8
testb %al, %al
je 0xc3aa
testq %rbx, %rbx
je 0xc384
movq %rbx, 0xa171c(%rip)     # 0xadaa0
movb 0xa170e(%rip), %al      # 0xada98
testb %al, %al
je 0xc3b1
leaq 0xa122b(%rip), %rdi     # 0xad5c0
callq 0x43e0
movq 0xa16ff(%rip), %rax     # 0xadaa0
popq %rbx
retq
callq 0x4b95
jmp 0xc362
callq 0x4be5
jmp 0xc378
callq 0x4c16
jmp 0xc38e
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa1267(%rip), %al      # 0xada98
testb %al, %al
je 0xc870
leaq 0xa0d5c(%rip), %rdi     # 0xad598
callq 0x4790
testb %bpl, %bpl
je 0xc84c
movl %ebx, 0xa0d14(%rip)     # 0xad560
movb 0xa1246(%rip), %al      # 0xada98
testb %al, %al
je 0xc877
leaq 0xa0d3b(%rip), %rdi     # 0xad598
callq 0x43e0
leaq 0xa0cf7(%rip), %rax     # 0xad560
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4c66
jmp 0xc835
callq 0x4cb6
jmp 0xc856
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa1211(%rip), %al      # 0xada98
cmpl $0x1, %esi
je 0xc8ac
testl %esi, %esi
jne 0xc8ca
testb %al, %al
je 0xc8e5
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0xa0cf7(%rip), %rcx     # 0xad598
leaq (%rcx,%rax,8), %rdi
callq 0x43e0
jmp 0xc8c6
testb %al, %al
je 0xc8ec
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0xa0cdb(%rip), %rcx     # 0xad598
leaq (%rcx,%rax,8), %rdi
callq 0x4790
xorl %eax, %eax
popq %rbx
retq
testb %al, %al
je 0xc8f3
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
leaq 0xa0cbd(%rip), %rcx     # 0xad598
leaq (%rcx,%rax,8), %rdi
popq %rbx
jmp 0x4090
callq 0x4d56
jmp 0xc894
callq 0x4d06
jmp 0xc8b0
callq 0x4da6
jmp 0xc8ce
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe57e
cmpl $0x0, (%rbx)
sete %al
cmpl $0x0, 0x4(%rbx)
sete %cl
orb %al, %cl
jne 0xe21a
movq 0x18(%rbx), %rax
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
imulq %rcx, %rdx
movl 0x8(%rbx), %ecx
imulq %rdx, %rcx
leaq (%rax,%rcx,2), %rdx
addq %rax, %rcx
leaq 0x65172(%rip), %rsi     # 0x73340
xorl %edi, %edi
movzbl (%rsi), %r8d
testl %r8d, %r8d
je 0xe206
movb 0x1(%rsi), %r9b
movb 0x2(%rsi), %r10b
movb 0x3(%rsi), %r11b
leal -0x1(%r8), %r14d
movb %r9b, (%rax)
incq %rax
movb %r10b, (%rcx)
incq %rcx
movb %r11b, (%rdx)
incq %rdx
decl %r8d
jne 0xe1e9
addq %r14, %rdi
incq %rdi
addq $0x4, %rsi
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
imulq %r8, %r9
cmpq %r9, %rdi
jb 0xe1d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8e8, %rsp            # imm = 0x8E8
movq %rdi, %rbx
testb %al, %al
je 0xe287
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
cmpl $0x0, 0x920(%rsp)
je 0xe32f
movq %rcx, %r13
movl %edx, %ebp
movl %esi, %r12d
leaq 0xe0(%rsp), %r14
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
xorl %esi, %esi
movss %xmm0, 0x4(%rsp)
movq %r9, 0x8(%rsp)
movq %r8, %r15
callq 0x4290
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x928(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x4000000030, %rax     # imm = 0x4000000030
movq %rax, (%rcx)
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
movq %r13, %rdx
callq 0x4300
movl 0x920(%rsp), %edi
movl $0x1, %esi
callq 0xf9f6
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %r15, %r8
movq 0x8(%rsp), %r9
movss 0x4(%rsp), %xmm0
pushq $0x1
pushq %rax
callq 0xffba
addq $0x10, %rsp
movq %rbx, %rax
addq $0x8e8, %rsp            # imm = 0x8E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8e8, %rsp            # imm = 0x8E8
movq %rdi, %r14
testb %al, %al
je 0xef5f
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movl 0x920(%rsp), %eax
testl %eax, %eax
je 0xf002
movq %r8, %rbx
movq %rcx, %r13
movl %edx, %ebp
movl %esi, %r15d
leaq 0xe0(%rsp), %r12
movl $0x800, %edx            # imm = 0x800
movq %r12, %rdi
xorl %esi, %esi
movss %xmm0, 0xc(%rsp)
callq 0x4290
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x928(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x4000000030, %rax     # imm = 0x4000000030
movq %rax, (%rcx)
movl $0x800, %esi            # imm = 0x800
movq %r12, %rdi
movq %r13, %rdx
callq 0x4300
leaq 0x8642d(%rip), %rcx     # 0x95401
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %r8
xorl %r9d, %r9d
movss 0xc(%rsp), %xmm0
movb $0x1, %al
pushq %r12
movl 0x928(%rsp), %r10d
pushq %r10
callq 0xe23a
addq $0x10, %rsp
movq %rax, %r14
movq %r14, %rax
addq $0x8e8, %rsp            # imm = 0x8E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0xf0d1
movdqu (%rax), %xmm0
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %edx
testb %dl, %dl
jne 0xf0d1
movd %xmm0, %edx
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %edi
imulq %rdx, %rdi
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %edx
movl 0xc(%rax), %r8d
imulq %rdx, %r8
imulq %rdi, %r8
addq %r8, %rcx
decq %rcx
cmpq 0x18(%rax), %rcx
jb 0xf0d1
addb %sil, (%rcx)
decq %rcx
jmp 0xf0c3
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf1b7
cmpl $0x0, 0x1c(%rbx)
je 0xf1b7
movl %edx, %ebp
movl %esi, %r14d
movq %rbx, %rdi
callq 0x36fbe
movb 0xa0b93(%rip), %al      # 0xafcf0
testb %al, %al
je 0xf1c5
movq 0xa0b78(%rip), %r15     # 0xafce0
movq %r15, %rdi
callq 0x4280
movq 0x4d0(%rbx), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4460
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 0x20e5e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0b24(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0xf161
leaq 0x9ea9c(%rip), %rdi     # 0xadc78
callq 0x21188
leaq 0x11fde(%rip), %rdi     # 0x211c6
leaq 0x9ea89(%rip), %rsi     # 0xadc78
leaq 0x9e362(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0xa0aee(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0xf161
movq %rax, %rbx
leaq 0xa0ada(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11e37
movl %edx, %r14d
movl %esi, %ebp
cmpl $-0x1, %edx
jne 0x11e1d
movl (%rbx), %r14d
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x14bae
incl %r14d
decl %ebp
jne 0x11e20
cmpb $0x0, 0x10(%rsp)
jne 0x11e4d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x11e4d
callq 0x4680
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x11e74
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x11e74
callq 0x4680
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11ec2
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x11eba
shlq $0x5, %r15
cmpb $0x0, -0x8(%r14,%r15)
jne 0x11eb4
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x11eb4
callq 0x4680
addq $-0x20, %r15
jne 0x11e9e
movq %r14, %rdi
callq 0x4680
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12033
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 0x12021
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x11fb7
movq -0x8(%r15), %r12
addq $-0x8, %r15
testq %r12, %r12
je 0x11faf
shlq $0x5, %r12
cmpb $0x0, -0x8(%r15,%r12)
jne 0x11fa9
movq (%r15,%r12), %rdi
testq %rdi, %rdi
je 0x11fa9
callq 0x4680
addq $-0x20, %r12
jne 0x11f93
movq %r15, %rdi
callq 0x4680
movl %r14d, %eax
movl $0x1, %edx
movq %rdx, %rcx
addq %rdx, %rdx
cmpq %rax, %rcx
jb 0x11fbf
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 0x1201d
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 0x12002
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 0x1206a
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0x1e16a
movdqu (%rbx), %xmm1
pxor %xmm2, %xmm2
pcmpeqd %xmm1, %xmm2
movmskps %xmm2, %eax
testb %al, %al
jne 0x1e16a
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
movd %xmm1, %edx
pshufd $0x55, %xmm1, %xmm2     # xmm2 = xmm1[1,1,1,1]
movd %xmm2, %eax
jne 0x1e017
jnp 0x1e147
imulq %rdx, %rax
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
movd %xmm1, %edx
movl 0xc(%rbx), %ecx
imulq %rdx, %rcx
imulq %rax, %rcx
testq %rcx, %rcx
jle 0x1e16a
leaq (%rdi,%rcx,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 0x5311b(%rip), %xmm2    # 0x71190
movdqa 0x530e3(%rip), %xmm3    # 0x71160
movdqa 0x530eb(%rip), %xmm4    # 0x71170
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 0x1e0d7
movss %xmm0, (%rdi,%rcx,4)
pxor %xmm5, %xmm7
pextrw $0x4, %xmm7, %edx
testb $0x1, %dl
je 0x1e0eb
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 0x1e128
movss %xmm0, 0x8(%rdi,%rcx,4)
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x1e138
movss %xmm0, 0xc(%rdi,%rcx,4)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x1e08d
jmp 0x1e16a
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
movd %xmm0, %ecx
movl 0xc(%rbx), %esi
imulq %rcx, %rsi
imulq %rax, %rdx
imulq %rsi, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x4290
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14635
movl %edx, %ebp
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1465c
cmpl $0x0, (%r15)
jle 0x1461b
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 0x14200
incq %r12
movslq 0x10(%rsp), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x145de
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x146e4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf9a4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14647
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf9a4
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13934
movslq (%r14), %rax
testq %rax, %rax
jle 0x1476c
movq 0x8(%r14), %rcx
shlq $0x5, %rax
xorl %edx, %edx
xorl %esi, %esi
andb $0x1, %sil
orb 0x10(%rcx,%rdx), %sil
addq $0x20, %rdx
cmpq %rdx, %rax
jne 0x14710
testb %sil, %sil
je 0x1476c
cmpl $0x0, (%r14)
jle 0x1479a
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 0x14354
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x14733
jmp 0x1479a
cmpl $0x0, (%r14)
jle 0x1479a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq 0x8(%rbx), %rsi
addq %r15, %rsi
callq 0xeea0
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x14778
movq %r14, %rdi
callq 0x11e7c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rcx, %rsi
imulq %rax, %rsi
movl %edx, %r8d
movl 0x8(%r14), %edx
imulq %rdx, %r8
imulq %rsi, %r8
movl %ebx, %r9d
imulq %rdx, %r9
imulq %rsi, %r9
cmpl %r9d, %r8d
ja 0x15312
movl %r8d, %r8d
imulq %rdx, %rsi
movl 0xc(%r14), %r10d
imulq %rsi, %r10
cmpq %r10, %r8
jae 0x15312
movl %r9d, %r9d
cmpq %r10, %r9
jae 0x15312
movq 0x18(%r14), %r9
subl %r15d, %ebx
incl %ebx
imulq %rbx, %rsi
testq %r9, %r9
sete %r10b
testq %rsi, %rsi
sete %sil
orb %r10b, %sil
jne 0x152ee
addq %r8, %r9
movl %eax, (%rdi)
movl %ecx, 0x4(%rdi)
movl %edx, 0x8(%rdi)
movl %ebx, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movq %r9, 0x18(%rdi)
jmp 0x15300
movq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb $0x0, 0x10(%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 0x5e007(%rip), %rax     # 0x73338
leaq 0x5f3da(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
movl 0xc(%r14), %r9d
leal -0x1(%rdx), %r11d
leal -0x1(%rcx), %r13d
leal -0x1(%r8), %ebp
leaq 0x7dae3(%rip), %rsi     # 0x92e3b
movq %r12, %rdi
xorl %eax, %eax
pushq %rbx
pushq %r15
pushq %rbp
pushq %r13
pushq %r11
leaq 0x69f6b(%rip), %r11     # 0x7f2d7
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0xc196
addq $0x40, %rsp
leaq 0x9789c(%rip), %rsi     # 0xacc20
movq 0x97c45(%rip), %rdx     # 0xacfd0
movq %r12, %rdi
callq 0x4900
movq %rax, %rbx
movq %r12, %rdi
callq 0x43b0
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e1e4
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 0x1e1e4
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %r9d, %r8d
callq 0x10470
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 0x1e20a
movq 0x18(%rbx), %rcx
addq %rcx, %rax
cvttss2si (%r14), %edx
addq $0x4, %r14
movb %dl, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x1e1cf
jmp 0x1e20a
cmpb $0x0, 0x10(%rbx)
jne 0x1e1f8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1e1f8
callq 0x4680
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_O1/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 0x1e301
movdqu (%rbx), %xmm2
pxor %xmm1, %xmm1
pcmpeqd %xmm2, %xmm1
movmskps %xmm1, %eax
testb %al, %al
jne 0x1e301
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x1e313
cmpl $0x0, 0xc(%rbx)
jle 0x1e301
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
xorl %r14d, %r14d
movss %xmm0, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax,%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 0x14f1e
movl %ebx, %esi
movq 0x30(%rsp), %rbx
movss 0x2c(%rsp), %xmm0
addq $0x20, %rsp
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x1e2bb
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 0x55004(%rip), %rax     # 0x73338
leaq 0x563d7(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x60f89(%rip), %r11     # 0x7f2d7
leaq 0x74d59(%rip), %rsi     # 0x930ae
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xc196
addq $0x20, %rsp
leaq 0x8e8af(%rip), %rsi     # 0xacc20
movq 0x8ec58(%rip), %rdx     # 0xacfd0
movq %r14, %rdi
callq 0x4900
movq %rax, %rbx
movq %r14, %rdi
callq 0x43b0
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e4ba
movl %r9d, %r13d
movq %rsi, %r14
movl %r8d, 0xc(%rsp)
movq %rdx, %r12
movl %ecx, %r15d
movq $0x0, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
movl 0x8(%rsi), %ebp
cmpl $0x1, %ebp
je 0x1e414
movl (%r14), %edx
movl 0x4(%r14), %ecx
decl %edx
shrl %edx
decl %ecx
shrl %ecx
leal -0x1(%rbp), %r8d
shrl %r8d
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x1e918
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1ed0a
movq %rax, %r14
cmpl $0x1, %ebp
movl %r15d, %ebp
je 0x1e432
cmpb $0x0, 0x48(%rsp)
jne 0x1e432
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1e432
callq 0x4680
movl (%r14), %esi
movl 0x4(%r14), %edx
movzbl %r13b, %eax
movl %eax, (%rsp)
movzbl 0xc(%rsp), %r9d
movq %rbx, %rdi
movq %r12, %rcx
movl %ebp, %r8d
callq 0x1ed3a
cmpl $0x2, 0x20(%rbx)
jne 0x1e475
leaq 0x2c(%rbx), %rsi
movq %r14, %rdi
callq 0x1f988
movzbl (%rax), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1faa4
movq %rax, %rdi
movl $0x1, %esi
callq 0x20e5e
movq %rax, %rbx
cmpb $0x0, 0x20(%rsp)
jne 0x1e4a8
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1e4a8
callq 0x4680
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 0x1e50e
movq %rax, %rbx
cmpb $0x0, 0x48(%rsp)
jne 0x1e4f0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1e4f0
callq 0x4680
jmp 0x1e4f0
jmp 0x1e4ed
movq %rax, %rbx
cmpb $0x0, 0x20(%rsp)
jne 0x1e506
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1e506
callq 0x4680
movq %rbx, %rdi
callq 0x4950