LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/Image3ChnlReal.cpp
// Function: Image3ChnlReal::Image3ChnlReal(Image3ChnlReal const&)
Image3ChnlReal::Image3ChnlReal(const Image3ChnlReal &ir)
{
	img_.push_back(new ImageReal());
	img_.push_back(new ImageReal());
	img_.push_back(new ImageReal());
	
	*this = ir;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa1dc
leaq 0x248a2(%rip), %rax     # 0x2fd18
movq %rax, (%rbx)
leaq 0x38(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
andq $0x0, 0x48(%rbx)
pushq $0x40
popq %rdi
callq 0x32d0
movq %rax, %r12
movq %rax, %rdi
callq 0xa588
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xc1e0
pushq $0x40
popq %rdi
callq 0x32d0
movq %rax, %r12
movq %rax, %rdi
callq 0xa588
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xc1e0
pushq $0x40
popq %rdi
callq 0x32d0
movq %rax, %r12
movq %rax, %rdi
callq 0xa588
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xc1e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb538
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb51d
jmp 0xb509
jmp 0xb509
movq %rax, %r15
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x32e0
jmp 0xb520
jmp 0xb51d
jmp 0xb51d
movq %rax, %r15
movq %r14, %rdi
callq 0xc1ac
movq %rbx, %rdi
callq 0xa2de
movq %r15, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/Image3ChnlReal.cpp
// Function: Image3ChnlReal::operator=(Image3ChnlReal const&)
const Image3ChnlReal& Image3ChnlReal::operator=(const Image3ChnlReal &ir)
{
	if (&ir == this)
		return *this;
	
	ImageInterface::operator=(ir);
	
	resize(ir.width_, ir.height_);
	*img_[0] = *ir.img_[0];
	*img_[1] = *ir.img_[1];
	*img_[2] = *ir.img_[2];
	
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xb59d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xa2f4
movl 0x28(%r14), %esi
movl 0x2c(%r14), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x38(%r14), %rax
movq (%rax), %rsi
movq 0x38(%rbx), %rax
movq (%rax), %rdi
callq 0xa5e6
movq 0x38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xa5e6
movq 0x38(%r14), %rax
movq 0x10(%rax), %rsi
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0xa5e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/Image3ChnlReal.cpp
// Function: Image3ChnlReal::~Image3ChnlReal()
Image3ChnlReal::~Image3ChnlReal()
{
	assert(img_.size() == 3);
	delete img_[0];
	delete img_[1];
	delete img_[2];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x24687(%rip), %rax     # 0x2fd18
movq %rax, (%rdi)
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0xb6f5
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb6bd
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xb6cf
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xb6de
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0xc1ac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa2de
leaq 0x17b65(%rip), %rdi     # 0x23261
leaq 0x17b6f(%rip), %rsi     # 0x23272
leaq 0x17b7b(%rip), %rcx     # 0x23285
pushq $0x2f
popq %rdx
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/Image3ChnlReal.cpp
// Function: Image3ChnlReal::operator==(Image3ChnlReal const&) const
bool Image3ChnlReal::operator==(const Image3ChnlReal &im) const
{
	if (&im == this)
		return true;
	
	if (!(ImageInterface::operator==(im)))
		return false;
	
	if (*img_[0] != *im.img_[0])
		return false;
	if (*img_[1] != *im.img_[1])
		return false;
	if (*img_[2] != *im.img_[2])
		return false;
	
	return true;
}

// Assembly:
cmpq %rdi, %rsi
je 0xb77a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa32c
testb %al, %al
je 0xb770
movq 0x38(%r14), %rax
movq (%rax), %rdi
movq 0x38(%rbx), %rax
movq (%rax), %rsi
callq 0xa724
testb %al, %al
jne 0xb770
movq 0x38(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0xa724
testb %al, %al
je 0xb77d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
retq
movq 0x38(%r14), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rsi
callq 0xa724
xorb $0x1, %al
jmp 0xb772
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/Image3ChnlReal.cpp
// Function: Image3ChnlReal::resize(int, int)
bool Image3ChnlReal::resize(int width, int height)
{
	if (!ImageInterface::resize(width, height))
	{
		erase();
		return false;
	}
	
	assert(img_.size() == 3);
	
	img_[0]->resize(width_, height_);
	img_[1]->resize(width_, height_);
	img_[2]->resize(width_, height_);
	
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xa56a
movl %eax, %ebx
testb %al, %al
je 0xb80c
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0xb81e
movq (%rax), %rdi
movl 0x28(%r14), %esi
movl 0x2c(%r14), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x38(%r14), %rax
movq 0x8(%rax), %rdi
movl 0x28(%r14), %esi
movl 0x2c(%r14), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x38(%r14), %rax
movq 0x10(%rax), %rdi
movl 0x28(%r14), %esi
movl 0x2c(%r14), %edx
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0xb814
movq %r14, %rdi
callq 0xb83c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x17a3c(%rip), %rdi     # 0x23261
leaq 0x17a46(%rip), %rsi     # 0x23272
leaq 0x17a7c(%rip), %rcx     # 0x232af
pushq $0x63
popq %rdx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: nn_deBayer(ImageReal&, Image3ChnlReal&)
void nn_deBayer(ImageReal &grayImage, Image3ChnlReal &rgbImage)
{
	int width = grayImage.width(), height = grayImage.height();
	for (int y = 0; y < height; y++)
		for (int x = 0; x < width; x++)
			nn_procOnePixel(grayImage, rgbImage, x, y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rdi), %r12d
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
movl 0x2c(%rdi), %r13d
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpl %r13d, %ebp
je 0xc62c
xorl %r15d, %r15d
cmpl %r15d, %r12d
je 0xc628
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xc35c
incl %r15d
jmp 0xc60e
incl %ebp
jmp 0xc606
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: bilinear_procOnePixel(ImageReal&, Image3ChnlReal&, int, int)
void bilinear_procOnePixel(
	ImageReal &grayImage, Image3ChnlReal &rgbImage,
	int x, int y)
{
	Color color = determineBayerColor(x, y);
	
	Float_t color1 = 0, color2 = 0;
	bilinear_calcMissingColors(grayImage, rgbImage, x, y, color1, color2);
	
	//Fill in the output
	Float_t bayerValue = grayImage(x, y);
	switch (color)
	{
		case R:
			rgbImage(R, x, y) = bayerValue;
			rgbImage(G, x, y) = color1;
			rgbImage(B, x, y) = color2;
			break;
		case G:
			rgbImage(R, x, y) = color1;
			rgbImage(G, x, y) = bayerValue;
			rgbImage(B, x, y) = color2;
			break;
		case B:
			rgbImage(R, x, y) = color1;
			rgbImage(G, x, y) = color2;
			rgbImage(B, x, y) = bayerValue;
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movl %edx, %edi
movl %ecx, %esi
callq 0x1c294
movl %eax, %r15d
leaq 0x18(%rsp), %r8
andq $0x0, (%r8)
leaq 0x10(%rsp), %r9
andq $0x0, (%r9)
movq %r12, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xc63b
movq 0x38(%r12), %rax
movl 0x28(%r12), %ecx
imull %ebx, %ecx
addl %ebp, %ecx
movsd (%rax,%rcx,8), %xmm0
cmpl $0x2, %r15d
je 0xcd50
cmpl $0x1, %r15d
je 0xcd02
testl %r15d, %r15d
jne 0xcdb6
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
movsd %xmm0, (%rsp)
callq 0xb868
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0xcd2b
movsd 0x18(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
movsd %xmm0, (%rsp)
callq 0xb868
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xb868
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0xcd9e
movsd 0x18(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
movsd %xmm0, (%rsp)
callq 0xb868
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xb868
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xb868
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: bilinear_deBayer(ImageReal&, Image3ChnlReal&)
void bilinear_deBayer(ImageReal &grayImage, Image3ChnlReal &rgbImage)
{
	int width = grayImage.width(), height = grayImage.height();
	for (int y = 0; y < height; y++)
		for (int x = 0; x < width; x++)
			bilinear_procOnePixel(grayImage, rgbImage, x, y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rdi), %r12d
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
movl 0x2c(%rdi), %r13d
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpl %r13d, %ebp
je 0xce12
xorl %r15d, %r15d
cmpl %r15d, %r12d
je 0xce0e
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xcc6c
incl %r15d
jmp 0xcdf4
incl %ebp
jmp 0xcdec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: hue_constructGreenChannel(ImageReal&, Image3ChnlReal&, int, int)
void hue_constructGreenChannel(
	ImageReal &grayImage, Image3ChnlReal &rgbImage,
	int x, int y)
{
	assert(determineBayerColor(x, y) != G);
	
	int width = grayImage.width(), height = grayImage.height();
	
	Float_t colorL = 0;
	int divisor = 0;
	if (y > 0)
	{
		colorL += grayImage(x, y - 1);
		divisor++;
	}
	if (x < width - 1)
	{
		colorL += grayImage(x + 1, y);
		divisor++;
	}
	if (y < height - 1)
	{
		colorL += grayImage(x, y + 1);
		divisor++;
	}
	if (x > 0)
	{
		colorL += grayImage(x - 1, y);
		divisor++;
	}
	assert(divisor > 0);
	
	rgbImage(G, x, y) = (Float_t)colorL / (Float_t)divisor;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %edi
movl %ecx, %esi
callq 0x1c294
cmpl $0x1, %eax
je 0xcf00
movl 0x28(%r12), %ecx
testl %ebx, %ebx
jle 0xce6b
pushq $0x1
popq %rax
leal -0x1(%rbx), %edx
movq 0x38(%r12), %rsi
imull %ecx, %edx
addl %r14d, %edx
xorpd %xmm1, %xmm1
addsd (%rsi,%rdx,8), %xmm1
jmp 0xce71
xorl %eax, %eax
xorpd %xmm1, %xmm1
movl 0x2c(%r12), %edx
leal -0x1(%rcx), %esi
cmpl %r14d, %esi
jle 0xce94
movq 0x38(%r12), %rsi
movl %ecx, %edi
imull %ebx, %edi
addl %r14d, %edi
incl %edi
addsd (%rsi,%rdi,8), %xmm1
incl %eax
decl %edx
cmpl %ebx, %edx
jle 0xceaf
leal 0x1(%rbx), %edx
movq 0x38(%r12), %rsi
imull %ecx, %edx
addl %r14d, %edx
addsd (%rsi,%rdx,8), %xmm1
incl %eax
testl %r14d, %r14d
jle 0xceca
movq 0x38(%r12), %rdx
imull %ebx, %ecx
addl %r14d, %ecx
decl %ecx
addsd (%rdx,%rcx,8), %xmm1
incl %eax
jmp 0xcece
testl %eax, %eax
je 0xcf1f
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
pushq $0x1
popq %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %ebx, %ecx
callq 0xb868
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x16653(%rip), %rdi     # 0x2355a
leaq 0x16592(%rip), %rsi     # 0x234a0
leaq 0x16664(%rip), %rcx     # 0x23579
movl $0x156, %edx            # imm = 0x156
callq 0x31a0
leaq 0x165c9(%rip), %rdi     # 0x234ef
leaq 0x16573(%rip), %rsi     # 0x234a0
leaq 0x16645(%rip), %rcx     # 0x23579
movl $0x170, %edx            # imm = 0x170
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: bayer(Image3ChnlReal, ImageReal&)
void bayer(Image3ChnlReal rgbImage, ImageReal &grayImage)
{
	cout << endl << "Bayerizing..." << endl;
	
	int width = rgbImage.width(), height = rgbImage.height();
	
	if (grayImage.width() != rgbImage.width() || grayImage.height() != rgbImage.height())
		die("Bayer output isn't same size as bayer input");
	
	for (int y = 0; y < height; y++)
		for (int x = 0; x < width; x++)
		{
			Color color = determineBayerColor(x, y);
			switch (color)
			{
				case R:
					grayImage(x, y) = rgbImage(R, x, y);
					break;
				case G:
					grayImage(x, y) = rgbImage(G, x, y);
					break;
				case B:
					grayImage(x, y) = rgbImage(B, x, y);
					break;
			}
		}
	
	grayImage.setFilename(rgbImage.filename());
	grayImage.appendFilename("_b");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x214c5(%rip), %rdi     # 0x2ffd0
callq 0x3120
leaq 0x14f5c(%rip), %rsi     # 0x23a73
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3120
movl 0x28(%r14), %r12d
movl 0x2c(%r14), %r13d
cmpl %r12d, 0x28(%rbx)
jne 0xeb3b
cmpl %r13d, 0x2c(%rbx)
je 0xeb47
leaq 0x14f00(%rip), %rdi     # 0x23a42
callq 0x3b3c
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpl %r13d, %ebp
je 0xeba1
xorl %r15d, %r15d
cmpl %r15d, %r12d
je 0xeb9d
movl %r15d, %edi
movl %ebp, %esi
callq 0x1c294
cmpl $0x2, %eax
ja 0xeb98
movq %r14, %rdi
movl %eax, %esi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xb868
movsd (%rax), %xmm0
movq 0x38(%rbx), %rax
movl 0x28(%rbx), %ecx
imull %ebp, %ecx
addl %r15d, %ecx
movsd %xmm0, (%rax,%rcx,8)
incl %r15d
jmp 0xeb5f
incl %ebp
jmp 0xeb57
addq $0x8, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x33b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa4ee
leaq 0x8(%rsp), %rdi
callq 0x3548
leaq 0x14e9d(%rip), %rsi     # 0x23a6e
movq %rbx, %rdi
callq 0x8686
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3548
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/DebayerProcs.cpp
// Function: deBayer(ImageReal&, Image3ChnlReal&)
void deBayer(ImageReal &grayImage, Image3ChnlReal &rgbImage)
{
	cout << endl << "DeBayerizing..." << endl;
	
	if (rgbImage.width() != grayImage.width() || rgbImage.height() != grayImage.height())
		die("DeBayer output isn't same size as deBayer input");
	
	string suffix;
	switch (gDeBayerMethod)
	{
		case DB_NEAREST_NEIGHBOR:
			nn_deBayer(grayImage, rgbImage);
			suffix = "-nn";
			break;
		case DB_BILINEAR:
			bilinear_deBayer(grayImage, rgbImage);
			suffix = "-bl";
			break;
		case DB_SMOOTH_HUE:
			hue_deBayer(grayImage, rgbImage);
			suffix = "-hue";
			break;
		case DB_ALTERNATING_PROJECTIONS:
			altProj_deBayer(grayImage, rgbImage);
			suffix = "-ap";
			break;
	}
	
	rgbImage.setFilename(grayImage.filename());
	rgbImage.appendFilename("_db");
	rgbImage.appendFilename(suffix);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x213bf(%rip), %rdi     # 0x2ffd0
callq 0x3120
leaq 0x14e54(%rip), %rsi     # 0x23a71
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3120
movl 0x28(%rbx), %eax
cmpl 0x28(%r14), %eax
jne 0xec3f
movl 0x2c(%rbx), %eax
cmpl 0x2c(%r14), %eax
je 0xec4b
leaq 0x14e3b(%rip), %rdi     # 0x23a81
callq 0x3b3c
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x2165d(%rip), %rax     # 0x302c0
movl (%rax), %eax
cmpq $0x3, %rax
ja 0xecd3
leaq 0x1480e(%rip), %rcx     # 0x23480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc5dd
leaq 0x14e24(%rip), %rsi     # 0x23ab1
jmp 0xecc9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd77d
leaq 0x14e18(%rip), %rsi     # 0x23ab9
jmp 0xecc9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe735
leaq 0x14e09(%rip), %rsi     # 0x23abe
jmp 0xecc9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcdc3
leaq 0x14dec(%rip), %rsi     # 0x23ab5
leaq 0x8(%rsp), %rdi
callq 0x3520
addq $0x8, %r14
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x33b0
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xa4ee
leaq 0x48(%rsp), %rdi
callq 0x3548
leaq 0x14dc0(%rip), %rsi     # 0x23ac2
movq %rbx, %rdi
callq 0x8686
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x33b0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xa508
leaq 0x28(%rsp), %rdi
callq 0x3548
leaq 0x8(%rsp), %rdi
callq 0x3548
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xed54
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3548
jmp 0xed5e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3548
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: xyz2rgb(double, double, double, double&, double&, double&)
void xyz2rgb(Float_t x, Float_t y, Float_t z,
			Float_t &r, Float_t &g, Float_t &b)
{
	r = x *  3.240479 + y * -1.537150 + z * -0.498535;
	g = x * -0.969256 + y *  1.875992 + z *  0.041556;
	b = x *  0.055648 + y * -0.204043 + z *  1.057311;
	
	if (r < 0)
		r = 0;
	else if (r > 1)
		r = 1;
	
	if (g < 0)
		g = 0;
	else if (g > 1)
		g = 1;
	
	if (b < 0)
		b = 0;
	else if (b > 1)
		b = 1;
}

// Assembly:
movsd 0x14b82(%rip), %xmm3    # 0x23b10
mulsd %xmm1, %xmm3
movsd 0x14b7e(%rip), %xmm4    # 0x23b18
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x14b76(%rip), %xmm3    # 0x23b20
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, (%rdi)
movsd 0x14b6a(%rip), %xmm3    # 0x23b28
mulsd %xmm1, %xmm3
movsd 0x14b66(%rip), %xmm4    # 0x23b30
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x14b5e(%rip), %xmm3    # 0x23b38
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
mulsd 0x14b56(%rip), %xmm1    # 0x23b40
movsd %xmm3, (%rsi)
mulsd 0x14b52(%rip), %xmm0    # 0x23b48
addsd %xmm1, %xmm0
mulsd 0x14b4e(%rip), %xmm2    # 0x23b50
addsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
movsd (%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0xf026
movsd 0x13038(%rip), %xmm0    # 0x22058
ucomisd %xmm0, %xmm1
jbe 0xf02a
movsd %xmm0, (%rdi)
movsd (%rsi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0xf046
movsd 0x13018(%rip), %xmm0    # 0x22058
ucomisd %xmm0, %xmm1
jbe 0xf04a
movsd %xmm0, (%rsi)
movsd (%rdx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0xf066
movsd 0x12ff8(%rip), %xmm0    # 0x22058
ucomisd %xmm0, %xmm1
jbe 0xf06a
movsd %xmm0, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: xyz2cielab(double, double, double, double&, double&, double&)
void xyz2cielab(Float_t x, Float_t y, Float_t z,
				Float_t &l, Float_t &a, Float_t &b)
{
	//assert(x >= 0 && x <= 1);
	//assert(y >= 0 && y <= 1);
	//assert(z >= 0 && z <= 1);
	
	//----------------------------------------------------------------------
	
	//Taken from http://www.easyrgb.com/math.php
	//and http://en.wikipedia.org/wiki/SRGB_color_space
	//and http://www.mediamacros.com/item/item-1006687658/
	//and http://www.cs.rit.edu/~ncs/color/t_convert.html
	
	//Two degree D65 white point tristimulus values
	x /= 95.047;
	y /= 100.0;
	z /= 108.883;
	
	if (x > 0.008856)
		x = pow(x, 1.0 / 3.0);
	else x = (7.787 * x) + (16.0 / 116.0);
	if (y > 0.008856)
		y = pow(y, 1.0 / 3.0);
	else y = (7.787 * y) + (16.0 / 116.0);
	if (z > 0.008856)
		z = pow(z, 1.0 / 3.0);
	else z = (7.787 * z) + (16.0 / 116.0);
	
	//This resource ( http://www.cs.rit.edu/~ncs/color/t_convert.html ) computes l like this:
	if (y > 0.008856)
		l = (116.0 * y) - 16.0;
	else l = 903.3 * y;
	//l = (116 * y) - 16;
	a = 500.0 * (x - y);
	b = 200.0 * (y - z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movapd %xmm1, %xmm4
divsd 0x14acf(%rip), %xmm0    # 0x23b58
divsd 0x14acf(%rip), %xmm4    # 0x23b60
movapd %xmm2, %xmm5
ucomisd 0x14ad3(%rip), %xmm0    # 0x23b70
jbe 0xf0c6
movsd 0x14ae1(%rip), %xmm1    # 0x23b88
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x34c0
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
jmp 0xf0d6
mulsd 0x14aaa(%rip), %xmm0    # 0x23b78
addsd 0x14aaa(%rip), %xmm0    # 0x23b80
divsd 0x14a8a(%rip), %xmm5    # 0x23b68
ucomisd 0x14a8a(%rip), %xmm4    # 0x23b70
movsd %xmm0, 0x18(%rsp)
jbe 0xf111
movsd 0x14a92(%rip), %xmm1    # 0x23b88
movapd %xmm4, %xmm0
movsd %xmm5, 0x8(%rsp)
callq 0x34c0
movsd 0x8(%rsp), %xmm5
movapd %xmm0, %xmm4
jmp 0xf121
mulsd 0x14a5f(%rip), %xmm4    # 0x23b78
addsd 0x14a5f(%rip), %xmm4    # 0x23b80
ucomisd 0x14a47(%rip), %xmm5    # 0x23b70
jbe 0xf14e
movsd 0x14a55(%rip), %xmm1    # 0x23b88
movapd %xmm5, %xmm0
movsd %xmm4, 0x10(%rsp)
callq 0x34c0
movsd 0x10(%rsp), %xmm4
movapd %xmm0, %xmm5
jmp 0xf15e
mulsd 0x14a22(%rip), %xmm5    # 0x23b78
addsd 0x14a22(%rip), %xmm5    # 0x23b80
movsd 0x14a2a(%rip), %xmm0    # 0x23b90
movsd 0x14a2a(%rip), %xmm1    # 0x23b98
mulsd %xmm4, %xmm1
addsd 0x14a26(%rip), %xmm1    # 0x23ba0
mulsd %xmm4, %xmm0
movsd 0x149ea(%rip), %xmm2    # 0x23b70
cmpltsd %xmm4, %xmm2
movapd %xmm2, %xmm3
andnpd %xmm0, %xmm3
andpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movlpd %xmm2, (%r15)
movsd 0x18(%rsp), %xmm0
subsd %xmm4, %xmm0
mulsd 0x149f6(%rip), %xmm0    # 0x23ba8
movsd %xmm0, (%r14)
subsd %xmm5, %xmm4
mulsd 0x149ed(%rip), %xmm4    # 0x23bb0
movsd %xmm4, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: cielab2xyz(double, double, double, double&, double&, double&)
void cielab2xyz(Float_t l, Float_t a, Float_t b,
				Float_t &x, Float_t &y, Float_t &z)
{
	y = (l + 16.0) / 116.0;
	x = a / 500.0 + y;
	z = y - b / 200.0;
	
	if (pow(y, 3) > .008856)
		y = pow(y, 3);
	else y = (y - 16.0 / 116.0) / 7.787;
	if (pow(x, 3) > .008856)
		x = pow(x, 3);
	else x = (x - 16.0 / 116.0) / 7.787;
	if (pow(z, 3) > .008856)
		z = pow(z, 3);
	else z = (z - 16.0 / 116.0) / 7.787;
	
	x *= 95.047;
	y *= 100.0;
	z *= 108.883;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addsd 0x149d1(%rip), %xmm0    # 0x23bb8
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd 0x14a8d(%rip), %xmm1    # 0x23c80
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movhpd %xmm1, (%rsi)
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
divsd 0x149b1(%rip), %xmm2    # 0x23bc0
addsd (%rsi), %xmm2
movsd %xmm2, (%rdx)
movsd (%rsi), %xmm0
movsd 0x149a5(%rip), %xmm1    # 0x23bc8
callq 0x34c0
ucomisd 0x14940(%rip), %xmm0    # 0x23b70
movsd (%r14), %xmm0
jbe 0xf246
movsd 0x14989(%rip), %xmm1    # 0x23bc8
callq 0x34c0
jmp 0xf256
addsd 0x14982(%rip), %xmm0    # 0x23bd0
divsd 0x14922(%rip), %xmm0    # 0x23b78
movsd %xmm0, (%r14)
movsd (%r15), %xmm0
movsd 0x14960(%rip), %xmm1    # 0x23bc8
callq 0x34c0
ucomisd 0x148fb(%rip), %xmm0    # 0x23b70
movsd (%r15), %xmm0
jbe 0xf28b
movsd 0x14944(%rip), %xmm1    # 0x23bc8
callq 0x34c0
jmp 0xf29b
addsd 0x1493d(%rip), %xmm0    # 0x23bd0
divsd 0x148dd(%rip), %xmm0    # 0x23b78
movsd %xmm0, (%r15)
movsd (%rbx), %xmm0
movsd 0x1491c(%rip), %xmm1    # 0x23bc8
callq 0x34c0
ucomisd 0x148b7(%rip), %xmm0    # 0x23b70
movsd (%rbx), %xmm0
jbe 0xf2ce
movsd 0x14901(%rip), %xmm1    # 0x23bc8
callq 0x34c0
jmp 0xf2de
addsd 0x148fa(%rip), %xmm0    # 0x23bd0
divsd 0x1489a(%rip), %xmm0    # 0x23b78
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
mulsd 0x14869(%rip), %xmm0    # 0x23b58
movsd %xmm0, (%r15)
movsd (%r14), %xmm0
mulsd 0x1485f(%rip), %xmm0    # 0x23b60
movsd %xmm0, (%r14)
movsd (%rbx), %xmm0
mulsd 0x14856(%rip), %xmm0    # 0x23b68
movsd %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: printColor(double, double, double)
void printColor(Float_t r, Float_t g, Float_t b)
{
	assert(r >= 0 && r <= 1 &&
			g >= 0 && g <= 1 &&
			b >= 0 && b <= 1);
	
	Float_t x, y, z, l, a, b2;
	
	rgb2xyz(r, g, b, x, y, z);
	xyz2cielab(x, y, z, l, a, b2);
	
	cout << "RGB:";
	cout << setw(15) << r;
	cout << setw(15) << g;
	cout << setw(15) << b << endl;
	cout << "XYZ:";
	cout << setw(15) << x;
	cout << setw(15) << y;
	cout << setw(15) << z << endl;
	cout << "LAB:";
	cout << setw(15) << l;
	cout << setw(15) << a;
	cout << setw(15) << b2 << endl << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movsd 0x12536(%rip), %xmm4    # 0x22058
ucomisd %xmm2, %xmm4
jb 0xfd18
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jb 0xfd18
ucomisd %xmm1, %xmm4
jb 0xfd18
ucomisd %xmm3, %xmm0
jb 0xfd18
ucomisd %xmm0, %xmm4
jb 0xfd18
ucomisd %xmm3, %xmm1
jb 0xfd18
leaq 0x58(%rsp), %rbx
leaq 0x50(%rsp), %r14
leaq 0x48(%rsp), %r15
movsd %xmm2, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0xee64
movsd (%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r14), %xmm1
movsd %xmm1, 0x20(%rsp)
movsd (%r15), %xmm2
movsd %xmm2, 0x28(%rsp)
leaq 0x40(%rsp), %r12
leaq 0x38(%rsp), %r14
leaq 0x30(%rsp), %rbx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf06b
movq 0x203fc(%rip), %r15     # 0x2ffd0
leaq 0x1435c(%rip), %rsi     # 0x23f37
movq %r15, %rdi
callq 0x32c0
movq (%r15), %rax
movq -0x18(%rax), %rax
pushq $0xf
popq %r13
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd (%rsp), %xmm0
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3460
movq %rax, %rdi
callq 0x3120
leaq 0x142f9(%rip), %rsi     # 0x23f3c
movq %r15, %rdi
callq 0x32c0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq %r15, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x3460
movq %rax, %rdi
callq 0x3120
leaq 0x14299(%rip), %rsi     # 0x23f41
movq %r15, %rdi
callq 0x32c0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movsd (%r12), %xmm0
movq %r15, %rdi
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movsd (%r14), %xmm0
movq %r15, %rdi
callq 0x3460
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movsd (%rbx), %xmm0
movq %r15, %rdi
callq 0x3460
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3120
leaq 0x141b4(%rip), %rdi     # 0x23ed3
leaq 0x13f9b(%rip), %rsi     # 0x23cc1
leaq 0x141df(%rip), %rcx     # 0x23f0c
movl $0x107, %edx            # imm = 0x107
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: rgbImgToLabImg(double, Image3ChnlReal const&, Image3ChnlReal&)
void rgbImgToLabImg(Float_t maxVal, const Image3ChnlReal &rgbImg, Image3ChnlReal &labImg)
{
	labImg.resize(rgbImg.width(), rgbImg.height());
	
	Float_t r, g, b;
	Float_t x, y, z;
	Float_t l, a, b2;
	int totalPixels = rgbImg.totalPixels();
	for (int i = 0; i < totalPixels; i++)
	{
		r = (*rgbImg[0])[i] / maxVal;
		g = (*rgbImg[1])[i] / maxVal;
		b = (*rgbImg[2])[i] / maxVal;
		
		rgb2xyz(r, g, b, x, y, z);
		xyz2cielab(x, y, z, l, a, b2);
		/*
		if (l < 0 || a < 0 || b2 < 0)
			cout << setw(10) << r
				<< setw(10) << g
				<< setw(10) << b
				<< setw(15) << x
				<< setw(10) << y
				<< setw(10) << z
				<< setw(15) << l
				<< setw(10) << a
				<< setw(10) << b2 << endl;
		*/
		(*labImg[0])[i] = l;
		(*labImg[1])[i] = a;
		(*labImg[2])[i] = b2;
		/*
		if (i % 128 == 0)
		{
			cout << "RGB:";
			cout << setw(15) << r;
			cout << setw(15) << g;
			cout << setw(15) << b << endl;
			cout << "XYZ:";
			cout << setw(15) << x;
			cout << setw(15) << y;
			cout << setw(15) << z << endl;
			cout << "LAB:";
			cout << setw(15) << l;
			cout << setw(15) << a;
			cout << setw(15) << b2 << endl << endl;
		}
		*/
	}
	
	labImg.setFilename(rgbImg.filename());
	labImg.appendFilename("_lab");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, (%rsp)
movl 0x28(%rdi), %esi
movl 0x2c(%rdi), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl 0x30(%r14), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0xfe34
movq 0x38(%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq 0x38(%rcx), %rcx
movsd (%rcx,%rbp,8), %xmm0
movsd (%rsp), %xmm3
divsd %xmm3, %xmm0
movq 0x38(%rdx), %rcx
movsd (%rcx,%rbp,8), %xmm1
divsd %xmm3, %xmm1
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movsd (%rax,%rbp,8), %xmm2
divsd %xmm3, %xmm2
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xee64
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf06b
movsd 0x18(%rsp), %xmm0
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rax), %rcx
movq 0x38(%rcx), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0xfd76
addq $0x8, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x33b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa4ee
leaq 0x38(%rsp), %rdi
callq 0x3548
leaq 0x12c1d(%rip), %rsi     # 0x22a81
movq %rbx, %rdi
callq 0x8686
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3548
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: labImgToRgbImg(double, Image3ChnlReal const&, Image3ChnlReal&)
void labImgToRgbImg(Float_t maxVal, const Image3ChnlReal &labImg, Image3ChnlReal &rgbImg)
{
	rgbImg.resize(labImg.width(), labImg.height());
	
	Float_t r, g, b;
	Float_t x, y, z;
	Float_t l, a, b2;
	int totalPixels = labImg.totalPixels();
	for (int i = 0; i < totalPixels; i++)
	{
		l = (*labImg[0])[i];
		a = (*labImg[1])[i];
		b2 = (*labImg[2])[i];
		
		cielab2xyz(l, a, b2, x, y, z);
		xyz2rgb(x, y, z, r, g, b);
		
		(*rgbImg[0])[i] = r * maxVal;
		(*rgbImg[1])[i] = g * maxVal;
		(*rgbImg[2])[i] = b * maxVal;
	}
	
	rgbImg.setFilename(labImg.filename());
	rgbImg.appendFilename("_rgb");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, (%rsp)
movl 0x28(%rdi), %esi
movl 0x2c(%rdi), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl 0x30(%r14), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
leaq 0x28(%rsp), %r15
leaq 0x20(%rsp), %r12
cmpq %rbp, %r13
je 0xff8d
movq 0x38(%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq 0x38(%rcx), %rcx
movsd (%rcx,%rbp,8), %xmm0
movq 0x38(%rdx), %rcx
movsd (%rcx,%rbp,8), %xmm1
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movsd (%rax,%rbp,8), %xmm2
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf1d1
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xef86
movsd 0x30(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movsd 0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x8(%rax), %rcx
movq 0x38(%rcx), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0xfecf
addq $0x8, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x33b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa4ee
leaq 0x38(%rsp), %rdi
callq 0x3548
leaq 0x12ac9(%rip), %rsi     # 0x22a86
movq %rbx, %rdi
callq 0x8686
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3548
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: calcNonoutlierMeanPixelValue(ImageReal&, double)
Float_t calcNonoutlierMeanPixelValue(ImageReal &grayImage, Float_t outlierSigmas)
{
	int totalPixels = grayImage.totalPixels();
	
	//Find the mean pixel value
	Float_t meanVal = 0;
	for (int i = 0; i < totalPixels; i++)
		meanVal += grayImage[i];
	meanVal /= totalPixels;
	
	//Find the variance of pixel value
	Float_t variance = 0;
	for (int i = 0; i < totalPixels; i++)
		variance += pow(grayImage[i] - meanVal, 2);
	variance /= (totalPixels * 3);
	
	//Find the standard deviation of pixel value
	Float_t stddev = sqrt(variance);
	
	//Define outliers as some number of standard deviations
	Float_t minOutlier = meanVal - stddev * outlierSigmas;
	Float_t maxOutlier = meanVal + stddev * outlierSigmas;
	
	//Find the mean pixel value of nonoutliers
	Float_t nonOutlierMeanVal = 0;
	int numNonOutliers = 0;
		for (int i = 0; i < totalPixels; i++)
			if (grayImage[i] >= minOutlier && grayImage[i] <= maxOutlier)
			{
				nonOutlierMeanVal += grayImage[i];
				numNonOutliers++;
			}
	nonOutlierMeanVal /= numNonOutliers;
	
	return nonOutlierMeanVal;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm2
movq %rdi, %rbx
movl 0x30(%rdi), %eax
movq 0x38(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r14d
cmovgl %eax, %r14d
xorpd %xmm3, %xmm3
cmpq %rdx, %r14
je 0x1001f
addsd (%rcx,%rdx,8), %xmm3
incq %rdx
jmp 0x10010
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm3
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %r14
je 0x10048
movsd (%rcx,%rdx,8), %xmm1
subsd %xmm3, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x1002d
leal (%rax,%rax,2), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jb 0x10063
sqrtsd %xmm0, %xmm0
jmp 0x10084
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x3220
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
addsd %xmm3, %xmm0
movq 0x38(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %r14
je 0x100d2
movsd (%rax,%rcx,8), %xmm2
movapd %xmm1, %xmm3
cmplepd %xmm2, %xmm3
movapd %xmm2, %xmm4
cmplepd %xmm0, %xmm4
andpd %xmm3, %xmm4
movq %xmm4, %rsi
testb $0x1, %sil
je 0x100cb
addsd %xmm2, %xmm5
subl %esi, %edx
incq %rcx
jmp 0x1009c
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm5
movapd %xmm5, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/ImageProcs.cpp
// Function: calcNonoutlierMeanPixelValue(Image3ChnlReal&, double)
Float_t calcNonoutlierMeanPixelValue(Image3ChnlReal &rgbImage, Float_t outlierSigmas)
{
	int totalPixels = rgbImage.totalPixels();
	
	//Find the mean pixel value
	Float_t meanVal = 0;
	for (int c = 0; c < 3; c++)
		for (int i = 0; i < totalPixels; i++)
			meanVal += (*rgbImage[c])[i];
	meanVal /= (totalPixels * 3);
	
	//Find the variance of pixel value
	Float_t variance = 0;
	for (int c = 0; c < 3; c++)
		for (int i = 0; i < totalPixels; i++)
			variance += pow((*rgbImage[c])[i] - meanVal, 2);
	variance /= (totalPixels * 3);
	
	//Find the standard deviation of pixel value
	Float_t stddev = sqrt(variance);
	
	//Define outliers as some number of standard deviations
	Float_t minOutlier = meanVal - stddev * outlierSigmas;
	Float_t maxOutlier = meanVal + stddev * outlierSigmas;
	
	//Find the mean pixel value of nonoutliers
	Float_t nonOutlierMeanVal = 0;
	int numNonOutliers = 0;
	for (int c = 0; c < 3; c++)
		for (int i = 0; i < totalPixels; i++)
			if ((*rgbImage[c])[i] >= minOutlier && (*rgbImage[c])[i] <= maxOutlier)
			{
				nonOutlierMeanVal += (*rgbImage[c])[i];
				numNonOutliers++;
			}
	nonOutlierMeanVal /= numNonOutliers;
	
	return nonOutlierMeanVal;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm3
movq %rdi, %rbx
movl 0x30(%rdi), %ecx
movq 0x38(%rdi), %rax
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %r14d
cmovgl %ecx, %r14d
xorpd %xmm4, %xmm4
cmpq $0x3, %rdx
je 0x10131
xorl %esi, %esi
cmpq %rsi, %r14
je 0x1012c
movq (%rax,%rdx,8), %rdi
movq 0x38(%rdi), %rdi
addsd (%rdi,%rsi,8), %xmm4
incq %rsi
jmp 0x10115
incq %rdx
jmp 0x1010d
leal (%rcx,%rcx,2), %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm4
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x10172
xorl %edx, %edx
cmpq %rdx, %r14
je 0x1016d
movq (%rax,%rcx,8), %rsi
movq 0x38(%rsi), %rsi
movsd (%rsi,%rdx,8), %xmm2
subsd %xmm4, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
jmp 0x1014a
incq %rcx
jmp 0x10142
divsd %xmm1, %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jb 0x10186
sqrtsd %xmm0, %xmm0
jmp 0x101a7
movsd %xmm3, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x3220
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm0
movapd %xmm4, %xmm1
subsd %xmm0, %xmm1
addsd %xmm4, %xmm0
movq 0x38(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x3, %rcx
je 0x1020a
xorl %esi, %esi
cmpq %rsi, %r14
je 0x10205
movq (%rax,%rcx,8), %rdi
movq 0x38(%rdi), %rdi
movsd (%rdi,%rsi,8), %xmm2
movapd %xmm1, %xmm3
cmplepd %xmm2, %xmm3
movapd %xmm2, %xmm4
cmplepd %xmm0, %xmm4
andpd %xmm3, %xmm4
movq %xmm4, %rdi
testb $0x1, %dil
je 0x101fe
addsd %xmm2, %xmm5
subl %edi, %edx
incq %rsi
jmp 0x101c7
incq %rcx
jmp 0x101bf
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm5
movapd %xmm5, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: assertValidDims(int, int)
bool assertValidDims(int width, int height)
{
	int numOnes = 0;
	for (int bitPos = 0; bitPos < sizeof(int) * 8; bitPos++)
		if (width & (1 << bitPos))
			++numOnes;
	if (width < 16 || numOnes != 1)
		return false;
	
	numOnes = 0;
	for (int bitPos = 0; bitPos < sizeof(int) * 8; bitPos++)
		if (height & (1 << bitPos))
			++numOnes;
	if (height < 16 || numOnes != 1)
		return false;
	
	return true;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x20, %eax
je 0x13af3
btl %eax, %edi
adcl $0x0, %ecx
incl %eax
jmp 0x13ae4
xorl %eax, %eax
cmpl $0x10, %edi
jl 0x13b20
cmpl $0x1, %ecx
jne 0x13b20
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x20, %ecx
je 0x13b12
btl %ecx, %esi
adcl $0x0, %eax
incl %ecx
jmp 0x13b03
cmpl $0x10, %esi
setge %cl
cmpl $0x1, %eax
sete %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: doFourierAnalysis(double const*, double*, int, int)
bool doFourierAnalysis(const Float_t *grayImage, Float_t *fourierTransform, int width, int height)
{
	if (!assertValidDims(width, height))
		return false;
	
	int err = fft2dInit(log2(height), log2(width));
	if (err != 0)
		return false;
	
	if (!fourierTransform)
		fourierTransform = new Float_t(width * height * sizeof(Float_t));
	if (fourierTransform != grayImage)
		memcpy(fourierTransform, grayImage, width * height * sizeof(Float_t));
	rfft2d(fourierTransform, log2(height), log2(width));
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %edi
movl %ecx, %esi
callq 0x13ae0
testb %al, %al
je 0x14131
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %r12
movl %ebx, %edi
callq 0x1528a
cvttsd2si %xmm0, %rsi
movq %r12, %rdi
callq 0x1c4a0
testl %eax, %eax
je 0x1413c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
jne 0x1417d
pushq $0x8
popq %rdi
callq 0x32d0
movq %rax, %r14
movl %ebp, %eax
imull %ebx, %eax
cltq
shlq $0x3, %rax
movq %rax, %xmm0
punpckldq 0xdebc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xdec4(%rip), %xmm0     # 0x22030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%r14)
cmpq %r15, %r14
je 0x14199
movl %ebp, %eax
imull %ebx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3240
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %r15
movl %ebx, %edi
callq 0x1528a
cvttsd2si %xmm0, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ce73
movb $0x1, %al
jmp 0x14133
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: doFourierAnalysis(ImageReal const&, ImageReal&)
bool doFourierAnalysis(const ImageReal &grayImage, ImageReal &fourierTransform)
{
	int width = grayImage.width(), height = grayImage.height();
	
	if (!assertValidDims(width, height))
		return false;
	
	int err = fft2dInit(log2(height), log2(width));
	if (err != 0)
		return false;
	
	fourierTransform = grayImage;
	rfft2d(fourierTransform.img(), log2(height), log2(width));
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x28(%rdi), %ebx
movl 0x2c(%rdi), %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0x13ae0
testb %al, %al
je 0x14208
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %r12
movl %ebx, %edi
callq 0x1528a
cvttsd2si %xmm0, %rsi
movq %r12, %rdi
callq 0x1c4a0
testl %eax, %eax
je 0x14213
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0xa5e6
movq 0x38(%r14), %r14
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %r15
movl %ebx, %edi
callq 0x1528a
cvttsd2si %xmm0, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ce73
movb $0x1, %al
jmp 0x1420a
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: multiplyFourierTransforms(double*, double*, int, int, double*)
bool multiplyFourierTransforms(Float_t *ft1, Float_t *ft2,
	int width, int height, Float_t *prod)
{
	if (!assertValidDims(width, height))
		return false;
	
	if (!prod)
		prod = new Float_t[width * height];
	rspect2dprod(ft1, ft2, prod, height, width);
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %edi
movl %ecx, %esi
callq 0x13ae0
movl %eax, %ebx
testb %al, %al
je 0x142a9
testq %r13, %r13
jne 0x14295
movl %r12d, %eax
imull %ebp, %eax
leaq (,%rax,8), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, %r13
movslq %r12d, %rcx
movslq %ebp, %r8
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d52c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: multiplyFourierTransformsAndInvert(double*, double*, int, int, double*)
bool multiplyFourierTransformsAndInvert(Float_t *ft1, Float_t *ft2,
	int width, int height, Float_t *convolvedImg)
{
	if (!multiplyFourierTransforms(ft1, ft2, width, height, convolvedImg))
		return false;
	
	int err = fft2dInit(log2(height), log2(width));
	if (err != 0)
		return false;
	
	//Invert the Fourier Transform
	rifft2d(convolvedImg, log2(height), log2(width));
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %ebp
callq 0x14249
testb %al, %al
je 0x142f7
movl %r14d, %edi
callq 0x1528a
cvttsd2si %xmm0, %r15
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %rsi
movq %r15, %rdi
callq 0x1c4a0
testl %eax, %eax
je 0x14304
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
callq 0x1528a
cvttsd2si %xmm0, %r14
movl %ebp, %edi
callq 0x1528a
cvttsd2si %xmm0, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d1be
movb $0x1, %al
jmp 0x142f9
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: convolveImageWithFilter(double*, double*, int, int, double*)
bool convolveImageWithFilter(Float_t *img, Float_t *filterFT,
	int width, int height, Float_t *imgConv)
{
	if (!assertValidDims(width, height))
		return false;
	
	//Get the Fourier Transform of the image
	Float_t *imgFT = new Float_t[width * height];
	assert(doFourierAnalysis(img, imgFT, width, height));
	
	//Multiplty the Fourier Transforms and invert the FT
	return multiplyFourierTransformsAndInvert(imgFT, filterFT, width, height, imgConv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %edi
movl %ecx, %esi
callq 0x13ae0
testb %al, %al
je 0x143a6
movl %ebp, %eax
imull %r14d, %eax
leaq (,%rax,8), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x140ee
testb %al, %al
je 0x143b7
movq %r13, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x142ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10895(%rip), %rdi     # 0x24c53
leaq 0x107f6(%rip), %rsi     # 0x24bbb
leaq 0x108b4(%rip), %rcx     # 0x24c80
movl $0xfa, %edx
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FourierTransform.cpp
// Function: embedImageInPow2Bounds(ImageReal const&, int, int, ImageReal&, int&, int&)
bool embedImageInPow2Bounds(const ImageReal &img, int newWidth, int newHeight, ImageReal &imgOut, int &offsetX, int &offsetY)
{
	if (!assertValidDims(newWidth, newHeight))
		return false;
	
	imgOut.resize(newWidth, newHeight);
	int width = img.width(), height = img.height();
	offsetX = (newWidth - width) / 2;
	offsetY = (newHeight - height) / 2;
	
	//By default, an embedded odd-length signal will be positioned such that the center pixel
	//resides at lower right, but I prefer that it be at upper left, so shift it by one.
	if (width % 2 == 1)
		offsetX++;
	if (height % 2 == 1)
		offsetY++;
	
	for (int y = 0; y < height; y++)
		for (int x = 0; x < width; x++)
			imgOut(x + offsetX, y + offsetY) = img(x, y);
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movl %esi, %edi
movl %edx, %esi
callq 0x13ae0
movb %al, 0x7(%rsp)
testb %al, %al
je 0x144a8
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq *0x28(%rax)
movl 0x28(%r12), %ecx
movl 0x2c(%r12), %esi
subl %ecx, %ebp
pushq $0x2
popq %rdi
movl %ebp, %eax
cltd
idivl %edi
movl %eax, (%r14)
subl %esi, %r13d
movl %r13d, %eax
cltd
idivl %edi
movl %eax, (%rbx)
movl %ecx, %eax
andl $0x80000001, %eax       # imm = 0x80000001
cmpl $0x1, %eax
jne 0x14446
incl (%r14)
movl %esi, %eax
andl $0x80000001, %eax       # imm = 0x80000001
cmpl $0x1, %eax
jne 0x14454
incl (%rbx)
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
testl %esi, %esi
cmovlel %eax, %esi
cmpl %esi, %eax
je 0x144a8
movq 0x38(%r12), %rdx
movl (%rbx), %edi
addl %eax, %edi
imull 0x28(%r15), %edi
addl (%r14), %edi
movq 0x38(%r15), %r8
movl 0x28(%r12), %r9d
imull %eax, %r9d
movq %rcx, %r10
subq $0x1, %r10
jb 0x144a4
movl %r9d, %r11d
movsd (%rdx,%r11,8), %xmm0
movl %edi, %r11d
movsd %xmm0, (%r8,%r11,8)
incl %edi
incl %r9d
jmp 0x14485
incl %eax
jmp 0x14460
movb 0x7(%rsp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq