LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c2f5
orl %eax, 0x48(%rbx)
jmp 0x1c2fc
movl %eax, %ecx
notl %ecx
andl %ecx, 0x48(%rbx)
testl %eax, %eax
setne 0x463(%rbx)
je 0x1c315
callq 0x1a004
leaq 0x10(%rax), %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::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 0x1c33d
callq 0x1a004
leaq 0x10(%rax), %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<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 0x76515(%rip), %al      # 0x92d40
testb %al, %al
je 0x1c915
pushq $0x8
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
cmpq $0x0, 0x764f2(%rip)     # 0x92d38
je 0x1c85b
pushq $0x8
popq %rdi
xorl %esi, %esi
callq 0xa419
leaq 0x764c7(%rip), %rax     # 0x92d20
popq %rcx
retq
leaq 0x764be(%rip), %rdi     # 0x92d20
pushq $0x1
popq %rcx
pushq $0x3
popq %r8
movl %ecx, %esi
movl $0x100, %edx            # imm = 0x100
callq 0xd758
pushq $0x10
popq %rax
xorl %edx, %edx
movl %eax, %ecx
cmpl $0xff, %ecx
ja 0x1c848
movl %eax, %esi
cmpl $0xff, %esi
ja 0x1c90d
leal 0x4(%rdx), %edi
movl $0xffffff00, %r8d       # imm = 0xFFFFFF00
testl %r8d, %r8d
je 0x1c903
movq 0x76495(%rip), %r10     # 0x92d38
movl %edx, %r9d
movl 0x76473(%rip), %r11d    # 0x92d20
imulq %r9, %r11
movb %cl, (%r10,%r11)
movl 0x76464(%rip), %r10d    # 0x92d20
movl 0x76461(%rip), %r11d    # 0x92d24
imulq %r10, %r11
imulq %r9, %r10
addq 0x76466(%rip), %r10     # 0x92d38
movb %sil, (%r11,%r10)
incl %edx
movl 0x76441(%rip), %r10d    # 0x92d20
imulq %r10, %r9
movl 0x7643a(%rip), %r11d    # 0x92d24
addq 0x76447(%rip), %r9      # 0x92d38
imulq %r10, %r11
leal 0x20(%r8), %r10d
movb %r10b, (%r9,%r11,2)
addl $0x40, %r8d
jmp 0x1c897
addl $0x20, %esi
movl %edi, %edx
jmp 0x1c886
addl $0x20, %ecx
jmp 0x1c87c
leaq 0x76424(%rip), %rdi     # 0x92d40
callq 0x49a0
testl %eax, %eax
je 0x1c833
andq $0x0, 0x76407(%rip)     # 0x92d38
leaq 0x763e8(%rip), %rsi     # 0x92d20
xorps %xmm0, %xmm0
movups %xmm0, 0x763de(%rip)    # 0x92d20
movb $0x0, 0x763e7(%rip)     # 0x92d30
leaq -0x110a2(%rip), %rdi    # 0xb8ae
leaq 0x73c01(%rip), %rdx     # 0x90558
callq 0x4490
leaq 0x763dd(%rip), %rdi     # 0x92d40
callq 0x4320
jmp 0x1c833
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
callq 0x8dc8
testb %al, %al
jne 0x47d92
movq 0x18(%r14), %rcx
movsd (%rcx), %xmm0
movl (%r14), %eax
movl 0x4(%r14), %edx
imulq %rax, %rdx
movl 0x8(%r14), %eax
movl 0xc(%r14), %esi
imulq %rax, %rsi
imulq %rdx, %rsi
leaq (%rcx,%rsi,8), %rdx
movapd %xmm0, %xmm1
movq %rcx, %rax
cmpq %rdx, %rcx
jae 0x47d86
movsd (%rcx), %xmm2
ucomisd %xmm1, %xmm2
movapd %xmm2, %xmm3
maxsd %xmm1, %xmm3
cmovaq %rcx, %rax
minsd %xmm0, %xmm2
addq $0x8, %rcx
movapd %xmm2, %xmm0
movapd %xmm3, %xmm1
jmp 0x47d5b
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
leaq 0xca33(%rip), %rax      # 0x547e8
leaq 0xde06(%rip), %r10      # 0x55bc2
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x2d2cf(%rip), %r11     # 0x7509f
leaq 0x2cb88(%rip), %rsi     # 0x7495f
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0x9bf8
addq $0x20, %rsp
leaq 0x47e54(%rip), %rsi     # 0x8fc48
movq 0x481dd(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgDisplay::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 0x29678
cmpl $0x0, 0x1c(%rbx)
je 0x29678
movb 0x460(%rbx), %al
cmpb $0x1, %al
jne 0x29678
callq 0x1a004
movq 0x2068(%rax), %r14
movq %r14, %rdi
callq 0x4270
cmpb $0x1, 0x30(%rbx)
jne 0x2964f
movq %rbx, %rdi
callq 0x1b81a
movq %rbx, %rdi
callq 0x1bb9a
movb $0x0, 0x460(%rbx)
movq %r14, %rdi
callq 0x41f0
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19f72
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::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 0x296d5
cmpl $0x0, 0x18(%r14)
je 0x296bb
cmpl $0x0, 0x1c(%r14)
je 0x296bb
movq %r14, %rdi
xorl %edx, %edx
callq 0x1902c
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19f72
pushq $0x3
popq %rcx
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x182e8
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
movl 0x18(%r14), %edx
movq 0x38(%r14), %rax
testq %rax, %rax
pushq $0x5b
popq %r9
pushq $0x22
popq %rsi
cmovnel %esi, %r9d
movl 0x1c(%r14), %ecx
leaq 0x4b07a(%rip), %r10     # 0x7477d
cmovneq %rax, %r10
movl 0x20(%r14), %r8d
pushq $0x5d
popq %r11
cmovnel %esi, %r11d
leaq 0x4b301(%rip), %rsi     # 0x74a1b
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x9d52
popq %rax
popq %rcx
leaq 0x6652f(%rip), %rsi     # 0x8fc60
movq 0x668a0(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, (%rsi)
jne 0x29769
callq 0x29796
movq %rax, (%rbx)
callq 0x29796
movl %ebp, %ecx
addq (%rbx), %rcx
cmpq %rax, %rcx
jbe 0x29788
movl %ecx, %ebp
subl %eax, %ebp
movq %rcx, (%rbx)
movl %ebp, %edi
callq 0x1c1d4
jmp 0x2978d
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29a0e
movzbl 0x20(%rsp), %eax
movl %eax, (%rsp)
movzbl %r9b, %r9d
movq %rbx, %rdi
callq 0x188be
andq $0x0, 0x28(%rbx)
movq 0x4f0(%rbx), %r14
callq 0x1a004
cmpl $0x8, 0x2070(%rax)
jne 0x29a1d
pushq $0x1
popq %rax
jmp 0x29a36
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1841e
callq 0x1a004
xorl %ecx, %ecx
cmpl $0x10, 0x2070(%rax)
setne %cl
leaq 0x2(,%rcx,2), %rax
movl 0x18(%rbx), %ecx
movl 0x1c(%rbx), %edx
imulq %rax, %rcx
imulq %rcx, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4280
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19f72
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl %edi, %ebx
pushq $0x3
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
cmpq $0x0, 0x692fa(%rip)     # 0x92d70
jne 0x29a84
callq 0x29796
movq %rax, 0x692ec(%rip)     # 0x92d70
pushq $0x3
popq %rdi
xorl %esi, %esi
callq 0xa419
leaq 0x692db(%rip), %rsi     # 0x92d70
movl %ebx, %edi
popq %rbx
jmp 0x29753
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2a339
movq 0x65cb1(%rip), %rax     # 0x8ffb8
xorl %ebx, %ebx
cmpq %rdi, (%rax)
je 0x2a349
movq 0x65c83(%rip), %rax     # 0x8ff98
cmpq %rdi, (%rax)
je 0x2a349
callq 0x4530
testl %eax, %eax
je 0x2a349
movl %eax, %ebp
leaq 0x4ac50(%rip), %rdi     # 0x74f7c
movl %eax, %esi
xorl %eax, %eax
callq 0x97a7
movl %ebp, %ebx
jmp 0x2a349
leaq 0x4ac12(%rip), %rdi     # 0x74f52
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x97a7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x6
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
callq 0x2a538
xorl %r14d, %r14d
pushq $0x3
popq %rbp
pushq $0x30
popq %r15
pushq $0xa
popq %r12
leaq 0x68a16(%rip), %r13     # 0x92d98
cmpq $0x8, %r14
je 0x2a3be
callq 0x4100
cltd
idivl %ebp
movl %edx, %ebx
callq 0x4100
movl %r12d, %esi
movl %r15d, %ecx
testl %ebx, %ebx
je 0x2a3b0
pushq $0x1a
popq %rsi
cmpl $0x1, %ebx
jne 0x2a3ad
pushq $0x61
jmp 0x2a3af
pushq $0x41
popq %rcx
cltd
idivl %esi
addl %ecx, %edx
movb %dl, (%r14,%r13)
incq %r14
jmp 0x2a382
pushq $0x6
popq %rdi
xorl %esi, %esi
callq 0xa419
leaq 0x689c9(%rip), %rax     # 0x92d98
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x2cc86
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x2e
popq %rbp
movq %rdi, %r12
cmpq %rbx, %r12
jb 0x2cc5e
movq %r12, %rdi
movl %ebp, %esi
callq 0x41a0
movq %r12, %r15
incq %rax
movq %rax, %r12
jmp 0x2cc44
cmpq %rbx, %r15
je 0x2cc94
testq %r14, %r14
je 0x2ccb2
movl %ebx, %r12d
notl %r12d
addl %r15d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4410
movb $0x0, (%r14,%r12)
jmp 0x2ccb2
testq %r14, %r14
je 0x2cc8f
movb $0x0, (%r14)
xorl %r15d, %r15d
jmp 0x2ccb2
testq %r14, %r14
je 0x2cca4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44c0
movq %rbx, %rdi
callq 0x41e0
movq %rax, %r15
addq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::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 0x2ccfb
movq %rdi, %r14
callq 0x41e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x41e0
cmpl %eax, %r15d
cmovael %eax, %r15d
incl %r15d
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1b5ab
xorl %eax, %eax
negq %rbx
sbbl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ce83
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0d4
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 0x27942(%rip), %rax     # 0x547e8
leaq 0x28d15(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x481de(%rip), %r11     # 0x7509f
leaq 0x49003(%rip), %rsi     # 0x75ecb
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0x9d52
addq $0x20, %rsp
leaq 0x62d7b(%rip), %rsi     # 0x8fc60
movq 0x630ec(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a720
cmpl $0x1, 0x10(%rsp)
jne 0x2d71c
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x9352
movq %rax, %rbx
jmp 0x2d74f
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x8e5c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ad88
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6c96
leaq 0x10(%rsp), %rdi
callq 0x9394
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6c96
jmp 0x2d777
jmp 0x2d774
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9394
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<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 0x2d7a5
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0d4
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 0x27020(%rip), %rax     # 0x547e8
leaq 0x283f3(%rip), %r10     # 0x55bc2
cmpb $0x0, 0x10(%r14)
cmovneq %rax, %r10
subq $0x8, %rsp
leaq 0x478bc(%rip), %r11     # 0x7509f
leaq 0x48e8d(%rip), %rsi     # 0x76677
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq 0x18(%r14)
callq 0x9d52
addq $0x20, %rsp
leaq 0x62459(%rip), %rsi     # 0x8fc60
movq 0x627ca(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x3f03a
cmpl $0x1, 0x10(%rsp)
jne 0x2d87c
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x9352
movq %rax, %rbx
jmp 0x2d8af
movsbl %bpl, %edx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x8e5c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ad88
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6c96
leaq 0x10(%rsp), %rdi
callq 0x9394
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6c96
jmp 0x2d8d7
jmp 0x2d8d4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9394
movq %rbx, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::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 0x2dcff
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x2dd1f
cmpb $0x2d, (%r14)
jne 0x2dcdd
movzbl 0x1(%r14), %eax
cmpl $0x2e, %eax
je 0x2dcce
testl %eax, %eax
jne 0x2dcdd
cmpb $0x72, (%r15)
jne 0x2dcea
movq 0x622dd(%rip), %rax     # 0x8ffb8
jmp 0x2dcf1
movq %r14, %rdi
movq %r15, %rsi
callq 0x45b0
jmp 0x2dcf4
movq 0x622a7(%rip), %rax     # 0x8ff98
movq (%rax), %rax
testq %rax, %rax
je 0x2dd49
popq %rbx
popq %r14
popq %r15
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x49363(%rip), %rsi     # 0x77076
movq %rax, %rdi
xorl %eax, %eax
callq 0x9d52
jmp 0x2dd40
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x49371(%rip), %rsi     # 0x770a4
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9d52
leaq 0x61f19(%rip), %rsi     # 0x8fc60
jmp 0x2dd74
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %rbx
leaq 0x4937b(%rip), %rsi     # 0x770d8
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2a3de
leaq 0x61f8c(%rip), %rsi     # 0x8fd00
movq 0x6225d(%rip), %rdx     # 0x8ffd8
movq %rbx, %rdi
callq 0x4910
jmp 0x2dd87
jmp 0x2dd87
movq %rax, %r14
movq %rbx, %rdi
callq 0x4390
movq %r14, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::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
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
testl %ebp, %ebp
je 0x2e3c6
movq 0x64afc(%rip), %rdi     # 0x92eb0
testq %rdi, %rdi
je 0x2e3be
callq 0x4670
andq $0x0, 0x64aea(%rip)     # 0x92eb0
movq 0x64ae3(%rip), %r14     # 0x92eb0
testq %rbx, %rbx
je 0x2e40c
testq %r14, %r14
jne 0x2e3eb
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %r14
movq %rax, 0x64ac5(%rip)     # 0x92eb0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x4280
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4240
jmp 0x2e471
testq %r14, %r14
jne 0x2e471
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %rbx
movq %rax, 0x64a8b(%rip)     # 0x92eb0
leaq 0x7(%rax), %rdi
movl $0x3f9, %edx            # imm = 0x3F9
xorl %esi, %esi
callq 0x4280
movl $0x75632f2e, (%rbx)     # imm = 0x75632F2E
movl $0x6c7275, 0x3(%rbx)    # imm = 0x6C7275
leaq 0x3234a(%rip), %rsi     # 0x60793
movq %rbx, %rdi
callq 0x45b0
testq %rax, %rax
je 0x2e460
movq %rax, %rdi
callq 0x2a2f8
jmp 0x2e471
movq 0x64a49(%rip), %rax     # 0x92eb0
movb $0x0, 0x4(%rax)
movl $0x6c727563, (%rax)     # imm = 0x6C727563
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0xa419
movq 0x64a2e(%rip), %rax     # 0x92eb0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::system(char const*, char const*)
inline int system(const char *const command, const char *const module_name=0) {
      cimg::unused(module_name);
#ifdef cimg_no_system_calls
      return -1;
#else
#if cimg_OS==1
      const unsigned int l = std::strlen(command);
      if (l) {
        char *const ncommand = new char[l+16];
        std::strncpy(ncommand,command,l);
        std::strcpy(ncommand+l," 2> /dev/null"); // Make command silent.
        const int out_val = std::system(ncommand);
        delete[] ncommand;
        return out_val;
      } else return -1;
#elif cimg_OS==2
      PROCESS_INFORMATION pi;
      STARTUPINFO si;
      std::memset(&pi,0,sizeof(PROCESS_INFORMATION));
      std::memset(&si,0,sizeof(STARTUPINFO));
      GetStartupInfo(&si);
      si.cb = sizeof(si);
      si.wShowWindow = SW_HIDE;
      si.dwFlags |= SW_HIDE | STARTF_USESHOWWINDOW;
      const BOOL res = CreateProcess((LPCTSTR)module_name,(LPTSTR)command,0,0,FALSE,0,0,0,&si,&pi);
      if (res) {
        WaitForSingleObject(pi.hProcess, INFINITE);
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
        return 0;
      } else return std::system(command);
#endif
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x41e0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
andq %rax, %rbx
je 0x2e4ed
addl $0x10, %eax
movq %rax, %rdi
callq 0x4040
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4240
movabsq $0x7665642f203e3220, %rax # imm = 0x7665642F203E3220
movq %rax, (%r15,%rbx)
movabsq $0x6c6c756e2f7665, %rax # imm = 0x6C6C756E2F7665
movq %rax, 0x6(%r15,%rbx)
movq %r15, %rdi
callq 0x4460
movl %eax, %ebx
movq %r15, %rdi
callq 0x4670
movl %ebx, %eax
jmp 0x2e4f0
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::wget_path(char const*, bool)
inline const char *wget_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,".\\wget.exe");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"wget.exe");
#else
        if (!path_found) {
          std::strcpy(s_path,"./wget");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"wget");
#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
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
testl %ebp, %ebp
je 0x2e527
movq 0x649a3(%rip), %rdi     # 0x92eb8
testq %rdi, %rdi
je 0x2e51f
callq 0x4670
andq $0x0, 0x64991(%rip)     # 0x92eb8
movq 0x6498a(%rip), %r14     # 0x92eb8
testq %rbx, %rbx
je 0x2e56d
testq %r14, %r14
jne 0x2e54c
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %r14
movq %rax, 0x6496c(%rip)     # 0x92eb8
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x4280
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4240
jmp 0x2e5d2
testq %r14, %r14
jne 0x2e5d2
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %rbx
movq %rax, 0x64932(%rip)     # 0x92eb8
leaq 0x7(%rax), %rdi
movl $0x3f9, %edx            # imm = 0x3F9
xorl %esi, %esi
callq 0x4280
movl $0x67772f2e, (%rbx)     # imm = 0x67772F2E
movl $0x746567, 0x3(%rbx)    # imm = 0x746567
leaq 0x321e9(%rip), %rsi     # 0x60793
movq %rbx, %rdi
callq 0x45b0
testq %rax, %rax
je 0x2e5c1
movq %rax, %rdi
callq 0x2a2f8
jmp 0x2e5d2
movq 0x648f0(%rip), %rax     # 0x92eb8
movb $0x0, 0x4(%rax)
movl $0x74656777, (%rax)     # imm = 0x74656777
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0xa419
movq 0x648d5(%rip), %rax     # 0x92eb8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::gunzip_path(char const*, bool)
inline const char *gunzip_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,".\\gunzip.exe");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"gunzip.exe");
#else
        if (!path_found) {
          std::strcpy(s_path,"./gunzip");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"gunzip");
#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
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
testl %ebp, %ebp
je 0x2e619
movq 0x648b9(%rip), %rdi     # 0x92ec0
testq %rdi, %rdi
je 0x2e611
callq 0x4670
andq $0x0, 0x648a7(%rip)     # 0x92ec0
movq 0x648a0(%rip), %r14     # 0x92ec0
testq %rbx, %rbx
je 0x2e65f
testq %r14, %r14
jne 0x2e63e
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %r14
movq %rax, 0x64882(%rip)     # 0x92ec0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x4280
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4240
jmp 0x2e6cb
testq %r14, %r14
jne 0x2e6cb
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %rbx
movq %rax, 0x64848(%rip)     # 0x92ec0
leaq 0x9(%rax), %rdi
movl $0x3f7, %edx            # imm = 0x3F7
xorl %esi, %esi
callq 0x4280
movabsq $0x70697a6e75672f2e, %rax # imm = 0x70697A6E75672F2E
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
leaq 0x320f3(%rip), %rsi     # 0x60793
movq %rbx, %rdi
callq 0x45b0
testq %rax, %rax
je 0x2e6b7
movq %rax, %rdi
callq 0x2a2f8
jmp 0x2e6cb
movq 0x64802(%rip), %rax     # 0x92ec0
movl $0x70697a, 0x3(%rax)    # imm = 0x70697A
movl $0x7a6e7567, (%rax)     # imm = 0x7A6E7567
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0xa419
movq 0x647e4(%rip), %rax     # 0x92ec0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: int cimg_library::cimg::fread<unsigned char>(unsigned char*, unsigned long, _IO_FILE*)
inline int fread(T *const ptr, const unsigned long nmemb, std::FILE *stream) {
      if (!ptr || nmemb<=0 || !stream)
        throw CImgArgumentException("cimg::fread(): Invalid reading request of %u %s%s from file %p to buffer %p.",
                                    nmemb,cimg::type<T>::string(),nmemb>1?"s":"",stream,ptr);

      const unsigned long wlimitT = 63*1024*1024, wlimit = wlimitT/sizeof(T);
      unsigned long to_read = nmemb, al_read = 0, l_to_read = 0, l_al_read = 0;
      do {
        l_to_read = (to_read*sizeof(T))<wlimitT?to_read:wlimit;
        l_al_read = (unsigned long)std::fread((void*)(ptr+al_read),sizeof(T),l_to_read,stream);
        al_read+=l_al_read;
        to_read-=l_al_read;
      } while (l_to_read==l_al_read && to_read>0);
      if (to_read>0)
        warn("cimg::fread(): Only %u/%u elements could be read from file.",
             al_read,nmemb);
      return al_read;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x36104
testq %rbx, %rbx
je 0x36104
testq %r14, %r14
je 0x36104
xorl %r12d, %r12d
pushq $0x1
popq %r13
movq %rbx, 0x10(%rsp)
movl $0x3f00000, %eax        # imm = 0x3F00000
cmpq %rax, %rbx
movl $0x3f00000, %ebp        # imm = 0x3F00000
cmovbq %rbx, %rbp
leaq (%r15,%r12), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x47d0
addq %rax, %r12
subq %rax, %rbx
cmpq %rax, %rbp
jne 0x360d7
testq %rbx, %rbx
jne 0x360a4
testq %rbx, %rbx
je 0x360f2
leaq 0x3f72d(%rip), %rdi     # 0x75810
movq %r12, %rsi
movq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x97a7
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r12
cmpq $0x2, %rbx
leaq 0x4076c(%rip), %rax     # 0x76888
leaq 0x1e6c5(%rip), %r8      # 0x547e8
cmovaeq %rax, %r8
movq %r15, (%rsp)
leaq 0x3f691(%rip), %rsi     # 0x757c3
leaq 0x2a64e(%rip), %rcx     # 0x60787
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %r9
xorl %eax, %eax
callq 0x9d52
leaq 0x59b10(%rip), %rsi     # 0x8fc60
movq 0x59e81(%rip), %rdx     # 0x8ffd8
movq %r12, %rdi
callq 0x4910
movq %rax, %rbx
movq %r12, %rdi
callq 0x4390
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::dcraw_path(char const*, bool)
inline const char *dcraw_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,".\\dcraw.exe");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"dcraw.exe");
#else
        if (!path_found) {
          std::strcpy(s_path,"./dcraw");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"dcraw");
#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
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
testl %ebp, %ebp
je 0x38d36
movq 0x5a1a4(%rip), %rdi     # 0x92ec8
testq %rdi, %rdi
je 0x38d2e
callq 0x4670
andq $0x0, 0x5a192(%rip)     # 0x92ec8
movq 0x5a18b(%rip), %r14     # 0x92ec8
testq %rbx, %rbx
je 0x38d7c
testq %r14, %r14
jne 0x38d5b
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %r14
movq %rax, 0x5a16d(%rip)     # 0x92ec8
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x4280
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4240
jmp 0x38de3
testq %r14, %r14
jne 0x38de3
movl $0x400, %edi            # imm = 0x400
callq 0x4040
movq %rax, %rbx
movq %rax, 0x5a133(%rip)     # 0x92ec8
leaq 0x8(%rax), %rdi
movl $0x3f8, %edx            # imm = 0x3F8
xorl %esi, %esi
callq 0x4280
movabsq $0x77617263642f2e, %rax # imm = 0x77617263642F2E
movq %rax, (%rbx)
leaq 0x279da(%rip), %rsi     # 0x60793
movq %rbx, %rdi
callq 0x45b0
testq %rax, %rax
je 0x38dd0
movq %rax, %rdi
callq 0x2a2f8
jmp 0x38de3
movq 0x5a0f1(%rip), %rax     # 0x92ec8
movw $0x77, 0x4(%rax)
movl $0x61726364, (%rax)     # imm = 0x61726364
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0xa419
movq 0x5a0d4(%rip), %rax     # 0x92ec8
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImgList<double>::load_gif_external(char const*)
CImgList<T>& load_gif_external(const char *const filename) {
      if (!filename)
        throw CImgArgumentException(_cimglist_instance
                                    "load_gif_external(): Specified filename is (null).",
                                    cimglist_instance);
      std::fclose(cimg::fopen(filename,"rb"));            // Check if file exists.
      if (!_load_gif_external(filename,false))
        if (!_load_gif_external(filename,true))
          try { assign(CImg<T>().load_other(filename)); } catch (CImgException&) { assign(); }
      if (is_empty())
        throw CImgIOException(_cimglist_instance
                              "load_gif_external(): Failed to open file '%s'.",
                              cimglist_instance,filename);
      return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x392d2
movq %rsi, %r14
leaq 0x3bff0(%rip), %rsi     # 0x7523b
movq %r14, %rdi
callq 0x2dca5
movq %rax, %rdi
callq 0x4530
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x393aa
cmpq $0x0, 0x8(%rax)
jne 0x392b7
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x393aa
cmpq $0x0, 0x8(%rax)
jne 0x392b7
leaq 0x10(%rsp), %rdi
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x2e0d4
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x39744
leaq 0x10(%rsp), %rdi
callq 0x6c96
cmpq $0x0, 0x8(%rbx)
je 0x39316
cmpl $0x0, (%rbx)
je 0x39316
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r14
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movq 0x8(%rbx), %r8
leaq 0x3cd5f(%rip), %rsi     # 0x7604e
leaq 0x3bda9(%rip), %r9      # 0x7509f
movq %rax, %rdi
xorl %eax, %eax
callq 0x9d52
leaq 0x56959(%rip), %rsi     # 0x8fc60
movq 0x56cca(%rip), %rdx     # 0x8ffd8
movq %r14, %rdi
callq 0x4910
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, %r12
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movq 0x8(%rbx), %r8
movq %r14, (%rsp)
leaq 0x3cd6d(%rip), %rsi     # 0x760a4
leaq 0x3bd61(%rip), %r9      # 0x7509f
movq %rax, %rdi
xorl %eax, %eax
callq 0x2a3de
leaq 0x569b1(%rip), %rsi     # 0x8fd00
movq 0x56c82(%rip), %rdx     # 0x8ffd8
movq %r12, %rdi
callq 0x4910
movq %rdx, %r12
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x6c96
cmpl $0x1, %r12d
jne 0x393a1
movq %r15, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x2a65a
callq 0x48d0
jmp 0x392b7
movq %rax, %r15
movq %r12, %rdi
jmp 0x3939c
movq %rax, %r15
movq %r14, %rdi
callq 0x4390
movq %r15, %rdi
callq 0x4950
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: void cimg_library::cimg::invert_endianness<double>(double*, unsigned long)
inline void invert_endianness(T* const buffer, const unsigned long size) {
      if (size) switch (sizeof(T)) {
      case 1 : break;
      case 2 : { for (unsigned short *ptr = (unsigned short*)buffer+size; ptr>(unsigned short*)buffer; ) {
        const unsigned short val = *(--ptr);
        *ptr = (unsigned short)((val>>8)|((val<<8)));
      }
      } break;
      case 4 : { for (unsigned int *ptr = (unsigned int*)buffer+size; ptr>(unsigned int*)buffer; ) {
        const unsigned int val = *(--ptr);
        *ptr = (val>>24)|((val>>8)&0xff00)|((val<<8)&0xff0000)|(val<<24);
      }
      } break;
      default : { for (T* ptr = buffer+size; ptr>buffer; ) {
        unsigned char *pb = (unsigned char*)(--ptr), *pe = pb + sizeof(T);
        for (int i = 0; i<(int)sizeof(T)/2; ++i) swap(*(pb++),*(--pe));
      }
      }
      }
    }

// Assembly:
testq %rsi, %rsi
je 0x3a702
leaq (%rdi,%rsi,8), %rcx
pushq $-0x1
popq %rax
cmpq %rdi, %rcx
jbe 0x3a702
leaq -0x8(%rcx), %rdx
movq %rax, %rsi
movq %rdx, %r8
cmpl $-0x5, %esi
je 0x3a6fd
movb (%r8), %r9b
movb (%rcx,%rsi), %r10b
movb %r10b, (%r8)
incq %r8
movb %r9b, (%rcx,%rsi)
decq %rsi
jmp 0x3a6e2
movq %rdx, %rcx
jmp 0x3a6d3
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<float>::vector(float const&, float const&, float const&, float const&, float const&, float const&, float const&, float const&)
static CImg<T> vector(const T& a0, const T& a1, const T& a2, const T& a3,
                          const T& a4, const T& a5, const T& a6, const T& a7) {
      CImg<T> r(1,8); T *ptr = r._data;
      *(ptr++) = a0; *(ptr++) = a1; *(ptr++) = a2; *(ptr++) = a3;
      *(ptr++) = a4; *(ptr++) = a5; *(ptr++) = a6; *(ptr++) = a7;
      return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
pushq $0x8
popq %rdx
pushq $0x1
popq %rcx
movl %ecx, %esi
movl %ecx, %r8d
callq 0x17dbc
movq 0x18(%rbx), %rax
movss (%rbp), %xmm0
movss %xmm0, (%rax)
movss (%r13), %xmm0
movss %xmm0, 0x4(%rax)
movss (%r12), %xmm0
movss %xmm0, 0x8(%rax)
movss (%r15), %xmm0
movss %xmm0, 0xc(%rax)
movss (%r14), %xmm0
movss %xmm0, 0x10(%rax)
movq 0x40(%rsp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x14(%rax)
movq 0x48(%rsp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x18(%rax)
movq 0x50(%rsp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x1c(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./SiftHelpers.h
// Function: Image::getUniformDistribution(int)
static vector<vector<float>> getUniformDistribution(int k = 50)
	{
		default_random_engine gen;
		normal_distribution<float> x(0.0,1.0);
		
		vector<vector<float>> distributionLists;
		for(int i = 0;i<k;++i)
		{
			srand(time(NULL));
			vector<float> distribution;
			for(int j = 0;j<128;++j)
			{
				distribution.push_back(x(gen));
			}
			distributionLists.push_back(distribution);
		}
		
		
		return distributionLists;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x30(%rsp), %r14
movq $0x1, (%r14)
movsd 0x102da(%rip), %xmm0    # 0x541e0
leaq 0x38(%rsp), %r15
movsd %xmm0, (%r15)
andl $0x0, 0x8(%r15)
movb $0x0, 0xc(%r15)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
xorl %ebx, %ebx
testl %esi, %esi
cmovlel %ebx, %esi
movl %esi, 0x8(%rsp)
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
cmpl 0x8(%rsp), %ebx
je 0x43fa0
xorl %edi, %edi
callq 0x44b0
movl %eax, %edi
callq 0x4500
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movl $0x80, %ebp
subl $0x1, %ebp
jb 0x43f88
movq %r15, %rdi
movq %r14, %rsi
callq 0x44212
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x44246
jmp 0x43f65
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4421a
movq %r12, %rdi
callq 0x848c
incl %ebx
jmp 0x43f3e
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43fb5
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x848c
movq (%rsp), %rdi
callq 0x441f0
movq %r14, %rdi
callq 0x4950
nop