LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19ed6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16e3b(%rip), %rsi     # 0x30d05
leaq 0x16e3e(%rip), %rdx     # 0x30d0f
jmp 0x19f7b
movl %esi, %ebp
testw %bp, %bp
js 0x19f66
movl %ebp, %edi
shrl $0xa, %edi
andl $0x1f, %edi
addl $-0xf, %edi
andl $0x3ff, %ebp            # imm = 0x3FF
orl $0x400, %ebp            # imm = 0x400
movsd 0xa7c8(%rip), %xmm0     # 0x246c8
callq 0x3370
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm0
mulsd 0x14703(%rip), %xmm0    # 0x2e618
movq 0x200ac(%rip), %rsi     # 0x39fc8
leaq 0x16df5(%rip), %rcx     # 0x30d18
movq %rsp, %r14
movl $0x148, %edx            # imm = 0x148
movq %r14, %rdi
movb $0x1, %al
callq 0x1d6b7
leaq 0x16dd4(%rip), %rsi     # 0x30d10
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 0x19f85
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x19f8d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1060d(%rip), %rsi     # 0x2a581
leaq 0x1060e(%rip), %rdx     # 0x2a589
movq %rbx, %rdi
callq 0x8f6e
jmp 0x19fbf
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 0x19fbf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rax
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 0x19fe9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1627c
movq %rbx, %rdi
movl $0x9, %esi
movl $0x9, %edx
xorl %ecx, %ecx
callq 0x165ab
testb %al, %al
je 0x1a56f
movzwl 0x3(%rbx), %eax
movzbl 0x5(%rbx), %ecx
shll $0x10, %ecx
leal (%rax,%rcx), %esi
incl %esi
leaq 0x1570c(%rip), %rdi     # 0x2fbfb
xorl %eax, %eax
callq 0x3030
movzwl 0x6(%rbx), %eax
movzbl 0x8(%rbx), %ecx
shll $0x10, %ecx
leal (%rax,%rcx), %esi
incl %esi
leaq 0x1570f(%rip), %rdi     # 0x2fc1c
xorl %eax, %eax
callq 0x3030
movzbl 0x9(%rbx), %esi
leaq 0x1571e(%rip), %rdi     # 0x2fc3d
xorl %eax, %eax
callq 0x3030
testb $0x7, 0x1(%rbx)
movzbl 0xa(%rbx), %esi
je 0x1a53c
movzbl 0xb(%rbx), %eax
andl $0x3, %eax
shll $0x8, %eax
orl %eax, %esi
leaq 0x15724(%rip), %rdi     # 0x2fc67
xorl %eax, %eax
callq 0x3030
cmpb $0x0, 0xb(%rbx)
leaq 0x11de2(%rip), %rax     # 0x2c337
leaq 0x11dd7(%rip), %rsi     # 0x2c333
cmovnsq %rax, %rsi
leaq 0x1572a(%rip), %rdi     # 0x2fc91
xorl %eax, %eax
popq %rbx
jmp 0x3030
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1627c
movq %rbx, %rdi
movl $0x10, %esi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x165ab
testb %al, %al
je 0x1a880
addq $0x3, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa
movq (%r14), %rsi
leaq 0x12b55(%rip), %rdi     # 0x2d3b4
xorl %eax, %eax
callq 0x3030
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1a880
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/parse-displayid-block.cpp
// Function: edid_state::parse_displayid_vesa(unsigned char const*)
void edid_state::parse_displayid_vesa(const unsigned char *x)
{
	check_displayid_datablock_revision(x[1]);

	if (!check_displayid_datablock_length(x, 5, 7))
		return;

	unsigned len = x[2];
	x += 6;
	printf("    Data Structure Type: ");
	switch (x[0] & 0x07) {
	case 0x00: printf("eDP\n"); break;
	case 0x01: printf("DP\n"); break;
	default: printf("Reserved\n"); break;
	}
	printf("    Default Colorspace and EOTF Handling: %s\n",
	       (x[0] & 0x80) ? "Native as specified in the Display Parameters DB" : "sRGB");
	printf("    Number of Pixels in Hor Pix Cnt Overlapping an Adjacent Panel: %u\n",
	       x[1] & 0xf);
	printf("    Multi-SST Operation: ");
	switch ((x[1] >> 5) & 0x03) {
	case 0x00: printf("Not Supported\n"); break;
	case 0x01: printf("Two Streams (number of links shall be 2 or 4)\n"); break;
	case 0x02: printf("Four Streams (number of links shall be 4)\n"); break;
	case 0x03: printf("Reserved\n"); break;
	}
	if (len >= 7) {
		double bpp = (x[2] & 0x3f) + (x[3] & 0x0f) / 16.0;
		printf("    Pass through timing's target DSC bits per pixel: %.4f\n", bpp);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl 0x1(%rsi), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1627c
movq %rbx, %rdi
movl $0x5, %esi
movl $0x7, %edx
xorl %ecx, %ecx
callq 0x165ab
testb %al, %al
je 0x1af81
movb 0x2(%rbx), %bpl
leaq 0x1506b(%rip), %rdi     # 0x2ff17
xorl %eax, %eax
callq 0x3030
movb 0x6(%rbx), %al
andb $0x7, %al
cmpb $0x1, %al
leaq 0x1696b(%rip), %rcx     # 0x3182c
leaq 0x166b8(%rip), %rdx     # 0x31580
cmoveq %rcx, %rdx
testb %al, %al
leaq 0x16956(%rip), %rdi     # 0x3182b
cmovneq %rdx, %rdi
callq 0x3380
cmpb $0x0, 0x6(%rbx)
leaq 0x150a7(%rip), %rax     # 0x2ff90
leaq 0x1506f(%rip), %rsi     # 0x2ff5f
cmovnsq %rax, %rsi
leaq 0x15036(%rip), %rdi     # 0x2ff31
xorl %eax, %eax
callq 0x3030
movzbl 0x7(%rbx), %esi
andl $0xf, %esi
leaq 0x15085(%rip), %rdi     # 0x2ff95
xorl %eax, %eax
callq 0x3030
leaq 0x150be(%rip), %rdi     # 0x2ffdc
xorl %eax, %eax
callq 0x3030
movzbl 0x7(%rbx), %eax
shrl $0x3, %eax
andl $0xc, %eax
leaq 0x13c2a(%rip), %rcx     # 0x2eb60
movslq (%rax,%rcx), %rdi
addq %rcx, %rdi
callq 0x3380
cmpb $0x7, %bpl
jb 0x1af81
movb 0x8(%rbx), %al
movb 0x9(%rbx), %cl
andb $0x3f, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm1
andb $0xf, %cl
movzbl %cl, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x136bf(%rip), %xmm0    # 0x2e628
addsd %xmm1, %xmm0
leaq 0x15082(%rip), %rdi     # 0x2fff6
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movzbl 0x1(%rsi), %esi
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1627c
movzbl 0x2(%r14), %r15d
cmpl $0xf9, %r15d
jb 0x1afd1
leaq 0x1506f(%rip), %rsi     # 0x30031
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movl $0xf8, %r15d
testl %r15d, %r15d
je 0x1b0a7
addq $0x3, %r14
movq 0x8(%rsp), %rax
leaq 0x948(%rax), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x950(%rax), %rbp
xorl %ebx, %ebx
movl %ebx, %eax
leaq (%r14,%rax), %r13
movzbl (%r14,%rax), %eax
movl %eax, %ecx
andl $-0x20, %ecx
shll $0x3, %ecx
movl %ecx, 0x4(%rsp)
cmpb $-0x20, %al
jb 0x1b021
movzbl 0x1(%r13), %eax
orl $0x700, %eax            # imm = 0x700
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x958(%rax), %rcx
movq %rbp, %rax
testq %rcx, %rcx
je 0x1b053
movl 0x4(%rsp), %edx
movq %rbp, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x1b03c
movq %rbp, %r12
cmpq %rbp, %rax
je 0x1b069
movl 0x4(%rsp), %ecx
cmpl 0x20(%rax), %ecx
cmovbq %rbp, %rax
movq %rax, %r12
xorl %edx, %edx
cmpq %rbp, %r12
setne %dl
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x12e60
cmpq %rbp, %r12
jne 0x1b092
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1616c
movzbl (%r13), %eax
andl $0x1f, %eax
addl %eax, %ebx
incl %ebx
cmpl %r15d, %ebx
jb 0x1aff8
cmpl %r15d, %ebx
je 0x1b0c1
leaq 0x14f90(%rip), %rsi     # 0x30043
xorl %edi, %edi
movl %r15d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x37ec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movzbl 0x2(%rsi), %eax
cmpb $0x79, %al
movl $0x79, %ecx
cmovbl %eax, %ecx
incl 0x918(%rdi)
movzbl %cl, %r8d
movzwl 0x912(%rdi), %eax
movzwl 0x914(%rdi), %ecx
movl $0x5, %edx
testl %r8d, %r8d
je 0x1b7e6
movl %edx, %r9d
movzbl (%rsi,%r9), %r9d
leal 0x2(%rdx), %r10d
movzbl (%rsi,%r10), %r10d
cmpl $0xe, %r9d
je 0x1b79d
cmpl $0x2, %r9d
jne 0x1b7b5
leal 0x1(%rdx), %r11d
movb (%rsi,%r11), %r11b
shrb $0x3, %r11b
andb $0xf, %r11b
btsl %r11d, %eax
movw %ax, 0x912(%rdi)
jmp 0x1b7b5
leal 0x1(%rdx), %r11d
movzbl (%rsi,%r11), %r11d
shrl $0x4, %r11d
btsl %r11d, %ecx
movw %cx, 0x914(%rdi)
cmpl $0x3, %r8d
jb 0x1b7da
leal 0x3(%r10), %r11d
movl %r8d, %ebx
subl %r11d, %ebx
jb 0x1b7da
orb %r9b, %r10b
je 0x1b7da
addl %edx, %r11d
movb $0x1, %r9b
movl %r11d, %edx
movl %ebx, %r8d
jmp 0x1b7dd
xorl %r9d, %r9d
testb %r9b, %r9b
jne 0x1b75a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
addq $0x30, %rdi
movq 0x38(%rbx), %rdx
leaq 0x1343f(%rip), %rcx     # 0x30a2e
movl $0x9, %r8d
xorl %esi, %esi
callq 0x3390
cmpb $0x0, 0x91e(%rbx)
jne 0x1d615
leaq 0x1342c(%rip), %rsi     # 0x30a38
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
cmpb $0x1, 0x91d(%rbx)
jne 0x1d637
cmpb $0x0, 0x91f(%rbx)
jne 0x1d637
leaq 0x13440(%rip), %rsi     # 0x30a6e
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
cmpb $0x1, 0x91d(%rbx)
jne 0x1d659
cmpb $0x0, 0x921(%rbx)
jne 0x1d659
leaq 0x13450(%rip), %rsi     # 0x30aa0
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
cmpb $0x1, 0x91d(%rbx)
jne 0x1d694
cmpb $0x0, 0x920(%rbx)
jne 0x1d694
cmpb $0x20, 0x910(%rbx)
leaq 0x13498(%rip), %rax     # 0x30b11
leaq 0xff2d(%rip), %rdx      # 0x2d5ad
cmovaeq %rax, %rdx
leaq 0x1344f(%rip), %rsi     # 0x30ada
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movq 0x928(%rbx), %rax
cmpq 0x930(%rbx), %rax
je 0x1d6a6
popq %rbx
retq
leaq 0x13468(%rip), %rsi     # 0x30b15
xorl %edi, %edi
xorl %eax, %eax
popq %rbx
jmp 0x37ec
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/parse-ls-ext-block.cpp
// Function: edid_state::parse_string_table(unsigned char const*)
void edid_state::parse_string_table(const unsigned char *x)
{
	printf("  UTF Type: ");
	switch (x[0] & 7) {
	case 0: printf("UTF 8\n"); break;
	case 1: printf("UTF 16BE\n"); break;
	case 2: printf("UTF 32BE\n"); break;
	default:
		printf("Unknown (0x%02x)\n", x[0] & 7);
		fail("Unknown UTF Type (0x%02x).\n", x[0] & 7);
		break;
	}
	printf("  Country Code ID (ISO 3166-3): %u\n", ((x[1] & 0x3f) << 8) | x[2]);

	if (x[3] || x[4]) {
		char name[4];

		name[0] = ((x[3] & 0x7c) >> 2) + '@';
		name[1] = ((x[3] & 0x03) << 3) + ((x[4] & 0xe0) >> 5) + '@';
		name[2] = (x[4] & 0x1f) + '@';
		name[3] = 0;
		if (name[0] == '@') name[0] = ' ';
		if (name[1] == '@') name[1] = ' ';
		if (name[2] == '@') name[2] = ' ';
		printf("  Language ID: '%s'\n", name);
	}
	x += 5;
	parse_string("Manufacturer Name", x);
	x += x[0] + 1;
	parse_string("Model Name", x);
	x += x[0] + 1;
	if (hide_serial_numbers)
		printf("  Serial Number: ...\n");
	else
		parse_string("Serial Number", x);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14139(%rip), %rdi     # 0x318b2
xorl %eax, %eax
callq 0x3030
movzbl (%r14), %esi
andl $0x7, %esi
cmpl $0x2, %esi
je 0x1d7a7
cmpl $0x1, %esi
je 0x1d79e
testl %esi, %esi
jne 0x1d7b5
leaq 0x141fe(%rip), %rdi     # 0x3199a
jmp 0x1d7ae
leaq 0x141ec(%rip), %rdi     # 0x31991
jmp 0x1d7ae
leaq 0x141da(%rip), %rdi     # 0x31988
callq 0x3380
jmp 0x1d7da
leaq 0x7700(%rip), %rdi      # 0x24ebc
xorl %eax, %eax
callq 0x3030
movzbl (%r14), %edx
andl $0x7, %edx
leaq 0x140ee(%rip), %rsi     # 0x318bf
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0x1(%r14), %eax
andl $0x3f, %eax
shll $0x8, %eax
movzbl 0x2(%r14), %esi
orl %eax, %esi
leaq 0x140e8(%rip), %rdi     # 0x318db
xorl %eax, %eax
callq 0x3030
movb 0x3(%r14), %sil
testb %sil, %sil
jne 0x1d80a
cmpb $0x0, 0x4(%r14)
je 0x1d871
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1f, %cl
leal 0x40(%rcx), %eax
movb %al, 0x4(%rsp)
movb 0x4(%r14), %al
shlb $0x3, %sil
movl %eax, %edx
shrb $0x5, %dl
orb %sil, %dl
andb $0x1f, %dl
leal 0x40(%rdx), %esi
movb %sil, 0x5(%rsp)
andb $0x1f, %al
leal 0x40(%rax), %esi
movb %sil, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
testb %cl, %cl
jne 0x1d84c
movb $0x20, 0x4(%rsp)
testb %dl, %dl
jne 0x1d855
movb $0x20, 0x5(%rsp)
testb %al, %al
jne 0x1d85e
movb $0x20, 0x6(%rsp)
leaq 0x1409a(%rip), %rdi     # 0x318ff
leaq 0x4(%rsp), %rsi
xorl %eax, %eax
callq 0x3030
leaq 0x5(%r14), %rsi
leaq 0x14098(%rip), %rdi     # 0x31914
callq 0x1d8cf
movzbl 0x5(%r14), %eax
addq %rax, %r14
addq $0x6, %r14
leaq 0x14092(%rip), %rdi     # 0x31926
movq %r14, %rsi
callq 0x1d8cf
cmpb $0x1, 0x52(%rbx)
jne 0x1d8b0
leaq 0x8ca5(%rip), %rdi      # 0x2654e
callq 0x3380
jmp 0x1d8c7
movzbl (%r14), %eax
leaq (%r14,%rax), %rsi
incq %rsi
leaq 0x8044(%rip), %rdi      # 0x25906
callq 0x1d8cf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x1(%rsi), %esi
movzbl 0x2(%r14), %edx
movzbl 0x3(%r14), %r8d
movl %r8d, %ecx
shrl $0x4, %ecx
andl $0xf, %r8d
movzbl 0x4(%r14), %r9d
leaq 0x13ff5(%rip), %rdi     # 0x31931
xorl %eax, %eax
callq 0x3030
leaq 0x5(%r14), %r15
movb 0x5(%r14), %al
decb %al
movl $0x7a, %esi
cmpb $0x78, %al
ja 0x1d98f
movl $0x5, %eax
movq %rax, %r12
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x1d768
movzbl (%r15), %eax
addq %r12, %rax
leaq (%r14,%rax), %r15
movzbl (%r14,%rax), %ecx
testq %rcx, %rcx
je 0x1d988
addq %rax, %rcx
cmpq $0x7f, %rcx
jb 0x1d95b
movl $0x7f, %esi
subl %eax, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x5b92
testb %al, %al
je 0x1d9a9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
leaq 0x13fa0(%rip), %rsi     # 0x3195f
xorl %edi, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x37ec
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x1(%rsi), %esi
leaq 0xd7dc(%rip), %rdi      # 0x2c711
xorl %eax, %eax
callq 0x3030
cmpb $0x0, 0x1(%rbx)
jne 0x1ef52
leaq 0x13c52(%rip), %rsi     # 0x32b9b
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d9d4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e00e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e304
leaq 0x27(%rbx), %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x5b92
testb %al, %al
jne 0x1ef97
leaq 0x13c21(%rip), %rsi     # 0x32baf
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
leaq 0x37(%rbx), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq 0x5b92
testb %al, %al
jne 0x1efbb
leaq 0x13c1b(%rip), %rsi     # 0x32bcd
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
leaq 0x48(%rbx), %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x5b92
testb %al, %al
jne 0x1efdf
leaq 0x13c15(%rip), %rsi     # 0x32beb
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eca4
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/parse-vtb-ext-block.cpp
// Function: edid_state::parse_vtb_ext_block(unsigned char const*)
void edid_state::parse_vtb_ext_block(const unsigned char *x)
{
	printf("  Version: %u\n", x[1]);
	if (x[1] != 1)
		fail("Invalid version %u.\n", x[1]);

	unsigned num_dtd = x[2];
	unsigned num_cvt = x[3];
	unsigned num_st = x[4];

	x += 5;
	if (num_dtd) {
		printf("  Detailed Timing Descriptors:\n");
		for (unsigned i = 0; i < num_dtd; i++, x += 18)
			detailed_timings("    ", x, false);
	}
	if (num_cvt) {
		printf("  Coordinated Video Timings:\n");
		for (unsigned i = 0; i < num_cvt; i++, x += 3)
			detailed_cvt_descriptor("    ", x, false);
	}
	if (num_st) {
		// Note: the VTB-EXT standard has a mistake in the example EDID
		// that it provides: there the refresh rate (bits 5-0 of the
		// second byte) is set to 60 for 60 Hz, but this should be 0
		// since the actual refresh rate is the value + 60.
		//
		// The documentation itself is correct, though.
		printf("  Standard Timings:\n");
		for (unsigned i = 0; i < num_st; i++, x += 2)
			print_standard_timing("    ", x[0], x[1], true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x1(%rsi), %esi
leaq 0xd701(%rip), %rdi      # 0x2c711
xorl %eax, %eax
callq 0x3030
movzbl 0x1(%r15), %edx
cmpl $0x1, %edx
je 0x1f031
leaq 0x14303(%rip), %rsi     # 0x3332b
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
movzbl 0x2(%r15), %r13d
leaq 0x5(%r15), %r14
movzbl 0x3(%r15), %ebp
movzbl 0x4(%r15), %r12d
testl %r13d, %r13d
je 0x1f075
leaq 0x142f0(%rip), %rdi     # 0x33340
callq 0x3380
leaq 0x63eb(%rip), %r15      # 0x25447
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xb374
addq $0x12, %r14
decl %r13d
jne 0x1f05c
testl %ebp, %ebp
je 0x1f0a4
leaq 0x142df(%rip), %rdi     # 0x3335f
callq 0x3380
leaq 0x63bb(%rip), %r15      # 0x25447
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9e26
addq $0x3, %r14
decl %ebp
jne 0x1f08c
testq %r12, %r12
je 0x1f0e6
leaq 0x142cc(%rip), %rdi     # 0x3337c
callq 0x3380
xorl %r13d, %r13d
leaq 0x6388(%rip), %r15      # 0x25447
movzbl (%r14,%r13,2), %edx
movzbl 0x1(%r14,%r13,2), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0xa252
incq %r13
cmpl %r13d, %r12d
jne 0x1f0bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/0918nobita[P]algorithm/polynomial1.cc
// Function: main
int main() {
  int X0, N;
  std::cin >> X0 >> N;
  std::vector<int> S(N);

  for (int i = 0; i < N; i++) {
    int a;
    std::cin >> a;
    S[i] = a * std::pow(X0, i);
  }

  std::cout << std::accumulate(S.begin(), S.end(), 0) << std::endl;

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x2d74(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rsi
callq 0x1070
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movslq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x1392
cmpl $0x0, (%rbx)
jle 0x12fc
xorl %r15d, %r15d
movq 0x2d39(%rip), %rbx      # 0x3fe0
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
callq 0x1100
mulsd 0x28(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jl 0x12ac
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x1315
addl (%rax), %esi
addq $0x4, %rax
jmp 0x1308
movq 0x2cb4(%rip), %rdi      # 0x3fd0
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1362
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1370
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x138a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/config.cpp
// Function: Config::getString(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Config::getString(const char *key, const std::string &def)
{
    auto conf = config.find(key);

    if (conf == config.end()) {
        config[key] = def;
    }

    return config[key];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0xa912
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb378
movq %rax, %r13
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0xa4d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x65c0
leaq 0x8(%r14), %rax
cmpq %rax, %r13
jne 0xa51b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0xa912
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xab62
movq %rax, %rdi
movq %r12, %rsi
callq 0x6340
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa51b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x65c0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0xa912
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xab62
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xaf6a
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa56a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x65c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa595
jmp 0xa59a
jmp 0xa595
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa5a7
jmp 0xa5b4
movq %rax, %rbx
jmp 0xa5b4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa5b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x65c0
movq %rbx, %rdi
callq 0x6a80
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/ui/ui.cpp
// Function: Ui::Ui()
Ui::Ui()
{
    disconnect = false;
    running = false;
    current_tab = nullptr;
    window = nullptr;
    statusbar = nullptr;
    width = 0;
    height = 0;
    tab_index = 0;
    hide_indicator = false;
    hide_top = false;
    hide_bottom = false;
    static_bar = false;
}

// Assembly:
leaq 0xc55d(%rip), %rax      # 0x17ac0
movq %rax, (%rdi)
movl $0x30, %eax
leaq (%rdi,%rax), %rcx
movq %rcx, -0x10(%rdi,%rax)
movq $0x0, -0x8(%rdi,%rax)
movb $0x0, (%rdi,%rax)
addq $0x20, %rax
cmpq $0xf0, %rax
jne 0xb56b
leaq 0xf0(%rdi), %rax
movq %rax, 0xe0(%rdi)
xorl %eax, %eax
movq %rax, 0xe8(%rdi)
movb $0x0, 0xf0(%rdi)
movups 0xc51e(%rip), %xmm0     # 0x17ad0
movups %xmm0, 0x108(%rdi)
movups 0xc520(%rip), %xmm0     # 0x17ae0
movups %xmm0, 0x118(%rdi)
movq 0xc522(%rip), %rcx      # 0x17af0
movq %rcx, 0x128(%rdi)
movq %rax, 0x138(%rdi)
movl %eax, 0x130(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movl %eax, 0x100(%rdi)
movw $0x0, 0x104(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pulsemixer.cpp
// Function: version()
void version()
{
    if (strlen(GIT_VERSION) > 0) {
        printf("ncpamixer git v%s\n", GIT_VERSION);
    } else {
        printf("ncpamixer v%s\n", FALLBACK_VERSION);
    }

    printf("Build type: %s\n", BUILD_TYPE);
    printf("Build date: %s\n", BUILD_DATE);
    printf("\n");

}

// Assembly:
pushq %rax
leaq 0xba6c(%rip), %rax      # 0x12b20
cmpb $0x0, (%rax)
je 0x70c9
leaq 0x9f44(%rip), %rdi      # 0x11004
leaq 0xba59(%rip), %rsi      # 0x12b20
jmp 0x70d7
leaq 0x9f47(%rip), %rdi      # 0x11017
leaq 0xa0dd(%rip), %rsi      # 0x111b4
xorl %eax, %eax
callq 0x6070
leaq 0x9f41(%rip), %rdi      # 0x11026
leaq 0xba46(%rip), %rsi      # 0x12b32
xorl %eax, %eax
callq 0x6070
leaq 0x9f3c(%rip), %rdi      # 0x11036
leaq 0xba3f(%rip), %rsi      # 0x12b40
xorl %eax, %eax
callq 0x6070
movl $0xa, %edi
popq %rax
jmp 0x67d0
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pulsemixer.cpp
// Function: help()
void help()
{
    version();

    printf("-c --config=CONFIG_FILE     Set custom location for config\n");
    printf("-t --tab=TAB                Open on given tab. Choices: "
           "(p)layback (default), (r)ecording, (o)utput, (i)nput, (c)onfiguration\n");
    printf("-h --help                   Print this help screen\n");
    printf("-v --version                Print version info\n");
}

// Assembly:
pushq %rax
callq 0x70ac
leaq 0x9f79(%rip), %rdi      # 0x11099
callq 0x68a0
leaq 0x9fa8(%rip), %rdi      # 0x110d4
callq 0x68a0
leaq 0xa01a(%rip), %rdi      # 0x11152
callq 0x68a0
leaq 0xa041(%rip), %rdi      # 0x11185
popq %rax
jmp 0x68a0
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::PaObject()
PaObject::PaObject() : type(pa_object_t::SINK)
{
    index = 0;
    memset(name, 0, sizeof(name));
    memset(pa_name, 0, sizeof(pa_name));
    channels = 0;
    mute = false;
    monitor_index = 0;
    monitor_stream = nullptr;
    peak = 0;
    pa_set_volume = nullptr;
    pa_set_mute = nullptr;
    pa_move = nullptr;
    pa_set_active_attribute = nullptr;
    pa_set_default = nullptr;
    active_attribute = nullptr;
    is_default = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x103c5(%rip), %rax     # 0x17870
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x0, 0x210(%rbx)
movb $0x0, 0x218(%rbx)
movl $0x207, %edx            # imm = 0x207
xorl %esi, %esi
callq 0x6350
xorps %xmm0, %xmm0
movups %xmm0, 0x21c(%rbx)
movups %xmm0, 0x230(%rbx)
movups %xmm0, 0x240(%rbx)
movups %xmm0, 0x250(%rbx)
movups %xmm0, 0x260(%rbx)
movq $0x0, 0x270(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::set_volume(float)
void PaObject::set_volume(float perc)
{

    if (pa_set_volume != nullptr) {
        pa_threaded_mainloop_lock(pulse.pa_ml);

        int vol = (PA_VOLUME_NORM * perc);
        pa_cvolume cvol;

        pa_cvolume_init(&cvol);
        pa_cvolume_set(&cvol, channels, vol);


        pa_operation *o = pa_set_volume(
                              pulse.pa_ctx,
                              index,
                              &cvol,
                              NULL,
                              NULL
                          );
        pa_operation_unref(o);
        pa_threaded_mainloop_unlock(pulse.pa_ml);
    }
}

// Assembly:
cmpq $0x0, 0x250(%rdi)
je 0x764d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x11033(%rip), %r15     # 0x18608
movq 0x158(%r15), %rdi
movss %xmm0, (%rsp)
callq 0x60c0
movss (%rsp), %xmm0
mulss 0x9bc5(%rip), %xmm0     # 0x111b8
cvttss2si %xmm0, %ebp
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x6980
movl 0x210(%rbx), %esi
movq %r14, %rdi
movl %ebp, %edx
callq 0x6af0
movq 0x150(%r15), %rdi
movl 0xc(%rbx), %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x250(%rbx)
movq %rax, %rdi
callq 0x6650
movq 0x158(%r15), %rdi
callq 0x6180
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::toggle_mute()
void PaObject::toggle_mute()
{
    if (pa_set_mute != nullptr) {
        pa_operation *o = pa_set_mute(
                              pulse.pa_ctx,
                              index,
                              !mute,
                              NULL,
                              NULL
                          );
        pa_operation_unref(o);
    }
}

// Assembly:
movq 0x258(%rdi), %r9
testq %r9, %r9
je 0x76c2
pushq %rax
leaq 0x10f6e(%rip), %rax     # 0x18608
movq 0x150(%rax), %rax
movl 0xc(%rdi), %esi
movzbl 0x218(%rdi), %edx
xorl $0x1, %edx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *%r9
movq %rax, %rdi
popq %rax
jmp 0x6650
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::move(unsigned int)
void PaObject::move(uint32_t dest)
{
    if (pa_move != nullptr) {
        pa_operation *o = pa_move(
                              pulse.pa_ctx,
                              index,
                              dest,
                              NULL,
                              NULL
                          );
        pa_operation_unref(o);
    }
}

// Assembly:
movq 0x260(%rdi), %r9
testq %r9, %r9
je 0x76f8
pushq %rax
movl %esi, %edx
leaq 0x10f2e(%rip), %rax     # 0x18608
movq 0x150(%rax), %rax
movl 0xc(%rdi), %esi
movq %rax, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *%r9
movq %rax, %rdi
popq %rax
jmp 0x6650
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::set_active_attribute(char const*)
void PaObject::set_active_attribute(const char *name)
{
    if (pa_set_active_attribute != nullptr) {
        pa_operation *o = pa_set_active_attribute(
                              pulse.pa_ctx,
                              index,
                              name,
                              NULL,
                              NULL
                          );
        pa_operation_unref(o);
    }
}

// Assembly:
movq 0x268(%rdi), %r9
testq %r9, %r9
je 0x772f
pushq %rax
movq %rsi, %rdx
leaq 0x10ef7(%rip), %rax     # 0x18608
movq 0x150(%rax), %rax
movl 0xc(%rdi), %esi
movq %rax, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *%r9
movq %rax, %rdi
popq %rax
jmp 0x6650
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::set_default(char const*)
void PaObject::set_default(const char *name)
{
    if (pa_set_default != nullptr) {
        pa_operation *o = pa_set_default(
                              pulse.pa_ctx,
                              name,
                              NULL,
                              NULL
                          );
        pa_operation_unref(o);
    }
}

// Assembly:
movq 0x270(%rdi), %rax
testq %rax, %rax
je 0x775a
pushq %rax
leaq 0x10ec4(%rip), %rcx     # 0x18608
movq 0x150(%rcx), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq %rax, %rdi
popq %rax
jmp 0x6650
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_object.cpp
// Function: PaObject::getRelation()
uint32_t PaObject::getRelation()
{
    if (active_attribute != nullptr) {
        for (uint32_t j = 0; j < attributes.size(); j++) {
            int current = strcmp(attributes[j]->name, active_attribute->name);

            if (current == 0) {
                return j;
            }
        }
    }

    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x230(%rdi), %rbx
testq %rbx, %rbx
je 0x77df
movq 0x238(%rdi), %r14
movq 0x240(%rdi), %r15
subq %r14, %r15
setne %r12b
je 0x77d6
addq $0x8, %rbx
movq (%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x67f0
testl %eax, %eax
je 0x77d8
sarq $0x3, %r15
xorl %ebp, %ebp
movl $0x1, %ecx
movl %ecx, %r13d
cmpq %r13, %r15
seta %r12b
jbe 0x77da
movq (%r14,%r13,8), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x67f0
leal 0x1(%r13), %ecx
testl %eax, %eax
cmovel %r13d, %ebp
jne 0x77ac
jmp 0x77da
jmp 0x77da
xorl %ebp, %ebp
testb %r12b, %r12b
jne 0x77e4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_card.cpp
// Function: PaCard::PaCard()
PaCard::PaCard()
{
    type = pa_object_t::CARD;
    monitor_stream = nullptr;
    pa_set_active_attribute = pa_context_set_card_profile_by_index;
    pa_set_volume = nullptr;
    pa_set_mute = nullptr;
    pa_move = nullptr;
    active_attribute = nullptr;
    pa_set_default = nullptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x74a0
leaq 0x100a4(%rip), %rax     # 0x178b0
movq %rax, (%rbx)
movl $0x4, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x220(%rbx)
movq 0x10752(%rip), %rcx     # 0x17f78
movq %rcx, 0x268(%rbx)
movq %rax, 0x230(%rbx)
movq %rax, 0x270(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x250(%rbx)
movq %rax, 0x260(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_card.cpp
// Function: PaCard::updateProfiles(pa_card_profile_info*, unsigned int)
void PaCard::updateProfiles(pa_card_profile_info *pa_profiles, uint32_t n_profile)
{
    clearAttributes();

    for (uint32_t i = 0; i < n_profile; i++) {
        PaObjectAttribute *p = new PaObjectAttribute;
        snprintf(p->name, sizeof(p->name), "%s", pa_profiles[i].name);
        snprintf(
            p->description,
            sizeof(p->description),
            "%s",
            pa_profiles[i].description
        );
        attributes.push_back(p);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7534
testl %ebp, %ebp
je 0x791d
leaq 0x238(%r14), %rax
movq %rax, 0x10(%rsp)
movl %ebp, %ebp
shlq $0x5, %rbp
leaq 0xb06b(%rip), %r12      # 0x128f5
movl $0x107, %r15d           # imm = 0x107
xorl %r13d, %r13d
movl $0x208, %edi            # imm = 0x208
callq 0x65b0
leaq 0x10054(%rip), %rcx     # 0x178f8
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
leaq 0x8(%rax), %rdi
movq (%rbx,%r13), %rcx
movl $0xff, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x6990
movq 0x8(%rsp), %rdi
addq %r15, %rdi
movq 0x8(%rbx,%r13), %rcx
movl $0xff, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x6990
movq 0x240(%r14), %rsi
cmpq 0x248(%r14), %rsi
je 0x7901
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x240(%r14)
jmp 0x7910
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x7950
addq $0x20, %r13
cmpq %r13, %rbp
jne 0x7893
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_sink.cpp
// Function: PaSink::PaSink()
PaSink::PaSink()
{
    type = pa_object_t::SINK;
    monitor_stream = nullptr;

    pa_set_volume = &pa_context_set_sink_volume_by_index;
    pa_set_mute = &pa_context_set_sink_mute_by_index;
    pa_move = nullptr;
    pa_set_active_attribute = &pa_context_set_sink_port_by_index;
    pa_set_default = &pa_context_set_default_sink;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x74a0
leaq 0xfe8c(%rip), %rax      # 0x17928
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x220(%rbx)
movq 0x10532(%rip), %rcx     # 0x17fe8
movq %rcx, 0x250(%rbx)
movq 0x104fc(%rip), %rcx     # 0x17fc0
movq %rcx, 0x258(%rbx)
movq %rax, 0x260(%rbx)
movq 0x10507(%rip), %rax     # 0x17fe0
movq %rax, 0x268(%rbx)
movq 0x10481(%rip), %rax     # 0x17f68
movq %rax, 0x270(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_sink.cpp
// Function: PaSink::updatePorts(pa_sink_port_info**, unsigned int)
void PaSink::updatePorts(pa_sink_port_info **info, uint32_t n_ports)
{
    clearAttributes();

    for (uint32_t i = 0; i < n_ports; i++) {
        auto *p = new PaPort;

        snprintf(p->name, sizeof(p->name), "%s", info[i]->name);
        snprintf(
            p->description,
            sizeof(p->description),
            "%s",
            info[i]->description
        );
        attributes.push_back(p);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7534
testl %ebp, %ebp
je 0x7b86
addq $0x238, %r14            # imm = 0x238
movl %ebp, %ebp
leaq 0xadd9(%rip), %r15      # 0x128f5
xorl %r12d, %r12d
movl $0x210, %edi            # imm = 0x210
callq 0x65b0
movq %rax, %r13
leaq 0xfe3d(%rip), %rax      # 0x17970
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
movq (%rbx,%r12,8), %rax
movq (%rax), %rcx
movl $0xff, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6990
leaq 0x107(%r13), %rdi
movq (%rbx,%r12,8), %rax
movq 0x8(%rax), %rcx
movl $0xff, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6990
movq %r13, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x7bb8
incq %r12
cmpq %r12, %rbp
jne 0x7b1f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_input.cpp
// Function: PaInput::PaInput()
PaInput::PaInput()
{
    type = pa_object_t::INPUT;
    monitor_stream = nullptr;
    pa_set_volume = &pa_context_set_sink_input_volume;
    pa_set_mute = &pa_context_set_sink_input_mute;
    pa_move = &pa_context_move_sink_input_by_index;
    pa_set_active_attribute = nullptr;
    pa_set_default = nullptr;

    sink = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x74a0
leaq 0xfcd4(%rip), %rax      # 0x179a8
movq %rax, (%rbx)
leaq 0x290(%rbx), %rax
movq %rax, 0x280(%rbx)
xorl %eax, %eax
movq %rax, 0x288(%rbx)
movb $0x0, 0x290(%rbx)
movl $0x1, 0x8(%rbx)
movq %rax, 0x220(%rbx)
movq 0x102c6(%rip), %rax     # 0x17fd0
movq %rax, 0x250(%rbx)
movq 0x10268(%rip), %rax     # 0x17f80
movq %rax, 0x258(%rbx)
movq 0x10232(%rip), %rax     # 0x17f58
movq %rax, 0x260(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rbx)
movl $0x0, 0x278(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_source.cpp
// Function: PaSource::PaSource()
PaSource::PaSource()
{
    type = pa_object_t::SOURCE;
    monitor_stream = nullptr;

    pa_set_volume = &pa_context_set_source_volume_by_index;
    pa_set_mute = &pa_context_set_source_mute_by_index ;
    pa_move = nullptr;
    pa_set_active_attribute = &pa_context_set_source_port_by_index;
    pa_set_default = &pa_context_set_default_source;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x74a0
leaq 0xfc14(%rip), %rax      # 0x179f0
movq %rax, (%rbx)
movl $0x2, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x220(%rbx)
movq 0x101a2(%rip), %rcx     # 0x17f98
movq %rcx, 0x250(%rbx)
movq 0x10124(%rip), %rcx     # 0x17f28
movq %rcx, 0x258(%rbx)
movq %rax, 0x260(%rbx)
movq 0x1011f(%rip), %rax     # 0x17f38
movq %rax, 0x268(%rbx)
movq 0x10139(%rip), %rax     # 0x17f60
movq %rax, 0x270(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_source.cpp
// Function: PaSource::updatePorts(pa_source_port_info**, unsigned int)
void PaSource::updatePorts(pa_source_port_info **info, uint32_t n_ports)
{
    clearAttributes();

    for (uint32_t i = 0; i < n_ports; i++) {
        PaPort *p = new PaPort;
        snprintf(p->name, sizeof(p->name), "%s", info[i]->name);
        snprintf(
            p->description,
            sizeof(p->description),
            "%s",
            info[i]->description
        );
        attributes.push_back(p);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7534
testl %ebp, %ebp
je 0x7ec6
addq $0x238, %r14            # imm = 0x238
movl %ebp, %ebp
leaq 0xaa99(%rip), %r15      # 0x128f5
xorl %r12d, %r12d
movl $0x210, %edi            # imm = 0x210
callq 0x65b0
movq %rax, %r13
leaq 0xfafd(%rip), %rax      # 0x17970
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
movq (%rbx,%r12,8), %rax
movq (%rax), %rcx
movl $0xff, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6990
leaq 0x107(%r13), %rdi
movq (%rbx,%r12,8), %rax
movq 0x8(%rax), %rcx
movl $0xff, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6990
movq %r13, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x7bb8
incq %r12
cmpq %r12, %rbp
jne 0x7e5f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa_source_output.cpp
// Function: PaSourceOutput::PaSourceOutput()
PaSourceOutput::PaSourceOutput()
{
    type = pa_object_t::SOURCE_OUTPUT;
    monitor_stream = nullptr;

    pa_set_volume = &pa_context_set_source_output_volume;
    pa_set_mute = &pa_context_set_source_output_mute;
    pa_move = &pa_context_move_source_output_by_index;
    pa_set_active_attribute = nullptr;
    pa_set_default = nullptr;

    source = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7cc4
leaq 0xfb38(%rip), %rax      # 0x17a38
movq %rax, (%rbx)
movl $0x3, 0x8(%rbx)
movq $0x0, 0x220(%rbx)
movq 0x10074(%rip), %rax     # 0x17f90
movq %rax, 0x250(%rbx)
movq 0x1008e(%rip), %rax     # 0x17fb8
movq %rax, 0x258(%rbx)
movq 0xffe8(%rip), %rax      # 0x17f20
movq %rax, 0x260(%rbx)
movl $0x0, 0x2a0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa.cpp
// Function: Pa::clearAllPaObjects()
void Pa::clearAllPaObjects()
{
    deletePaobjects(&PA_SOURCE_OUTPUTS);
    deletePaobjects(&PA_INPUTS);
    deletePaobjects(&PA_SOURCES);
    deletePaobjects(&PA_SINKS);
    deletePaobjects(&PA_CARDS);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x98(%rdi), %rsi
callq 0x8160
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8160
leaq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0x8160
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
callq 0x8160
leaq 0xc8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8160
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa.cpp
// Function: Pa::exitPa()
void Pa::exitPa()
{
    if (pa_ctx) {
        pa_context_disconnect(pa_ctx);
        pa_threaded_mainloop_stop(pa_ml);
        pa_threaded_mainloop_free(pa_ml);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x815e
callq 0x6aa0
movq 0x158(%rbx), %rdi
callq 0x6b40
movq 0x158(%rbx), %rdi
popq %rbx
jmp 0x6400
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa.cpp
// Function: Pa::deletePaobjects(std::map<unsigned int, PaObject*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, PaObject*>>>*)
void Pa::deletePaobjects(std::map<uint32_t, PaObject *> *objects)
{
    std::lock_guard<std::mutex> lk(inputMtx);

    for (auto i = objects->begin(); i != objects->end(); ) {
        delete i->second;
        i = objects->erase(i);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
callq 0x6870
testl %eax, %eax
jne 0x81c0
movq 0x18(%r14), %r15
leaq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x81ad
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x819d
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x97a0
movq %rax, %r15
jmp 0x8189
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x64b0
movl %eax, %edi
callq 0x6430
movq %rax, %r14
movq %rbx, %rdi
callq 0x64b0
movq %r14, %rdi
callq 0x6a80
// File: /workspace/github_cpp_makefile_star2_O1/fulhax[P]ncpamixer/src/pa.cpp
// Function: Pa::do_reconnect(Pa*)
void Pa::do_reconnect(Pa *pa)
{
    if (pa->reconnect_running || pa->connected) {
        return;
    }

    pa->reconnect_running = true;
    pa->clearAllPaObjects();

    while (!pa->connected) {
        pa->pa_connect();
        usleep(500000);
    }

    pa->reconnect_running = false;
}

// Assembly:
cmpb $0x0, (%rdi)
jne 0x8216
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x1(%rdi)
jne 0x8215
movb $0x1, (%rbx)
movq %rbx, %rdi
callq 0x80ec
cmpb $0x0, 0x1(%rbx)
jne 0x8212
movq %rbx, %rdi
callq 0x8218
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x6810
cmpb $0x1, 0x1(%rbx)
jne 0x81fa
movb $0x0, (%rbx)
popq %rbx
retq
nop