LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: curs_back
void curs_back(struct terminal_t *term, struct parm_t *parm)
{
	int num = sum(parm);

	if (num <= 0)
		num = 1;

	move_cursor(term, 0, -num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5dd9
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
subl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x4cd0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: curs_nl
void curs_nl(struct terminal_t *term, struct parm_t *parm)
{
	int num = sum(parm);

	if (num <= 0)
		num = 1;

	move_cursor(term, num, 0);
	cr(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5e19
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x4cd0
movq -0x8(%rbp), %rdi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: curs_pl
void curs_pl(struct terminal_t *term, struct parm_t *parm)
{
	int num = sum(parm);

	if (num <= 0)
		num = 1;

	move_cursor(term, -num, 0);
	cr(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5e69
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x4cd0
movq -0x8(%rbp), %rdi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: curs_pos
void curs_pos(struct terminal_t *term, struct parm_t *parm)
{
	int line, col;

	if (parm->argc <= 0) {
		line = col = 0;
	} else if (parm->argc == 2) {
		line = dec2num(parm->argv[0]) - 1;
		col  = dec2num(parm->argv[1]) - 1;
	} else {
		return;
	}

	if (line < 0)
		line = 0;
	if (col < 0)
		col = 0;

	set_cursor(term, line, col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x5f19
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x5f4e
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x5f4a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x31b0
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5f4c
jmp 0x5f77
jmp 0x5f4e
cmpl $0x0, -0x14(%rbp)
jge 0x5f5b
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x5f68
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x4e10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: erase_line
void erase_line(struct terminal_t *term, struct parm_t *parm)
{
	int i, mode;

	mode = (parm->argc <= 0) ? 0: dec2num(parm->argv[parm->argc - 1]);

	if (mode < 0 || 2 < mode)
		return;

	if (mode == 0) {
		for (i = term->cursor.x; i < term->cols; i++)
			erase_cell(term, term->cursor.y, i);
	} else if (mode == 1) {
		for (i = 0; i <= term->cursor.x; i++)
			erase_cell(term, term->cursor.y, i);
	} else if (mode == 2) {
		for (i = 0; i < term->cols; i++)
			erase_cell(term, term->cursor.y, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x61e0
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61fd
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x31b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x6213
movl $0x2, %eax
cmpl -0x18(%rbp), %eax
jge 0x6218
jmp 0x62d1
cmpl $0x0, -0x18(%rbp)
jne 0x6256
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6254
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x46f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6229
jmp 0x62d1
cmpl $0x1, -0x18(%rbp)
jne 0x6293
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
cmpl %ecx, %eax
jg 0x6291
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x46f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6263
jmp 0x62cf
cmpl $0x2, -0x18(%rbp)
jne 0x62cd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x62cb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x46f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62a0
jmp 0x62cd
jmp 0x62cf
jmp 0x62d1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: insert_line
void insert_line(struct terminal_t *term, struct parm_t *parm)
{
	int num = sum(parm);

	if (term->mode & MODE_ORIGIN) {
		if (term->cursor.y < term->scroll.top
			|| term->cursor.y > term->scroll.bottom)
			return;
	}

	if (num <= 0)
		num = 1;

	scroll(term, term->cursor.y, term->scroll.bottom, -num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6337
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jl 0x6333
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
cmpl %ecx, %eax
jle 0x6335
jmp 0x6362
jmp 0x6337
cmpl $0x0, -0x14(%rbp)
jg 0x6344
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movq -0x8(%rbp), %rax
movzwl 0x22(%rax), %edx
xorl %ecx, %ecx
subl -0x14(%rbp), %ecx
callq 0x4ad0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: delete_line
void delete_line(struct terminal_t *term, struct parm_t *parm)
{
	int num = sum(parm);

	if (term->mode & MODE_ORIGIN) {
		if (term->cursor.y < term->scroll.top
			|| term->cursor.y > term->scroll.bottom)
			return;
	}

	if (num <= 0)
		num = 1;

	scroll(term, term->cursor.y, term->scroll.bottom, num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x63c7
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jl 0x63c3
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
cmpl %ecx, %eax
jle 0x63c5
jmp 0x63f0
jmp 0x63c7
cmpl $0x0, -0x14(%rbp)
jg 0x63d4
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movq -0x8(%rbp), %rax
movzwl 0x22(%rax), %edx
movl -0x14(%rbp), %ecx
callq 0x4ad0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: delete_char
void delete_char(struct terminal_t *term, struct parm_t *parm)
{
	int i, num = sum(parm);

	if (num <= 0)
		num = 1;

	for (i = term->cursor.x; i < term->cols; i++) {
		if ((i + num) < term->cols)
			copy_cell(term, term->cursor.y, i, term->cursor.y, i + num);
		else
			erase_cell(term, term->cursor.y, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x6429
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6496
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6475
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %ecx
movl -0x14(%rbp), %r8d
addl -0x18(%rbp), %r8d
callq 0x4780
jmp 0x6489
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x46f0
jmp 0x648b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6434
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: erase_char
void erase_char(struct terminal_t *term, struct parm_t *parm)
{
	int i, num = sum(parm);

	if (num <= 0)
		num = 1;
	else if (num + term->cursor.x > term->cols)
		num = term->cols - term->cursor.x;

	for (i = term->cursor.x; i < term->cursor.x + num; i++)
		erase_cell(term, term->cursor.y, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3230
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x64cb
movl $0x1, -0x18(%rbp)
jmp 0x64f7
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x64f5
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x64f7
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6533
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x46f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6502
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: status_report
void status_report(struct terminal_t *term, struct parm_t *parm)
{
	int i, num;
	char buf[BUFSIZE];

	for (i = 0; i < parm->argc; i++) {
		num = dec2num(parm->argv[i]);
		if (num == 5) {         /* terminal response: ready */
			ewrite(term->fd, "\033[0n", 4);
		} else if (num == 6) {  /* cursor position report */
			snprintf(buf, BUFSIZE, "\033[%d;%dR", term->cursor.y + 1, term->cursor.x + 1);
			ewrite(term->fd, buf, strlen(buf));
		} else if (num == 15) { /* terminal response: printer not connected */
			ewrite(term->fd, "\033[?13n", 6);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6bc6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x31b0
movl %eax, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jne 0x6b20
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq 0x4f290(%rip), %rsi     # 0x55da1
movl $0x4, %edx
callq 0x2930
jmp 0x6bb6
cmpl $0x6, -0x18(%rbp)
jne 0x6b95
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %r8d
addl $0x1, %r8d
movl $0x400, %esi            # imm = 0x400
leaq 0x4f255(%rip), %rdx     # 0x55da6
movb $0x0, %al
callq 0x2110
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x42c(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x20d0
movl -0x42c(%rbp), %edi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
callq 0x2930
jmp 0x6bb4
cmpl $0xf, -0x18(%rbp)
jne 0x6bb2
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq 0x4f207(%rip), %rsi     # 0x55daf
movl $0x6, %edx
callq 0x2930
jmp 0x6bb4
jmp 0x6bb6
jmp 0x6bb8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ada
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: set_mode
void set_mode(struct terminal_t *term, struct parm_t *parm)
{
	int i, mode;

	for (i = 0; i < parm->argc; i++) {
		mode = dec2num(parm->argv[i]);
		if (*(term->esc.buf + 1) != '?')
			continue; /* not supported */

		if (mode == 6) { /* private mode */
			term->mode |= MODE_ORIGIN;
			set_cursor(term, 0, 0);
		} else if (mode == 7) {
			term->mode |= MODE_AMRIGHT;
		} else if (mode == 25) {
			term->mode |= MODE_CURSOR;
		} else if (mode == 8901) {
			term->mode |= MODE_VWBS;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6cc6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x31b0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3f, %eax
je 0x6c4e
jmp 0x6cb8
cmpl $0x6, -0x18(%rbp)
jne 0x6c70
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4e10
jmp 0x6cb6
cmpl $0x7, -0x18(%rbp)
jne 0x6c85
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6cb4
cmpl $0x19, -0x18(%rbp)
jne 0x6c9a
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6cb2
cmpl $0x22c5, -0x18(%rbp)    # imm = 0x22C5
jne 0x6cb0
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6cb2
jmp 0x6cb4
jmp 0x6cb6
jmp 0x6cb8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c17
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: reset_mode
void reset_mode(struct terminal_t *term, struct parm_t *parm)
{
	int i, mode;

	for (i = 0; i < parm->argc; i++) {
		mode = dec2num(parm->argv[i]);
		if (*(term->esc.buf + 1) != '?')
			continue; /* not supported */

		if (mode == 6) { /* private mode */
			term->mode &= ~MODE_ORIGIN;
			set_cursor(term, 0, 0);
		} else if (mode == 7) {
			term->mode &= ~MODE_AMRIGHT;
			term->wrap_occurred = false;
		} else if (mode == 25) {
			term->mode &= ~MODE_CURSOR;
		} else if (mode == 8901) {
			term->mode &= ~MODE_VWBS;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6d9e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x31b0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3f, %eax
je 0x6d1e
jmp 0x6d90
cmpl $0x6, -0x18(%rbp)
jne 0x6d40
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4e10
jmp 0x6d8e
cmpl $0x7, -0x18(%rbp)
jne 0x6d5d
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x3c(%rax)
jmp 0x6d8c
cmpl $0x19, -0x18(%rbp)
jne 0x6d72
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6d8a
cmpl $0x22c5, -0x18(%rbp)    # imm = 0x22C5
jne 0x6d88
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x9, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6d8a
jmp 0x6d8c
jmp 0x6d8e
jmp 0x6d90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ce7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: set_margin
void set_margin(struct terminal_t *term, struct parm_t *parm)
{
	int top, bottom;

	if (parm->argc <= 0) {        /* CSI r */
		top    = 0;
		bottom = term->lines - 1;
	} else if (parm->argc == 2) { /* CSI ; r -> use default value */
		top    = (parm->argv[0] == NULL) ? 0: dec2num(parm->argv[0]) - 1;
		bottom = (parm->argv[1] == NULL) ? term->lines - 1: dec2num(parm->argv[1]) - 1;
	} else {
		return;
	}

	if (top < 0 || top >= term->lines)
		top = 0;
	if (bottom < 0 || bottom >= term->lines)
		bottom = term->lines - 1;

	if (top >= bottom)
		return;

	term->scroll.top = top;
	term->scroll.bottom = bottom;

	set_cursor(term, 0, 0); /* move cursor to home */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x6ddf
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e4c
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6e48
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6dfa
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e0d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6e2d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6e40
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x31b0
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x6e4a
jmp 0x6eb7
jmp 0x6e4c
cmpl $0x0, -0x14(%rbp)
jl 0x6e5e
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x6e65
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x6e77
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x6e84
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x6e8e
jmp 0x6eb7
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x20(%rax)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x22(%rax)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4e10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/csi.h
// Function: clear_tabstop
void clear_tabstop(struct terminal_t *term, struct parm_t *parm)
{
	int i, j, num;

	if (parm->argc <= 0) {
		term->tabstop[term->cursor.x] = false;
	} else {
		for (i = 0; i < parm->argc; i++) {
			num = dec2num(parm->argv[i]);
			if (num == 0) {
				term->tabstop[term->cursor.x] = false;
			} else if (num == 3) {
				for (j = 0; j < term->cols; j++)
					term->tabstop[j] = false;
				return;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x6ef2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
movb $0x0, (%rax,%rcx)
jmp 0x6f7f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6f7d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x31b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6f35
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
movb $0x0, (%rax,%rcx)
jmp 0x6f6d
cmpl $0x3, -0x1c(%rbp)
jne 0x6f6b
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x6f69
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6f42
jmp 0x6f7f
jmp 0x6f6d
jmp 0x6f6f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ef9
jmp 0x6f7f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/osc.h
// Function: reset_palette
void reset_palette(struct terminal_t *term, void *arg)
{
	/*
	reset color c
		OSC 104 ; c ST
			c: index of color
			ST: BEL or ESC \
	reset all color
		OSC 104 ST
			ST: BEL or ESC \

	terminfo: oc=\E]104\E\\
	*/
	struct parm_t *pt = (struct parm_t *) arg;
	int i, argc = pt->argc, c;
	char **argv = pt->argv;

	if (argc < 2) { /* reset all color palette */
		for (i = 0; i < COLORS; i++)
			term->virtual_palette[i] = color_list[i];
		term->palette_modified = true;
	} else if (argc == 2) { /* reset color_palette[c] */
		c = dec2num(argv[1]);
		if (0 <= c && c < COLORS) {
			term->virtual_palette[c] = color_list[c];
			term->palette_modified = true;
		}
	}
}

// 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)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x7618
movl $0x0, -0x1c(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jge 0x760b
movslq -0x1c(%rbp), %rcx
leaq 0x3a22(%rip), %rax      # 0xb010
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, 0x80(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x75da
movq -0x8(%rbp), %rax
movb $0x1, 0x480(%rax)
jmp 0x766a
cmpl $0x2, -0x20(%rbp)
jne 0x7668
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jg 0x7666
cmpl $0x100, -0x24(%rbp)     # imm = 0x100
jge 0x7666
movslq -0x24(%rbp), %rcx
leaq 0x39c7(%rip), %rax      # 0xb010
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, 0x80(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movb $0x1, 0x480(%rax)
jmp 0x7668
jmp 0x766a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_repeat
static inline int sixel_repeat(struct terminal_t *term, struct sixel_canvas_t *sc, char *buf)
{
	int i, count;
	size_t length;
	char *cp, tmp[BUFSIZE];
	uint8_t bitmap;

	cp = buf + 1; /* skip '!' itself */
	while (isdigit(*cp)) /* skip non sixel bitmap character */
		cp++;

	length = (cp - buf);
	strncpy(tmp, buf + 1, length - 1);
	*(tmp + length - 1) = '\0';

	count = dec2num(tmp);

	logging(DEBUG, "sixel_repeat()\nbuf:%s length:%u\ncount:%d repeat:0x%.2X\n",
		tmp, (unsigned) length, count, *cp);

	if ('?' <= *cp && *cp <= '~') {
		bitmap = bit_mask[BITS_PER_SIXEL] & (*cp - '?');
		for (i = 0; i < count; i++)
			sixel_bitmap(term, sc, bitmap);
	}

	return length + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x2330
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x7cd1
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7ca3
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq -0x430(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
callq 0x2070
movq -0x28(%rbp), %rax
movb $0x0, -0x431(%rbp,%rax)
leaq -0x430(%rbp), %rdi
callq 0x31b0
movl %eax, -0x20(%rbp)
leaq -0x430(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl -0x20(%rbp), %r8d
movq -0x30(%rbp), %rax
movsbl (%rax), %r9d
xorl %edi, %edi
leaq 0x4e35d(%rip), %rsi     # 0x56096
movb $0x0, %al
callq 0x2450
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3f, %eax
cmpl %ecx, %eax
jg 0x7da4
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x7da4
movl 0x36d6(%rip), %eax      # 0xb438
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x3f, %ecx
andl %ecx, %eax
movb %al, -0x431(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7da2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzbl -0x431(%rbp), %edx
callq 0x82f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d7b
jmp 0x7da4
movq -0x28(%rbp), %rax
addq $0x1, %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_attr
static inline int sixel_attr(struct sixel_canvas_t *sc, char *buf)
{
	char *cp, tmp[BUFSIZE];
	size_t length;
	struct parm_t parm;

	cp = buf + 1;
	while (isdigit(*cp) || *cp == ';') /* skip valid params */
		cp++;

	length = (cp - buf);
	strncpy(tmp, buf + 1, length - 1);
	*(tmp + length - 1) = '\0';

	reset_parm(&parm);
	parse_arg(tmp, &parm, ';', isdigit);

	if (parm.argc >= 4) {
		sc->width  = dec2num(parm.argv[2]);
		sc->height = dec2num(parm.argv[3]);
	}

	logging(DEBUG, "sixel_attr()\nbuf:%s\nwidth:%d height:%d\n",
		tmp, sc->width, sc->height);

	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x2330
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x4b1(%rbp)
jne 0x7e1b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
sete %al
movb %al, -0x4b1(%rbp)
movb -0x4b1(%rbp), %al
testb $0x1, %al
jne 0x7e27
jmp 0x7e35
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7ddf
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x428(%rbp), %rdx
subq $0x1, %rdx
callq 0x2070
movq -0x428(%rbp), %rax
movb $0x0, -0x421(%rbp,%rax)
leaq -0x4b0(%rbp), %rdi
callq 0x2fa0
leaq -0x420(%rbp), %rdi
leaq -0x4b0(%rbp), %rsi
movl $0x3b, %edx
movq 0x5111d(%rip), %rcx     # 0x58fb8
callq 0x3060
cmpl $0x4, -0x4b0(%rbp)
jl 0x7ed3
movq -0x498(%rbp), %rdi
callq 0x31b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x490(%rbp), %rdi
callq 0x31b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq -0x420(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
xorl %edi, %edi
leaq 0x4e1dc(%rip), %rsi     # 0x560ce
movb $0x0, %al
callq 0x2450
movq -0x428(%rbp), %rax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_nl
static inline int sixel_nl(struct sixel_canvas_t *sc)
{
	logging(DEBUG, "sixel_nl()\n");

	/* DECGNL moves active position to left margin
		and down one line of sixels:
		http://odl.sysworks.biz/disk$vaxdocdec963/decw$book/d3qsaaa1.p67.decw$book */
	sc->point.y += BITS_PER_SIXEL;
	sc->point.x = 0;

	if (sc->point.y > sc->height)
		sc->height = sc->point.y;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
leaq 0x4deae(%rip), %rsi     # 0x56153
movb $0x0, %al
callq 0x2450
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %ecx
addl $0x6, %ecx
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x82e5
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_bitmap
static inline int sixel_bitmap(struct terminal_t *term, struct sixel_canvas_t *sc, uint8_t bitmap)
{
	int i, offset;
	//uint8_t r, g, b;

	logging(DEBUG, "sixel_bitmap()\nbitmap:%.2X point(%d, %d)\n",
		bitmap, sc->point.x, sc->point.y);

	if (sc->point.x >= term->width || sc->point.y >= term->height)
		return 1;

	offset = sc->point.x * BYTES_PER_PIXEL + sc->point.y * sc->line_length;

	for (i = 0; i < BITS_PER_SIXEL; i++) {
		if (offset >= BYTES_PER_PIXEL * term->width * term->height)
			break;

		if (bitmap & (0x01 << i)) {
			memcpy(sc->pixmap + offset, &sc->color_table[sc->color_index], BYTES_PER_PIXEL);
			/*
			split_rgb(sc->color_table[sc->color_index], &r, &g, &b);
			*(sc->pixmap + offset + 0) = b;
			*(sc->pixmap + offset + 1) = g;
			*(sc->pixmap + offset + 2) = r;
			*/
		}

		offset += sc->line_length;
	}
	sc->point.x++;

	if (sc->point.x > sc->width)
		sc->width = sc->point.x;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edx
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %r8d
xorl %edi, %edi
leaq 0x4de3c(%rip), %rsi     # 0x5615f
movb $0x0, %al
callq 0x2450
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x834c
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x8358
movl $0x1, -0x4(%rbp)
jmp 0x8424
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
shll $0x2, %eax
movq -0x18(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
movq -0x18(%rbp), %rdx
imull 0x14(%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x6, -0x20(%rbp)
jge 0x83ed
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x2, %ecx
movq -0x10(%rbp), %rdx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jl 0x83a0
jmp 0x83ed
movzbl -0x19(%rbp), %eax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x83d5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rsi
movzbl 0x18(%rsi), %esi
movl 0x1c(%rdx,%rsi,4), %edx
movl %edx, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x837f
movq -0x18(%rbp), %rax
movw 0x8(%rax), %cx
addw $0x1, %cx
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x841d
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_parse_header
void sixel_parse_header(struct terminal_t *term, char *start_buf)
{
	/*
	sixel format
		DSC P1; P2; P3; q; s...s; ST
	parameters
		DCS: ESC(0x1B) P (0x50) (8bit C1 character not recognized)
		P1 : pixel aspect ratio (force 0, 2:1) (ignored)
		P2 : background mode (ignored)
			0 or 2: 0 stdands for current background color (default)
			1     : 0 stands for remaining current color
		P3 : horizontal grid parameter (ignored)
		q  : final character of sixel sequence
		s  : see parse_sixel_data()
		ST : ESC (0x1B) '\' (0x5C) or BEL (0x07)
	*/
	char *cp;
	struct parm_t parm;

	/* replace final char of sixel header by NUL '\0' */
	cp = strchr(start_buf, 'q');
	*cp = '\0';

	logging(DEBUG, "sixel_parse_header()\nbuf:%s\n", start_buf);

	/* split header by semicolon ';' */
	reset_parm(&parm);
	parse_arg(start_buf, &parm, ';', isdigit);

	/* set canvas parameters */
	reset_sixel(&term->sixel, term->color_pair, term->width, term->height);
	sixel_parse_data(term, &term->sixel, cp + 1); /* skip 'q' */
	sixel_copy2cell(term, &term->sixel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x71, %esi
callq 0x2100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq 0x4d67a(%rip), %rsi     # 0x55e43
movb $0x0, %al
callq 0x2450
leaq -0xa0(%rbp), %rdi
callq 0x2fa0
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x3b, %edx
movq 0x507c5(%rip), %rcx     # 0x58fb8
callq 0x3060
movq -0x8(%rbp), %rdi
addq $0xbb588, %rdi          # imm = 0xBB588
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %edx
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movzwl 0x4c(%rax), %esi
callq 0x8430
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xbb588, %rsi          # imm = 0xBB588
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x7af0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xbb588, %rsi          # imm = 0xBB588
callq 0x85b0
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: decdld_parse_data
void decdld_parse_data(char *start_buf, int start_char, struct glyph_t *chars)
{
	/*
	DECDLD sixel data
		';': glyph separator
		'/': line feed
		sixel bitmap:
			range of ? (hex 3F) to ~ (hex 7E)
			? (hex 3F) represents the binary value 00 0000.
			t (hex 74) represents the binary value 11 0101.
			~ (hex 7E) represents the binary value 11 1111.
	*/
	char *cp, *end_buf;
	uint8_t char_num = start_char; /* start_char == 0 means SPACE(0x20) */
	uint8_t bitmap, row = 0, column = 0;

	init_glyph(&chars[char_num]);
	cp      = start_buf;
	end_buf = cp + strlen(cp);

	while (cp < end_buf) {
		if ('?' <= *cp && *cp <= '~') { /* sixel bitmap */
			logging(DEBUG, "char_num(ten):0x%.2X\n", char_num);
			/* remove offset '?' and use only 6bit */
			bitmap = bit_mask[BITS_PER_SIXEL] & (*cp - '?');
			decdld_bitmap(&chars[char_num], bitmap, row, column);
			column++;
		} else if (*cp == ';') {  /* next char */
			row = column = 0;
			char_num++;
			init_glyph(&chars[char_num]);
		} else if (*cp == '/') {  /* sixel nl+cr */
			row++;
			column = 0;
		} else if (*cp == '\0') { /* end of DECDLD sequence */
			break;
		}
		cp++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x29(%rbp)
movb $0x0, -0x2b(%rbp)
movb $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movzbl -0x29(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x89c0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x89ae
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3f, %eax
cmpl %ecx, %eax
jg 0x893d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x893d
movzbl -0x29(%rbp), %edx
xorl %edi, %edi
leaq 0x4d56d(%rip), %rsi     # 0x55e60
movb $0x0, %al
callq 0x2450
movl 0x2b38(%rip), %eax      # 0xb438
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x3f, %ecx
andl %ecx, %eax
movb %al, -0x2a(%rbp)
movq -0x18(%rbp), %rdi
movzbl -0x29(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movb -0x2a(%rbp), %cl
movb -0x2b(%rbp), %al
movzbl %cl, %esi
movzbl %al, %edx
movzbl -0x2c(%rbp), %ecx
callq 0x8a10
movb -0x2c(%rbp), %al
addb $0x1, %al
movb %al, -0x2c(%rbp)
jmp 0x899d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x896f
movb $0x0, -0x2c(%rbp)
movb $0x0, -0x2b(%rbp)
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
movzbl -0x29(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x89c0
jmp 0x899b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x8989
movb -0x2b(%rbp), %al
addb $0x1, %al
movb %al, -0x2b(%rbp)
movb $0x0, -0x2c(%rbp)
jmp 0x8999
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8997
jmp 0x89ae
jmp 0x8999
jmp 0x899b
jmp 0x899d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x88bc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: init_glyph
static inline void init_glyph(struct glyph_t *glyph)
{
	int i;

	glyph->width = 1; /* drcs glyph must be HALF */
	glyph->code = 0;  /* this value not used: drcs call by DRCSMMv1 */

	for (i = 0; i < CELL_HEIGHT; i++)
		glyph->bitmap[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x8a01
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0x6(%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x89e1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: decdld_bitmap
static inline void decdld_bitmap(struct glyph_t *glyph, uint8_t bitmap, uint8_t row, uint8_t column)
{
	/*
			  MSB        LSB (glyph_t bitmap order, padding at LSB side)
				  -> column
	sixel bit0 ->........
	sixel bit1 ->........
	sixel bit2 ->....@@..
	sixel bit3 ->...@..@.
	sixel bit4 ->...@....
	sixel bit5 ->...@....
				 .@@@@@..
				 ...@....
				|...@....
			row |...@....
				v...@....
				 ...@....
				 ...@....
				 ...@....
				 ........
				 ........
	*/
	int i, height_shift, width_shift;

	logging(DEBUG, "bit pattern:0x%.2X\n", bitmap);

	width_shift = CELL_WIDTH - 1 - column;
	if (width_shift < 0)
		return;

	for (i = 0; i < BITS_PER_SIXEL; i++) {
		if((bitmap >> i) & 0x01) {
			height_shift = row * BITS_PER_SIXEL + i;

			if (height_shift < CELL_HEIGHT) {
				logging(DEBUG, "height_shift:%d width_shift:%d\n", height_shift, width_shift);
				glyph->bitmap[height_shift] |= bit_mask[CELL_WIDTH] & (0x01 << width_shift);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movzbl -0x9(%rbp), %edx
xorl %edi, %edi
leaq 0x4d750(%rip), %rsi     # 0x56189
movb $0x0, %al
callq 0x2450
movzbl -0xb(%rbp), %ecx
movl $0x7, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x8a56
jmp 0x8ad2
movl $0x0, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jge 0x8ad2
movzbl -0x9(%rbp), %eax
movl -0x10(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8ac5
movzbl -0xa(%rbp), %eax
imull $0x6, %eax, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x8ac3
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
xorl %edi, %edi
leaq 0x4d707(%rip), %rsi     # 0x5619d
movb $0x0, %al
callq 0x2450
movl 0x299d(%rip), %esi      # 0xb440
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl 0x6(%rax,%rcx,2), %edx
orl %esi, %edx
movw %dx, 0x6(%rax,%rcx,2)
jmp 0x8ac5
jmp 0x8ac7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8a5d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: control_character
void control_character(struct terminal_t *term, uint8_t ch)
{
	static const char *ctrl_char[] = {
		"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
		"BS ", "HT ", "LF ", "VT ", "FF ", "CR ", "SO ", "SI ",
		"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
		"CAN", "EM ", "SUB", "ESC", "FS ", "GS ", "RS ", "US ",
	};

	*term->esc.bp = '\0';

	logging(DEBUG, "ctl: %s\n", ctrl_char[ch]);

	if (ctrl_func[ch])
		ctrl_func[ch](term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movb $0x0, (%rax)
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x50e36(%rip), %rax     # 0x59b00
movq (%rax,%rcx,8), %rdx
xorl %edi, %edi
leaq 0x4d26d(%rip), %rsi     # 0x55f44
movb $0x0, %al
callq 0x2450
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x50515(%rip), %rax     # 0x59200
cmpq $0x0, (%rax,%rcx,8)
je 0x8d09
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x50501(%rip), %rax     # 0x59200
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: esc_sequence
void esc_sequence(struct terminal_t *term, uint8_t ch)
{
	*term->esc.bp = '\0';

	logging(DEBUG, "esc: ESC %s\n", term->esc.buf);

	if (strlen(term->esc.buf) == 1 && esc_func[ch])
		esc_func[ch](term);

	/* not reset if csi/osc/dcs seqence */
	if (ch == '[' || ch == ']' || ch == 'P')
		return;

	reset_esc(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
xorl %edi, %edi
leaq 0x4d20f(%rip), %rsi     # 0x55f4d
movb $0x0, %al
callq 0x2450
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x20d0
cmpq $0x1, %rax
jne 0x8d83
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x5059b(%rip), %rax     # 0x59300
cmpq $0x0, (%rax,%rcx,8)
je 0x8d83
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x50587(%rip), %rax     # 0x59300
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movzbl -0x9(%rbp), %eax
cmpl $0x5b, %eax
je 0x8d9e
movzbl -0x9(%rbp), %eax
cmpl $0x5d, %eax
je 0x8d9e
movzbl -0x9(%rbp), %eax
cmpl $0x50, %eax
jne 0x8da0
jmp 0x8da9
movq -0x8(%rbp), %rdi
callq 0x5130
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: csi_sequence
void csi_sequence(struct terminal_t *term, uint8_t ch)
{
	struct parm_t parm;

	*(term->esc.bp - 1) = '\0'; /* omit final character */

	logging(DEBUG, "csi: CSI %s\n", term->esc.buf + 1);

	reset_parm(&parm);
	parse_arg(term->esc.buf + 1, &parm, ';', isdigit); /* skip '[' */

	if (csi_func[ch])
		csi_func[ch](term, &parm);

	reset_esc(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movb $0x0, -0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
addq $0x1, %rdx
xorl %edi, %edi
leaq 0x4d174(%rip), %rsi     # 0x55f5a
movb $0x0, %al
callq 0x2450
leaq -0x98(%rbp), %rdi
callq 0x2fa0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x1, %rdi
leaq -0x98(%rbp), %rsi
movl $0x3b, %edx
movq 0x501a0(%rip), %rcx     # 0x58fb8
callq 0x3060
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x508d6(%rip), %rax     # 0x59700
cmpq $0x0, (%rax,%rcx,8)
je 0x8e4f
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x508c2(%rip), %rax     # 0x59700
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x5130
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: is_osc_parm
int is_osc_parm(int c)
{
	if (isdigit(c) || isalpha(c) ||
		c == '?' || c == ':' || c == '/' || c == '#')
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x2330
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x8ec7
callq 0x2330
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x8ec7
cmpl $0x3f, -0x8(%rbp)
je 0x8ec7
cmpl $0x3a, -0x8(%rbp)
je 0x8ec7
cmpl $0x2f, -0x8(%rbp)
je 0x8ec7
cmpl $0x23, -0x8(%rbp)
jne 0x8ed0
movl $0x1, -0x4(%rbp)
jmp 0x8ed7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: osc_sequence
void osc_sequence(struct terminal_t *term, uint8_t ch)
{
	int osc_mode;
	struct parm_t parm;

	omit_string_terminator(term->esc.bp, ch);

	logging(DEBUG, "osc: OSC %s\n", term->esc.buf);

	reset_parm(&parm);
	parse_arg(term->esc.buf + 1, &parm, ';', is_osc_parm); /* skip ']' */

	if (parm.argc > 0) {
		osc_mode = dec2num(parm.argv[0]);
		logging(DEBUG, "osc_mode:%d\n", osc_mode);

		/* XXX: disable because this functions only work 24/32bpp
			-> support other bpp (including pseudo color) */
		if (osc_mode == 4)
			set_palette(term, &parm);
		else if (osc_mode == 104)
			reset_palette(term, &parm);
		if (osc_mode == 8900)
			glyph_width_report(term, &parm);
	}
	reset_esc(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movzbl -0x9(%rbp), %esi
callq 0x8ee0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
xorl %edi, %edi
leaq 0x4d020(%rip), %rsi     # 0x55f67
movb $0x0, %al
callq 0x2450
leaq -0x98(%rbp), %rdi
callq 0x2fa0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x1, %rdi
leaq -0x98(%rbp), %rsi
movl $0x3b, %edx
leaq -0x109(%rip), %rcx      # 0x8e70
callq 0x3060
cmpl $0x0, -0x98(%rbp)
jle 0x8ff4
movq -0x90(%rbp), %rdi
callq 0x31b0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
xorl %edi, %edi
leaq 0x4cfd2(%rip), %rsi     # 0x55f74
movb $0x0, %al
callq 0x2450
cmpl $0x4, -0x10(%rbp)
jne 0x8fc1
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x73a0
jmp 0x8fd9
cmpl $0x68, -0x10(%rbp)
jne 0x8fd7
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x75a0
jmp 0x8fd9
cmpl $0x22c4, -0x10(%rbp)    # imm = 0x22C4
jne 0x8ff2
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x76c0
jmp 0x8ff4
movq -0x8(%rbp), %rdi
callq 0x5130
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: dcs_sequence
void dcs_sequence(struct terminal_t *term, uint8_t ch)
{
	char *cp;

	omit_string_terminator(term->esc.bp, ch);

	logging(DEBUG, "dcs: DCS %s\n", term->esc.buf);

	/* check DCS header */
	cp = term->esc.buf + 1; /* skip P */
	while (cp < term->esc.bp) {
		if (*cp == '{' || *cp == 'q')                      /* DECDLD or sixel */
			break;
		else if (*cp == ';' || ('0' <= *cp && *cp <= '9')) /* valid DCS header */
			;
		else                                               /* invalid sequence */
			cp = term->esc.bp;
		cp++;
	}

	if (cp != term->esc.bp) { /* header only or couldn't find final char */
		/* parse DCS header */
		if (*cp == 'q')
			sixel_parse_header(term, term->esc.buf + 1);
		else if (*cp == '{')
			decdld_parse_header(term, term->esc.buf + 1);
	}

	reset_esc(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movzbl -0x9(%rbp), %esi
callq 0x8ee0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
xorl %edi, %edi
leaq 0x4cf3d(%rip), %rsi     # 0x55f81
movb $0x0, %al
callq 0x2450
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x90c9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
je 0x9081
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x71, %eax
jne 0x9083
jmp 0x90c9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x90ab
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x90ad
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x90ad
jmp 0x90b9
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x90bb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x905b
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
je 0x911f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x71, %eax
jne 0x90fa
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
addq $0x1, %rsi
callq 0x8790
jmp 0x911d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x911b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
addq $0x1, %rsi
callq 0x8ae0
jmp 0x911d
jmp 0x911f
movq -0x8(%rbp), %rdi
callq 0x5130
addq $0x20, %rsp
popq %rbp
retq
nop