LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rsi
pushq $0x26
popq %rdx
pushq $0x1
popq %rcx
pushq $0x3
popq %r8
callq 0xbbfa
movq 0x18(%rbx), %rax
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
movl 0x8(%rbx), %ecx
movq %r9, %rdx
imulq %r8, %rdx
imulq %rcx, %rdx
leaq (%rax,%rdx), %rcx
leaq (%rax,%rdx,2), %rdx
leaq 0x48f9a(%rip), %rsi     # 0x547f0
xorl %edi, %edi
movl %r8d, %r8d
movl %r9d, %r9d
imulq %r8, %r9
cmpq %r9, %rdi
jae 0xb8a3
movzbl (%rsi), %r8d
movb 0x1(%rsi), %r9b
movb 0x2(%rsi), %r10b
movb 0x3(%rsi), %r11b
movl %r8d, %ebp
subl $0x1, %ebp
jb 0xb893
movb %r9b, (%rax)
incq %rax
movb %r10b, (%rcx)
incq %rcx
movb %r11b, (%rdx)
incq %rdx
jmp 0xb87a
addq $0x4, %rsi
addq %r8, %rdi
movl (%rbx), %r8d
movl 0x4(%rbx), %r9d
jmp 0xb858
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb90f
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 0xb9b3
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
leaq 0xe0(%rsp), %r13
movl $0x800, %edx            # imm = 0x800
movq %r13, %rdi
xorl %esi, %esi
movss %xmm0, 0x4(%rsp)
movq %r9, 0x8(%rsp)
movq %r8, %r15
callq 0x4280
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 %r13, %rdi
movq %r14, %rdx
callq 0x42f0
pushq $0x1
popq %rsi
movl 0x920(%rsp), %edi
callq 0xcd6c
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %r13, %rcx
movq %r15, %r8
movq 0x8(%rsp), %r9
movss 0x4(%rsp), %xmm0
pushq $0x1
pushq %rax
callq 0xd302
popq %rcx
popq %rdx
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_O2/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 0xc527
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 0xc5c8
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 0x4280
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 0x42f0
leaq 0x6a2eb(%rip), %rcx     # 0x76887
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 0xb8c2
popq %rcx
popq %rdx
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_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<unsigned char>& cimg_library::CImg<unsigned char>::operator*=<int>(int)
CImg<T>& operator*=(const t value) {
      if (is_empty()) return *this;
#ifdef cimg_use_openmp
#pragma omp parallel for if (size()>=262144)
#endif
      cimg_rof(*this,ptrd,T) *ptrd = (T)(*ptrd * value);
      return *this;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xfd1c
testb %al, %al
je 0xc5f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rax
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
imulq %rcx, %rdx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
imulq %rcx, %rsi
imulq %rdx, %rsi
leaq (%rsi,%rax), %rcx
decq %rcx
cmpq %rax, %rcx
jb 0xc5ef
movb (%rcx), %al
mulb %bpl
movb %al, (%rcx)
movq 0x18(%rbx), %rax
decq %rcx
jmp 0xc61b
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xfd1c
testb %al, %al
je 0xc64b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rax
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
imulq %rcx, %rdx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
imulq %rcx, %rsi
imulq %rdx, %rsi
leaq (%rsi,%rax), %rcx
decq %rcx
cmpq %rax, %rcx
jb 0xc641
addb %bpl, (%rcx)
movq 0x18(%rbx), %rax
decq %rcx
jmp 0xc66d
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc75e
cmpl $0x0, 0x1c(%rbx)
je 0xc75e
movl %edx, %ebp
movl %esi, %r14d
movq %rbx, %rdi
callq 0x29610
callq 0x1a004
movq 0x2068(%rax), %r15
movq %r15, %rdi
callq 0x4270
movq 0x4d0(%rbx), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4440
movl %r14d, 0x44c(%rbx)
movl %ebp, 0x450(%rbx)
movb $0x0, 0x462(%rbx)
movq %r15, %rdi
callq 0x41f0
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19f72
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::screen_width()
static int screen_width() {
      Display *const dpy = cimg::X11_attr().display;
      int res = 0;
      if (!dpy) {
        Display *const _dpy = XOpenDisplay(0);
        if (!_dpy)
          throw CImgDisplayException("CImgDisplay::screen_width(): Failed to open X11 display.");
        res = DisplayWidth(_dpy,DefaultScreen(_dpy));
        XCloseDisplay(_dpy);
      } else {
#ifdef cimg_use_xrandr
        if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution)
          res = cimg::X11_attr().resolutions[cimg::X11_attr().curr_resolution].width;
        else res = DisplayWidth(dpy,DefaultScreen(dpy));
#else
        res = DisplayWidth(dpy,DefaultScreen(dpy));
#endif
      }
      return res;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1a004
movq 0x2068(%rax), %rax
testq %rax, %rax
je 0xc799
movq 0xe8(%rax), %rcx
movslq 0xe0(%rax), %rax
shlq $0x7, %rax
movl 0x18(%rcx,%rax), %ebx
jmp 0xc7c3
xorl %edi, %edi
callq 0x46e0
testq %rax, %rax
je 0xc7cd
movq 0xe8(%rax), %rcx
movslq 0xe0(%rax), %rdx
shlq $0x7, %rdx
movl 0x18(%rcx,%rdx), %ebx
movq %rax, %rdi
callq 0x4a00
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x681c7(%rip), %rsi     # 0x749a8
movq %rax, %rdi
xorl %eax, %eax
callq 0x1b624
leaq 0x834ce(%rip), %rsi     # 0x8fcc0
movq 0x837df(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::screen_height()
static int screen_height() {
      Display *const dpy = cimg::X11_attr().display;
      int res = 0;
      if (!dpy) {
        Display *const _dpy = XOpenDisplay(0);
        if (!_dpy)
          throw CImgDisplayException("CImgDisplay::screen_height(): Failed to open X11 display.");
        res = DisplayHeight(_dpy,DefaultScreen(_dpy));
        XCloseDisplay(_dpy);
      } else {
#ifdef cimg_use_xrandr
        if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution)
          res = cimg::X11_attr().resolutions[cimg::X11_attr().curr_resolution].height;
        else res = DisplayHeight(dpy,DefaultScreen(dpy));
#else
        res = DisplayHeight(dpy,DefaultScreen(dpy));
#endif
      }
      return res;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1a004
movq 0x2068(%rax), %rax
testq %rax, %rax
je 0xc841
movq 0xe8(%rax), %rcx
movslq 0xe0(%rax), %rax
shlq $0x7, %rax
movl 0x1c(%rcx,%rax), %ebx
jmp 0xc86b
xorl %edi, %edi
callq 0x46e0
testq %rax, %rax
je 0xc875
movq 0xe8(%rax), %rcx
movslq 0xe0(%rax), %rdx
shlq $0x7, %rdx
movl 0x1c(%rcx,%rdx), %ebx
movq %rax, %rdi
callq 0x4a00
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x68158(%rip), %rsi     # 0x749e1
movq %rax, %rdi
xorl %eax, %eax
callq 0x1b624
leaq 0x83426(%rip), %rsi     # 0x8fcc0
movq 0x83737(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
testl %esi, %esi
je 0xe911
movl %edx, %r14d
movl %esi, %ebp
cmpl $-0x1, %edx
jne 0xe8f4
movl (%rbx), %r14d
movq %rsp, %r15
subl $0x1, %ebp
jb 0xe911
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x113d6
incl %r14d
jmp 0xe8f7
movq %rsp, %rdi
callq 0xb8ae
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb8ae
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0xe98e
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0xe986
addq $-0x20, %r15
shlq $0x5, %r12
leaq (%r15,%r12), %rdi
callq 0xb8ae
addq $-0x20, %r12
jne 0xe977
movq %r14, %rdi
callq 0x4670
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0xeaf3
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 0xeae3
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0xea89
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0xea81
addq $-0x20, %r12
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0xdba4
addq $-0x20, %r13
jne 0xea72
movq %r15, %rdi
callq 0x4670
movl %r14d, %edi
callq 0xeb7d
cmpq $0x11, %rax
pushq $0x10
popq %rcx
cmovaeq %rax, %rcx
movl %ecx, 0x4(%rbx)
movl %ecx, %r12d
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rdi
callq 0x4040
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testq %r12, %r12
je 0xeadf
addq $0x20, %rax
xorl %edx, %edx
xorps %xmm0, %xmm0
andq $0x0, (%rax,%rdx)
movups %xmm0, -0x18(%rax,%rdx)
movb $0x0, -0x8(%rax,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r15
jne 0xeac7
movq %rcx, 0x8(%rbx)
movl %r14d, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xeb28
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
callq 0x1808a
movss 0xc(%rsp), %xmm1
testb %al, %al
jne 0x18080
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
movq 0x18(%rbx), %rdi
movl (%rbx), %edx
movl 0x4(%rbx), %eax
jne 0x1803e
jnp 0x18063
imulq %rdx, %rax
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
imulq %rcx, %rdx
imulq %rax, %rdx
leaq (%rdi,%rdx,4), %rax
cmpq %rax, %rdi
jae 0x18080
movss %xmm1, (%rdi)
addq $0x4, %rdi
jmp 0x18054
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
imulq %rcx, %rsi
imulq %rax, %rdx
imulq %rsi, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x4280
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x10ee5
movl %edx, %ebp
movq %rsi, %r14
movl (%rsi), %esi
movq %rsp, %rdi
callq 0x10f0a
xorl %r15d, %r15d
movzbl %bpl, %ebp
xorl %r12d, %r12d
movslq (%rsp), %rax
cmpq %rax, %r12
jge 0x10ecf
movq 0x8(%rsp), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rsi
addq %r15, %rsi
movl %ebp, %edx
callq 0x1094a
incq %r12
addq $0x20, %r15
jmp 0x10ea7
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x10f80
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcd26
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ef7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcd26
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10356
movl (%r14), %eax
movq 0x8(%r14), %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
shlq $0x5, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
je 0x10fc5
andb $0x1, %dil
orb 0x10(%rcx,%rdx), %dil
addq $0x20, %rdx
jmp 0x10fb1
xorl %r15d, %r15d
xorl %r12d, %r12d
testb $0x1, %dil
je 0x10ff7
cltq
cmpq %rax, %r12
jge 0x1101d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq 0x8(%r14), %rsi
addq %r15, %rsi
callq 0x11034
incq %r12
movl (%r14), %eax
addq $0x20, %r15
jmp 0x10fd1
cltq
cmpq %rax, %r12
jge 0x1101d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq 0x8(%rbx), %rsi
addq %r15, %rsi
callq 0xc498
incq %r12
movl (%r14), %eax
addq $0x20, %r15
jmp 0x10ff7
movq %r14, %rdi
callq 0xe94e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<unsigned char>::get_crop_font() const
CImgList<T> get_crop_font() const {
      CImgList<T> res;
      cimglist_for(*this,l) {
        const CImg<T>& letter = (*this)[l];
        int xmin = letter._width, xmax = 0;
        cimg_forXY(letter,x,y) if (letter(x,y)) { if (x<xmin) xmin = x; if (x>xmax) xmax = x; }
        if (xmin>xmax) CImg<T>(letter._width,letter._height,1,letter._spectrum,0).move_to(res);
        else letter.get_crop(xmin,0,xmax,letter._height-1).move_to(res);
      }
      res[' '].resize(res['f']._width,-100,-100,-100,0);
      if (' '+256<res.size()) res[' '+256].resize(res['f']._width,-100,-100,-100,0);
      return res;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movslq (%rsi), %rax
cmpq %rax, %r13
jge 0x11174
movq 0x8(%rsi), %rax
movq %r13, %rdx
shlq $0x5, %rdx
movl (%rax,%rdx), %esi
movl 0x4(%rax,%rdx), %r9d
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
testl %r9d, %r9d
movl $0x0, %r10d
cmovgl %r9d, %r10d
addq %rdx, %rax
movl %esi, %r15d
xorl %r14d, %r14d
xorl %r11d, %r11d
cmpl %r10d, %r11d
je 0x110f6
xorl %ebp, %ebp
cmpq %rbp, %rdi
je 0x110ee
movq 0x18(%rax), %r12
leal (%rcx,%rbp), %ebx
cmpl %r15d, %ebp
movl %r15d, %edx
cmovll %ebp, %edx
cmpl %r14d, %ebp
movl %r14d, %r8d
cmovgl %ebp, %r8d
cmpb $0x0, (%r12,%rbx)
cmovnel %edx, %r15d
cmovnel %r8d, %r14d
incq %rbp
jmp 0x110bd
incl %r11d
addq %rsi, %rcx
jmp 0x110b6
cmpl %r14d, %r15d
jle 0x1112d
movl 0xc(%rax), %r8d
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl %r9d, %edx
pushq $0x1
popq %rcx
xorl %r9d, %r9d
callq 0x1121a
movq %r14, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
pushq $-0x1
popq %rdx
callq 0xb9c8
movq %r14, %rdi
jmp 0x11162
decl %r9d
andl $0x0, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x1138e
movq %r12, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
pushq $-0x1
popq %rdx
callq 0xb9c8
movq %r12, %rdi
callq 0xb8ae
incq %r13
movq 0x10(%rsp), %rsi
jmp 0x11072
movq 0x8(%rbx), %rdi
movl 0xcc0(%rdi), %esi
addq $0x400, %rdi            # imm = 0x400
andl $0x0, (%rsp)
pushq $-0x64
popq %rcx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
movl %ecx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0xba08
cmpl $0x121, (%rbx)          # imm = 0x121
jb 0x111de
movq 0x8(%rbx), %rdi
movl 0xcc0(%rdi), %esi
addq $0x2400, %rdi           # imm = 0x2400
andl $0x0, (%rsp)
pushq $-0x64
popq %rcx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
movl %ecx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0xba08
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11205
jmp 0x111f6
jmp 0x11205
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xb8ae
jmp 0x11208
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xcd26
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edx
movl 0x4(%rsi), %ecx
movl %r15d, %esi
movl 0x8(%rbx), %r8d
movq %rcx, %rax
imulq %rdx, %rax
imulq %r8, %rsi
imulq %rax, %rsi
movl %r14d, %edi
imulq %r8, %rdi
imulq %rax, %rdi
cmpl %edi, %esi
ja 0x11a96
movl %esi, %esi
imulq %r8, %rax
movl 0xc(%rbx), %r9d
imulq %rax, %r9
cmpq %r9, %rsi
jae 0x11a96
movl %edi, %eax
cmpq %r9, %rax
jae 0x11a96
addq 0x18(%rbx), %rsi
subl %r15d, %r14d
incl %r14d
subq $0x8, %rsp
movq %r12, %rdi
movl %r14d, %r9d
pushq $0x1
callq 0x101b6
popq %rax
popq %rcx
movq %r12, %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 (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
leaq 0x42d35(%rip), %rax     # 0x547e8
leaq 0x44108(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
movl 0xc(%rbx), %r9d
leal -0x1(%rdx), %r11d
leal -0x1(%rcx), %r13d
leal -0x1(%r8), %ebp
leaq 0x62812(%rip), %rsi     # 0x742eb
movq %r12, %rdi
xorl %eax, %eax
pushq %r14
pushq %r15
pushq %rbp
pushq %r13
pushq %r11
leaq 0x4ec99(%rip), %r11     # 0x60787
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0x9d52
addq $0x40, %rsp
leaq 0x7e15b(%rip), %rsi     # 0x8fc60
movq 0x7e4cc(%rip), %rdx     # 0x8ffd8
movq %r12, %rdi
callq 0x4910
movq %rax, %rbx
movq %r12, %rdi
callq 0x4390
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18161
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 0x18161
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %r9d, %r8d
callq 0xd758
movq 0x18(%rbx), %rax
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
imulq %rcx, %rdx
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %ecx
imulq %rsi, %rcx
imulq %rdx, %rcx
addq %rax, %rcx
cmpq %rcx, %rax
jae 0x18170
cvttss2si (%r14), %edx
addq $0x4, %r14
movb %dl, (%rax)
incq %rax
jmp 0x1814c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe9a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movss %xmm0, 0xc(%rsp)
movq %r9, 0x10(%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
callq 0xfd1c
testb %al, %al
je 0x1820b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x58(%rsp)
je 0x1825b
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x181f9
movq 0x58(%rsp), %rax
movzbl (%rax,%r14), %eax
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
movss 0xc(%rsp), %xmm0
pushq %rax
pushq %r14
movl 0x60(%rsp), %eax
pushq %rax
pushq 0x28(%rsp)
callq 0x1172e
addq $0x20, %rsp
incq %r14
jmp 0x18216
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 0x3c56c(%rip), %rax     # 0x547e8
leaq 0x3d93f(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x484f1(%rip), %r11     # 0x60787
leaq 0x5c2c1(%rip), %rsi     # 0x7455e
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0x9d52
addq $0x20, %rsp
leaq 0x779a7(%rip), %rsi     # 0x8fc60
movq 0x77d18(%rip), %rdx     # 0x8ffd8
movq %r14, %rdi
callq 0x4910
movq %rax, %rbx
movq %r14, %rdi
callq 0x4390
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x183e2
movl %r9d, %r13d
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
andq $0x0, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
movl 0x8(%rsi), %r8d
cmpl $0x1, %r8d
je 0x1836d
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 0x18596
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x188a2
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xb8ae
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 0x188be
cmpl $0x2, 0x20(%rbx)
jne 0x183ab
leaq 0x2c(%rbx), %rsi
movq %r14, %rdi
callq 0x18f34
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1902c
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x19f72
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb8ae
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 0x1841e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xb8ae
jmp 0x1840c
jmp 0x18409
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb8ae
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
callq 0x263a6
testb %al, %al
jne 0x26322
movq 0x18(%r14), %rdx
movl (%rdx), %ecx
movl (%r14), %eax
movl 0x4(%r14), %esi
imulq %rax, %rsi
movl 0x8(%r14), %eax
movl 0xc(%r14), %edi
imulq %rax, %rdi
imulq %rsi, %rdi
leaq (%rdx,%rdi,4), %rsi
movl %ecx, %edi
movq %rdx, %rax
cmpq %rsi, %rdx
jae 0x2630f
movl (%rdx), %r8d
cmpl %edi, %r8d
cmovbl %r8d, %edi
cmovbq %rdx, %rax
cmpl %ecx, %r8d
cmoval %r8d, %ecx
addq $0x4, %rdx
jmp 0x262ef
movl %ecx, %ecx
cvtsi2ss %rcx, %xmm0
movss %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
leaq 0x2e4a3(%rip), %rax     # 0x547e8
leaq 0x2f876(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x4e1f1(%rip), %r11     # 0x74551
leaq 0x4e4df(%rip), %rsi     # 0x74846
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0x9bf8
addq $0x20, %rsp
leaq 0x698c4(%rip), %rsi     # 0x8fc48
movq 0x69c4d(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19faf
cmpl $0x0, 0x1c(%rbx)
je 0x19faf
movl %esi, %ebp
callq 0x1a004
movq 0x2068(%rax), %r14
movq %r14, %rdi
callq 0x4270
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x1c202
movq %r14, %rdi
callq 0x41f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc8cc
movq %rax, %rdi
callq 0x1a0c0
movq %rax, %rdi
callq 0x1a0e6
movb $0x0, 0x463(%rbx)
movb 0x463(%rbx), %al
movb %al, 0x462(%rbx)
movb 0x462(%rbx), %al
movb %al, 0x461(%rbx)
andl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, 0x30(%rdi)
jne 0x1a0be
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1a004
movq 0x2068(%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4660
movq 0x4d8(%rbx), %rsi
testq %rsi, %rsi
je 0x1a0ab
movq %r14, %rdi
callq 0x4870
andq $0x0, 0x4d8(%rbx)
movb $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
callq 0x1a004
leaq 0x10(%rax), %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
callq 0x1a004
leaq 0x10(%rax), %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x8(%rdi)
andq $0x0, 0x2068(%rdi)
andq $0x0, 0x206f(%rdi)
callq 0x4430
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0x47c0
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a16a
movq (%rax), %rdi
callq 0x4720
movq 0x8(%rbx), %rdi
callq 0x44d0
leaq 0x10(%rbx), %rdi
callq 0x4a40
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x43c0
movq %rbx, %rdi
popq %rbx
jmp 0x45a0
movq %rax, %rdi
callq 0x7f6f
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0xfd1c
testb %al, %al
jne 0x1a23b
movq 0x18(%rbx), %rcx
movb (%rcx), %dl
movl (%rbx), %eax
movl 0x4(%rbx), %edi
imulq %rax, %rdi
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
imulq %rax, %rsi
imulq %rdi, %rsi
addq %rcx, %rsi
movq %rcx, %rax
cmpq %rsi, %rcx
jae 0x1a233
movzbl (%rcx), %edi
cmpb %dl, %dil
movzbl %dl, %edx
cmovbl %edi, %edx
cmovbq %rcx, %rax
incq %rcx
jmp 0x1a219
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 0x3a58c(%rip), %rax     # 0x547e8
leaq 0x3b95f(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x46511(%rip), %r11     # 0x60787
leaq 0x5a46c(%rip), %rsi     # 0x746e9
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0x9bf8
addq $0x20, %rsp
leaq 0x759af(%rip), %rsi     # 0x8fc48
movq 0x75d38(%rip), %rdx     # 0x8ffd8
movq %r14, %rdi
callq 0x4910
movq %rax, %rbx
movq %r14, %rdi
callq 0x4390
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::strncasecmp(char const*, char const*, int)
inline int strncasecmp(const char *const str1, const char *const str2, const int l) {
      if (!l) return 0;
      if (!str1) return str2?-1:0;
      const char *nstr1 = str1, *nstr2 = str2;
      int k, diff = 0; for (k = 0; k<l && !(diff = uncase(*nstr1)-uncase(*nstr2)); ++k) { ++nstr1; ++nstr2; }
      return k!=l?diff:0;
    }

// Assembly:
testl %edx, %edx
je 0x1b608
testq %rdi, %rdi
je 0x1b60b
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpl %eax, %ecx
je 0x1b613
movzbl (%rdi,%rax), %r8d
leal -0x5b(%r8), %r9d
leal 0x20(%r8), %r10d
cmpb $-0x1a, %r9b
movzbl %r10b, %r9d
cmovbl %r8d, %r9d
movsbl %r9b, %r8d
movzbl (%rsi,%rax), %r9d
leal -0x5b(%r9), %r10d
leal 0x20(%r9), %r11d
cmpb $-0x1a, %r10b
movzbl %r11b, %r10d
cmovbl %r9d, %r10d
movsbl %r10b, %r9d
subl %r9d, %r8d
jne 0x1b618
incq %rax
jmp 0x1b5c0
xorl %eax, %eax
retq
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
xorl %r8d, %r8d
jmp 0x1b61a
movl %eax, %ecx
xorl %eax, %eax
cmpl %edx, %ecx
cmovnel %r8d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::_events_thread(void*)
static void* _events_thread(void *arg) { // Thread to manage events for all opened display windows.
      Display *const dpy = cimg::X11_attr().display;
      XEvent event;
      pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,0);
      pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);
      if (!arg) for (;;) {
        XLockDisplay(dpy);
        bool event_flag = XCheckTypedEvent(dpy,ClientMessage,&event);
        if (!event_flag) event_flag = XCheckMaskEvent(dpy,
                                                      ExposureMask | StructureNotifyMask | ButtonPressMask |
                                                      KeyPressMask | PointerMotionMask | EnterWindowMask |
                                                      LeaveWindowMask | ButtonReleaseMask | KeyReleaseMask,&event);
        if (event_flag)
          for (unsigned int i = 0; i<cimg::X11_attr().nb_wins; ++i)
            if (!cimg::X11_attr().wins[i]->_is_closed && event.xany.window==cimg::X11_attr().wins[i]->_window)
              cimg::X11_attr().wins[i]->_handle_events(&event);
        XUnlockDisplay(dpy);
        pthread_testcancel();
        cimg::sleep(8);
      }
      return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
callq 0x1a004
movq 0x2068(%rax), %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x4130
xorl %edi, %edi
xorl %esi, %esi
callq 0x47f0
testq %r14, %r14
je 0x1b775
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x21
popq %rbp
leaq 0x8(%rsp), %r14
pushq $0x8
popq %r15
movq %rbx, %rdi
callq 0x4270
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4920
testl %eax, %eax
jne 0x1b7ae
movl $0x2807f, %esi          # imm = 0x2807F
movq %rbx, %rdi
movq %r14, %rdx
callq 0x46c0
testl %eax, %eax
je 0x1b7ff
xorl %r12d, %r12d
callq 0x1a004
movl (%rax), %eax
cmpq %rax, %r12
jae 0x1b7ff
callq 0x1a004
movq 0x68(%rax,%r12,8), %rax
cmpb $0x0, 0x460(%rax)
jne 0x1b7fa
movq 0x28(%rsp), %r13
callq 0x1a004
movq 0x68(%rax,%r12,8), %rax
cmpq 0x4d0(%rax), %r13
jne 0x1b7fa
callq 0x1a004
movq 0x68(%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x1bc7c
incq %r12
jmp 0x1b7b1
movq %rbx, %rdi
callq 0x41f0
callq 0x4360
movl %r15d, %edi
callq 0x1c1d4
jmp 0x1b781
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::_map_window()
void _map_window() {
      Display *const dpy = cimg::X11_attr().display;
      bool is_exposed = false, is_mapped = false;
      XWindowAttributes attr;
      XEvent event;
      XMapRaised(dpy,_window);
      do { // Wait for the window to be mapped.
        XWindowEvent(dpy,_window,StructureNotifyMask | ExposureMask,&event);
        switch (event.type) {
        case MapNotify : is_mapped = true; break;
        case Expose : is_exposed = true; break;
        }
      } while (!is_exposed || !is_mapped);
      do { // Wait for the window to be visible.
        XGetWindowAttributes(dpy,_window,&attr);
        if (attr.map_state!=IsViewable) { XSync(dpy,0); cimg::sleep(10); }
      } while (attr.map_state!=IsViewable);
      _window_x = attr.x;
      _window_y = attr.y;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
callq 0x1a004
movq 0x2068(%rax), %r14
movq 0x4d0(%rbx), %rsi
movq %r14, %rdi
callq 0x4a20
xorl %ebp, %ebp
leaq 0x90(%rsp), %r15
xorl %r12d, %r12d
movq 0x4d0(%rbx), %rsi
movl $0x28000, %edx          # imm = 0x28000
movq %r14, %rdi
movq %r15, %rcx
callq 0x40f0
movl 0x90(%rsp), %eax
cmpl $0xc, %eax
je 0x1bc01
cmpl $0x13, %eax
jne 0x1bc04
movb $0x1, %r12b
jmp 0x1bc04
movb $0x1, %bpl
movl %ebp, %eax
andb %r12b, %al
testb $0x1, %al
je 0x1bbd4
leaq 0x8(%rsp), %r15
pushq $0xa
popq %rbp
movq 0x4d0(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4960
cmpl $0x2, 0x64(%rsp)
je 0x1bc46
movq %r14, %rdi
xorl %esi, %esi
callq 0x4a10
movl %ebp, %edi
callq 0x1c1d4
cmpl $0x2, 0x64(%rsp)
jne 0x1bc15
movl 0x8(%rsp), %eax
movl %eax, 0x44c(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x450(%rbx)
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::sleep(unsigned int)
inline void sleep(const unsigned int milliseconds) {
#if cimg_OS==1
      struct timespec tv;
      tv.tv_sec = milliseconds/1000;
      tv.tv_nsec = (milliseconds%1000)*1000000;
      nanosleep(&tv,0);
#elif cimg_OS==2
      Sleep(milliseconds);
#endif
    }

// Assembly:
subq $0x18, %rsp
movl %edi, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x4150
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::_paint(bool)
void _paint(const bool wait_expose=true) {
      if (_is_closed || !_image) return;
      Display *const dpy = cimg::X11_attr().display;
      if (wait_expose) { // Send an expose event sticked to display window to force repaint.
        XEvent event;
        event.xexpose.type = Expose;
        event.xexpose.serial = 0;
        event.xexpose.send_event = 1;
        event.xexpose.display = dpy;
        event.xexpose.window = _window;
        event.xexpose.x = 0;
        event.xexpose.y = 0;
        event.xexpose.width = width();
        event.xexpose.height = height();
        event.xexpose.count = 0;
        XSendEvent(dpy,_window,0,0,&event);
      } else { // Repaint directly (may be called from the expose event).
        GC gc = DefaultGC(dpy,DefaultScreen(dpy));
#ifdef cimg_use_xshm
        if (_shminfo) XShmPutImage(dpy,_window,gc,_image,0,0,0,0,_width,_height,1);
        else XPutImage(dpy,_window,gc,_image,0,0,0,0,_width,_height);
#else
        XPutImage(dpy,_window,gc,_image,0,0,0,0,_width,_height);
#endif
      }
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0xe8, %rsp
cmpb $0x0, 0x460(%rdi)
jne 0x1c2ca
movq %rdi, %rbx
cmpq $0x0, 0x4e8(%rdi)
je 0x1c2ca
movl %esi, %ebp
callq 0x1a004
movq 0x2068(%rax), %rdi
testb %bpl, %bpl
je 0x1c281
leaq 0x28(%rsp), %r8
movl $0xc, (%r8)
andq $0x0, 0x8(%r8)
movl $0x1, 0x10(%r8)
movq %rdi, 0x18(%r8)
movq 0x4d0(%rbx), %rsi
movq %rsi, 0x20(%r8)
andq $0x0, 0x28(%r8)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%r8)
andl $0x0, 0x38(%r8)
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x40e0
jmp 0x1c2ca
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x48(%rax,%rcx), %rdx
movq 0x4d0(%rbx), %rsi
movq 0x4e8(%rbx), %rcx
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r8d
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movl %r8d, 0x18(%rsp)
movl %eax, 0x10(%rsp)
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4a90
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq