LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::UpsampleX(CLinear16*)
void CLinear16::UpsampleX(CLinear16 *bmp)
{
	color_t *src = mData - 1;
	color_t *dst = bmp->mData;
	for (int y = 0; y < mHeight; y++)
	{
		UpfilterXLeft(src++, dst);
		dst += 2;
		for (int x = 1; x < mWidth-1; x++)
		{
			UpfilterX(src++, dst);
			dst += 2;
		}
		UpfilterXRight(src++, dst);
		dst += 2;
	}
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
jle 0x6fbe
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x18(%rdi), %r15
addq $-0x8, %r15
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e6b
cmpl $0x3, (%rbx)
jl 0x6f9a
movl $0x1, %r12d
addq $0x8, %r15
addq $0x10, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5dea
incl %r12d
movl (%rbx), %eax
decl %eax
cmpl %eax, %r12d
jl 0x6f71
leaq 0x8(%r15), %rdi
leaq 0x10(%r14), %rsi
jmp 0x6fa2
leaq 0x10(%r14), %rsi
leaq 0x8(%r15), %rdi
addq $0x10, %r15
callq 0x5ebc
addq $0x20, %r14
incl %ebp
cmpl 0x4(%rbx), %ebp
jl 0x6f5b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::UpsampleY(CLinear16*)
void CLinear16::UpsampleY(CLinear16 *bmp)
{
	color_t *src1 = mData - mWidth;
	color_t *src2 = mData;
	color_t *src3 = mData + mWidth;
	color_t *dst1 = bmp->mData;
	color_t *dst2 = bmp->mData + bmp->mWidth;
	for (int y = 0; y < mHeight; y++)
	{
		if (y == 0)
		{
			for (int x = 0; x < mWidth; x++)
			{
				UpfilterY(src2, src2, src3, dst1++, dst2++);
				src1++; src2++; src3++;
			}
		}
		else if (y == mHeight - 1)
		{
			for (int x = 0; x < mWidth; x++)
			{
				UpfilterY(src1, src2, src2, dst1++, dst2++);
				src1++; src2++; src3++;
			}
		}
		else
		{
			for (int x = 0; x < mWidth; x++)
			{
				Upfilter(src1++, src2++, src3++, dst1++, dst2++);
			}
		}
		dst1 += bmp->mWidth;
		dst2 += bmp->mWidth;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl 0x4(%rdi), %edx
testl %edx, %edx
jle 0x71b6
movq %rdi, %r9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movslq (%rax), %rax
leaq (%rcx,%rax,8), %r8
movq 0x18(%rdi), %r15
movslq (%rdi), %rax
leaq (%r15,%rax,8), %r13
movq %rax, %rsi
shlq $0x3, %rsi
movq %r15, %r12
subq %rsi, %r12
xorl %esi, %esi
movq %rdi, (%rsp)
testl %esi, %esi
movl %esi, 0xc(%rsp)
je 0x70fa
decl %edx
cmpl %edx, %esi
jne 0x713e
testl %eax, %eax
jle 0x7187
xorl %r14d, %r14d
leaq 0x8(%rcx), %rbx
leaq 0x8(%r8), %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x5f06
movq (%rsp), %r9
addq $0x8, %r12
addq $0x8, %r15
addq $0x8, %r13
incl %r14d
movl (%r9), %eax
movq %rbp, %r8
movq %rbx, %rcx
cmpl %eax, %r14d
jl 0x70be
jmp 0x718d
testl %eax, %eax
jle 0x7187
xorl %r14d, %r14d
leaq 0x8(%rcx), %rbx
leaq 0x8(%r8), %rbp
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5f06
movq (%rsp), %r9
addq $0x8, %r12
addq $0x8, %r15
addq $0x8, %r13
incl %r14d
movl (%r9), %eax
movq %rbp, %r8
movq %rbx, %rcx
cmpl %eax, %r14d
jl 0x7105
jmp 0x718d
testl %eax, %eax
jle 0x7187
xorl %r14d, %r14d
movq %r13, %rdx
movq %r15, %rsi
movq %r12, %rdi
leaq 0x8(%rdi), %r12
leaq 0x8(%rsi), %r15
leaq 0x8(%rdx), %r13
leaq 0x8(%rcx), %rbx
leaq 0x8(%r8), %rbp
callq 0x5f84
movq (%rsp), %r9
incl %r14d
movl (%r9), %eax
movq %rbp, %r8
movq %rbx, %rcx
movq %r13, %rdx
movq %r15, %rsi
movq %r12, %rdi
cmpl %eax, %r14d
jl 0x714e
jmp 0x718d
movq %rcx, %rbx
movq %r8, %rbp
movq 0x10(%rsp), %rcx
movslq (%rcx), %rdx
leaq (%rbx,%rdx,8), %rcx
leaq (,%rdx,8), %r8
addq %rbp, %r8
movl 0xc(%rsp), %esi
incl %esi
movl 0x4(%r9), %edx
cmpl %edx, %esi
jl 0x70a1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::DownsampleX(CLinear16*)
void CLinear16::DownsampleX(CLinear16 *bmp)
{
	assert((mWidth  & 0xfffe) == bmp->mWidth*2);
	assert(mHeight == bmp->mHeight);
	color_t *src = mData - 1;
	color_t *dst = bmp->mData;
	for (int y = 0; y < bmp->mHeight; y++)
	{
		DownfilterXLeft(src, dst++);
		src += 2;
		for (int x = 1; x < bmp->mWidth-1; x++)
		{
			DownfilterX(src, dst++);
			src += 2;
		}
		DownfilterXRight(src, dst++);
		src += 2 + (mWidth&1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfffe, %eax           # imm = 0xFFFE
andl (%rdi), %eax
movl (%rsi), %ecx
addl %ecx, %ecx
cmpl %ecx, %eax
jne 0x7679
movq %rdi, %rbx
movq %rsi, %r14
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x7698
testl %eax, %eax
jle 0x766a
movq 0x18(%r14), %r15
movq 0x18(%rbx), %r12
addq $-0x8, %r12
xorl %ebp, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x56fc
addq $0x10, %r12
cmpl $0x3, (%r14)
jl 0x7645
movl $0x1, %r13d
addq $0x8, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x569c
incl %r13d
addq $0x10, %r12
movl (%r14), %eax
decl %eax
cmpl %eax, %r13d
jl 0x7625
leaq 0x8(%r15), %rsi
addq $0x10, %r15
movq %r12, %rdi
callq 0x5760
movl (%rbx), %eax
andl $0x1, %eax
leaq (%r12,%rax,8), %r12
addq $0x10, %r12
incl %ebp
cmpl 0x4(%r14), %ebp
jl 0x760a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16cc1(%rip), %rdi     # 0x1e341
leaq 0x16c39(%rip), %rsi     # 0x1e2c0
leaq 0x16d23(%rip), %rcx     # 0x1e3b1
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x4100
leaq 0x16d3b(%rip), %rdi     # 0x1e3da
leaq 0x16c1a(%rip), %rsi     # 0x1e2c0
leaq 0x16d04(%rip), %rcx     # 0x1e3b1
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x4100
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::WriteSimple16(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ESimpleFormat)
bool CLinear16::WriteSimple16(std::string filename, ESimpleFormat format)
{
	int bytesPerPixel;
	TSimpleHeader header;
	int bytesPerLine;
	;

	FILE *f = fopen(filename.c_str(), "wb");
	if (f == NULL) 
		return false;
	switch (format)
	{
	case ESimpleFormatRgba:
	case ESimpleFormatBgra:
		bytesPerPixel = 8;
		break;
	case ESimpleFormatRgb:
	case ESimpleFormatBgr:
		bytesPerPixel = 6;
		break;
	case ESimpleFormatL:
		bytesPerPixel = 2;
		break;
	case ESimpleFormatLa:
		bytesPerPixel = 4;
		break;
	default:
		assert(0);
	return false;
	}

	header.cookieA = 'PMIS';
	header.cookieB = 'ECIL';
	header.datasize = bytesPerPixel * mWidth * mHeight;
	header.width = mWidth;
	header.height = mHeight;
	header.bits = 16;
	header.format = format;
	fwrite(&header,1,sizeof(TSimpleHeader),f);
	bytesPerLine = mWidth * bytesPerPixel;
	uint16_t *dst = (uint16_t *) malloc(bytesPerLine);
	color_t *src = mData;
	for (int i = 0; i < mHeight; i++)
	{
		WriteSimpleScanline(src, dst, format);
		fwrite(dst,1,bytesPerLine,f);
		src += mWidth;
	}
	fclose(f);
	free(dst);
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
movq %rdi, %r15
movq (%rsi), %rdi
leaq 0x166dc(%rip), %rsi     # 0x1e33e
callq 0x4150
movq %rax, %rbx
testq %rax, %rax
je 0x7d47
leal -0xc3b(%r12), %eax
cmpl $0x6, %eax
jae 0x7d5c
movl %eax, %eax
leaq 0x1661b(%rip), %rcx     # 0x1e2a8
movslq (%rcx,%rax,4), %r14
movabsq $0x4543494c504d4953, %rax # imm = 0x4543494C504D4953
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl %eax, %edx
imull %ecx, %edx
imull %r14d, %edx
movslq %edx, %rdx
movq %rdx, 0x8(%rdi)
movl %eax, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movl $0x10, 0x18(%rdi)
movl %r12d, 0x1c(%rdi)
movl $0x1, %esi
movl $0x20, %edx
movq %rbx, %rcx
callq 0x42d0
movq %r12, (%rsp)
movslq (%r15), %r12
imulq %r14, %r12
movq %r12, %rdi
callq 0x4140
movq %rax, %r13
cmpl $0x0, 0x4(%r15)
jle 0x7d37
movq 0x18(%r15), %rbp
xorl %r14d, %r14d
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq (%rsp), %rcx
callq 0x793e
movl $0x1, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x42d0
movslq (%r15), %rax
leaq (%rbp,%rax,8), %rbp
incl %r14d
cmpl 0x4(%r15), %r14d
jl 0x7d01
movq %rbx, %rdi
callq 0x42a0
movq %r13, %rdi
callq 0x41c0
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x166e8(%rip), %rdi     # 0x1e44b
leaq 0x16556(%rip), %rsi     # 0x1e2c0
leaq 0x166dc(%rip), %rcx     # 0x1e44d
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x4100
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::ConvertToMonochrome()
void CLinear16::ConvertToMonochrome()
{
	color_t *c = mData;
	for (int y = 0; y < mHeight; y++)
	{
		for (int x = 0; x < mWidth; x++)
		{
			// scale by 10000
			int luma = c->r * 2126 + c->g * 7152 + c->b * 722 + 5000;
			luma /= 10000;
			c->r = luma;
			c->g = luma;
			c->b = luma;
			c++;
		}
	}

}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x7faa
movq 0x18(%rdi), %rcx
movl (%rdi), %edx
xorl %esi, %esi
movl %edx, %edi
testl %edx, %edx
jle 0x7fa4
movzwl 0x4(%rcx), %r8d
imull $0x84e, %r8d, %r8d      # imm = 0x84E
movzwl 0x2(%rcx), %r9d
imull $0x1bf0, %r9d, %r9d     # imm = 0x1BF0
addl %r8d, %r9d
movzwl (%rcx), %r8d
imull $0x2d2, %r8d, %r8d      # imm = 0x2D2
addl %r9d, %r8d
addl $0x1388, %r8d           # imm = 0x1388
imulq $0x68db8bad, %r8, %r8   # imm = 0x68DB8BAD
shrq $0x2c, %r8
movw %r8w, 0x4(%rcx)
movw %r8w, 0x2(%rcx)
movw %r8w, (%rcx)
addq $0x8, %rcx
decl %edi
jne 0x7f53
incl %esi
cmpl %eax, %esi
jne 0x7f4d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::CompositePremultiplied(CLinear16*)
void CLinear16::CompositePremultiplied(CLinear16 *overlay)
{
	color_t *src = overlay->mData;
	color_t *dst = mData;
	for (int y = 0; y < mHeight; y++)
	{
		for (int x = 0; x < mWidth; x++)
		{
			if (src->a == 0xffff)
			{
				// destination gets 100% of source
				*dst = *src;
			}
			else if (src->a > 0)
			{
				// destination gets 100% of source
				int b = 0xffff - src->a;
				dst->b = dst->b * b / 65535 + src->b;
				dst->g = dst->g * b / 65535 + src->g;
				dst->r = dst->r * b / 65535 + src->r;
			}
			src++;
			dst++;
		}
	}
}

// Assembly:
movl 0x4(%rdi), %r9d
testl %r9d, %r9d
jle 0x806d
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
movl (%rdi), %r8d
xorl %edx, %edx
movl $0x80008001, %esi       # imm = 0x80008001
testl %r8d, %r8d
jle 0x8062
xorl %r9d, %r9d
movzwl 0x6(%rcx), %r10d
testl %r10d, %r10d
je 0x804a
cmpl $0xffff, %r10d          # imm = 0xFFFF
jne 0x7ff5
movq (%rcx), %r8
movq %r8, (%rax)
movl (%rdi), %r8d
jmp 0x804a
notl %r10d
movzwl %r10w, %r10d
movzwl (%rax), %r11d
imull %r10d, %r11d
imulq %rsi, %r11
shrq $0x2f, %r11
addw (%rcx), %r11w
movw %r11w, (%rax)
movzwl 0x2(%rax), %r11d
imull %r10d, %r11d
imulq %rsi, %r11
shrq $0x2f, %r11
addw 0x2(%rcx), %r11w
movw %r11w, 0x2(%rax)
movzwl 0x4(%rax), %r11d
imull %r10d, %r11d
imulq %rsi, %r11
shrq $0x2f, %r11
addw 0x4(%rcx), %r11w
movw %r11w, 0x4(%rax)
addq $0x8, %rcx
addq $0x8, %rax
incl %r9d
cmpl %r8d, %r9d
jl 0x7fd7
movl 0x4(%rdi), %r9d
incl %edx
cmpl %r9d, %edx
jl 0x7fcb
retq
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::CompositeStraight(CLinear16*)
void CLinear16::CompositeStraight(CLinear16 *overlay)
{
	color_t *src = overlay->mData;
	color_t *dst = mData;
	for (int y = 0; y < mHeight; y++)
	{
		for (int x = 0; x < mWidth; x++)
		{
			if (src->a == 0xffff)
			{
				// destination gets 100% of source
				*dst = *src;
			}
			else if (src->a > 0)
			{
				// destination gets 100% of source
				int b = 0xffff - src->a;
				dst->b = (dst->b * b + src->b * src->a) / 65535;
				dst->g = (dst->g * b + src->g * src->a) / 65535;
				dst->r = (dst->r * b + src->r * src->a) / 65535;
			}
			src++;
			dst++;
		}
	}
}

// Assembly:
movl 0x4(%rdi), %r9d
testl %r9d, %r9d
jle 0x814a
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
movl (%rdi), %r8d
xorl %edx, %edx
movl $0x80008001, %esi       # imm = 0x80008001
testl %r8d, %r8d
jle 0x813c
xorl %r9d, %r9d
movzwl 0x6(%rcx), %r10d
testl %r10d, %r10d
je 0x8124
cmpl $0xffff, %r10d          # imm = 0xFFFF
jne 0x80ba
movq (%rcx), %r8
movq %r8, (%rax)
movl (%rdi), %r8d
jmp 0x8124
movl %r10d, %r11d
xorl $0xffff, %r11d          # imm = 0xFFFF
movzwl (%rax), %ebx
imull %r11d, %ebx
movzwl (%rcx), %r14d
imull %r10d, %r14d
addl %ebx, %r14d
imulq %rsi, %r14
shrq $0x2f, %r14
movw %r14w, (%rax)
movzwl 0x2(%rax), %ebx
imull %r11d, %ebx
movzwl 0x2(%rcx), %r14d
imull %r10d, %r14d
addl %ebx, %r14d
imulq %rsi, %r14
shrq $0x2f, %r14
movw %r14w, 0x2(%rax)
movzwl 0x4(%rax), %ebx
imull %r11d, %ebx
movzwl 0x4(%rcx), %r11d
imull %r10d, %r11d
addl %ebx, %r11d
imulq %rsi, %r11
shrq $0x2f, %r11
movw %r11w, 0x4(%rax)
addq $0x8, %rcx
addq $0x8, %rax
incl %r9d
cmpl %r8d, %r9d
jl 0x809c
movl 0x4(%rdi), %r9d
incl %edx
cmpl %r9d, %edx
jl 0x8090
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::WriteLumaToAlpha(bool)
void CLinear16::WriteLumaToAlpha(bool invertLuma)
{
	color_t *c = mData;
	for (int y = 0; y < mHeight; y++)
	{
		for (int x = 0; x < mWidth; x++)
		{
			int luma = c->r * 2126 + c->g * 7152 +c->b * 722 + 5000;
			luma /= 10000;
			c->a = invertLuma ? 65535 - luma : luma;
			c++;
		}
	}
}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x81be
movq 0x18(%rdi), %rcx
movl (%rdi), %edx
xorl %edi, %edi
movl %edx, %r8d
testl %edx, %edx
jle 0x81b8
movzwl 0x4(%rcx), %r9d
imull $0x84e, %r9d, %r9d      # imm = 0x84E
movzwl 0x2(%rcx), %r10d
imull $0x1bf0, %r10d, %r10d   # imm = 0x1BF0
addl %r9d, %r10d
movzwl (%rcx), %r9d
imull $0x2d2, %r9d, %r9d      # imm = 0x2D2
addl %r10d, %r9d
addl $0x1388, %r9d           # imm = 0x1388
imulq $0x68db8bad, %r9, %r9   # imm = 0x68DB8BAD
shrq $0x2c, %r9
movl %r9d, %r10d
notl %r10d
testb %sil, %sil
cmovel %r9d, %r10d
movw %r10w, 0x6(%rcx)
addq $0x8, %rcx
decl %r8d
jne 0x8162
incl %edi
cmpl %eax, %edi
jne 0x815b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::BlitImage(CLinear16*, int, int)
void CLinear16::BlitImage(CLinear16 *image, int dstX, int dstY)
{
	if (dstX + image->mWidth > mWidth)
	{
		assert(0);
		return;
	}
	if (dstY + image->mHeight > mHeight)
	{
		assert(0);
		return;
	}
	color_t *src = image->mData;
	color_t *dst = mData + dstY*mWidth + dstX;
	for (int y = 0; y < image->mHeight; y++)
	{
		for (int x = 0; x < image->mWidth; x++)
		{
			*dst++ = *src++;
		}
		dst += mWidth - image->mWidth;
	}
}

// Assembly:
pushq %rax
movl (%rsi), %eax
leal (%rax,%rdx), %r9d
movl (%rdi), %r8d
cmpl %r8d, %r9d
jg 0x823c
movl 0x4(%rsi), %r10d
leal (%r10,%rcx), %r9d
cmpl 0x4(%rdi), %r9d
jg 0x825b
testl %r10d, %r10d
jle 0x823a
imull %r8d, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq 0x18(%rdi), %rcx
movslq %edx, %rdx
leaq (%rcx,%rdx,8), %rcx
movq 0x18(%rsi), %rdx
xorl %r9d, %r9d
testl %eax, %eax
jle 0x8225
xorl %r8d, %r8d
movq (%rdx), %rax
addq $0x8, %rdx
movq %rax, (%rcx)
addq $0x8, %rcx
incl %r8d
movl (%rsi), %eax
cmpl %eax, %r8d
jl 0x8206
movl (%rdi), %r8d
movl 0x4(%rsi), %r10d
movl %r8d, %r11d
subl %eax, %r11d
movslq %r11d, %r11
leaq (%rcx,%r11,8), %rcx
incl %r9d
cmpl %r10d, %r9d
jl 0x81ff
popq %rax
retq
leaq 0x16208(%rip), %rdi     # 0x1e44b
leaq 0x16076(%rip), %rsi     # 0x1e2c0
leaq 0x162af(%rip), %rcx     # 0x1e500
movl $0x385, %edx            # imm = 0x385
callq 0x4100
leaq 0x161e9(%rip), %rdi     # 0x1e44b
leaq 0x16057(%rip), %rsi     # 0x1e2c0
leaq 0x16290(%rip), %rcx     # 0x1e500
movl $0x38a, %edx            # imm = 0x38A
callq 0x4100
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::Flip(bool, bool)
void CLinear16::Flip(bool flipX, bool flipY)
{
	color_t *src;
	color_t *dst;
	color_t temp;

	if (flipY)
	{
		for (int y = 0; y < mHeight/2; y++)
		{
			src = mData + y * mWidth;
			dst = mData + (mHeight - 1 - y) * mWidth;
			if (flipX)
			{
				dst += mWidth - 1;
				for (int x = 0; x < mWidth; x++)
				{
					temp = *src;
					*src++ = *dst;
					*dst-- = temp;
				}
			}
			else
			{
				for (int x = 0; x < mWidth; x++)
				{
					temp = *src;
					*src++ = *dst;
					*dst++ = temp;
				}
			}
		}
	}
	else if (flipX)
	{
		for (int y = 0; y < mHeight; y++)
		{
			src = mData + y * mWidth;
			dst = src + mWidth - 1;
			for (int x = 0; x < mWidth/2; x++)
			{
				temp = *src;
				*src++ = *dst;
				*dst-- = temp;
			}
		}
	}
}

// Assembly:
testl %edx, %edx
je 0x86c8
movl 0x4(%rdi), %r8d
cmpl $0x2, %r8d
jl 0x8732
movl (%rdi), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %edx, %r9d
movq 0x18(%rdi), %r10
testb %sil, %sil
je 0x8662
movl %edx, %r11d
testl %edx, %edx
jle 0x86a5
movslq %r9d, %rdx
addl %ecx, %r8d
imull %r9d, %r8d
movslq %r8d, %r8
shlq $0x3, %r8
leaq (%r8,%rdx,8), %rdx
leaq (%r10,%rdx), %r8
addq $-0x8, %r8
imull %eax, %r9d
movslq %r9d, %rdx
leaq (%r10,%rdx,8), %r9
xorl %r10d, %r10d
movq (%r9,%r10,8), %rdx
movq (%r8), %r11
movq %r11, (%r9,%r10,8)
movq %rdx, (%r8)
movl (%rdi), %edx
incq %r10
addq $-0x8, %r8
movl %edx, %r11d
cmpl %edx, %r10d
jl 0x8641
jmp 0x86a5
testl %r9d, %r9d
jle 0x86a2
addl %ecx, %r8d
imull %r9d, %r8d
movslq %r8d, %rdx
leaq (%r10,%rdx,8), %r8
imull %eax, %r9d
movslq %r9d, %rdx
leaq (%r10,%rdx,8), %r9
xorl %r10d, %r10d
movq (%r9,%r10,8), %rdx
movq (%r8,%r10,8), %r11
movq %r11, (%r9,%r10,8)
movq %rdx, (%r8,%r10,8)
movl (%rdi), %edx
incq %r10
movl %edx, %r11d
cmpl %edx, %r10d
jl 0x8683
jmp 0x86a5
movl %r9d, %r11d
incl %eax
movl 0x4(%rdi), %r8d
movl %r8d, %r10d
shrl $0x1f, %r10d
addl %r8d, %r10d
sarl %r10d
decl %ecx
movl %r11d, %r9d
cmpl %r10d, %eax
jl 0x8602
jmp 0x8732
testb %sil, %sil
je 0x8732
movl 0x4(%rdi), %edx
testl %edx, %edx
jle 0x8732
movl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x872c
movq 0x18(%rdi), %rsi
movl %ecx, %edx
imull %eax, %ecx
leaq (,%rcx,8), %r8
leaq (%r8,%rdx,8), %rdx
addq %rsi, %rdx
addq $-0x8, %rdx
leaq (%rsi,%rcx,8), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %rcx
movq (%rdx), %r9
movq %r9, (%rsi,%r8,8)
movq %rcx, (%rdx)
movl (%rdi), %ecx
movl %ecx, %r9d
shrl $0x1f, %r9d
addl %ecx, %r9d
sarl %r9d
incq %r8
addq $-0x8, %rdx
cmpl %r9d, %r8d
jl 0x8700
movl 0x4(%rdi), %edx
incl %eax
cmpl %edx, %eax
jl 0x86d8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::Rotate90()
void CLinear16::Rotate90()
{
	CLinear16 *temp = new CLinear16(mWidth, mHeight);

	color_t *src = mData;

	for (int y = 0; y < mHeight; y++)
	{
		color_t *dst = temp->mData + mWidth - 1 - y;
		for (int x = 0; x < mWidth; x++)
		{
			*dst = *src++;
			dst += mWidth;
		}
	}

	BlitImage(temp, 0, 0);

	delete temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x9620
movq %rax, %rbx
movl (%r14), %r12d
movl 0x4(%r14), %ebp
movl %r12d, (%rax)
movl %ebp, 0x4(%rax)
movl %ebp, %eax
imull %r12d, %eax
leal (,%rax,8), %ecx
movslq %ecx, %r15
movq %r15, 0x8(%rbx)
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x9660
movq %rax, 0x18(%rbx)
movq %rax, %rdi
movl $0x80, %esi
movq %r15, %rdx
callq 0x4070
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
testl %ebp, %ebp
jle 0x87f4
movq 0x18(%r14), %rax
xorl %ecx, %ecx
testl %r12d, %r12d
jle 0x87e9
movl %r12d, %edx
shlq $0x3, %rdx
addq 0x18(%rbx), %rdx
leaq (,%rcx,8), %rsi
subq %rsi, %rdx
addq $-0x8, %rdx
xorl %esi, %esi
movq (%rax), %rdi
addq $0x8, %rax
movq %rdi, (%rdx)
movslq (%r14), %r12
leaq (%rdx,%r12,8), %rdx
incl %esi
cmpl %r12d, %esi
jl 0x87cd
movl 0x4(%r14), %ebp
incq %rcx
movslq %ebp, %rdx
cmpq %rdx, %rcx
jl 0x87ac
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x81c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8819
callq 0x8920
movq $0x0, 0x18(%rbx)
movl $0x20, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8910
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x8910
movq %r14, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O3/kylegranger[P]ImageScaling/linear16.cpp
// Function: CLinear16::Rotate(int)
void CLinear16::Rotate(int angle)
{
	assert(mWidth == mHeight);
	angle = angle % 360;
	switch (angle)
	{
	case 0:
		break;
	case 90:
		Rotate90();
		break;
	case 180:
		Flip(true, true);
		break;
	case 270:
		Flip(true, true);
		Rotate90();
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0x88c3
movq %rdi, %rbx
movslq %esi, %rax
imulq $-0x49f49f49, %rax, %rcx # imm = 0xB60B60B7
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x8, %ecx
addl %edx, %ecx
imull $0x168, %ecx, %ecx      # imm = 0x168
subl %ecx, %eax
cmpl $0xb3, %eax
jg 0x8885
testl %eax, %eax
je 0x88ae
cmpl $0x5a, %eax
je 0x88a5
jmp 0x88e2
cmpl $0xb4, %eax
je 0x88b0
cmpl $0x10e, %eax            # imm = 0x10E
jne 0x88e2
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x85e0
movq %rbx, %rdi
popq %rbx
jmp 0x8734
popq %rbx
retq
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
popq %rbx
jmp 0x85e0
leaq 0x15d0a(%rip), %rdi     # 0x1e5d4
leaq 0x159ef(%rip), %rsi     # 0x1e2c0
leaq 0x15d0e(%rip), %rcx     # 0x1e5e6
movl $0x428, %edx            # imm = 0x428
callq 0x4100
leaq 0x15b62(%rip), %rdi     # 0x1e44b
leaq 0x159d0(%rip), %rsi     # 0x1e2c0
leaq 0x15cef(%rip), %rcx     # 0x1e5e6
movl $0x439, %edx            # imm = 0x439
callq 0x4100
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mrGoncharuk[P]foldermonitor/src/DbWriter.cpp
// Function: DBWriter::executeQuery(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void 	DBWriter::executeQuery(const std::string &query)
{
	int ret;
	char *errmsg;

	std::lock_guard<std::mutex> lock(dbMutex);
	ret = sqlite3_exec(db, query.c_str(), nullptr, nullptr, &errmsg);
	if (ret == SQLITE_OK)
		syslog(LOG_NOTICE, "DW> Query executed successfully.");
	else
	{
		syslog(LOG_ERR, "DW> Error while migrating data from. Query: [%s]. Error message: %s.", query.c_str(), errmsg);
		sqlite3_free(errmsg);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x2280
testl %eax, %eax
jne 0x2d1a
movq 0x8(%r15), %rdi
movq (%r14), %rsi
leaq 0x8(%rsp), %r8
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2240
testl %eax, %eax
je 0x2cf5
movq (%r14), %rdx
movq 0x8(%rsp), %rcx
leaq 0x176f(%rip), %rsi      # 0x444c
movl $0x3, %edi
xorl %eax, %eax
callq 0x2050
movq 0x8(%rsp), %rdi
callq 0x2230
jmp 0x2d08
leaq 0x172f(%rip), %rsi      # 0x442b
movl $0x5, %edi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2170
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x2140
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/mrGoncharuk[P]foldermonitor/src/DirectoryMonitor.cpp
// Function: DirectoryMonitor::~DirectoryMonitor()
DirectoryMonitor::~DirectoryMonitor()
{
	syslog(LOG_NOTICE, "DM> File watcher destroyed.");
	if (fileDescriptor > 0 && watchDescriptor > 0)
		inotify_rm_watch(fileDescriptor, watchDescriptor);
	if (fileDescriptor > 0)
		close(fileDescriptor);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x16c9(%rip), %rsi      # 0x44c8
movl $0x5, %edi
xorl %eax, %eax
callq 0x2050
movl (%rbx), %edi
testl %edi, %edi
jle 0x2e28
movl 0x4(%rbx), %esi
testl %esi, %esi
jle 0x2e23
callq 0x20f0
movl (%rbx), %edi
testl %edi, %edi
jle 0x2e28
callq 0x2360
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2e3b
popq %rbx
jmp 0x21c0
popq %rbx
retq
movq %rax, %rdi
callq 0x2d52
nop
// File: /workspace/github_cpp_makefile_star2_O3/mrGoncharuk[P]foldermonitor/src/DirectoryMonitor.cpp
// Function: DirectoryMonitor::initWatcher()
bool DirectoryMonitor::initWatcher()
{
	fileDescriptor = inotify_init();
	if (fileDescriptor < 0)
	{
		syslog (LOG_ERR, "DM> Error while inotify initialization.");
		syslog (LOG_NOTICE, "DM> Daemon stops.");
		return false;
	}
	watchDescriptor = inotify_add_watch(fileDescriptor, fname.c_str(), IN_CREATE);
	if (watchDescriptor < 0)
	{
		syslog (LOG_ERR, "DM> Error while starting watching folder.");
		syslog (LOG_NOTICE, "DM> Daemon stops.");
		return false;
	}
	syslog(LOG_NOTICE, "DM> File watcher initialized successfully.");
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2310
movl %eax, (%rbx)
testl %eax, %eax
js 0x2ed5
movq 0x8(%rbx), %rsi
movl %eax, %edi
movl $0x100, %edx            # imm = 0x100
callq 0x2110
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x2ede
movb $0x1, %bl
leaq 0x168f(%rip), %rsi      # 0x4562
jmp 0x2efa
leaq 0x1622(%rip), %rsi      # 0x44fe
jmp 0x2ee5
leaq 0x1653(%rip), %rsi      # 0x4538
xorl %ebx, %ebx
movl $0x3, %edi
xorl %eax, %eax
callq 0x2050
leaq 0x162c(%rip), %rsi      # 0x4526
movl $0x5, %edi
xorl %eax, %eax
callq 0x2050
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrGoncharuk[P]foldermonitor/src/MigrationManager.cpp
// Function: MigrationManager::migrateData(std::mutex&, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::atomic<bool>&)
void	MigrationManager::migrateData(std::mutex &list_mutex, std::list<std::string> &filenames, std::atomic<bool> &isRunning)
{
	if (threadAmount == 1)
	{
		syslog(LOG_NOTICE, "MM> Data migration will be executed in solo thread mode.");
		migrateSolo(list_mutex, filenames, isRunning);
	}
	else
	{
		syslog(LOG_NOTICE, "MM> Data migration will be executed in <%d> threads.", threadAmount);
		migrateThreaded(list_mutex, filenames, isRunning);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%rdi), %edx
cmpl $0x1, %edx
jne 0x3acd
leaq 0xc25(%rip), %rsi       # 0x46ca
movl $0x5, %edi
xorl %eax, %eax
callq 0x2050
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x343c
leaq 0xc2f(%rip), %rsi       # 0x4703
movl $0x5, %edi
xorl %eax, %eax
callq 0x2050
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3558
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  boostNgrams = 1.0;
  dim = 100;
  ws = 5;
  dropoutK = 0;
  epoch = 5;
  minCount = 5;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::transgram;
  bucket = 2000000;
  bucketChar = 1;
  minn = 0;
  maxn = 0;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
  saveOutput = 0;
  maxVocabSize = -1;
  numCheckPoints = 1;
  qout = false;
  retrain = false;
  qnorm = false;
  cutoff = 0;
  dsub = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xe0(%rdi), %r15
leaq 0xf0(%rdi), %rbp
movq %rbp, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movb %al, 0xf0(%rdi)
leaq 0x108(%rdi), %r12
leaq 0x118(%rdi), %r14
movq %r14, 0x108(%rdi)
movq %rax, 0x110(%rdi)
movb %al, 0x118(%rdi)
movaps 0x192ec(%rip), %xmm0    # 0x1e010
movups %xmm0, 0x80(%rdi)
movl $0x5, 0xa0(%rdi)
movaps 0x192e4(%rip), %xmm0    # 0x1e020
movups %xmm0, 0xa8(%rdi)
movaps 0x192e6(%rip), %xmm0    # 0x1e030
movups %xmm0, 0xbc(%rdi)
movq %rax, 0xcc(%rdi)
movl $0xc, 0xd4(%rdi)
movaps 0x192d7(%rip), %xmm0    # 0x1e040
movups %xmm0, 0x90(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xd8(%rdi)
leaq 0x192c8(%rip), %rcx     # 0x1e050
movl $0x9, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x44b0
movl $0x2, 0x100(%rbx)
movq 0x110(%rbx), %rdx
leaq 0x1aaa4(%rip), %rcx     # 0x1f856
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44b0
movl $0x0, 0x128(%rbx)
movl $0xffffffff, 0xa4(%rbx) # imm = 0xFFFFFFFF
movl $0x1, 0xb8(%rbx)
movw $0x0, 0x12c(%rbx)
movb $0x0, 0x12e(%rbx)
movq $0x0, 0x130(%rbx)
movq $0x2, 0x138(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x4e2b
movq (%r14), %rsi
incq %rsi
callq 0x4300
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x4e3f
movq (%rbp), %rsi
incq %rsi
callq 0x4300
movq 0x60(%rbx), %rdi
cmpq %r13, %rdi
je 0x4e54
movq (%r13), %rsi
incq %rsi
callq 0x4300
movq 0x40(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x4e6f
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4e8a
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x4ea4
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rsp), %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int32_t Dictionary::find(const std::string& w) const {
  int32_t h = hash(w) % MAX_VOCAB_SIZE;
  while (word2int_[h] != -1 && words_[word2int_[h]].word != w) {
    h = (h + 1) % MAX_VOCAB_SIZE;
  }
  return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x637e
movq (%rsi), %rax
movl $0x811c9dc5, %ebx       # imm = 0x811C9DC5
xorl %ecx, %ecx
movsbl (%rax,%rcx), %edx
xorl %ebx, %edx
imull $0x1000193, %edx, %ebx  # imm = 0x1000193
incq %rcx
cmpq %rcx, %r14
jne 0x6350
movl %ebx, %eax
shrl $0x7, %eax
imulq $0x11e54c7, %rax, %rax  # imm = 0x11E54C7
shrq $0x2a, %rax
imull $0x1c9c380, %eax, %eax  # imm = 0x1C9C380
subl %eax, %ebx
jmp 0x6383
movl $0x5da1c5, %ebx         # imm = 0x5DA1C5
movq 0x10(%rdi), %r12
movl %ebx, %eax
movl (%r12,%rax,4), %eax
cmpl $-0x1, %eax
je 0x63de
movq 0x28(%rdi), %r13
movq (%rsi), %r15
xorl %ebp, %ebp
cltq
leaq (%rax,%rax,8), %rax
cmpq %r14, 0x8(%r13,%rax,8)
jne 0x63ca
testq %r14, %r14
je 0x63de
leaq (,%rax,8), %rax
addq %r13, %rax
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4320
testl %eax, %eax
je 0x63de
incl %ebx
cmpl $0x1c9c380, %ebx        # imm = 0x1C9C380
cmovel %ebp, %ebx
movl (%r12,%rbx,4), %eax
cmpl $-0x1, %eax
jne 0x639b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
uint32_t Dictionary::hash(const std::string& str) const {
  uint32_t h = 2166136261;
  for (size_t i = 0; i < str.size(); i++) {
    h = h ^ uint32_t(str[i]);
    h = h * 16777619;
  }
  return h;
}

// Assembly:
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x6418
movq (%rsi), %rdx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %esi, %esi
movsbl (%rdx,%rsi), %edi
xorl %eax, %edi
imull $0x1000193, %edi, %eax  # imm = 0x1000193
incq %rsi
cmpq %rsi, %rcx
jne 0x6403
retq
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
retq
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Dictionary::add(const std::string& w) {
  int32_t h = find(w);
  ntokens_++;
  if (word2int_[h] == -1) {
    entry e;
    e.word = w;
    e.count = 1;
    e.type = getType(w);
    words_.push_back(e);
    word2int_[h] = size_++;
  } else {
    words_[word2int_[h]].count++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6332
incq 0x68(%rbx)
movl %eax, %r13d
movq 0x10(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq $-0x1, %rax
je 0x645d
movq 0x28(%rbx), %rcx
leaq (%rax,%rax,8), %rax
incq 0x20(%rcx,%rax,8)
jmp 0x6509
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movq %rax, 0x30(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x41a0
leaq 0x8(%rsp), %r15
movq $0x1, 0x20(%r15)
movq (%rbx), %rax
movq 0xe0(%rax), %rsi
movq 0xe8(%rax), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x45a0
testq %rax, %rax
sete 0x28(%r15)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0xa502
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
movq 0x10(%rbx), %rcx
movl %eax, (%rcx,%r13,4)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x64f2
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6509
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa52c
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::vector<int32_t> Dictionary::getNgrams(const std::string& word) const {
  int32_t i = getId(word);
  if (i >= 0) {
    return getNgrams(i);
  }
  std::vector<int32_t> ngrams;
  computeNgrams(BOW + word + EOW, ngrams);
  return ngrams;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x6332
movq 0x10(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %esi
testl %esi, %esi
js 0x6600
movq %r14, %rdi
callq 0x6562
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa560
jmp 0x66bd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x23d7b(%rip), %rsi     # 0x2a390
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0xa5e0
movq 0x23d87(%rip), %rsi     # 0x2a3b0
movq 0x23d88(%rip), %rdx     # 0x2a3b8
leaq 0x20(%rsp), %rdi
callq 0x4100
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6660
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6667
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6738
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x66a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66bd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x66e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x66e8
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6708
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x6708
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x671c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::computeNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&) const
void Dictionary::computeNgrams(const std::string& word,
                               std::vector<int32_t>& ngrams) const {
  for (size_t i = 0; i < word.size(); i++) {
    std::string ngram;
    if ((word[i] & 0xC0) == 0x80) continue;
    for (size_t j = i, n = 1; j < word.size() && n <= args_->maxn; n++) {
      ngram.push_back(word[j++]);
      while (j < word.size() && (word[j] & 0xC0) == 0x80) {
        ngram.push_back(word[j++]);
      }
      if (n >= args_->minn && !(n == 1 && (i == 0 || j == word.size()))) {
        int32_t h = hash(ngram) % args_->bucket;
        ngrams.push_back(nwords_ + h);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x68bd
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq %r13, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq (%r14), %rax
movb (%rax,%rbx), %al
andb $-0x40, %al
negb %al
jo 0x68b1
cmpq %rcx, %rbx
jae 0x68b1
movq (%r15), %rax
cmpl $0x0, 0xd0(%rax)
je 0x6891
movl $0x1, %ebp
movq %rbx, %r13
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movq %r12, %rdi
callq 0x4290
incq %r13
movq 0x8(%r14), %rcx
cmpq %rcx, %r13
jae 0x67ea
movq (%r14), %rax
movb (%rax,%r13), %al
movl %eax, %edx
andb $-0x40, %dl
negb %dl
jno 0x67ea
incq %r13
movsbl %al, %esi
movq %r12, %rdi
callq 0x4290
jmp 0x67c1
movq (%r15), %rsi
movslq 0xcc(%rsi), %rax
cmpq %rax, %rbp
jb 0x6876
testq %rbx, %rbx
sete %al
cmpq %rcx, %r13
sete %dl
cmpq $0x1, %rbp
jne 0x680f
orb %dl, %al
jne 0x6876
movq 0x18(%rsp), %rdx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
testq %rdx, %rdx
je 0x683d
movq 0x10(%rsp), %rdi
xorl %r8d, %r8d
movsbl (%rdi,%r8), %r9d
xorl %eax, %r9d
imull $0x1000193, %r9d, %eax  # imm = 0x1000193
incq %r8
cmpq %r8, %rdx
jne 0x6826
xorl %edx, %edx
divl 0xc4(%rsi)
addl 0x5c(%r15), %edx
movl %edx, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6868
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x6876
leaq 0xc(%rsp), %rdx
callq 0xb082
movq 0x8(%r14), %rcx
cmpq %rcx, %r13
jae 0x6891
incq %rbp
movq (%r15), %rax
movslq 0xd0(%rax), %rax
cmpq %rax, %rbp
jbe 0x67ae
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %r13
cmpq %r13, %rdi
je 0x68b1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x8(%r14), %rcx
incq %rbx
cmpq %rcx, %rbx
jb 0x676a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68d0
jmp 0x68d0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x68ef
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getNgrams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) const
void Dictionary::getNgrams(const std::string& word,
                           std::vector<int32_t>& ngrams,
                           std::vector<std::string>& substrings) const {
  int32_t i = getId(word);
  ngrams.clear();
  substrings.clear();
  if (i >= 0) {
    ngrams.push_back(i);
    substrings.push_back(words_[i].word);
  } else {
    ngrams.push_back(-1);
    substrings.push_back(word);
  }
  computeNgrams(BOW + word + EOW, ngrams, substrings);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x6332
movq 0x10(%r15), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %ebp
movl %ebp, 0x4(%rsp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x6931
movq %rax, 0x8(%r14)
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0xad04
testl %ebp, %ebp
js 0x6956
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x6978
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x698c
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x699d
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x69aa
leaq 0x4(%rsp), %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0xad56
movl (%r13), %ebp
movslq %ebp, %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq 0x28(%r15), %rsi
jmp 0x69ad
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xb082
movq %r12, %rsi
movq %rbx, %rdi
callq 0xa63a
leaq 0x239d4(%rip), %rsi     # 0x2a390
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0xa5e0
movq 0x239dd(%rip), %rsi     # 0x2a3b0
movq 0x239de(%rip), %rdx     # 0x2a3b8
movq %r13, %rdi
callq 0x4100
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6a0a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6a12
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6ac0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a6e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4300
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
jmp 0x6a9c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ab7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::bisent2vec) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x6cc7
cmpl %esi, 0x5c(%rdi)
jle 0x6ce6
movq (%rdi), %rax
cmpl $0x4, 0xc0(%rax)
jne 0x6cb8
xorl %eax, %eax
jmp 0x6cc5
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0x17edb(%rip), %rdi     # 0x1eba9
leaq 0x17c6a(%rip), %rsi     # 0x1e93f
leaq 0x17ccc(%rip), %rcx     # 0x1e9a8
movl $0x62, %edx
callq 0x41d0
leaq 0x17cf3(%rip), %rdi     # 0x1e9e0
leaq 0x17c4b(%rip), %rsi     # 0x1e93f
leaq 0x17cad(%rip), %rcx     # 0x1e9a8
movl $0x63, %edx
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::getVocab[abi:cxx11]() const
std::vector<std::string> Dictionary::getVocab() const {
  std::vector<std::string> vocab;
  for (auto& w : words_) {
    if (w.type == entry_type::word) vocab.push_back(w.word);
  }
  return vocab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
cmpq %r15, %r14
je 0x6e0b
cmpb $0x0, 0x28(%r14)
jne 0x6e05
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa63a
addq $0x48, %r14
jmp 0x6dee
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa678
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::initNgrams()
void Dictionary::initNgrams() {
  for (size_t i = 0; i < size_; i++) {
    std::string word = BOW + words_[i].word + EOW;
    words_[i].subwords.push_back(i);
    computeNgrams(word, words_[i].subwords);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, 0x58(%rdi)
je 0x7008
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movl $0x30, %ebp
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rbp), %rdx
addq $-0x30, %rdx
movq %r15, %rdi
leaq 0x23470(%rip), %rsi     # 0x2a390
callq 0xa5e0
movq 0x23484(%rip), %rsi     # 0x2a3b0
movq 0x23485(%rip), %rdx     # 0x2a3b8
movq %r15, %rdi
callq 0x4100
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6f5e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6f66
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6f9a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4300
movq 0x28(%rbx), %rdx
movl %r14d, 0x28(%rsp)
movq 0x8(%rdx,%rbp), %rsi
cmpq 0x10(%rdx,%rbp), %rsi
je 0x6fbd
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdx,%rbp)
jmp 0x6fcf
addq %rbp, %rdx
movq %rdx, %rdi
movq %r15, %rdx
callq 0xb082
movq 0x28(%rbx), %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6738
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6ff4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
incq %r14
movslq 0x58(%rbx), %rax
addq $0x48, %rbp
cmpq %rax, %r14
jb 0x6f0a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7032
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x704c
movq 0x38(%rsp), %rsi
jmp 0x7044
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x704c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]Bi-Sent2Vec/src/dictionary.cc
// Function: fasttext::Dictionary::readWord(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
bool Dictionary::readWord(std::istream& in, std::string& word) const
{
  char c;
  std::streambuf& sb = *in.rdbuf();
  word.clear();
  while ((c = sb.sbumpc()) != EOF) {
    if (c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\v' ||
        c == '\f' || c == '\0') {
      if (word.empty()) {
        if (c == '\n') {
          word += EOS;
          return true;
        }
        continue;
      } else {
        if (c == '\n')
          sb.sungetc();
        return true;
      }
    }
    word.push_back(c);
  }
  // trigger eofbit
  in.get();
  return !word.empty();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rbx
movq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq 0x10(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
jae 0x70f8
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rbx)
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x7103
movl %eax, %edx
andl $0xfb, %edx
cmpl $0x9, %edx
jne 0x70bd
cmpq $0x0, 0x8(%r14)
jne 0x7116
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x707e
jmp 0x7134
cmpl $0xaffffff, %ecx        # imm = 0xAFFFFFF
jle 0x70df
cmpl $0xb000000, %ecx        # imm = 0xB000000
je 0x70ac
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x70ac
cmpl $0xc000000, %ecx        # imm = 0xC000000
je 0x70ac
jmp 0x70eb
testl %ecx, %ecx
je 0x70ac
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x70ac
movsbl %al, %esi
movq %r14, %rdi
callq 0x4290
jmp 0x707e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
jmp 0x7092
movq %r15, %rdi
callq 0x4370
cmpq $0x0, 0x8(%r14)
setne %bpl
jmp 0x714d
movb $0x1, %bpl
cmpl $0xa000000, %ecx        # imm = 0xA000000
jne 0x714d
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
jae 0x715a
decq %rax
movq %rax, 0x10(%rbx)
jmp 0x714d
movq 0x23235(%rip), %rsi     # 0x2a370
movq 0x23236(%rip), %rdx     # 0x2a378
movq %r14, %rdi
callq 0x4100
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x46a0
jmp 0x714d