LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_ParseWithOpts
cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
{
	const char *end=0;
	cJSON *c=cJSON_New_Item();
	ep=0;
	if (!c) return 0;       /* memory fail */

	end=parse_value(c,skip(value));
	if (!end)	{cJSON_Delete(c);return 0;}	/* parse failure. ep is set. */

	/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
	if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}}
	if (return_parse_end) *return_parse_end=end;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
callq 0xe870
movq %rax, -0x30(%rbp)
movq $0x0, 0x134a9(%rip) # 0x21c68
cmpq $0x0, -0x30(%rbp)
jne 0xe7d3
movq $0x0, -0x8(%rbp)
jmp 0xe864
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xea40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xe8b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe80e
movq -0x30(%rbp), %rdi
callq 0xe6c0
movq $0x0, -0x8(%rbp)
jmp 0xe864
cmpl $0x0, -0x1c(%rbp)
je 0xe84a
movq -0x28(%rbp), %rdi
callq 0xea40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xe848
movq -0x30(%rbp), %rdi
callq 0xe6c0
movq -0x28(%rbp), %rax
movq %rax, 0x1342a(%rip)     # 0x21c68
movq $0x0, -0x8(%rbp)
jmp 0xe864
jmp 0xe84a
cmpq $0x0, -0x18(%rbp)
je 0xe85c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: fgheng[P]keysound/src/cJSON.cc
// Function: parse_value(cJSON*, char const*)
static const char *parse_value(cJSON *item,const char *value)
{
	if (!value)						return 0;	/* Fail on null. */
	if (!strncmp(value,"null",4))	{ item->type=cJSON_NULL;  return value+4; }
	if (!strncmp(value,"false",5))	{ item->type=cJSON_False; return value+5; }
	if (!strncmp(value,"true",4))	{ item->type=cJSON_True; item->valueint=1;	return value+4; }
	if (*value=='\"')				{ return parse_string(item,value); }
	if (*value=='-' || (*value>='0' && *value<='9'))	{ return parse_number(item,value); }
	if (*value=='[')				{ return parse_array(item,value); }
	if (*value=='{')				{ return parse_object(item,value); }

	ep=value;return 0;	/* failure. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe8d4
movq $0x0, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rdi
leaq 0x80e1(%rip), %rsi      # 0x169c0
movl $0x4, %edx
callq 0x41b0
cmpl $0x0, %eax
jne 0xe90a
movq -0x10(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rdi
leaq 0x80b0(%rip), %rsi      # 0x169c5
movl $0x5, %edx
callq 0x41b0
cmpl $0x0, %eax
jne 0xe940
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rdi
leaq 0x8080(%rip), %rsi      # 0x169cb
movl $0x4, %edx
callq 0x41b0
cmpl $0x0, %eax
jne 0xe981
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0xe9a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff80
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xe9c7
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xe9da
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xe9da
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x103d0
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0xe9f9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10690
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0xea18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10830
movq %rax, -0x8(%rbp)
jmp 0xea2b
movq -0x18(%rbp), %rax
movq %rax, 0x13245(%rip)     # 0x21c68
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_PrintBuffered
char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt)
{
	printbuffer p;
	p.buffer=(char*)cJSON_malloc(prebuffer);
	p.length=prebuffer;
	p.offset=0;
	return print_value(item,0,fmt,&p);
	return p.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x10657(%rip), %rax     # 0x1f3b0
movslq -0xc(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
leaq -0x20(%rbp), %rcx
callq 0xeaf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_strdup(char const*)
static char* cJSON_strdup(const char* str)
{
      size_t len;
      char* copy;

      len = strlen(str) + 1;
      if (!(copy = (char*)cJSON_malloc(len))) return 0;
      memcpy(copy,str,len);
      return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4190
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq 0x1030c(%rip), %rax     # 0x1f3b0
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xf0be
movq $0x0, -0x8(%rbp)
jmp 0xf0d7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x42e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/cJSON.cc
// Function: parse_array(cJSON*, char const*)
static const char *parse_array(cJSON *item,const char *value)
{
	cJSON *child;
	if (*value!='[')	{ep=value;return 0;}	/* not an array! */

	item->type=cJSON_Array;
	value=skip(value+1);
	if (*value==']') return value+1;	/* empty array. */

	item->child=child=cJSON_New_Item();
	if (!item->child) return 0;		 /* memory fail */
	value=skip(parse_value(child,skip(value)));	/* skip any spacing, get the value. */
	if (!value) return 0;

	while (*value==',')
	{
		cJSON *new_item;
		if (!(new_item=cJSON_New_Item())) return 0; 	/* memory fail */
		child->next=new_item;new_item->prev=child;child=new_item;
		value=skip(parse_value(child,skip(value+1)));
		if (!value) return 0;	/* memory fail */
	}

	if (*value==']') return value+1;	/* end of array */
	ep=value;return 0;	/* malformed. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x106c4
movq -0x18(%rbp), %rax
movq %rax, 0x115b1(%rip)     # 0x21c68
movq $0x0, -0x8(%rbp)
jmp 0x1081f
movq -0x10(%rbp), %rax
movl $0x5, 0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0xea40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x106fd
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1081f
callq 0xe870
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x10729
movq $0x0, -0x8(%rbp)
jmp 0x1081f
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xea40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe8b0
movq %rax, %rdi
callq 0xea40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10766
movq $0x0, -0x8(%rbp)
jmp 0x1081f
jmp 0x10768
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x107f2
callq 0xe870
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x10790
movq $0x0, -0x8(%rbp)
jmp 0x1081f
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0xea40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xe8b0
movq %rax, %rdi
callq 0xea40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x107ed
movq $0x0, -0x8(%rbp)
jmp 0x1081f
jmp 0x10768
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x1080c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1081f
movq -0x18(%rbp), %rax
movq %rax, 0x11451(%rip)     # 0x21c68
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fgheng[P]keysound/src/cJSON.cc
// Function: ensure(printbuffer*, int)
static char* ensure(printbuffer *p,int needed)
{
	char *newbuffer;int newsize;
	if (!p || !p->buffer) return 0;
	needed+=p->offset;
	if (needed<=p->length) return p->buffer+p->offset;

	newsize=pow2gt(needed);
	newbuffer=(char*)cJSON_malloc(newsize);
	if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}
	if (newbuffer) memcpy(newbuffer,p->buffer,p->length);
	cJSON_free(p->buffer);
	p->length=newsize;
	p->buffer=newbuffer;
	return newbuffer+p->offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10da0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10dad
movq $0x0, -0x8(%rbp)
jmp 0x10e8b
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x10de1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x10e8b
movl -0x14(%rbp), %edi
callq 0x11f30
movl %eax, -0x24(%rbp)
movq 0xe5bd(%rip), %rax      # 0x1f3b0
movslq -0x24(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10e34
movq 0xe5ad(%rip), %rax      # 0x1f3b8
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x10e8b
cmpq $0x0, -0x20(%rbp)
je 0x10e53
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x42e0
movq 0xe55e(%rip), %rax      # 0x1f3b8
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/main.cc
// Function: kill_exists_process()
static void kill_exists_process() {
    static std::string cmd =
        std::string("ps ax | grep ") +
        program_invocation_short_name +
        " | grep -v grep";

    pid_t pid = 0;

    FILE *tmp = fopen(PID_FILE, "r");

    // 文件存在，读取文件		If the file exists, read the file
    if (tmp != NULL && fscanf(tmp, "%d", &pid) ==1) {
        fclose(tmp);
    } else {
        // 文件不存在，使用命令获取	File does not exist, use command to get
        // 成功获取pid			the PID successfully
        sscanf(execute(cmd).c_str(), "%d", &pid);
    }

    if (pid > 0 && pid != getpid() /*&& pid_is_real(pid)*/) {
        kill(pid, SIGINT);
        remove(PID_FILE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
cmpb $0x0, 0xf12e(%rip)      # 0x21d20
jne 0x12ca9
leaq 0xf121(%rip), %rdi      # 0x21d20
callq 0x46b0
cmpl $0x0, %eax
je 0x12ca9
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4680
movq -0x88(%rbp), %rdx
leaq 0x406f(%rip), %rsi      # 0x16c9a
leaq -0x40(%rbp), %rdi
callq 0x93e0
jmp 0x12c36
movq 0xc393(%rip), %rax      # 0x1efd0
movq (%rax), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x92a0
jmp 0x12c4f
leaq 0xf0aa(%rip), %rdi      # 0x21d00
leaq 0x404b(%rip), %rdx      # 0x16ca8
leaq -0x20(%rbp), %rsi
callq 0x92a0
jmp 0x12c68
leaq -0x20(%rbp), %rdi
callq 0x4728
leaq -0x40(%rbp), %rdi
callq 0x4728
leaq -0x41(%rbp), %rdi
callq 0x4420
movq 0xc316(%rip), %rdi      # 0x1efa0
leaq 0xf06f(%rip), %rsi      # 0x21d00
leaq 0xc700(%rip), %rdx      # 0x1f398
callq 0x4300
leaq 0xf07c(%rip), %rdi      # 0x21d20
callq 0x4210
movl $0x0, -0x58(%rbp)
leaq 0x4001(%rip), %rdi      # 0x16cb8
leaq 0x357d(%rip), %rsi      # 0x1623b
callq 0x4460
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x12d48
movq -0x60(%rbp), %rdi
leaq 0x3cf7(%rip), %rsi      # 0x169d0
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x46c0
cmpl $0x1, %eax
jne 0x12d48
movq -0x60(%rbp), %rdi
callq 0x43b0
jmp 0x12d7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12d31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12d28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4728
leaq -0x40(%rbp), %rdi
callq 0x4728
leaq -0x41(%rbp), %rdi
callq 0x4420
leaq 0xefdf(%rip), %rdi      # 0x21d20
callq 0x4200
jmp 0x12dc1
leaq -0x80(%rbp), %rdi
leaq 0xefad(%rip), %rsi      # 0x21d00
callq 0x13050
leaq -0x80(%rbp), %rdi
callq 0x4170
movq %rax, %rdi
leaq 0x3c65(%rip), %rsi      # 0x169d0
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x4380
leaq -0x80(%rbp), %rdi
callq 0x4728
cmpl $0x0, -0x58(%rbp)
jle 0x12db8
movl -0x58(%rbp), %eax
movl %eax, -0x8c(%rbp)
callq 0x4560
movl %eax, %ecx
movl -0x8c(%rbp), %eax
cmpl %ecx, %eax
je 0x12db8
movl -0x58(%rbp), %edi
movl $0x2, %esi
callq 0x4520
leaq 0x3f05(%rip), %rdi      # 0x16cb8
callq 0x46a0
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4670
nopw (%rax,%rax)
// File: fgheng[P]keysound/src/main.cc
// Function: signal_handling()
static void signal_handling() {
    struct sigaction act = {{0}};
    act.sa_handler = signal_handler;

    sigaction(SIGHUP, &act, NULL);
    sigaction(SIGINT, &act, NULL);
    sigaction(SIGTERM, &act, NULL);
    sigaction(SIGQUIT, &act, NULL);

    // 避免成为僵尸进程?	Avoid becoming a zombie process?
    act.sa_handler = SIG_IGN;
    sigaction(SIGTERM, &act, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x41d0
leaq 0x39b(%rip), %rax       # 0x13190
movq %rax, -0x98(%rbp)
movl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
movl $0x3, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
movl $0x1, %eax
movq %rax, -0x98(%rbp)
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fgheng[P]keysound/src/main.cc
// Function: create_pid_file()
static void create_pid_file() {
    // 文件存在返回-1			Return -1 if the file exists
    int fd = open(PID_FILE, O_WRONLY | O_CREAT | O_EXCL, 0644);

    if (fd != -1) {
        char pid[16] = {0};
        sprintf(pid, "%d", getpid());

        if (write(fd, pid, strlen(pid)) == -1) {
            close(fd);
            remove(PID_FILE);

            std::cout << "write pid file error" << std::endl;
            // exit(EXIT_FAILURE);
        } else close(fd);
    } else {
        if (errno == EEXIST) {
            std::cout << "another process is running" << std::endl;
        } else {
            std::cout << "read file error" << std::endl;
        }
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x3e29(%rip), %rdi      # 0x16cb8
movl $0xc1, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x4280
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x12f4c
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x41d0
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4560
movq -0x38(%rbp), %rdi
movl %eax, %edx
leaq 0x3af9(%rip), %rsi      # 0x169d0
movb $0x0, %al
callq 0x40a0
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4190
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x4130
cmpq $-0x1, %rax
jne 0x12f42
movl -0x4(%rbp), %edi
callq 0x46f0
leaq 0x3d9f(%rip), %rdi      # 0x16cb8
callq 0x46a0
movq 0xc093(%rip), %rdi      # 0x1efb8
leaq 0x3d9e(%rip), %rsi      # 0x16cca
callq 0x43a0
movq %rax, %rdi
movq 0xc04d(%rip), %rsi      # 0x1ef88
callq 0x4400
jmp 0x12f4a
movl -0x4(%rbp), %edi
callq 0x46f0
jmp 0x12fa6
callq 0x4060
cmpl $0x11, (%rax)
jne 0x12f7a
movq 0xc05b(%rip), %rdi      # 0x1efb8
leaq 0x3d7b(%rip), %rsi      # 0x16cdf
callq 0x43a0
movq %rax, %rdi
movq 0xc015(%rip), %rsi      # 0x1ef88
callq 0x4400
jmp 0x12f9c
movq 0xc037(%rip), %rdi      # 0x1efb8
leaq 0x3d72(%rip), %rsi      # 0x16cfa
callq 0x43a0
movq %rax, %rdi
movq 0xbff1(%rip), %rsi      # 0x1ef88
callq 0x4400
movl $0x1, %edi
callq 0x4480
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fgheng[P]keysound/./include/usage.hpp
// Function: usage()
static void usage()
{
    std::cout   << "Usage: keysound [OPTION]...\n"
                << "Play sound while pressed keyboard keys.\n"
                << "\n"
                << "  -f, --file=WAV_FILE        play sound use FILE\n"
                << "  -j, --json=JSON_FILE       config keyboard sound by json\n"
                << "  -d, --dir=DIR              config keyboard sound by direction\n"
                << "  -l, --log=LOG_FILE         log file (not implemented)\n"
                << "  -D, --daemon               run in background\n"
                << "  -k, --kill                 stop all\n"
                << "  -?, -h, --help             help\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xbffd(%rip), %rdi      # 0x1efb8
leaq 0x3b30(%rip), %rsi      # 0x16af2
callq 0x43a0
movq %rax, %rdi
leaq 0x3b3e(%rip), %rsi      # 0x16b0f
callq 0x43a0
movq %rax, %rdi
leaq 0x3c3e(%rip), %rsi      # 0x16c1e
callq 0x43a0
movq %rax, %rdi
leaq 0x3b49(%rip), %rsi      # 0x16b38
callq 0x43a0
movq %rax, %rdi
leaq 0x3b6c(%rip), %rsi      # 0x16b6a
callq 0x43a0
movq %rax, %rdi
leaq 0x3b99(%rip), %rsi      # 0x16ba6
callq 0x43a0
movq %rax, %rdi
leaq 0x3bcb(%rip), %rsi      # 0x16be7
callq 0x43a0
movq %rax, %rdi
leaq 0x3bf5(%rip), %rsi      # 0x16c20
callq 0x43a0
movq %rax, %rdi
leaq 0x3c16(%rip), %rsi      # 0x16c50
callq 0x43a0
movq %rax, %rdi
leaq 0x3c2e(%rip), %rsi      # 0x16c77
callq 0x43a0
popq %rbp
retq
// File: fgheng[P]keysound/src/main.cc
// Function: execute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string execute(const std::string &cmd) {
    FILE *pipe = popen(cmd.c_str(), "r");
    std::string result = "";

    if (pipe) {
        char buf[64];
        while (!feof(pipe)) {
            if (fgets(buf, 64, pipe))
                result += buf;
        }
        pclose(pipe);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4170
movq %rax, %rdi
leaq 0x31b7(%rip), %rsi      # 0x1623b
callq 0x4110
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4680
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x393b(%rip), %rsi      # 0x169e8
callq 0x93e0
jmp 0x130b4
leaq -0x1a(%rbp), %rdi
callq 0x4420
cmpq $0x0, -0x18(%rbp)
je 0x13157
jmp 0x130ca
movq -0x18(%rbp), %rdi
callq 0x4590
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x130e1
jmp 0x1314a
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x45b0
movq %rax, -0x90(%rbp)
jmp 0x130fc
movq -0x90(%rbp), %rax
cmpq $0x0, %rax
je 0x13148
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4370
jmp 0x13118
jmp 0x13148
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4420
jmp 0x1317a
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4728
jmp 0x1317a
jmp 0x130ca
movq -0x18(%rbp), %rdi
callq 0x4510
jmp 0x13155
jmp 0x13157
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1316a
movq -0x80(%rbp), %rdi
callq 0x4728
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/main.cc
// Function: signal_handler(int)
static void signal_handler(int signal) {
    stop_detect();
    stop_play();

    // 删除文件		Delete Files
    post_process();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0xaf50
callq 0xe3e0
callq 0x131b0
addq $0x10, %rsp
popq %rbp
retq
// File: fgheng[P]keysound/src/main.cc
// Function: post_process()
static void post_process() {
    pid_t pid = 0;
    FILE *tmp = fopen(PID_FILE, "r");

    if (tmp) {
        if (fscanf(tmp, "%d", &pid) == 1) {
            fclose(tmp);
            if (pid == getpid()) remove(PID_FILE);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x3af2(%rip), %rdi      # 0x16cb8
leaq 0x306e(%rip), %rsi      # 0x1623b
callq 0x4460
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13225
movq -0x10(%rbp), %rdi
leaq 0x37e8(%rip), %rsi      # 0x169d0
leaq -0x4(%rbp), %rdx
movb $0x0, %al
callq 0x46c0
cmpl $0x1, %eax
jne 0x13223
movq -0x10(%rbp), %rdi
callq 0x43b0
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x4560
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jne 0x13221
leaq 0x3a9c(%rip), %rdi      # 0x16cb8
callq 0x46a0
jmp 0x13223
jmp 0x13225
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fgheng[P]keysound/src/utils.cc
// Function: add_event_id(int)
void add_event_id(int event_id) {
    if (event_id > FILE_NUMS) {
        std::cout << "add error file is lager" << std::endl;
        return;
    }
    mtx.lock();
    key_detects_bool[event_id] = true;
    mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jle 0x142a8
movq 0xad2d(%rip), %rdi      # 0x1efb8
leaq 0x2b12(%rip), %rsi      # 0x16da4
callq 0x43a0
movq %rax, %rdi
movq 0xace7(%rip), %rsi      # 0x1ef88
callq 0x4400
jmp 0x142cf
leaq 0xdec1(%rip), %rdi      # 0x22170
callq 0xe250
movslq -0x4(%rbp), %rcx
leaq 0xdab1(%rip), %rax      # 0x21d70
movb $0x1, (%rax,%rcx)
leaq 0xdea6(%rip), %rdi      # 0x22170
callq 0xe2a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/utils.cc
// Function: del_event_id(int)
void del_event_id(int event_id) {
    if (event_id > FILE_NUMS) {
        std::cout << "delete error file is lager" << std::endl;
        return;
    }
    mtx.lock();
    key_detects_bool[event_id] = false;
    mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jle 0x14318
movq 0xacbd(%rip), %rdi      # 0x1efb8
leaq 0x2aba(%rip), %rsi      # 0x16dbc
callq 0x43a0
movq %rax, %rdi
movq 0xac77(%rip), %rsi      # 0x1ef88
callq 0x4400
jmp 0x1433f
leaq 0xde51(%rip), %rdi      # 0x22170
callq 0xe250
movslq -0x4(%rbp), %rcx
leaq 0xda41(%rip), %rax      # 0x21d70
movb $0x0, (%rax,%rcx)
leaq 0xde36(%rip), %rdi      # 0x22170
callq 0xe2a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fgheng[P]keysound/src/utils.cc
// Function: event_id_exists(int)
bool event_id_exists(int event_id) {
    if (event_id > FILE_NUMS) {
        std::cout << "file is lager" << std::endl;
        return false;
    }
    return key_detects_bool[event_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x400, -0x8(%rbp)      # imm = 0x400
jle 0x1438c
movq 0xac4d(%rip), %rdi      # 0x1efb8
leaq 0x2a3c(%rip), %rsi      # 0x16dae
callq 0x43a0
movq %rax, %rdi
movq 0xac07(%rip), %rsi      # 0x1ef88
callq 0x4400
movb $0x0, -0x1(%rbp)
jmp 0x143a3
movslq -0x8(%rbp), %rcx
leaq 0xd9d9(%rip), %rax      # 0x21d70
cmpb $0x0, (%rax,%rcx)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: fgheng[P]keysound/src/utils.cc
// Function: clear_all_key_detect_threads()
void clear_all_key_detect_threads() {
    mtx.lock();
    // std::memset(key_detects_bool, 0, FILE_NUMS);
    // key_detects.erase(key_detects.begin(), key_detects.end());
    key_detects.clear();
    mtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xdd85(%rip), %rdi      # 0x22170
callq 0xe250
leaq 0xd941(%rip), %rdi      # 0x21d38
callq 0x14680
leaq 0xdd6d(%rip), %rdi      # 0x22170
callq 0xe2a0
popq %rbp
retq
nopw (%rax,%rax)
// File: fgheng[P]keysound/src/utils.cc
// Function: little_end()
bool little_end() {
    uint16_t num = 0x1122;
    uint8_t *c = (uint8_t *)&num;
    if (*c == 0x22) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x1122, -0x4(%rbp)     # imm = 0x1122
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x14434
movb $0x1, -0x1(%rbp)
jmp 0x14438
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: aydarbiktimirov[P]data-structures/src/include/persistent-data-structure.cpp
// Function: CAbstractPersistentDataStructure::SetVersion(unsigned long)
CAbstractPersistentDataStructure &CAbstractPersistentDataStructure::SetVersion(size_t version)
{
	if (version >= version_count)
	{
		throw std::out_of_range("version out of bounds");
	}

	current_version = version;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0x23f2
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x4c47(%rip), %rsi      # 0x7004
callq 0x2030
jmp 0x23c4
movq -0x30(%rbp), %rdi
movq 0x8c01(%rip), %rsi      # 0xafd0
movq 0x8bf2(%rip), %rdx      # 0xafc8
callq 0x21b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20d0
jmp 0x2404
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x21d0
nopl (%rax)
// File: aydarbiktimirov[P]data-structures/src/include/persistent-segment-tree.h
// Function: CPersistentSegmentTree<int, std::plus<int>>::operator()(unsigned long, unsigned long, unsigned long) const
T CPersistentSegmentTree<T, Operation>::operator()(size_t left, size_t right, size_t version) const
{
	if (version >= this->GetVersionCount())
	{
		throw std::out_of_range("version doesn't exist");
	}
	if (left > right)
	{
		return operator()(right, left);
	}
	if (right >= element_count)
	{
		throw std::out_of_range("index out of bounds");
	}

	return Calculate(left, right, roots[version], 0, values_first_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x544d
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1de1(%rip), %rsi      # 0x71f6
callq 0x2030
jmp 0x541c
movq -0x50(%rbp), %rdi
movq 0x5ba9(%rip), %rsi      # 0xafd0
movq 0x5b9a(%rip), %rdx      # 0xafc8
callq 0x21b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20d0
jmp 0x5519
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5471
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, -0x4(%rbp)
jmp 0x5510
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x20(%rcx), %rax
jb 0x54cf
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x1d72(%rip), %rsi      # 0x720c
callq 0x2030
jmp 0x54a1
movq -0x58(%rbp), %rdi
movq 0x5b24(%rip), %rsi      # 0xafd0
movq 0x5b15(%rip), %rdx      # 0xafc8
callq 0x21b0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20d0
jmp 0x5519
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x48, %rdi
movq -0x28(%rbp), %rsi
callq 0x5680
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq (%rax), %rcx
movq 0x28(%rdi), %r9
xorl %eax, %eax
movl %eax, %r8d
callq 0x5530
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: aydarbiktimirov[P]data-structures/src/include/persistent-segment-tree.h
// Function: CPersistentSegmentTree<int, std::plus<int>>::Calculate(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) const
T CPersistentSegmentTree<T, Operation>::Calculate(size_t from, size_t to, size_t current, size_t left_bound, size_t right_bound) const
{ // сумма элементов между left_bound и right_bound хранится в элемнете current
	if (from > to)
	{
		return default_value;
	}
	if (from == left_bound && to == right_bound)
	{
		return values[current].value;
	}
	size_t middle_bound = (left_bound + right_bound) / 2;
	return Operation()(Calculate(from, std::min(to, middle_bound), values[current].left, left_bound, middle_bound),
		Calculate(std::max(middle_bound + 1, from), to, values[current].right, middle_bound + 1, right_bound));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5574
movq -0x60(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5670
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x55a3
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x55a3
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0x56a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5670
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3920
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x78(%rbp)
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0x56a0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x5530
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4970
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0x56a0
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %r8
addq $0x1, %r8
movq -0x38(%rbp), %r9
callq 0x5530
movl %eax, -0x4c(%rbp)
leaq -0x41(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x4ae0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: FindClosestLeafNode(gaps::R3SurfelTree*, gaps::R3Point const&, double)
R3SurfelNode *
FindClosestLeafNode(R3SurfelTree *tree, const R3Point& query_position, RNLength max_distance)
{
  // Find closest node
  R3SurfelNode *closest_node = NULL;
  RNLength closest_distance = max_distance;
  RNVolume closest_volume = FLT_MAX;
  for (int i = 0; i < tree->NNodes(); i++) {
    R3SurfelNode *node = tree->Node(i);
    if (node->NParts() > 0) continue;
    RNLength distance = R3Distance(node->BBox(), query_position);
    if (distance <= closest_distance) {
      RNVolume volume = node->BBox().Volume();
      if ((distance < closest_distance) || (volume < closest_volume)) {
        closest_distance = distance;
        closest_volume = volume;
        closest_node = node;
      }
    }
  }

  // Return closest node
  return closest_node;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x1de617(%rip), %xmm0   # 0x1f8008
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x50(%rsp), %rdi
callq 0x26330
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x19ae8
movq 0x50(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x26350
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x26380
cmpl $0x0, %eax
jle 0x19a46
jmp 0x19ad8
movq 0x18(%rsp), %rdi
callq 0x5ccc0
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x263a0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x19ad6
movq 0x18(%rsp), %rdi
callq 0x5ccc0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x19ab2
movsd 0x8(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19ad4
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x19ad6
jmp 0x19ad8
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x199ff
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CheckForNumber(char const*)
static int
CheckForNumber(const char *str)
{
  // Check if string is a number
  for (const char *strp = str; *strp; strp++) {
    if (isdigit(*strp)) continue;
    if (*strp == '-') continue;
    if (*strp == '-') continue;
    if (*strp == '+') continue;
    if (*strp == '.') continue;
    return 0;
  }

  // Passed all tests
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x1a90e
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x16680
cmpl $0x0, %eax
je 0x1a8be
jmp 0x1a900
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1a8cc
jmp 0x1a900
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1a8da
jmp 0x1a900
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x1a8e8
jmp 0x1a900
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x1a8f6
jmp 0x1a900
movl $0x0, 0x14(%rsp)
jmp 0x1a916
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1a8a2
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CheckForArgument(int, char**, char const*)
static int 
CheckForArgument(int argc, char **argv, const char *argument)
{
  // Check for -v in program arguments
  for (int i = 1; i < argc; i++) 
    if (!strcmp(argv[i], argument)) return 1;
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x1e01a
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x16a80
cmpl $0x0, %eax
jne 0x1e00b
movl $0x1, 0x24(%rsp)
jmp 0x1e022
jmp 0x1e00d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1dfda
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CreateNode(gaps::R3SurfelScene*, char const*, char const*)
static R3SurfelNode *
CreateNode(R3SurfelScene *scene, const char *node_name, const char *parent_name)
{
  // Get surfel tree
  R3SurfelTree *tree = scene->Tree();
  if (!tree) {
    RNFail("Scene has no tree\n");
    return NULL;
  }    

  // Find parent node
  R3SurfelNode *parent_node = tree->FindNodeByName(parent_name);
  if (!parent_node) {
    RNFail("Unable to find parent node with name %s\n", parent_name);
    return NULL;
  }

  // Create node
  R3SurfelNode *node = new R3SurfelNode(node_name);
  if (!node) {
    RNFail("Unable to allocate node\n");
    return NULL;
  }
            
  // Insert node into tree
  tree->InsertNode(node, parent_node);

  // Return node
  return node;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x26780
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1e2f6
leaq 0x1da411(%rip), %rdi    # 0x1f86f2
movb $0x0, %al
callq 0x172cb0
movq $0x0, 0x50(%rsp)
jmp 0x1e3bc
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x60280
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1e333
movq 0x38(%rsp), %rsi
leaq 0x1da3e7(%rip), %rdi    # 0x1f8705
movb $0x0, %al
callq 0x172cb0
movq $0x0, 0x50(%rsp)
jmp 0x1e3bc
movl $0xd0, %edi
callq 0x16740
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
callq 0x5c600
jmp 0x1e354
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1e39e
leaq 0x1da3c1(%rip), %rdi    # 0x1f872e
movb $0x0, %al
callq 0x172cb0
movq $0x0, 0x50(%rsp)
jmp 0x1e3bc
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xd0, %esi
callq 0x16750
jmp 0x1e3c6
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x60080
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x16ca0
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CreateLabel(gaps::R3SurfelScene*, char const*, char const*)
static R3SurfelLabel *
CreateLabel(R3SurfelScene *scene, const char *label_name, const char *parent_name)
{
  // Find parent label
  R3SurfelLabel *parent_label = scene->FindLabelByName(parent_name);
  if (!parent_label) {
    RNFail("Unable to find parent label with name %s\n", parent_name);
    return NULL;
  }

  // Create label
  R3SurfelLabel *label = CreateLabel(scene, parent_label, label_name);
  if (!label) {
    RNFail("Unable to create label\n");
    return NULL;
  }

  // Return label
  return label;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x70ea0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x1e5f0
movq 0x48(%rsp), %rsi
leaq 0x1da1c1(%rip), %rdi    # 0x1f879c
movb $0x0, %al
callq 0x172cb0
movq $0x0, 0x60(%rsp)
jmp 0x1e678
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movsd 0x1d9a0d(%rip), %xmm2   # 0x1f8028
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x16e4f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %r9
movl %r8d, %ecx
callq 0x8a320
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x1e66e
leaq 0x1da16a(%rip), %rdi    # 0x1f87c6
movb $0x0, %al
callq 0x172cb0
movq $0x0, 0x60(%rsp)
jmp 0x1e678
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CreateMultiresolutionNodes(gaps::R3SurfelScene*, char const*, double, double, double)
static int
CreateMultiresolutionNodes(R3SurfelScene *scene, const char *node_name,
  RNScalar min_complexity, RNScalar min_resolution, RNScalar min_multiresolution_factor)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Get surfel tree
  R3SurfelTree *tree = scene->Tree();
  if (!tree) {
    RNFail("Scene has no surfel tree\n");
    return 0;
  }    

  // Temporary
  if (strcmp(node_name, "All")) {
    RNFail("-create_multiresolution_nodes only supported for All nodes\n");
    return 0;
  }

  // Create multiresolution nodes
  tree->CreateMultiresolutionNodes(min_complexity, min_resolution, min_multiresolution_factor);

  // Print statistics
  if (print_verbose) {
    printf("Created multiresolution nodes  ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Nodes = %d\n", tree->NNodes());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x16dd30
leaq 0x8(%rsp), %rdi
callq 0x263f0
movq 0x38(%rsp), %rdi
callq 0x26780
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x252c4
leaq 0x1d38ae(%rip), %rdi    # 0x1f8b5e
movb $0x0, %al
callq 0x172cb0
movl $0x0, 0x44(%rsp)
jmp 0x2536c
movq 0x30(%rsp), %rdi
leaq 0x1d38c5(%rip), %rsi    # 0x1f8b95
callq 0x16a80
cmpl $0x0, %eax
je 0x252f2
leaq 0x1d3c16(%rip), %rdi    # 0x1f8ef7
movb $0x0, %al
callq 0x172cb0
movl $0x0, 0x44(%rsp)
jmp 0x2536c
movq (%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x60ba0
cmpl $0x0, 0x23f4ac(%rip)    # 0x2647c0
je 0x25364
leaq 0x1d3c16(%rip), %rdi    # 0x1f8f33
movb $0x0, %al
callq 0x16090
leaq 0x8(%rsp), %rdi
callq 0x16ddf0
leaq 0x1d324a(%rip), %rdi    # 0x1f857f
movb $0x1, %al
callq 0x16090
movq (%rsp), %rdi
callq 0x26330
movl %eax, %esi
leaq 0x1d336f(%rip), %rdi    # 0x1f86bd
movb $0x0, %al
callq 0x16090
movq 0x235c34(%rip), %rax    # 0x25af90
movq (%rax), %rdi
callq 0x168c0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflprocess/sflprocess.cpp
// Function: CloseScene(gaps::R3SurfelScene*)
static int
CloseScene(R3SurfelScene *scene)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Close scene files
  if (!scene->CloseFile()) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Closed scene ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Comments = %d\n", scene->NComments());
    printf("  # Objects = %d\n", scene->NObjects());
    printf("  # Labels = %d\n", scene->NLabels());
    printf("  # Assignments = %d\n", scene->NLabelAssignments());
    printf("  # Features = %d\n", scene->NFeatures());
    printf("  # Scans = %d\n", scene->NScans());
    printf("  # Images = %d\n", scene->NImages());
    printf("  # Nodes = %d\n", scene->Tree()->NNodes());
    printf("  # Blocks = %d\n", scene->Tree()->Database()->NBlocks());
    printf("  # Surfels = %lld\n", scene->Tree()->Database()->NSurfels());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x16dd30
leaq 0x8(%rsp), %rdi
callq 0x263f0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
callq *0xf8(%rax)
cmpl $0x0, %eax
jne 0x258a1
movl $0x0, 0x24(%rsp)
jmp 0x25a18
cmpl $0x0, 0x23ef18(%rip)    # 0x2647c0
je 0x25a10
leaq 0x1d373e(%rip), %rdi    # 0x1f8ff3
movb $0x0, %al
callq 0x16090
leaq 0x8(%rsp), %rdi
callq 0x16ddf0
leaq 0x1d2cb2(%rip), %rdi    # 0x1f857f
movb $0x1, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x266a0
movl %eax, %esi
leaq 0x1d2d56(%rip), %rdi    # 0x1f863d
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x266c0
movl %eax, %esi
leaq 0x1d2d4f(%rip), %rdi    # 0x1f8650
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x266e0
movl %eax, %esi
leaq 0x1d2d47(%rip), %rdi    # 0x1f8662
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26700
movl %eax, %esi
leaq 0x1d2d3e(%rip), %rdi    # 0x1f8673
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26720
movl %eax, %esi
leaq 0x1d2d3a(%rip), %rdi    # 0x1f8689
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26740
movl %eax, %esi
leaq 0x1d2d33(%rip), %rdi    # 0x1f869c
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26760
movl %eax, %esi
leaq 0x1d2d29(%rip), %rdi    # 0x1f86ac
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26780
movq %rax, %rdi
callq 0x26330
movl %eax, %esi
leaq 0x1d2d18(%rip), %rdi    # 0x1f86bd
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26780
movq %rax, %rdi
callq 0x26790
movq %rax, %rdi
callq 0x267a0
movl %eax, %esi
leaq 0x1d2cfe(%rip), %rdi    # 0x1f86cd
movb $0x0, %al
callq 0x16090
movq 0x18(%rsp), %rdi
callq 0x26780
movq %rax, %rdi
callq 0x26790
movq %rax, %rdi
callq 0x267c0
movq %rax, %rsi
leaq 0x1d2ce4(%rip), %rdi    # 0x1f86de
movb $0x0, %al
callq 0x16090
movq 0x235588(%rip), %rax    # 0x25af90
movq (%rax), %rdi
callq 0x168c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atsidaev[P]trx2x/./utils.h
// Function: make_uppercase(char*)
inline void make_uppercase(char* str) {
	while (*str != 0) {
		if (*str >= 'a' && *str <= 'z')
			*str -= 'a' - 'A';
		str++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1b16
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x1b08
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x1b08
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
subl $0x20, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1ad8
popq %rbp
retq
nopl (%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: CalcCRC32(int, unsigned char)
int32_t CalcCRC32(int32_t CRC, unsigned char Symbol)
{
   int32_t temp;
   CRC ^= -1l ^ Symbol;
   for(int k = 8; k--;) 
      { temp = -(CRC & 1), CRC >>= 1, CRC ^= 0xEDB88320ul & temp; }
   CRC ^= -1l;
   return CRC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, %ecx
xorq $-0x1, %rcx
movslq -0x4(%rbp), %rax
xorq %rcx, %rax
movl %eax, -0x4(%rbp)
movl $0x8, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
je 0x1b8a
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
movslq -0xc(%rbp), %rcx
movabsq $0xedb88320, %rax       # imm = 0xEDB88320
andq %rax, %rcx
movslq -0x4(%rbp), %rax
xorq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x1b48
movslq -0x4(%rbp), %rax
xorq $-0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TDiskImage::TDiskImage()
TDiskImage::TDiskImage()
{
   AddBOOT = false;

   for(int t=0; t < 256; t++)
      for(int s=0; s < 256; s++)
      {
         FTrackLength[t][s] = 0;
         FTracksPtr[t][s][0] = NULL;
         FTracksPtr[t][s][1] = NULL;
      }

   DiskPresent = false;
   ReadOnly = true;
   Changed = false;
   FType = DIT_UNK;
   MaxTrack = 81;
   MaxSide = 0x01;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x145009(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x1c5e
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jge 0x1c4e
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
shlq $0xa, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq %rax, %rcx
addq $0x40000, %rcx          # imm = 0x40000
movslq -0xc(%rbp), %rdx
shlq $0xc, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq $0x0, (%rcx)
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1bd2
jmp 0x1c50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bbe
movq -0x18(%rbp), %rax
movb $0x0, 0x145006(%rax)
movb $0x1, 0x145005(%rax)
movb $0x0, 0x145004(%rax)
movl $0x0, 0x141000(%rax)
movb $0x51, 0x145007(%rax)
movb $0x1, 0x145008(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)