// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_hdmi_block(unsigned char const*, unsigned int)
void edid_state::cta_hdmi_block(const unsigned char *x, unsigned length)
{
	unsigned len_vic, len_3d;

	if (length < 4) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}
	printf("    Source physical address: %x.%x.%x.%x\n", x[3] >> 4, x[3] & 0x0f,
	       x[4] >> 4, x[4] & 0x0f);

	if (length < 6)
		return;

	if (x[5] & 0x80)
		printf("    Supports_AI\n");
	if (x[5] & 0x40)
		printf("    DC_48bit\n");
	if (x[5] & 0x20)
		printf("    DC_36bit\n");
	if (x[5] & 0x10)
		printf("    DC_30bit\n");
	if (x[5] & 0x08)
		printf("    DC_Y444\n");
	/* two reserved bits */
	if (x[5] & 0x01)
		printf("    DVI_Dual\n");

	if (length < 7)
		return;

	printf("    Maximum TMDS clock: %u MHz\n", x[6] * 5);
	if (x[6] * 5 > 340)
		fail("HDMI VSDB Max TMDS rate is > 340.\n");

	if (length < 8)
		return;

	if (x[7] & 0x0f) {
		printf("    Supported Content Types:\n");
		if (x[7] & 0x01)
			printf("      Graphics\n");
		if (x[7] & 0x02)
			printf("      Photo\n");
		if (x[7] & 0x04)
			printf("      Cinema\n");
		if (x[7] & 0x08)
			printf("      Game\n");
	}

	unsigned b = 8;
	if (x[7] & 0x80) {
		hdmi_latency(x[b], x[b + 1], false);

		if (x[7] & 0x40) {
			if (x[b] == x[b + 2] &&
			    x[b + 1] == x[b + 3])
				warn("Progressive and Interlaced latency values are identical, no need for both.\n");
			b += 2;
			hdmi_latency(x[b], x[b + 1], true);
		}
		b += 2;
	}

	if (!(x[7] & 0x20))
		return;

	bool mask = false;
	bool formats = false;

	printf("    Extended HDMI video details:\n");
	if (x[b] & 0x80)
		printf("      3D present\n");
	if ((x[b] & 0x60) == 0x20) {
		printf("      All advertised VICs are 3D-capable\n");
		formats = true;
	}
	if ((x[b] & 0x60) == 0x40) {
		printf("      3D-capable-VIC mask present\n");
		formats = true;
		mask = true;
	}
	switch (x[b] & 0x18) {
	case 0x00: break;
	case 0x08:
		   printf("      Base EDID image size is aspect ratio\n");
		   break;
	case 0x10:
		   printf("      Base EDID image size is in units of 1 cm\n");
		   break;
	case 0x18:
		   printf("      Base EDID image size is in units of 5 cm\n");
		   base.max_display_width_mm *= 5;
		   base.max_display_height_mm *= 5;
		   printf("        Recalculated image size: %u cm x %u cm\n",
			  base.max_display_width_mm / 10, base.max_display_height_mm / 10);
		   break;
	}
	b++;
	len_vic = (x[b] & 0xe0) >> 5;
	len_3d = (x[b] & 0x1f) >> 0;
	b++;

	if (len_vic) {
		unsigned i;

		printf("      HDMI VICs:\n");
		for (i = 0; i < len_vic; i++) {
			unsigned char vic = x[b + i];
			const struct timings *t;

			if (vic && vic <= ARRAY_SIZE(edid_hdmi_mode_map)) {
				std::string suffix = "HDMI VIC " + std::to_string(vic);
				cta.supported_hdmi_vic_codes |= 1 << (vic - 1);
				t = find_vic_id(edid_hdmi_mode_map[vic - 1]);
				print_timings("        ", t, suffix.c_str());
			} else {
				printf("         Unknown (HDMI VIC %u)\n", vic);
				fail("Unknown HDMI VIC %u.\n", vic);
			}
		}

		b += len_vic;
	}

	if (!len_3d)
		return;

	if (formats) {
		/* 3D_Structure_ALL_15..8 */
		if (x[b] & 0x80)
			printf("      3D: Side-by-side (half, quincunx)\n");
		if (x[b] & 0x01)
			printf("      3D: Side-by-side (half, horizontal)\n");
		/* 3D_Structure_ALL_7..0 */
		b++;
		if (x[b] & 0x40)
			printf("      3D: Top-and-bottom\n");
		if (x[b] & 0x20)
			printf("      3D: L + depth + gfx + gfx-depth\n");
		if (x[b] & 0x10)
			printf("      3D: L + depth\n");
		if (x[b] & 0x08)
			printf("      3D: Side-by-side (full)\n");
		if (x[b] & 0x04)
			printf("      3D: Line-alternative\n");
		if (x[b] & 0x02)
			printf("      3D: Field-alternative\n");
		if (x[b] & 0x01)
			printf("      3D: Frame-packing\n");
		b++;
		len_3d -= 2;
	}

	if (mask) {
		int max_idx = -1;
		unsigned i;

		printf("      3D VIC indices that support these capabilities:\n");
		/* worst bit ordering ever */
		for (i = 0; i < 8; i++)
			if (x[b + 1] & (1 << i)) {
				print_vic_index("        ", i, "");
				max_idx = i;
			}
		for (i = 0; i < 8; i++)
			if (x[b] & (1 << i)) {
				print_vic_index("        ", i + 8, "");
				max_idx = i + 8;
			}
		b += 2;
		len_3d -= 2;
		if (max_idx >= (int)cta.preparsed_svds[0].size())
			fail("HDMI 3D VIC indices max index %d > %u (#SVDs).\n",
			     max_idx + 1, cta.preparsed_svds[0].size());
	}

	/*
	 * list of nibbles:
	 * 2D_VIC_Order_X
	 * 3D_Structure_X
	 * (optionally: 3D_Detail_X and reserved)
	 */
	if (!len_3d)
		return;

	unsigned end = b + len_3d;
	int max_idx = -1;

	printf("      3D VIC indices with specific capabilities:\n");
	while (b < end) {
		unsigned char idx = x[b] >> 4;
		std::string s;

		if (idx > max_idx)
			max_idx = idx;
		switch (x[b] & 0x0f) {
		case 0: s = "frame packing"; break;
		case 1: s = "field alternative"; break;
		case 2: s = "line alternative"; break;
		case 3: s = "side-by-side (full)"; break;
		case 4: s = "L + depth"; break;
		case 5: s = "L + depth + gfx + gfx-depth"; break;
		case 6: s = "top-and-bottom"; break;
		case 8:
			s = "side-by-side";
			switch (x[b + 1] >> 4) {
			case 0x00: s += ", any subsampling"; break;
			case 0x01: s += ", horizontal"; break;
			case 0x02: case 0x03: case 0x04: case 0x05:
				   s += ", not in use";
				   fail("not-in-use 3D_Detail_X value 0x%02x.\n",
					x[b + 1] >> 4);
				   break;
			case 0x06: s += ", all quincunx combinations"; break;
			case 0x07: s += ", quincunx odd/left, odd/right"; break;
			case 0x08: s += ", quincunx odd/left, even/right"; break;
			case 0x09: s += ", quincunx even/left, odd/right"; break;
			case 0x0a: s += ", quincunx even/left, even/right"; break;
			default:
				   s += ", reserved";
				   fail("reserved 3D_Detail_X value 0x%02x.\n",
					x[b + 1] >> 4);
				   break;
			}
			break;
		default:
			s = "unknown (";
			s += utohex(x[b] & 0x0f) + ")";
			fail("Unknown 3D_Structure_X value 0x%02x.\n", x[b] & 0x0f);
			break;
		}
		print_vic_index("        ", idx, s.c_str());
		if ((x[b] & 0x0f) >= 8)
			b++;
		b++;
	}
	if (max_idx >= (int)cta.preparsed_svds[0].size())
		fail("HDMI 2D VIC indices max index %d > %u (#SVDs).\n",
		     max_idx + 1, cta.preparsed_svds[0].size());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebp
