LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_colorimetry_block(unsigned char const*, unsigned int)
static void cta_colorimetry_block(const unsigned char *x, unsigned length)
{
	unsigned i;

	if (length < 2) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}
	for (i = 0; i < ARRAY_SIZE(colorimetry_map); i++) {
		if (x[0] & (1 << i))
			printf("    %s\n", colorimetry_map[i]);
	}
	if (x[1] & 0x80)
		printf("    DCI-P3\n");
	if (x[1] & 0x40)
		printf("    ICtCp\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x1b19d
movl -0xc(%rbp), %edx
xorl %edi, %edi
leaq 0x1e41e(%rip), %rsi     # 0x395af
movb $0x0, %al
callq 0x47d0
jmp 0x1b230
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x8, %rax
jae 0x1b1f2
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1b1e5
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x3065d(%rip), %rax     # 0x4b830
movq (%rax,%rcx,8), %rsi
leaq 0x1ed39(%rip), %rdi     # 0x39f17
movb $0x0, %al
callq 0x4050
jmp 0x1b1e7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b1a4
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1b212
leaq 0x2116c(%rip), %rdi     # 0x3c377
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1b230
leaq 0x2115a(%rip), %rdi     # 0x3c383
movb $0x0, %al
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_hdr_dyn_metadata_block(unsigned char const*, unsigned int)
static void cta_hdr_dyn_metadata_block(const unsigned char *x, unsigned length)
{
	if (length < 3) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}
	while (length >= 3) {
		unsigned type_len = x[0];
		unsigned type = x[1] | (x[2] << 8);

		if (length < type_len + 1)
			return;
		printf("    HDR Dynamic Metadata Type %u\n", type);
		switch (type) {
		case 1:
		case 4:
			if (type_len > 2)
				printf("      Version: %u\n", x[3] & 0xf);
			break;
		case 2:
			if (type_len > 2) {
				unsigned version = x[3] & 0xf;
				printf("      Version: %u\n", version);
				if (version >= 1) {
					if (x[3] & 0x10) printf("      Supports SL-HDR1 (ETSI TS 103 433-1)\n");
					if (x[3] & 0x20) printf("      Supports SL-HDR2 (ETSI TS 103 433-2)\n");
					if (x[3] & 0x40) printf("      Supports SL-HDR3 (ETSI TS 103 433-3)\n");
				}
			}
			break;
		default:
			break;
		}
		length -= type_len + 1;
		x += type_len + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jae 0x1b4cd
movl -0xc(%rbp), %edx
xorl %edi, %edi
leaq 0x1e0ee(%rip), %rsi     # 0x395af
movb $0x0, %al
callq 0x47d0
jmp 0x1b61e
jmp 0x1b4cf
cmpl $0x3, -0xc(%rbp)
jb 0x1b61e
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1b50d
jmp 0x1b61e
movl -0x14(%rbp), %esi
leaq 0x21076(%rip), %rdi     # 0x3c58d
xorl %eax, %eax
callq 0x4050
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1b543
jmp 0x1b52b
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1b567
jmp 0x1b535
movl -0x1c(%rbp), %eax
subl $0x4, %eax
jne 0x1b5f6
jmp 0x1b543
cmpl $0x2, -0x10(%rbp)
jbe 0x1b562
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %esi
andl $0xf, %esi
leaq 0x21054(%rip), %rdi     # 0x3c5af
movb $0x0, %al
callq 0x4050
jmp 0x1b5f8
cmpl $0x2, -0x10(%rbp)
jbe 0x1b5f4
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
andl $0xf, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
leaq 0x21026(%rip), %rdi     # 0x3c5af
movb $0x0, %al
callq 0x4050
cmpl $0x1, -0x18(%rbp)
jb 0x1b5f2
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1b5b4
leaq 0x21015(%rip), %rdi     # 0x3c5c2
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1b5d2
leaq 0x21023(%rip), %rdi     # 0x3c5ee
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1b5f0
leaq 0x21031(%rip), %rdi     # 0x3c61a
movb $0x0, %al
callq 0x4050
jmp 0x1b5f2
jmp 0x1b5f4
jmp 0x1b5f8
jmp 0x1b5f8
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1b4cf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
addl $0x1, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %esi
movl -0xc(%rbp), %edx
addl $0x5, %edx
leaq 0x2018a(%rip), %rdi     # 0x3b7ea
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1b686
leaq 0x20fc7(%rip), %rdi     # 0x3c646
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1b6a3
leaq 0x20fc7(%rip), %rdi     # 0x3c663
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1b6c0
leaq 0x20fcb(%rip), %rdi     # 0x3c684
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1b6dd
leaq 0x20fd1(%rip), %rdi     # 0x3c6a7
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1b6fb
leaq 0x20fd4(%rip), %rdi     # 0x3c6c8
movb $0x0, %al
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_ifdb(unsigned char const*, unsigned int)
static void cta_ifdb(const unsigned char *x, unsigned length)
{
	unsigned len_hdr = x[0] >> 5;

	if (length < 2) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}
	printf("    VSIFs: %u\n", x[1]);
	if (length < len_hdr + 2)
		return;
	length -= len_hdr + 2;
	x += len_hdr + 2;
	while (length > 0) {
		int payload_len = x[0] >> 5;

		if ((x[0] & 0x1f) == 1 && length >= 4) {
			unsigned oui = (x[3] << 16) | (x[2] << 8) | x[1];

			printf("    InfoFrame Type Code %u, OUI %s\n",
			       x[0] & 0x1f, ouitohex(oui).c_str());
			x += 4;
			length -= 4;
		} else {
			printf("    InfoFrame Type Code %u\n", x[0] & 0x1f);
			x++;
			length--;
		}
		x += payload_len;
		length -= payload_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
movl %eax, -0x10(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x1baea
movl -0xc(%rbp), %edx
xorl %edi, %edi
leaq 0x1dad1(%rip), %rsi     # 0x395af
movb $0x0, %al
callq 0x47d0
jmp 0x1bc45
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
leaq 0x20e70(%rip), %rdi     # 0x3c969
movb $0x0, %al
callq 0x4050
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jae 0x1bb12
jmp 0x1bc45
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
jbe 0x1bc45
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
cmpl $0x1, %eax
jne 0x1bbf7
cmpl $0x4, -0xc(%rbp)
jb 0x1bbf7
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %eax
shll $0x10, %eax
movzbl 0x2(%rcx), %edx
shll $0x8, %edx
orl %edx, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
movl %eax, -0x48(%rbp)
movl -0x18(%rbp), %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7770
movq -0x50(%rbp), %rdi
callq 0x4150
movl -0x48(%rbp), %esi
movq %rax, %rdx
leaq 0x20dc1(%rip), %rdi     # 0x3c978
xorl %eax, %eax
callq 0x4050
jmp 0x1bbc0
leaq -0x38(%rbp), %rdi
callq 0x41f0
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
subl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bc24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41f0
jmp 0x1bc4b
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
andl $0x1f, %esi
leaq 0x20d94(%rip), %rdi     # 0x3c99c
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bb33
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_microsoft(unsigned char const*, unsigned int)
static void cta_microsoft(const unsigned char *x, unsigned length)
{
	// This VSDB is documented at:
	// https://docs.microsoft.com/en-us/windows-hardware/drivers/display/specialized-monitors-edid-extension
	printf("    Version: %u\n", x[0]);
	if (x[0] > 2) {
		// In version 1 and 2 these bits should always be set to 0.
		printf("    Desktop Usage: %u\n", (x[1] >> 6) & 1);
		printf("    Third-Party Usage: %u\n", (x[1] >> 5) & 1);
	}
	printf("    Display Product Primary Use Case: %u (%s)\n", x[1] & 0x1f,
	       display_use_case(x[1] & 0x1f).c_str());
	printf("    Container ID: %s\n", containerid2s(x + 2).c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
leaq 0x1f151(%rip), %rdi     # 0x3c5b1
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jle 0x1d4ab
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
sarl $0x6, %esi
andl $0x1, %esi
leaq 0x204a4(%rip), %rdi     # 0x3d92c
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
sarl $0x5, %esi
andl $0x1, %esi
leaq 0x2049f(%rip), %rdi     # 0x3d943
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
andl $0x1f, %esi
movl %esi, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1f930
movq -0x70(%rbp), %rdi
callq 0x4150
movl -0x64(%rbp), %esi
movq %rax, %rdx
leaq 0x20482(%rip), %rdi     # 0x3d95e
xorl %eax, %eax
callq 0x4050
jmp 0x1d4e5
leaq -0x30(%rbp), %rdi
callq 0x41f0
movq -0x8(%rbp), %rsi
addq $0x2, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x73d0
movq -0x78(%rbp), %rdi
callq 0x4150
movq %rax, %rsi
leaq 0x20477(%rip), %rdi     # 0x3d98d
xorl %eax, %eax
callq 0x4050
jmp 0x1d51f
leaq -0x60(%rbp), %rdi
callq 0x41f0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41f0
jmp 0x1d55d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41f0
movq -0x38(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_sadb(unsigned char const*, unsigned int)
static void cta_sadb(const unsigned char *x, unsigned length)
{
	unsigned sad;
	unsigned i;

	if (length < 3) {
		fail("Empty Data Block with length %u.\n", length);
		return;
	}

	sad = ((x[2] << 16) | (x[1] << 8) | x[0]);

	for (i = 0; i < ARRAY_SIZE(speaker_map); i++) {
		if ((sad >> i) & 1)
			printf("    %s\n", speaker_map[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jae 0x1d59a
movl -0xc(%rbp), %edx
xorl %edi, %edi
leaq 0x1c01e(%rip), %rsi     # 0x395af
movb $0x0, %al
callq 0x47d0
jmp 0x1d609
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x15, %rax
jae 0x1d609
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1d5fc
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x2e0b6(%rip), %rax     # 0x4b6a0
movq (%rax,%rcx,8), %rsi
leaq 0x1c922(%rip), %rdi     # 0x39f17
movb $0x0, %al
callq 0x4050
jmp 0x1d5fe
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d5c5
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rpavlik[P]edid-decode/parse-cta-block.cpp
// Function: cta_vesa_dtcdb(unsigned char const*, unsigned int)
static void cta_vesa_dtcdb(const unsigned char *x, unsigned length)
{
	if (length != 7 && length != 15 && length != 31) {
		fail("Invalid length %u.\n", length);
		return;
	}

	switch (x[0] >> 6) {
	case 0: printf("    White"); break;
	case 1: printf("    Red"); break;
	case 2: printf("    Green"); break;
	case 3: printf("    Blue"); break;
	}
	unsigned v = x[0] & 0x3f;
	printf(" transfer characteristics: %u", v);
	for (unsigned i = 1; i < length; i++)
		printf(" %u", v += x[i]);
	printf(" 1023\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
je 0x1d649
cmpl $0xf, -0xc(%rbp)
je 0x1d649
cmpl $0x1f, -0xc(%rbp)
je 0x1d649
movl -0xc(%rbp), %edx
xorl %edi, %edi
leaq 0x1e4d8(%rip), %rsi     # 0x3bb15
movb $0x0, %al
callq 0x47d0
jmp 0x1d715
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shrl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x1d6b0
movq -0x20(%rbp), %rax
leaq 0x18947(%rip), %rcx     # 0x35fb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20492(%rip), %rdi     # 0x3db0b
movb $0x0, %al
callq 0x4050
jmp 0x1d6b0
leaq 0x2048c(%rip), %rdi     # 0x3db15
movb $0x0, %al
callq 0x4050
jmp 0x1d6b0
leaq 0x20484(%rip), %rdi     # 0x3db1d
movb $0x0, %al
callq 0x4050
jmp 0x1d6b0
leaq 0x2047e(%rip), %rdi     # 0x3db27
movb $0x0, %al
callq 0x4050
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3f, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
leaq 0x20469(%rip), %rdi     # 0x3db30
movb $0x0, %al
callq 0x4050
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1d707
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %esi
addl -0x10(%rbp), %esi
movl %esi, -0x10(%rbp)
leaq 0x1e0f1(%rip), %rdi     # 0x3b7e6
movb $0x0, %al
callq 0x4050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d6d5
leaq 0x20440(%rip), %rdi     # 0x3db4e
movb $0x0, %al
callq 0x4050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
cmpl $0xfe, %eax
jne 0x1e364
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x90, %rax
addq $0x78, %rax
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x78, %rdi
callq 0x4040
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x90, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x20(%rbp), %rsi
movq %rax, %rdi
movl $0x54, %edx
callq 0x42a0
jmp 0x1e4d9
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
cmpl $0x90, %eax
ja 0x1e42e
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x8, %rax
movq %rax, -0x48(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
movq -0x48(%rbp), %rdi
subl $0x81, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x1fef0
addq $0x78, %rax
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x78, %rdi
callq 0x4040
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x8, %rax
movq %rax, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
movq -0x38(%rbp), %rdi
subl $0x81, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x1fef0
movq %rax, -0x30(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movl $0x54, %edx
callq 0x42a0
jmp 0x1e4d7
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x28, %rax
movq %rax, -0x68(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
movq -0x68(%rbp), %rdi
subl $0x91, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x1fef0
addq $0x78, %rax
movq %rax, -0x60(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x60(%rbp), %rsi
movq %rax, %rdi
addq $0x78, %rdi
callq 0x4040
movq -0x18(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
addq $0x28, %rax
movq %rax, -0x58(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20340
movq -0x58(%rbp), %rdi
subl $0x91, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x1fef0
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x20320
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movl $0x54, %edx
callq 0x42a0
jmp 0x1e4d9
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x180, %rdi            # imm = 0x180
addq $0x40, %rdi
callq 0xb9a0
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
addq $0x40, %rdi
callq 0xba10
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb9d0
testb $0x1, %al
jne 0x1e533
jmp 0x1e56c
leaq -0x10(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20350
testb $0x1, %al
jne 0x1e54a
jmp 0x1e55f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1e2d0
jmp 0x1e561
leaq -0x10(%rbp), %rdi
callq 0xba60
jmp 0x1e508
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
addq $0x128, %rdi            # imm = 0x128
callq 0xb9a0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
addq $0x128, %rdi            # imm = 0x128
callq 0xba10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb9d0
testb $0x1, %al
jne 0x1e5b5
jmp 0x1e5ee
leaq -0x28(%rbp), %rdi
callq 0x20320
movq %rax, %rdi
callq 0x20350
testb $0x1, %al
jne 0x1e5cc
jmp 0x1e5e1
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x1e2d0
jmp 0x1e5e3
leaq -0x28(%rbp), %rdi
callq 0xba60
jmp 0x1e587
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x7, %eax
movb %al, -0xc(%rbp)
movzbl -0x9(%rbp), %eax
andl $-0x8, %eax
movzbl -0xa(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movb %al, -0xd(%rbp)
movzbl -0xc(%rbp), %eax
movzbl -0xb(%rbp), %ecx
cmpl %ecx, %eax
je 0x21b60
movzbl -0xc(%rbp), %edx
movzbl -0xb(%rbp), %ecx
movl $0x1, %edi
leaq 0x1c703(%rip), %rsi     # 0x3e25c
movb $0x0, %al
callq 0x47d0
cmpb $0x0, -0xd(%rbp)
je 0x21b7d
movzbl -0xd(%rbp), %edx
movl $0x1, %edi
leaq 0x1c707(%rip), %rsi     # 0x3e27d
movb $0x0, %al
callq 0x47d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x1d(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x21fd9
movzbl -0x1d(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x21fd9
movzbl -0x1d(%rbp), %edx
movl -0x18(%rbp), %ecx
xorl %edi, %edi
leaq 0x1ee3e(%rip), %rsi     # 0x40e0e
movb $0x0, %al
callq 0x47d0
jmp 0x22027
movzbl -0x1d(%rbp), %eax
cmpl -0x18(%rbp), %eax
jbe 0x21ffb
movzbl -0x1d(%rbp), %edx
movl -0x18(%rbp), %ecx
xorl %edi, %edi
leaq 0x1ee5d(%rip), %rsi     # 0x40e4f
movb $0x0, %al
callq 0x47d0
jmp 0x22025
movzbl -0x1d(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2201d
movzbl -0x1d(%rbp), %edx
movl -0x14(%rbp), %ecx
xorl %edi, %edi
leaq 0x1ee79(%rip), %rsi     # 0x40e8d
movb $0x0, %al
callq 0x47d0
jmp 0x22023
movb $0x1, -0x1(%rbp)
jmp 0x22060
jmp 0x22025
jmp 0x22027
movzbl -0x1d(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x2205c
movq -0x10(%rbp), %rsi
addq $0x3, %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movzbl -0x1d(%rbp), %edx
subl -0x1c(%rbp), %edx
leaq 0x12793(%rip), %rdi     # 0x347df
movl $0x1, %ecx
movl $0x10, %r8d
callq 0x7860
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: print_flag_lines(char const*, char const*, unsigned char, char const**)
static void print_flag_lines(const char *indent, const char *label,
			     unsigned char flag_byte, const char **flags)
{
	if (flag_byte) {
		printf("%s\n", label);

		for (int i = 0; i < 8; i++)
			if (flag_byte & (1 << i))
				printf("%s%s\n", indent, flags[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x220f2
movq -0x10(%rbp), %rsi
leaq 0x17e81(%rip), %rdi     # 0x39f1b
movb $0x0, %al
callq 0x4050
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x220f0
movzbl -0x11(%rbp), %eax
movl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x220e3
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x123bd(%rip), %rdi     # 0x34499
movb $0x0, %al
callq 0x4050
jmp 0x220e5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x220a8
jmp 0x220f2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movzbl 0x1(%rax), %esi
movl %ecx, %edx
callq 0x21b00
movq -0x10(%rbp), %rdi
movl $0x6, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x21f90
testb $0x1, %al
jne 0x24590
jmp 0x24650
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
sarl $0x4, %eax
cvtsi2sd %eax, %xmm0
movsd 0x195b1(%rip), %xmm1    # 0x3db58
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %esi
andl $0xf, %esi
shll %esi
leaq 0x1a887(%rip), %rdi     # 0x3ee46
movb $0x1, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %esi
andl $0x3f, %esi
shll %esi
leaq 0x1a897(%rip), %rdi     # 0x3ee71
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %esi
andl $0x3f, %esi
shll %esi
leaq 0x1a8a6(%rip), %rdi     # 0x3ee9b
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
andl $0x7f, %eax
imull $0xa, %eax, %esi
leaq 0x1a8b4(%rip), %rdi     # 0x3eec5
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0x3f, %eax
imull $0xa, %eax, %esi
leaq 0x1a8bc(%rip), %rdi     # 0x3eee9
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
andl $0x3f, %eax
imull $0xa, %eax, %esi
leaq 0x1a8c4(%rip), %rdi     # 0x3ef0d
movb $0x0, %al
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpb $0x0, -0x9(%rbp)
jne 0x24f78
jmp 0x2504d
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1c1a8(%rip), %rdi     # 0x41132
movb $0x0, %al
callq 0x4050
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jae 0x2503f
movzbl -0x9(%rbp), %eax
movl %eax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x24fbc
movl $0x7, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x24fc2
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2502f
cmpl $0x0, -0x20(%rbp)
je 0x24fec
leaq 0xad14(%rip), %rdi      # 0x2fcf9
movb $0x0, %al
callq 0x4050
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x25015
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq 0xafb0(%rip), %rdi      # 0x2ffbc
movb $0x0, %al
callq 0x4050
jmp 0x25026
movl -0x24(%rbp), %esi
leaq 0x1bfa4(%rip), %rdi     # 0x40fc3
movb $0x0, %al
callq 0x4050
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25031
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x24f98
leaq 0xa8c3(%rip), %rdi      # 0x2f909
movb $0x0, %al
callq 0x4050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x7c00, %eax           # imm = 0x7C00
sarl $0xa, %eax
subl $0xf, %eax
movl %eax, -0x10(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0x400, %eax            # imm = 0x400
movl %eax, -0x14(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x26c57
leaq -0x15(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4560
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x1a3b0(%rip), %rsi     # 0x40fd8
callq 0xb510
jmp 0x26c2f
leaq -0x15(%rbp), %rdi
callq 0x4370
jmp 0x26d17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x4370
jmp 0x26d21
movzwl -0xa(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x26cad
leaq -0x25(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4560
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x130fc(%rip), %rsi     # 0x39d7d
callq 0xb510
jmp 0x26c88
leaq -0x25(%rbp), %rdi
callq 0x4370
jmp 0x26d17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4370
jmp 0x26d21
movl -0x10(%rbp), %esi
movl $0x2, %edi
callq 0x2a990
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movsd 0x16ea2(%rip), %xmm1    # 0x3db70
mulsd %xmm1, %xmm0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2a940
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
leaq 0x1a2f5(%rip), %rdx     # 0x40fe3
callq 0xb4c0
jmp 0x26cf5
leaq -0x48(%rbp), %rdi
callq 0x41f0
jmp 0x26d17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
jmp 0x26d21
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4550
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x7, %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
xorl %edx, %edx
movzbl %cl, %esi
movzbl %al, %ecx
callq 0x21b00
movq -0x10(%rbp), %rdi
movl $0x9, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x21f90
testb $0x1, %al
jne 0x27106
jmp 0x27201
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x8, %eax
orl %eax, %esi
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x10, %eax
orl %eax, %esi
addl $0x1, %esi
leaq 0x18cf6(%rip), %rdi     # 0x3fe28
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
shll $0x8, %eax
orl %eax, %esi
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
shll $0x10, %eax
orl %eax, %esi
addl $0x1, %esi
leaq 0x18ce4(%rip), %rdi     # 0x3fe49
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %esi
leaq 0x18cef(%rip), %rdi     # 0x3fe6a
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x271ba
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
andl $0x3, %eax
shll $0x8, %eax
addl %eax, %esi
leaq 0x18ce3(%rip), %rdi     # 0x3fe94
movb $0x0, %al
callq 0x4050
jmp 0x271d0
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %esi
leaq 0x18ccb(%rip), %rdi     # 0x3fe94
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %ecx
andl $0x80, %ecx
leaq 0x14ef2(%rip), %rsi     # 0x3c0d7
leaq 0x14ee7(%rip), %rax     # 0x3c0d3
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x18cc4(%rip), %rdi     # 0x3febe
movb $0x0, %al
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_ContainerID(unsigned char const*)
void edid_state::parse_displayid_ContainerID(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	if (check_displayid_datablock_length(x, 16, 16)) {
		x += 3;
		printf("    Container ID: %s\n", containerid2s(x).c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movzbl 0x1(%rax), %esi
movl %ecx, %edx
callq 0x21b00
movq -0x10(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x21f90
testb $0x1, %al
jne 0x2757d
jmp 0x275d8
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x73d0
movq -0x48(%rbp), %rdi
callq 0x4150
movq %rax, %rsi
leaq 0x163e0(%rip), %rdi     # 0x3d98d
xorl %eax, %eax
callq 0x4050
jmp 0x275b6
leaq -0x30(%rbp), %rdi
callq 0x41f0
jmp 0x275d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41f0
jmp 0x275de
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4550
nopw (%rax,%rax)
// File: rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_cta_data_block(unsigned char const*)
void edid_state::parse_displayid_cta_data_block(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	unsigned len = x[2];
	unsigned i;

	if (len > 248) {
		fail("Length is > 248.\n");
		len = 248;
	}
	x += 3;

	for (i = 0; i < len; i += (x[i] & 0x1f) + 1) {
		unsigned tag = (x[i] & 0xe0) << 3;

		if (tag == 0x700)
			tag |= x[i + 1];
		bool duplicate = dispid.found_tags.find(tag) != dispid.found_tags.end();

		cta_block(x + i, duplicate);
		if (!duplicate)
			dispid.found_tags.insert(tag);
	}

	if (i != len)
		fail("Length is %u instead of %u.\n", len, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movzbl 0x1(%rax), %esi
movl %ecx, %edx
callq 0x21b00
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xf8, -0x14(%rbp)
jbe 0x27d34
xorl %edi, %edi
leaq 0x185a6(%rip), %rsi     # 0x402cc
movb $0x0, %al
callq 0x47d0
movl $0xf8, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x27e2c
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %eax
andl $0xe0, %eax
shll $0x3, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x700, -0x1c(%rbp)     # imm = 0x700
jne 0x27d88
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x48(%rbp), %rdi
addq $0x910, %rdi            # imm = 0x910
addq $0x38, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x20260
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x910, %rdi            # imm = 0x910
addq $0x38, %rdi
callq 0x202a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20230
movq -0x48(%rbp), %rdi
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x1c230
testb $0x1, -0x1d(%rbp)
jne 0x27e0e
movq -0x48(%rbp), %rdi
addq $0x910, %rdi            # imm = 0x910
addq $0x38, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x202d0
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
jmp 0x27e10
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %eax
andl $0x1f, %eax
addl $0x1, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x27d47
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x27e4a
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
xorl %edi, %edi
leaq 0x1849b(%rip), %rsi     # 0x402de
movb $0x0, %al
callq 0x47d0
addq $0x50, %rsp
popq %rbp
retq
// File: rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::preparse_displayid_block(unsigned char const*)
void edid_state::preparse_displayid_block(const unsigned char *x)
{
	unsigned length = x[2];

	if (length > 121)
		length = 121;

	unsigned offset = 5;

	dispid.preparsed_displayid_blocks++;
	while (length > 0) {
		unsigned tag = x[offset];
		unsigned len = x[offset + 2];

		switch (tag) {
		case 0x02:
			dispid.preparsed_color_ids |= 1 << ((x[offset + 1] >> 3) & 0x0f);
			break;
		case 0x0e:
			dispid.preparsed_xfer_ids |= 1 << ((x[offset + 1] >> 4) & 0x0f);
			break;
		default:
			break;
		}

		if (length < 3)
			break;

		if (length < len + 3)
			break;

		if (!tag && !len)
			break;

		length -= len + 3;
		offset += len + 3;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x79, -0x14(%rbp)
jbe 0x2875c
movl $0x79, -0x14(%rbp)
movq -0x28(%rbp), %rax
movl $0x5, -0x18(%rbp)
movl 0x918(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x918(%rax)
cmpl $0x0, -0x14(%rbp)
jbe 0x28862
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x2, %eax
je 0x287b6
jmp 0x287ac
movl -0x2c(%rbp), %eax
subl $0xe, %eax
je 0x287e9
jmp 0x2881c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
sarl $0x3, %ecx
andl $0xf, %ecx
movl $0x1, %edx
shll %cl, %edx
movzwl 0x912(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x912(%rax)
jmp 0x2881e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
movl $0x1, %edx
shll %cl, %edx
movzwl 0x914(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x914(%rax)
jmp 0x2881e
jmp 0x2881e
cmpl $0x3, -0x14(%rbp)
jae 0x28826
jmp 0x28862
movl -0x14(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x3, %ecx
cmpl %ecx, %eax
jae 0x28835
jmp 0x28862
cmpl $0x0, -0x1c(%rbp)
jne 0x28843
cmpl $0x0, -0x20(%rbp)
jne 0x28843
jmp 0x28862
movl -0x20(%rbp), %ecx
addl $0x3, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl $0x3, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x28776
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::check_displayid_blocks()
void edid_state::check_displayid_blocks()
{
	data_block = "DisplayID";
	if (!dispid.has_product_identification)
		fail("Missing DisplayID Product Identification Data Block.\n");
	if (dispid.is_display && !dispid.has_display_parameters)
		fail("Missing DisplayID Display Parameters Data Block.\n");
	if (dispid.is_display && !dispid.has_display_interface_features)
		fail("Missing DisplayID Display Interface Features Data Block.\n");
	if (dispid.is_display && !dispid.has_type_1_7)
		fail("Missing DisplayID Type %s Detailed Timing Data Block.\n",
		     dispid.version >= 0x20 ? "VII" : "I");
	if (dispid.preferred_timings.empty())
		fail("DisplayID expects at least one preferred timing.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x30, %rdi
leaq 0x164a6(%rip), %rsi     # 0x40cf5
callq 0x4420
movq -0x10(%rbp), %rax
testb $0x1, 0x91e(%rax)
jne 0x2a871
xorl %edi, %edi
leaq 0x16495(%rip), %rsi     # 0x40cff
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rax
testb $0x1, 0x91d(%rax)
je 0x2a89b
movq -0x10(%rbp), %rax
testb $0x1, 0x91f(%rax)
jne 0x2a89b
xorl %edi, %edi
leaq 0x164a1(%rip), %rsi     # 0x40d35
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rax
testb $0x1, 0x91d(%rax)
je 0x2a8c5
movq -0x10(%rbp), %rax
testb $0x1, 0x921(%rax)
jne 0x2a8c5
xorl %edi, %edi
leaq 0x164a9(%rip), %rsi     # 0x40d67
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rax
testb $0x1, 0x91d(%rax)
je 0x2a90f
movq -0x10(%rbp), %rax
testb $0x1, 0x920(%rax)
jne 0x2a90f
movq -0x10(%rbp), %rax
movzbl 0x910(%rax), %ecx
leaq 0xacb0(%rip), %rdx      # 0x355a1
leaq 0x164e0(%rip), %rax     # 0x40dd8
cmpl $0x20, %ecx
cmovgeq %rax, %rdx
xorl %edi, %edi
leaq 0x16499(%rip), %rsi     # 0x40da1
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rdi
addq $0x910, %rdi            # imm = 0x910
addq $0x18, %rdi
callq 0xb930
testb $0x1, %al
jne 0x2a929
jmp 0x2a939
xorl %edi, %edi
leaq 0x164aa(%rip), %rsi     # 0x40ddc
movb $0x0, %al
callq 0x47d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rpavlik[P]edid-decode/parse-ls-ext-block.cpp
// Function: parse_string(char const*, unsigned char const*)
static void parse_string(const char *name, const unsigned char *x)
{
	if (!*x)
		return;
	printf("  %s: ", name);
	hex_block("", x + 1, *x, true, *x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2af2b
jmp 0x2af65
movq -0x8(%rbp), %rsi
leaq 0x161fa(%rip), %rdi     # 0x41130
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rax
movzbl (%rax), %edx
movq -0x10(%rbp), %rax
movzbl (%rax), %r8d
leaq 0x4f5e(%rip), %rdi      # 0x2feb9
movl $0x1, %ecx
callq 0x7860
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rpavlik[P]edid-decode/parse-ls-ext-block.cpp
// Function: edid_state::parse_ls_ext_block(unsigned char const*)
void edid_state::parse_ls_ext_block(const unsigned char *x)
{
	const unsigned char *orig = x;

	printf("  Version: %u.%u\n  Unicode Version: %u.%u.%u\n",
	       x[1], x[2], (x[3] >> 4), x[3] & 0x0f, x[4]);
	x += 5;

	while (x[0] && x + x[0] < orig + 127) {
		parse_string_table(x + 1);
		x += x[0];
	}
	if (!memchk(x, orig + 127 - x)) {
		data_block.clear();
		fail("Non-zero values in unused space.\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %edx
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
sarl $0x4, %ecx
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %r8d
andl $0xf, %r8d
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %r9d
leaq 0x16118(%rip), %rdi     # 0x410e0
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x2b00b
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
addq $0x7f, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2b014
jmp 0x2b03c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x2ad10
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x2afdb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x7f, %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
xorl %edx, %edx
callq 0x7810
testb $0x1, %al
jne 0x2b079
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x4400
xorl %edi, %edi
leaq 0x1609c(%rip), %rsi     # 0x4110e
movb $0x0, %al
callq 0x47d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rpavlik[P]edid-decode/parse-di-ext-block.cpp
// Function: edid_state::parse_di_ext_block(unsigned char const*)
void edid_state::parse_di_ext_block(const unsigned char *x)
{
	printf("  Version: %u\n", x[1]);
	if (!x[1])
		fail("Invalid version 0.\n");

	parse_digital_interface(x);
	parse_display_device(x);
	parse_display_caps(x);
	if (!memchk(x + 0x27, 16))
		fail("Bytes 0x27-0x36 should be 0.\n");
	if (!memchk(x + 0x37, 17))
		fail("Bytes 0x37-0x47 should be 0.\n");
	if (!memchk(x + 0x48, 9))
		fail("Bytes 0x48-0x50 should be 0.\n");
	parse_display_xfer(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %esi
leaq 0xf82c(%rip), %rdi      # 0x3c5b3
movb $0x0, %al
callq 0x4050
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x2cda8
xorl %edi, %edi
leaq 0x15d0e(%rip), %rsi     # 0x42aaf
movb $0x0, %al
callq 0x47d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b080
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b790
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bbf0
movq -0x10(%rbp), %rdi
addq $0x27, %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x7810
testb $0x1, %al
jne 0x2cdf7
xorl %edi, %edi
leaq 0x15cd3(%rip), %rsi     # 0x42ac3
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rdi
addq $0x37, %rdi
movl $0x11, %esi
xorl %edx, %edx
callq 0x7810
testb $0x1, %al
jne 0x2ce1f
xorl %edi, %edi
leaq 0x15cc9(%rip), %rsi     # 0x42ae1
movb $0x0, %al
callq 0x47d0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x7810
testb $0x1, %al
jne 0x2ce47
xorl %edi, %edi
leaq 0x15cbf(%rip), %rsi     # 0x42aff
movb $0x0, %al
callq 0x47d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ca70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)