LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/edid-decode.cpp
// Function: extract_edid_xorg(char const*)
static bool extract_edid_xorg(const char *start)
{
	bool find_first_num = true;

	for (; *start; start++) {
		if (find_first_num) {
			const char *s;

			/* skip ahead to the : */
			s = strstr(start, ": \t");
			if (!s)
				s = strstr(start, ":     ");
			if (!s)
				break;
			start = s;
			/* and find the first number */
			while (!isxdigit(start[1]))
				start++;
			find_first_num = false;
			continue;
		} else {
			/* Read a %02x from the log */
			if (!isxdigit(*start)) {
				find_first_num = true;
				continue;
			}
			if (!edid_add_byte(start))
				return false;
			start++;
		}
	}
	return state.edid_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x8442
movq %rdi, %rbx
movb $0x1, %al
leaq 0x18d14(%rip), %r14     # 0x210e1
leaq 0x18d11(%rip), %r15     # 0x210e5
testb $0x1, %al
je 0x8410
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3080
testq %rax, %rax
jne 0x83f8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3080
testq %rax, %rax
je 0x8442
movq %rax, %rbx
decq %rbx
movsbl 0x2(%rbx), %edi
callq 0x3090
incq %rbx
testl %eax, %eax
je 0x83fe
jmp 0x8430
movsbl %cl, %edi
callq 0x3090
testl %eax, %eax
je 0x843e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8456
testb %al, %al
je 0x8452
incq %rbx
xorl %eax, %eax
movb 0x1(%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x83d4
jmp 0x8442
movb $0x1, %al
jmp 0x8432
cmpl $0x0, 0x32297(%rip)     # 0x3a6e0
setne %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x844c
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/edid-decode.cpp
// Function: edid_add_byte(char const*, bool)
static bool edid_add_byte(const char *s, bool two_digits = true)
{
	char buf[3];

	if (state.edid_size == sizeof(edid))
		return false;
	buf[0] = s[0];
	buf[1] = two_digits ? s[1] : 0;
	buf[2] = 0;
	edid[state.edid_size++] = strtoul(buf, NULL, 16);
	return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x3227f(%rip), %ebx     # 0x3a6e0
cmpl $0x8000, %ebx           # imm = 0x8000
je 0x84ac
movb (%rdi), %al
movb %al, 0xd(%rsp)
testb %sil, %sil
je 0x8479
movb 0x1(%rdi), %al
jmp 0x847b
xorl %eax, %eax
leaq 0xd(%rsp), %rdi
movb %al, 0x1(%rdi)
movb $0x0, 0x2(%rdi)
xorl %esi, %esi
movl $0x10, %edx
callq 0x30c0
movl 0x32247(%rip), %ecx     # 0x3a6e0
leal 0x1(%rcx), %edx
movl %edx, 0x3223e(%rip)     # 0x3a6e0
leaq 0x36d07(%rip), %rdx     # 0x3f1b0
movb %al, (%rcx,%rdx)
cmpl $0x8000, %ebx           # imm = 0x8000
setne %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-base-block.cpp
// Function: close_match_to_dmt(timings const&, unsigned int&)
const struct timings *close_match_to_dmt(const timings &t, unsigned &dmt)
{
	for (unsigned i = 0; i < ARRAY_SIZE(dmt_timings); i++) {
		if (timings_close_match(t, dmt_timings[i].t)) {
			dmt = dmt_timings[i].dmt_id;
			return &dmt_timings[i].t;
		}
	}
	dmt = 0;
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x195a4(%rip), %r13     # 0x22570
leaq (%r12,%r13), %r15
addq $0xc, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d98
testb %al, %al
jne 0x8ff7
addq $0x60, %r12
cmpq $0x2100, %r12           # imm = 0x2100
jne 0x8fcc
xorl %eax, %eax
xorl %r15d, %r15d
jmp 0x8ffb
movl (%r12,%r13), %eax
movl %eax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-base-block.cpp
// Function: extract_string(unsigned char const*, unsigned int)
char *extract_string(const unsigned char *x, unsigned len)
{
	static char s[EDID_PAGE_SIZE];
	int seen_newline = 0;
	unsigned i;

	memset(s, 0, sizeof(s));

	for (i = 0; i < len; i++) {
		if (isgraph(x[i])) {
			s[i] = x[i];
		} else if (!seen_newline) {
			if (x[i] == 0x0a) {
				seen_newline = 1;
				if (!i)
					fail("Empty string.\n");
				else if (s[i - 1] == 0x20)
					fail("One or more trailing spaces.\n");
			} else if (x[i] == 0x20) {
				s[i] = x[i];
			} else {
				fail("Non-printable character.\n");
				return s;
			}
		} else if (x[i] != 0x20) {
			fail("Non-space after newline.\n");
			return s;
		}
	}
	/* Does the string end with a space? */
	if (!seen_newline && s[len - 1] == 0x20)
		fail("One or more trailing spaces.\n");

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x3d351(%rip)    # 0x47230
movaps %xmm0, 0x3d33a(%rip)    # 0x47220
movaps %xmm0, 0x3d323(%rip)    # 0x47210
movaps %xmm0, 0x3d30c(%rip)    # 0x47200
movaps %xmm0, 0x3d2f5(%rip)    # 0x471f0
movaps %xmm0, 0x3d2de(%rip)    # 0x471e0
movaps %xmm0, 0x3d2c7(%rip)    # 0x471d0
movaps %xmm0, 0x3d2b0(%rip)    # 0x471c0
movq %rsi, (%rsp)
testl %esi, %esi
je 0x9fd8
movq %rdi, %r14
movl (%rsp), %r13d
xorl %r15d, %r15d
xorl %ebx, %ebx
movb (%r14,%r15), %r12b
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x3220
testl %eax, %eax
je 0x9f48
leaq 0x3d27e(%rip), %rax     # 0x471c0
movb %r12b, (%r15,%rax)
jmp 0x9f5b
testl %ebx, %ebx
je 0x9f65
movl $0x1, %ebx
cmpb $0x20, %r12b
jne 0x9ff4
incq %r15
cmpq %r13, %r15
jne 0x9f28
jmp 0x9fd4
cmpl $0x20, %ebp
je 0x9f9e
cmpl $0xa, %ebp
jne 0x9ffd
testq %r15, %r15
je 0x9fbd
movl $0x1, %ebx
leaq 0x3d23c(%rip), %rax     # 0x471c0
cmpb $0x20, -0x1(%r15,%rax)
jne 0x9f5b
xorl %edi, %edi
leaq 0x1a8be(%rip), %rsi     # 0x24853
xorl %eax, %eax
callq 0x37cc
jmp 0x9f5b
leaq 0x3d21b(%rip), %rax     # 0x471c0
movb $0x20, (%r15,%rax)
incq %r15
movl $0x0, %ebx
cmpq %r13, %r15
jne 0x9f28
jmp 0x9fd8
xorl %edi, %edi
leaq 0x1a87e(%rip), %rsi     # 0x24844
xorl %eax, %eax
callq 0x37cc
movl $0x1, %ebx
jmp 0x9f5b
testl %ebx, %ebx
jne 0xa00d
movq (%rsp), %rcx
decl %ecx
leaq 0x3d1db(%rip), %rax     # 0x471c0
cmpb $0x20, (%rcx,%rax)
jne 0xa00d
leaq 0x1a861(%rip), %rsi     # 0x24853
jmp 0xa004
leaq 0x1a890(%rip), %rsi     # 0x2488b
jmp 0xa004
leaq 0x1a86d(%rip), %rsi     # 0x24871
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
leaq 0x3d1ac(%rip), %rax     # 0x471c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-base-block.cpp
// Function: edid_state::preparse_detailed_block(unsigned char const*)
void edid_state::preparse_detailed_block(const unsigned char *x)
{
	if (x[0] || x[1])
		return;
	if (x[3] != 0xfd)
		return;

	switch (x[10]) {
	case 0x00: /* default gtf */
		base.supports_gtf = true;
		break;
	case 0x02: /* secondary gtf curve */
		base.supports_gtf = true;
		base.supports_sec_gtf = !memchk(x + 12, 6);
		base.sec_gtf_start_freq = x[12] * 2;
		base.C = x[13] / 2.0;
		base.M = (x[15] << 8) | x[14];
		base.K = x[16];
		base.J = x[17] / 2.0;
		break;
	case 0x04: /* cvt */
		if (base.edid_minor >= 4) {
			/* GTF is implied if CVT is signaled */
			base.supports_gtf = true;
			base.supports_cvt = true;
		}
		break;
	}
}

// Assembly:
cmpb $0x0, (%rsi)
je 0xbd52
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x0, 0x1(%rsi)
jne 0xbe3a
cmpb $-0x3, 0x3(%r14)
jne 0xbe3a
movq %rdi, %rbx
movzbl 0xa(%r14), %eax
cmpl $0x4, %eax
je 0xbe23
cmpl $0x2, %eax
je 0xbd98
testl %eax, %eax
jne 0xbe3a
movb $0x1, 0x91(%rbx)
jmp 0xbe3a
movb $0x1, 0x91(%rbx)
leaq 0xc(%r14), %rdi
movl $0x6, %esi
xorl %edx, %edx
callq 0x5ba5
xorb $0x1, %al
movb %al, 0x92(%rbx)
movzbl 0xc(%r14), %eax
addl %eax, %eax
movl %eax, 0x94(%rbx)
movzbl 0xd(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd 0x1423b(%rip), %xmm1    # 0x20010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rbx)
movzwl 0xe(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xa0(%rbx)
movzbl 0x10(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xa8(%rbx)
movzbl 0x11(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0xb0(%rbx)
jmp 0xbe3a
cmpl $0x4, 0x88(%rbx)
jb 0xbe3a
movb $0x1, %al
movb %al, 0x91(%rbx)
movb %al, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: find_vic_id(unsigned char)
const struct timings *find_vic_id(unsigned char vic)
{
	if (vic > 0 && vic <= ARRAY_SIZE(edid_cta_modes1))
		return edid_cta_modes1 + vic - 1;
	if (vic >= 193 && vic < ARRAY_SIZE(edid_cta_modes2) + 193)
		return edid_cta_modes2 + vic - 193;
	return NULL;
}

// Assembly:
testb %dil, %dil
jle 0xdfeb
movzbl %dil, %eax
imulq $0x54, %rax, %rax
leaq 0x18b0d(%rip), %rcx     # 0x26af0
addq %rcx, %rax
addq $-0x54, %rax
retq
leal 0x3f(%rdi), %eax
cmpb $0x1a, %al
ja 0xe00b
movzbl %dil, %eax
imulq $0x54, %rax, %rax
leaq 0x1b49f(%rip), %rcx     # 0x294a0
addq %rcx, %rax
addq $-0x3f54, %rax          # imm = 0xC0AC
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_close_match_to_vic(timings const&, unsigned int&)
const struct timings *cta_close_match_to_vic(const timings &t, unsigned &vic)
{
	for (vic = 1; vic <= ARRAY_SIZE(edid_cta_modes1); vic++) {
		if (timings_close_match(t, edid_cta_modes1[vic - 1]))
			return &edid_cta_modes1[vic - 1];
	}
	for (vic = 193; vic < ARRAY_SIZE(edid_cta_modes2) + 193; vic++) {
		if (timings_close_match(t, edid_cta_modes1[vic - 193]))
			return &edid_cta_modes1[vic - 193];
	}
	vic = 0;
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, (%rsi)
xorl %ecx, %ecx
leaq 0x18a9a(%rip), %rbx     # 0x26af0
movl %ecx, %eax
imulq $0x54, %rax, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x3d98
movl (%r14), %ecx
testb %al, %al
jne 0xe0bb
leal 0x1(%rcx), %eax
movl %eax, (%r14)
cmpl $0x80, %eax
jb 0xe056
movl $0xc1, (%r14)
movl $0xc1, %ecx
addl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
imulq $0x54, %rcx, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x3d98
movl (%r14), %ecx
testb %al, %al
jne 0xe0bf
incl %ecx
movl %ecx, (%r14)
cmpl $0xdc, %ecx
jb 0xe087
movl $0x0, (%r14)
xorl %ebx, %ebx
jmp 0xe0cc
decl %ecx
jmp 0xe0c5
addl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
imulq $0x54, %rcx, %rax
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_list_vics()
void edid_state::cta_list_vics()
{
	char type[16];
	for (unsigned vic = 1; vic <= ARRAY_SIZE(edid_cta_modes1); vic++) {
		sprintf(type, "VIC %3u", vic);
		print_timings("", &edid_cta_modes1[vic - 1], type, "", false, false);
	}
	for (unsigned vic = 193; vic < ARRAY_SIZE(edid_cta_modes2) + 193; vic++) {
		sprintf(type, "VIC %3u", vic);
		print_timings("", &edid_cta_modes2[vic - 193], type, "", false, false);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $-0x7f, %rbp
leaq 0x189fb(%rip), %r14     # 0x26af0
leaq 0x12808(%rip), %r15     # 0x20904
leaq 0x10(%rsp), %r12
leaq 0x12b81(%rip), %r13     # 0x20c89
leal 0x80(%rbp), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3070
movl $0x0, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x3e8c
addq $0x54, %r14
incq %rbp
jne 0xe108
movq $-0x1b, %rbp
leaq 0x1b350(%rip), %r14     # 0x294a0
leaq 0x127ad(%rip), %r15     # 0x20904
leaq 0x10(%rsp), %r12
leaq 0x12b26(%rip), %r13     # 0x20c89
leal 0xdc(%rbp), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3070
movl $0x0, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x3e8c
addq $0x54, %r14
incq %rbp
jne 0xe163
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_list_hdmi_vics()
void edid_state::cta_list_hdmi_vics()
{
	for (unsigned i = 0; i < ARRAY_SIZE(edid_hdmi_mode_map); i++) {
		unsigned vic = edid_hdmi_mode_map[i];
		char type[16];

		sprintf(type, "HDMI VIC %u", i + 1);
		print_timings("", find_vic_id(vic), type, "", false, false);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
leaq 0x18927(%rip), %rbp     # 0x26af0
leaq 0x12ab9(%rip), %r12     # 0x20c89
xorl %r13d, %r13d
leaq 0x1bdb6(%rip), %rax     # 0x29f90
movzbl (%r13,%rax), %r14d
incq %r13
movq %r15, %rdi
leaq 0x12735(%rip), %rsi     # 0x20922
movl %r13d, %edx
xorl %eax, %eax
callq 0x3070
imulq $0x54, %r14, %rax
leaq (%rax,%rbp), %rdx
addq $-0x54, %rdx
movl $0x0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x3e8c
cmpq $0x4, %r13
jne 0xe1d3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::print_vic_index(char const*, unsigned int, char const*, bool)
void edid_state::print_vic_index(const char *prefix, unsigned idx, const char *suffix, bool ycbcr420)
{
	if (!suffix)
		suffix = "";
	if (idx < cta.preparsed_svds[0].size()) {
		unsigned char vic = cta.preparsed_svds[0][idx];
		const struct timings *t = find_vic_id(vic);
		char buf[16];

		sprintf(buf, "VIC %3u", vic);

		if (t) {
			struct timings tmp = *t;
			tmp.ycbcr420 = ycbcr420;
			print_timings(prefix, &tmp, buf, suffix);
		} else {
			printf("%sUnknown (%s%s%s)\n", prefix, buf,
			       *suffix ? ", " : "", suffix);
		}
	} else {
		// Should not happen!
		printf("%sSVD Index %u is out of range", prefix, idx + 1);
		if (*suffix)
			printf(" (%s)", suffix);
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rsi, %r14
testq %rcx, %rcx
leaq 0x1234d(%rip), %r12     # 0x20c89
cmoveq %r12, %rbx
movl %edx, %eax
movq 0x8e0(%rdi), %rcx
movq 0x8e8(%rdi), %rsi
subq %rcx, %rsi
cmpq %rax, %rsi
jbe 0xe976
movl %r8d, %ebp
movq %rdi, %r15
movzbl (%rcx,%rax), %edx
testb %dl, %dl
jle 0xe9b7
movq $-0x54, %rcx
leaq 0x1817c(%rip), %rax     # 0x26af0
jmp 0xe9cc
incl %edx
leaq 0x1b750(%rip), %rdi     # 0x2a0cf
movq %r14, %rsi
xorl %eax, %eax
callq 0x3030
cmpb $0x0, (%rbx)
je 0xe99f
leaq 0x1b759(%rip), %rdi     # 0x2a0ee
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
movl $0xa, %edi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3310
leal 0x3f(%rdx), %eax
cmpb $0x1a, %al
ja 0xea2c
movq $-0x3f54, %rcx          # imm = 0xC0AC
leaq 0x1aad4(%rip), %rax     # 0x294a0
addq %rcx, %rax
imulq $0x54, %rdx, %r12
addq %rax, %r12
leaq 0x11f27(%rip), %rsi     # 0x20904
leaq 0x10(%rsp), %r13
movq %r13, %rdi
xorl %eax, %eax
callq 0x3070
leaq 0x24(%rsp), %rdx
movl $0x15, %ecx
movq %rdx, %rdi
movq %r12, %rsi
rep  movsl (%rsi), %es:(%rdi)
movb %bpl, 0x50(%rdx)
movl $0x1, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x3e8c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11ed1(%rip), %rsi     # 0x20904
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3070
cmpb $0x0, (%rbx)
leaq 0x120d2(%rip), %rcx     # 0x20b1e
cmoveq %r12, %rcx
leaq 0x1b664(%rip), %rdi     # 0x2a0bb
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3030
jmp 0xea1d
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_y420cmdb(unsigned char const*, unsigned int)
void edid_state::cta_y420cmdb(const unsigned char *x, unsigned length)
{
	unsigned max_idx = 0;
	unsigned i;

	if (!length) {
		printf("    All VDB SVDs\n");
		return;
	}

	if (memchk(x, length)) {
		printf("    Empty Capability Map\n");
		fail("Empty Capability Map.\n");
		return;
	}

	for (i = 0; i < length; i++) {
		unsigned char v = x[i];
		unsigned j;

		for (j = 0; j < 8; j++) {
			if (!(v & (1 << j)))
				continue;

			print_vic_index("    ", i * 8 + j, "", true);
			max_idx = i * 8 + j;
			if (max_idx < cta.preparsed_svds[0].size()) {
				unsigned vic = cta.preparsed_svds[0][max_idx];
				if (cta.preparsed_has_vic[1][vic])
					fail("VIC %u is also a YCbCr 4:2:0-only VIC.\n", vic);
			}
		}
	}
	if (max_idx >= cta.preparsed_svds[0].size())
		fail("Max index %u > %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 $0x18, %rsp
testl %edx, %edx
je 0xeabe
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x5ba5
testb %al, %al
je 0xead8
leaq 0x1eb13(%rip), %rdi     # 0x2d5ae
callq 0x3380
leaq 0x1b64d(%rip), %rsi     # 0x2a0f4
xorl %edi, %edi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
leaq 0x1ead8(%rip), %rdi     # 0x2d59d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3380
movl %ebp, %eax
movq %rax, (%rsp)
leaq 0x121a4(%rip), %r12     # 0x20c89
xorl %eax, %eax
xorl %edx, %edx
movq %r14, 0x8(%rsp)
leal (,%rax,8), %ebp
movq %rax, 0x10(%rsp)
movzbl (%r14,%rax), %r13d
xorl %r14d, %r14d
movl $0x8, %r15d
btl %r14d, %r13d
jae 0xeb5e
movq %rbx, %rdi
leaq 0x1697f(%rip), %rsi     # 0x25497
movl %ebp, %edx
movq %r12, %rcx
movl $0x1, %r8d
callq 0xe91e
movq 0x8e0(%rbx), %rax
movq 0x8e8(%rbx), %rcx
subq %rax, %rcx
cmpq %rbp, %rcx
jbe 0xeb5c
movzbl (%rax,%rbp), %edx
cmpb $0x0, 0x7e0(%rbx,%rdx)
je 0xeb5c
xorl %edi, %edi
leaq 0x1b5b6(%rip), %rsi     # 0x2a10b
xorl %eax, %eax
callq 0x37cc
movl %ebp, %edx
incl %r14d
incq %rbp
decq %r15
jne 0xeb08
movq 0x10(%rsp), %rax
incq %rax
cmpq (%rsp), %rax
movq 0x8(%rsp), %r14
jne 0xeaee
movl %edx, %eax
movq 0x8e8(%rbx), %rcx
subq 0x8e0(%rbx), %rcx
cmpq %rax, %rcx
jbe 0xeba4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl %edx
leaq 0x1b586(%rip), %rsi     # 0x2a133
xorl %edi, %edi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: hdmi_latency2s[abi:cxx11](unsigned char, bool)
static std::string hdmi_latency2s(unsigned char l, bool is_video)
{
	if (!l)
		return "Unknown";
	if (l == 0xff)
		return is_video ? "Video not supported" : "Audio not supported";
	return std::to_string(1 + 2 * l) + " ms";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0xff, %esi
je 0xf2ca
testl %esi, %esi
jne 0xf30b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x166ed(%rip), %rsi     # 0x259ae
leaq 0x166ed(%rip), %rdx     # 0x259b5
jmp 0xf2f7
leaq 0x1c760(%rip), %rax     # 0x2ba31
leaq 0x1c76d(%rip), %rsi     # 0x2ba45
leaq 0x10(%rbx), %rcx
testb %dl, %dl
cmovneq %rax, %rsi
leaq 0x1c75b(%rip), %rax     # 0x2ba44
leaq 0x1c768(%rip), %rdx     # 0x2ba58
cmovneq %rax, %rdx
movq %rcx, (%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d58
movzbl %sil, %eax
leal 0x1(,%rax,2), %ebp
cmpb $0x32, %al
movl $0x3, %ecx
sbbl $0x0, %ecx
cmpb $0x5, %al
movl $0x1, %r14d
cmovael %ecx, %r14d
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x2d, %edx
callq 0x32a0
movq (%r15), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8a6d
leaq 0x1c6fc(%rip), %rsi     # 0x2ba59
movq %r15, %rdi
callq 0x3420
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xf387
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xf38d
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xf3ba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xf3e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_preparse_sldb(unsigned char const*, unsigned int)
void edid_state::cta_preparse_sldb(const unsigned char *x, unsigned length)
{
	cta.has_sldb = true;
	while (length >= 2) {
		if (length >= 5 && (x[0] & 0x40)) {
			cta.preparsed_sld_has_coord = true;
			return;
		}
		length -= 2;
		x += 2;
	}
}

// Assembly:
movb $0x1, 0x2ce(%rdi)
cmpl $0x2, %edx
jb 0x1027c
cmpl $0x5, %edx
jb 0x10270
testb $0x40, (%rsi)
jne 0x1027d
addl $-0x2, %edx
addq $0x2, %rsi
cmpl $0x1, %edx
ja 0x10266
retq
movb $0x1, 0x2cc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_displayid_type_7(unsigned char const*, unsigned int)
void edid_state::cta_displayid_type_7(const unsigned char *x, unsigned length)
{
	check_displayid_datablock_revision(x[0], 0x00, 2);

	if (length < 21U + ((x[0] & 0x70) >> 4)) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}
	parse_displayid_type_1_7_timing(x + 1, true, 2, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl (%rsi), %esi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x1611c
movzbl (%r14), %eax
shrl $0x4, %eax
andl $0x7, %eax
addl $0x15, %eax
cmpl %ebx, %eax
jbe 0x104d4
leaq 0x19c8b(%rip), %rsi     # 0x2a14f
xorl %edi, %edi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x37cc
incq %r14
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x2, %ecx
movl $0x1, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x166ca
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_displayid_type_8(unsigned char const*, unsigned int)
void edid_state::cta_displayid_type_8(const unsigned char *x, unsigned length)
{
	check_displayid_datablock_revision(x[0], 0xe8, 1);
	if (length < ((x[0] & 0x08) ? 3 : 2)) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}

	unsigned sz = (x[0] & 0x08) ? 2 : 1;
	unsigned type = x[0] >> 6;

	if (type) {
		fail("Only code type 0 is supported.\n");
		return;
	}

	if (x[0] & 0x20)
		printf("    Also supports YCbCr 4:2:0\n");

	x++;
	length--;
	for (unsigned i = 0; i < length / sz; i++) {
		unsigned id = x[i * sz];

		if (sz == 2)
			id |= x[i * sz + 1] << 8;
		parse_displayid_type_4_8_timing(type, id, true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl (%rsi), %esi
movl $0xe8, %edx
movl $0x1, %ecx
callq 0x1611c
movzbl (%r14), %eax
movl %eax, %r12d
andl $0x8, %r12d
cmpl $0x1, %r12d
movl $0x3, %ecx
sbbl $0x0, %ecx
cmpl %ebx, %ecx
jbe 0x10558
leaq 0x19c10(%rip), %rsi     # 0x2a14f
xorl %edi, %edi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
cmpb $0x40, %al
jae 0x105ca
cmpb $0x20, %al
jb 0x1056c
leaq 0x1d43a(%rip), %rdi     # 0x2d9a1
callq 0x3380
decl %ebx
movl %r12d, %ebp
shrl $0x3, %ebp
movl %ebp, %ecx
shrl %cl, %ebx
testl %ebx, %ebx
je 0x105bb
xorl %r13d, %r13d
movl %r13d, %edx
movl %ebp, %ecx
shll %cl, %edx
movzbl 0x1(%r14,%rdx), %eax
testb %r12b, %r12b
je 0x105a1
movl %edx, %ecx
movzbl 0x2(%r14,%rcx), %ecx
shll $0x8, %ecx
movzwl %ax, %eax
orl %ecx, %eax
movzwl %ax, %edx
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x177d0
incl %r13d
cmpl %r13d, %ebx
jne 0x1057f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a608(%rip), %rsi     # 0x2abd9
xorl %edi, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_displayid_type_10(unsigned char const*, unsigned int)
void edid_state::cta_displayid_type_10(const unsigned char *x, unsigned length)
{
	check_displayid_datablock_revision(x[0], 0x70);
	if (length < 7U + ((x[0] & 0x70) >> 4)) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}

	unsigned sz = 6U + ((x[0] & 0x70) >> 4);
	x++;
	length--;
	for (unsigned i = 0; i < length / sz; i++)
		parse_displayid_type_10_timing(x + i * sz, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %esi
xorl %r12d, %r12d
movl $0x70, %edx
xorl %ecx, %ecx
callq 0x1611c
movzbl (%rbx), %r13d
shrl $0x4, %r13d
andl $0x7, %r13d
leal 0x7(%r13), %eax
cmpl %ebp, %eax
jbe 0x10641
leaq 0x19b27(%rip), %rsi     # 0x2a14f
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
addl $0x6, %r13d
incq %rbx
decl %ebp
movl %ebp, %eax
xorl %edx, %edx
divl %r13d
movl %eax, %r15d
cmpl $0x1, %eax
adcl $0x0, %r15d
negq %r15
movl %r12d, %esi
addq %rbx, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x1a77c
addl %r13d, %r12d
incq %r15
jne 0x1065e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_hdr10plus(unsigned char const*, unsigned int)
static void cta_hdr10plus(const unsigned char *x, unsigned length)
{
	printf("    Application Version: %u", x[0]);
	if (length > 1)
		hex_block("  ", x + 1, length - 1);
	else
		printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movzbl (%rdi), %esi
leaq 0x19c79(%rip), %rdi     # 0x2be8f
xorl %eax, %eax
callq 0x3030
cmpl $0x2, %ebx
jb 0x1224a
incq %r14
decl %ebx
leaq 0x1326b(%rip), %rdi     # 0x25499
movq %r14, %rsi
movl %ebx, %edx
movl $0x1, %ecx
movl $0x10, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5bd2
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_dolby_audio(unsigned char const*, unsigned int)
static void cta_dolby_audio(const unsigned char *x, unsigned length)
{
	unsigned char version = 1 + (x[0] & 0x07);

	printf("    Version: %u (%u bytes)\n", version, length + 5);
	if (x[0] & 0x80)
		printf("    Headphone playback only\n");
	if (x[0] & 0x40)
		printf("    Height speaker zone present\n");
	if (x[0] & 0x20)
		printf("    Surround speaker zone present\n");
	if (x[0] & 0x10)
		printf("    Center speaker zone present\n");
	if (x[1] & 0x01)
		printf("    Supports Dolby MAT PCM decoding at 48 kHz only, does not support TrueHD\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
andl $0x7, %eax
incl %eax
leal 0x5(%rsi), %edx
leaq 0x1962b(%rip), %rdi     # 0x2beab
movl %eax, %esi
xorl %eax, %eax
callq 0x3030
movb (%rbx), %al
testb %al, %al
jns 0x1289d
leaq 0x1b6a5(%rip), %rdi     # 0x2df3b
callq 0x3380
movb (%rbx), %al
testb $0x40, %al
je 0x128af
leaq 0x1b6af(%rip), %rdi     # 0x2df57
callq 0x3380
movb (%rbx), %al
testb $0x20, %al
je 0x128c1
leaq 0x1b6bd(%rip), %rdi     # 0x2df77
callq 0x3380
movb (%rbx), %al
testb $0x10, %al
je 0x128d1
leaq 0x1b6cd(%rip), %rdi     # 0x2df99
callq 0x3380
testb $0x1, 0x1(%rbx)
jne 0x128d9
popq %rbx
retq
leaq 0x1b6d9(%rip), %rdi     # 0x2dfb9
popq %rbx
jmp 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_resolve_svr(__gnu_cxx::__normal_iterator<timings_ext*, std::vector<timings_ext, std::allocator<timings_ext>>>)
void edid_state::cta_resolve_svr(vec_timings_ext::iterator iter)
{
	if (iter->svr() == 254) {
		iter->flags = cta.t8vtdb.flags;
		iter->t = cta.t8vtdb.t;
	} else if (iter->svr() <= 144) {
		iter->flags = cta.vec_dtds[iter->svr() - 129].flags;
		iter->t = cta.vec_dtds[iter->svr() - 129].t;
	} else {
		iter->flags = cta.vec_vtdbs[iter->svr() - 145].flags;
		iter->t = cta.vec_vtdbs[iter->svr() - 145].t;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0xfe, %eax
jne 0x15380
leaq 0x210(%r14), %r15
addq $0x288, %r14            # imm = 0x288
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x3140
jmp 0x153f7
leaq 0x78(%rbx), %rdi
cmpl $0x90, %eax
ja 0x153c2
movl $0xffffff7f, %r15d      # imm = 0xFFFFFF7F
addl %r15d, %eax
movq 0x188(%r14), %rcx
imulq $0x98, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x78, %rsi
callq 0x3140
addl (%rbx), %r15d
imulq $0x98, %r15, %r15
addq 0x188(%r14), %r15
jmp 0x153f7
movl $0xffffff6f, %r15d      # imm = 0xFFFFFF6F
addl %r15d, %eax
movq 0x1a8(%r14), %rcx
imulq $0x98, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x78, %rsi
callq 0x3140
addl (%rbx), %r15d
imulq $0x98, %r15, %r15
addq 0x1a8(%r14), %r15
movl $0xa, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x50(%r15), %eax
movl %eax, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: edid_state::cta_resolve_svrs()
void edid_state::cta_resolve_svrs()
{
	for (vec_timings_ext::iterator iter = cta.preferred_timings.begin();
	     iter != cta.preferred_timings.end(); ++iter) {
		if (iter->has_svr())
			cta_resolve_svr(iter);
	}

	for (vec_timings_ext::iterator iter = cta.native_timings.begin();
	     iter != cta.native_timings.end(); ++iter) {
		if (iter->has_svr())
			cta_resolve_svr(iter);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c0(%rdi), %r14
movq 0x1c8(%rdi), %rax
cmpq %rax, %r14
je 0x15454
cmpl $0x0, (%r14)
je 0x1544b
cmpl $0x0, 0x4(%r14)
jne 0x1544b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15350
movq 0x1c8(%rbx), %rax
addq $0x98, %r14
jmp 0x15427
movq 0x2a8(%rbx), %r14
movq 0x2b0(%rbx), %rax
cmpq %rax, %r14
je 0x1548f
cmpl $0x0, (%r14)
je 0x15486
cmpl $0x0, 0x4(%r14)
jne 0x15486
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15350
movq 0x2b0(%rbx), %rax
addq $0x98, %r14
jmp 0x15462
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::check_displayid_datablock_revision(unsigned char, unsigned char, unsigned char)
void edid_state::check_displayid_datablock_revision(unsigned char hdr,
						    unsigned char valid_flags,
						    unsigned char rev)
{
	unsigned char revision = hdr & 7;
	unsigned char flags = hdr & ~7 & ~valid_flags;

	if (revision != rev)
		warn("Unexpected revision (%u != %u).\n", revision, rev);
	if (flags)
		warn("Unexpected flags (0x%02x).\n", flags);
}

// Assembly:
pushq %rbx
movl %edx, %ebx
notb %bl
andb %sil, %bl
movl %esi, %eax
andb $0x7, %al
andb $-0x8, %bl
cmpb %cl, %al
je 0x16148
movzbl %cl, %ecx
movzbl %al, %edx
leaq 0x18a74(%rip), %rsi     # 0x2ebb0
movl $0x1, %edi
xorl %eax, %eax
callq 0x37cc
testb %bl, %bl
je 0x16163
movzbl %bl, %edx
leaq 0x18a7b(%rip), %rsi     # 0x2ebd1
movl $0x1, %edi
xorl %eax, %eax
popq %rbx
jmp 0x37cc
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_product_id(unsigned char const*)
void edid_state::parse_displayid_product_id(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	dispid.has_product_identification = true;
	if (dispid.version >= 0x20) {
		unsigned oui = (x[3] << 16) | (x[4] << 8) | x[5];
		printf("    Vendor OUI %s\n", ouitohex(oui).c_str());
	} else {
		printf("    Vendor ID: %c%c%c\n", x[3], x[4], x[5]);
	}
	printf("    Product Code: %u\n", x[6] | (x[7] << 8));
	unsigned sn = x[8] | (x[9] << 8) | (x[10] << 16) | (x[11] << 24);
	if (sn) {
		if (hide_serial_numbers)
			printf("    Serial Number: ...\n");
		else
			printf("    Serial Number: %u\n", sn);
	}
	unsigned week = x[12];
	unsigned year = 2000 + x[13];
	printf("    %s: %u",
	       week == 0xff ? "Model Year" : "Year of Manufacture", year);
	if (week && week <= 0x36)
		printf(", Week %u", week);
	printf("\n");
	if (x[14]) {
		char buf[256];

		memcpy(buf, x + 15, x[14]);
		buf[x[14]] = 0;
		printf("    Product ID: %s\n", buf);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1611c
movb $0x1, 0x91e(%r14)
cmpb $0x20, 0x910(%r14)
movzbl 0x3(%rbx), %esi
jb 0x161e5
shll $0x10, %esi
movzbl 0x4(%rbx), %eax
shll $0x8, %eax
orl %esi, %eax
movzbl 0x5(%rbx), %esi
orl %eax, %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5b45
movq (%r15), %rsi
leaq 0x18a2b(%rip), %rdi     # 0x2ebed
xorl %eax, %eax
callq 0x3030
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x161fb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x161fb
movzbl 0x4(%rbx), %edx
movzbl 0x5(%rbx), %ecx
leaq 0x18a0c(%rip), %rdi     # 0x2ec00
xorl %eax, %eax
callq 0x3030
movzwl 0x6(%rbx), %esi
leaq 0x18a11(%rip), %rdi     # 0x2ec17
xorl %eax, %eax
callq 0x3030
movl 0x8(%rbx), %esi
testl %esi, %esi
je 0x16237
cmpb $0x1, 0x52(%r14)
jne 0x16229
leaq 0x1037a(%rip), %rdi     # 0x2659c
callq 0x3380
jmp 0x16237
leaq 0xf892(%rip), %rdi      # 0x25ac2
xorl %eax, %eax
callq 0x3030
movzbl 0xc(%rbx), %r14d
movzbl 0xd(%rbx), %edx
addl $0x7d0, %edx            # imm = 0x7D0
cmpl $0xff, %r14d
leaq 0x189e4(%rip), %rax     # 0x2ec38
leaq 0x189e8(%rip), %rsi     # 0x2ec43
cmoveq %rax, %rsi
leaq 0x189c7(%rip), %rdi     # 0x2ec2d
xorl %eax, %eax
callq 0x3030
leal -0x1(%r14), %eax
cmpb $0x35, %al
ja 0x16286
leaq 0x189db(%rip), %rdi     # 0x2ec57
movl %r14d, %esi
xorl %eax, %eax
callq 0x3030
movl $0xa, %edi
callq 0x3310
movzbl 0xe(%rbx), %r14d
testq %r14, %r14
je 0x162c5
addq $0xf, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31d0
movb $0x0, (%rsp,%r14)
leaq 0x189a6(%rip), %rdi     # 0x2ec61
movq %r15, %rsi
xorl %eax, %eax
callq 0x3030
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_parameters(unsigned char const*)
void edid_state::parse_displayid_parameters(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	if (!check_displayid_datablock_length(x, 12, 12))
		return;

	dispid.has_display_parameters = true;
	printf("    Image size: %.1f mm x %.1f mm\n",
	       ((x[4] << 8) + x[3]) / 10.0,
	       ((x[6] << 8) + x[5]) / 10.0);
	printf("    Pixels: %d x %d\n",
	       (x[8] << 8) + x[7], (x[10] << 8) + x[9]);
	print_flag_lines("      ", "    Feature support flags:",
			 x[11], feature_support_flags);

	if (x[12] != 0xff)
		printf("    Gamma: %.2f\n", ((x[12] + 100.0) / 100.0));
	printf("    Aspect ratio: %.2f\n", ((x[13] + 100.0) / 100.0));
	printf("    Dynamic bpc native: %d\n", (x[14] & 0xf) + 1);
	printf("    Dynamic bpc overall: %d\n", ((x[14] >> 4) & 0xf) + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1611c
movq %rbx, %rdi
movl $0xc, %esi
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x1644b
testb %al, %al
je 0x1643c
movb $0x1, 0x91f(%r14)
movzwl 0x3(%rbx), %eax
cvtsi2sd %eax, %xmm0
movsd 0x18304(%rip), %xmm2    # 0x2e628
divsd %xmm2, %xmm0
movzwl 0x5(%rbx), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm2, %xmm1
leaq 0x1893a(%rip), %rdi     # 0x2ec75
movb $0x2, %al
callq 0x3030
movzwl 0x7(%rbx), %esi
movzwl 0x9(%rbx), %edx
leaq 0x18947(%rip), %rdi     # 0x2ec98
xorl %eax, %eax
callq 0x3030
movzbl 0xb(%rbx), %ebp
testl %ebp, %ebp
je 0x163a8
leaq 0x18946(%rip), %rdi     # 0x2ecad
callq 0x3380
leaq 0x239ed(%rip), %r12     # 0x39d60
leaq 0xeddb(%rip), %r14      # 0x25155
leaq 0xf114(%rip), %r15      # 0x25495
xorl %r13d, %r13d
btl %r13d, %ebp
jae 0x1639b
movq (%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3030
incq %r13
addq $0x8, %r12
cmpq $0x8, %r13
jne 0x16384
movb 0xc(%rbx), %al
cmpb $-0x1, %al
je 0x163d7
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x9c5f(%rip), %xmm1     # 0x20020
addsd %xmm1, %xmm0
divsd %xmm1, %xmm0
leaq 0xf9dd(%rip), %rdi      # 0x25dad
movb $0x1, %al
callq 0x3030
movzbl 0xd(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x9c36(%rip), %xmm1     # 0x20020
addsd %xmm1, %xmm0
divsd %xmm1, %xmm0
leaq 0x188cf(%rip), %rdi     # 0x2ecc8
movb $0x1, %al
callq 0x3030
movzbl 0xe(%rbx), %esi
andl $0xf, %esi
incl %esi
leaq 0x188d0(%rip), %rdi     # 0x2ece0
xorl %eax, %eax
callq 0x3030
movzbl 0xe(%rbx), %esi
shrl $0x4, %esi
incl %esi
leaq 0x188d5(%rip), %rdi     # 0x2ecfc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: check_displayid_datablock_length(unsigned char const*, unsigned int, unsigned int, unsigned int)
static bool check_displayid_datablock_length(const unsigned char *x,
					     unsigned expectedlenmin = 0,
					     unsigned expectedlenmax = 128 - 2 - 5 - 3,
					     unsigned payloaddumpstart = 0)
{
	unsigned char len = x[2];

	if (expectedlenmin == expectedlenmax && len != expectedlenmax)
		fail("DisplayID payload length is different than expected (%d != %d).\n", len, expectedlenmax);
	else if (len > expectedlenmax)
		fail("DisplayID payload length is greater than expected (%d > %d).\n", len, expectedlenmax);
	else if (len < expectedlenmin)
		fail("DisplayID payload length is less than expected (%d < %d).\n", len, expectedlenmin);
	else
		return true;

	if (len > payloaddumpstart)
		hex_block("    ", x + 3 + payloaddumpstart, len - payloaddumpstart);
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %edx, %eax
movl %esi, %ecx
movq %rdi, %r14
cmpl %edx, %esi
setne %dl
movzbl 0x2(%rdi), %ebx
cmpl %esi, %ebx
sete %sil
orb %dl, %sil
je 0x1647f
cmpl %eax, %ebx
jbe 0x164bf
leaq 0x1a751(%rip), %rsi     # 0x30bc8
xorl %edi, %edi
movl %ebx, %edx
movl %eax, %ecx
jmp 0x1648a
leaq 0x1a701(%rip), %rsi     # 0x30b87
xorl %edi, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x37cc
subl %ebp, %ebx
jbe 0x164b8
movl %ebp, %eax
leaq (%r14,%rax), %rsi
addq $0x3, %rsi
leaq 0xeff1(%rip), %rdi      # 0x25497
movl %ebx, %edx
movl $0x1, %ecx
movl $0x10, %r8d
callq 0x5bd2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
cmpl %ecx, %ebx
jae 0x164ba
leaq 0x1a73a(%rip), %rsi     # 0x30c06
jmp 0x16486
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_video_timing_range_limits(unsigned char const*)
void edid_state::parse_displayid_video_timing_range_limits(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	if (!check_displayid_datablock_length(x, 15, 15))
		return;
	printf("    Pixel Clock: %.3f-%.3f MHz\n",
	       (double)((x[3] | (x[4] << 8) | (x[5] << 16)) + 1) / 100.0,
	       (double)((x[6] | (x[7] << 8) | (x[8] << 16)) + 1) / 100.0);
	printf("    Horizontal Frequency: %u-%u kHz\n", x[9], x[10]);
	printf("    Minimum Horizontal Blanking: %u pixels\n", x[11] | (x[12] << 8));
	printf("    Vertical Refresh: %u-%u Hz\n", x[13], x[14]);
	printf("    Minimum Vertical Blanking: %u lines\n", x[15] | (x[16] << 8));
	if (x[17] & 0x80)
		printf("    Supports Interlaced\n");
	if (x[17] & 0x40)
		printf("    Supports CVT\n");
	if (x[17] & 0x20)
		printf("    Supports CVT Reduced Blanking\n");
	if (x[17] & 0x10)
		printf("    Discrete frequency display device\n");
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1611c
movq %rbx, %rdi
movl $0xf, %esi
movl $0xf, %edx
xorl %ecx, %ecx
callq 0x1644b
testb %al, %al
je 0x17b0d
movzwl 0x3(%rbx), %eax
movzbl 0x5(%rbx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
incl %eax
cvtsi2sd %eax, %xmm0
movsd 0x85cc(%rip), %xmm2     # 0x20020
divsd %xmm2, %xmm0
movzwl 0x6(%rbx), %eax
movzbl 0x8(%rbx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
incl %eax
cvtsi2sd %eax, %xmm1
divsd %xmm2, %xmm1
leaq 0x174d5(%rip), %rdi     # 0x2ef4b
movb $0x2, %al
callq 0x3030
movzbl 0x9(%rbx), %esi
movzbl 0xa(%rbx), %edx
leaq 0x174df(%rip), %rdi     # 0x2ef6b
xorl %eax, %eax
callq 0x3030
movzwl 0xb(%rbx), %esi
leaq 0x174f2(%rip), %rdi     # 0x2ef90
xorl %eax, %eax
callq 0x3030
movzbl 0xd(%rbx), %esi
movzbl 0xe(%rbx), %edx
leaq 0x17508(%rip), %rdi     # 0x2efbc
xorl %eax, %eax
callq 0x3030
movzwl 0xf(%rbx), %esi
leaq 0x17516(%rip), %rdi     # 0x2efdc
xorl %eax, %eax
callq 0x3030
movb 0x11(%rbx), %al
testb %al, %al
jns 0x17ae3
leaq 0x192ce(%rip), %rdi     # 0x30da9
callq 0x3380
movb 0x11(%rbx), %al
testb $0x40, %al
je 0x17af6
leaq 0x192d3(%rip), %rdi     # 0x30dc1
callq 0x3380
movb 0x11(%rbx), %al
testb $0x20, %al
je 0x17b09
leaq 0x192d1(%rip), %rdi     # 0x30dd2
callq 0x3380
movb 0x11(%rbx), %al
testb $0x10, %al
jne 0x17b0f
popq %rbx
retq
leaq 0x192de(%rip), %rdi     # 0x30df4
popq %rbx
jmp 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_intf_power_sequencing(unsigned char const*)
void edid_state::parse_displayid_intf_power_sequencing(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	if (!check_displayid_datablock_length(x, 6, 6))
		return;

	printf("    Power Sequence T1 Range: %.1f-%u.0 ms\n", (x[3] >> 4) / 10.0, (x[3] & 0xf) * 2);
	printf("    Power Sequence T2 Range: 0.0-%u.0 ms\n", (x[4] & 0x3f) * 2);
	printf("    Power Sequence T3 Range: 0.0-%u.0 ms\n", (x[5] & 0x3f) * 2);
	printf("    Power Sequence T4 Min: %u.0 ms\n", (x[6] & 0x7f) * 10);
	printf("    Power Sequence T5 Min: %u.0 ms\n", (x[7] & 0x3f) * 10);
	printf("    Power Sequence T6 Min: %u.0 ms\n", (x[8] & 0x3f) * 10);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1611c
movq %rbx, %rdi
movl $0x6, %esi
movl $0x6, %edx
xorl %ecx, %ecx
callq 0x1644b
testb %al, %al
je 0x17f4e
movzbl 0x3(%rbx), %esi
movl %esi, %eax
shrl $0x4, %eax
cvtsi2sd %eax, %xmm0
divsd 0x1676a(%rip), %xmm0    # 0x2e628
addl %esi, %esi
andl $0x1e, %esi
leaq 0x17322(%rip), %rdi     # 0x2f1ec
movb $0x1, %al
callq 0x3030
movzbl 0x4(%rbx), %esi
addl %esi, %esi
andl $0x7e, %esi
leaq 0x17336(%rip), %rdi     # 0x2f217
xorl %eax, %eax
callq 0x3030
movzbl 0x5(%rbx), %esi
addl %esi, %esi
andl $0x7e, %esi
leaq 0x17349(%rip), %rdi     # 0x2f241
xorl %eax, %eax
callq 0x3030
movzbl 0x6(%rbx), %eax
andl $0x7f, %eax
addl %eax, %eax
leal (%rax,%rax,4), %esi
leaq 0x17359(%rip), %rdi     # 0x2f26b
xorl %eax, %eax
callq 0x3030
movzbl 0x7(%rbx), %eax
andl $0x3f, %eax
addl %eax, %eax
leal (%rax,%rax,4), %esi
leaq 0x17363(%rip), %rdi     # 0x2f28f
xorl %eax, %eax
callq 0x3030
movzbl 0x8(%rbx), %eax
andl $0x3f, %eax
addl %eax, %eax
leal (%rax,%rax,4), %esi
leaq 0x1736d(%rip), %rdi     # 0x2f2b3
xorl %eax, %eax
popq %rbx
jmp 0x3030
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: print_flags(char const*, unsigned char, char const**, bool)
static void print_flags(const char *label, unsigned char flag_byte,
			const char **flags, bool reverse = false)
{
	if (!flag_byte)
		return;

	unsigned countflags = 0;

	printf("%s: ", label);
	for (unsigned i = 0; i < 8; i++) {
		if (flag_byte & (1 << (reverse ? 7 - i : i))) {
			if (countflags)
				printf(", ");
			if (flags[i])
				printf("%s", flags[i]);
			else
				printf("Undefined (%u)", i);
			countflags++;
		}
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
testl %esi, %esi
je 0x18610
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %rsi
leaq 0x19438(%rip), %rdi     # 0x319c3
xorl %eax, %eax
callq 0x3030
movzbl %bpl, %r15d
leaq 0x8581(%rip), %r13      # 0x20b1e
xorl %ebp, %ebp
xorl %r12d, %r12d
movl %ebp, %eax
xorb $0x7, %al
movzbl %al, %eax
testb %bl, %bl
cmovel %ebp, %eax
btl %eax, %r15d
jae 0x185ef
testl %r12d, %r12d
je 0x185c3
movq %r13, %rdi
xorl %eax, %eax
callq 0x3030
movq (%r14,%rbp,8), %rsi
testq %rsi, %rsi
je 0x185dc
leaq 0x879f(%rip), %rdi      # 0x20d72
xorl %eax, %eax
callq 0x3030
jmp 0x185ec
leaq 0x1874d(%rip), %rdi     # 0x30d30
movl %ebp, %esi
xorl %eax, %eax
callq 0x3030
incl %r12d
incq %rbp
cmpq $0x8, %rbp
jne 0x185a2
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3310
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: ieee7542d[abi:cxx11](unsigned short)
static std::string ieee7542d(unsigned short fp)
{
	int exp = ((fp & 0x7c00) >> 10) - 15;
	unsigned fract = (fp & 0x3ff) | 0x400;

	if (fp == 0x8000)
		return "do not use";
	if (fp & 0x8000)
		return "reserved";
	return std::to_string(pow(2, exp) * fract / 1024.0) + " cd/m^2";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x8000, %esi           # imm = 0x8000
jne 0x19d94
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16fbd(%rip), %rsi     # 0x30d45
leaq 0x16fc0(%rip), %rdx     # 0x30d4f
jmp 0x19e39
movl %esi, %ebp
testw %bp, %bp
js 0x19e24
movl %ebp, %edi
shrl $0xa, %edi
andl $0x1f, %edi
addl $-0xf, %edi
andl $0x3ff, %ebp            # imm = 0x3FF
orl $0x400, %ebp            # imm = 0x400
movsd 0xa91a(%rip), %xmm0     # 0x246d8
callq 0x3370
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm0
mulsd 0x1486d(%rip), %xmm0    # 0x2e640
movq 0x201ee(%rip), %rsi     # 0x39fc8
leaq 0x16f77(%rip), %rcx     # 0x30d58
movq %rsp, %r14
movl $0x148, %edx            # imm = 0x148
movq %r14, %rdi
movb $0x1, %al
callq 0x1d324
leaq 0x16f56(%rip), %rsi     # 0x30d50
movq %r14, %rdi
callq 0x3420
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x19e49
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x19e51
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x10777(%rip), %rsi     # 0x2a5a9
leaq 0x10778(%rip), %rdx     # 0x2a5b1
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8d58
movupd (%rcx), %xmm0
movupd %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19e83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19eaa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_dynamic_video_timings_range_limits(unsigned char const*)
void edid_state::parse_displayid_dynamic_video_timings_range_limits(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1], 0, (x[1] & 7) == 1);

	if (!check_displayid_datablock_length(x, 9, 9))
		return;

	printf("    Minimum Pixel Clock: %u kHz\n",
	       1 + (x[3] | (x[4] << 8) | (x[5] << 16)));
	printf("    Maximum Pixel Clock: %u kHz\n",
	       1 + (x[6] | (x[7] << 8) | (x[8] << 16)));
	printf("    Minimum Vertical Refresh Rate: %u Hz\n", x[9]);
	if (x[1] & 7)
		printf("    Maximum Vertical Refresh Rate: %u Hz\n", x[10] + ((x[11] & 3) << 8));
	else
		printf("    Maximum Vertical Refresh Rate: %u Hz\n", x[10]);
	printf("    Seamless Dynamic Video Timing Support: %s\n",
	       (x[11] & 0x80) ? "Yes" : "No");
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movzbl 0x1(%rsi), %esi
movl %esi, %eax
andb $0x7, %al
xorl %ecx, %ecx
cmpb $0x1, %al
sete %cl
xorl %edx, %edx
callq 0x1611c
movq %rbx, %rdi
movl $0x9, %esi
movl $0x9, %edx
xorl %ecx, %ecx
callq 0x1644b
testb %al, %al
je 0x1a431
movzwl 0x3(%rbx), %eax
movzbl 0x5(%rbx), %ecx
shll $0x10, %ecx
leal (%rcx,%rax), %esi
incl %esi
leaq 0x1588a(%rip), %rdi     # 0x2fc3b
xorl %eax, %eax
callq 0x3030
movzwl 0x6(%rbx), %eax
movzbl 0x8(%rbx), %ecx
shll $0x10, %ecx
leal (%rcx,%rax), %esi
incl %esi
leaq 0x1588d(%rip), %rdi     # 0x2fc5c
xorl %eax, %eax
callq 0x3030
movzbl 0x9(%rbx), %esi
leaq 0x1589c(%rip), %rdi     # 0x2fc7d
xorl %eax, %eax
callq 0x3030
testb $0x7, 0x1(%rbx)
movzbl 0xa(%rbx), %esi
je 0x1a3fe
movzbl 0xb(%rbx), %eax
andl $0x3, %eax
shll $0x8, %eax
orl %eax, %esi
leaq 0x158a2(%rip), %rdi     # 0x2fca7
xorl %eax, %eax
callq 0x3030
cmpb $0x0, 0xb(%rbx)
leaq 0x11f48(%rip), %rax     # 0x2c35f
leaq 0x11f3d(%rip), %rsi     # 0x2c35b
cmovnsq %rax, %rsi
leaq 0x158a8(%rip), %rdi     # 0x2fcd1
xorl %eax, %eax
popq %rbx
jmp 0x3030
popq %rbx
retq
nop