// File: /workspace/github_cpp_makefile_star2_O3/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 $0x88, %rsp
movl %edx, %ebp
cmpl $0x3, %edx
ja 0xf423
leaq 0x1ad48(%rip), %rsi     # 0x2a14f
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
movq %rsi, %r14
movq %rdi, %r12
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 0x1aeb4(%rip), %rdi     # 0x2a2ff
xorl %eax, %eax
callq 0x3030
cmpl $0x6, %ebp
jb 0xfd9e
movb 0x5(%r14), %al
testb %al, %al
jns 0xf473
leaq 0x1e15d(%rip), %rdi     # 0x2d5c7
callq 0x3380
movb 0x5(%r14), %al
testb $0x40, %al
je 0xf487
leaq 0x1e159(%rip), %rdi     # 0x2d5d7
callq 0x3380
movb 0x5(%r14), %al
testb $0x20, %al
je 0xf49b
leaq 0x1e152(%rip), %rdi     # 0x2d5e4
callq 0x3380
movb 0x5(%r14), %al
testb $0x10, %al
je 0xf4af
leaq 0x1e14b(%rip), %rdi     # 0x2d5f1
callq 0x3380
movb 0x5(%r14), %al
testb $0x8, %al
je 0xf4c3
leaq 0x1e144(%rip), %rdi     # 0x2d5fe
callq 0x3380
movb 0x5(%r14), %al
testb $0x1, %al
je 0xf4d3
leaq 0x1e13c(%rip), %rdi     # 0x2d60a
callq 0x3380
cmpl $0x6, %ebp
je 0xfd9e
movzbl 0x6(%r14), %eax
leal (%rax,%rax,4), %esi
leaq 0x1ae3e(%rip), %rdi     # 0x2a329
xorl %eax, %eax
callq 0x3030
cmpb $0x45, 0x6(%r14)
jb 0xf509
leaq 0x1ae49(%rip), %rsi     # 0x2a349
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
cmpl $0x8, %ebp
jb 0xfd9e
movb 0x7(%r14), %al
testb $0xf, %al
je 0xf57a
leaq 0x1e0f6(%rip), %rdi     # 0x2d617
callq 0x3380
movb 0x7(%r14), %al
testb $0x1, %al
je 0xf53e
leaq 0x1e0ff(%rip), %rdi     # 0x2d634
callq 0x3380
movb 0x7(%r14), %al
testb $0x2, %al
je 0xf552
leaq 0x1e0fa(%rip), %rdi     # 0x2d643
callq 0x3380
movb 0x7(%r14), %al
testb $0x4, %al
je 0xf566
leaq 0x1e0f2(%rip), %rdi     # 0x2d64f
callq 0x3380
movb 0x7(%r14), %al
testb $0x8, %al
je 0xf57a
leaq 0x1e0eb(%rip), %rdi     # 0x2d65c
callq 0x3380
movb 0x7(%r14), %al
movl $0x8, %ebx
testb %al, %al
jns 0xf5eb
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
xorl %ecx, %ecx
callq 0xf100
movb 0x7(%r14), %al
movl $0xa, %ebx
testb $0x40, %al
je 0xf5eb
movb 0x8(%r14), %cl
movb 0xa(%r14), %al
cmpb %al, %cl
jne 0xf5d0
movb 0x9(%r14), %dl
movl %ecx, %eax
cmpb 0xb(%r14), %dl
jne 0xf5d0
leaq 0x1adac(%rip), %rsi     # 0x2a36c
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
movb 0xa(%r14), %al
movzbl 0xb(%r14), %edx
movzbl %al, %esi
movl $0x1, %ecx
callq 0xf100
movb 0x7(%r14), %al
movl $0xc, %ebx
testb $0x20, %al
je 0xfd9e
leaq 0x1e06d(%rip), %rdi     # 0x2d667
callq 0x3380
movl %ebx, %r13d
movb (%r14,%r13), %al
testb %al, %al
jns 0xf61a
leaq 0x1e077(%rip), %rdi     # 0x2d688
callq 0x3380
movb (%r14,%r13), %al
movl %eax, %ecx
andb $0x60, %cl
cmpb $0x20, %cl
sete %bpl
jne 0xf638
leaq 0x1e06a(%rip), %rdi     # 0x2d699
callq 0x3380
movb (%r14,%r13), %al
movl %eax, %ebx
andb $0x60, %bl
cmpb $0x40, %bl
jne 0xf655
leaq 0x1e079(%rip), %rdi     # 0x2d6c2
callq 0x3380
movb (%r14,%r13), %al
movb $0x1, %bpl
movb %bpl, 0xb(%rsp)
shrb $0x3, %al
andb $0x3, %al
movzbl %al, %eax
leaq 0x171c7(%rip), %rcx     # 0x26830
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1e09a(%rip), %rdi     # 0x2d713
jmp 0xf682
leaq 0x1e062(%rip), %rdi     # 0x2d6e4
callq 0x3380
jmp 0xf6de
leaq 0x1e0ae(%rip), %rdi     # 0x2d73e
callq 0x3380
movl 0x174(%r12), %eax
movl 0x178(%r12), %ecx
leal (%rax,%rax,4), %esi
movl %esi, 0x174(%r12)
leal (%rcx,%rcx,4), %edx
movl %edx, 0x178(%r12)
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rax, %rsi
shrq $0x23, %rsi
imulq %rax, %rdx
shrq $0x23, %rdx
leaq 0x1ace1(%rip), %rdi     # 0x2a3b8
xorl %eax, %eax
callq 0x3030
movzbl 0x1(%r14,%r13), %r15d
addq $0x2, %r13
cmpb $0x20, %r15b
jb 0xf8ad
movb %bl, 0xa(%rsp)
movq %r12, 0x58(%rsp)
movl %r15d, 0xc(%rsp)
movl %r15d, %ebx
shrl $0x5, %ebx
leaq 0x1e060(%rip), %rdi     # 0x2d76d
callq 0x3380
movq %r13, %r12
leaq 0x20(%rsp), %r13
movq %r12, 0x50(%rsp)
addq %r14, %r12
xorl %r15d, %r15d
movq %r14, 0x60(%rsp)
movzbl (%r12,%r15), %ebp
leal -0x1(%rbp), %eax
cmpb $0x3, %al
ja 0xf7b0
movq %rbx, %r14
movq %r12, %rbx
movq %r13, %r12
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, %esi
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x32a0
movq 0x30(%rsp), %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x8a6d
movl $0x9, %r8d
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1ac63(%rip), %rcx     # 0x2a3e8
callq 0x3290
movq %r12, %r13
movq %r12, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xf7d7
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0xf7df
leaq 0x1ac3b(%rip), %rdi     # 0x2a3f2
movl %ebp, %esi
xorl %eax, %eax
callq 0x3030
xorl %edi, %edi
leaq 0x1ac49(%rip), %rsi     # 0x2a412
movl %ebp, %edx
xorl %eax, %eax
callq 0x37cc
jmp 0xf88c
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq %rbx, %r12
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
movq %r14, %rbx
je 0xf819
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3260
decl %ebp
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movq 0x58(%rsp), %rdi
orl %eax, 0x2d8(%rdi)
leaq 0x1a75a(%rip), %rax     # 0x29f90
movzbl (%rbp,%rax), %eax
imulq $0x54, %rax, %rax
leaq 0x172aa(%rip), %rcx     # 0x26af0
leaq (%rax,%rcx), %rdx
addq $-0x54, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, (%rsp)
leaq 0x15c32(%rip), %rsi     # 0x25493
leaq 0x11421(%rip), %r8      # 0x20c89
xorl %r9d, %r9d
callq 0x3e8c
movq 0x60(%rsp), %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xf88c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
incq %r15
cmpq %r15, %rbx
jne 0xf72a
addl 0x50(%rsp), %ebx
movl %ebx, %r13d
movq 0x58(%rsp), %r12
movl 0xc(%rsp), %r15d
movb 0xa(%rsp), %bl
andl $0x1f, %r15d
je 0xfd9e
cmpb $0x0, 0xb(%rsp)
je 0xf98c
movl %ebx, %ebp
movl %r13d, %ebx
movb (%r14,%rbx), %al
testb %al, %al
jns 0xf8df
leaq 0x1dea8(%rip), %rdi     # 0x2d77e
callq 0x3380
movb (%r14,%rbx), %al
testb $0x1, %al
je 0xf8ef
leaq 0x1debc(%rip), %rdi     # 0x2d7a6
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x40, %al
je 0xf909
leaq 0x1ded1(%rip), %rdi     # 0x2d7d0
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x20, %al
je 0xf91e
leaq 0x1ded5(%rip), %rdi     # 0x2d7e9
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x10, %al
je 0xf933
leaq 0x1dee6(%rip), %rdi     # 0x2d80f
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x8, %al
je 0xf948
leaq 0x1dee5(%rip), %rdi     # 0x2d823
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x4, %al
je 0xf95d
leaq 0x1deee(%rip), %rdi     # 0x2d841
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x2, %al
je 0xf972
leaq 0x1def4(%rip), %rdi     # 0x2d85c
callq 0x3380
movb 0x1(%r14,%rbx), %al
testb $0x1, %al
je 0xf982
leaq 0x1defb(%rip), %rdi     # 0x2d878
callq 0x3380
addl $0x2, %r13d
addl $-0x2, %r15d
movl %ebp, %ebx
cmpb $0x40, %bl
jne 0xfa64
movl %r15d, 0xc(%rsp)
movq %r12, %rbx
leaq 0x1deec(%rip), %rdi     # 0x2d890
callq 0x3380
movq %r13, 0x50(%rsp)
movl %r13d, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq 0x112c9(%rip), %r13     # 0x20c89
movzbl 0x1(%r14,%r12), %eax
btl %r15d, %eax
jae 0xf9e7
movq %rbx, %rdi
leaq 0x15abd(%rip), %rsi     # 0x25493
movl %r15d, %edx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xe91e
movl %r15d, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0xf9c0
xorl %r13d, %r13d
leaq 0x1128f(%rip), %r15     # 0x20c89
movzbl (%r14,%r12), %eax
btl %r13d, %eax
jae 0xfa20
leal 0x8(%r13), %ebp
movq %rbx, %rdi
leaq 0x15a80(%rip), %rsi     # 0x25493
movl %ebp, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe91e
incl %r13d
cmpl $0x8, %r13d
jne 0xf9fa
movq 0x50(%rsp), %r13
addl $0x2, %r13d
movl 0xc(%rsp), %r15d
addl $-0x2, %r15d
movq %rbx, %r12
movq 0x8e8(%rbx), %rcx
subq 0x8e0(%rbx), %rcx
cmpl %ecx, %ebp
jl 0xfa64
incl %ebp
leaq 0x1a9cf(%rip), %rsi     # 0x2a428
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x37cc
testl %r15d, %r15d
je 0xfd9e
addl %r13d, %r15d
leaq 0x1de4f(%rip), %rdi     # 0x2d8c6
callq 0x3380
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl %r15d, %r13d
jae 0xfd76
movl %r15d, 0xc(%rsp)
movl %r13d, %r13d
movq %r13, %r15
movzbl (%r14,%r13), %eax
movl %eax, %r13d
shrl $0x4, %r13d
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
cmpl %r13d, %ebp
cmovlel %r13d, %ebp
andl $0xf, %eax
cmpl $0x8, %eax
ja 0xfaea
leaq 0x16d71(%rip), %rcx     # 0x26840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, %r8d
leaq 0x1a973(%rip), %rcx     # 0x2a458
jmp 0xfc22
movl $0x9, %r8d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1aad6(%rip), %rcx     # 0x2a5d6
callq 0x3390
movzbl (%r14,%r15), %esi
andl $0xf, %esi
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x59f2
movq %rbx, %rdi
leaq 0x1cd89(%rip), %rsi     # 0x2c8ad
callq 0x3420
leaq 0x40(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfc89
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0xfc8f
movl $0x1b, %r8d
leaq 0x1dc8e(%rip), %rcx     # 0x2d7f3
jmp 0xfc22
movl $0x11, %r8d
leaq 0x1a8ef(%rip), %rcx     # 0x2a466
jmp 0xfc22
movl $0xe, %r8d
leaq 0x1a914(%rip), %rcx     # 0x2a49d
jmp 0xfc22
movl $0xc, %r8d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1a908(%rip), %rcx     # 0x2a4ac
callq 0x3390
movzbl 0x1(%r15,%r14), %eax
shrl $0x4, %eax
cmpl $0xa, %eax
ja 0xfd54
leaq 0x16ca2(%rip), %rcx     # 0x26864
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x1a8e9(%rip), %rsi     # 0x2a4b9
jmpq *%rax
leaq 0x10(%rsp), %rdi
leaq 0x1a8fa(%rip), %rsi     # 0x2a4d8
callq 0x3420
movb 0x1(%r14,%r15), %al
shrb $0x4, %al
leaq 0x1a8f3(%rip), %rsi     # 0x2a4e5
jmp 0xfd00
movl $0x10, %r8d
leaq 0x1a874(%rip), %rcx     # 0x2a478
jmp 0xfc22
movl $0x13, %r8d
leaq 0x1a876(%rip), %rcx     # 0x2a489
jmp 0xfc22
movl $0x9, %r8d
leaq 0x1dbf7(%rip), %rcx     # 0x2d819
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
movq 0x10(%rsp), %rcx
movq %r12, %rdi
leaq 0x15854(%rip), %rsi     # 0x25493
movl %r13d, %edx
xorl %r8d, %r8d
callq 0xe91e
movq %r15, %r13
movzbl (%r14,%r15), %eax
btl $0x3, %eax
adcl $0x1, %r13d
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xfc76
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
movl 0xc(%rsp), %r15d
cmpl %r15d, %r13d
jb 0xfa8f
jmp 0xfd76
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x30b0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xfcd7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xfcf3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
movb (%r14,%r15), %al
andb $0xf, %al
leaq 0x1a8e0(%rip), %rsi     # 0x2a5e0
movzbl %al, %edx
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0xfc30
leaq 0x1a84e(%rip), %rsi     # 0x2a566
jmp 0xfd45
leaq 0x1a806(%rip), %rsi     # 0x2a527
jmp 0xfd45
leaq 0x1a7a1(%rip), %rsi     # 0x2a4cb
jmp 0xfd45
leaq 0x1a7d8(%rip), %rsi     # 0x2a50b
jmp 0xfd45
leaq 0x1a84a(%rip), %rsi     # 0x2a586
jmp 0xfd45
leaq 0x1a801(%rip), %rsi     # 0x2a546
leaq 0x10(%rsp), %rdi
callq 0x3420
jmp 0xfc30
leaq 0x10(%rsp), %rdi
leaq 0x1a847(%rip), %rsi     # 0x2a5a7
callq 0x3420
movb 0x1(%r14,%r15), %al
shrb $0x4, %al
leaq 0x1a83e(%rip), %rsi     # 0x2a5b2
jmp 0xfd00
movq 0x8e8(%r12), %rcx
subq 0x8e0(%r12), %rcx
cmpl %ecx, %ebp
jl 0xfd9e
incl %ebp
leaq 0x1a873(%rip), %rsi     # 0x2a606
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x37cc
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xfdd4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xfdd4
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xfe1f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xfe1f
jmp 0xfe1c
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xfe3b
movq 0x40(%rsp), %rsi
jmp 0xfe33
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
jne 0xfe2e
jmp 0xfe3b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xfe3b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
nop