LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_open
pnm_file pnm_file_open(FILE* f, pnm_type_t* ptype, int* pwidth, int* pheight)
{
	char magic, typec;
	int depth;
	int i;
	pnm_file s;

	if (fscanf(f, "%c%c\n", &magic, &typec) != 2)
		return 0;

	if (magic != 'P' || (typec != '5' && typec != '6'))
		return 0;

	*ptype = (pnm_type_t)(typec - '0');

	/* comments */
	for (i = 0; i < 16; i++)
		if (!fscanf(f, "#%*[^\n]\n"))
			break;

	if (fscanf(f, "%d %d\n", pwidth, pheight) != 2)
		return 0;

	/* scanf("%d\n") matches ANY AMOUNT of whitespace after the number. */
	if (fscanf(f, "%d", &depth) != 1)
		return 0;
	if (fgetc(f) != '\n')
		return 0;

	if (depth != 255)
		return 0;

	s = (pnm_file)malloc(sizeof(*s));
	s->file = f;
	s->type = *ptype;
	s->width = *pwidth;
	s->height = *pheight;
	s->stride = ((s->type == 6) ? 3 : 1) * s->width;

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1c74(%rip), %rsi      # 0x3007
leaq -0x29(%rbp), %rdx
leaq -0x2a(%rbp), %rcx
movb $0x0, %al
callq 0x1050
cmpl $0x2, %eax
je 0x13b4
movq $0x0, -0x8(%rbp)
jmp 0x150c
movsbl -0x29(%rbp), %eax
cmpl $0x50, %eax
jne 0x13cf
movsbl -0x2a(%rbp), %eax
cmpl $0x35, %eax
je 0x13dc
movsbl -0x2a(%rbp), %eax
cmpl $0x36, %eax
je 0x13dc
movq $0x0, -0x8(%rbp)
jmp 0x150c
movsbl -0x2a(%rbp), %ecx
subl $0x30, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jge 0x141c
movq -0x10(%rbp), %rdi
leaq 0x1c0c(%rip), %rsi      # 0x300d
movb $0x0, %al
callq 0x1050
cmpl $0x0, %eax
jne 0x140f
jmp 0x141c
jmp 0x1411
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x13f0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x1be7(%rip), %rsi      # 0x3016
movb $0x0, %al
callq 0x1050
cmpl $0x2, %eax
je 0x1448
movq $0x0, -0x8(%rbp)
jmp 0x150c
movq -0x10(%rbp), %rdi
leaq 0x1bca(%rip), %rsi      # 0x301d
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x1050
cmpl $0x1, %eax
je 0x1470
movq $0x0, -0x8(%rbp)
jmp 0x150c
movq -0x10(%rbp), %rdi
callq 0x1090
cmpl $0xa, %eax
je 0x148b
movq $0x0, -0x8(%rbp)
jmp 0x150c
cmpl $0xff, -0x30(%rbp)
je 0x149e
movq $0x0, -0x8(%rbp)
jmp 0x150c
movl $0x18, %edi
callq 0x10e0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x6, %edx
cmovel %eax, %ecx
movq -0x40(%rbp), %rax
imull 0xc(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_read_pic
int pnm_file_read_pic(pnm_file s, pnm_pix_t* picbuf)
{
	int l;

	for (l = 0; l < s->height; l++)
		if (pnm_file_read_line(s, picbuf + l*s->stride) < 0)
			return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x15cb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
cltq
addq %rax, %rsi
callq 0x1520
cmpl $0x0, %eax
jge 0x15be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15d2
jmp 0x15c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1587
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/pnm.c
// Function: pnm_filename_create
pnm_file pnm_filename_create(const char* fname, pnm_type_t type, int width, int height)
{
	FILE* f;
	pnm_file pnm;

	f = fopen(fname, "wb");
	if (!f)
		return 0;

	pnm = pnm_file_create(f, type, width, height);
	if (!pnm) {
		fclose(f);
		return 0;
	}

	return pnm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1a20(%rip), %rsi      # 0x3020
callq 0x1100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x161a
movq $0x0, -0x8(%rbp)
jmp 0x1652
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x1660
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x164a
movq -0x28(%rbp), %rdi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1652
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_create
pnm_file pnm_file_create(FILE* f, pnm_type_t type, int width, int height)
{
	pnm_file s;

	s = (pnm_file)malloc(sizeof(*s));

	s->file = f;
	s->type = type;
	s->width = width;
	s->height = height;
	s->stride = ((s->type == 6) ? 3 : 1) * s->width;

	fprintf(f, "P%d\n%d %d\n255\n", type, width, height);

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x18, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x6, %edx
cmovel %eax, %ecx
movq -0x20(%rbp), %rax
imull 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x193c(%rip), %rsi      # 0x3023
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_write_pic
int pnm_file_write_pic(pnm_file s, const pnm_pix_t* picbuf)
{
	int l;

	for (l = 0; l < s->height; l++)
		if (pnm_file_write_line(s, picbuf + l*s->stride) < 0)
			return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x17ab
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
cltq
addq %rax, %rsi
callq 0x1700
cmpl $0x0, %eax
jge 0x179e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17b2
jmp 0x17a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1767
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_read_text
int util_read_text(struct aatrace_text* txt, FILE* f)
{
	size_t sz = 0x1000;
	txt->buf = (char*)malloc(sz);
	unsigned int l;

	if (!fgets(txt->buf, sz, f))
		return -1;

	txt->ll = txt->w = strlen(txt->buf) - 1;

	for (l = 1; ; l++) {
		if ((l + 1)*txt->ll + 1 > sz) {
			sz *= 2;
			txt->buf = (char*)realloc(txt->buf, sz);
		}

		if (!fgets(&txt->buf[l*txt->ll], sz - l*txt->ll, f))
			break;
	}

	txt->h = l;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x1000, -0x20(%rbp)    # imm = 0x1000
movq -0x20(%rbp), %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x10a0
cmpq $0x0, %rax
jne 0x1863
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1927
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1080
subq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, %eax
cmpq -0x20(%rbp), %rax
jbe 0x18c8
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x10f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x8(%rdx), %ecx
movl %ecx, %ecx
subq %rcx, %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x10a0
cmpq $0x0, %rax
jne 0x1906
jmp 0x1916
jmp 0x1908
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x188a
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_load_text
int util_load_text(struct aatrace_text* txt, const char* fname)
{
	FILE* f = stdin;

	if (strcmp(fname, "-")) {
		f = fopen(fname, "rb");
		if (!f) {
			fprintf(stderr, "Error opening TXT file '%s': %s\n",
				fname, strerror(errno));

			return -1;
		}
	}

	if (util_read_text(txt, f) < 0) {
		fprintf(stderr, "Error reading TXT file '%s': %s\n",
			fname, strerror(errno));

		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x3691(%rip), %rax      # 0x4fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x16d9(%rip), %rsi      # 0x3032
callq 0x10b0
cmpl $0x0, %eax
je 0x19c4
movq -0x18(%rbp), %rdi
leaq 0x1696(%rip), %rsi      # 0x3004
callq 0x1100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19c2
movq 0x3673(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x1682(%rip), %rsi      # 0x3034
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a21
jmp 0x19c4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1810
cmpl $0x0, %eax
jge 0x1a1a
movq 0x361b(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x164b(%rip), %rsi      # 0x3055
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_write_text
int util_write_text(FILE* f, const struct aatrace_text* txt)
{
	int l;

	for (l = 0; l < txt->h; l++) {
		if (fwrite(&txt->buf[l*txt->ll], txt->w, 1, f) != 1)
			return -1;

		putc('\n', f);
	}

	return (txt->w + 1)*txt->h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1aa8
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movslq 0xc(%rax), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x1110
cmpq $0x1, %rax
je 0x1a8f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1abd
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x10c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a47
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_store_text
int util_store_text(const char* fname, const struct aatrace_text* txt)
{
	FILE* f = stdout;

	if (strcmp(fname, "-")) {
		f = fopen(fname, "wb");
		if (!f) {
			fprintf(stderr, "Error creating TXT file '%s': %s\n",
				fname, strerror(errno));

			return -1;
		}
	}

	if (util_write_text(f, txt) < 0) {
		fprintf(stderr, "Error writing TXT file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x34e9(%rip), %rax      # 0x4fd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1539(%rip), %rsi      # 0x3032
callq 0x10b0
cmpl $0x0, %eax
je 0x1b64
movq -0x10(%rbp), %rdi
leaq 0x1512(%rip), %rsi      # 0x3020
callq 0x1100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1b62
movq 0x34d3(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x1524(%rip), %rsi      # 0x3076
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bc1
jmp 0x1b64
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a30
cmpl $0x0, %eax
jge 0x1bba
movq 0x347b(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x14ee(%rip), %rsi      # 0x3098
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1bc1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_load_pic
int util_load_pic(struct aatrace_pic* pic, const char* fname)
{
	pnm_file pnm;
	pnm_type_t type;

	if (strcmp(fname, "-")) {
		pnm = pnm_filename_open(fname, &type, &pic->w, &pic->h);
	} else {
		pnm = pnm_file_open(stdin, &type, &pic->w, &pic->h);
	}

	if (!pnm || type != PNM_TYPE_PGM) {
		if (errno) {
			fprintf(stderr, "Error opening PGM file '%s': %s\n",
				fname, strerror(errno));
		} else {
			fprintf(stderr, "Bad PGM file '%s'\n", fname);
		}
		return -1;
	}

	pic->ll = pic->w;
	pic->buf = (unsigned char*)malloc(pic->ll*pic->h);

	if (pnm_file_read_pic(pnm, pic->buf) < 0) {
		fprintf(stderr, "Error reading PGM file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	pnm_file_close(pnm);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1447(%rip), %rsi      # 0x3032
callq 0x10b0
cmpl $0x0, %eax
je 0x1c18
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0xc, %rdx
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
leaq -0x24(%rbp), %rsi
callq 0x12e0
movq %rax, -0x20(%rbp)
jmp 0x1c3f
movq 0x33b9(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0xc, %rdx
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
leaq -0x24(%rbp), %rsi
callq 0x1370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c4c
cmpl $0x5, -0x24(%rbp)
je 0x1cbb
callq 0x1040
cmpl $0x0, (%rax)
je 0x1c93
movq 0x339b(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x142f(%rip), %rsi      # 0x30b9
movb $0x0, %al
callq 0x10d0
jmp 0x1caf
movq 0x335e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1432(%rip), %rsi      # 0x30da
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d54
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1570
cmpl $0x0, %eax
jge 0x1d44
movq 0x32f1(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x13b9(%rip), %rsi      # 0x30ed
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d54
movq -0x20(%rbp), %rdi
callq 0x17e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_store_pic
int util_store_pic(const char* fname, const struct aatrace_pic* pic)
{
	pnm_file pnm;

	if (strcmp(fname, "-")) {
		pnm = pnm_filename_create(fname, PNM_TYPE_PGM, pic->w, pic->h);
	} else {
		pnm = pnm_file_create(stdout, PNM_TYPE_PGM, pic->w, pic->h);
	}

	if (!pnm) {
		fprintf(stderr, "Error creating PGM file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	if (pnm_file_write_pic(pnm, pic->buf) < 0) {
		fprintf(stderr, "Error writing PGM file '%s': %s\n",
			fname, strerror(errno));

		return -1;
	}

	pnm_file_close(pnm);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x12b7(%rip), %rsi      # 0x3032
callq 0x10b0
cmpl $0x0, %eax
je 0x1da7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movl $0x5, %esi
callq 0x15e0
movq %rax, -0x20(%rbp)
jmp 0x1dcd
movq 0x3222(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movl $0x5, %esi
callq 0x1660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e18
movq 0x321d(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x1306(%rip), %rsi      # 0x310e
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e81
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1750
cmpl $0x0, %eax
jge 0x1e71
movq 0x31c4(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x12cf(%rip), %rsi      # 0x3130
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e81
movq -0x20(%rbp), %rdi
callq 0x17e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/util.c
// Function: util_load_font
int util_load_font(struct aatrace_font* font, const char* fname)
{
	if (util_load_pic(&font->pic, fname) < 0)
		return -1;

	if (font->pic.w != AATRACE_FONT_WIDTH) {
		fprintf(stderr, "Font '%s' has unsupported width %d\n",
			fname, font->pic.w);
		return -1;
	}

	font->w = AATRACE_FONT_WIDTH;
	font->h = AATRACE_FONT_HEIGHT;
	font->nchars = font->pic.h/AATRACE_FONT_HEIGHT;
	font->ascii_offset = AATRACE_FONT_ASCII_OFFSET;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bd0
cmpl $0x0, %eax
jge 0x1ebb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f31
movq -0x10(%rbp), %rax
cmpl $0x8, 0xc(%rax)
je 0x1ef1
movq 0x312c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
leaq 0x1270(%rip), %rsi      # 0x3151
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f31
movq -0x10(%rbp), %rax
movl $0x8, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x10, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x20, 0x24(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/render.c
// Function: aatrace_render_pic
void aatrace_render_pic(struct aatrace_pic* out,
			const struct aatrace_text* txt,
			const struct aatrace_font* font)
{
	int tl, tc;

	out->ll = out->w = txt->w*font->w;
	out->h = txt->h*font->h;
	out->buf = (unsigned char*)malloc(out->ll*out->h);

	for (tl = 0; tl < txt->h; tl++)
		for (tc = 0; tc < txt->w; tc++) {
			int tile = txt->buf[tl*txt->ll + tc] - font->ascii_offset;

			aatrace_bitblt(out->buf, font->pic.buf,
				       out->ll, font->pic.ll,
				       tc*font->w, tl*font->h,
				       0, tile*font->h,
				       font->w, font->h);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
imull 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
imull 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x2089
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x2079
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
subl 0x24(%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0x28(%rbp), %r8d
movq -0x20(%rbp), %rax
imull 0x18(%rax), %r8d
movl -0x24(%rbp), %r9d
movq -0x20(%rbp), %rax
imull 0x1c(%rax), %r9d
movl -0x2c(%rbp), %r11d
movq -0x20(%rbp), %rax
imull 0x1c(%rax), %r11d
movq -0x20(%rbp), %rax
movl 0x18(%rax), %r10d
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
xorl %ebx, %ebx
movl $0x0, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x2090
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1fc8
jmp 0x207b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1fb1
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/./bitblt.h
// Function: aatrace_bitblt
static
void aatrace_bitblt(unsigned char* d, const unsigned char* s,
		    unsigned int dll, unsigned int sll,
		    int dx, int dy, int sx, int sy,
		    int w, int h)
{
	int l, i;

	for (l = 0; l < h; l++)
		for (i = 0; i < w; i++)
			d[(l + dy)*dll + dx + i] = s[(l + sy)*sll + sx + i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x28(%rbp), %eax
jge 0x211e
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x20(%rbp), %eax
jge 0x2111
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl 0x18(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl 0x10(%rbp), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x20(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x20cc
jmp 0x2113
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20bd
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/3-ProcessUser/exec_example.c
// Function: main
int main(void) {
	int i = 10;
	printf("before execl...\n");

//	execl("/bin/xxx", "/bin/ls", "-l", "-a", NULL);
  execl("/bin/ls", "-l", "-a", NULL);
//    execl("/bin/ls", "/bin/ls", "*.c", NULL);

	printf("after execl...(%d)\n", i);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, -0x8(%rbp)
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0xe9a(%rip), %rdi       # 0x2015
leaq 0xe9b(%rip), %rsi       # 0x201d
leaq 0xe97(%rip), %rdx       # 0x2020
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x1040
movl -0x8(%rbp), %esi
leaq 0xe85(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_create_buffer
YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file , yyscanner);

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x40, %edi
callq 0x3700
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x455c
movq -0x18(%rbp), %rsi
leaq 0x802b(%rip), %rdi      # 0xc582
callq 0x60d0
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3700
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x45a2
movq -0x18(%rbp), %rsi
leaq 0x7fe5(%rip), %rdi      # 0xc582
callq 0x60d0
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6a40
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_load_buffer_state
static void yy_load_buffer_state  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	yyg->yy_hold_char = *yyg->yy_c_buf_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: yy_get_previous_state
static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_current_state = yyg->yy_start;

	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			yyg->yy_last_accepting_state = yy_current_state;
			yyg->yy_last_accepting_cpos = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 158 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x6239
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6170
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5159(%rip), %rax      # 0xb2c0
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
jmp 0x617a
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x617a
movl -0x28(%rbp), %eax
movb %al, -0x21(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5235(%rip), %rax      # 0xb3c0
cmpw $0x0, (%rax,%rcx,2)
je 0x61a8
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x61aa
movslq -0xc(%rbp), %rcx
leaq 0x595b(%rip), %rax      # 0xbb10
movswl (%rax,%rcx,2), %eax
movzbl -0x21(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5337(%rip), %rax      # 0xb500
movswl (%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
je 0x6202
movslq -0xc(%rbp), %rcx
leaq 0x5aa3(%rip), %rax      # 0xbc80
movswl (%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
cmpl $0x9e, -0xc(%rbp)
jl 0x6200
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
leaq 0x5bf6(%rip), %rax      # 0xbdf0
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
jmp 0x61aa
movslq -0xc(%rbp), %rcx
leaq 0x5903(%rip), %rax      # 0xbb10
movswl (%rax,%rcx,2), %eax
movzbl -0x21(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5c0f(%rip), %rax      # 0xbe30
movswl (%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6139
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 158 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 157);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x5152(%rip), %rax      # 0xb3c0
cmpw $0x0, (%rax,%rcx,2)
je 0x628b
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x628d
movslq -0x4(%rbp), %rcx
leaq 0x5878(%rip), %rax      # 0xbb10
movswl (%rax,%rcx,2), %eax
movzbl -0x29(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5254(%rip), %rax      # 0xb500
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x62e5
movslq -0x4(%rbp), %rcx
leaq 0x59c0(%rip), %rax      # 0xbc80
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x9e, -0x4(%rbp)
jl 0x62e3
movzbl -0x29(%rbp), %eax
movl %eax, %ecx
leaq 0x5b13(%rip), %rax      # 0xbdf0
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
jmp 0x628d
movslq -0x4(%rbp), %rcx
leaq 0x5820(%rip), %rax      # 0xbb10
movswl (%rax,%rcx,2), %eax
movzbl -0x29(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5b2c(%rip), %rax      # 0xbe30
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x9d, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x632a
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x6330
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yyrestart
void yyrestart  (FILE * input_file , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack (yyscanner);
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
	yy_load_buffer_state( yyscanner );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x69ac
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x69ea
jmp 0x69b4
xorl %eax, %eax
testb $0x1, %al
jne 0x69ea
jmp 0x69b4
movq -0x10(%rbp), %rdi
callq 0x43e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
movl $0x4000, %esi           # imm = 0x4000
callq 0x3510
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6a0f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x6a17
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x6a17
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6a40
movq -0x10(%rbp), %rdi
callq 0x45d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_init_buffer
static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3080
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3350
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6ab6
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x6abe
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x6abe
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq %rcx, %rax
je 0x6ae1
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x6b08
movq -0x10(%rbp), %rdi
callq 0x34f0
movl %eax, %edi
callq 0x3130
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6b0f
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6b0f
movl -0x3c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x3080
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_switch_to_buffer
void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack (yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yyg->yy_did_buffer_switch_on_eof = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6b76
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x6b7e
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x6b7e
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x6b8d
jmp 0x6c34
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6bb1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6bb9
jmp 0x6c08
xorl %eax, %eax
testb $0x1, %al
jne 0x6bb9
jmp 0x6c08
movq -0x18(%rbp), %rax
movb 0x30(%rax), %cl
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x45d0
movq -0x18(%rbp), %rax
movl $0x1, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_delete_buffer
void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf , yyscanner );

	yyfree( (void *) b , yyscanner );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6c84
jmp 0x6d06
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6cb1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x6cb9
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x6cb9
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6cde
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6cf9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yy_flush_buffer
void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( yyscanner );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6d54
jmp 0x6de7
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6dc9
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x6dd1
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x6dd1
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6de7
movq -0x10(%rbp), %rdi
callq 0x45d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yypush_buffer_state
void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack(yyscanner);

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*yyg->yy_c_buf_p = yyg->yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		yyg->yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( yyscanner );
	yyg->yy_did_buffer_switch_on_eof = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6e14
jmp 0x6f00
movq -0x10(%rbp), %rdi
callq 0x43e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6e41
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6e49
jmp 0x6e98
xorl %eax, %eax
testb $0x1, %al
jne 0x6e49
jmp 0x6e98
movq -0x18(%rbp), %rax
movb 0x30(%rax), %cl
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6ebc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6ec4
jmp 0x6ed4
xorl %eax, %eax
testb $0x1, %al
jne 0x6ec4
jmp 0x6ed4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x45d0
movq -0x18(%rbp), %rax
movl $0x1, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yypop_buffer_state
void yypop_buffer_state (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (yyg->yy_buffer_stack_top > 0)
		--yyg->yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( yyscanner );
		yyg->yy_did_buffer_switch_on_eof = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6f48
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6f55
jmp 0x6f50
xorl %eax, %eax
testb $0x1, %al
jne 0x6f55
jmp 0x6f50
jmp 0x7002
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6f7a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x6f82
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x6f82
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x32b0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x6fc2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6fe6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6fee
jmp 0x7002
xorl %eax, %eax
testb $0x1, %al
jne 0x6fee
jmp 0x7002
movq -0x8(%rbp), %rdi
callq 0x45d0
movq -0x10(%rbp), %rax
movl $0x1, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yyget_lineno
int yyget_lineno  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yylineno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7294
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x72a5
jmp 0x729c
xorl %eax, %eax
testb $0x1, %al
jne 0x72a5
jmp 0x729c
movl $0x0, -0x4(%rbp)
jmp 0x72bf
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/doy[P]libvt100/src/parser.c
// Function: vt100_parser_yyget_column
int yyget_column  (yyscan_t yyscanner)
{
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

        if (! YY_CURRENT_BUFFER)
            return 0;
    
    return yycolumn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7304
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7315
jmp 0x730c
xorl %eax, %eax
testb $0x1, %al
jne 0x7315
jmp 0x730c
movl $0x0, -0x4(%rbp)
jmp 0x732f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)