LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/superyuan[P]refeditor/MappingConvertor.cpp
// Function: mapExtendedChrome(GenomePosition&)
int mapExtendedChrome(GenomePosition &gp2)
{
    int target = gp2.pos+readLength/2; //the middle of the read, in case the read overlap with 2 mini chromosomes.
    if (chrMap[gp2.chrName] != NULL)
	{
		vector<posMap> *v = chrMap[gp2.chrName];
		int min=0;
		int max=v->size()-1;
		int middle = (min+max+1)/2;

		while(min != max) {
			if ((*v)[middle].from <= target) {
				min=middle;
			} else {
				max=middle-1;
			}
			middle = (min+max+1)/2;
		}
		int offset = 0;
		if ( (*v)[min].from <= target)
			offset = (*v)[min].from - (*v)[min].to;
		gp2.pos -= offset;
	}
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x5cc2(%rip), %eax      # 0x8534
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
addl 0x20(%rdi), %ebp
leaq 0x5cb3(%rip), %rdi      # 0x8538
movq %rbx, %rsi
callq 0x377a
cmpq $0x0, (%rax)
je 0x2903
leaq 0x5c9e(%rip), %rdi      # 0x8538
movq %rbx, %rsi
callq 0x377a
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
imull $0xaaaaaaab, %ecx, %esi # imm = 0xAAAAAAAB
xorl %ecx, %ecx
movl %esi, %edx
decl %edx
je 0x28ea
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
movslq %edi, %rsi
leaq (%rsi,%rsi,2), %rsi
cmpl %ebp, (%rax,%rsi,4)
jg 0x28da
movl %edi, %ecx
jmp 0x28de
decl %edi
movl %edi, %edx
leal (%rdx,%rcx), %esi
incl %esi
cmpl %edx, %ecx
jne 0x28c1
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rsi
movl (%rax,%rsi,4), %edx
xorl %ecx, %ecx
cmpl %ebp, %edx
jg 0x2900
leaq (%rax,%rsi,4), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
addl %ecx, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kuszmaul[P]6886/rdtsc.c
// Function: main
int main (int argc __attribute__((unused)), char *argv[] __attribute__((unused))) {
    struct timespec start, end;
    {
	int r = clock_gettime(CLOCK_MONOTONIC, &start);
	assert(r==0);
    }
    int N = 10000000;
    unsigned long long vv=0;
    for (int i=0; i<N; i++) {
	vv += rdtsc();
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    double tdiff = ((end.tv_sec-start.tv_sec)
		    + 1e-9*(end.tv_nsec-start.tv_nsec));
    printf("vv=%llu\n", vv);
    printf("Time %.6fs (%gns per call to clock_gettime(CLOCK_MONOTONIC,...)\n",
	   tdiff, 1e9*(tdiff/(double)N));
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
movl $0x1, %edi
callq 0x1030
testl %eax, %eax
jne 0x1215
movl $0x989680, %ecx         # imm = 0x989680
xorl %ebx, %ebx
rdtsc
movl %eax, %eax
addq %rbx, %rax
movl %edx, %ebx
shlq $0x20, %rbx
addq %rax, %rbx
decl %ecx
jne 0x1181
leaq 0x18(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x1030
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq 0x8(%rsp), %rax
cvtsi2sd %rax, %xmm0
subq 0x10(%rsp), %rcx
cvtsi2sd %rcx, %xmm1
mulsd 0xe3e(%rip), %xmm1      # 0x2008
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0xe6a(%rip), %rdi       # 0x2044
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movsd (%rsp), %xmm0
movapd %xmm0, %xmm1
divsd 0xe1b(%rip), %xmm1      # 0x2010
mulsd 0xe1b(%rip), %xmm1      # 0x2018
leaq 0xe49(%rip), %rdi       # 0x204d
movb $0x2, %al
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xe04(%rip), %rdi       # 0x2020
leaq 0xe02(%rip), %rsi       # 0x2025
leaq 0xe03(%rip), %rcx       # 0x202d
movl $0x12, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::Image(char*)
Image::Image(char *type)
{
  if(!strcmp(type, "bw")) 
  {
    imgtype = "bw";
    channels = 1;
    cols = 512; //default
    rows = 512; //default
    imgdata = new unsigned char [cols*rows*channels];
  }
  else
  {
    imgtype = "color";
    channels = 3;
    cols = 512; //default
    rows = 512; //default
    imgdata = new unsigned char [cols*rows*channels];
  }
  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd5dd(%rip), %r14      # 0x121e7
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2200
testl %eax, %eax
je 0x4c3f
leaq 0xca3c(%rip), %rax      # 0x1165c
movq %rax, (%rbx)
movl $0x3, 0x10(%rbx)
movabsq $0x20000000200, %rax    # imm = 0x20000000200
movq %rax, 0x8(%rbx)
movl $0xc0000, %edi          # imm = 0xC0000
jmp 0x4c5c
movq %r14, (%rbx)
movl $0x1, 0x10(%rbx)
movabsq $0x20000000200, %rax    # imm = 0x20000000200
movq %rax, 0x8(%rbx)
movl $0x40000, %edi          # imm = 0x40000
callq 0x2030
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::Image(char*, int, int)
Image::Image(char *type, int width, int height)
{
  if(!strcmp(type, "bw")) 
  {
    imgtype = "bw";
    channels = 1;
    cols = width; 
    rows = height;
    imgdata = new unsigned char [cols*rows*channels];
  }
  else
  {
    imgtype = "color";
    channels = 3;
    cols = width; 
    rows = height;
    imgdata = new unsigned char [cols*rows*channels];
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0xd563(%rip), %r15      # 0x121e7
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2200
movl %ebp, %ecx
imull %r14d, %ecx
testl %eax, %eax
je 0x4cb6
leaq 0xc9bc(%rip), %rax      # 0x1165c
movq %rax, (%rbx)
movl $0x3, 0x10(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
leal (%rcx,%rcx,2), %ecx
jmp 0x4cc7
movq %r15, (%rbx)
movl $0x1, 0x10(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movslq %ecx, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::read_image(char const*, int, int)
void Image::read_image(const char *filename, int width, int height)
{
  if (!strcmp(imgtype, "color"))
  {
    //cols = width;
    //rows = height;
    FILE *file;
    if (!(file=fopen(filename,"rb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }

    if (!(fread(imgdata, sizeof(int), cols*rows*channels, file)))
      std::cout << "Error Reading" << std::endl;

    fclose(file);
  }

  else if (!strcmp(imgtype, "bw"))
  {
    // cols = width;
    // rows = height;

    FILE *file;
    if (!(file=fopen(filename,"rb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fread(imgdata, sizeof(int), cols*rows*channels, file)))
      std::cout << "Error Reading" << std::endl;
    fclose(file);  
    
  }

  else
  {
    std::cout << "Filetype wasn't right!" << std::endl;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq 0xc969(%rip), %rsi      # 0x1165c
movq %r15, %rdi
callq 0x2200
testl %eax, %eax
je 0x4d59
leaq 0xd4e1(%rip), %rsi      # 0x121e7
movq %r15, %rdi
callq 0x2200
testl %eax, %eax
je 0x4d59
movq 0x112b7(%rip), %rbx     # 0x15fd0
leaq 0xc966(%rip), %rsi      # 0x11686
movl $0x16, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
leaq 0xc902(%rip), %rsi      # 0x11662
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
je 0x4de9
movq %rax, %r15
movq 0x18(%r14), %rdi
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
imulq %rax, %rcx
movslq 0x10(%r14), %rdx
imulq %rcx, %rdx
movl $0x4, %esi
movq %r15, %rcx
callq 0x2220
testq %rax, %rax
jne 0x4ddc
movq 0x1122f(%rip), %rbx     # 0x15fd0
leaq 0xc8d0(%rip), %rsi      # 0x11678
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2180
movq 0x111e0(%rip), %rdi     # 0x15fd0
leaq 0xc86e(%rip), %rsi      # 0x11665
callq 0x2170
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20a0
movl $0x1, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::write_image(char const*, int, int)
void Image::write_image(const char *filename, int width, int height)
{
  if (!strcmp(imgtype, "color"))
  {
    // cols = width;
    // rows = height;

    FILE *file;
    if (!(file=fopen(filename,"wb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fwrite(imgdata, sizeof(unsigned char), cols*rows*channels, file)))
       std::cout << "Error Writing" << std::endl;
    fclose(file);
   
  }

  else if (!strcmp(imgtype, "bw"))
  {
    // cols = width;
    // rows = height;

    FILE *file;

    if (!(file=fopen(filename,"wb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fwrite(imgdata, sizeof(unsigned char), cols*rows*channels, file)))
      std::cout << "Error Writing" << std::endl;
    fclose(file);  

  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
leaq 0xc82d(%rip), %rsi      # 0x1165c
movq %rbx, %rdi
callq 0x2200
testl %eax, %eax
je 0x4e54
leaq 0xd3a5(%rip), %rsi      # 0x121e7
movq %rbx, %rdi
callq 0x2200
testl %eax, %eax
je 0x4e54
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc842(%rip), %rsi      # 0x1169d
movq %r14, %rdi
callq 0x21c0
testq %rax, %rax
je 0x4ee4
movq %rax, %rbx
movq 0x18(%r15), %rdi
movslq 0x8(%r15), %rax
movslq 0xc(%r15), %rcx
imulq %rax, %rcx
movslq 0x10(%r15), %rdx
imulq %rcx, %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2300
testq %rax, %rax
jne 0x4ed7
movq 0x11134(%rip), %r14     # 0x15fd0
leaq 0xc7fd(%rip), %rsi      # 0x116a0
movl $0xd, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2180
movq 0x110e5(%rip), %rdi     # 0x15fd0
leaq 0xc773(%rip), %rsi      # 0x11665
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20a0
movl $0x1, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::operator=(Image)
void Image::operator=(Image img_copy)
{
  strcpy(imgtype, img_copy.imgtype);
  img_copy.rows = rows;
  img_copy.cols = cols;
  img_copy.channels = channels;
  for(int i = 0; i < rows; i++)
    for(int j = 0; j < cols; j++)
      for(int k = 0; k < channels; k++)
        img_copy.setvalue(i,j,k,getvalue(i,j,k));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2140
movl 0xc(%r14), %eax
movl %eax, 0xc(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
cmpl $0x0, 0xc(%r14)
jle 0x5039
xorl %eax, %eax
cmpl $0x0, 0x8(%r14)
jle 0x5031
xorl %ecx, %ecx
movl 0x10(%r14), %esi
testl %esi, %esi
jle 0x5029
xorl %edx, %edx
movl 0x8(%r14), %edi
imull %eax, %edi
addl %ecx, %edi
imull %esi, %edi
movslq %edi, %rsi
addq 0x18(%r14), %rsi
movl 0x8(%rbx), %edi
imull %eax, %edi
addl %ecx, %edi
imull 0x10(%rbx), %edi
movb (%rdx,%rsi), %sil
movslq %edi, %rdi
addq 0x18(%rbx), %rdi
movb %sil, (%rdx,%rdi)
movl 0x10(%r14), %esi
incq %rdx
cmpl %esi, %edx
jl 0x4ff0
incl %ecx
cmpl 0x8(%r14), %ecx
jl 0x4fe6
incl %eax
cmpl 0xc(%r14), %eax
jl 0x4fdd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Ycbcr2Rgb(double*, double*, double*, double, double, double)
void Ycbcr2Rgb(num *R, num *G, num *B, num Y, num Cr, num Cb)
{
	Y -= 16;
	Cb -= 128;
	Cr -= 128;
	*R = (num)(0.00456621004566210107*Y + 1.1808799897946415e-09*Cr + 0.00625892896994393634*Cb);
	*G = (num)(0.00456621004566210107*Y - 0.00153632368604490212*Cr - 0.00318811094965570701*Cb);
	*B = (num)(0.00456621004566210107*Y + 0.00791071623355474145*Cr + 1.1977497040190077e-08*Cb);
}

// Assembly:
addsd 0xbf00(%rip), %xmm0     # 0x110d0
movsd 0xbf00(%rip), %xmm3     # 0x110d8
addsd %xmm3, %xmm2
addsd %xmm3, %xmm1
movsd 0xbef8(%rip), %xmm3     # 0x110e0
mulsd 0xbef8(%rip), %xmm0     # 0x110e8
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0xbef0(%rip), %xmm4     # 0x110f0
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdi)
movsd 0xbee4(%rip), %xmm3     # 0x110f8
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0xbedc(%rip), %xmm4     # 0x11100
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
mulsd 0xbed0(%rip), %xmm1     # 0x11108
addsd %xmm0, %xmm1
mulsd 0xbecc(%rip), %xmm2     # 0x11110
addsd %xmm1, %xmm2
movsd %xmm2, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsv(double*, double*, double*, double, double, double)
void Rgb2Hsv(num *H, num *S, num *V, num R, num G, num B)
{
	num Max = MAX3(R, G, B);
	num Min = MIN3(R, G, B);
	num C = Max - Min;
	
	
	*V = Max;
	
	if(C > 0)
	{
		if(Max == R)
		{
			*H = (G - B) / C;
			
			if(G < B)
				*H += 6;
		}
		else if(Max == G)
			*H = 2 + (B - R) / C;
		else
			*H = 4 + (R - G) / C;
		
		*H *= 60;
		*S = C / Max;
	}
	else
		*H = *S = 0;
}

// Assembly:
movapd %xmm1, %xmm4
cmplesd %xmm0, %xmm4
movapd %xmm4, %xmm3
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm4
orpd %xmm3, %xmm4
movapd %xmm2, %xmm3
cmplesd %xmm4, %xmm3
movapd %xmm3, %xmm5
andpd %xmm4, %xmm5
andnpd %xmm2, %xmm3
orpd %xmm5, %xmm3
movapd %xmm0, %xmm4
cmplesd %xmm1, %xmm4
movapd %xmm4, %xmm5
andpd %xmm0, %xmm5
andnpd %xmm1, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm5
cmplesd %xmm2, %xmm5
movapd %xmm5, %xmm6
andpd %xmm4, %xmm6
andnpd %xmm2, %xmm5
orpd %xmm6, %xmm5
movapd %xmm3, %xmm4
subsd %xmm5, %xmm4
movlpd %xmm3, (%rdx)
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x56fb
ucomisd %xmm0, %xmm3
jne 0x5704
jp 0x5704
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, (%rdi)
ucomisd %xmm1, %xmm2
jbe 0x5736
addsd 0xbb67(%rip), %xmm0     # 0x11260
jmp 0x5732
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdi)
retq
ucomisd %xmm1, %xmm3
jne 0x5722
jp 0x5722
subsd %xmm0, %xmm2
divsd %xmm4, %xmm2
addsd 0xbb3c(%rip), %xmm2     # 0x11258
movapd %xmm2, %xmm0
jmp 0x5732
subsd %xmm1, %xmm0
divsd %xmm4, %xmm0
addsd 0xbb1e(%rip), %xmm0     # 0x11250
movsd %xmm0, (%rdi)
movsd (%rdi), %xmm0
mulsd 0xbb26(%rip), %xmm0     # 0x11268
movsd %xmm0, (%rdi)
divsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsv2Rgb(double*, double*, double*, double, double, double)
void Hsv2Rgb(num *R, num *G, num *B, num H, num S, num V)
{
	num C = S * V;
	num Min = V - C;
	num X;
	
	
	H -= 360*floor(H/360);
	H /= 60;
	X = C*(1 - fabs(H - 2*floor(H/2) - 1));
	
	switch((int)H)
	{
	case 0:
		*R = Min + C;
		*G = Min + X;
		*B = Min;
		break;
	case 1:
		*R = Min + X;
		*G = Min + C;
		*B = Min;
		break;
	case 2:
		*R = Min;
		*G = Min + C;
		*B = Min + X;
		break;
	case 3:
		*R = Min;
		*G = Min + X;
		*B = Min + C;
		break;
	case 4:
		*R = Min + X;
		*G = Min;
		*B = Min + C;
		break;
	case 5:
		*R = Min + C;
		*G = Min;
		*B = Min + X;
		break;
	default:
		*R = *G = *B = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xbaf6(%rip), %xmm0     # 0x11270
callq 0x2280
movapd %xmm0, %xmm1
mulsd 0xbaed(%rip), %xmm1     # 0x11278
addsd (%rsp), %xmm1
divsd 0xbad0(%rip), %xmm1     # 0x11268
movapd %xmm1, (%rsp)
movsd 0xb983(%rip), %xmm0     # 0x11128
mulsd %xmm1, %xmm0
callq 0x2280
movapd (%rsp), %xmm3
cvttsd2si %xmm3, %eax
cmpl $0x5, %eax
ja 0x5888
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm1
addsd %xmm0, %xmm0
subsd %xmm0, %xmm3
addsd 0xba9c(%rip), %xmm3     # 0x11280
andpd 0xbd64(%rip), %xmm3     # 0x11550
movsd 0xba94(%rip), %xmm0     # 0x11288
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
leaq 0xbdad(%rip), %rcx      # 0x115b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
addsd %xmm1, %xmm0
movsd %xmm0, (%r14)
jmp 0x586a
addsd %xmm1, %xmm0
movsd %xmm0, (%r15)
movsd %xmm1, (%r14)
jmp 0x584e
movsd %xmm1, (%r15)
addsd %xmm1, %xmm2
movsd %xmm2, (%r14)
jmp 0x587e
movsd %xmm1, (%r15)
addsd %xmm1, %xmm0
movsd %xmm0, (%r14)
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx)
jmp 0x5893
addsd %xmm1, %xmm0
movsd %xmm0, (%r15)
addsd %xmm1, %xmm2
movsd %xmm2, (%r14)
movsd %xmm1, (%rbx)
jmp 0x5893
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
movsd %xmm1, (%r14)
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5893
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movq %rax, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsl(double*, double*, double*, double, double, double)
void Rgb2Hsl(num *H, num *S, num *L, num R, num G, num B)
{
	num Max = MAX3(R, G, B);
	num Min = MIN3(R, G, B);
	num C = Max - Min;
	
	
	*L = (Max + Min)/2;
	
	if(C > 0)
	{
		if(Max == R)
		{
			*H = (G - B) / C;
			
			if(G < B)
				*H += 6;
		}
		else if(Max == G)
			*H = 2 + (B - R) / C;
		else
			*H = 4 + (R - G) / C;
		
		*H *= 60;
		*S = (*L <= 0.5) ? (C/(2*(*L))) : (C/(2 - 2*(*L)));
	}
	else
		*H = *S = 0;
}

// Assembly:
movapd %xmm1, %xmm3
cmplesd %xmm0, %xmm3
movapd %xmm3, %xmm4
andpd %xmm0, %xmm4
andnpd %xmm1, %xmm3
orpd %xmm4, %xmm3
movapd %xmm2, %xmm4
cmplesd %xmm3, %xmm4
movapd %xmm4, %xmm5
andpd %xmm3, %xmm5
andnpd %xmm2, %xmm4
orpd %xmm5, %xmm4
movapd %xmm0, %xmm3
cmplesd %xmm1, %xmm3
movapd %xmm3, %xmm5
andpd %xmm0, %xmm5
andnpd %xmm1, %xmm3
orpd %xmm5, %xmm3
movapd %xmm3, %xmm5
cmplesd %xmm2, %xmm5
movapd %xmm5, %xmm6
andpd %xmm3, %xmm6
andnpd %xmm2, %xmm5
orpd %xmm6, %xmm5
movapd %xmm4, %xmm3
subsd %xmm5, %xmm3
addsd %xmm4, %xmm5
mulsd 0xb813(%rip), %xmm5     # 0x11128
movsd %xmm5, (%rdx)
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm3
jbe 0x594b
ucomisd %xmm0, %xmm4
jne 0x5954
jp 0x5954
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm3, %xmm0
movsd %xmm0, (%rdi)
ucomisd %xmm1, %xmm2
jbe 0x5986
addsd 0xb917(%rip), %xmm0     # 0x11260
jmp 0x5982
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdi)
retq
ucomisd %xmm1, %xmm4
jne 0x5972
jp 0x5972
subsd %xmm0, %xmm2
divsd %xmm3, %xmm2
addsd 0xb8ec(%rip), %xmm2     # 0x11258
movapd %xmm2, %xmm0
jmp 0x5982
subsd %xmm1, %xmm0
divsd %xmm3, %xmm0
addsd 0xb8ce(%rip), %xmm0     # 0x11250
movsd %xmm0, (%rdi)
movsd (%rdi), %xmm0
mulsd 0xb8d6(%rip), %xmm0     # 0x11268
movsd %xmm0, (%rdi)
movsd (%rdx), %xmm0
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0xb8ae(%rip), %xmm2     # 0x11258
subsd %xmm1, %xmm2
cmpnlesd 0xb771(%rip), %xmm0     # 0x11128
movapd %xmm0, %xmm4
andnpd %xmm1, %xmm4
andpd %xmm2, %xmm0
orpd %xmm4, %xmm0
divsd %xmm0, %xmm3
movsd %xmm3, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsl2Rgb(double*, double*, double*, double, double, double)
void Hsl2Rgb(num *R, num *G, num *B, num H, num S, num L)
{
	num C = (L <= 0.5) ? (2*L*S) : ((2 - 2*L)*S);
	num Min = L - 0.5*C;
	num X;
	
	
	H -= 360*floor(H/360);
	H /= 60;
	X = C*(1 - fabs(H - 2*floor(H/2) - 1));
	
	switch((int)H)
	{
	case 0:
		*R = Min + C;
		*G = Min + X;
		*B = Min;
		break;
	case 1:
		*R = Min + X;
		*G = Min + C;
		*B = Min;
		break;
	case 2:
		*R = Min;
		*G = Min + C;
		*B = Min + X;
		break;
	case 3:
		*R = Min;
		*G = Min + X;
		*B = Min + C;
		break;
	case 4:
		*R = Min + X;
		*G = Min;
		*B = Min + C;
		break;
	case 5:
		*R = Min + C;
		*G = Min;
		*B = Min + X;
		break;
	default:
		*R = *G = *B = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xb875(%rip), %xmm0     # 0x11270
callq 0x2280
mulsd 0xb870(%rip), %xmm0     # 0x11278
addsd (%rsp), %xmm0
divsd 0xb853(%rip), %xmm0     # 0x11268
movapd %xmm0, (%rsp)
mulsd 0xb706(%rip), %xmm0     # 0x11128
callq 0x2280
movapd (%rsp), %xmm5
cvttsd2si %xmm5, %eax
cmpl $0x5, %eax
ja 0x5b36
movsd 0x18(%rsp), %xmm4
movapd %xmm4, %xmm2
addsd %xmm4, %xmm2
movsd 0xb809(%rip), %xmm3     # 0x11258
subsd %xmm2, %xmm3
movapd %xmm4, %xmm1
cmpnlesd 0xb6c8(%rip), %xmm1     # 0x11128
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0xb6c6(%rip), %xmm2     # 0x11140
mulsd %xmm1, %xmm2
addsd %xmm4, %xmm2
addsd %xmm0, %xmm0
subsd %xmm0, %xmm5
addsd 0xb7ee(%rip), %xmm5     # 0x11280
andpd 0xbab6(%rip), %xmm5     # 0x11550
movsd 0xb7e6(%rip), %xmm0     # 0x11288
subsd %xmm5, %xmm0
mulsd %xmm1, %xmm0
leaq 0xbb17(%rip), %rcx      # 0x115c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm2, %xmm1
movsd %xmm1, (%r15)
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
jmp 0x5b18
addsd %xmm2, %xmm0
movsd %xmm0, (%r15)
movsd %xmm2, (%r14)
jmp 0x5afc
movsd %xmm2, (%r15)
addsd %xmm2, %xmm1
movsd %xmm1, (%r14)
jmp 0x5b2c
movsd %xmm2, (%r15)
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
addsd %xmm2, %xmm1
movsd %xmm1, (%rbx)
jmp 0x5b41
addsd %xmm2, %xmm0
movsd %xmm0, (%r15)
addsd %xmm2, %xmm1
movsd %xmm1, (%r14)
movsd %xmm2, (%rbx)
jmp 0x5b41
addsd %xmm2, %xmm1
movsd %xmm1, (%r15)
movsd %xmm2, (%r14)
addsd %xmm2, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5b41
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movq %rax, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsi(double*, double*, double*, double, double, double)
void Rgb2Hsi(num *H, num *S, num *I, num R, num G, num B)
{
	num alpha = 0.5*(2*R - G - B);
	num beta = 0.866025403784439*(G - B);
	
	
	*I = (R + G + B)/3;
	
	if(*I > 0)
	{
		*S = 1 - MIN3(R,G,B) / *I;
		*H = atan2(beta, alpha)*(180/M_PI);
		
		if(*H < 0)
			*H += 360;
	}
	else
		*H = *S = 0;
}

// Assembly:
pushq %rbx
movapd %xmm0, %xmm3
movq %rdi, %rbx
movapd %xmm0, %xmm5
addsd %xmm1, %xmm5
addsd %xmm2, %xmm5
divsd 0xb729(%rip), %xmm5     # 0x11290
movsd %xmm5, (%rdx)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jbe 0x5c0c
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
mulsd 0xb70f(%rip), %xmm0     # 0x11298
movapd %xmm3, %xmm4
addsd %xmm3, %xmm4
subsd %xmm1, %xmm4
subsd %xmm2, %xmm4
mulsd 0xb587(%rip), %xmm4     # 0x11128
movapd %xmm3, %xmm6
cmplesd %xmm1, %xmm6
andpd %xmm6, %xmm3
andnpd %xmm1, %xmm6
orpd %xmm3, %xmm6
movapd %xmm6, %xmm1
cmplesd %xmm2, %xmm1
movapd %xmm1, %xmm3
andpd %xmm6, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
divsd %xmm5, %xmm1
movsd 0xb6ad(%rip), %xmm2     # 0x11288
subsd %xmm1, %xmm2
movsd %xmm2, (%rsi)
movapd %xmm4, %xmm1
callq 0x2060
mulsd 0xb6ac(%rip), %xmm0     # 0x112a0
movsd %xmm0, (%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5c17
addsd 0xb666(%rip), %xmm0     # 0x11270
jmp 0x5c13
movq $0x0, (%rsi)
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsi2Rgb(double*, double*, double*, double, double, double)
void Hsi2Rgb(num *R, num *G, num *B, num H, num S, num I)
{
	H -= 360*floor(H/360);
	
	if(H < 120)
	{
		*B = I*(1 - S);
		*R = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*G = 3*I - *R - *B;
	}
	else if(H < 240)
	{
		H -= 120;
		*R = I*(1 - S);
		*G = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*B = 3*I - *R - *G;
	}
	else
	{
		H -= 240;
		*G = I*(1 - S);
		*B = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*R = 3*I - *G - *B;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xb62b(%rip), %xmm0     # 0x11270
callq 0x2280
movapd %xmm0, %xmm1
mulsd 0xb622(%rip), %xmm1     # 0x11278
addsd 0x10(%rsp), %xmm1
movsd 0xb644(%rip), %xmm0     # 0x112a8
ucomisd %xmm1, %xmm0
jbe 0x5cff
movsd 0xb612(%rip), %xmm0     # 0x11288
subsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movapd %xmm1, %xmm0
mulsd 0xb62e(%rip), %xmm0     # 0x112c0
movsd %xmm1, 0x10(%rsp)
callq 0x22e0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb5b7(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb601(%rip), %xmm0     # 0x112c0
callq 0x22e0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb5b2(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15)
mulsd 0xb5a3(%rip), %xmm0     # 0x11290
subsd %xmm1, %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%r14)
jmp 0x5e2c
movsd 0xb5a9(%rip), %xmm0     # 0x112b0
ucomisd %xmm1, %xmm0
movsd 0xb575(%rip), %xmm0     # 0x11288
subsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
jbe 0x5dab
addsd 0xb59b(%rip), %xmm1     # 0x112c8
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%r15)
mulsd 0xb580(%rip), %xmm1     # 0x112c0
movapd %xmm1, %xmm0
callq 0x22e0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb50b(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb555(%rip), %xmm0     # 0x112c0
callq 0x22e0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb506(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%r14)
mulsd 0xb4f7(%rip), %xmm0     # 0x11290
subsd (%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5e2c
addsd 0xb505(%rip), %xmm1     # 0x112b8
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%r14)
mulsd 0xb4fa(%rip), %xmm1     # 0x112c0
movapd %xmm1, %xmm0
callq 0x22e0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb485(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb4cf(%rip), %xmm0     # 0x112c0
callq 0x22e0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb480(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
mulsd 0xb472(%rip), %xmm0     # 0x11290
subsd (%r14), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Xyz(double*, double*, double*, double, double, double)
void Rgb2Xyz(num *X, num *Y, num *Z, num R, num G, num B)
{
	R = INVGAMMACORRECTION(R);
	G = INVGAMMACORRECTION(G);
	B = INVGAMMACORRECTION(B);
	*X = (num)(0.4123955889674142161*R + 0.3575834307637148171*G + 0.1804926473817015735*B);
	*Y = (num)(0.2125862307855955516*R + 0.7151703037034108499*G + 0.07220049864333622685*B);
	*Z = (num)(0.01929721549174694484*R + 0.1191838645808485318*G + 0.9504971251315797660*B);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm1, %xmm4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xb47c(%rip), %xmm1     # 0x112d0
ucomisd %xmm0, %xmm1
movsd %xmm2, 0x10(%rsp)
jae 0x5e93
addsd 0xb478(%rip), %xmm0     # 0x112e0
divsd 0xb478(%rip), %xmm0     # 0x112e8
movsd 0xb478(%rip), %xmm1     # 0x112f0
movsd %xmm4, 0x8(%rsp)
callq 0x22a0
movsd 0xb445(%rip), %xmm1     # 0x112d0
movsd 0x8(%rsp), %xmm4
jmp 0x5e9b
divsd 0xb43d(%rip), %xmm0     # 0x112d8
movsd %xmm0, 0x18(%rsp)
ucomisd %xmm4, %xmm1
jae 0x5ed6
addsd 0xb431(%rip), %xmm4     # 0x112e0
divsd 0xb431(%rip), %xmm4     # 0x112e8
movsd 0xb431(%rip), %xmm1     # 0x112f0
movapd %xmm4, %xmm0
callq 0x22a0
movsd 0xb400(%rip), %xmm1     # 0x112d0
movapd %xmm0, %xmm4
jmp 0x5ede
divsd 0xb3fa(%rip), %xmm4     # 0x112d8
movsd 0x10(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jae 0x5f15
addsd 0xb3ee(%rip), %xmm0     # 0x112e0
divsd 0xb3ee(%rip), %xmm0     # 0x112e8
movsd 0xb3ee(%rip), %xmm1     # 0x112f0
movsd %xmm4, 0x8(%rsp)
callq 0x22a0
movsd 0x8(%rsp), %xmm4
jmp 0x5f1d
divsd 0xb3bb(%rip), %xmm0     # 0x112d8
movsd 0xb3d3(%rip), %xmm2     # 0x112f8
mulsd %xmm4, %xmm2
movsd 0xb3cf(%rip), %xmm1     # 0x11300
movsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0xb3c1(%rip), %xmm2     # 0x11308
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
movsd 0xb3b4(%rip), %xmm2     # 0x11310
mulsd %xmm4, %xmm2
movsd 0xb3b0(%rip), %xmm1     # 0x11318
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0xb3a8(%rip), %xmm2     # 0x11320
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
mulsd 0xb3a0(%rip), %xmm4     # 0x11328
movsd %xmm2, (%r14)
mulsd 0xb39b(%rip), %xmm3     # 0x11330
addsd %xmm4, %xmm3
mulsd 0xb397(%rip), %xmm0     # 0x11338
addsd %xmm3, %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Rgb(double*, double*, double*, double, double, double)
void Xyz2Rgb(num *R, num *G, num *B, num X, num Y, num Z)
{	
	num R1, B1, G1, Min;
	
	
	R1 = (num)( 3.2406*X - 1.5372*Y - 0.4986*Z);
	G1 = (num)(-0.9689*X + 1.8758*Y + 0.0415*Z);
	B1 = (num)( 0.0557*X - 0.2040*Y + 1.0570*Z);
	
	Min = MIN3(R1, G1, B1);
	
	/* Force nonnegative values so that gamma correction is well-defined. */
	if(Min < 0)
	{
		R1 -= Min;
		G1 -= Min;
		B1 -= Min;
	}

	/* Transform from RGB to R'G'B' */
	*R = GAMMACORRECTION(R1);
	*G = GAMMACORRECTION(G1);
	*B = GAMMACORRECTION(B1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xb36f(%rip), %xmm0     # 0x11340
mulsd %xmm1, %xmm0
movsd 0xb36b(%rip), %xmm4     # 0x11348
mulsd %xmm3, %xmm4
addsd %xmm0, %xmm4
movsd 0xb363(%rip), %xmm0     # 0x11350
mulsd %xmm2, %xmm0
addsd %xmm4, %xmm0
movsd 0xb35b(%rip), %xmm4     # 0x11358
mulsd %xmm1, %xmm4
movsd 0xb357(%rip), %xmm5     # 0x11360
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
movsd 0xb34f(%rip), %xmm6     # 0x11368
mulsd %xmm2, %xmm6
mulsd 0xb34b(%rip), %xmm1     # 0x11370
addsd %xmm5, %xmm6
mulsd 0xb347(%rip), %xmm3     # 0x11378
addsd %xmm1, %xmm3
mulsd 0xb343(%rip), %xmm2     # 0x11380
addsd %xmm3, %xmm2
movapd %xmm0, %xmm1
cmplesd %xmm6, %xmm1
movapd %xmm1, %xmm3
andpd %xmm0, %xmm3
andnpd %xmm6, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm3
cmplesd %xmm2, %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
andnpd %xmm2, %xmm3
orpd %xmm4, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm3, %xmm4
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
movapd %xmm3, %xmm5
cmpltsd %xmm4, %xmm5
andpd %xmm5, %xmm1
andnpd %xmm2, %xmm5
jbe 0x609e
subsd %xmm3, %xmm0
subsd %xmm3, %xmm6
orpd %xmm1, %xmm5
movsd 0xb2de(%rip), %xmm1     # 0x11388
ucomisd %xmm0, %xmm1
movapd %xmm5, (%rsp)
jae 0x60e8
movsd 0xb2d3(%rip), %xmm1     # 0x11390
movapd %xmm6, 0x10(%rsp)
callq 0x22a0
movsd 0xb2b8(%rip), %xmm1     # 0x11388
movapd 0x10(%rsp), %xmm6
mulsd 0xb20a(%rip), %xmm0     # 0x112e8
addsd 0xb2b2(%rip), %xmm0     # 0x11398
jmp 0x60f0
mulsd 0xb1e8(%rip), %xmm0     # 0x112d8
movsd %xmm0, (%r15)
ucomisd %xmm6, %xmm1
jae 0x612a
movsd 0xb28d(%rip), %xmm1     # 0x11390
movapd %xmm6, %xmm0
callq 0x22a0
movsd 0xb274(%rip), %xmm1     # 0x11388
movapd %xmm0, %xmm6
mulsd 0xb1c8(%rip), %xmm6     # 0x112e8
addsd 0xb270(%rip), %xmm6     # 0x11398
jmp 0x6132
mulsd 0xb1a6(%rip), %xmm6     # 0x112d8
movapd (%rsp), %xmm0
movsd %xmm6, (%r14)
ucomisd %xmm0, %xmm1
jae 0x6161
movsd 0xb246(%rip), %xmm1     # 0x11390
callq 0x22a0
mulsd 0xb191(%rip), %xmm0     # 0x112e8
addsd 0xb239(%rip), %xmm0     # 0x11398
jmp 0x6169
mulsd 0xb16f(%rip), %xmm0     # 0x112d8
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Lab(double*, double*, double*, double, double, double)
void Xyz2Lab(num *L, num *a, num *b, num X, num Y, num Z)
{
	X /= WHITEPOINT_X;
	Y /= WHITEPOINT_Y;
	Z /= WHITEPOINT_Z;
	X = LABF(X);
	Y = LABF(Y);
	Z = LABF(Z);
	*L = 116*Y - 16;
	*a = 500*(X - Y);
	*b = 200*(Y - Z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm2, %xmm3
movapd %xmm1, %xmm2
movq %rdx, %rbx
movq %rsi, %r14
divsd 0xb20a(%rip), %xmm0     # 0x113a0
movq %rdi, %r15
ucomisd 0xb20f(%rip), %xmm0     # 0x113b0
jae 0x61b5
mulsd 0xb215(%rip), %xmm0     # 0x113c0
addsd 0xb215(%rip), %xmm0     # 0x113c8
jmp 0x61da
movsd 0xb1fb(%rip), %xmm1     # 0x113b8
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x22a0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
divsd 0xb1c6(%rip), %xmm3     # 0x113a8
ucomisd 0xb1c6(%rip), %xmm2     # 0x113b0
movsd %xmm0, 0x18(%rsp)
jae 0x6204
mulsd 0xb1c6(%rip), %xmm2     # 0x113c0
addsd 0xb1c6(%rip), %xmm2     # 0x113c8
jmp 0x6225
movsd 0xb1ac(%rip), %xmm1     # 0x113b8
movapd %xmm2, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x22a0
movsd 0x8(%rsp), %xmm3
movapd %xmm0, %xmm2
ucomisd 0xb183(%rip), %xmm3     # 0x113b0
jae 0x6241
mulsd 0xb189(%rip), %xmm3     # 0x113c0
addsd 0xb189(%rip), %xmm3     # 0x113c8
jmp 0x6262
movsd 0xb16f(%rip), %xmm1     # 0x113b8
movapd %xmm3, %xmm0
movsd %xmm2, 0x10(%rsp)
callq 0x22a0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
movsd 0xb166(%rip), %xmm0     # 0x113d0
mulsd %xmm2, %xmm0
addsd 0xae5a(%rip), %xmm0     # 0x110d0
movsd %xmm0, (%r15)
movsd 0x18(%rsp), %xmm0
subsd %xmm2, %xmm0
mulsd 0xb14b(%rip), %xmm0     # 0x113d8
movsd %xmm0, (%r14)
subsd %xmm3, %xmm2
mulsd 0xb142(%rip), %xmm2     # 0x113e0
movsd %xmm2, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Lab2Rgb(double*, double*, double*, double, double, double)
void Lab2Xyz(num *X, num *Y, num *Z, num L, num a, num b)
{
	L = (L + 16)/116;
	a = L + a/500;
	b = L - b/200;
	*X = WHITEPOINT_X*LABINVF(a);
	*Y = WHITEPOINT_Y*LABINVF(L);
	*Z = WHITEPOINT_Z*LABINVF(b);
}

// Assembly:
addsd 0xa791(%rip), %xmm0     # 0x11098
divsd 0xaac1(%rip), %xmm0     # 0x113d0
divsd 0xaac1(%rip), %xmm1     # 0x113d8
addsd %xmm0, %xmm1
divsd 0xaac5(%rip), %xmm2     # 0x113e8
movapd %xmm1, %xmm7
mulsd %xmm1, %xmm7
mulsd %xmm1, %xmm7
movsd 0xaab9(%rip), %xmm5     # 0x113f0
movsd 0xaac1(%rip), %xmm3     # 0x11400
movapd %xmm3, %xmm4
cmpnlesd %xmm1, %xmm4
addsd %xmm5, %xmm1
movsd 0xaaa4(%rip), %xmm6     # 0x113f8
mulsd %xmm6, %xmm1
andpd %xmm4, %xmm1
andnpd %xmm7, %xmm4
orpd %xmm1, %xmm4
mulsd 0xaa34(%rip), %xmm4     # 0x113a0
addsd %xmm0, %xmm2
movapd %xmm0, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm0, %xmm7
movapd %xmm3, %xmm1
cmpnlesd %xmm0, %xmm1
addsd %xmm5, %xmm0
mulsd %xmm6, %xmm0
andpd %xmm1, %xmm0
andnpd %xmm7, %xmm1
orpd %xmm0, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm2, %xmm5
mulsd %xmm6, %xmm5
cmpnlesd %xmm2, %xmm3
andpd %xmm3, %xmm5
andnpd %xmm0, %xmm3
orpd %xmm5, %xmm3
mulsd 0xa9e2(%rip), %xmm3     # 0x113a8
movapd %xmm4, %xmm0
movapd %xmm3, %xmm2
jmp 0x5fb3
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Luv(double*, double*, double*, double, double, double)
void Xyz2Luv(num *L, num *u, num *v, num X, num Y, num Z)
{	
	num u1, v1, Denom;
	

	if((Denom = X + 15*Y + 3*Z) > 0)
	{
		u1 = (4*X) / Denom;
		v1 = (9*Y) / Denom;
	}
	else
		u1 = v1 = 0;

	Y /= WHITEPOINT_Y;
	Y = LABF(Y);
	*L = 116*Y - 16;
	*u = 13*(*L)*(u1 - WHITEPOINT_U);
	*v = 13*(*L)*(v1 - WHITEPOINT_V);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm1, %xmm3
movapd %xmm0, %xmm1
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0xb062(%rip), %xmm0     # 0x11408
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
mulsd 0xaeda(%rip), %xmm2     # 0x11290
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x63f2
mulsd 0xae84(%rip), %xmm1     # 0x11250
divsd %xmm2, %xmm1
movsd 0xb048(%rip), %xmm4     # 0x11420
mulsd %xmm3, %xmm4
divsd %xmm2, %xmm4
addsd 0xb030(%rip), %xmm1     # 0x11418
addsd 0xb020(%rip), %xmm4     # 0x11410
jmp 0x6402
movsd 0xb016(%rip), %xmm4     # 0x11410
movsd 0xb016(%rip), %xmm1     # 0x11418
ucomisd 0xafa6(%rip), %xmm3     # 0x113b0
jae 0x641e
mulsd 0xafac(%rip), %xmm3     # 0x113c0
addsd 0xafac(%rip), %xmm3     # 0x113c8
jmp 0x6449
movsd %xmm1, 0x8(%rsp)
movsd 0xaf8c(%rip), %xmm1     # 0x113b8
movapd %xmm3, %xmm0
movsd %xmm4, (%rsp)
callq 0x22a0
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm3
mulsd 0xaf7f(%rip), %xmm3     # 0x113d0
addsd 0xac77(%rip), %xmm3     # 0x110d0
movsd %xmm3, (%r14)
movsd 0xafc2(%rip), %xmm0     # 0x11428
mulsd %xmm0, %xmm3
mulsd %xmm3, %xmm1
movsd %xmm1, (%r15)
mulsd (%r14), %xmm0
mulsd %xmm0, %xmm4
movsd %xmm4, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Luv2Xyz(double*, double*, double*, double, double, double)
void Luv2Xyz(num *X, num *Y, num *Z, num L, num u, num v)
{
	*Y = (L + 16)/116;
	*Y = WHITEPOINT_Y*LABINVF(*Y);
	
	if(L != 0)
	{
		u /= L;
		v /= L;
	}
	
	u = u/13 + WHITEPOINT_U;
	v = v/13 + WHITEPOINT_V;
	*X = (*Y) * ((9*u)/(4*v));
	*Z = (*Y) * ((3 - 0.75*u)/v - 5);
}

// Assembly:
movsd 0xac06(%rip), %xmm4     # 0x11098
addsd %xmm0, %xmm4
divsd 0xaf32(%rip), %xmm4     # 0x113d0
movapd %xmm4, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm4, %xmm5
movsd 0xaf3e(%rip), %xmm6     # 0x113f0
addsd %xmm4, %xmm6
mulsd 0xaf3a(%rip), %xmm6     # 0x113f8
movsd 0xaf3a(%rip), %xmm3     # 0x11400
cmpnlesd %xmm4, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm5, %xmm4
andpd %xmm6, %xmm3
orpd %xmm4, %xmm3
movlpd %xmm3, (%rsi)
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
movapd %xmm1, %xmm4
divsd %xmm0, %xmm4
jne 0x64f7
jp 0x64f7
movapd %xmm1, %xmm4
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
jne 0x6507
jp 0x6507
movapd %xmm2, %xmm1
movsd 0xaf19(%rip), %xmm0     # 0x11428
divsd %xmm0, %xmm4
addsd 0xaf15(%rip), %xmm4     # 0x11430
divsd %xmm0, %xmm1
addsd 0xaf11(%rip), %xmm1     # 0x11438
movsd 0xaef1(%rip), %xmm0     # 0x11420
mulsd %xmm4, %xmm0
movsd 0xad15(%rip), %xmm2     # 0x11250
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
mulsd 0xaef5(%rip), %xmm4     # 0x11440
addsd 0xad3d(%rip), %xmm4     # 0x11290
mulsd %xmm0, %xmm3
divsd %xmm1, %xmm4
addsd 0xaee5(%rip), %xmm4     # 0x11448
movsd %xmm3, (%rdi)
mulsd (%rsi), %xmm4
movsd %xmm4, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Lch(double*, double*, double*, double, double, double)
void Xyz2Lch(num *L, num *C, num *H, num X, num Y, num Z)
{
	num a, b;
	
	
	Xyz2Lab(L, &a, &b, X, Y, Z);
	*C = sqrt(a*a + b*b);
	*H = atan2(b, a)*180.0/M_PI;
	
	if(*H < 0)
		*H += 360;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm1, %xmm3
movq %rdx, %rbx
movq %rsi, %r14
divsd 0xae15(%rip), %xmm0     # 0x113a0
movq %rdi, %r15
ucomisd 0xae1a(%rip), %xmm0     # 0x113b0
jae 0x65aa
mulsd 0xae20(%rip), %xmm0     # 0x113c0
addsd 0xae20(%rip), %xmm0     # 0x113c8
jmp 0x65cf
movsd 0xae06(%rip), %xmm1     # 0x113b8
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x22a0
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
divsd 0xadd1(%rip), %xmm2     # 0x113a8
ucomisd 0xadd1(%rip), %xmm3     # 0x113b0
movsd %xmm0, 0x10(%rsp)
jae 0x65f9
mulsd 0xadd1(%rip), %xmm3     # 0x113c0
addsd 0xadd1(%rip), %xmm3     # 0x113c8
jmp 0x661a
movsd 0xadb7(%rip), %xmm1     # 0x113b8
movapd %xmm3, %xmm0
movsd %xmm2, 0x18(%rsp)
callq 0x22a0
movsd 0x18(%rsp), %xmm2
movapd %xmm0, %xmm3
ucomisd 0xad8e(%rip), %xmm2     # 0x113b0
jae 0x6636
mulsd 0xad94(%rip), %xmm2     # 0x113c0
addsd 0xad94(%rip), %xmm2     # 0x113c8
jmp 0x6657
movsd 0xad7a(%rip), %xmm1     # 0x113b8
movapd %xmm2, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x22a0
movsd 0x8(%rsp), %xmm3
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0xad6b(%rip), %xmm0     # 0x113d0
mulsd %xmm3, %xmm0
addsd 0xaa5f(%rip), %xmm0     # 0x110d0
subsd %xmm3, %xmm1
mulsd 0xad5b(%rip), %xmm1     # 0x113d8
movsd %xmm0, (%r15)
subsd %xmm2, %xmm3
mulsd 0xad52(%rip), %xmm3     # 0x113e0
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x66b2
sqrtsd %xmm0, %xmm0
jmp 0x66cf
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x20f0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
movsd %xmm0, (%r14)
movapd %xmm3, %xmm0
callq 0x2060
mulsd 0xad6b(%rip), %xmm0     # 0x11450
divsd 0xad6b(%rip), %xmm0     # 0x11458
movsd 0xab7b(%rip), %xmm1     # 0x11270
addsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpltsd 0xad5a(%rip), %xmm2     # 0x11460
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movlpd %xmm2, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: ApplyColorTransform(colortransform, double*, double*, double*, double, double, double)
void ApplyColorTransform(colortransform Trans, 
	num *D0, num *D1, num *D2, num S0, num S1, num S2)
{
	switch(Trans.NumStages)
	{
	case 1:
		Trans.Fun[0](D0, D1, D2, S0, S1, S2);
		break;
	case 2:
		{
			num T0, T1, T2;
			Trans.Fun[0](&T0, &T1, &T2, S0, S1, S2);
			Trans.Fun[1](D0, D1, D2, T0, T1, T2);
		}
		break;
	default:
		*D0 = S0;
		*D1 = S1;
		*D2 = S2;
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movl (%r12), %eax
cmpl $0x2, %eax
je 0x72f6
cmpl $0x1, %eax
jne 0x7330
movq 0x8(%r12), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rsp, %rdi
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq *0x8(%r12)
movq %rsp, %rax
movsd (%rax), %xmm0
movsd (%r13), %xmm1
movsd (%rbp), %xmm2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r12)
jmp 0x733e
movsd %xmm0, (%r15)
movsd %xmm1, (%r14)
movsd %xmm2, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/ImageProc.h
// Function: ImageProc::color_to_bw(char const*, char const*, int, int)
void ImageProc::color_to_bw(const char *infile, const char *outfile, int width, int height)
{
	Image img_color("color", width, height);	//object for input color image
	Image img_bw("bw", width, height);			//object for output b-&-w image

	img_color.read_image(infile, img_color.cols, img_color.rows);	//reading input image from file

	for(int i = 0; i < img_bw.rows; i++)
		for(int j = 0; j < img_bw.cols; j++)
			for(int k = 0; k < img_bw.channels; k++)
				img_bw.setvalue(i,j,k,((img_color.getvalue(i,j,0)*0.21)\
									  +(img_color.getvalue(i,j,1)*0.72)\
									  +(img_color.getvalue(i,j,2)*0.07))); //using Luminosity formula: grayscale_value = 0.21*R + 0.72*G + 0.07*B

	img_bw.write_image(outfile, img_bw.cols, img_bw.rows);	//writing image to output file
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq 0xa2ec(%rip), %rsi      # 0x1165c
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x4c6e
leaq 0xae63(%rip), %rsi      # 0x121e7
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4c6e
movl 0x8(%r12), %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4cde
movslq 0xc(%r13), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jle 0x7486
movl 0x20(%rsp), %ecx
movl 0x28(%rsp), %edx
movq 0x50(%rsp), %rsi
movl 0x48(%rsp), %edi
movq 0x30(%rsp), %r8
movl %ecx, %r9d
imull %edx, %r9d
xorl %r10d, %r10d
movsd 0xa114(%rip), %xmm0     # 0x114f8
movsd 0xa114(%rip), %xmm1     # 0x11500
movsd 0xa114(%rip), %xmm2     # 0x11508
xorl %r11d, %r11d
testl %ecx, %ecx
jle 0x7475
movl 0x4(%rsp), %eax
movl %eax, %r14d
imull %r11d, %r14d
movl %r10d, %r15d
xorl %r12d, %r12d
testl %edx, %edx
jle 0x746a
movslq %r15d, %r13
addq %r8, %r13
leal (%r14,%r12), %ebx
imull %edi, %ebx
movslq %ebx, %rbx
xorl %ebp, %ebp
movzbl (%rsi,%rbx), %eax
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
movzbl 0x1(%rsi,%rbx), %eax
xorps %xmm4, %xmm4
cvtsi2sd %eax, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm4, %xmm3
movzbl 0x2(%rsi,%rbx), %eax
xorps %xmm4, %xmm4
cvtsi2sd %eax, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
cvttsd2si %xmm4, %eax
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %rdx
jne 0x7422
incq %r12
addl %edx, %r15d
cmpq %rcx, %r12
jne 0x740c
incq %r11
addl %r9d, %r10d
cmpq 0x10(%rsp), %r11
jne 0x73f7
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4e1a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/ImageProc.h
// Function: ImageProc::oil_painting(char const*, char const*, int, int, int)
void ImageProc::oil_painting(const char *infile, const char *outfile, int width, int height, int window_size)
{
	Image img_orig("color", width, height);
	Image img_oil("color", width, height);

	img_orig.read_image(infile, img_orig.cols, img_orig.rows);
	oil_paint_filter(img_orig, img_oil, window_size);

	img_oil.write_image(outfile, img_oil.cols, img_oil.rows);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
leaq 0x9aa0(%rip), %r13      # 0x1165c
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4c6e
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x4c6e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4cde
movq %rbx, %rdi
movq %rbp, %rsi
movl 0xc(%rsp), %edx
callq 0x7c18
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x4e1a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rishabh-battulwar[P]imageprocessing/./include/ImageProc.h
// Function: ImageProc::film_special_effect(char const*, char const*, int, int)
void ImageProc::film_special_effect(const char *infile, const char *outfile, int width, int height)
{
	Image img_orig("color", width, height);
	Image img_film("color", width, height);

	img_orig.read_image(infile, img_orig.cols, img_orig.rows);
	film_effect_filter(img_orig, img_film);

	img_film.write_image(outfile, img_film.cols, img_film.rows);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, (%rsp)
movq %rdi, %r15
leaq 0x96eb(%rip), %r12      # 0x1165c
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x4c6e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4c6e
movq %r13, %rdi
movq %r15, %rsi
callq 0x4cde
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7fc8
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4e1a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop