LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: unsigned int const& cimg_library::CImg<unsigned int>::min_max<float>(float&) const
const T& min_max(t& max_val) const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "min_max(): Empty instance.",
                                    cimg_instance);
      const T *ptr_min = _data;
      T min_value = *ptr_min, max_value = min_value;
      cimg_for(*this,ptrs,T) {
        const T val = *ptrs;
        if (val<min_value) { min_value = val; ptr_min = ptrs; }
        if (val>max_value) max_value = val;
      }
      max_val = (t)max_value;
      return *ptr_min;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3316d
movdqu (%rbx), %xmm0
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %ecx
testb %cl, %cl
jne 0x3316d
movl (%rax), %ecx
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, %r8d
movl 0xc(%rbx), %edx
imulq %r8, %rdx
imulq %rdi, %rdx
testq %rdx, %rdx
jle 0x33155
leaq (%rax,%rdx,4), %rdi
movq %rax, %r8
movl %ecx, %edx
movl (%r8), %r9d
cmpl %ecx, %r9d
cmovbl %r9d, %ecx
cmovbq %r8, %rax
cmpl %edx, %r9d
cmoval %r9d, %edx
addq $0x4, %r8
cmpq %rdi, %r8
jb 0x33135
jmp 0x33157
movl %ecx, %edx
movl %edx, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
leaq 0x401aa(%rip), %rax     # 0x73338
leaq 0x4157d(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x5fef9(%rip), %r11     # 0x930a1
leaq 0x601e7(%rip), %rsi     # 0x93396
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xbfd8
addq $0x20, %rsp
leaq 0x79a3d(%rip), %rsi     # 0xacc08
movq 0x79dfe(%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::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 0x20ea0
cmpl $0x0, 0x1c(%rbx)
je 0x20ea0
movl %esi, %ebp
movb 0x8ee77(%rip), %al      # 0xafcf0
testb %al, %al
je 0x20ea8
movq 0x8ee5c(%rip), %r14     # 0xafce0
movq %r14, %rdi
callq 0x4280
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x2415e
movq %r14, %rdi
callq 0x41f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8ee41(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x20e7d
leaq 0x8cdb9(%rip), %rdi     # 0xadc78
callq 0x21188
leaq 0x2fb(%rip), %rdi       # 0x211c6
leaq 0x8cda6(%rip), %rsi     # 0xadc78
leaq 0x8c67f(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8ee0b(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x20e7d
movq %rax, %rbx
leaq 0x8edfa(%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::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 0xf4f8
movq %rax, %rdi
callq 0x21074
movq %rax, %rdi
callq 0x210fc
movb $0x0, 0x463(%rbx)
movb 0x463(%rbx), %al
movb %al, 0x462(%rbx)
movb 0x462(%rbx), %al
movb %al, 0x461(%rbx)
movl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::_desinit_fullscreen()
void _desinit_fullscreen() {
      if (!_is_fullscreen) return;
      Display *const dpy = cimg::X11_attr().display;
      XUngrabKeyboard(dpy,CurrentTime);
#ifdef cimg_use_xrandr
      if (cimg::X11_attr().resolutions && cimg::X11_attr().curr_resolution) {
        XRRScreenConfiguration *config = XRRGetScreenInfo(dpy,DefaultRootWindow(dpy));
        XRRSetScreenConfig(dpy,config,DefaultRootWindow(dpy),0,cimg::X11_attr().curr_rotation,CurrentTime);
        XRRFreeScreenConfigInfo(config);
        XSync(dpy,0);
        cimg::X11_attr().curr_resolution = 0;
      }
#endif
      if (_background_window) XDestroyWindow(dpy,_background_window);
      _background_window = 0;
      _is_fullscreen = false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x30(%rdi)
jne 0x21011
movq %rdi, %rbx
movb 0x8ed17(%rip), %al      # 0xafcf0
testb %al, %al
je 0x21019
movq 0x8ecfc(%rip), %r14     # 0xafce0
movq %r14, %rdi
xorl %esi, %esi
callq 0x4670
movq 0x4d8(%rbx), %rsi
testq %rsi, %rsi
je 0x21002
movq %r14, %rdi
callq 0x4860
movq $0x0, 0x4d8(%rbx)
movb $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8ecd0(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x20fdd
leaq 0x8cc48(%rip), %rdi     # 0xadc78
callq 0x21188
leaq 0x18a(%rip), %rdi       # 0x211c6
leaq 0x8cc35(%rip), %rsi     # 0xadc78
leaq 0x8c50e(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8ec9a(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x20fdd
movq %rax, %rbx
leaq 0x8ec89(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::set_button()
CImgDisplay& set_button() {
      _button = 0;
      _is_event = true;
#if cimg_display==1
      pthread_cond_broadcast(&cimg::X11_attr().wait_event);
#elif cimg_display==2
      SetEvent(cimg::Win32_attr().wait_event);
#endif
      return *this;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x48(%rdi)
movb $0x1, 0x463(%rdi)
movb 0x8ec64(%rip), %al      # 0xafcf0
testb %al, %al
je 0x210a1
leaq 0x8cbf1(%rip), %rdi     # 0xadc88
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x8ec48(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x21090
leaq 0x8cbc0(%rip), %rdi     # 0xadc78
callq 0x21188
leaq 0x102(%rip), %rdi       # 0x211c6
leaq 0x8cbad(%rip), %rsi     # 0xadc78
leaq 0x8c486(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8ec12(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x21090
movq %rax, %rbx
leaq 0x8ec01(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::set_wheel()
CImgDisplay& set_wheel() {
      _wheel = 0;
      _is_event = true;
#if cimg_display==1
      pthread_cond_broadcast(&cimg::X11_attr().wait_event);
#elif cimg_display==2
      SetEvent(cimg::Win32_attr().wait_event);
#endif
      return *this;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x45c(%rdi)
movb $0x1, 0x463(%rdi)
movb 0x8ebd9(%rip), %al      # 0xafcf0
testb %al, %al
je 0x2112c
leaq 0x8cb66(%rip), %rdi     # 0xadc88
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x8ebbd(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x2111b
leaq 0x8cb35(%rip), %rdi     # 0xadc78
callq 0x21188
leaq 0x77(%rip), %rdi        # 0x211c6
leaq 0x8cb22(%rip), %rsi     # 0xadc78
leaq 0x8c3fb(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8eb87(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x2111b
movq %rax, %rbx
leaq 0x8eb76(%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::cimg::X11_info::X11_info()
X11_info():nb_wins(0),events_thread(0),display(0),
                 nb_bits(0),is_blue_first(false),is_shm_enabled(false),byte_order(false) {
        XInitThreads();
        pthread_mutex_init(&wait_event_mutex,0);
        pthread_cond_init(&wait_event,0);
#ifdef cimg_use_xrandr
        resolutions = 0;
        curr_rotation = 0;
        curr_resolution = nb_resolutions = 0;
#endif
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x2068(%rdi)
movq %rax, 0x206f(%rdi)
callq 0x4450
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0x47b0
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x45d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x211e9
movq (%rax), %rdi
callq 0x4710
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x211e9
callq 0x44e0
leaq 0x10(%rbx), %rdi
callq 0x4a60
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x43e0
movq %rbx, %rdi
popq %rbx
jmp 0x45b0
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<unsigned char>::min() const
const T& min() const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "min(): Empty instance.",
                                    cimg_instance);
      const T *ptr_min = _data;
      T min_value = *ptr_min;
      cimg_for(*this,ptrs,T) if (*ptrs<min_value) min_value = *(ptr_min=ptrs);
      return *ptr_min;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x212fb
movdqu (%rbx), %xmm0
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %ecx
testb %cl, %cl
jne 0x212fb
movd %xmm0, %ecx
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %edx
imulq %rcx, %rdx
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %esi
movl 0xc(%rbx), %ecx
imulq %rsi, %rcx
imulq %rdx, %rcx
testq %rcx, %rcx
jle 0x212f3
addq %rax, %rcx
movb (%rax), %dl
movq %rax, %rsi
movzbl (%rsi), %edi
cmpb %dl, %dil
movzbl %dl, %edx
cmovbl %edi, %edx
cmovbq %rsi, %rax
incq %rsi
cmpq %rcx, %rsi
jb 0x212db
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 0x5201c(%rip), %rax     # 0x73338
leaq 0x533ef(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x5dfa1(%rip), %r11     # 0x7f2d7
leaq 0x71efc(%rip), %rsi     # 0x93239
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xbfd8
addq $0x20, %rsp
leaq 0x8b8af(%rip), %rsi     # 0xacc08
movq 0x8bc70(%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::_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 $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
movb 0x8c482(%rip), %al      # 0xafcf0
testb %al, %al
je 0x23946
movq 0x8c463(%rip), %r14     # 0xafce0
movq 0x4d0(%rbx), %rsi
movq %r14, %rdi
callq 0x4a30
xorl %ebp, %ebp
leaq 0xa0(%rsp), %r15
xorl %r12d, %r12d
movq 0x4d0(%rbx), %rsi
movl $0x28000, %edx          # imm = 0x28000
movq %r14, %rdi
movq %r15, %rcx
callq 0x40e0
movl 0xa0(%rsp), %eax
cmpl $0xc, %eax
je 0x238c6
cmpl $0x13, %eax
jne 0x238c9
movb $0x1, %r12b
jmp 0x238c9
movb $0x1, %bpl
movl %ebp, %eax
andb %r12b, %al
testb $0x1, %al
je 0x23899
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x4d0(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4960
cmpl $0x2, 0x74(%rsp)
je 0x2391b
movq %r14, %rdi
xorl %esi, %esi
callq 0x4a20
movq $0x0, 0x8(%rsp)
movq $0x989680, 0x10(%rsp)   # imm = 0x989680
movq %r12, %rdi
xorl %esi, %esi
callq 0x4130
cmpl $0x2, 0x74(%rsp)
jne 0x238dc
movl 0x18(%rsp), %eax
movl %eax, 0x44c(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x450(%rbx)
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8c3a3(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x23876
leaq 0x8a317(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x27a7(%rip), %rdi     # 0x211c6
leaq 0x8a304(%rip), %rsi     # 0xadc78
leaq 0x89bdd(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8c369(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x23876
movq %rax, %rbx
leaq 0x8c355(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xc8, %rsp
cmpb $0x0, 0x460(%rdi)
jne 0x241df
movq %rdi, %rbx
cmpq $0x0, 0x4e8(%rdi)
je 0x241df
movl %esi, %ebp
movb 0x8bb6b(%rip), %al      # 0xafcf0
testb %al, %al
je 0x24233
movq 0x8bb4c(%rip), %rdi     # 0xafce0
testb %bpl, %bpl
je 0x241e9
leaq 0x8(%rsp), %r8
movl $0xc, (%r8)
xorl %eax, %eax
movq %rax, 0x8(%r8)
movl $0x1, 0x10(%r8)
movq %rdi, 0x18(%r8)
movq 0x4d0(%rbx), %rsi
movq %rsi, 0x20(%r8)
movq %rax, 0x28(%r8)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%r8)
movl $0x0, 0x38(%r8)
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x40d0
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
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), %r10d
xorl %r11d, %r11d
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq %r11
pushq %r11
callq 0x4a90
addq $0xe8, %rsp
jmp 0x241e6
leaq 0x8bab6(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x2418d
leaq 0x89a2a(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x3094(%rip), %rdi     # 0x211c6
leaq 0x89a17(%rip), %rsi     # 0xadc78
leaq 0x892f0(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8ba7c(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x2418d
movq %rax, %rbx
leaq 0x8ba68(%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::CImgDisplay::set_button(unsigned int, bool)
CImgDisplay& set_button(const unsigned int button, const bool is_pressed=true) {
      const unsigned int buttoncode = button==1?1:button==2?2:button==3?4:0;
      if (is_pressed) _button |= buttoncode; else _button &= ~buttoncode;
      _is_event = buttoncode?true:false;
      if (buttoncode) {
#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
leal -0x1(%rsi), %ecx
xorl %eax, %eax
cmpl $0x3, %esi
sete %al
shll $0x2, %eax
cmpl $0x2, %ecx
cmovbl %esi, %eax
testl %edx, %edx
je 0x242b7
orl %eax, 0x48(%rbx)
jmp 0x242be
movl %eax, %ecx
notl %ecx
andl %ecx, 0x48(%rbx)
testl %eax, %eax
setne 0x463(%rbx)
je 0x242df
movb 0x8ba21(%rip), %al      # 0xafcf0
testb %al, %al
je 0x242e4
leaq 0x899ae(%rip), %rdi     # 0xadc88
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x8ba05(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x242d3
leaq 0x8997d(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x3141(%rip), %rdi     # 0x211c6
leaq 0x8996a(%rip), %rsi     # 0xadc78
leaq 0x89243(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8b9cf(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x242d3
movq %rax, %rbx
leaq 0x8b9be(%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::CImgDisplay::set_wheel(int)
CImgDisplay& set_wheel(const int amplitude) {
      _wheel+=amplitude;
      _is_event = amplitude?true:false;
      if (amplitude) {
#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
addl %esi, 0x45c(%rdi)
testl %esi, %esi
setne 0x463(%rdi)
je 0x2436b
movb 0x8b995(%rip), %al      # 0xafcf0
testb %al, %al
je 0x24370
leaq 0x89922(%rip), %rdi     # 0xadc88
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
leaq 0x8b979(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x2435f
leaq 0x898f1(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x31cd(%rip), %rdi     # 0x211c6
leaq 0x898de(%rip), %rsi     # 0xadc78
leaq 0x891b7(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x8b943(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x2435f
movq %rax, %rbx
leaq 0x8b932(%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::CImg<unsigned char>::default_LUT256()
static const CImg<Tuchar>& default_LUT256() {
      static CImg<Tuchar> colormap;
      cimg::mutex(8);
      if (!colormap) {
        colormap.assign(1,256,1,3);
        for (unsigned int index = 0, r = 16; r<256; r+=32)
          for (unsigned int g = 16; g<256; g+=32)
            for (unsigned int b = 32; b<256; b+=64) {
              colormap(0,index,0) = (Tuchar)r;
              colormap(0,index,1) = (Tuchar)g;
              colormap(0,index++,2) = (Tuchar)b;
            }
      }
      cimg::mutex(8,0);
      return colormap;
    }

// Assembly:
pushq %rax
movb 0x896d5(%rip), %al      # 0xafd40
testb %al, %al
je 0x2676f
movb 0x8741f(%rip), %al      # 0xada98
testb %al, %al
je 0x26779
leaq 0x87050(%rip), %rdi     # 0xad6d8
callq 0x4790
cmpq $0x0, 0x896a3(%rip)     # 0xafd38
jne 0x26750
leaq 0x8967e(%rip), %rdi     # 0xafd20
movl $0x1, %esi
movl $0x100, %edx            # imm = 0x100
movl $0x1, %ecx
movl $0x3, %r8d
callq 0x10470
xorl %eax, %eax
movl $0x10, %ecx
movl $0x10, %edx
movl $0xffffff00, %esi       # imm = 0xFFFFFF00
movq 0x89664(%rip), %r8      # 0xafd38
movl %eax, %edi
movl 0x89643(%rip), %r9d     # 0xafd20
imulq %rdi, %r9
movb %cl, (%r8,%r9)
movl 0x89634(%rip), %r8d     # 0xafd20
movl 0x89631(%rip), %r9d     # 0xafd24
imulq %r8, %r9
imulq %rdi, %r8
addq 0x89636(%rip), %r8      # 0xafd38
movb %dl, (%r9,%r8)
incl %eax
movl 0x89611(%rip), %r8d     # 0xafd20
imulq %r8, %rdi
movl 0x8960a(%rip), %r9d     # 0xafd24
addq 0x89617(%rip), %rdi     # 0xafd38
imulq %r8, %r9
leal 0x20(%rsi), %r8d
movb %r8b, (%rdi,%r9,2)
addl $0x40, %esi
jne 0x266cd
leal 0x20(%rdx), %esi
cmpl $0xe0, %edx
movl %esi, %edx
jb 0x266c8
leal 0x20(%rcx), %edx
cmpl $0xe0, %ecx
movl %edx, %ecx
jb 0x266c3
movb 0x87342(%rip), %al      # 0xada98
testb %al, %al
je 0x26783
leaq 0x86f77(%rip), %rdi     # 0xad6d8
callq 0x43e0
leaq 0x895b3(%rip), %rax     # 0xafd20
popq %rcx
retq
callq 0x500f
jmp 0x26673
callq 0x5062
jmp 0x26681
callq 0x50b2
jmp 0x2675a
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: double const& cimg_library::CImg<double>::max_min<double>(double&) const
const T& max_min(t& min_val) const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "max_min(): Empty instance.",
                                    cimg_instance);
      const T *ptr_max = _data;
      T max_value = *ptr_max, min_value = max_value;
      cimg_for(*this,ptrs,T) {
        const T val = *ptrs;
        if (val>max_value) { max_value = val; ptr_max = ptrs; }
        if (val<min_value) min_value = val;
      }
      min_val = (t)min_value;
      return *ptr_max;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x61b5f
movdqu (%rbx), %xmm1
pxor %xmm0, %xmm0
pcmpeqd %xmm1, %xmm0
movmskps %xmm0, %ecx
testb %cl, %cl
jne 0x61b5f
movsd (%rax), %xmm0
movd %xmm1, %ecx
pshufd $0x55, %xmm1, %xmm2     # xmm2 = xmm1[1,1,1,1]
movd %xmm2, %edx
imulq %rcx, %rdx
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
movd %xmm1, %edi
movl 0xc(%rbx), %ecx
imulq %rdi, %rcx
imulq %rdx, %rcx
testq %rcx, %rcx
jle 0x61b4f
leaq (%rax,%rcx,8), %rcx
movq %rax, %rdx
movapd %xmm0, %xmm2
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm3
maxsd %xmm0, %xmm3
cmovaq %rdx, %rax
minsd %xmm2, %xmm1
addq $0x8, %rdx
movapd %xmm3, %xmm0
movapd %xmm1, %xmm2
cmpq %rcx, %rdx
jb 0x61b24
jmp 0x61b53
movapd %xmm0, %xmm1
movsd %xmm1, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl 0xc(%rbx), %r9d
leaq 0x117b8(%rip), %rax     # 0x73338
leaq 0x12b8b(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%rbx)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x32055(%rip), %r11     # 0x93bef
leaq 0x3190e(%rip), %rsi     # 0x934af
movq %r14, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%rbx)
callq 0xbfd8
addq $0x20, %rsp
leaq 0x4b04b(%rip), %rsi     # 0xacc08
movq 0x4b40c(%rip), %rdx     # 0xacfd0
movq %r14, %rdi
callq 0x4900
movq %rax, %rbx
movq %r14, %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::CImgDisplay::show()
CImgDisplay& show() {
      if (is_empty() || !_is_closed) return *this;
      Display *const dpy = cimg::X11_attr().display;
      XLockDisplay(dpy);
      if (_is_fullscreen) _init_fullscreen();
      _map_window();
      _is_closed = false;
      XUnlockDisplay(dpy);
      return paint();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x3702d
cmpl $0x0, 0x1c(%rbx)
je 0x3702d
movb 0x460(%rbx), %al
cmpb $0x1, %al
jne 0x3702d
movb 0x78d0f(%rip), %al      # 0xafcf0
testb %al, %al
je 0x37038
movq 0x78cf4(%rip), %r14     # 0xafce0
movq %r14, %rdi
callq 0x4280
cmpb $0x1, 0x30(%rbx)
jne 0x37002
movq %rbx, %rdi
callq 0x23336
movq %rbx, %rdi
callq 0x23856
movb $0x0, 0x460(%rbx)
movq %r14, %rdi
callq 0x41f0
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20e5e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x78cb1(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x36fe5
leaq 0x76c29(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x15e95(%rip), %rdi    # 0x211c6
leaq 0x76c16(%rip), %rsi     # 0xadc78
leaq 0x764ef(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x78c7b(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x36fe5
movq %rax, %rbx
leaq 0x78c67(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay& cimg_library::CImgDisplay::display<unsigned char>(cimg_library::CImg<unsigned char> const&)
CImgDisplay& display(const CImg<T>& img) {
      if (!img)
        throw CImgArgumentException(_cimgdisplay_instance
                                    "display(): Empty specified image.",
                                    cimgdisplay_instance);
      if (is_empty()) return assign(img);
      return render(img).paint(false);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x18(%rsi)
je 0x370e9
cmpl $0x0, 0x18(%r14)
je 0x370cd
cmpl $0x0, 0x1c(%r14)
je 0x370cd
movq %r14, %rdi
xorl %edx, %edx
callq 0x1faa4
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20e5e
movq %r14, %rdi
xorl %edx, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e394
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
movl 0x18(%r14), %edx
movq 0x38(%r14), %rax
testq %rax, %rax
movl $0x5b, %r9d
movl $0x22, %esi
cmovnel %esi, %r9d
movl 0x1c(%r14), %ecx
leaq 0x5c1b2(%rip), %r10     # 0x932cd
cmovneq %rax, %r10
movl 0x20(%r14), %r8d
movl $0x5d, %r11d
cmovnel %esi, %r11d
leaq 0x5c437(%rip), %rsi     # 0x9356b
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0xc196
addq $0x10, %rsp
leaq 0x75ad3(%rip), %rsi     # 0xacc20
movq 0x75e7c(%rip), %rdx     # 0xacfd0
movq %rbx, %rdi
callq 0x4900
movq %rax, %r14
movq %rbx, %rdi
callq 0x43b0
movq %r14, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::assign(unsigned int, unsigned int, char const*, unsigned int, bool, bool)
CImgDisplay& assign(const unsigned int dimw, const unsigned int dimh, const char *const title=0,
                        const unsigned int normalization_type=3,
                        const bool fullscreen_flag=false, const bool closed_flag=false) {
      if (!dimw || !dimh) return assign();
      _assign(dimw,dimh,title,normalization_type,fullscreen_flag,closed_flag);
      _min = _max = 0;
      std::memset(_data,0,(cimg::X11_attr().nb_bits==8?sizeof(unsigned char):
                           (cimg::X11_attr().nb_bits==16?sizeof(unsigned short):sizeof(unsigned int)))*
                  (unsigned long)_width*_height);
      return paint();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
setne %al
testl %edx, %edx
setne %dil
testb %dil, %al
je 0x374f0
movzbl 0x20(%rsp), %eax
movl %eax, (%rsp)
movzbl %r9b, %r9d
movq %rbx, %rdi
callq 0x1ed3a
movq $0x0, 0x28(%rbx)
movq 0x4f0(%rbx), %r14
movb 0x78860(%rip), %al      # 0xafcf0
testb %al, %al
je 0x374ff
movl $0x1, %eax
cmpl $0x8, 0x78848(%rip)     # 0xafce8
je 0x374c4
movb 0x78848(%rip), %al      # 0xafcf0
testb %al, %al
je 0x37546
xorl %eax, %eax
cmpl $0x10, 0x7882f(%rip)    # 0xafce8
setne %al
leaq 0x2(,%rax,2), %rax
movl 0x18(%rbx), %ecx
movl 0x1c(%rbx), %edx
imulq %rax, %rcx
imulq %rcx, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4290
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20e5e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e50e
leaq 0x787ea(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x37494
leaq 0x76762(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x1635c(%rip), %rdi    # 0x211c6
leaq 0x7674f(%rip), %rsi     # 0xadc78
leaq 0x76028(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x787b4(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x37494
leaq 0x787a3(%rip), %rdi     # 0xafcf0
callq 0x49b0
testl %eax, %eax
je 0x374b0
leaq 0x76717(%rip), %rdi     # 0xadc78
callq 0x21188
leaq -0x163a7(%rip), %rdi    # 0x211c6
leaq 0x76704(%rip), %rsi     # 0xadc78
leaq 0x75fdd(%rip), %rdx     # 0xad558
callq 0x44b0
leaq 0x78769(%rip), %rdi     # 0xafcf0
callq 0x4330
jmp 0x374b0
jmp 0x37593
movq %rax, %rbx
leaq 0x78753(%rip), %rdi     # 0xafcf0
callq 0x4310
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::wait(unsigned int)
inline unsigned int wait(const unsigned int milliseconds) {
      cimg::mutex(3);
      static unsigned long timer = 0;
      if (!timer) timer = cimg::time();
      cimg::mutex(3,0);
      return _wait(milliseconds,timer);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movb 0x764dd(%rip), %al      # 0xada98
testb %al, %al
je 0x37705
leaq 0x76046(%rip), %rdi     # 0xad610
callq 0x4790
cmpq $0x0, 0x78799(%rip)     # 0xafd70
jne 0x37613
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x48a0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r14)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
addq %rdx, %rax
movq %rax, 0x7875d(%rip)     # 0xafd70
movb 0x7647f(%rip), %al      # 0xada98
testb %al, %al
je 0x3770f
leaq 0x75fe8(%rip), %rdi     # 0xad610
callq 0x43e0
cmpq $0x0, 0x7873b(%rip)     # 0xafd70
jne 0x37671
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x48a0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r14)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
addq %rdx, %rax
movq %rax, 0x786ff(%rip)     # 0xafd70
xorl %r14d, %r14d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x48a0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r15)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
imulq $0x3e8, (%r15), %rax    # imm = 0x3E8
addq %rdx, %rax
movl %ebx, %ecx
addq 0x786c0(%rip), %rcx     # 0xafd70
cmpq %rax, %rcx
jbe 0x376f1
movl %ecx, %r14d
subl %eax, %r14d
movq %rcx, 0x786ae(%rip)     # 0xafd70
imulq $0x10624dd3, %r14, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %r14d, %ecx
subl %eax, %ecx
imull $0xf4240, %ecx, %eax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x4130
jmp 0x376f8
movq %rax, 0x78678(%rip)     # 0xafd70
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x5102
jmp 0x375c3
callq 0x5152
jmp 0x37621
nop
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::fclose(_IO_FILE*)
inline int fclose(std::FILE *file) {
      if (!file) warn("cimg::fclose(): Specified file is (null).");
      if (!file || file==stdin || file==stdout) return 0;
      const int errn = std::fclose(file);
      if (errn!=0) warn("cimg::fclose(): Error code %d returned during file closing.",
                        errn);
      return errn;
    }

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3849b
movq 0x74b3d(%rip), %rax     # 0xacfa8
xorl %ebx, %ebx
cmpq %rdi, (%rax)
je 0x384ab
movq 0x74b0f(%rip), %rax     # 0xacf88
cmpq %rdi, (%rax)
je 0x384ab
callq 0x4540
movl %eax, %ebx
testl %eax, %eax
je 0x384ab
leaq 0x5b63c(%rip), %rdi     # 0x93acc
movl %ebx, %esi
xorl %eax, %eax
callq 0xbb52
jmp 0x384ab
leaq 0x5b600(%rip), %rdi     # 0x93aa2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xbb52
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::strcasecmp(char const*, char const*)
inline int strcasecmp(const char *const str1, const char *const str2) {
      if (!str1) return str2?-1:0;
      const unsigned int
        l1 = (unsigned int)std::strlen(str1),
        l2 = (unsigned int)std::strlen(str2);
      return cimg::strncasecmp(str1,str2,1+(l1<l2?l1:l2));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3b79c
movq %rdi, %r14
callq 0x41e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x41e0
movq %rax, %rcx
cmpl %ecx, %r15d
cmovbl %r15d, %ecx
xorl %eax, %eax
movl %ecx, %edx
incl %edx
je 0x3b7a3
xorl %esi, %esi
movl $0x0, %edi
movl $0x0, %eax
cmpl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
ja 0x3b795
movl %edx, %ecx
xorl %edi, %edi
movzbl (%r14,%rdi), %eax
leal -0x5b(%rax), %r8d
leal 0x20(%rax), %r9d
cmpb $-0x1a, %r8b
movzbl %r9b, %r8d
cmovbl %eax, %r8d
movsbl %r8b, %eax
movzbl (%rbx,%rdi), %r8d
leal -0x5b(%r8), %r9d
leal 0x20(%r8), %r10d
cmpb $-0x1a, %r9b
movzbl %r10b, %r9d
cmovbl %r8d, %r9d
movsbl %r9b, %r8d
subl %r8d, %eax
jne 0x3b795
incq %rdi
cmpl %edi, %ecx
jne 0x3b74d
movl %edx, %edi
cmpl %edx, %edi
cmovel %esi, %eax
jmp 0x3b7a3
xorl %eax, %eax
negq %rbx
sbbl %eax, %eax
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::CImg<double>::load_exr(char const*)
CImg<T>& load_exr(const char *const filename) {
      if (!filename)
        throw CImgArgumentException(_cimg_instance
                                    "load_exr(): Specified filename is (null).",
                                    cimg_instance);

#ifndef cimg_use_openexr
      return load_other(filename);
#else
      Imf::RgbaInputFile file(filename);
      Imath::Box2i dw = file.dataWindow();
      const int
        inwidth = dw.max.x - dw.min.x + 1,
        inheight = dw.max.y - dw.min.y + 1;
      Imf::Array2D<Imf::Rgba> pixels;
      pixels.resizeErase(inheight,inwidth);
      file.setFrameBuffer(&pixels[0][0] - dw.min.x - dw.min.y*inwidth, 1, inwidth);
      file.readPixels(dw.min.y, dw.max.y);
      assign(inwidth,inheight,1,4);
      T *ptr_r = data(0,0,0,0), *ptr_g = data(0,0,0,1), *ptr_b = data(0,0,0,2), *ptr_a = data(0,0,0,3);
      cimg_forXY(*this,x,y) {
        *(ptr_r++) = (T)pixels[y][x].r;
        *(ptr_g++) = (T)pixels[y][x].g;
        *(ptr_b++) = (T)pixels[y][x].b;
        *(ptr_a++) = (T)pixels[y][x].a;
      }
      return *this;
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x3b8df
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d31a
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 0x37a36(%rip), %rax     # 0x73338
leaq 0x38e09(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x582d2(%rip), %r11     # 0x93bef
leaq 0x59121(%rip), %rsi     # 0x94a45
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0xc196
addq $0x20, %rsp
leaq 0x712df(%rip), %rsi     # 0xacc20
movq 0x71688(%rip), %rdx     # 0xacfd0
movq %rbx, %rdi
callq 0x4900
movq %rax, %r14
movq %rbx, %rdi
callq 0x43b0
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>::load_parrec(char const*, char, float)
CImg<T>& load_parrec(const char *const filename, const char axis='c', const float align=0) {
      CImgList<T> list;
      list.load_parrec(filename);
      if (list._width==1) return list[0].move_to(*this);
      return assign(list.get_append(axis,align));
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movss %xmm0, 0xc(%rsp)
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x4dbc2
cmpl $0x1, 0x10(%rsp)
jne 0x3c636
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xb6d4
movq %rax, %rbx
jmp 0x3c687
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0xb120
movq 0x40(%rsp), %rsi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x34(%rsp), %r9d
movq %rbx, %rdi
callq 0xb8ee
movq %rax, %rbx
cmpb $0x0, 0x38(%rsp)
jne 0x3c687
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3c687
callq 0x4680
leaq 0x10(%rsp), %rdi
callq 0xb746
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x38(%rsp)
jne 0x3c6bb
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3c6bb
callq 0x4680
jmp 0x3c6bb
jmp 0x3c6b8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb746
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::load_minc2(char const*)
CImg<T>& load_minc2(const char *const filename) {
      if (!filename)
        throw CImgArgumentException(_cimg_instance
                                    "load_minc2(): Specified filename is (null).",
                                    cimg_instance);
#ifndef cimg_use_minc2
      return load_other(filename);
#else
      minc::minc_1_reader rdr;
      rdr.open(filename);
      assign(rdr.ndim(1)?rdr.ndim(1):1,
             rdr.ndim(2)?rdr.ndim(2):1,
             rdr.ndim(3)?rdr.ndim(3):1,
             rdr.ndim(4)?rdr.ndim(4):1);
      if(typeid(T)==typeid(unsigned char))
        rdr.setup_read_byte();
      else if(typeid(T)==typeid(int))
        rdr.setup_read_int();
      else if(typeid(T)==typeid(double))
        rdr.setup_read_double();
      else
        rdr.setup_read_float();
      minc::load_standard_volume(rdr, this->_data);
      return *this;
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x3c6e9
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d31a
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 0x36c2c(%rip), %rax     # 0x73338
leaq 0x37fff(%rip), %r10     # 0x74712
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x574c8(%rip), %r11     # 0x93bef
leaq 0x58ac3(%rip), %rsi     # 0x951f1
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0xc196
addq $0x20, %rsp
leaq 0x704d5(%rip), %rsi     # 0xacc20
movq 0x7087e(%rip), %rdx     # 0xacfd0
movq %rbx, %rdi
callq 0x4900
movq %rax, %r14
movq %rbx, %rdi
callq 0x43b0
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>::load_cimg(char const*, char, float)
CImg<T>& load_cimg(const char *const filename, const char axis='z', const float align=0) {
      CImgList<T> list;
      list.load_cimg(filename);
      if (list._width==1) return list[0].move_to(*this);
      return assign(list.get_append(axis,align));
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movss %xmm0, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x563fc
cmpl $0x1, 0x10(%rsp)
jne 0x3c7ad
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xb6d4
movq %rax, %rbx
jmp 0x3c7fe
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0xb120
movq 0x40(%rsp), %rsi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x34(%rsp), %r9d
movq %rbx, %rdi
callq 0xb8ee
movq %rax, %rbx
cmpb $0x0, 0x38(%rsp)
jne 0x3c7fe
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3c7fe
callq 0x4680
leaq 0x10(%rsp), %rdi
callq 0xb746
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x38(%rsp)
jne 0x3c832
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3c832
callq 0x4680
jmp 0x3c832
jmp 0x3c82f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb746
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::fopen(char const*, char const*)
inline std::FILE *fopen(const char *const path, const char *const mode) {
      if (!path)
        throw CImgArgumentException("cimg::fopen(): Specified file path is (null).");
      if (!mode)
        throw CImgArgumentException("cimg::fopen(): File '%s', specified mode is (null).",
                                    path);
      std::FILE *res = 0;
      if (*path=='-' && (!path[1] || path[1]=='.')) {
        res = (*mode=='r')?stdin:stdout;
#if cimg_OS==2
        if (*mode && mode[1]=='b') { // Force stdin/stdout to be in binary mode.
          if (_setmode(_fileno(res),0x8000)==-1) res = 0;
        }
#endif
      } else res = std::fopen(path,mode);
      if (!res) throw CImgIOException("cimg::fopen(): Failed to open file '%s' with mode '%s'.",
                                      path,mode);
      return res;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3cf0d
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x3cf2d
cmpb $0x2d, (%r14)
jne 0x3ceeb
movzbl 0x1(%r14), %eax
cmpl $0x2e, %eax
je 0x3cedc
testl %eax, %eax
jne 0x3ceeb
cmpb $0x72, (%r15)
jne 0x3cef8
movq 0x700bf(%rip), %rax     # 0xacfa8
jmp 0x3ceff
movq %r14, %rdi
movq %r15, %rsi
callq 0x45c0
jmp 0x3cf02
movq 0x70089(%rip), %rax     # 0xacf88
movq (%rax), %rax
testq %rax, %rax
je 0x3cf57
popq %rbx
popq %r14
popq %r15
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x58ccf(%rip), %rsi     # 0x95bf0
movq %rax, %rdi
xorl %eax, %eax
callq 0xc196
jmp 0x3cf4e
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x58cdd(%rip), %rsi     # 0x95c1e
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xc196
leaq 0x6fccb(%rip), %rsi     # 0xacc20
jmp 0x3cf82
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x58ce7(%rip), %rsi     # 0x95c52
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x385b4
leaq 0x6fd6e(%rip), %rsi     # 0xaccf0
movq 0x70047(%rip), %rdx     # 0xacfd0
movq %rbx, %rdi
callq 0x4900
jmp 0x3cf95
jmp 0x3cf95
movq %rax, %r14
movq %rbx, %rdi
callq 0x43b0
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::curl_path(char const*, bool)
inline const char *curl_path(const char *const user_path=0, const bool reinit_path=false) {
      static char *s_path = 0;
      cimg::mutex(7);
      if (reinit_path) { delete[] s_path; s_path = 0; }
      if (user_path) {
        if (!s_path) s_path = new char[1024];
        std::memset(s_path,0,1024);
        std::strncpy(s_path,user_path,1023);
      } else if (!s_path) {
        s_path = new char[1024];
        std::memset(s_path,0,1024);
        bool path_found = false;
        std::FILE *file = 0;
#if cimg_OS==2
        if (!path_found) {
          std::strcpy(s_path,".\\curl.exe");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"curl.exe");
#else
        if (!path_found) {
          std::strcpy(s_path,"./curl");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"curl");
#endif
        winformat_string(s_path);
      }
      cimg::mutex(7,0);
      return s_path;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movb 0x70493(%rip), %al      # 0xada98
testb %al, %al
je 0x3d74b
leaq 0x7009c(%rip), %rdi     # 0xad6b0
callq 0x4790
testb %bpl, %bpl
je 0x3d63a
movq 0x7288b(%rip), %rdi     # 0xafeb0
testq %rdi, %rdi
je 0x3d62f
callq 0x4680
movq $0x0, 0x72876(%rip) # 0xafeb0
movq 0x7286f(%rip), %rax     # 0xafeb0
testq %rbx, %rbx
je 0x3d684
testq %rax, %rax
jne 0x3d65c
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, 0x72854(%rip)     # 0xafeb0
movq 0x7284d(%rip), %r14     # 0xafeb0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x4290
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4240
jmp 0x3d689
testq %rax, %rax
je 0x3d6af
movb 0x70409(%rip), %al      # 0xada98
testb %al, %al
je 0x3d755
leaq 0x70012(%rip), %rdi     # 0xad6b0
callq 0x43e0
movq 0x72806(%rip), %rax     # 0xafeb0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %rbx
movq %rax, 0x727ed(%rip)     # 0xafeb0
leaq 0x7(%rax), %rdi
movl $0x3f9, %edx            # imm = 0x3F9
xorl %esi, %esi
callq 0x4290
movl $0x75632f2e, (%rbx)     # imm = 0x75632F2E
movl $0x6c7275, 0x3(%rbx)    # imm = 0x6C7275
leaq 0x41bfc(%rip), %rsi     # 0x7f2e3
movq %rbx, %rdi
callq 0x45c0
testq %rax, %rax
je 0x3d735
movq 0x6f8ad(%rip), %rcx     # 0xacfa8
cmpq %rax, (%rcx)
je 0x3d689
movq 0x6f881(%rip), %rcx     # 0xacf88
cmpq %rax, (%rcx)
je 0x3d689
movq %rax, %rdi
callq 0x4540
testl %eax, %eax
je 0x3d689
leaq 0x563a5(%rip), %rdi     # 0x93acc
movl %eax, %esi
xorl %eax, %eax
callq 0xbb52
jmp 0x3d689
movq 0x72774(%rip), %rax     # 0xafeb0
movb $0x0, 0x4(%rax)
movl $0x6c727563, (%rax)     # imm = 0x6C727563
jmp 0x3d689
callq 0x54cc
jmp 0x3d60d
callq 0x551c
jmp 0x3d697