LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x7, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x1f(%rsp)
je 0x6625f
movq 0x9cc91(%rip), %rax     # 0x102ed0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x66254
movq 0x8(%rsp), %rdi
callq 0x5680
movq $0x0, 0x9cc71(%rip) # 0x102ed0
cmpq $0x0, 0x20(%rsp)
je 0x662b0
cmpq $0x0, 0x9cc61(%rip)     # 0x102ed0
jne 0x66282
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9cc4e(%rip)     # 0x102ed0
movq 0x9cc47(%rip), %rdi     # 0x102ed0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x9cc34(%rip), %rdi     # 0x102ed0
movq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x5270
jmp 0x66361
cmpq $0x0, 0x9cc18(%rip)     # 0x102ed0
jne 0x6635f
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9cc01(%rip)     # 0x102ed0
movq 0x9cbfa(%rip), %rdi     # 0x102ed0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movb $0x0, 0x1e(%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, 0x1e(%rsp)
jne 0x66339
movq 0x9cbd2(%rip), %rdi     # 0x102ed0
leaq 0x83061(%rip), %rsi     # 0xe9366
callq 0x54d0
movq 0x9cbbf(%rip), %rdi     # 0x102ed0
leaq 0x6e39a(%rip), %rsi     # 0xd46b2
callq 0x55c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x66337
movq 0x10(%rsp), %rdi
callq 0x5c6f0
movb $0x1, 0x1e(%rsp)
jmp 0x66339
testb $0x1, 0x1e(%rsp)
jne 0x66353
movq 0x9cb89(%rip), %rdi     # 0x102ed0
leaq 0x8301a(%rip), %rsi     # 0xe9368
callq 0x54d0
movq 0x9cb76(%rip), %rdi     # 0x102ed0
callq 0x5c780
jmp 0x66361
movl $0x7, %edi
xorl %esi, %esi
callq 0x12d30
movq 0x9cb5c(%rip), %rax     # 0x102ed0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
movb $0x0, %al
callq 0x66720
movq 0x28(%rsp), %rdi
callq 0x5210
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x66421
movl 0x1c(%rsp), %eax
addl $0x10, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5040
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x5270
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
addq %rax, %rdi
leaq 0x82f81(%rip), %rsi     # 0xe936d
callq 0x54d0
movq 0x10(%rsp), %rdi
callq 0x5470
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x66417
movq (%rsp), %rdi
callq 0x5680
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x66429
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x7, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x1f(%rsp)
je 0x6648f
movq 0x9ca69(%rip), %rax     # 0x102ed8
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x66484
movq 0x8(%rsp), %rdi
callq 0x5680
movq $0x0, 0x9ca49(%rip) # 0x102ed8
cmpq $0x0, 0x20(%rsp)
je 0x664e0
cmpq $0x0, 0x9ca39(%rip)     # 0x102ed8
jne 0x664b2
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9ca26(%rip)     # 0x102ed8
movq 0x9ca1f(%rip), %rdi     # 0x102ed8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x9ca0c(%rip), %rdi     # 0x102ed8
movq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x5270
jmp 0x66591
cmpq $0x0, 0x9c9f0(%rip)     # 0x102ed8
jne 0x6658f
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9c9d9(%rip)     # 0x102ed8
movq 0x9c9d2(%rip), %rdi     # 0x102ed8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movb $0x0, 0x1e(%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, 0x1e(%rsp)
jne 0x66569
movq 0x9c9aa(%rip), %rdi     # 0x102ed8
leaq 0x82e46(%rip), %rsi     # 0xe937b
callq 0x54d0
movq 0x9c997(%rip), %rdi     # 0x102ed8
leaq 0x6e16a(%rip), %rsi     # 0xd46b2
callq 0x55c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x66567
movq 0x10(%rsp), %rdi
callq 0x5c6f0
movb $0x1, 0x1e(%rsp)
jmp 0x66569
testb $0x1, 0x1e(%rsp)
jne 0x66583
movq 0x9c961(%rip), %rdi     # 0x102ed8
leaq 0x82dff(%rip), %rsi     # 0xe937d
callq 0x54d0
movq 0x9c94e(%rip), %rdi     # 0x102ed8
callq 0x5c780
jmp 0x66591
movl $0x7, %edi
xorl %esi, %esi
callq 0x12d30
movq 0x9c934(%rip), %rax     # 0x102ed8
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x7, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x1f(%rsp)
je 0x665ff
movq 0x9c901(%rip), %rax     # 0x102ee0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x665f4
movq 0x8(%rsp), %rdi
callq 0x5680
movq $0x0, 0x9c8e1(%rip) # 0x102ee0
cmpq $0x0, 0x20(%rsp)
je 0x66650
cmpq $0x0, 0x9c8d1(%rip)     # 0x102ee0
jne 0x66622
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9c8be(%rip)     # 0x102ee0
movq 0x9c8b7(%rip), %rdi     # 0x102ee0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x9c8a4(%rip), %rdi     # 0x102ee0
movq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x5270
jmp 0x66701
cmpq $0x0, 0x9c888(%rip)     # 0x102ee0
jne 0x666ff
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x9c871(%rip)     # 0x102ee0
movq 0x9c86a(%rip), %rdi     # 0x102ee0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movb $0x0, 0x1e(%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, 0x1e(%rsp)
jne 0x666d9
movq 0x9c842(%rip), %rdi     # 0x102ee0
leaq 0x82cdd(%rip), %rsi     # 0xe9382
callq 0x54d0
movq 0x9c82f(%rip), %rdi     # 0x102ee0
leaq 0x6dffa(%rip), %rsi     # 0xd46b2
callq 0x55c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x666d7
movq 0x10(%rsp), %rdi
callq 0x5c6f0
movb $0x1, 0x1e(%rsp)
jmp 0x666d9
testb $0x1, 0x1e(%rsp)
jne 0x666f3
movq 0x9c7f9(%rip), %rdi     # 0x102ee0
leaq 0x82c96(%rip), %rsi     # 0xe9384
callq 0x54d0
movq 0x9c7e6(%rip), %rdi     # 0x102ee0
callq 0x5c780
jmp 0x66701
movl $0x7, %edi
xorl %esi, %esi
callq 0x12d30
movq 0x9c7cc(%rip), %rax     # 0x102ee0
addq $0x28, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: void cimg_library::cimg::invert_endianness<unsigned short>(unsigned short*, 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x7952e
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x8(%rsp), %rax
jbe 0x7952c
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x2, %rcx
movq %rcx, -0x18(%rsp)
movw -0x2(%rax), %ax
movw %ax, -0x1a(%rsp)
movzwl -0x1a(%rsp), %eax
sarl $0x8, %eax
movzwl -0x1a(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
jmp 0x794e7
jmp 0x7952e
retq
nop
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x7, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x1f(%rsp)
je 0x7b7df
movq 0x87729(%rip), %rax     # 0x102ee8
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7b7d4
movq 0x8(%rsp), %rdi
callq 0x5680
movq $0x0, 0x87709(%rip) # 0x102ee8
cmpq $0x0, 0x20(%rsp)
je 0x7b830
cmpq $0x0, 0x876f9(%rip)     # 0x102ee8
jne 0x7b802
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x876e6(%rip)     # 0x102ee8
movq 0x876df(%rip), %rdi     # 0x102ee8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x876cc(%rip), %rdi     # 0x102ee8
movq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x5270
jmp 0x7b8e1
cmpq $0x0, 0x876b0(%rip)     # 0x102ee8
jne 0x7b8df
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x87699(%rip)     # 0x102ee8
movq 0x87692(%rip), %rdi     # 0x102ee8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movb $0x0, 0x1e(%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, 0x1e(%rsp)
jne 0x7b8b9
movq 0x8766a(%rip), %rdi     # 0x102ee8
leaq 0x6e6e6(%rip), %rsi     # 0xe9f6b
callq 0x54d0
movq 0x87657(%rip), %rdi     # 0x102ee8
leaq 0x58e1a(%rip), %rsi     # 0xd46b2
callq 0x55c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7b8b7
movq 0x10(%rsp), %rdi
callq 0x5c6f0
movb $0x1, 0x1e(%rsp)
jmp 0x7b8b9
testb $0x1, 0x1e(%rsp)
jne 0x7b8d3
movq 0x87621(%rip), %rdi     # 0x102ee8
leaq 0x6e69f(%rip), %rsi     # 0xe9f6d
callq 0x54d0
movq 0x8760e(%rip), %rdi     # 0x102ee8
callq 0x5c780
jmp 0x7b8e1
movl $0x7, %edi
xorl %esi, %esi
callq 0x12d30
movq 0x875f4(%rip), %rax     # 0x102ee8
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movl $0x1, %r8d
movl $0x8, %edx
movl %r8d, %esi
movl %r8d, %ecx
callq 0x31ac0
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x40(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x38(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x60(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x68(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movq 0x70(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x80c2d
movq 0x10(%rsp), %rdi
callq 0x31710
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x95f90
leaq 0x50(%rsp), %rdi
xorps %xmm0, %xmm0
movss 0x326fc(%rip), %xmm1    # 0xc8120
callq 0x95fb0
movq 0x10(%rsp), %rdi
movb $0x0, 0x4f(%rsp)
callq 0x96000
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x95b0c
xorl %eax, %eax
movl %eax, %edi
callq 0x54c0
movl %eax, %edi
callq 0x5500
leaq 0x30(%rsp), %rdi
callq 0x96010
movl $0x0, 0x2c(%rsp)
cmpl $0x80, 0x2c(%rsp)
jge 0x95ae1
leaq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x96050
movss %xmm0, 0x4(%rsp)
jmp 0x95a91
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x96020
jmp 0x95aae
jmp 0x95ab0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x95a70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf1f0
movq 0x10(%rsp), %rdi
callq 0x95f30
jmp 0x95b2c
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x96080
jmp 0x95af2
leaq 0x30(%rsp), %rdi
callq 0xf1f0
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x95a40
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x95b22
movq 0x10(%rsp), %rdi
callq 0x95f30
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::normalize(double, double)
CImg<T>& normalize(const T min_value, const T max_value) {
      if (is_empty()) return *this;
      const T a = min_value<max_value?min_value:max_value, b = min_value<max_value?max_value:min_value;
      T m, M = max_min(m);
      const Tfloat fm = (Tfloat)m, fM = (Tfloat)M;
      if (m==M) return fill(min_value);
      if (m!=a || M!=b)
#ifdef cimg_use_openmp
#pragma omp parallel for if (size()>=65536)
#endif
        cimg_rof(*this,ptrd,T) *ptrd = (T)((*ptrd-fm)/(fM-fm)*(b-a)+a);
      return *this;
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x10320
testb $0x1, %al
jne 0x9921a
jmp 0x99229
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x993b0
movsd 0x60(%rsp), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x99249
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x99255
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x60(%rsp), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x99281
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x9928d
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x993c0
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x40(%rsp), %xmm0
ucomisd 0x38(%rsp), %xmm0
jne 0x992f4
jp 0x992f4
movq 0x18(%rsp), %rdi
movsd 0x60(%rsp), %xmm0
callq 0x5dfa0
movq %rax, 0x70(%rsp)
jmp 0x993b0
movsd 0x40(%rsp), %xmm0
ucomisd 0x50(%rsp), %xmm0
jne 0x99319
jp 0x99319
movsd 0x38(%rsp), %xmm0
ucomisd 0x48(%rsp), %xmm0
jne 0x99319
jp 0x99319
jmp 0x993a6
movq 0x18(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, (%rsp)
callq 0x117b0
movq %rax, %rcx
movq (%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x18(%rcx), %rax
jb 0x993a4
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
subsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x48(%rsp), %xmm2
subsd 0x50(%rsp), %xmm2
movsd 0x50(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x99342
jmp 0x993a6
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: double& cimg_library::CImg<double>::max_min<double>(double&)
T& max_min(t& min_val) {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "max_min(): Empty instance.",
                                    cimg_instance);
      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, 0x50(%rsp)
callq 0x10320
testb $0x1, %al
jne 0x993f2
jmp 0x994d5
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 0x4f59b(%rip), %rcx     # 0xe89d2
leaq 0x306a3(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
callq 0x118f0
movq %rax, 0x48(%rsp)
jmp 0x99456
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 0x4f3ed(%rip), %rsi     # 0xe887e
xorl %eax, %eax
callq 0x11fd0
jmp 0x9949a
movq 0x20(%rsp), %rdi
leaq 0x666a2(%rip), %rsi     # 0xffb48
leaq -0x8729d(%rip), %rdx    # 0x12210
callq 0x5920
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x53a0
jmp 0x995c3
movq 0x50(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x68(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0x117b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0x995a1
movq 0x68(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
ucomisd 0x78(%rsp), %xmm0
jbe 0x99571
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x78(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x80(%rsp)
movsd 0x58(%rsp), %xmm1
movsd 0x70(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9958f
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x99591
movq 0x68(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x68(%rsp)
jmp 0x9952f
movsd 0x70(%rsp), %xmm0
movq 0x98(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x80(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x5970
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::number_filename(char const*, int, unsigned int, char*)
inline char* number_filename(const char *const filename, const int number,
                                 const unsigned int digits, char *const str) {
      if (!filename) { if (str) *str = 0; return 0; }
      char format[1024] = { 0 }, body[1024] = { 0 };
      const char *const ext = cimg::split_filename(filename,body);
      if (*ext) cimg_snprintf(format,sizeof(format),"%%s_%%.%ud.%%s",digits);
      else cimg_snprintf(format,sizeof(format),"%%s_%%.%ud",digits);
      std::sprintf(str,format,body,number,ext);
      return str;
    }

// Assembly:
subq $0x838, %rsp            # imm = 0x838
movq %rdi, 0x828(%rsp)
movl %esi, 0x824(%rsp)
movl %edx, 0x820(%rsp)
movq %rcx, 0x818(%rsp)
cmpq $0x0, 0x828(%rsp)
jne 0x99627
cmpq $0x0, 0x818(%rsp)
je 0x99616
movq 0x818(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x830(%rsp)
jmp 0x996eb
leaq 0x410(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x828(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x63280
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x99691
leaq 0x410(%rsp), %rdi
movl 0x820(%rsp), %ecx
movl $0x400, %esi            # imm = 0x400
leaq 0x51f8c(%rip), %rdx     # 0xeb614
movb $0x0, %al
callq 0x5890
jmp 0x996b3
leaq 0x410(%rsp), %rdi
movl 0x820(%rsp), %ecx
movl $0x400, %esi            # imm = 0x400
leaq 0x51f77(%rip), %rdx     # 0xeb623
movb $0x0, %al
callq 0x5890
movq 0x818(%rsp), %rdi
leaq 0x410(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl 0x824(%rsp), %ecx
movq 0x8(%rsp), %r8
movb $0x0, %al
callq 0x50a0
movq 0x818(%rsp), %rax
movq %rax, 0x830(%rsp)
movq 0x830(%rsp), %rax
addq $0x838, %rsp            # imm = 0x838
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::save_tiff(char const*, unsigned int, float const*, char const*) const
const CImg<T>& save_tiff(const char *const filename, const unsigned int compression_type=0,
                             const float *const voxel_size=0, const char *const description=0) const {
      if (!filename)
        throw CImgArgumentException(_cimg_instance
                                    "save_tiff(): Specified filename is (null).",
                                    cimg_instance);
      if (is_empty()) { cimg::fempty(0,filename); return *this; }

#ifdef cimg_use_tiff
      TIFF *tif = TIFFOpen(filename,"w");
      if (tif) {
        cimg_forZ(*this,z) get_slice(z)._save_tiff(tif,z,compression_type,voxel_size,description);
        TIFFClose(tif);
      } else throw CImgIOException(_cimg_instance
                                   "save_tiff(): Failed to open file '%s' for writing.",
                                   cimg_instance,
                                   filename);
      return *this;
#else
      cimg::unused(compression_type,voxel_size,description);
      return save_other(filename);
#endif
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movl %edx, 0x7c(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x99c9b
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 0x4edcc(%rip), %rcx     # 0xe89d2
leaq 0x2fed4(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
callq 0x118f0
movq %rax, 0x48(%rsp)
jmp 0x99c25
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 0x527f2(%rip), %rsi     # 0xec452
xorl %eax, %eax
callq 0x12220
jmp 0x99c69
movq 0x20(%rsp), %rdi
leaq 0x65eeb(%rip), %rsi     # 0xffb60
leaq -0x8781c(%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 0x99d10
movq 0x50(%rsp), %rdi
callq 0x10320
testb $0x1, %al
jne 0x99cab
jmp 0x99ccb
movq 0x80(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x9c310
movq 0x50(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x99d00
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x7c(%rsp), %rdi
movb $0x0, %al
callq 0x5be30
movq 0x50(%rsp), %rdi
movq 0x80(%rsp), %rsi
movl $0x64, %edx
callq 0x9b6b0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5970
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::save_video(char const*, unsigned int, char const*, bool) const
const CImg<T>& save_video(const char *const filename, const unsigned int fps=25,
                              const char *codec=0, const bool keep_open=false) const {
      if (is_empty()) { CImgList<T>().save_video(filename,fps,codec,keep_open); return *this; }
      CImgList<T> list;
      get_split('z').move_to(list);
      list.save_video(filename,fps,codec,keep_open);
      return *this;
    }

// Assembly:
subq $0x88, %rsp
movb %r8b, %al
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movq %rcx, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10320
testb $0x1, %al
jne 0x9b578
jmp 0x9b5e4
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7c580
movq 0x8(%rsp), %rdi
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq 0x60(%rsp), %rcx
movzbl 0x5f(%rsp), %r8d
andl $0x1, %r8d
callq 0xb3b20
jmp 0x9b5ab
leaq 0x48(%rsp), %rdi
callq 0x10fb0
movq 0x10(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x9b695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x10fb0
jmp 0x9b6a5
leaq 0x28(%rsp), %rdi
callq 0x7c580
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x7a, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb0bd0
jmp 0x9b609
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xb3b90
jmp 0x9b61a
leaq 0x18(%rsp), %rdi
callq 0x10fb0
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq 0x60(%rsp), %rcx
movzbl 0x5f(%rsp), %r8d
andl $0x1, %r8d
leaq 0x28(%rsp), %rdi
callq 0xb3b20
jmp 0x9b648
movq 0x10(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x10fb0
jmp 0x9b695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x9b689
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x10fb0
leaq 0x28(%rsp), %rdi
callq 0x10fb0
jmp 0x9b6a5
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5970
nop
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::fempty(_IO_FILE*, char const*)
inline void fempty(std::FILE *const file, const char *const filename) {
      if (!file && !filename)
        throw CImgArgumentException("cimg::file_type(): Specified filename is (null).");
      std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");
      if (!file) cimg::fclose(nfile);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x9c385
cmpq $0x0, 0x28(%rsp)
jne 0x9c385
movl $0x4008, %edi           # imm = 0x4008
callq 0x5240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x4eceb(%rip), %rsi     # 0xeb035
xorl %eax, %eax
callq 0x12220
jmp 0x9c353
movq 0x8(%rsp), %rdi
leaq 0x63801(%rip), %rsi     # 0xffb60
leaq -0x89f06(%rip), %rdx    # 0x12460
callq 0x5920
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x53a0
jmp 0x9c3cd
cmpq $0x0, 0x30(%rsp)
je 0x9c398
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9c3ad
movq 0x28(%rsp), %rdi
leaq 0x4cb5c(%rip), %rsi     # 0xe8f00
callq 0x654a0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x9c3c8
movq 0x10(%rsp), %rdi
callq 0x5c6f0
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5970
nopw (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::max() const
const T& max() const {
      if (is_empty())
        throw CImgInstanceException(_cimg_instance
                                    "max(): Empty instance.",
                                    cimg_instance);
      const T *ptr_max = _data;
      T max_value = *ptr_max;
      cimg_for(*this,ptrs,T) if (*ptrs>max_value) max_value = *(ptr_max=ptrs);
      return *ptr_max;
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x10320
testb $0x1, %al
jne 0xa0cfa
jmp 0xa0ddd
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 0x47c93(%rip), %rcx     # 0xe89d2
leaq 0x28d9b(%rip), %rax     # 0xc9ae1
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x48(%rsp)
callq 0x118f0
movq %rax, 0x50(%rsp)
jmp 0xa0d5e
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 0x4b41a(%rip), %rsi     # 0xec1b3
xorl %eax, %eax
callq 0x11fd0
jmp 0xa0da2
movq 0x28(%rsp), %rdi
leaq 0x5ed9a(%rip), %rsi     # 0xffb48
leaq -0x8eba5(%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 0xa0e75
movq 0x58(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x68(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
callq 0x117b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0xa0e68
movq 0x68(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x70(%rsp), %xmm0
jbe 0xa0e56
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0xa0e58
movq 0x68(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x68(%rsp)
jmp 0xa0e25
movq 0x78(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::gzip_path(char const*, bool)
inline const char *gzip_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,".\\gzip.exe");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"gzip.exe");
#else
        if (!path_found) {
          std::strcpy(s_path,"./gzip");
          if ((file=std::fopen(s_path,"r"))!=0) { cimg::fclose(file); path_found = true; }
        }
        if (!path_found) std::strcpy(s_path,"gzip");
#endif
        winformat_string(s_path);
      }
      cimg::mutex(7,0);
      return s_path;
    }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x7, %edi
movl $0x1, %esi
callq 0x12d30
testb $0x1, 0x1f(%rsp)
je 0xb0aaf
movq 0x52469(%rip), %rax     # 0x102ef8
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xb0aa4
movq 0x8(%rsp), %rdi
callq 0x5680
movq $0x0, 0x52449(%rip) # 0x102ef8
cmpq $0x0, 0x20(%rsp)
je 0xb0b00
cmpq $0x0, 0x52439(%rip)     # 0x102ef8
jne 0xb0ad2
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x52426(%rip)     # 0x102ef8
movq 0x5241f(%rip), %rdi     # 0x102ef8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movq 0x5240c(%rip), %rdi     # 0x102ef8
movq 0x20(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x5270
jmp 0xb0bb1
cmpq $0x0, 0x523f0(%rip)     # 0x102ef8
jne 0xb0baf
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x523d9(%rip)     # 0x102ef8
movq 0x523d2(%rip), %rdi     # 0x102ef8
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x52a0
movb $0x0, 0x1e(%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, 0x1e(%rsp)
jne 0xb0b89
movq 0x523aa(%rip), %rdi     # 0x102ef8
leaq 0x3bfe4(%rip), %rsi     # 0xecb39
callq 0x54d0
movq 0x52397(%rip), %rdi     # 0x102ef8
leaq 0x23b4a(%rip), %rsi     # 0xd46b2
callq 0x55c0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xb0b87
movq 0x10(%rsp), %rdi
callq 0x5c6f0
movb $0x1, 0x1e(%rsp)
jmp 0xb0b89
testb $0x1, 0x1e(%rsp)
jne 0xb0ba3
movq 0x52361(%rip), %rdi     # 0x102ef8
leaq 0x3bf9d(%rip), %rsi     # 0xecb3b
callq 0x54d0
movq 0x5234e(%rip), %rdi     # 0x102ef8
callq 0x5c780
jmp 0xb0bb1
movl $0x7, %edi
xorl %esi, %esi
callq 0x12d30
movq 0x52334(%rip), %rax     # 0x102ef8
addq $0x28, %rsp
retq
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::transpose()
CImg<T>& transpose() {
      if (_width==1) { _width = _height; _height = 1; return *this; }
      if (_height==1) { _height = _width; _width = 1; return *this; }
      if (_width==_height) {
        cimg_forYZC(*this,y,z,c) for (int x = y; x<width(); ++x) cimg::swap((*this)(x,y,z,c),(*this)(y,x,z,c));
        return *this;
      }
      return get_transpose().move_to(*this);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x1, (%rax)
jne 0xba093
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movl $0x1, 0x4(%rax)
movq %rax, 0x70(%rsp)
jmp 0xba229
movq 0x20(%rsp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xba0b8
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, (%rax)
movq %rax, 0x70(%rsp)
jmp 0xba229
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0xba1d1
movl $0x0, 0x64(%rsp)
movq 0x20(%rsp), %rcx
movl 0x64(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0xba1c5
movl $0x0, 0x60(%rsp)
movq 0x20(%rsp), %rcx
movl 0x60(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0xba1b3
movl $0x0, 0x5c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x5c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0xba1a1
movl 0x5c(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x20(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x89c0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0xba18f
movq 0x20(%rsp), %rdi
movl 0x58(%rsp), %esi
movl 0x5c(%rsp), %edx
movl 0x60(%rsp), %ecx
movl 0x64(%rsp), %r8d
callq 0x9880
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
movl 0x60(%rsp), %ecx
movl 0x64(%rsp), %r8d
callq 0x9880
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xbaf90
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xba11e
jmp 0xba191
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xba104
jmp 0xba1a3
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0xba0ea
jmp 0xba1b5
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xba0d0
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xba229
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbbd00
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10f50
movq %rax, 0x8(%rsp)
jmp 0xba1f9
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xa540
jmp 0xba229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xa540
jmp 0xba233
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5970
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>& cimg_library::CImg<double>::sort<int>(cimg_library::CImg<int>&, bool)
CImg<T>& sort(CImg<t>& permutations, const bool is_increasing=true) {
      permutations.assign(_width,_height,_depth,_spectrum);
      if (is_empty()) return *this;
      cimg_foroff(permutations,off) permutations[off] = (t)off;
      return _quicksort(0,size()-1,permutations,is_increasing,true);
    }

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl (%rax), %esi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
callq 0x75740
movq 0x10(%rsp), %rdi
callq 0x10320
testb $0x1, %al
jne 0xbb1d6
jmp 0xbb1e5
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xbb26e
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x76780
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0xbb238
movq 0x20(%rsp), %rax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xbb2a0
movl 0xc(%rsp), %edx
movq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xbb1fd
movq 0x10(%rsp), %rdi
callq 0x117b0
movq 0x10(%rsp), %rdi
subq $0x1, %rax
movl %eax, %edx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %al
xorl %esi, %esi
movl $0x1, %r9d
andb $0x1, %al
movzbl %al, %r8d
callq 0xbb2b0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::get_diagonal() const
CImg<T> get_diagonal() const {
      if (is_empty()) return *this;
      CImg<T> res(size(),size(),1,1,0);
      cimg_foroff(*this,off) res(off,off) = (*this)(off);
      return res;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x10320
testb $0x1, %al
jne 0xbf5f0
jmp 0xbf604
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xadb0
jmp 0xbf6df
movq 0x28(%rsp), %rdi
movb $0x0, 0x57(%rsp)
callq 0x117b0
movq 0x28(%rsp), %rdi
movl %eax, 0x14(%rsp)
callq 0x117b0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
movl $0x1, %r8d
xorps %xmm0, %xmm0
movl %r8d, %ecx
callq 0x89f0
movq 0x28(%rsp), %rdi
movq $0x0, 0x48(%rsp)
callq 0x117b0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0xbf6c7
movq 0x28(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0xb2800
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl 0x48(%rsp), %edx
movl %edx, %esi
callq 0x9850
movq %rax, 0x8(%rsp)
jmp 0xbf68f
movq 0x8(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0xbf655
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xa540
jmp 0xbf6e9
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xbf6dd
movq 0x18(%rsp), %rdi
callq 0xa540
jmp 0xbf6df
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::get_pseudoinvert() const
CImg<Tfloat> get_pseudoinvert() const {
      CImg<Tfloat> U, S, V;
      SVD(U,S,V);
      const Tfloat tolerance = (sizeof(Tfloat)<=4?5.96e-8f:1.11e-16f)*cimg::max(_width,_height)*S.max();
      cimg_forX(V,x) {
        const Tfloat s = S(x), invs = s>tolerance?1/s:(Tfloat)0;
        cimg_forY(V,y) V(x,y)*=invs;
      }
      return V*U.transpose();
    }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xb6c0
leaq 0x98(%rsp), %rdi
callq 0xb6c0
jmp 0xbfb4d
leaq 0x68(%rsp), %rdi
callq 0xb6c0
jmp 0xbfb59
movq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movl $0x1, %r8d
movl $0x28, %r9d
xorps %xmm0, %xmm0
callq 0xb7140
jmp 0xbfb89
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
callq 0x15db0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss 0x85ff(%rip), %xmm1     # 0xc81a8
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xbfd80
movq %rax, 0x20(%rsp)
jmp 0xbfbcb
movq 0x20(%rsp), %rax
movsd 0x18(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0xbfcff
movl 0x5c(%rsp), %esi
leaq 0x98(%rsp), %rdi
callq 0x897e0
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
ucomisd 0x60(%rsp), %xmm0
jbe 0xbfc35
movsd 0x83f1(%rip), %xmm0     # 0xc8018
divsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xbfc40
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xbfc40
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0xbfced
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x5c(%rsp), %esi
movl 0x44(%rsp), %edx
leaq 0x68(%rsp), %rdi
callq 0x9850
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xbfc54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbfd65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xbfd58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xa540
jmp 0xbfd58
jmp 0xbfcef
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xbfbe8
leaq 0xb8(%rsp), %rdi
callq 0xba060
movq %rax, (%rsp)
jmp 0xbfd12
movq (%rsp), %rdx
movq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xba2b0
jmp 0xbfd27
leaq 0x68(%rsp), %rdi
callq 0xa540
leaq 0x98(%rsp), %rdi
callq 0xa540
leaq 0xb8(%rsp), %rdi
callq 0xa540
movq 0x30(%rsp), %rax
addq $0xe8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0xa540
leaq 0xb8(%rsp), %rdi
callq 0xa540
movq 0x90(%rsp), %rdi
callq 0x5970
nop