LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_bandpass(int, float, float)
void FIR_filter::set_up_bandpass(int sample_width, float frequency_cutoff_low, float frequency_cutoff_high){

	filter_width = sample_width;
	sample_width--;

	float ncofh = (2*PI*frequency_cutoff_high)/sample_rate;
	float ncofl = (2*PI*frequency_cutoff_low)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0;
		if(n != sample_width/2.0){
			float p1 = sin((ncofh)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			float p2 = sin((ncofl)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			hd = p1 - p2;
		} else {
			hd = (ncofh-ncofl)/PI;
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movss %xmm0, 0x28(%rsp)
movss %xmm1, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x2c(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rsp)
movss 0x24(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x46e2(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x28(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x46b5(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x5bd8
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
cvtsi2sdl 0x18(%rsp), %xmm0
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x466f(%rip), %xmm2     # 0xa110
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5ab2
jp 0x5ab2
jmp 0x5b90
movss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm1
cvtsi2sdl 0x2c(%rsp), %xmm2
movsd 0x4640(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
cvtsi2sdl 0x18(%rsp), %xmm2
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x461b(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x4613(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm1
cvtsi2sdl 0x2c(%rsp), %xmm2
movsd 0x45db(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
cvtsi2sdl 0x18(%rsp), %xmm2
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x45b6(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x45ae(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
subss 0xc(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x5bb6
movss 0x20(%rsp), %xmm0
subss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4570(%rip), %xmm1     # 0xa118
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0x14(%rsp), %rsi
callq 0x7200
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5a76
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_bandreject(int, float, float)
void FIR_filter::set_up_bandreject(int sample_width, float frequency_cutoff_low, float frequency_cutoff_high){

	filter_width = sample_width;
	sample_width--;

	float ncofh = (2*PI*frequency_cutoff_high)/sample_rate;
	float ncofl = (2*PI*frequency_cutoff_low)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0;
		if(n != sample_width/2.0){
			float p1 = sin((ncofl)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			float p2 = sin((ncofh)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			hd = p1 - p2;
		} else {
			hd = 1.0f-(ncofl-ncofh)/PI;
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movss %xmm0, 0x28(%rsp)
movss %xmm1, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x2c(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rsp)
movss 0x24(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x44e2(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x28(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x44b5(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x5de4
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
cvtsi2sdl 0x18(%rsp), %xmm0
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x446f(%rip), %xmm2     # 0xa110
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5cb2
jp 0x5cb2
jmp 0x5d90
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm1
cvtsi2sdl 0x2c(%rsp), %xmm2
movsd 0x4440(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
cvtsi2sdl 0x18(%rsp), %xmm2
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x441b(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x4413(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm1
cvtsi2sdl 0x2c(%rsp), %xmm2
movsd 0x43db(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
cvtsi2sdl 0x18(%rsp), %xmm2
cvtsi2sdl 0x2c(%rsp), %xmm1
movsd 0x43b6(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x43ae(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
subss 0xc(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x5dc2
movss 0x1c(%rsp), %xmm0
subss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4370(%rip), %xmm0     # 0xa118
divsd %xmm0, %xmm1
movsd 0x436c(%rip), %xmm0     # 0xa120
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0x14(%rsp), %rsi
callq 0x7200
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5c76
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readUInt16(std::istream&)
uint16_t util::readUInt16(std::istream &in){
	uint16_t tmp16int = 0;
	unsigned char tmp;
	for(int i = 0; i < 2; i++){
		in >> tmp;
		tmp16int += uint16_t(tmp * pow(0x100, i));
	}
	return tmp16int;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movw $0x0, 0xe(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x2, 0x8(%rsp)
jge 0x85fb
movq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rsi
callq 0x32c0
movzbl 0xd(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
cvtsi2sdl 0x8(%rsp), %xmm1
movsd 0x1c8e(%rip), %xmm0     # 0xa258
callq 0x3410
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movzwl %ax, %ecx
movzwl 0xe(%rsp), %eax
addl %ecx, %eax
movw %ax, 0xe(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x8598
movw 0xe(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readUInt32(std::istream&)
uint32_t util::readUInt32(std::istream &in){
        uint32_t tmp32int = 0;
        unsigned char tmp;
        for(int i = 0; i < 4; i++){
                in >> tmp;
                tmp32int += uint32_t(tmp * pow(0x100, i));
        }
	return tmp32int;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x8688
movq 0x20(%rsp), %rdi
leaq 0x1b(%rsp), %rsi
callq 0x32c0
movzbl 0x1b(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm1
movsd 0x1bfc(%rip), %xmm0     # 0xa258
callq 0x3410
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8629
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeUInt16(std::ostream&, unsigned short)
void util::writeUInt16(std::ostream &out, uint16_t wri){
	char *tmp = (char*) &wri;
	for(int i = 0; i < 2; i++){
		out.write((char*) tmp, 1);
		tmp++;
	}
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
leaq 0x1e(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x8749
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3320
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8713
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeUInt32(std::ostream&, unsigned int)
void util::writeUInt32(std::ostream &out, uint32_t wri){
	char *tmp = (char*) &wri;
	for(int i = 0; i < 4; i++){
		out.write(tmp, 1);
		tmp++;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
leaq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x87a5
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3320
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x876f
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readInArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void util::readInArguments(std::string args){
	std::stringstream ss(args);

	char buffer[100];
	while(!ss.eof()){
		ss.getline(buffer, 100, ' ');
		if(buffer[0] == '-'){
			std::string key(buffer);
			ss.getline(buffer, 100, ' ');
			std::string arg(buffer);
			commandlineargs.insert(std::make_pair(key, arg));
		}
	}
}

// Assembly:
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdi, 0x28(%rsp)
movq %rdi, 0x2d0(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x4960
movq 0x28(%rsp), %rsi
movl %eax, %edx
leaq 0x148(%rsp), %rdi
callq 0x3390
movq 0x148(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x148(%rsp,%rax), %rdi
callq 0x3450
movb %al, 0x27(%rsp)
jmp 0x89b6
movb 0x27(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x89c5
jmp 0x8bce
leaq 0x148(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movl $0x64, %edx
movl $0x20, %ecx
callq 0x3460
jmp 0x89e6
movsbl 0xe0(%rsp), %eax
cmpl $0x2d, %eax
jne 0x8bc9
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3430
movq 0x18(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x48a0
jmp 0x8a25
leaq 0xaf(%rsp), %rdi
callq 0x3290
leaq 0x148(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movl $0x64, %edx
movl $0x20, %ecx
callq 0x3460
jmp 0x8a53
leaq 0x87(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3430
movq 0x10(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x48a0
jmp 0x8a81
leaq 0x87(%rsp), %rdi
callq 0x3290
leaq 0x40(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x8dd0
jmp 0x8aaa
leaq 0x57bf(%rip), %rdi      # 0xe270
leaq 0x40(%rsp), %rsi
callq 0x8d80
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x8ac6
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8e10
leaq 0x88(%rsp), %rdi
callq 0x3150
leaq 0xb0(%rsp), %rdi
callq 0x3150
jmp 0x8bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x8be3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xaf(%rsp), %rdi
callq 0x3290
jmp 0x8be3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x8bba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x3290
jmp 0x8bba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x8bad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8e10
leaq 0x88(%rsp), %rdi
callq 0x3150
leaq 0xb0(%rsp), %rdi
callq 0x3150
jmp 0x8be3
jmp 0x8997
leaq 0x148(%rsp), %rdi
callq 0x31b0
addq $0x2d8, %rsp            # imm = 0x2D8
retq
leaq 0x148(%rsp), %rdi
callq 0x31b0
movq 0xd8(%rsp), %rdi
callq 0x3420
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::writeDebugStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void util::writeDebugStream(std::string msg){
	if(debugfstream.is_open()){
		debugfstream << msg;
		debugfstream.flush();
	} else {
		debugfstream.open("debug");
		writeDebugStream(msg);
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
leaq 0x568b(%rip), %rdi      # 0xe2a0
callq 0x31c0
testb $0x1, %al
jne 0x8c20
jmp 0x8c3f
movq 0x8(%rsp), %rsi
leaq 0x5674(%rip), %rdi      # 0xe2a0
callq 0x3210
leaq 0x5668(%rip), %rdi      # 0xe2a0
callq 0x3160
jmp 0x8c9b
leaq 0x565a(%rip), %rdi      # 0xe2a0
leaq 0x1613(%rip), %rsi      # 0xa260
movl $0x10, %edx
callq 0x3060
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3110
movq (%rsp), %rdi
callq 0x8c00
jmp 0x8c75
leaq 0x20(%rsp), %rdi
callq 0x3150
jmp 0x8c9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3150
jmp 0x8ca0
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/compress/compress.c
// Function: makeWindow
static int **
makeWindow(int channels)
    {
    int i,j;
    int **input;

    input = (int **) New(sizeof(int *) * channels);

    for (i = 0; i < channels; ++i)
        {
        input[i] = (int *) New(sizeof(int *) * windowSize);
        for (j = 0; j < windowSize; ++j)
            input[i][j] = 0;
        }

    return input;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x1db0
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1a9f
movslq 0x670c(%rip), %rax      # 0x8150
shlq $0x3, %rax
movl %eax, %edi
callq 0x1db0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x66e2(%rip), %eax      # 0x8150
jge 0x1a92
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a65
jmp 0x1a94
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1a35
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/compress/compress.c
// Function: rms
static double
rms(int count,int amp,int channel)
    {
    int index;
    static double last[2] = {0,0};

    index = count % windowSize;

    last[channel] +=
        amp * amp - window[channel][index] * window[channel][index];

    window[channel][index] = amp;
        
    //printf("count is %d, amp is %d, last is %f, rms is %f\n",
        //count,amp,last,pow(last,0.5));

    return pow(last[channel],0.5);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl 0x6685(%rip)            # 0x8150
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
imull -0x8(%rbp), %eax
movq 0x6694(%rip), %rcx      # 0x8170
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movq 0x667e(%rip), %rdx      # 0x8170
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq -0x10(%rbp), %rsi
imull (%rdx,%rsi,4), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x666d(%rip), %rax      # 0x8180
addsd (%rax,%rcx,8), %xmm0
leaq 0x6661(%rip), %rax      # 0x8180
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %edx
movq 0x6642(%rip), %rax      # 0x8170
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
leaq 0x6638(%rip), %rax      # 0x8180
movsd (%rax,%rcx,8), %xmm0
movsd 0x34cb(%rip), %xmm1     # 0x5020
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: lfq_init
int lfq_init(struct lfq_ctx *ctx, int max_consume_thread) {
	struct lfq_node * tmpnode = calloc(1,sizeof(struct lfq_node));
	if (!tmpnode) 
		return -errno;
		
	struct lfq_node * free_pool_node = calloc(1,sizeof(struct lfq_node));
	if (!free_pool_node) 
		return -errno;
		
	tmpnode->can_free = free_pool_node->can_free = true;
	memset(ctx, 0, sizeof(struct lfq_ctx));
	ctx->MAXHPSIZE = max_consume_thread;
	ctx->HP = calloc(max_consume_thread,sizeof(struct lfq_node));
	ctx->tid_map = calloc(max_consume_thread,sizeof(struct lfq_node));
	ctx->head = ctx->tail=tmpnode;
	ctx->fph = ctx->fpt=free_pool_node;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x118d
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x124b
movl $0x1, %edi
movl $0x18, %esi
callq 0x1070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11bb
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x124b
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1060
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movslq -0x14(%rbp), %rdi
movl $0x18, %esi
callq 0x1070
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0x14(%rbp), %rdi
movl $0x18, %esi
callq 0x1070
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: lfg_count_freelist
long lfg_count_freelist(const struct lfq_ctx *ctx) {
	long count=0;
	struct lfq_node *p = (struct lfq_node *)ctx->fph; // non-volatile
	while(p) {
		count++;
		p = p->free_next;
	}
	
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x129d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x127c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: lfq_clean
int lfq_clean(struct lfq_ctx *ctx){
	if ( ctx->tail && ctx->head ) { // if have data in queue
		struct lfq_node *tmp;
		while ( (struct lfq_node *) ctx->head ) { // while still have node
			tmp = (struct lfq_node *) ctx->head->next;
			safe_free(ctx, (struct lfq_node *)ctx->head);
			ctx->head = tmp;
		}
		ctx->tail = 0;
	}
	if ( ctx->fph && ctx->fpt ) {
		free_pool(ctx, true);
		if ( ctx->fph != ctx->fpt )
			return -1;
		free((void *)ctx->fpt); // free the empty node
		ctx->fph=ctx->fpt=0;
	}
	if ( !ctx->fph && !ctx->fpt ) {
		free((void *)ctx->HP);
		free((void *)ctx->tid_map);
		memset(ctx,0,sizeof(struct lfq_ctx));
	} else
		return -1;
		
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, %rax
je 0x131e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, %rax
je 0x131e
jmp 0x12d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, %rax
je 0x1312
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x13f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12d9
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, %rax
je 0x138b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, %rax
je 0x138b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1490
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
cmpq %rcx, %rax
je 0x1366
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13e3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, %rax
jne 0x13d3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, %rax
jne 0x13d3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1060
jmp 0x13dc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: safe_free
static
void safe_free(struct lfq_ctx *ctx, struct lfq_node * lfn) {
	if (lfn->can_free && !inHP(ctx,lfn)) {
		// free is not thread-safe
		if (CAS(&ctx->is_freeing, 0, 1)) {
			lfn->next = (void*)-1;    // poison the pointer to detect use-after-free
			free(lfn);    // we got the lock; actually free
			ctx->is_freeing = false;
			smb();
		} else               // we didn't get the lock; only add to a freelist
			enpool(ctx, lfn);
	} else
		enpool(ctx, lfn);
	free_pool(ctx, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x146d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17d0
cmpl $0x0, %eax
jne 0x146d
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl $0x1, %edx
lock
cmpxchgl %edx, 0x20(%rcx)
movl %eax, %ecx
sete %al
testb $0x1, %al
jne 0x1439
jmp 0x145e
movq -0x10(%rbp), %rax
movq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
jmp 0x146b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1830
jmp 0x147a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1830
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1490
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: free_pool
static
void free_pool(struct lfq_ctx *ctx, bool freeall ) {
	if (!CAS(&ctx->is_freeing, 0, 1))
		return; // this pool free is not support multithreading.
	volatile struct lfq_node * p;

	for ( int i = 0 ; i < MAXFREE || freeall ; i++ ) {
		p = ctx->fph;
		if ( (!p->can_free) || (!p->free_next) || inHP(ctx, (struct lfq_node *)p) )
			goto exit;
		ctx->fph = p->free_next;
		free((void *)p);
	}
exit:
	ctx->is_freeing = false;
	smb();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl $0x1, %edx
lock
cmpxchgl %edx, 0x20(%rcx)
movl %eax, %ecx
sete %al
testb $0x1, %al
jne 0x14c2
jmp 0x1551
movl $0x0, -0x1c(%rbp)
movb $0x1, %al
cmpl $0x96, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jl 0x14dd
movb -0x9(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x14e6
jmp 0x1544
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x151e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, %rax
je 0x151e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17d0
cmpl $0x0, %eax
je 0x1520
jmp 0x1546
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x1040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14c9
jmp 0x1546
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: lfq_enqueue
int lfq_enqueue(struct lfq_ctx *ctx, void * data) {
	struct lfq_node * insert_node = calloc(1,sizeof(struct lfq_node));
	if (!insert_node)
		return -errno;
	insert_node->data=data;
//	mb();  // we've only written to "private" memory that other threads can't see.
	volatile struct lfq_node *old_tail;
#if 0
	do {
		old_tail = (struct lfq_node *) ctx->tail;
	} while(!CAS(&ctx->tail,old_tail,insert_node));
#else
	old_tail = XCHG(&ctx->tail, insert_node);
#endif
	// We've claimed our spot in the insertion order by modifying tail
	// we are the only inserting thread with a pointer to the old tail.

	// now we can make it part of the list by overwriting the NULL pointer in the old tail
	// This is safe whether or not other threads have updated ->next in our insert_node
#ifdef DEBUG
	assert(!(old_tail->next) && "old tail wasn't NULL");
#endif
	old_tail->next = insert_node;
	// TODO: could a consumer thread could have freed the old tail?  no because that would leave head=NULL

//	ATOMIC_ADD( &ctx->count, 1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x159b
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x15c9
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
xchgq %rax, 0x40(%rcx)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: lfq_dequeue
void * lfq_dequeue(struct lfq_ctx *ctx ) {
	//return lfq_dequeue_tid(ctx, 0);  // TODO: let this inline even in the shared library
// old version
	int tid = alloc_tid(ctx);
	if (tid==-1)
		return (void *)-1; // To many thread race

	void * ret = lfq_dequeue_tid(ctx, tid);
	free_tid(ctx, tid);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1730
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x16fb
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x171f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1030
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: alloc_tid
static
int alloc_tid(struct lfq_ctx *ctx) {
	for (int i = 0; i < ctx->MAXHPSIZE; i++) 
		if (ctx->tid_map[i] == 0) 
			if (CAS(&ctx->tid_map[i], 0, 1))
				return i;

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x1799
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
jne 0x178c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %esi
lock
cmpxchgl %esi, (%rcx,%rdx,4)
movl %eax, %ecx
sete %al
testb $0x1, %al
jne 0x1782
jmp 0x178a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17a0
jmp 0x178c
jmp 0x178e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x173f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darkautism[P]lfqueue/lfq.c
// Function: inHP
static
int inHP(struct lfq_ctx *ctx, struct lfq_node * lfn) {
	for ( int i = 0 ; i < ctx->MAXHPSIZE ; i++ ) {
		//lmb(); // not needed, we don't care if loads reorder here, just that we check all the elements
		if (ctx->HP[i] == lfn)
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x181b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x180e
movl $0x1, -0x4(%rbp)
jmp 0x1822
jmp 0x1810
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_EV
const char * ed_EV(int n)
{
  switch(n)
  {
    case 0: return "EV_SYN";
    case 1: return "EV_KEY";
    case 2: return "EV_REL";
    case 3: return "EV_ABS";
    case 4: return "EV_MSC";
    case 5: return "EV_SW";
    case 17: return "EV_LED";
    case 18: return "EV_SND";
    case 20: return "EV_REP";
    case 21: return "EV_FF";
    case 22: return "EV_PWR";
    case 23: return "EV_FF_STATUS";
    case 31: return "EV_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x1f, %rax
ja 0x131e
movq -0x18(%rbp), %rax
leaq 0x4da1(%rip), %rcx      # 0x6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x64d1(%rip), %rax      # 0x7744
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64c8(%rip), %rax      # 0x774b
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64bf(%rip), %rax      # 0x7752
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64b6(%rip), %rax      # 0x7759
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64b0(%rip), %rax      # 0x7760
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64aa(%rip), %rax      # 0x7767
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x64a3(%rip), %rax      # 0x776d
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x649d(%rip), %rax      # 0x7774
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x6497(%rip), %rax      # 0x777b
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x6491(%rip), %rax      # 0x7782
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x648a(%rip), %rax      # 0x7788
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x6484(%rip), %rax      # 0x778f
movq %rax, -0x8(%rbp)
jmp 0x1326
leaq 0x6484(%rip), %rax      # 0x779c
movq %rax, -0x8(%rbp)
jmp 0x1326
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_SYN
const char * ed_SYN(int n)
{
  switch(n)
  {
    case 0: return "SYN_REPORT";
    case 1: return "SYN_CONFIG";
    case 2: return "SYN_MT_REPORT";
    case 3: return "SYN_DROPPED";
    case 15: return "SYN_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xf, %rax
ja 0x1399
movq -0x18(%rbp), %rax
leaq 0x4d35(%rip), %rcx      # 0x6084
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6444(%rip), %rax      # 0x77a3
movq %rax, -0x8(%rbp)
jmp 0x13a1
leaq 0x6442(%rip), %rax      # 0x77ae
movq %rax, -0x8(%rbp)
jmp 0x13a1
leaq 0x6440(%rip), %rax      # 0x77b9
movq %rax, -0x8(%rbp)
jmp 0x13a1
leaq 0x6441(%rip), %rax      # 0x77c7
movq %rax, -0x8(%rbp)
jmp 0x13a1
leaq 0x6440(%rip), %rax      # 0x77d3
movq %rax, -0x8(%rbp)
jmp 0x13a1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_REL
const char * ed_REL(int n)
{
  switch(n)
  {
    case 0: return "REL_X";
    case 1: return "REL_Y";
    case 2: return "REL_Z";
    case 3: return "REL_RX";
    case 4: return "REL_RY";
    case 5: return "REL_RZ";
    case 6: return "REL_HWHEEL";
    case 7: return "REL_DIAL";
    case 8: return "REL_WHEEL";
    case 9: return "REL_MISC";
    case 10: return "REL_RESERVED";
    case 11: return "REL_WHEEL_HI_RES";
    case 12: return "REL_HWHEEL_HI_RES";
    case 15: return "REL_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xf, %rax
ja 0x3a4e
movq -0x18(%rbp), %rax
leaq 0x3ae1(%rip), %rcx      # 0x7464
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5b17(%rip), %rax      # 0x94aa
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5b0d(%rip), %rax      # 0x94b0
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5b03(%rip), %rax      # 0x94b6
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5af9(%rip), %rax      # 0x94bc
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5af0(%rip), %rax      # 0x94c3
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5aea(%rip), %rax      # 0x94ca
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ae4(%rip), %rax      # 0x94d1
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ae2(%rip), %rax      # 0x94dc
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ade(%rip), %rax      # 0x94e5
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5adb(%rip), %rax      # 0x94ef
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ad7(%rip), %rax      # 0x94f8
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ad7(%rip), %rax      # 0x9505
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5adb(%rip), %rax      # 0x9516
movq %rax, -0x8(%rbp)
jmp 0x3a56
leaq 0x5ae0(%rip), %rax      # 0x9528
movq %rax, -0x8(%rbp)
jmp 0x3a56
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_SW
const char * ed_SW(int n)
{
  switch(n)
  {
    case 0: return "SW_LID";
    case 1: return "SW_TABLET_MODE";
    case 2: return "SW_HEADPHONE_INSERT";
    case 3: return "SW_RFKILL_ALL";
    case 4: return "SW_MICROPHONE_INSERT";
    case 5: return "SW_DOCK";
    case 6: return "SW_LINEOUT_INSERT";
    case 7: return "SW_JACK_PHYSICAL_INSERT";
    case 8: return "SW_VIDEOOUT_INSERT";
    case 9: return "SW_CAMERA_LENS_COVER";
    case 10: return "SW_KEYPAD_SLIDE";
    case 11: return "SW_FRONT_PROXIMITY";
    case 12: return "SW_ROTATE_LOCK";
    case 13: return "SW_LINEIN_INSERT";
    case 14: return "SW_MUTE_DEVICE";
    case 15: return "SW_PEN_INSERTED";
    case 16: return "SW_MACHINE_COVER";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x10, %rax
ja 0x3e4e
movq -0x18(%rbp), %rax
leaq 0x3851(%rip), %rcx      # 0x75a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x59de(%rip), %rax      # 0x9741
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d5(%rip), %rax      # 0x9748
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d4(%rip), %rax      # 0x9757
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d8(%rip), %rax      # 0x976b
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d6(%rip), %rax      # 0x9779
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59db(%rip), %rax      # 0x978e
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d3(%rip), %rax      # 0x9796
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59d5(%rip), %rax      # 0x97a8
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59e0(%rip), %rax      # 0x97c0
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59e6(%rip), %rax      # 0x97d3
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59ee(%rip), %rax      # 0x97e8
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59f1(%rip), %rax      # 0x97f8
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59f7(%rip), %rax      # 0x980b
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59f9(%rip), %rax      # 0x981a
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59fd(%rip), %rax      # 0x982b
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x59ff(%rip), %rax      # 0x983a
movq %rax, -0x8(%rbp)
jmp 0x3e56
leaq 0x5a02(%rip), %rax      # 0x984a
movq %rax, -0x8(%rbp)
jmp 0x3e56
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_MSC
const char * ed_MSC(int n)
{
  switch(n)
  {
    case 0: return "MSC_SERIAL";
    case 1: return "MSC_PULSELED";
    case 2: return "MSC_GESTURE";
    case 3: return "MSC_RAW";
    case 4: return "MSC_SCAN";
    case 5: return "MSC_TIMESTAMP";
    case 7: return "MSC_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x3ee3
movq -0x18(%rbp), %rax
leaq 0x3769(%rip), %rcx      # 0x75e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x59cc(%rip), %rax      # 0x985b
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59ca(%rip), %rax      # 0x9866
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59ca(%rip), %rax      # 0x9873
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59c9(%rip), %rax      # 0x987f
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59c4(%rip), %rax      # 0x9887
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59c0(%rip), %rax      # 0x9890
movq %rax, -0x8(%rbp)
jmp 0x3eeb
leaq 0x59c1(%rip), %rax      # 0x989e
movq %rax, -0x8(%rbp)
jmp 0x3eeb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_LED
const char * ed_LED(int n)
{
  switch(n)
  {
    case 0: return "LED_NUML";
    case 1: return "LED_CAPSL";
    case 2: return "LED_SCROLLL";
    case 3: return "LED_COMPOSE";
    case 4: return "LED_KANA";
    case 5: return "LED_SLEEP";
    case 6: return "LED_SUSPEND";
    case 7: return "LED_MUTE";
    case 8: return "LED_MISC";
    case 9: return "LED_MAIL";
    case 10: return "LED_CHARGING";
    case 15: return "LED_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xf, %rax
ja 0x3fce
movq -0x18(%rbp), %rax
leaq 0x36e5(%rip), %rcx      # 0x7608
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5973(%rip), %rax      # 0x98a6
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x596c(%rip), %rax      # 0x98af
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5966(%rip), %rax      # 0x98b9
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5965(%rip), %rax      # 0x98c5
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5964(%rip), %rax      # 0x98d1
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5960(%rip), %rax      # 0x98da
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x595d(%rip), %rax      # 0x98e4
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x595c(%rip), %rax      # 0x98f0
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5958(%rip), %rax      # 0x98f9
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5954(%rip), %rax      # 0x9902
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5950(%rip), %rax      # 0x990b
movq %rax, -0x8(%rbp)
jmp 0x3fd6
leaq 0x5950(%rip), %rax      # 0x9918
movq %rax, -0x8(%rbp)
jmp 0x3fd6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_REP
const char * ed_REP(int n)
{
  switch(n)
  {
    case 0: return "REP_DELAY";
    case 1: return "REP_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x3ffd
jmp 0x3ff3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x400a
jmp 0x4017
leaq 0x591c(%rip), %rax      # 0x9920
movq %rax, -0x8(%rbp)
jmp 0x401f
leaq 0x5919(%rip), %rax      # 0x992a
movq %rax, -0x8(%rbp)
jmp 0x401f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_SND
const char * ed_SND(int n)
{
  switch(n)
  {
    case 0: return "SND_CLICK";
    case 1: return "SND_BELL";
    case 2: return "SND_TONE";
    case 7: return "SND_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x408c
movq -0x18(%rbp), %rax
leaq 0x35f9(%rip), %rcx      # 0x7648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x58d3(%rip), %rax      # 0x9932
movq %rax, -0x8(%rbp)
jmp 0x4094
leaq 0x58d0(%rip), %rax      # 0x993c
movq %rax, -0x8(%rbp)
jmp 0x4094
leaq 0x58cc(%rip), %rax      # 0x9945
movq %rax, -0x8(%rbp)
jmp 0x4094
leaq 0x58c8(%rip), %rax      # 0x994e
movq %rax, -0x8(%rbp)
jmp 0x4094
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_BUS
const char * ed_BUS(int n)
{
  switch(n)
  {
    case 1: return "BUS_PCI";
    case 2: return "BUS_ISAPNP";
    case 3: return "BUS_USB";
    case 4: return "BUS_HIL";
    case 5: return "BUS_BLUETOOTH";
    case 6: return "BUS_VIRTUAL";
    case 16: return "BUS_ISA";
    case 17: return "BUS_I8042";
    case 18: return "BUS_XTKBD";
    case 19: return "BUS_RS232";
    case 20: return "BUS_GAMEPORT";
    case 21: return "BUS_PARPORT";
    case 22: return "BUS_AMIGA";
    case 23: return "BUS_ADB";
    case 24: return "BUS_I2C";
    case 25: return "BUS_HOST";
    case 26: return "BUS_GSC";
    case 27: return "BUS_ATARI";
    case 28: return "BUS_SPI";
    case 29: return "BUS_RMI";
    case 30: return "BUS_CEC";
    case 31: return "BUS_INTEL_ISHTP";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1e, %eax
ja 0x4211
movq -0x18(%rbp), %rax
leaq 0x35a2(%rip), %rcx      # 0x7668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5880(%rip), %rax      # 0x9956
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5878(%rip), %rax      # 0x995e
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5873(%rip), %rax      # 0x9969
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x586b(%rip), %rax      # 0x9971
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5863(%rip), %rax      # 0x9979
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5861(%rip), %rax      # 0x9987
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x585d(%rip), %rax      # 0x9993
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5855(%rip), %rax      # 0x999b
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x584f(%rip), %rax      # 0x99a5
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5849(%rip), %rax      # 0x99af
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5843(%rip), %rax      # 0x99b9
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5840(%rip), %rax      # 0x99c6
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x583c(%rip), %rax      # 0x99d2
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5839(%rip), %rax      # 0x99dc
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5834(%rip), %rax      # 0x99e4
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x582f(%rip), %rax      # 0x99ec
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x582b(%rip), %rax      # 0x99f5
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5826(%rip), %rax      # 0x99fd
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5823(%rip), %rax      # 0x9a07
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x581e(%rip), %rax      # 0x9a0f
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5819(%rip), %rax      # 0x9a17
movq %rax, -0x8(%rbp)
jmp 0x4219
leaq 0x5814(%rip), %rax      # 0x9a1f
movq %rax, -0x8(%rbp)
jmp 0x4219
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/./input.generated.h
// Function: ed_FF_STATUS
const char * ed_FF_STATUS(int n)
{
  switch(n)
  {
    case 0: return "FF_STATUS_STOPPED";
    case 1: return "FF_STATUS_MAX";
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x423d
jmp 0x4233
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x424a
jmp 0x4257
leaq 0x57eb(%rip), %rax      # 0x9a2f
movq %rax, -0x8(%rbp)
jmp 0x425f
leaq 0x57f0(%rip), %rax      # 0x9a41
movq %rax, -0x8(%rbp)
jmp 0x425f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glitchub[P]evdump/evdump.c
// Function: report
void report(char *ename, struct timeval *etime, int etype, int ecode, int evalue)
{
    // filter out unwanted events
    if (onlytype != -1 && etype != onlytype) return;
    if (onlycode != -1 && ecode != onlycode) return;
    if (onlyvalue != -1 && evalue != onlyvalue) return;

    printf("%s %ld.%06ld type=%d (%s) code=%d (%s) value=%d\n", ename, etime->tv_sec, etime->tv_usec, etype, ed_EV(etype)?:"unknown", ecode, code(etype,ecode)?:"unknown", evalue);
    fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $-0x1, 0x7b4c(%rip)     # 0xc0b0
je 0x4576
movl -0x14(%rbp), %eax
cmpl 0x7b41(%rip), %eax      # 0xc0b0
je 0x4576
jmp 0x4679
cmpl $-0x1, 0x7b37(%rip)     # 0xc0b4
je 0x458f
movl -0x18(%rbp), %eax
cmpl 0x7b2c(%rip), %eax      # 0xc0b4
je 0x458f
jmp 0x4679
cmpl $-0x1, 0x7b22(%rip)     # 0xc0b8
je 0x45a8
movl -0x1c(%rbp), %eax
cmpl 0x7b17(%rip), %eax      # 0xc0b8
je 0x45a8
jmp 0x4679
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %edi
callq 0x1240
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x45e9
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x45f6
leaq 0x5543(%rip), %rax      # 0x9b33
movq %rax, -0x50(%rbp)
jmp 0x45f6
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x4270
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x4623
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x4630
leaq 0x5509(%rip), %rax      # 0x9b33
movq %rax, -0x70(%rbp)
jmp 0x4630
movl -0x5c(%rbp), %r11d
movq -0x68(%rbp), %r9
movl -0x2c(%rbp), %r8d
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rsi
movq -0x70(%rbp), %r10
movl -0x1c(%rbp), %eax
leaq 0x54ac(%rip), %rdi      # 0x9b02
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x1050
movq 0x7957(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
callq 0x10b0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/ntp_msg.c
// Function: print_short_ntp
void print_short_ntp(const struct ntp_msg *m, const struct ntptimes *t) {
  struct timespec recv_time, trans_time;

  printf(" %u.%06u", ntohs(m->delay), ntp_frac_to_us(m->delay_fb));
  printf(" %u.%06u", ntohs(m->dispersion), ntp_frac_to_us(m->dispersion_fb));

  recv_time.tv_sec = ntp_s_to_unixtime(m->recv_time);
  recv_time.tv_nsec = ntp_frac_to_ns(m->recv_time_fb);
  if(t != NULL) {
    printf(" ");
    print_diff_ts(&t->before_sendto, &recv_time);
  }

  trans_time.tv_sec = ntp_s_to_unixtime(m->trans_time);
  trans_time.tv_nsec = ntp_frac_to_ns(m->trans_time_fb);
  if(t != NULL) {
    printf(" ");
    print_diff_ts(&trans_time, &t->after_recvmsg);
  }

  printf(" ");
  print_diff_ts(&trans_time, &recv_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x1100
movzwl %ax, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x1a20
movl -0x38(%rbp), %esi
movzwl %ax, %edx
leaq 0x1506(%rip), %rdi      # 0x32a3
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %edi
callq 0x1100
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %edi
callq 0x1a20
movl -0x34(%rbp), %esi
movzwl %ax, %edx
leaq 0x14d2(%rip), %rdi      # 0x32a3
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x1930
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edi
callq 0x19e0
movl %eax, %eax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e1e
leaq 0x1497(%rip), %rdi      # 0x32a1
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2160
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x1930
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edi
callq 0x19e0
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e68
leaq 0x1451(%rip), %rdi      # 0x32a1
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2160
leaq 0x1432(%rip), %rdi      # 0x32a1
movb $0x0, %al
callq 0x1070
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2160
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)