LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: addtt
static void
addtt(starttime, type)
const zic_t	starttime;
int		type;
{
	if (starttime <= min_time ||
		(timecnt == 1 && attypes[0].at < min_time)) {
		gmtoffs[0] = gmtoffs[type];
		isdsts[0] = isdsts[type];
		ttisstds[0] = ttisstds[type];
		ttisgmts[0] = ttisgmts[type];
		if (abbrinds[type] != 0)
			(void) strcpy(chars, &chars[abbrinds[type]]);
		abbrinds[0] = 0;
		charcnt = strlen(chars) + 1;
		typecnt = 1;
		timecnt = 0;
		type = 0;
	}
	if (timecnt >= TZ_MAX_TIMES) {
		error(_("too many transitions?!"));
		exit(EXIT_FAILURE);
	}
	attypes[timecnt].at = starttime;
	attypes[timecnt].type = type;
	++timecnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq 0xb28e(%rip), %rax      # 0x12228
jle 0x6fbd
cmpl $0x1, 0xb761(%rip)      # 0x12704
jne 0x7080
movq 0xc3b0(%rip), %rax      # 0x13360
cmpq 0xb271(%rip), %rax      # 0x12228
jge 0x7080
movslq -0xc(%rbp), %rcx
leaq 0xb758(%rip), %rax      # 0x12720
movq (%rax,%rcx,8), %rax
movq %rax, 0xb74d(%rip)      # 0x12720
movslq -0xc(%rbp), %rcx
leaq 0xbf42(%rip), %rax      # 0x12f20
movb (%rax,%rcx), %al
movb %al, 0xbf39(%rip)       # 0x12f20
movslq -0xc(%rbp), %rcx
leaq 0xc16e(%rip), %rax      # 0x13160
movb (%rax,%rcx), %al
movb %al, 0xc165(%rip)       # 0x13160
movslq -0xc(%rbp), %rcx
leaq 0xc25a(%rip), %rax      # 0x13260
movb (%rax,%rcx), %al
movb %al, 0xc251(%rip)       # 0x13260
movslq -0xc(%rbp), %rcx
leaq 0xc046(%rip), %rax      # 0x13060
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7048
movslq -0xc(%rbp), %rcx
leaq 0xc032(%rip), %rax      # 0x13060
movzbl (%rax,%rcx), %eax
leaq 0xbfe7(%rip), %rsi      # 0x13020
addq %rax, %rsi
leaq 0xbfdd(%rip), %rdi      # 0x13020
callq 0x2080
movb $0x0, 0xc011(%rip)      # 0x13060
leaq 0xbfca(%rip), %rdi      # 0x13020
callq 0x20d0
addq $0x1, %rax
movl %eax, 0xb6a7(%rip)      # 0x1270c
movl $0x1, 0xb699(%rip)      # 0x12708
movl $0x0, 0xb68b(%rip)      # 0x12704
movl $0x0, -0xc(%rbp)
cmpl $0x4b0, 0xb67a(%rip)    # imm = 0x4B0
jl 0x70a2
leaq 0x7dab(%rip), %rdi      # 0xee3e
callq 0x4110
movl $0x1, %edi
callq 0x2270
movq -0x8(%rbp), %rcx
movslq 0xb657(%rip), %rdx      # 0x12704
leaq 0xc2ac(%rip), %rax      # 0x13360
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movslq 0xb63a(%rip), %rdx      # 0x12704
leaq 0xc28f(%rip), %rax      # 0x13360
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x8(%rax)
movl 0xb623(%rip), %eax      # 0x12704
addl $0x1, %eax
movl %eax, 0xb61a(%rip)      # 0x12704
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: yearistype
static int
yearistype(year, type)
const int		year;
const char * const	type;
{
	static char *	buf;
	int		result;

	if (type == NULL || *type == '\0')
		return TRUE;
	buf = erealloc(buf, (int) (132 + strlen(yitcommand) + strlen(type)));
	(void) sprintf(buf, "%s %d %s", yitcommand, year, type);
	result = system(buf);
	if (WIFEXITED(result)) switch (WEXITSTATUS(result)) {
		case 0:
			return TRUE;
		case 1:
			return FALSE;
	}
	error(_("Wild result from command execution"));
	(void) fprintf(stderr, _("%s: command was '%s', result was %d\n"),
		progname, buf, result);
	for ( ; ; )
		exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7112
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x711e
movl $0x1, -0x4(%rbp)
jmp 0x7217
movq 0x10d3b(%rip), %rax     # 0x17e60
movq %rax, -0x28(%rbp)
movq 0xb0a0(%rip), %rdi      # 0x121d0
callq 0x20d0
addq $0x84, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movl %eax, %esi
callq 0xd030
movq %rax, %rdi
callq 0x40b0
movq %rax, 0x10cf4(%rip)     # 0x17e60
movq 0x10ced(%rip), %rdi     # 0x17e60
movq 0xb056(%rip), %rdx      # 0x121d0
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %r8
leaq 0x7ccd(%rip), %rsi      # 0xee55
movb $0x0, %al
callq 0x2250
movq 0x10cca(%rip), %rdi     # 0x17e60
callq 0x20e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x71d7
movzwl -0x14(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x71c3
jmp 0x71b9
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x71cc
jmp 0x71d5
movl $0x1, -0x4(%rbp)
jmp 0x7217
movl $0x0, -0x4(%rbp)
jmp 0x7217
jmp 0x71d7
leaq 0x7c80(%rip), %rdi      # 0xee5e
callq 0x4110
movq 0xae0e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xafbc(%rip), %rdx      # 0x121b0
movq 0x10c65(%rip), %rcx     # 0x17e60
movl -0x14(%rbp), %r8d
leaq 0x7c7b(%rip), %rsi      # 0xee81
movb $0x0, %al
callq 0x2180
movl $0x1, %edi
callq 0x2270
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: stringoffset
static int
stringoffset(result, offset)
char *	result;
long	offset;
{
	register int	hours;
	register int	minutes;
	register int	seconds;

	result[0] = '\0';
	if (offset < 0) {
		(void) strcpy(result, "-");
		offset = -offset;
	}
	seconds = offset % SECSPERMIN;
	offset /= SECSPERMIN;
	minutes = offset % MINSPERHOUR;
	offset /= MINSPERHOUR;
	hours = offset;
	if (hours >= HOURSPERDAY) {
		result[0] = '\0';
		return -1;
	}
	(void) sprintf(end(result), "%d", hours);
	if (minutes != 0 || seconds != 0) {
		(void) sprintf(end(result), ":%02d", minutes);
		if (seconds != 0)
			(void) sprintf(end(result), ":%02d", seconds);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
jge 0x84b8
movq -0x10(%rbp), %rdi
leaq 0x6653(%rip), %rsi      # 0xeafc
callq 0x2080
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x18, -0x1c(%rbp)
jl 0x851f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8597
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x20f0
movq %rax, %rdi
movl -0x1c(%rbp), %edx
leaq 0x66e1(%rip), %rsi      # 0xec18
movb $0x0, %al
callq 0x2250
cmpl $0x0, -0x20(%rbp)
jne 0x854a
cmpl $0x0, -0x24(%rbp)
je 0x8590
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x20f0
movq %rax, %rdi
movl -0x20(%rbp), %edx
leaq 0x66a5(%rip), %rsi      # 0xec07
movb $0x0, %al
callq 0x2250
cmpl $0x0, -0x24(%rbp)
je 0x858e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x20f0
movq %rax, %rdi
movl -0x24(%rbp), %edx
leaq 0x6680(%rip), %rsi      # 0xec07
movb $0x0, %al
callq 0x2250
jmp 0x8590
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/timocramer[P]thinklight-fun/tl-morsestrobo.c
// Function: main
int main(int argc, char **argv) {
	if(tl_init()) {
		fputs("Light Interface cannot be opened!\n", stderr);
		return 1;
	}
	if(tl_status() == TL_ON)
		initial_status = TL_ON;
	
	if(lock()) {
		if(errno != EEXIST)
			perror("open " LOCKFILE);
		else
			fputs("Thinklight is in use!\n", stderr);
		return 1;
	}
	
	install_signal_handler();
	
#ifdef MORSE
	if(argc < 2) {
		fputs(argv[0], stderr);
		fputs(": No arguments!\n", stderr);
		goto finish;
	}
	
	/* morse the arguments */
	int i = 1;
	while(1) {
		morse_string(argv[i]);
		
		++i;
		
		if(i >= argc) /* is it the last argument? */
			break;
		morse_char(' ');
	}
	
	/* save the initial status */
	if(initial_status == TL_ON)
		tl_on();
	else
		tl_off();
	
	finish:
	tl_deinit();
	unlock();
#elif defined STROBO
	/* use argc and argv so the compiler doesn't complain */
	(void) argc;
	(void) argv;
	
	while(1) {
		tl_toggle();
		usleep(DELAY);
	}
	/* deinit and unlock happens in the signal handler */
#endif
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x18f0
cmpl $0x0, %eax
je 0x1242
movq 0x2dd1(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xeb7(%rip), %rdi       # 0x20e8
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x1332
callq 0x1a10
cmpl $0x1, %eax
jne 0x1256
movl $0x1, 0x2e42(%rip)      # 0x4098
callq 0x1340
cmpl $0x0, %eax
je 0x129a
callq 0x1030
cmpl $0x11, (%rax)
je 0x1278
leaq 0xe9a(%rip), %rdi       # 0x210b
callq 0x10d0
jmp 0x128e
movq 0x2d79(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe9c(%rip), %rdi       # 0x2125
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x1332
callq 0x1390
cmpl $0x2, -0x8(%rbp)
jge 0x12d3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x2d45(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
callq 0x1080
movq 0x2d36(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe70(%rip), %rdi       # 0x213c
callq 0x1080
jmp 0x1321
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1420
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x12fe
jmp 0x130a
movl $0x20, %edi
callq 0x1480
jmp 0x12da
cmpl $0x1, 0x2d87(%rip)      # 0x4098
jne 0x131a
callq 0x1970
jmp 0x131f
callq 0x19c0
jmp 0x1321
callq 0x1940
callq 0x1520
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/timocramer[P]thinklight-fun/tl-morsestrobo.c
// Function: morse_string
static void morse_string(char *str) {
	char *c = str;
	
	while(*c != 0) {
		morse_char(*c);
		++c;
		if(*c != 0)
			usleep(AFTER_LETTER);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1470
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x1480
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x146e
movl $0x53020, %edi          # imm = 0x53020
callq 0x10f0
jmp 0x1434
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/timocramer[P]thinklight-fun/tl-morsestrobo.c
// Function: morse_char
static void morse_char(char c) {
	const char *p = morse_code(c);
	
	if(p != NULL) {
		while(*p != 0) {
			tl_toggle();
			if(*p == '.')
				usleep(DIT);
			else
				usleep(DAH);
			
			tl_toggle();
			usleep(AFTER_SYMBOL);
			
			++p;
		}
	}
	else if(c == ' ')
		usleep(AFTER_WORD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x1590
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14f6
jmp 0x14a4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x14f4
callq 0x1a90
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x14cd
movl $0x29810, %edi          # imm = 0x29810
callq 0x10f0
jmp 0x14d7
movl $0x7c830, %edi          # imm = 0x7C830
callq 0x10f0
callq 0x1a90
movl $0x29810, %edi          # imm = 0x29810
callq 0x10f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14a4
jmp 0x150b
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jne 0x1509
movl $0xa6040, %edi          # imm = 0xA6040
callq 0x10f0
jmp 0x150b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/uevent.c
// Function: usage
void usage(char *progname) {
  fprintf(stderr, "\
Usage:\n\
  %1$s -l GROUPS  listen for uevents, printing them to stdout\n\
  %1$s -b GROUPS  read uevents from stdin and broadcast them\n\
", progname);
  exit(EX_USAGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2cf5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcf3(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1130
movl $0x40, %edi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/spipe/main.c
// Function: callback_conndied
static int
callback_conndied(void * cookie, int reason)
{
	struct events_threads * ET = cookie;

	/* Check reason. */
	switch (reason) {
	case PROTO_CONN_CLOSED:
	case PROTO_CONN_CANCELLED:
		break;
	case PROTO_CONN_CONNECT_FAILED:
		warn0("Could not connect");
		ET->connection_error = 1;
		break;
	case PROTO_CONN_HANDSHAKE_FAILED:
		warn0("Handshake failed");
		ET->connection_error = 1;
		break;
	default:
		warn0("Connection error");
		ET->connection_error = 1;
	}

	/* Shut it down if there's an error. */
	if (ET->connection_error)
		graceful_shutdown_manual();

	/* Quit event loop. */
	ET->conndone = 1;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
jb 0x4868
jmp 0x4854
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x486a
jmp 0x485e
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x4892
jmp 0x48ba
jmp 0x48e0
jmp 0x486c
leaq 0x17bc7(%rip), %rdi     # 0x1c43a
movb $0x0, %al
callq 0x9b80
callq 0x3400
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x48e0
jmp 0x4894
leaq 0x17bb1(%rip), %rdi     # 0x1c44c
movb $0x0, %al
callq 0x9b80
callq 0x3400
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x48e0
jmp 0x48bc
leaq 0x17b9a(%rip), %rdi     # 0x1c45d
movb $0x0, %al
callq 0x9b80
callq 0x3400
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x48ef
callq 0xc250
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/spipe/main.c
// Function: callback_graceful_shutdown
static int
callback_graceful_shutdown(void * cookie)
{
	struct events_threads * ET = cookie;
	int rc;
	int i;

	/* Cancel the threads. */
	for (i = 0; i < 2; i++) {
		if ((rc = pthread_cancel(ET->threads[i])) != 0) {
			/*
			 * According to the POSIX standard, a Thread ID should
			 * still be valid after pthread_exit has been invoked
			 * by the thread if pthread_join() has not yet been
			 * called.  However, many platforms return ESRCH in
			 * this situation.
			 */
			if (rc != ESRCH) {
				warn0("pthread_cancel: %s", strerror(rc));
				goto err0;
			}
		}
	}

	/* Wait for the threads to finish. */
	for (i = 0; i < 2; i++) {
		if ((rc = pthread_join(ET->threads[i], NULL)) != 0) {
			warn0("pthread_join: %s", strerror(rc));
			goto err0;
		}
	}

	/* We've stopped the threads. */
	ET->stopped = 1;

	/* Shut down the main event loop. */
	ET->conndone = 1;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x498a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3390
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x497d
cmpl $0x3, -0x1c(%rbp)
je 0x497b
jmp 0x4952
movl -0x1c(%rbp), %edi
callq 0x3300
movq %rax, %rsi
leaq 0x17951(%rip), %rdi     # 0x1c2b5
movb $0x0, %al
callq 0x9b80
callq 0x3400
movl $0x0, (%rax)
jmp 0x4a08
jmp 0x497d
jmp 0x497f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x492b
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x49e9
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3030
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x49dc
jmp 0x49b6
movl -0x1c(%rbp), %edi
callq 0x3300
movq %rax, %rsi
leaq 0x178dc(%rip), %rdi     # 0x1c2a4
movb $0x0, %al
callq 0x9b80
callq 0x3400
movl $0x0, (%rax)
jmp 0x4a08
jmp 0x49de
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4991
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4a0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/char_array_expandable.c
// Function: char_array_expandable_put
void char_array_expandable_put(char_array_expandable *self, int8_t c){

	if(self->length == self->capacity){

		uint16_t old_capacity = self->capacity;

		self->capacity += self->capacity/5;

		int8_t *new_data = (int8_t*) malloc(sizeof(int8_t) * self->capacity);
		int8_t *old_data = self->data;

		uint16_t i;
		for(i = 0; i < old_capacity; i++)
			new_data[i] = old_data[i];

		free(old_data);

		self->data = new_data;

	}

	self->data[self->length] =  c;

	self->length++;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x137e
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, %edx
movq -0x8(%rbp), %rax
movzwl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movw $0x0, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1369
movq -0x20(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movb %dl, (%rax,%rcx)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x1339
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/float_ring_buffer.c
// Function: float_ring_buffer_init
void float_ring_buffer_init(float_ring_buffer *self, unsigned short capacity){

	self->size = capacity;
	self->data = (float*) malloc(sizeof(float) * capacity);

	self->read_position = 0;
	self->write_position = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc(%rax)
movzwl -0xa(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xa(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/float_ring_buffer.c
// Function: float_ring_buffer_get
float float_ring_buffer_get(float_ring_buffer *self, unsigned short index){

	unsigned short position = self->read_position + index;

	if(position >= self->size)
		position -= self->size;

	return self->data[position];

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movzwl -0xa(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jl 0x1513
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %ecx
movzwl -0xc(%rbp), %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xc(%rbp), %ecx
movss (%rax,%rcx,4), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/char_ring_buffer.c
// Function: char_ring_buffer_get
signed char char_ring_buffer_get(char_ring_buffer *self, unsigned short index){

	unsigned short position = self->read_position + index;

	if(position >= self->size)
		position -= self->size;

	return self->data[position];

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movzwl -0xa(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jl 0x1763
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %ecx
movzwl -0xc(%rbp), %eax
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xc(%rbp), %ecx
movb (%rax,%rcx), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/APRSPacket.c
// Function: APRSPacket_destroy
void APRSPacket_destroy(APRSPacket *packet){

	int i;
	for(i = 0; i < packet->repeaters; i++)
		free(packet->repeater_addresses[i]);
	free(packet->repeater_addresses);

	free(packet->data.data);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1b02
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ad3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/AFSK_Demodulator.c
// Function: AFSK_Demodulator_init
void AFSK_Demodulator_init(AFSK_Demodulator *self, uint32_t sr, uint16_t br, float off, float nf, uint16_t frequency_0, uint16_t frequency_1){

	#ifdef __DEBUG
		fourier_coefficient_debug = fopen("fourier_coefficient_debug.raw", "w");
	#endif

	self->sample_rate = sr;
	self->bit_rate = br;

	self->offset = off;
	self->noise_floor = nf;

	self->frequency_0 = frequency_0;
	self->frequency_1 = frequency_1;

	self->input_buffer.size = 0;
	self->fcd_buffer.size   = 0;

	self->fcMax = 0;
	self->fcMin = 0;

	char_ring_buffer_init(&self->bit_sequence, 14);

	char_array_expandable_init(&self->byte_sequence, 330);

	AFSK_Demodulator_reset(self);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %dx, -0xe(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movw %ax, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movw -0xe(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x24(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x34(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x38(%rax)
movw -0x1a(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x28(%rax)
movw -0x1c(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2a(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movl $0xe, %esi
callq 0x1660
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl $0x14a, %esi            # imm = 0x14A
callq 0x1270
movq -0x8(%rbp), %rdi
callq 0x1b30
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/AFSK_Demodulator.c
// Function: AFSK_Demodulator_destroy
void AFSK_Demodulator_destroy(AFSK_Demodulator *self){

	if(self->input_buffer.size != 0)
		char_ring_buffer_destory(&self->input_buffer);
	if(self->fcd_buffer.size != 0)
		float_ring_buffer_destory(&self->fcd_buffer);

	if(self->bit_sequence.size != 0)
		char_ring_buffer_destory(&self->bit_sequence);

	if(self->byte_sequence.capacity != 0)
		char_array_expandable_destroy(&self->byte_sequence);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %eax
cmpl $0x0, %eax
je 0x1e22
movq -0x8(%rbp), %rdi
callq 0x1890
movq -0x8(%rbp), %rax
movzwl 0x1c(%rax), %eax
cmpl $0x0, %eax
je 0x1e3c
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1640
movq -0x8(%rbp), %rax
movzwl 0x4c(%rax), %eax
cmpl $0x0, %eax
je 0x1e56
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x1890
movq -0x8(%rbp), %rax
movzwl 0x60(%rax), %eax
cmpl $0x0, %eax
je 0x1e70
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x13f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/packet_main.c
// Function: print_raw_packet
void print_raw_packet(APRSPacket *packet){

	unsigned short length = packet->data.len;

	fputc((length>>8) & 0xFF, stdout);
	fputc( length     & 0xFF, stdout);

	fwrite(packet->data.data, sizeof(char), packet->data.len, stdout);
	fflush(stdout);

	fprintf(stderr, "packet: Packet Length: %d\n", packet->data.len);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
sarl $0x8, %edi
andl $0xff, %edi
movq 0x3a15(%rip), %rax      # 0x5fd0
movq (%rax), %rsi
callq 0x10b0
movzwl -0xa(%rbp), %edi
andl $0xff, %edi
movq 0x39fc(%rip), %rax      # 0x5fd0
movq (%rax), %rsi
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edx
movq 0x39dc(%rip), %rax      # 0x5fd0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1140
movq 0x39c8(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
callq 0x1100
movq 0x39e1(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %edx
leaq 0x1a3e(%rip), %rsi      # 0x4066
movb $0x0, %al
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/packet_main.c
// Function: print_packet
void print_packet(APRSPacket *packet, bool show_errors_bool, bool raw){

	uint16_t fsc = APRSPacket_crc(packet);

	/* CRC is added to packet with bytes reversed
	 */
	uint16_t fsc2 = packet->data.data[packet->data.len-1];
	fsc2 <<= 8;
	fsc2 |= packet->data.data[packet->data.len-2] & 0xFF;

	if(fsc != fsc2 && !show_errors_bool) return;

	if(raw)
		print_raw_packet(packet);

	else
		print_detailed_packet(packet, fsc, fsc2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a80
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl (%rcx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
andl $0xff, %ecx
movzwl -0xe(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
je 0x28fe
testb $0x1, -0x9(%rbp)
jne 0x28fe
jmp 0x2923
testb $0x1, -0xa(%rbp)
je 0x290f
movq -0x8(%rbp), %rdi
callq 0x2590
jmp 0x2923
movq -0x8(%rbp), %rdi
movw -0xc(%rbp), %ax
movzwl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x2640
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/packet/packet_main.c
// Function: parse_opt
static error_t parse_opt(int key, char *arg, struct argp_state *state){

	// remove cast in full C
	struct arguments *arguments = ((struct arguments*)(state->input));

	switch(key){
		case 'i':
			arguments->filename = arg;
			break;
		case 's':
			arguments->sample_rate = atoi(arg);
			break;
		case 'b':
			arguments->bit_rate = atoi(arg);
			break;
		case 'e':
			arguments->show_errors = true;
			break;
		case 'r':
			arguments->raw = true;
			break;
		case 'n':
			arguments->noise_floor = atoi(arg);
			break;
		case 'o':
			arguments->offset = atof(arg);
			break;
		case -1:
			arguments->frequency_0 = atoi(arg);
			break;
		case -2:
			arguments->frequency_1 = atoi(arg);
			break;
		default:
			return ARGP_ERR_UNKNOWN;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $-0x2, %eax
je 0x2c36
jmp 0x2b50
movl -0x24(%rbp), %eax
subl $-0x1, %eax
je 0x2c22
jmp 0x2b5e
movl -0x24(%rbp), %eax
subl $0x62, %eax
je 0x2bce
jmp 0x2b68
movl -0x24(%rbp), %eax
subl $0x65, %eax
je 0x2be2
jmp 0x2b72
movl -0x24(%rbp), %eax
subl $0x69, %eax
je 0x2ba7
jmp 0x2b7c
movl -0x24(%rbp), %eax
subl $0x6e, %eax
je 0x2bf6
jmp 0x2b86
movl -0x24(%rbp), %eax
subl $0x6f, %eax
je 0x2c0a
jmp 0x2b90
movl -0x24(%rbp), %eax
subl $0x72, %eax
je 0x2bec
jmp 0x2b9a
movl -0x24(%rbp), %eax
subl $0x73, %eax
je 0x2bb7
jmp 0x2c4a
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x2c53
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
jmp 0x2c53
movq -0x20(%rbp), %rax
movb $0x1, 0x19(%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1060
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x2c53
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x2c53
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/crc/crcccitt.c
// Function: CRCCCITT
uint16_t CRCCCITT(uint8_t *data, uint16_t len, uint16_t polynomial){

	uint16_t crc = 0xFFFF;
	uint8_t i;

	while(len--){

		crc ^= *data++;

		for(i = 0; i < 8; i++){
			if(crc & 0x0001)
				crc = (crc >> 1) ^ polynomial;
			else
				crc >>= 1;
		}

	}

	crc ^= 0xFFFF;

	return crc;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movw $0xffff, -0xe(%rbp)     # imm = 0xFFFF
movw -0xa(%rbp), %ax
movw %ax, %cx
addw $-0x1, %cx
movw %cx, -0xa(%rbp)
cmpw $0x0, %ax
je 0x2d00
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %ecx
movzwl -0xe(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
movb $0x0, -0xf(%rbp)
movzbl -0xf(%rbp), %eax
cmpl $0x8, %eax
jge 0x2cfe
movzwl -0xe(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2ce8
movzwl -0xe(%rbp), %eax
sarl %eax
movzwl -0xc(%rbp), %ecx
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
jmp 0x2cf2
movzwl -0xe(%rbp), %eax
sarl %eax
movw %ax, -0xe(%rbp)
jmp 0x2cf4
movb -0xf(%rbp), %al
addb $0x1, %al
movb %al, -0xf(%rbp)
jmp 0x2cc1
jmp 0x2c8c
movzwl -0xe(%rbp), %eax
xorl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/util/argp.c
// Function: argp_parse_argument
static int argp_parse_argument(const char *name, const char *arg){

	int c = 0;

	while(true){

		// They are equal!
		if(name[c] == '\0' && (arg[c+2] == '\0' || arg[c+2] == '='))
			return c;

		// Finish if one string is a different length or if they have different values
		else if(name[c] == '\0' || arg[c+2] == '\0' || arg[c+2] == '=' || name[c] != arg[c+2])
			return -1;

		c++;

	}

	return -1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3008
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3000
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x3008
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x307f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3066
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3066
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x3066
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x306f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x307f
jmp 0x3071
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fc3
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.10/job-queue1.c
// Function: thread_function
void* thread_function (void* arg)
{
  while (job_queue != NULL) {
    /* Get the next available job.  */
    struct job* next_job = job_queue;
    /* Remove this job from the list.  */
    job_queue = job_queue->next;
    /* Carry out the work.  */
    process_job (next_job);
    /* Clean up.  */
    free (next_job);
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x2ea4(%rip)      # 0x4058
je 0x11e6
movq 0x2e9b(%rip), %rax      # 0x4058
movq %rax, -0x10(%rbp)
movq 0x2e90(%rip), %rax      # 0x4058
movq (%rax), %rax
movq %rax, 0x2e86(%rip)      # 0x4058
movq -0x10(%rbp), %rdi
callq 0x1180
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x11ac
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/f5pl_test.c
// Function: main
int main(int argc, char* argv[]) {
    //argument check check
    if (argc != 3) {
        ERROR("Not enough arguments. Usage  %s <ip_address> <file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char buffer[BUFF_SIZE];

    char* filepath = argv[2];
    int length = strlen(filepath);
    if (length > BUFF_SIZE) {
        ERROR("The file path is longer than the maximum allowed size %d\n",
              BUFF_SIZE);
        exit(EXIT_FAILURE);
    }

    //Connect to the server given as argument on port
    int socketfd = TCP_client_connect(argv[1], PORT);

    //send the message
    send_full_msg(socketfd, filepath, length);

    //receive the message
    int received = recv_full_msg(socketfd, buffer, BUFF_SIZE);

    //print the message
    buffer[received] = '\0'; //null character before printing the string
    fprintf(stderr, "Recieved : %s\n", buffer);

    //close the connection
    TCP_client_disconnect(socketfd);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x1e6f
movq 0x31b2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x15f1(%rip), %rsi      # 0x3448
leaq 0x1637(%rip), %rdx      # 0x3495
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1130
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x1018(%rbp)
movq -0x1018(%rbp), %rdi
callq 0x1080
movl %eax, -0x101c(%rbp)
cmpl $0x1000, -0x101c(%rbp)  # imm = 0x1000
jle 0x1eca
movq 0x3155(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x15ed(%rip), %rsi      # 0x349a
leaq 0x15e1(%rip), %rdx      # 0x3495
movl $0x1000, %ecx           # imm = 0x1000
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1130
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4e36, %esi           # imm = 0x4E36
callq 0x19c0
movl %eax, -0x1020(%rbp)
movl -0x1020(%rbp), %edi
movq -0x1018(%rbp), %rsi
movslq -0x101c(%rbp), %rdx
callq 0x1280
movl -0x1020(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1370
movl %eax, -0x1024(%rbp)
movslq -0x1024(%rbp), %rax
movb $0x0, -0x1010(%rbp,%rax)
movq 0x30ca(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq -0x1010(%rbp), %rdx
leaq 0x15ad(%rip), %rsi      # 0x34ec
movb $0x0, %al
callq 0x10e0
movl -0x1020(%rbp), %edi
callq 0x1dd0
xorl %eax, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/test/testBitBuffer.C
// Function: main
int main(int argc, char** argv) {
  BitBuffer* b = new BitBuffer(1);
  unsigned char t = 0;
  while (t < 255) {
    b->putBit(t);
    int d = b->getBit();
    printf("%d\n", d);
    t++;
  }
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa8, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl $0x1, %esi
callq 0x12a0
jmp 0x1215
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
cmpl $0xff, %eax
jge 0x1288
movq 0x20(%rsp), %rdi
movzbl 0x13(%rsp), %esi
callq 0x13c0
movq 0x20(%rsp), %rdi
callq 0x1340
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0xdad(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movb 0x13(%rsp), %al
addb $0x1, %al
movb %al, 0x13(%rsp)
jmp 0x1223
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xa8, %esi
callq 0x1080
jmp 0x1291
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x10d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/test/./../slow/src/BitBuffer.h
// Function: BitBuffer::BitBuffer(int)
BitBuffer(int capacity) {
    this->capacity = capacity;
    this->capacityMask = capacity - 1;
    head = 0;
    tail = 0;
    waitingfornotfull = false;
    waitingfornotempty = false;
    buf = new int[capacity];
    pthread_mutex_init(&bufferlock, NULL);
    pthread_cond_init(&notempty, NULL);
    pthread_cond_init(&notfull, NULL);
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movb $0x0, 0x40(%rax)
movb $0x0, 0x41(%rax)
movslq 0xc(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1040
movq (%rsp), %rdi
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10b0
movq (%rsp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movq (%rsp), %rdi
addq $0x78, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/slow/src/BitBuffer.C
// Function: BitBuffer::getBit()
int BitBuffer::getBit() {
  int c;
  pthread_mutex_lock(&bufferlock);
  while (head - tail == 0) {
    pthread_cond_wait(&notempty, &bufferlock);
  }

  c = buf[tail++ & capacityMask];

  pthread_cond_signal(&notfull);

  pthread_mutex_unlock(&bufferlock);
  return c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x10a0
movq (%rsp), %rcx
movl 0x8(%rcx), %eax
subl 0xc(%rcx), %eax
cmpl $0x0, %eax
jne 0x1380
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x48, %rdi
addq $0x18, %rsi
callq 0x10c0
jmp 0x135b
movq (%rsp), %rdi
movq 0x10(%rdi), %rax
movl 0xc(%rdi), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xc(%rdi)
andl 0x4(%rdi), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
addq $0x78, %rdi
callq 0x1030
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/slow/src/BitBuffer.C
// Function: BitBuffer::putBit(int)
void BitBuffer::putBit(int ch) {
  pthread_mutex_lock(&bufferlock);

  while ((head - tail) >= capacity) {
    pthread_cond_wait(&notfull, &bufferlock);
  }

  buf[head++ & capacityMask] = ch;

  pthread_cond_signal(&notempty);

  pthread_mutex_unlock(&bufferlock);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x10a0
movq (%rsp), %rcx
movl 0x8(%rcx), %eax
subl 0xc(%rcx), %eax
cmpl (%rcx), %eax
jl 0x1403
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x78, %rdi
addq $0x18, %rsi
callq 0x10c0
jmp 0x13df
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x10(%rdi), %rax
movl 0x8(%rdi), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdi)
andl 0x4(%rdi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x48, %rdi
callq 0x1030
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/slow/src/BitBuffer.C
// Function: BitBuffer::clear()
void BitBuffer::clear() {
  pthread_mutex_lock(&bufferlock);
  if (head - tail == 0) {
    pthread_mutex_unlock(&bufferlock);
    return;
  }

  head = 0;
  tail = 0;

  pthread_cond_signal(&notfull);

  pthread_mutex_unlock(&bufferlock);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x10a0
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %eax
subl 0xc(%rcx), %eax
cmpl $0x0, %eax
jne 0x147c
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
jmp 0x14a6
movq 0x8(%rsp), %rdi
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
addq $0x78, %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.5/temp_file.c
// Function: write_temp_file
temp_file_handle write_temp_file (char* buffer, size_t length)
{
	/* Create the filename and file. The XXXXXX will be replaced with
	characters that make the filename unique. */
	char temp_filename[] = "/tmp/temp_file.XXXXXX";
	int fd = mkstemp (temp_filename);
	/* Unlink the file immediately, so that it will be removed when the
	file descriptor is closed. */
	unlink (temp_filename);
	/* Write the number of bytes to the file first. */
	write (fd, &length, sizeof (length));
	/* Now write the data itself. */
	write (fd, buffer, length);
	/* Use the file descriptor as the handle for the temporary file.*/
	return fd;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xe39(%rip), %rax       # 0x2010
movq %rax, -0x30(%rbp)
movq 0xe36(%rip), %rax       # 0x2018
movq %rax, -0x28(%rbp)
movl 0xe34(%rip), %eax       # 0x2020
movl %eax, -0x20(%rbp)
movw 0xe2e(%rip), %ax        # 0x2024
movw %ax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10b0
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1030
movl -0x34(%rbp), %edi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x1040
movl -0x34(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1040
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.5/temp_file.c
// Function: read_temp_file
char* read_temp_file (temp_file_handle temp_file, size_t* length)
{
	char* buffer;
	/* The TEMP_FILE handle is a file descriptor to the temporary file. */
	int fd = temp_file;
	/* Rewind to the beginning of the file. */
	lseek (fd, 0, SEEK_SET);
	/* Read the size of the data in the temporary file. */
	read (fd, length, sizeof (*length));
	/* Allocate a buffer and read the data. */
	buffer = (char*) malloc (*length);
	read (fd, buffer, *length);
	/* Close the file descriptor, which will cause the temporary file to go away. */
	close (fd);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1070
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10a0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x1090
movl -0x1c(%rbp), %edi
callq 0x1080
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.5/temp_file.c
// Function: main
int main(){
	char* text = "Prueba de write_temp_file";
	temp_file_handle temp;
	size_t length = strlen(text);
	size_t* pointer = &length;
	temp = write_temp_file(text, length);
	printf("el texto en el temp_file:\n%s", read_temp_file(temp,pointer));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd60(%rip), %rax       # 0x2026
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11c0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x1240
movq %rax, %rsi
leaq 0xd3b(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_create_default
obdeque * obdeque_create_default(void){

  static const char classname[] = "obdeque";
  obdeque *new_instance = malloc(sizeof(obdeque));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obdeque_destroy, &obdeque_hash,
               &obdeque_compare, &obdeque_display, classname);

  new_instance->head = NULL;
  new_instance->tail = NULL;
  new_instance->length = 0;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d2f
jmp 0x1d4e
leaq 0x3db5(%rip), %rdi      # 0x5aeb
leaq 0x38c4(%rip), %rsi      # 0x5601
movl $0x200, %edx            # imm = 0x200
leaq 0x3ed2(%rip), %rcx      # 0x5c1b
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x1697(%rip), %rsi      # 0x33f0
leaq 0x1710(%rip), %rdx      # 0x3470
leaq 0x1879(%rip), %rcx      # 0x35e0
leaq 0x1a52(%rip), %r8       # 0x37c0
leaq 0x407c(%rip), %r9       # 0x5df1
callq 0x3bf0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_copy
obdeque * obdeque_copy(const obdeque *to_copy){

  obj *element;
  obdeque_iterator *iter;
  obdeque *copy;

  assert(to_copy);

  copy = obdeque_create_default();

  iter = obdeque_head_iterator(to_copy);

  if(!iter) return copy; /* if the list is empty, return empty copy */

  /* while there are elements in the deque to copy add to the tail of the
   * deque */
  do{
    element = obdeque_obj_at_iterator(to_copy, iter);
    obdeque_add_at_tail(copy, element);
  } while(obdeque_iterate_next(to_copy, iter));

  ob_release((obj *)iter);

  return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1dc5
jmp 0x1de4
leaq 0x382d(%rip), %rdi      # 0x55f9
leaq 0x382e(%rip), %rsi      # 0x5601
movl $0x18, %edx
leaq 0x3838(%rip), %rcx      # 0x5617
callq 0x1050
callq 0x1d10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e0b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e4d
jmp 0x1e0d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1eb0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f70
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2040
cmpb $0x0, %al
jne 0x1e0d
movq -0x20(%rbp), %rdi
callq 0x3ef0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)