LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::flipVertical()
void ImageReal::flipVertical()
{
	Float_t temp;
	int halfHeight = height_ / 2;
	for (int y = 0; y < halfHeight; y++)
		for (int x = 0; x < width_; x++)
		{
			temp = (*this)(x, y);
			(*this)(x, y) = (*this)(x, (height_ - 1) - y);
			(*this)(x, (height_ - 1) - y) = temp;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x2c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15d10
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x15d00
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x16fd0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x1c(%rbp), %esi
movl 0x2c(%rdi), %edx
subl $0x1, %edx
subl -0x18(%rbp), %edx
callq 0x16fd0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x16fd0
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x1c(%rbp), %esi
movl 0x2c(%rdi), %edx
subl $0x1, %edx
subl -0x18(%rbp), %edx
callq 0x16fd0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15c6c
jmp 0x15d02
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15c59
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::rot90CW()
void ImageReal::rot90CW()
{
	ImageReal temp(width_, height_);
	Float_t *tempImgPtr = temp.img_;
	for (int y = 0; y < height_; y++)
		for (int x = 0; x < width_; x++)
			*tempImgPtr++ = img_[((height_ - 1) - x) * width_ + y];
	*this = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
leaq -0x48(%rbp), %rdi
callq 0x15710
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x70(%rbp), %rcx
movl -0x54(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x15dbc
movl $0x0, -0x58(%rbp)
movq -0x70(%rbp), %rcx
movl -0x58(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x15daf
movq -0x70(%rbp), %rdx
movq 0x38(%rdx), %rax
movl 0x2c(%rdx), %ecx
subl $0x1, %ecx
subl -0x58(%rbp), %ecx
imull 0x28(%rdx), %ecx
addl -0x54(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x15d65
jmp 0x15db1
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x15d52
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x15690
jmp 0x15dcb
leaq -0x48(%rbp), %rdi
callq 0x157e0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x157e0
movq -0x60(%rbp), %rdi
callq 0x4620
nopl (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::rot180()
void ImageReal::rot180()
{
	Float_t temp;
	int halfTotalPixels = totalPixels_ / 2;
	for (int i = 0; i < halfTotalPixels; i++)
	{
		temp = img_[i];
		img_[i] = img_[(totalPixels_ - 1) - i];
		img_[(totalPixels_ - 1) - i] = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x30(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15e8a
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rax
movslq -0x18(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x10(%rbp)
movq 0x38(%rcx), %rax
movl 0x30(%rcx), %edx
subl $0x1, %edx
subl -0x18(%rbp), %edx
movslq %edx, %rdx
movsd (%rax,%rdx,8), %xmm0
movq 0x38(%rcx), %rax
movslq -0x18(%rbp), %rdx
movsd %xmm0, (%rax,%rdx,8)
movsd -0x10(%rbp), %xmm0
movq 0x38(%rcx), %rax
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15e25
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::rot90CCW()
void ImageReal::rot90CCW()
{
	ImageReal temp(width_, height_);
	Float_t *tempImgPtr = temp.img_;
	for (int y = 0; y < height_; y++)
		for (int x = 0; x < width_; x++)
			*tempImgPtr++ = img_
				[x * width_ + ((width_ - 1) - y)];
	*this = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
leaq -0x48(%rbp), %rdi
callq 0x15710
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x70(%rbp), %rcx
movl -0x54(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x15f2e
movl $0x0, -0x58(%rbp)
movq -0x70(%rbp), %rcx
movl -0x58(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x15f21
movq -0x70(%rbp), %rdx
movq 0x38(%rdx), %rax
movl -0x58(%rbp), %ecx
imull 0x28(%rdx), %ecx
movl 0x28(%rdx), %edx
subl $0x1, %edx
subl -0x54(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x15ed5
jmp 0x15f23
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x15ec2
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x15690
jmp 0x15f3d
leaq -0x48(%rbp), %rdi
callq 0x157e0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x157e0
movq -0x60(%rbp), %rdi
callq 0x4620
nopw (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::downsample(ImageReal&, int, int) const
void ImageReal::downsample(ImageReal &imageOut, int startX, int startY) const
{
	assert(width_ % 2 == 0 && height_ % 2 == 0);
	
	int	widthOut = width_ / 2, heightOut = height_ / 2;
	if (imageOut.width() != widthOut || imageOut.height() != heightOut)
		imageOut.resize(widthOut, heightOut);
	
	int imageOutIdx = 0;
	for (int y = startY; y < height_; y += 2)
		for (int x = startX; x < width_; x += 2, ++imageOutIdx)
			imageOut[imageOutIdx] = img_[y * width_ + x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x2d(%rbp)
jne 0x15fbb
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x15fc4
jmp 0x15fc6
jmp 0x15fe5
leaq 0x340eb(%rip), %rdi     # 0x4a0b8
leaq 0x34108(%rip), %rsi     # 0x4a0dc
movl $0xbc, %edx
leaq 0x3410a(%rip), %rcx     # 0x4a0ea
callq 0x4240
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movl 0x2c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedd0
cmpl -0x1c(%rbp), %eax
jne 0x16027
movq -0x10(%rbp), %rdi
callq 0xedf0
cmpl -0x20(%rbp), %eax
je 0x16037
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x0, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x160b7
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x160aa
movq -0x38(%rbp), %rdx
movq 0x38(%rdx), %rax
movl -0x28(%rbp), %ecx
imull 0x28(%rdx), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xef70
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16056
jmp 0x160ac
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x16044
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::upsample(ImageReal&, int, int) const
void ImageReal::upsample(ImageReal &imageOut, int startX, int startY) const
{
	assert(width_ % 2 == 0 && height_ % 2 == 0);
	
	int widthOut = width_ * 2, heightOut = height_ * 2;
	if (imageOut.width() != widthOut || imageOut.height() != heightOut)
		imageOut.resize(widthOut, heightOut);
	
	int imageInIdx = 0;
	for (int y = startY; y < heightOut; y += 2)
		for (int x = startX; x < widthOut; x += 2, ++imageInIdx)
			imageOut[y * widthOut + x] = img_[imageInIdx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x2d(%rbp)
jne 0x1610b
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x16114
jmp 0x16116
jmp 0x16135
leaq 0x33f9b(%rip), %rdi     # 0x4a0b8
leaq 0x33fb8(%rip), %rsi     # 0x4a0dc
movl $0xcd, %edx
leaq 0x33ff2(%rip), %rcx     # 0x4a122
callq 0x4240
movq -0x38(%rbp), %rax
movl 0x28(%rax), %ecx
shll %ecx
movl %ecx, -0x1c(%rbp)
movl 0x2c(%rax), %eax
shll %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedd0
cmpl -0x1c(%rbp), %eax
jne 0x16165
movq -0x10(%rbp), %rdi
callq 0xedf0
cmpl -0x20(%rbp), %eax
je 0x16175
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x0, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x161eb
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x161de
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
imull -0x1c(%rbp), %esi
addl -0x2c(%rbp), %esi
callq 0xef70
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16190
jmp 0x161e0
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x16182
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x14df0
movq -0x58(%rbp), %rdi
leaq 0x42b75(%rip), %rax     # 0x59d10
movq %rax, (%rdi)
addq $0x38, %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x18c20
movl $0x40, %edi
callq 0x43a0
movq %rax, -0x40(%rbp)
jmp 0x171c2
movq -0x40(%rbp), %rdi
callq 0x155e0
jmp 0x171cd
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x18c40
jmp 0x171e4
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x68(%rbp)
movl $0x40, %edi
callq 0x43a0
movq %rax, -0x60(%rbp)
jmp 0x17200
movq -0x60(%rbp), %rdi
callq 0x155e0
jmp 0x1720b
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x18c40
jmp 0x17222
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x78(%rbp)
movl $0x40, %edi
callq 0x43a0
movq %rax, -0x70(%rbp)
jmp 0x1723e
movq -0x70(%rbp), %rdi
callq 0x155e0
jmp 0x17249
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x18c40
jmp 0x17260
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17300
jmp 0x1726f
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x172d8
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x43b0
jmp 0x172d8
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x43b0
jmp 0x172d8
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x43b0
movq -0x48(%rbp), %rdi
callq 0x18c70
movq -0x58(%rbp), %rdi
callq 0x15030
movq -0x20(%rbp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x1732b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x173fb
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15070
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18cf0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf8c0
movq -0x38(%rbp), %rsi
movq (%rax), %rdi
callq 0x15690
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0x18cf0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movl $0x1, %esi
callq 0xf8c0
movq -0x30(%rbp), %rsi
movq (%rax), %rdi
callq 0x15690
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0x18cf0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
movl $0x2, %esi
callq 0xf8c0
movq -0x28(%rbp), %rsi
movq (%rax), %rdi
callq 0x15690
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x42735(%rip), %rax     # 0x59d00
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x38, %rdi
callq 0x18cd0
cmpq $0x3, %rax
jne 0x175e3
jmp 0x17602
leaq 0x32d5f(%rip), %rdi     # 0x4a349
leaq 0x32d69(%rip), %rsi     # 0x4a35a
movl $0x2f, %edx
leaq 0x32d70(%rip), %rcx     # 0x4a36d
callq 0x4240
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf8c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1762a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0xf8c0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x17653
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0xf8c0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1767c
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x18c70
movq -0x10(%rbp), %rdi
callq 0x15030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x176f7
movb $0x1, -0x1(%rbp)
jmp 0x177df
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x150e0
testb $0x1, %al
jne 0x17711
movb $0x0, -0x1(%rbp)
jmp 0x177df
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18cf0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18cf0
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x158e0
testb $0x1, %al
jne 0x1774c
jmp 0x17755
movb $0x0, -0x1(%rbp)
jmp 0x177df
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0x18cf0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0x18cf0
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x158e0
testb $0x1, %al
jne 0x17792
jmp 0x17798
movb $0x0, -0x1(%rbp)
jmp 0x177df
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0x18cf0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0x18cf0
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x158e0
testb $0x1, %al
jne 0x177d5
jmp 0x177db
movb $0x0, -0x1(%rbp)
jmp 0x177df
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x15580
testb $0x1, %al
jne 0x1785b
movq -0x20(%rbp), %rdi
callq 0x17920
movb $0x0, -0x1(%rbp)
jmp 0x1790a
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x18cd0
cmpq $0x3, %rax
jne 0x17870
jmp 0x1788f
leaq 0x32ad2(%rip), %rdi     # 0x4a349
leaq 0x32adc(%rip), %rsi     # 0x4a35a
movl $0x63, %edx
leaq 0x32b0d(%rip), %rcx     # 0x4a397
callq 0x4240
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf8c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0xf8c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0xf8c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedd0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedf0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x19bd1
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x19bc4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x19780
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19b9e
jmp 0x19bc6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19b8f
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedd0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedf0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1a6a1
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a694
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x1a420
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a66e
jmp 0x1a696
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a65f
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x380a0
cmpl $0x1, %eax
je 0x1a6d8
jmp 0x1a6f7
leaq 0x2ff4b(%rip), %rdi     # 0x4a62a
leaq 0x2fe8a(%rip), %rsi     # 0x4a570
movl $0x156, %edx            # imm = 0x156
leaq 0x2ff57(%rip), %rcx     # 0x4a649
callq 0x4240
movq -0x8(%rbp), %rdi
callq 0xedd0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedf0
movl %eax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x1a74d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x16fd0
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a783
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
callq 0x16fd0
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a7b9
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
callq 0x16fd0
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1a7e8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x18(%rbp), %edx
callq 0x16fd0
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x1a7f0
jmp 0x1a80f
leaq 0x2fdc8(%rip), %rdi     # 0x4a5bf
leaq 0x2fd72(%rip), %rsi     # 0x4a570
movl $0x170, %edx            # imm = 0x170
leaq 0x2fe3f(%rip), %rcx     # 0x4a649
callq 0x4240
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl $0x1, %esi
callq 0x17990
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movsd -0x8(%rbp), %xmm1
movsd 0x2caf4(%rip), %xmm0    # 0x4ac20
mulsd -0x10(%rbp), %xmm0
movsd 0x2cadf(%rip), %xmm2    # 0x4ac18
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x2cac2(%rip), %xmm2    # 0x4ac10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm1
movsd 0x2ca9d(%rip), %xmm0    # 0x4ac08
mulsd -0x10(%rbp), %xmm0
movsd 0x2ca88(%rip), %xmm2    # 0x4ac00
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x2ca6b(%rip), %xmm2    # 0x4abf8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm1
movsd 0x2ca46(%rip), %xmm0    # 0x4abf0
mulsd -0x10(%rbp), %xmm0
movsd 0x2ca31(%rip), %xmm2    # 0x4abe8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x2ca14(%rip), %xmm2    # 0x4abe0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1e1f6
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1e21e
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2ae1a(%rip), %xmm1    # 0x49020
ucomisd %xmm1, %xmm0
jbe 0x1e21c
movq -0x20(%rbp), %rax
movsd 0x2ae08(%rip), %xmm0    # 0x49020
movsd %xmm0, (%rax)
jmp 0x1e21e
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1e238
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1e260
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2add8(%rip), %xmm1    # 0x49020
ucomisd %xmm1, %xmm0
jbe 0x1e25e
movq -0x28(%rbp), %rax
movsd 0x2adc6(%rip), %xmm0    # 0x49020
movsd %xmm0, (%rax)
jmp 0x1e260
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1e27a
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1e2a2
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2ad96(%rip), %xmm1    # 0x49020
ucomisd %xmm1, %xmm0
jbe 0x1e2a0
movq -0x30(%rbp), %rax
movsd 0x2ad84(%rip), %xmm0    # 0x49020
movsd %xmm0, (%rax)
jmp 0x1e2a2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movsd 0x2c7cd(%rip), %xmm0    # 0x4ac88
addsd -0x8(%rbp), %xmm0
movsd 0x2c7a0(%rip), %xmm1    # 0x4ac68
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd 0x2c79f(%rip), %xmm1    # 0x4ac80
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
addsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x2c76e(%rip), %xmm2    # 0x4ac78
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movsd 0x2c6f4(%rip), %xmm1    # 0x4ac28
ucomisd %xmm1, %xmm0
jbe 0x1e556
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x1e57e
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2c6ea(%rip), %xmm1    # 0x4ac50
subsd %xmm1, %xmm0
movsd 0x2c6d6(%rip), %xmm1    # 0x4ac48
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movsd 0x2c690(%rip), %xmm1    # 0x4ac28
ucomisd %xmm1, %xmm0
jbe 0x1e5ba
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x1e5e2
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2c686(%rip), %xmm1    # 0x4ac50
subsd %xmm1, %xmm0
movsd 0x2c672(%rip), %xmm1    # 0x4ac48
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movsd 0x2c62c(%rip), %xmm1    # 0x4ac28
ucomisd %xmm1, %xmm0
jbe 0x1e61e
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movl $0x3, %edi
callq 0x258f0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x1e646
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x2c622(%rip), %xmm1    # 0x4ac50
subsd %xmm1, %xmm0
movsd 0x2c60e(%rip), %xmm1    # 0x4ac48
divsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x2c5ee(%rip), %xmm0    # 0x4ac40
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd 0x2c5d2(%rip), %xmm0    # 0x4ac38
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movsd 0x2c5b6(%rip), %xmm0    # 0x4ac30
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageProcs.cpp
// Function: diffImages(Image3ChnlReal const&, Image3ChnlReal const&, Image3ChnlReal&)
void diffImages(const Image3ChnlReal &img1, const Image3ChnlReal &img2, Image3ChnlReal &diff)
{
	assert(img1.width() == img2.width() && img1.height() == img2.height());
	int width = img1.width(), height = img1.height();
	diff.resize(width, height);
	int totalPixels = img1.totalPixels();
	assert(totalPixels = width * height);
	
	for (int c = 0; c < 3; c++)
		diffImages(*img1[c], *img2[c], *diff[c]);
	
	diff.setFilename(img1.filename());
	diff.appendFilename("_dif");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedd0
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedd0
movl -0x5c(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x55(%rbp)
jne 0x2579c
movq -0x8(%rbp), %rdi
callq 0xedf0
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedf0
movl %eax, %ecx
movl -0x60(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x257a5
jmp 0x257a7
jmp 0x257c6
leaq 0x26378(%rip), %rdi     # 0x4bb26
leaq 0x2557c(%rip), %rsi     # 0x4ad31
movl $0x5ab, %edx            # imm = 0x5AB
leaq 0x26409(%rip), %rcx     # 0x4bbca
callq 0x4240
movq -0x8(%rbp), %rdi
callq 0xedd0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xedf0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0xf200
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x2580b
jmp 0x2582a
leaq 0x26396(%rip), %rdi     # 0x4bba8
leaq 0x25518(%rip), %rsi     # 0x4ad31
movl $0x5af, %edx            # imm = 0x5AF
leaq 0x263a5(%rip), %rcx     # 0x4bbca
callq 0x4240
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x2587e
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x25920
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x25920
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xef40
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x25530
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x25831
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xf090
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x154b0
jmp 0x258a6
leaq -0x48(%rbp), %rdi
callq 0x46c8
movq -0x18(%rbp), %rdi
leaq 0x2630b(%rip), %rsi     # 0x4bbc5
callq 0xf220
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x46c8
movq -0x50(%rbp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x20, %rax
jae 0x2668e
movl -0x8(%rbp), %eax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x26681
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26683
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26658
cmpl $0x10, -0x8(%rbp)
jl 0x2669a
cmpl $0x1, -0x10(%rbp)
je 0x266a0
movb $0x0, -0x1(%rbp)
jmp 0x266fa
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x20, %rax
jae 0x266e4
movl -0xc(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x266d7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x266d9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x266ae
cmpl $0x10, -0xc(%rbp)
jl 0x266f0
cmpl $0x1, -0x10(%rbp)
je 0x266f6
movb $0x0, -0x1(%rbp)
jmp 0x266fa
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/FourierTransform.cpp
// Function: findNextPow2(int)
int findNextPow2(int val)
{
	for (int i = 2; i <= 65536; i<<=1)
		if (val <= i)
			return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jg 0x26743
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x26737
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2674a
jmp 0x26739
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
jmp 0x2671e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x26640
testb $0x1, %al
jne 0x2777e
movb $0x0, -0x1(%rbp)
jmp 0x27863
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x30(%rbp), %rdi
cvttsd2si %xmm0, %rsi
callq 0x384c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x277b7
movb $0x0, -0x1(%rbp)
jmp 0x27863
cmpq $0x0, -0x18(%rbp)
jne 0x27807
movl $0x8, %edi
callq 0x43a0
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %edx
imull %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
movq %rcx, %xmm0
movaps 0x2186c(%rip), %xmm1    # 0x49050
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x21870(%rip), %xmm1    # 0x49060
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2782c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x4300
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
cvttsd2si %xmm0, %rdx
callq 0x39510
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedd0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedf0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x26640
testb $0x1, %al
jne 0x278ad
movb $0x0, -0x1(%rbp)
jmp 0x2792c
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x30(%rbp), %rdi
cvttsd2si %xmm0, %rsi
callq 0x384c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x278e3
movb $0x0, -0x1(%rbp)
jmp 0x2792c
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x15690
movq -0x18(%rbp), %rdi
callq 0xf2c0
movq %rax, -0x40(%rbp)
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
cvttsd2si %xmm0, %rdx
callq 0x39510
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x26640
testb $0x1, %al
jne 0x2796f
movb $0x0, -0x1(%rbp)
jmp 0x279c1
cmpq $0x0, -0x28(%rbp)
jne 0x279a4
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movslq -0x20(%rbp), %rcx
movslq -0x1c(%rbp), %r8
callq 0x3a280
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x27940
testb $0x1, %al
jne 0x27a0b
movb $0x0, -0x1(%rbp)
jmp 0x27a78
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x38(%rbp), %rdi
cvttsd2si %xmm0, %rsi
callq 0x384c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x27a41
movb $0x0, -0x1(%rbp)
jmp 0x27a78
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %edi
callq 0x29350
cvttsd2si %xmm0, %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %edi
callq 0x29350
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
cvttsd2si %xmm0, %rdx
callq 0x39be0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x26640
testb $0x1, %al
jne 0x27ac2
movb $0x0, -0x1(%rbp)
jmp 0x27b46
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x27750
testb $0x1, %al
jne 0x27b09
jmp 0x27b0b
jmp 0x27b2a
leaq 0x241db(%rip), %rdi     # 0x4bced
leaq 0x24136(%rip), %rsi     # 0x4bc4f
movl $0xfa, %edx
leaq 0x241f5(%rip), %rcx     # 0x4bd1a
callq 0x4240
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x279d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x26640
testb $0x1, %al
jne 0x27b96
movb $0x0, -0x1(%rbp)
jmp 0x27c96
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0xedd0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0xedf0
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
subl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
subl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x27c05
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x27c20
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x27c92
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x27c85
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
callq 0x1d980
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x28(%rbp), %rax
addl (%rax), %esi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
addl (%rax), %edx
callq 0x16fd0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x27c36
jmp 0x27c87
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x27c27
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)