LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x1f750
testb $0x1, %al
jne 0x3759a
jmp 0x3767d
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x28(%rsp)
movl (%rax), %ecx
movl %ecx, 0x30(%rsp)
movl 0x4(%rax), %ecx
movl %ecx, 0x34(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x38(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rsp)
movb 0x10(%rax), %dl
leaq 0xb13f3(%rip), %rcx     # 0xe89d2
leaq 0x924fb(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x1c2e0
movq %rax, 0x50(%rsp)
jmp 0x375fe
movl 0x3c(%rsp), %r9d
movl 0x38(%rsp), %r8d
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %r10
movq 0x50(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rsi, (%rax)
leaq 0xb0fcf(%rip), %rsi     # 0xe8608
xorl %eax, %eax
callq 0x11fd0
jmp 0x37642
movq 0x28(%rsp), %rdi
leaq 0xc84fa(%rip), %rsi     # 0xffb48
leaq -0x25445(%rip), %rdx    # 0x12210
callq 0x5920
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x53a0
jmp 0x37709
movq 0x58(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movb (%rax), %al
movb %al, 0x77(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x68(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
callq 0x1c2b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0x376fc
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
movzbl 0x77(%rsp), %ecx
cmpl %ecx, %eax
jge 0x376ea
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movb (%rax), %al
movb %al, 0x77(%rsp)
jmp 0x376ec
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x376bd
movq 0x78(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x3afc6
movl $0x0, 0x44(%rsp)
jmp 0x3b0b1
cmpq $0x0, 0x38(%rsp)
jne 0x3afea
movq 0x30(%rsp), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, 0x44(%rsp)
jmp 0x3b0b1
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %ecx
xorl %eax, %eax
cmpl 0x2c(%rsp), %ecx
movb %al, 0xf(%rsp)
jge 0x3b05a
movq 0x20(%rsp), %rax
movsbl (%rax), %edi
callq 0x1e0a0
movsbl %al, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0x1e0a0
movb %al, %cl
movl 0x8(%rsp), %eax
movsbl %cl, %ecx
subl %ecx, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3b064
jmp 0x3b08d
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3b00e
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
je 0x3b0a1
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x3b0a9
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x3b0a9
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0xd8(%rsp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x5150
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x57f0
cmpq $0x0, 0xe0(%rsp)
jne 0x3b44a
jmp 0x3b33a
movq 0xd8(%rsp), %rdi
callq 0x5290
movq 0xd8(%rsp), %rdi
movl $0x21, %esi
leaq 0x18(%rsp), %rdx
callq 0x5930
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x3b394
movq 0xd8(%rsp), %rdi
movl $0x2807f, %esi          # imm = 0x2807F
leaq 0x18(%rsp), %rdx
callq 0x56c0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0x3b429
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x37200
movq %rax, %rcx
movl 0xc(%rsp), %eax
movl (%rcx), %ecx
cmpl %ecx, %eax
jae 0x3b427
callq 0x37200
movl 0x10(%rsp), %ecx
movq 0x68(%rax,%rcx,8), %rax
movb 0x460(%rax), %al
testb $0x1, %al
jne 0x3b418
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x37200
movq %rax, %rcx
movq (%rsp), %rax
movl 0x10(%rsp), %edx
movq 0x68(%rcx,%rdx,8), %rcx
cmpq 0x4d0(%rcx), %rax
jne 0x3b418
callq 0x37200
movl 0x10(%rsp), %ecx
movq 0x68(%rax,%rcx,8), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3bcd0
jmp 0x3b41a
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3b3a7
jmp 0x3b429
movq 0xd8(%rsp), %rdi
callq 0x5220
callq 0x5370
movl $0x8, %edi
callq 0x3c5a0
jmp 0x3b33a
xorl %eax, %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x170(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x37200
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x2068(%rcx), %rcx
movq %rcx, 0x168(%rsp)
movb $0x0, 0x167(%rsp)
movb $0x0, 0x166(%rsp)
movq 0x168(%rsp), %rdi
movq 0x4d0(%rax), %rsi
callq 0x5a70
movq 0x10(%rsp), %rax
movq 0x168(%rsp), %rdi
movq 0x4d0(%rax), %rsi
movl $0x28000, %edx          # imm = 0x28000
leaq 0x18(%rsp), %rcx
callq 0x5110
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0xc, %eax
je 0x3bbe3
jmp 0x3bbce
movl 0xc(%rsp), %eax
subl $0x13, %eax
jne 0x3bbeb
jmp 0x3bbd9
movb $0x1, 0x166(%rsp)
jmp 0x3bbeb
movb $0x1, 0x167(%rsp)
jmp 0x3bbed
movb $0x1, %al
testb $0x1, 0x167(%rsp)
movb %al, 0xb(%rsp)
je 0x3bc0a
movb 0x166(%rsp), %al
xorb $-0x1, %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x3bb9c
jmp 0x3bc14
movq 0x10(%rsp), %rax
movq 0x168(%rsp), %rdi
movq 0x4d0(%rax), %rsi
leaq 0xd8(%rsp), %rdx
callq 0x5990
cmpl $0x2, 0x134(%rsp)
je 0x3bc58
movq 0x168(%rsp), %rdi
xorl %esi, %esi
callq 0x5a60
movl $0xa, %edi
callq 0x3c5a0
jmp 0x3bc5a
cmpl $0x2, 0x134(%rsp)
jne 0x3bc14
movq 0x10(%rsp), %rax
movl 0xd8(%rsp), %ecx
movl %ecx, 0x44c(%rax)
movl 0xdc(%rsp), %ecx
movl %ecx, 0x450(%rax)
addq $0x178, %rsp            # imm = 0x178
retq
nopl (%rax,%rax)
// File: 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, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5170
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x108, %rsp            # imm = 0x108
movb %sil, %al
movq %rdi, 0x100(%rsp)
andb $0x1, %al
movb %al, 0xff(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0x460(%rax), %al
testb $0x1, %al
jne 0x3c631
movq 0x20(%rsp), %rax
cmpq $0x0, 0x4e8(%rax)
jne 0x3c636
jmp 0x3c75e
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0xf0(%rsp)
testb $0x1, 0xff(%rsp)
je 0x3c6e6
movq 0x20(%rsp), %rdi
movl $0xc, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movl $0x1, 0x40(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x4d0(%rdi), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movl $0x0, 0x5c(%rsp)
callq 0x17aa0
movq 0x20(%rsp), %rdi
movl %eax, 0x60(%rsp)
callq 0x17bc0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x64(%rsp)
movl $0x0, 0x68(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x4d0(%rax), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x30(%rsp), %r8
callq 0x5100
jmp 0x3c75e
movq 0x20(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq 0xe8(%rcx), %rcx
movq 0xf0(%rsp), %rdx
movslq 0xe0(%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
movq 0x48(%rcx), %rcx
movq %rcx, 0x28(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x4d0(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x4e8(%rax), %rcx
movl 0x18(%rax), %r10d
movl 0x1c(%rax), %eax
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x5ad0
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x3c7a1
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3c7cd
cmpl $0x2, 0x1c(%rsp)
jne 0x3c7b2
movl $0x2, %eax
movl %eax, (%rsp)
jmp 0x3c7c6
movl 0x1c(%rsp), %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x3c7ef
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
movl 0x48(%rax), %ecx
orl %edx, %ecx
movl %ecx, 0x48(%rax)
jmp 0x3c803
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
xorl $-0x1, %edx
movl 0x48(%rax), %ecx
andl %edx, %ecx
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
xorl %ecx, %ecx
negl %edx
sbbl %ecx, %ecx
andb $0x1, %cl
movb %cl, 0x463(%rax)
cmpl $0x0, 0x14(%rsp)
je 0x3c833
callq 0x37200
movq %rax, %rdi
addq $0x10, %rdi
callq 0x51a0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edx
movl 0x45c(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0x45c(%rax)
movl 0xc(%rsp), %edx
xorl %ecx, %ecx
negl %edx
sbbl %ecx, %ecx
andb $0x1, %cl
movb %cl, 0x463(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x3c893
callq 0x37200
movq %rax, %rdi
addq $0x10, %rdi
callq 0x51a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
cmpb $0x0, 0xc5a95(%rip)     # 0x102d60
jne 0x3d312
leaq 0xc5a8c(%rip), %rdi     # 0x102d60
callq 0x59d0
cmpl $0x0, %eax
je 0x3d312
leaq 0xc5a5b(%rip), %rdi     # 0x102d40
callq 0x156b0
jmp 0x3d2ec
leaq -0x27ca3(%rip), %rdi    # 0x15650
leaq 0xc5a46(%rip), %rsi     # 0x102d40
leaq 0xc3277(%rip), %rdx     # 0x100578
callq 0x54a0
leaq 0xc5a53(%rip), %rdi     # 0x102d60
callq 0x5340
movl $0x8, %edi
movl $0x1, %esi
callq 0x12d30
leaq 0xc5a18(%rip), %rdi     # 0x102d40
callq 0x19990
cmpq $0x0, %rax
jne 0x3d466
leaq 0xc5a02(%rip), %rdi     # 0x102d40
movl $0x1, %ecx
movl $0x100, %edx            # imm = 0x100
movl $0x3, %r8d
movl %ecx, %esi
callq 0x199a0
movl $0x0, 0x18(%rsp)
movl $0x10, 0x14(%rsp)
cmpl $0x100, 0x14(%rsp)      # imm = 0x100
jae 0x3d464
movl $0x10, 0x10(%rsp)
cmpl $0x100, 0x10(%rsp)      # imm = 0x100
jae 0x3d452
movl $0x20, 0xc(%rsp)
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jae 0x3d440
movl 0x14(%rsp), %eax
movb %al, 0x9(%rsp)
movl 0x18(%rsp), %edx
leaq 0xc598e(%rip), %rdi     # 0x102d40
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x43e60
movb 0x9(%rsp), %cl
movb %cl, (%rax)
movl 0x10(%rsp), %eax
movb %al, 0xa(%rsp)
movl 0x18(%rsp), %edx
leaq 0xc596c(%rip), %rdi     # 0x102d40
xorl %esi, %esi
movl $0x1, %ecx
callq 0x43e60
movb 0xa(%rsp), %cl
movb %cl, (%rax)
movl 0xc(%rsp), %eax
movb %al, 0xb(%rsp)
movl 0x18(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
leaq 0xc593e(%rip), %rdi     # 0x102d40
xorl %esi, %esi
movl $0x2, %ecx
callq 0x43e60
movb 0xb(%rsp), %cl
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $0x40, %eax
movl %eax, 0xc(%rsp)
jmp 0x3d391
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0xc5927(%rip), %rdi     # 0x102d60
callq 0x5320
jmp 0x3d47e
jmp 0x3d442
movl 0x10(%rsp), %eax
addl $0x20, %eax
movl %eax, 0x10(%rsp)
jmp 0x3d37b
jmp 0x3d454
movl 0x14(%rsp), %eax
addl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x3d365
jmp 0x3d466
movl $0x8, %edi
xorl %esi, %esi
callq 0x12d30
leaq 0xc58c7(%rip), %rax     # 0x102d40
addq $0x28, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5970
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: unsigned int const& cimg_library::CImg<unsigned int>::max_min<float>(float&) 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x52e50
testb $0x1, %al
jne 0x5a482
jmp 0x5a565
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x28(%rsp)
movl (%rax), %ecx
movl %ecx, 0x30(%rsp)
movl 0x4(%rax), %ecx
movl %ecx, 0x34(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x38(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rsp)
movb 0x10(%rax), %dl
leaq 0x8e50b(%rip), %rcx     # 0xe89d2
leaq 0x6f613(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x32420
movq %rax, 0x50(%rsp)
jmp 0x5a4e6
movl 0x3c(%rsp), %r9d
movl 0x38(%rsp), %r8d
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %r10
movq 0x50(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x8e35d(%rip), %rsi     # 0xe887e
xorl %eax, %eax
callq 0x11fd0
jmp 0x5a52a
movq 0x28(%rsp), %rdi
leaq 0xa5612(%rip), %rsi     # 0xffb48
leaq -0x4832d(%rip), %rdx    # 0x12210
callq 0x5920
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x53a0
jmp 0x5a636
movq 0x58(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x78(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x70(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
callq 0x546d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x5a611
movq 0x70(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jbe 0x5a5ed
movl 0x64(%rsp), %eax
movl %eax, 0x7c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x78(%rsp), %eax
jae 0x5a5ff
movl 0x64(%rsp), %eax
movl %eax, 0x78(%rsp)
jmp 0x5a601
movq 0x70(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x70(%rsp)
jmp 0x5a5b7
movl 0x78(%rsp), %eax
cvtsi2ss %rax, %xmm0
movq 0x98(%rsp), %rax
movss %xmm0, (%rax)
movq 0x80(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37140
testb $0x1, %al
jne 0x5b0cb
movq 0x8(%rsp), %rax
movb 0x460(%rax), %al
testb $0x1, %al
jne 0x5b0d7
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x5b13b
callq 0x37200
movq 0x2068(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5290
movq 0x8(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x5b107
movq 0x8(%rsp), %rdi
callq 0x3b460
movq 0x8(%rsp), %rdi
callq 0x3bb40
movq 0x8(%rsp), %rax
movb $0x0, 0x460(%rax)
movq 0x10(%rsp), %rdi
callq 0x5220
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x370c0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x20360
cmpq $0x0, %rax
jne 0x5b27e
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rsp)
movl 0x18(%rax), %ecx
movl %ecx, 0x28(%rsp)
movl 0x1c(%rax), %ecx
movl %ecx, 0x2c(%rsp)
movl 0x20(%rax), %ecx
movl %ecx, 0x30(%rsp)
movq 0x38(%rax), %rcx
movb $0x22, %al
movb $0x5b, %dl
movb %dl, 0x36(%rsp)
cmpq $0x0, %rcx
movb %al, 0x37(%rsp)
jne 0x5b1c6
movb 0x36(%rsp), %al
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rax
movb 0x37(%rsp), %cl
movsbl %cl, %ecx
movl %ecx, 0x1c(%rsp)
cmpq $0x0, 0x38(%rax)
je 0x5b1ed
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x5b1fb
leaq 0x8d4a8(%rip), %rax     # 0xe869c
movq %rax, 0x10(%rsp)
jmp 0x5b1fb
movl 0x1c(%rsp), %r9d
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %edx
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rsi
movq 0x38(%rax), %rax
testq %rax, %rax
movl $0x22, %eax
movl $0x5d, %r10d
cmovnel %eax, %r10d
movq %rsp, %rax
movl %r10d, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x8d6f7(%rip), %rsi     # 0xe893a
xorl %eax, %eax
callq 0x12220
jmp 0x5b24c
movq 0x20(%rsp), %rdi
leaq 0xa4908(%rip), %rsi     # 0xffb60
leaq -0x48dff(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x53a0
jmp 0x5b2dd
movq 0x38(%rsp), %rdi
callq 0x37140
testb $0x1, %al
jne 0x5b28e
jmp 0x5b2b3
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x32870
movq %rax, 0x60(%rsp)
jmp 0x5b2d3
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
xorl %edx, %edx
callq 0x34280
movq %rax, %rdi
xorl %esi, %esi
callq 0x370c0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x5970
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::_wait(unsigned int, unsigned long&)
inline unsigned int _wait(const unsigned int milliseconds, unsigned long& timer) {
      if (!timer) timer = cimg::time();
      const unsigned long current_time = cimg::time();
      if (current_time>=timer+milliseconds) { timer = current_time; return 0; }
      const unsigned long time_diff = timer + milliseconds - current_time;
      timer = current_time + time_diff;
      cimg::sleep(time_diff);
      return (unsigned int)time_diff;
    }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5b318
callq 0x5b3a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
callq 0x5b3a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movl 0x20(%rsp), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x5b352
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x5b392
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rsp), %ecx
addq %rcx, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
addq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl %eax, %edi
callq 0x3c5a0
movq 0x8(%rsp), %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movl %r9d, %eax
movq %rcx, 0x18(%rsp)
movl %edx, %ecx
movq 0x18(%rsp), %rdx
movl %ecx, 0x20(%rsp)
movl %esi, %ecx
movl 0x20(%rsp), %esi
movl %ecx, 0x24(%rsp)
movq %rdi, %r9
movl 0x24(%rsp), %edi
movb %al, %cl
movb 0x60(%rsp), %al
movq %r9, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
andb $0x1, %cl
movb %cl, 0x33(%rsp)
andb $0x1, %al
movb %al, 0x32(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x5b87a
cmpl $0x0, 0x40(%rsp)
jne 0x5b88e
movq 0x28(%rsp), %rdi
callq 0x32b00
movq %rax, 0x50(%rsp)
jmp 0x5b957
movq 0x28(%rsp), %rdi
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movb 0x33(%rsp), %r9b
movb 0x32(%rsp), %al
andb $0x1, %r9b
andb $0x1, %al
movzbl %r9b, %r9d
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x33360
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rax)
movq 0x4f0(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x37200
cmpl $0x8, 0x2070(%rax)
jne 0x5b8fe
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x5b91f
callq 0x37200
movl 0x2070(%rax), %edx
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0x10, %edx
cmoveq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl 0x18(%rax), %ecx
imulq %rcx, %rdx
movl 0x1c(%rax), %eax
imulq %rax, %rdx
xorl %esi, %esi
callq 0x52a0
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x370c0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rax
movl %edi, 0x4(%rsp)
movl $0x3, %edi
movl $0x1, %esi
callq 0x12d30
cmpq $0x0, 0xa7404(%rip)     # 0x102d90
jne 0x5b99a
callq 0x5b3a0
movq %rax, 0xa73f6(%rip)     # 0x102d90
movl $0x3, %edi
xorl %esi, %esi
callq 0x12d30
movl 0x4(%rsp), %edi
leaq 0xa73df(%rip), %rsi     # 0x102d90
callq 0x5b2f0
popq %rcx
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5c70f
leaq 0x8c76d(%rip), %rdi     # 0xe8e75
movb $0x0, %al
callq 0x117e0
cmpq $0x0, 0x8(%rsp)
je 0x5c739
movq 0x8(%rsp), %rax
movq 0xa3895(%rip), %rcx     # 0xfffb8
cmpq (%rcx), %rax
je 0x5c739
movq 0x8(%rsp), %rax
movq 0xa385c(%rip), %rcx     # 0xfff90
cmpq (%rcx), %rax
jne 0x5c743
movl $0x0, 0x14(%rsp)
jmp 0x5c772
movq 0x8(%rsp), %rdi
callq 0x5530
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x5c76a
movl 0x4(%rsp), %esi
leaq 0x8c73c(%rip), %rdi     # 0xe8e9f
movb $0x0, %al
callq 0x117e0
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::filenamerand()
inline const char* filenamerand() {
      cimg::mutex(6);
      static char randomid[9] = { 0 };
      cimg::srand();
      for (unsigned int k = 0; k<8; ++k) {
        const int v = (int)std::rand()%3;
        randomid[k] = (char)(v==0?('0'+(std::rand()%10)):(v==1?('a'+(std::rand()%26)):('A'+(std::rand()%26))));
      }
      cimg::mutex(6,0);
      return randomid;
    }

// Assembly:
subq $0x18, %rsp
movl $0x6, %edi
movl $0x1, %esi
callq 0x12d30
callq 0x5cad0
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jae 0x5c85e
callq 0x5120
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x5c7fb
callq 0x5120
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x30, %eax
movl %eax, 0xc(%rsp)
jmp 0x5c838
cmpl $0x1, 0x10(%rsp)
jne 0x5c81a
callq 0x5120
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x61, %eax
movl %eax, 0x8(%rsp)
jmp 0x5c830
callq 0x5120
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x41, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %dl
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0xa656d(%rip), %rax     # 0x102db8
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5c7c0
movl $0x6, %edi
xorl %esi, %esi
callq 0x12d30
leaq 0xa6547(%rip), %rax     # 0x102db8
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::split_filename(char const*, char*)
inline const char *split_filename(const char *const filename, char *const body=0) {
      if (!filename) { if (body) *body = 0; return 0; }
      const char *p = 0; for (const char *np = filename; np>=filename && (p=np); np = std::strchr(np,'.')+1) {}
      if (p==filename) {
        if (body) std::strcpy(body,filename);
        return filename + std::strlen(filename);
      }
      const unsigned int l = (unsigned int)(p - filename - 1);
      if (body) { std::memcpy(body,filename,l); body[l] = 0; }
      return p;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x632b4
cmpq $0x0, 0x20(%rsp)
je 0x632a6
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x633a4
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0xb(%rsp)
jb 0x632ee
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x632f8
jmp 0x63314
jmp 0x632fa
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x51c0
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x632c7
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jne 0x6335b
cmpq $0x0, 0x20(%rsp)
je 0x63337
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x54d0
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x5210
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x633a4
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x6339a
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x5420
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x633df
movq 0x20(%rsp), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, 0x34(%rsp)
jmp 0x63445
movq 0x28(%rsp), %rdi
callq 0x5210
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5210
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x63423
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x6342b
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
addl $0x1, %edx
callq 0x3afa0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x639de
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x20(%rsp)
movl (%rax), %ecx
movl %ecx, 0x28(%rsp)
movl 0x4(%rax), %ecx
movl %ecx, 0x2c(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x30(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, 0x34(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x38(%rsp)
movb 0x10(%rax), %dl
leaq 0x85089(%rip), %rcx     # 0xe89d2
leaq 0x66191(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
callq 0x118f0
movq %rax, 0x48(%rsp)
jmp 0x63968
movl 0x34(%rsp), %r9d
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %edx
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %r10
movq 0x48(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x8644b(%rip), %rsi     # 0xe9dee
xorl %eax, %eax
callq 0x12220
jmp 0x639ac
movq 0x20(%rsp), %rdi
leaq 0x9c1a8(%rip), %rsi     # 0xffb60
leaq -0x5155f(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x53a0
jmp 0x639f2
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x65ba0
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5970
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x7c580
movq 0x20(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x7f780
jmp 0x64997
cmpl $0x1, 0x58(%rsp)
jne 0x649e9
leaq 0x58(%rsp), %rdi
callq 0x7cf60
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x10f50
movq %rax, 0x10(%rsp)
jmp 0x649bc
movq 0x10(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0x64a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x64a70
movsbl 0x6f(%rsp), %edx
movss 0x68(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10490
jmp 0x64a05
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5e300
movq %rax, 0x8(%rsp)
jmp 0x64a1b
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa540
movl $0x1, 0x48(%rsp)
jmp 0x64a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa540
jmp 0x64a70
leaq 0x58(%rsp), %rdi
callq 0x10fb0
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x10fb0
movq 0x50(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x64b8e
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x20(%rsp)
movl (%rax), %ecx
movl %ecx, 0x28(%rsp)
movl 0x4(%rax), %ecx
movl %ecx, 0x2c(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x30(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, 0x34(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x38(%rsp)
movb 0x10(%rax), %dl
leaq 0x83ed9(%rip), %rcx     # 0xe89d2
leaq 0x64fe1(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
callq 0x118f0
movq %rax, 0x48(%rsp)
jmp 0x64b18
movl 0x34(%rsp), %r9d
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %edx
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %r10
movq 0x48(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x85a49(%rip), %rsi     # 0xea59c
xorl %eax, %eax
callq 0x12220
jmp 0x64b5c
movq 0x20(%rsp), %rdi
leaq 0x9aff8(%rip), %rsi     # 0xffb60
leaq -0x5270f(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x53a0
jmp 0x64ba2
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x65ba0
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5970
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x7c580
movq 0x20(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x89800
jmp 0x64c57
cmpl $0x1, 0x58(%rsp)
jne 0x64ca9
leaq 0x58(%rsp), %rdi
callq 0x7cf60
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x10f50
movq %rax, 0x10(%rsp)
jmp 0x64c7c
movq 0x10(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0x64d16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x64d30
movsbl 0x6f(%rsp), %edx
movss 0x68(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10490
jmp 0x64cc5
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5e300
movq %rax, 0x8(%rsp)
jmp 0x64cdb
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa540
movl $0x1, 0x48(%rsp)
jmp 0x64d16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa540
jmp 0x64d30
leaq 0x58(%rsp), %rdi
callq 0x10fb0
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x10fb0
movq 0x50(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x65510
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x85ac9(%rip), %rsi     # 0xeaf9b
xorl %eax, %eax
callq 0x12220
jmp 0x654db
movq 0x18(%rsp), %rdi
leaq 0x9a679(%rip), %rsi     # 0xffb60
leaq -0x5308e(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x53a0
jmp 0x65663
cmpq $0x0, 0x38(%rsp)
jne 0x65577
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdx
leaq 0x85a90(%rip), %rsi     # 0xeafc9
xorl %eax, %eax
callq 0x12220
jmp 0x65542
movq 0x10(%rsp), %rdi
leaq 0x9a612(%rip), %rsi     # 0xffb60
leaq -0x530f5(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x53a0
jmp 0x65663
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x655df
movq 0x40(%rsp), %rax
cmpb $0x0, 0x1(%rax)
je 0x655a6
movq 0x40(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0x655df
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x655c4
movq 0x9a9fe(%rip), %rax     # 0xfffb8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x655d3
movq 0x9a9c5(%rip), %rax     # 0xfff90
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x655f3
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x55c0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x65659
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x859dd(%rip), %rsi     # 0xeaffd
xorl %eax, %eax
callq 0x5c880
jmp 0x65629
movq (%rsp), %rdi
leaq 0x9a63c(%rip), %rsi     # 0xffc70
leaq -0x8b7b(%rip), %rdx     # 0x5cac0
callq 0x5920
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x53a0
jmp 0x65663
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5970
nopl (%rax)