cmpl $0x3, %edx
ja 0xf5c1
leaq 0x1ab82(%rip), %rsi     # 0x2a127
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37ec
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x3(%rsi), %edx
movl %edx, %esi
shrl $0x4, %esi
andl $0xf, %edx
movzbl 0x4(%r14), %r8d
movl %r8d, %ecx
shrl $0x4, %ecx
andl $0xf, %r8d
leaq 0x1acee(%rip), %rdi     # 0x2a2d7
xorl %eax, %eax
callq 0x3030
cmpl $0x6, %ebp
jb 0xff2b
cmpb $0x0, 0x5(%r14)
jns 0xf60c
leaq 0x1df98(%rip), %rdi     # 0x2d59f
callq 0x3380
testb $0x40, 0x5(%r14)
je 0xf61f
leaq 0x1df95(%rip), %rdi     # 0x2d5af
callq 0x3380
testb $0x20, 0x5(%r14)
je 0xf632
leaq 0x1df8f(%rip), %rdi     # 0x2d5bc
callq 0x3380
testb $0x10, 0x5(%r14)
je 0xf645
leaq 0x1df89(%rip), %rdi     # 0x2d5c9
callq 0x3380
testb $0x8, 0x5(%r14)
je 0xf658
leaq 0x1df83(%rip), %rdi     # 0x2d5d6
callq 0x3380
testb $0x1, 0x5(%r14)
je 0xf66b
leaq 0x1df7c(%rip), %rdi     # 0x2d5e2
callq 0x3380
cmpl $0x6, %ebp
je 0xff2b
movzbl 0x6(%r14), %eax
leal (%rax,%rax,4), %esi
leaq 0x1ac7e(%rip), %rdi     # 0x2a301
xorl %eax, %eax
callq 0x3030
cmpb $0x45, 0x6(%r14)
jb 0xf6a1
leaq 0x1ac89(%rip), %rsi     # 0x2a321
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
cmpl $0x8, %ebp
jb 0xff2b
testb $0xf, 0x7(%r14)
je 0xf709
leaq 0x1df37(%rip), %rdi     # 0x2d5ef
callq 0x3380
testb $0x1, 0x7(%r14)
je 0xf6d0
leaq 0x1df41(%rip), %rdi     # 0x2d60c
callq 0x3380
testb $0x2, 0x7(%r14)
je 0xf6e3
leaq 0x1df3d(%rip), %rdi     # 0x2d61b
callq 0x3380
testb $0x4, 0x7(%r14)
je 0xf6f6
leaq 0x1df36(%rip), %rdi     # 0x2d627
callq 0x3380
testb $0x8, 0x7(%r14)
je 0xf709
leaq 0x1df30(%rip), %rdi     # 0x2d634
callq 0x3380
movl $0x8, %ebx
cmpb $0x0, 0x7(%r14)
jns 0xf772
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
xorl %ecx, %ecx
callq 0xf2a6
movl $0xa, %ebx
testb $0x40, 0x7(%r14)
je 0xf772
movb 0x8(%r14), %al
cmpb 0xa(%r14), %al
jne 0xf759
movb 0x9(%r14), %al
cmpb 0xb(%r14), %al
jne 0xf759
leaq 0x1abf7(%rip), %rsi     # 0x2a344
movl $0x1, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0xa(%r14), %esi
movzbl 0xb(%r14), %edx
movl $0x1, %ecx
callq 0xf2a6
movl $0xc, %ebx
testb $0x20, 0x7(%r14)
je 0xff2b
leaq 0x1debb(%rip), %rdi     # 0x2d63f
callq 0x3380
movl %ebx, %r13d
cmpb $0x0, (%r14,%r13)
jns 0xf79f
leaq 0x1dec6(%rip), %rdi     # 0x2d660
callq 0x3380
movb (%r14,%r13), %al
andb $0x60, %al
cmpb $0x20, %al
sete 0x12(%rsp)
jne 0xf7ba
leaq 0x1debc(%rip), %rdi     # 0x2d671
callq 0x3380
movb (%r14,%r13), %bl
andb $0x60, %bl
cmpb $0x40, %bl
jne 0xf7d7
leaq 0x1decd(%rip), %rdi     # 0x2d69a
callq 0x3380
movb $0x1, 0x12(%rsp)
movzbl (%r14,%r13), %eax
shrl $0x3, %eax
andl $0x3, %eax
leaq 0x1702f(%rip), %rcx     # 0x26818
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1def2(%rip), %rdi     # 0x2d6eb
jmp 0xf802
leaq 0x1deba(%rip), %rdi     # 0x2d6bc
callq 0x3380
jmp 0xf85a
leaq 0x1df06(%rip), %rdi     # 0x2d716
callq 0x3380
movl 0x174(%r15), %eax
movl 0x178(%r15), %ecx
leal (%rax,%rax,4), %esi
movl %esi, 0x174(%r15)
leal (%rcx,%rcx,4), %edx
movl %edx, 0x178(%r15)
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rax, %rsi
shrq $0x23, %rsi
imulq %rax, %rdx
shrq $0x23, %rdx
leaq 0x1ab3d(%rip), %rdi     # 0x2a390
xorl %eax, %eax
callq 0x3030
movzbl 0x1(%r14,%r13), %eax
addq $0x2, %r13
cmpb $0x20, %al
movq %r15, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jb 0xfa38
movb %bl, 0x13(%rsp)
movq %r14, %r12
movl %eax, %r14d
shrl $0x5, %r14d
leaq 0x1debb(%rip), %rdi     # 0x2d745
callq 0x3380
leaq 0x30(%rsp), %r15
movq %r13, 0x60(%rsp)
movq %r13, %rbx
movq %r12, 0x68(%rsp)
addq %r12, %rbx
xorl %r13d, %r13d
movq %r14, 0x70(%rsp)
movzbl (%rbx,%r13), %ebp
leal -0x1(%rbp), %eax
cmpb $0x3, %al
ja 0xf946
cmpb $0x64, %bpl
movl $0x3, %r12d
sbbl $0x0, %r12d
cmpb $0xa, %bpl
movl $0x1, %eax
cmovbl %eax, %r12d
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl $0x2d, %edx
callq 0x32a0
movq 0x40(%rsp), %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x8c91
movl $0x9, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1aaa7(%rip), %rcx     # 0x2a3c0
callq 0x3290
movq %r15, 0x20(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq 0x18(%rsp), %r12
je 0xf96d
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xf974
leaq 0x1aa7d(%rip), %rdi     # 0x2a3ca
movl %ebp, %esi
xorl %eax, %eax
callq 0x3030
xorl %edi, %edi
leaq 0x1aa8b(%rip), %rsi     # 0x2a3ea
movl %ebp, %edx
xorl %eax, %eax
callq 0x37ec
jmp 0xfa1b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xf9a8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
decl %ebp
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orl %eax, 0x2d8(%r12)
leaq 0x1a5a6(%rip), %rax     # 0x29f68
movzbl (%rbp,%rax), %eax
imulq $0x54, %rax, %rax
leaq 0x170fe(%rip), %rcx     # 0x26ad0
leaq (%rax,%rcx), %rdx
addq $-0x54, %rdx
movq 0x20(%rsp), %rcx
movl $0x1, (%rsp)
movq %r12, %rdi
leaq 0x15a53(%rip), %rsi     # 0x25443
leaq 0x11282(%rip), %r8      # 0x20c79
xorl %r9d, %r9d
callq 0x3ebe
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
movq 0x70(%rsp), %r14
je 0xfa1b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
incq %r13
cmpq %r13, %r14
jne 0xf8ac
addl 0x60(%rsp), %r14d
movl %r14d, %r13d
movb 0x13(%rsp), %bl
movq 0x68(%rsp), %r14
movl 0x14(%rsp), %r12d
andl $0x1f, %r12d
je 0xff2b
cmpb $0x0, 0x12(%rsp)
je 0xfb13
movl %ebx, %ebp
movl %r13d, %ebx
cmpb $0x0, (%r14,%rbx)
jns 0xfa6a
leaq 0x1dcf1(%rip), %rdi     # 0x2d756
callq 0x3380
testb $0x1, (%r14,%rbx)
je 0xfa7d
leaq 0x1dd06(%rip), %rdi     # 0x2d77e
callq 0x3380
testb $0x40, 0x1(%r14,%rbx)
je 0xfa91
leaq 0x1dd1c(%rip), %rdi     # 0x2d7a8
callq 0x3380
testb $0x20, 0x1(%r14,%rbx)
je 0xfaa5
leaq 0x1dd21(%rip), %rdi     # 0x2d7c1
callq 0x3380
testb $0x10, 0x1(%r14,%rbx)
je 0xfab9
leaq 0x1dd33(%rip), %rdi     # 0x2d7e7
callq 0x3380
testb $0x8, 0x1(%r14,%rbx)
je 0xfacd
leaq 0x1dd33(%rip), %rdi     # 0x2d7fb
callq 0x3380
testb $0x4, 0x1(%r14,%rbx)
je 0xfae1
leaq 0x1dd3d(%rip), %rdi     # 0x2d819
callq 0x3380
testb $0x2, 0x1(%r14,%rbx)
je 0xfaf5
leaq 0x1dd44(%rip), %rdi     # 0x2d834
callq 0x3380
testb $0x1, 0x1(%r14,%rbx)
je 0xfb09
leaq 0x1dd4c(%rip), %rdi     # 0x2d850
callq 0x3380
addl $0x2, %r13d
addl $-0x2, %r12d
movl %ebp, %ebx
cmpb $0x40, %bl
jne 0xfbf4
movl %r12d, 0x14(%rsp)
leaq 0x1dd40(%rip), %rdi     # 0x2d868
callq 0x3380
movq %r13, 0x60(%rsp)
movl %r13d, %ebx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq 0x158ff(%rip), %r12     # 0x25443
leaq 0x1112e(%rip), %r13     # 0x20c79
movzbl 0x1(%r14,%rbx), %eax
btl %r15d, %eax
jae 0xfb70
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movl %r15d, %edx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xea8c
movl %r15d, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0xfb4b
xorl %r13d, %r13d
leaq 0x158c0(%rip), %r15     # 0x25443
leaq 0x110ef(%rip), %r12     # 0x20c79
movzbl (%r14,%rbx), %eax
btl %r13d, %eax
jae 0xfbae
leal 0x8(%r13), %ebp
movq 0x18(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xea8c
incl %r13d
cmpl $0x8, %r13d
jne 0xfb8a
movq 0x60(%rsp), %r13
addl $0x2, %r13d
movl 0x14(%rsp), %r12d
addl $-0x2, %r12d
movq 0x18(%rsp), %rax
movq 0x8e8(%rax), %rcx
subq 0x8e0(%rax), %rcx
cmpl %ecx, %ebp
jl 0xfbf4
incl %ebp
leaq 0x1a817(%rip), %rsi     # 0x2a400
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x37ec
testl %r12d, %r12d
je 0xff2b
addl %r13d, %r12d
leaq 0x1dc97(%rip), %rdi     # 0x2d89e
callq 0x3380
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl %r12d, %r13d
jae 0xff00
movl %r13d, %r13d
movq %r13, %r15
movzbl (%r14,%r13), %eax
movl %eax, %r13d
shrl $0x4, %r13d
leaq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
cmpl %r13d, %ebp
cmovlel %r13d, %ebp
andl $0xf, %eax
cmpl $0x8, %eax
ja 0xfc75
leaq 0x16bce(%rip), %rcx     # 0x26828
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, %r8d
leaq 0x1a7c0(%rip), %rcx     # 0x2a430
jmp 0xfdaf
movl $0x9, %r8d
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1a923(%rip), %rcx     # 0x2a5ae
callq 0x3390
movzbl (%r14,%r15), %esi
andl $0xf, %esi
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x59df
movq %rbx, %rdi
leaq 0x1cbd6(%rip), %rsi     # 0x2c885
callq 0x3420
leaq 0x50(%rsp), %rsi
movq %rsi, 0x40(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfe0e
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0xfe14
movl $0x1b, %r8d
leaq 0x1dadb(%rip), %rcx     # 0x2d7cb
jmp 0xfdaf
movl $0x11, %r8d
leaq 0x1a73c(%rip), %rcx     # 0x2a43e
jmp 0xfdaf
movl $0xe, %r8d
leaq 0x1a761(%rip), %rcx     # 0x2a475
jmp 0xfdaf
movl $0xc, %r8d
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1a755(%rip), %rcx     # 0x2a484
callq 0x3390
leal 0x1(%r15), %ebx
movzbl (%r14,%rbx), %eax
shrl $0x4, %eax
cmpl $0xa, %eax
ja 0xfedf
leaq 0x16afc(%rip), %rcx     # 0x2684c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x1a733(%rip), %rsi     # 0x2a491
jmpq *%rax
leaq 0x20(%rsp), %rdi
leaq 0x1a744(%rip), %rsi     # 0x2a4b0
callq 0x3420
movb (%r14,%rbx), %al
shrb $0x4, %al
leaq 0x1a73e(%rip), %rsi     # 0x2a4bd
jmp 0xfe8b
movl $0x10, %r8d
leaq 0x1a6bf(%rip), %rcx     # 0x2a450
jmp 0xfdaf
movl $0x13, %r8d
leaq 0x1a6c1(%rip), %rcx     # 0x2a461
jmp 0xfdaf
movl $0x9, %r8d
leaq 0x1da42(%rip), %rcx     # 0x2d7f1
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdi
leaq 0x15675(%rip), %rsi     # 0x25443
movl %r13d, %edx
xorl %r8d, %r8d
callq 0xea8c
movq %r15, %r13
movzbl (%r14,%r15), %eax
btl $0x3, %eax
adcl $0x1, %r13d
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xfc11
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xfc11
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x30b0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xfe5c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0xfe7e
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3260
movb (%r14,%r15), %al
andb $0xf, %al
leaq 0x1a72d(%rip), %rsi     # 0x2a5b8
movzbl %al, %edx
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0xfdbd
leaq 0x1a69b(%rip), %rsi     # 0x2a53e
jmp 0xfed0
leaq 0x1a653(%rip), %rsi     # 0x2a4ff
jmp 0xfed0
leaq 0x1a5ee(%rip), %rsi     # 0x2a4a3
jmp 0xfed0
leaq 0x1a625(%rip), %rsi     # 0x2a4e3
jmp 0xfed0
leaq 0x1a697(%rip), %rsi     # 0x2a55e
jmp 0xfed0
leaq 0x1a64e(%rip), %rsi     # 0x2a51e
leaq 0x20(%rsp), %rdi
callq 0x3420
jmp 0xfdbd
leaq 0x20(%rsp), %rdi
leaq 0x1a694(%rip), %rsi     # 0x2a57f
callq 0x3420
movb (%r14,%rbx), %al
shrb $0x4, %al
leaq 0x1a68c(%rip), %rsi     # 0x2a58a
jmp 0xfe8b
movq 0x18(%rsp), %rax
movq 0x8e8(%rax), %rcx
subq 0x8e0(%rax), %rcx
cmpl %ecx, %ebp
jl 0xff2b
incl %ebp
leaq 0x1a6be(%rip), %rsi     # 0x2a5de
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x37ec
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xff61
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xff61
movq %rax, %rbx
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0xffb2
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xffb2
jmp 0xffaf
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xffce
movq 0x50(%rsp), %rsi
jmp 0xffc6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
jne 0xffc1
jmp 0xffce
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xffce
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400