LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: fixup_doublesize_rows
static void fixup_doublesize_rows(deark *c, lctx *d)
{
	i64 i, j;
	struct de_char_cell *r;
	u8 size_mode;

	for(j=0; j<d->screen->height && j<MAX_ROWS; j++) {
		size_mode = d->row_data[j].size_mode;
		if(size_mode==0) continue;

		r = d->screen->cell_rows[j];
		if(!r) return;

		for(i=d->screen->width-1; i>=0; i--) {
			if(i>0) r[i] = r[i/2]; // struct copy
			r[i].size_flags = 0;
			if(size_mode==SIZEMODE_DBLH_TOP) {
				r[i].size_flags |= DE_PAINTFLAG_TOPHALF;
			}
			else if(size_mode==SIZEMODE_DBLH_BOTTOM){
				r[i].size_flags |= DE_PAINTFLAG_BOTTOMHALF;
			}
			if(i%2)
				r[i].size_flags |= DE_PAINTFLAG_RIGHTHALF;
			else
				r[i].size_flags |= DE_PAINTFLAG_LEFTHALF;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x2a(%rbp)
jge 0x203c9
cmpq $0x1388, -0x20(%rbp)    # imm = 0x1388
setl %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x203d5
jmp 0x2053c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jne 0x203f5
jmp 0x2052b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x20419
jmp 0x2053c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x20529
cmpq $0x0, -0x18(%rbp)
jle 0x20482
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x2, %esi
cqto
idivq %rsi
movq %rax, %rdx
movq -0x38(%rbp), %rax
imulq $0x14, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movb $0x0, 0x13(%rax)
movzbl -0x29(%rbp), %eax
cmpl $0x1, %eax
jne 0x204b3
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x13(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x13(%rax)
jmp 0x204d4
movzbl -0x29(%rbp), %eax
cmpl $0x2, %eax
jne 0x204d2
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x13(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x13(%rax)
jmp 0x204d4
movq -0x18(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x20500
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x13(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x13(%rax)
jmp 0x20516
movq -0x28(%rbp), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x13(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x13(%rax)
jmp 0x20518
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2042c
jmp 0x2052b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x203a4
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_escape_code
static void do_escape_code(deark *c, lctx *d, u8 code, i64 pos,
	i64 *extra_bytes_to_skip)
{
	if(code>=96) return;

	if(code=='P') { // DCS
		i64 pos2;
		u8 b0, b1;

		// A DCS sequence ends with 1b 5c, or maybe 9c.

		// pos is currently the position of the 'P'.
		pos2 = pos+1;
		while(pos2 < d->effective_file_size) {
			b0 = de_getbyte(pos2);
			b1 = de_getbyte(pos2+1);
			if(b0==0x9c) {
				*extra_bytes_to_skip = pos2 - pos;
				return;
			}
			if(b0==0x1b && b1==0x5c) {
				*extra_bytes_to_skip = pos2+1 - pos;
				return;
			}
			pos2++;
		}
		// End of DCS sequence not found.
		return;
	}

	if(code=='\\') return; // Disable Manual Input (we ignore this)
	if(code=='b') return; // Enable Manual Input (we ignore this)

	if(d->control_seq_seen[(UI)code]==0) {
		de_warn(c, "Unsupported escape code '%c' at %"I64_FMT,
			(char)code, pos);
		d->control_seq_seen[(UI)code] = 1;
	}
	d->control_seq_seen[(UI)code] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x60, %eax
jl 0x2082b
jmp 0x20946
movzbl -0x11(%rbp), %eax
cmpl $0x50, %eax
jne 0x208db
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jge 0x208d9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
callq 0x165060
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x9c, %eax
jne 0x208a1
movq -0x30(%rbp), %rcx
subq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x20946
movzbl -0x31(%rbp), %eax
cmpl $0x1b, %eax
jne 0x208c8
movzbl -0x32(%rbp), %eax
cmpl $0x5c, %eax
jne 0x208c8
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
subq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x20946
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x20844
jmp 0x20946
movzbl -0x11(%rbp), %eax
cmpl $0x5c, %eax
jne 0x208e6
jmp 0x20946
movzbl -0x11(%rbp), %eax
cmpl $0x62, %eax
jne 0x208f1
jmp 0x20946
movq -0x10(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movl %ecx, %ecx
movzbl 0x208(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x20934
movq -0x8(%rbp), %rdi
movsbl -0x11(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq 0x17d3bf(%rip), %rsi    # 0x19dcda
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movl %ecx, %ecx
movb $0x1, 0x208(%rax,%rcx)
movq -0x10(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movl %ecx, %ecx
movb $0x1, 0x208(%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_ctrl_char
static void do_ctrl_char(deark *c, lctx *d, u8 ch)
{
	if(ch==13) { // CR
		d->xpos = 0;
		return;
	}
	if(ch==10) { // LF
		d->ypos++;
		// Some files aren't rendered correctly unless an LF implies a CR.
		d->xpos = 0;
		return;
	}

	// ^N = shift out - selects G1 character set
	// ^O = shift in  - selects G0 character set
	if(ch==0x0e) d->curr_charset_index = 1;
	else if(ch==0x0f) d->curr_charset_index = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xd, %eax
jne 0x20f08
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x20f5b
movzbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x20f2f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x20f5b
movzbl -0x11(%rbp), %eax
cmpl $0xe, %eax
jne 0x20f45
movq -0x10(%rbp), %rax
movl $0x1, 0x60(%rax)
jmp 0x20f5b
movzbl -0x11(%rbp), %eax
cmpl $0xf, %eax
jne 0x20f59
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
jmp 0x20f5b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: ansi_char_to_unicode
static i32 ansi_char_to_unicode(deark *c, lctx *d, u8 ch)
{
	i32 u;
	int cs;

	if(d->curr_charset_index==0)
		cs = d->curr_g0_charset;
	else
		cs = d->curr_g1_charset;

	if(cs==CHARSET_LINEDRAWING) {
		if(ch>=95 && ch<=126) {
			u = de_char_to_unicode_ex((i32)ch, &d->es_dec_special_gr);
			return u;
		}
	}
	else if(cs==CHARSET_UK) {
		// I think this is the only difference between the US and UK charsets.
		if(ch=='#') return 0x00a3;
	}

	u = de_char_to_unicode_ex((i32)ch, &d->es_main);
	return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x20f8b
movq -0x18(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x20f95
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jne 0x20fce
movzbl -0x19(%rbp), %eax
cmpl $0x5f, %eax
jl 0x20fcc
movzbl -0x19(%rbp), %eax
cmpl $0x7e, %eax
jg 0x20fcc
movzbl -0x19(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x98, %rsi
callq 0x160a30
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21004
jmp 0x20fea
cmpl $0x2, -0x24(%rbp)
jne 0x20fe8
movzbl -0x19(%rbp), %eax
cmpl $0x23, %eax
jne 0x20fe6
movl $0xa3, -0x4(%rbp)
jmp 0x21004
jmp 0x20fe8
jmp 0x20fea
movzbl -0x19(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0x160a30
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: get_cell_at
static struct de_char_cell *get_cell_at(deark *c, struct de_char_screen *screen,
	i64 xpos, i64 ypos)
{
	i64 i;
	struct de_char_cell *cell;

	if(xpos<0 || ypos<0) return NULL;
	if(xpos>=screen->width || ypos>=MAX_ROWS) return NULL;
	if(!screen->cell_rows[ypos]) {
		screen->cell_rows[ypos] = de_mallocarray(c, screen->width, sizeof(struct de_char_cell));
		for(i=0; i<screen->width; i++) {
			// Initialize each new cell
			cell = &screen->cell_rows[ypos][i];
			init_cell(c, cell);
		}
	}
	return &(screen->cell_rows[ypos][xpos]);
}

// 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)
cmpq $0x0, -0x20(%rbp)
jl 0x21036
cmpq $0x0, -0x28(%rbp)
jge 0x21043
movq $0x0, -0x8(%rbp)
jmp 0x2110c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x2105a
cmpq $0x1388, -0x28(%rbp)    # imm = 0x1388
jl 0x21067
movq $0x0, -0x8(%rbp)
jmp 0x2110c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x210f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x14, %edx
callq 0x15c450
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x210ee
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
imulq $0x14, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x21120
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x210aa
jmp 0x210f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
imulq $0x14, -0x20(%rbp), %rcx
addq %rcx, %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/jsummers[P]deark/modules/ansiart.c
// Function: init_cell
static void init_cell(deark *c, struct de_char_cell *cell)
{
	cell->codepoint = 0x20;
	cell->codepoint_unicode = 0x20;
	cell->bgcol = DEFAULT_BGCOL;
	cell->fgcol = DEFAULT_FGCOL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x20, (%rax)
movq -0x10(%rbp), %rax
movl $0x20, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x7, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_H
static void do_code_H(deark *c, lctx *d)
{
	i64 row, col;

	parse_params(c, d, 1, 0);

	if(d->parse_results.num_params>=1) row = d->parse_results.params[0];
	else row = 1;

	if(d->parse_results.num_params>=2) col = d->parse_results.params[1];
	else col = 1;

	d->xpos = col-1;
	d->ypos = row-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x21db0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x120(%rax)
jl 0x21304
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2130c
movq $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x120(%rax)
jl 0x2132a
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x21332
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_h
static void do_code_h(deark *c, lctx *d, i64 param_start)
{
	int ok=0;
	int is_DEC = 0;
	int i;

	if(d->param_string_buf[0]=='?') {
		is_DEC = 1; // "DEC private parameters"
	}

	parse_params(c, d, 0, is_DEC?1:0);

	for(i=0; i<d->parse_results.num_params; i++) {
		ok = 0;

		if(is_DEC) {
			switch(d->parse_results.params[i]) {
			case 4: // Smooth scrolling
				ok = 1;
				break;
			case 7: // Set autowrap (default)
				ok = 1;
				break;
			case 25: // Display the cursor (VT320)
				ok = 1;
				break;
			case 33:
				d->disable_blink_attr = 1;
				ok = 1;
				break;
			}
		}
		else {
			switch(d->parse_results.params[i]) {
			case 7: // Set autowrap (default)
				// Some sources say it's Esc [?7h, and some say it's
				// Esc [7h. I'll assume both are okay.
				ok = 1;
				break;
			}
		}

		if(!ok && d->num_warnings<ANSIART_MAX_WARNINGS) {
			de_warn(c, "Unsupported 'h' control sequence '%s%d' at %"I64_FMT,
				is_DEC?"?":"", (int)d->parse_results.params[i], param_start);
			d->num_warnings++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xb8(%rax), %eax
cmpl $0x3f, %eax
jne 0x21399
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x21db0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0x214d4
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x21442
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
addq $-0x4, %rax
movq %rax, -0x30(%rbp)
subq $0x1d, %rax
ja 0x21440
movq -0x30(%rbp), %rax
leaq 0x17c6e7(%rip), %rcx    # 0x19daf4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x1c(%rbp)
jmp 0x21440
movl $0x1, -0x1c(%rbp)
jmp 0x21440
movl $0x1, -0x1c(%rbp)
jmp 0x21440
movq -0x10(%rbp), %rax
movb $0x1, 0x70(%rax)
movl $0x1, -0x1c(%rbp)
jmp 0x21463
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
subq $0x7, %rax
jne 0x21461
jmp 0x2145a
movl $0x1, -0x1c(%rbp)
jmp 0x21463
cmpl $0x0, -0x1c(%rbp)
jne 0x214c4
movq -0x10(%rbp), %rax
cmpq $0xa, 0x68(%rax)
jge 0x214c4
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %ecx
leaq 0x1af74e(%rip), %rdx    # 0x1d0bd0
leaq 0x1967a4(%rip), %rax    # 0x1b7c2d
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x18(%rbp), %r8
leaq 0x17c93c(%rip), %rsi    # 0x19dde9
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
jmp 0x214c6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x213c4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_J
static void do_code_J(deark *c, lctx *d)
{
	i64 n;
	i64 i, j;

	read_one_int(c, d, d->param_string_buf, &n, 0);
	// 0 = clear from cursor to end of screen
	// 1 = clear from cursor to beginning of screen
	// 2 = clear screen

	for(j=0; j<d->screen->height; j++) {
		for(i=0; i<d->screen->width; i++) {
			if(n==0) {
				if(j<d->ypos) continue;
				if(j==d->ypos && i<d->xpos) continue;
			}
			else if(n==1) {
				if(j>d->ypos) continue;
				if(j==d->ypos && i>d->xpos) continue;
			}
			erase_cell(c, get_cell_at(c, d->screen, i, j));
		}
	}

	if(n==2) {
		d->xpos = 0;
		d->ypos = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0xb8, %rdx
leaq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x21d40
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jge 0x21610
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jge 0x215fd
cmpq $0x0, -0x18(%rbp)
jne 0x21586
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x21566
jmp 0x215ec
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x21584
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jge 0x21584
jmp 0x215ec
jmp 0x215bf
cmpq $0x1, -0x18(%rbp)
jne 0x215bd
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jle 0x2159d
jmp 0x215ec
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x215bb
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x215bb
jmp 0x215ec
jmp 0x215bd
jmp 0x215bf
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x21010
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x21ef0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21537
jmp 0x215ff
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21519
cmpq $0x2, -0x18(%rbp)
jne 0x2162f
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_K
static void do_code_K(deark *c, lctx *d)
{
	i64 n;
	i64 i;

	read_one_int(c, d, d->param_string_buf, &n, 0);
	// 0 = clear cursor to end of line
	// 1 = clear from start of line to cursor
	// 2 = clear entire line

	// TODO: This line clearing logic may not be exactly correct.

	for(i=0; i<d->screen->width; i++) {
		if(n==0) {
			if(i<d->xpos) continue;
		}
		else if(n==1) {
			if(i>d->xpos) continue;
		}
		erase_cell(c, get_cell_at(c, d->screen, i, d->ypos));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0xb8, %rdx
leaq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x21d40
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jge 0x21700
cmpq $0x0, -0x18(%rbp)
jne 0x216a3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jge 0x216a1
jmp 0x216ef
jmp 0x216be
cmpq $0x1, -0x18(%rbp)
jne 0x216bc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x216ba
jmp 0x216ef
jmp 0x216bc
jmp 0x216be
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
callq 0x21010
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x21ef0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21679
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_l
static void do_code_l(deark *c, lctx *d, i64 param_start)
{
	int ok=0;
	int is_DEC = 0;
	int i;

	if(d->param_string_buf[0]=='?') {
		is_DEC = 1; // "DEC private parameters"
	}

	parse_params(c, d, 0, is_DEC?1:0);

	for(i=0; i<d->parse_results.num_params; i++) {
		ok = 0;

		if(is_DEC) {
			switch(d->parse_results.params[i]) {
			case 4: // Disable smooth scrolling
				ok = 1;
				break;
			case 5: // Disable reverse-video screen
				ok = 1;
				break;
			case 25: // Hide the cursor (VT320)
				ok = 1;
				break;
			case 33:
				d->disable_blink_attr = 0;
				ok = 1;
				break;
			}
		}
		else {
			switch(d->parse_results.params[i]) {
			case 4: // Disable INSERT mode
				ok = 1;
				break;
			case 5: // Disable STATUS REPORT TRANSFER MODE
				ok = 1;
				break;
			}
		}

		if(!ok && d->num_warnings<ANSIART_MAX_WARNINGS) {
			de_warn(c, "Unsupported 'l' control sequence '%s%d' at %"I64_FMT,
				is_DEC?"?":"", (int)d->parse_results.params[i], param_start);
			d->num_warnings++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xb8(%rax), %eax
cmpl $0x3f, %eax
jne 0x21749
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x21db0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0x2189d
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x217f2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
addq $-0x4, %rax
movq %rax, -0x30(%rbp)
subq $0x1d, %rax
ja 0x217f0
movq -0x30(%rbp), %rax
leaq 0x17c3af(%rip), %rcx    # 0x19db6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x1c(%rbp)
jmp 0x217f0
movl $0x1, -0x1c(%rbp)
jmp 0x217f0
movl $0x1, -0x1c(%rbp)
jmp 0x217f0
movq -0x10(%rbp), %rax
movb $0x0, 0x70(%rax)
movl $0x1, -0x1c(%rbp)
jmp 0x2182c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
je 0x2181a
jmp 0x2180e
movq -0x38(%rbp), %rax
subq $0x5, %rax
je 0x21823
jmp 0x2182a
movl $0x1, -0x1c(%rbp)
jmp 0x2182a
movl $0x1, -0x1c(%rbp)
jmp 0x2182c
cmpl $0x0, -0x1c(%rbp)
jne 0x2188d
movq -0x10(%rbp), %rax
cmpq $0xa, 0x68(%rax)
jge 0x2188d
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %ecx
leaq 0x1af385(%rip), %rdx    # 0x1d0bd0
leaq 0x1963db(%rip), %rax    # 0x1b7c2d
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x128(%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x18(%rbp), %r8
leaq 0x17c5a2(%rip), %rsi    # 0x19de18
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
jmp 0x2188f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21774
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_code_t
static void do_code_t(deark *c, lctx *d, i64 param_start)
{
	parse_params(c, d, 0, 0);

	if(d->parse_results.num_params==4 &&
		d->parse_results.params[0]>=0 && d->parse_results.params[0]<=1 &&
		d->parse_results.params[1]>=0 && d->parse_results.params[1]<=255 &&
		d->parse_results.params[2]>=0 && d->parse_results.params[2]<=255 &&
		d->parse_results.params[3]>=0 && d->parse_results.params[3]<=255)
	{
		// 24-bit color definition.
		// Reference: http://picoe.ca/2014/03/07/24-bit-ansi/
		u32 clr;
		if(d->opt_disable_24bitcolor) return;
		clr = (u32)DE_MAKE_RGB(d->parse_results.params[1],
			d->parse_results.params[2], d->parse_results.params[3]);
		if(d->parse_results.params[0]==0)
			d->curr_bgcol = clr;
		else
			d->curr_fgcol = clr;
	}
	else {
		if(d->num_warnings<ANSIART_MAX_WARNINGS) {
			de_warn(c, "Unsupported 't' control sequence at %"I64_FMT, param_start);
			d->num_warnings++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x21db0
movq -0x10(%rbp), %rax
cmpl $0x4, 0x120(%rax)
jne 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x128(%rax)
jl 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0x1, 0x128(%rax)
jg 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jl 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0xff, 0x130(%rax)
jg 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x138(%rax)
jl 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0xff, 0x138(%rax)
jg 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x140(%rax)
jl 0x21cfe
movq -0x10(%rbp), %rax
cmpq $0xff, 0x140(%rax)
jg 0x21cfe
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x21c9c
jmp 0x21d31
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
shlq $0x10, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x138(%rcx), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
orq 0x140(%rcx), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x128(%rax)
jne 0x21cf2
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x21cfc
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x48(%rax)
jmp 0x21d31
movq -0x10(%rbp), %rax
cmpq $0xa, 0x68(%rax)
jge 0x21d2f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x17c193(%rip), %rsi    # 0x19deab
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
jmp 0x21d31
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: read_one_int
static void read_one_int(deark *c, lctx *d, const u8 *buf,
	i64 *a, i64 a_default)
{
	parse_params(c, d, a_default, 0);

	if(d->parse_results.num_params>=1) {
		*a = d->parse_results.params[0];
	}
	else {
		*a = a_default;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x21db0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x120(%rax)
jl 0x21d92
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x21d9d
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: parse_params
static void parse_params(deark *c, lctx *d, i64 default_val, i64 offset)
{
	i64 buf_len;
	i64 ppos;
	i64 param_len;
	char *p_ptr;
	int last_param = 0;

	d->parse_results.num_params = 0;

	buf_len = de_strlen((const char*)d->param_string_buf);

	ppos = offset;
	while(1) {
		if(d->parse_results.num_params >= MAX_ESC_PARAMS) {
			break;
		}

		p_ptr = de_strchr((const char*)&d->param_string_buf[ppos], ';');
		if(p_ptr) {
			param_len = p_ptr - (char*)&d->param_string_buf[ppos];
		}
		else {
			param_len = buf_len - ppos;
			last_param = 1;
		}

		if(param_len>=1) {
			d->parse_results.params[d->parse_results.num_params] = de_atoi64((const char*)&d->param_string_buf[ppos]);
		}
		else {
			d->parse_results.params[d->parse_results.num_params] = default_val;
		}
		d->parse_results.num_params++;

		if(last_param) {
			break;
		}

		// Advance past the parameter data and the terminating semicolon.
		ppos += param_len + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x120(%rax)
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x190e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0x120(%rax)
jl 0x21e0b
jmp 0x21ee0
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
addq -0x30(%rbp), %rdi
movl $0x3b, %esi
callq 0x15abe0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x21e4b
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0xb8, %rcx
addq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x21e5e
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x44(%rbp)
cmpq $0x1, -0x38(%rbp)
jl 0x21e95
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
addq -0x30(%rbp), %rdi
callq 0x15ccc0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x120(%rcx), %rcx
movq %rdx, 0x128(%rax,%rcx,8)
jmp 0x21eb0
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x120(%rcx), %rcx
movq %rdx, 0x128(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x120(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x120(%rax)
cmpl $0x0, -0x44(%rbp)
je 0x21ecb
jmp 0x21ee0
movq -0x38(%rbp), %rax
addq $0x1, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x21df9
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ansiart.c
// Function: do_ext_color
static void do_ext_color(deark *c, lctx *d)
{
	int is_bg;
	const char *name;
	u8 cr, cg, cb;
	u32 clr;

	if(d->parse_results.num_params<2) return;

	if(d->parse_results.params[0]==48) {
		is_bg = 1;
		name = "bg";
	}
	else {
		is_bg = 0;
		name = "fg";
	}

	if(d->parse_results.params[1]!=2) {
		de_warn(c, "Unsupported extended %s color format: %d",
			name, (int)d->parse_results.params[1]);
		return;
	}

	if(d->parse_results.num_params<5) {
		de_warn(c, "Invalid extended %s color code", name);
		return;
	}

	if(d->opt_disable_24bitcolor) return;

	cr = (u8)(d->parse_results.params[2]%256);
	cg = (u8)(d->parse_results.params[3]%256);
	cb = (u8)(d->parse_results.params[4]%256);
	clr = (u32)DE_MAKE_RGB(cr, cg, cb);
	if(is_bg) {
		d->curr_bgcol = clr;
	}
	else {
		d->curr_fgcol = clr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x120(%rax)
jge 0x21f52
jmp 0x2207a
movq -0x10(%rbp), %rax
cmpq $0x30, 0x128(%rax)
jne 0x21f74
movl $0x1, -0x14(%rbp)
leaq 0x190308(%rip), %rax    # 0x1b2276
movq %rax, -0x20(%rbp)
jmp 0x21f86
movl $0x0, -0x14(%rbp)
leaq 0x17bede(%rip), %rax    # 0x19de60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0x130(%rax)
je 0x21fbc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movl %eax, %ecx
leaq 0x17beb3(%rip), %rsi    # 0x19de63
movb $0x0, %al
callq 0x15bc10
jmp 0x2207a
movq -0x10(%rbp), %rax
cmpl $0x5, 0x120(%rax)
jge 0x21fe4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x17beb4(%rip), %rsi    # 0x19de8c
movb $0x0, %al
callq 0x15bc10
jmp 0x2207a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x21ff2
jmp 0x2207a
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movb %dl, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movb %dl, %al
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movb %dl, %al
movb %al, -0x23(%rbp)
movzbl -0x21(%rbp), %eax
shll $0x10, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
movzbl -0x22(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x23(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x22070
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x2207a
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ar.c
// Function: de_module_ar
void de_module_ar(deark *c, struct deark_module_info *mi)
{
	mi->id = "ar";
	mi->desc = "ar archive";
	mi->run_fn = de_run_ar;
	mi->identify_fn = de_identify_ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x18902f(%rip), %rcx    # 0x1ab0f6
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1a527b(%rip), %rcx    # 0x1c7350
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x22100
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0x221b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/ar.c
// Function: de_run_ar
static void de_run_ar(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	i64 item_len;
	int ret;

	d = de_malloc(c, sizeof(lctx));
	d->input_encoding = de_get_input_encoding(c, NULL, DE_ENCODING_UTF8);

	pos = 8;
	while(1) {
		if(pos >= c->infile->len) break;
		ret = do_ar_item(c, d, pos, &item_len);
		if(!ret || item_len<1) break;
		pos += item_len;
	}

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq $0x8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x22160
jmp 0x22195
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x22200
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x22185
cmpq $0x1, -0x28(%rbp)
jge 0x22187
jmp 0x22195
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2214c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: de_module_asf
void de_module_asf(deark *c, struct deark_module_info *mi)
{
	mi->id = "asf";
	mi->desc = "ASF, WMV, WMA";
	mi->run_fn = de_run_asf;
	mi->identify_fn = de_identify_asf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x17b8e1(%rip), %rcx    # 0x19e1a8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x17b8d7(%rip), %rcx    # 0x19e1ac
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0x22900
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x7d(%rip), %rcx        # 0x22970
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: de_run_asf
static void de_run_asf(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;

	d = de_malloc(c, sizeof(lctx));

	do_object_sequence(c, d, 0, c->infile->len, 0, 0, 0);

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
xorl %r9d, %r9d
movl %r9d, %r8d
movq $0x0, (%rsp)
callq 0x229c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: do_object_sequence
static int do_object_sequence(deark *c, lctx *d, i64 pos1, i64 len, int level,
	int known_object_count, i64 num_objects_expected)
{
	int retval = 0;
	i64 pos = pos1;
	int saved_indent_level;
	i64 bytes_remaining;
	i64 objects_found = 0;

	de_dbg_indent_save(c, &saved_indent_level);

	if(level >= 16) { // An arbitrary recursion limit
		goto done;
	}

	while(1) {
		int ret;
		i64 bytes_consumed = 0;

		bytes_remaining = pos1+len-pos;
		if(known_object_count && objects_found>=num_objects_expected) {
			break;
		}

		if(bytes_remaining<24) {
			break;
		}

		ret = do_object(c, d, pos, bytes_remaining, level, &bytes_consumed);
		if(!ret) goto done;
		if(bytes_consumed<24) goto done;

		objects_found++;
		pos += bytes_consumed;
	}

	bytes_remaining = pos1+len-pos;
	if(bytes_remaining>0) {
		de_dbg(c, "[%d extra bytes at %"I64_FMT"]", (int)bytes_remaining, pos);
	}

	if(known_object_count && objects_found<num_objects_expected) {
		de_warn(c, "Expected %d objects at %"I64_FMT", only found %d", (int)num_objects_expected,
			pos1, (int)objects_found);
	}

done:
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x15b580
cmpl $0x10, -0x24(%rbp)
jl 0x22a13
jmp 0x22b04
jmp 0x22a15
movq $0x0, -0x60(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x22a3f
movq -0x50(%rbp), %rax
cmpq 0x10(%rbp), %rax
jl 0x22a3f
jmp 0x22a9c
cmpq $0x18, -0x48(%rbp)
jge 0x22a48
jmp 0x22a9c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x60(%rbp), %r9
callq 0x22b20
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x22a73
jmp 0x22b04
cmpq $0x18, -0x60(%rbp)
jge 0x22a7f
jmp 0x22b04
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x22a15
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jle 0x22acf
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movl %eax, %edx
movq -0x38(%rbp), %rcx
leaq 0x17b6f2(%rip), %rsi    # 0x19e1ba
movb $0x0, %al
callq 0x15b0d0
cmpl $0x0, -0x28(%rbp)
je 0x22b02
movq -0x50(%rbp), %rax
cmpq 0x10(%rbp), %rax
jge 0x22b02
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movl %eax, %r8d
leaq 0x17b6d7(%rip), %rsi    # 0x19e1d2
movb $0x0, %al
callq 0x15bc10
jmp 0x22b04
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x15b5a0
movl -0x2c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: read_and_render_guid
static void read_and_render_guid(dbuf *f, u8 *id, i64 pos,
	char *id_string, size_t id_string_len)
{
	dbuf_read(f, id, pos, 16);
	fmtutil_guid_to_uuid(id);
	if(id_string) {
		fmtutil_render_uuid(f->c, id, id_string, id_string_len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %ecx
callq 0x164d10
movq -0x10(%rbp), %rdi
callq 0x174010
cmpq $0x0, -0x20(%rbp)
je 0x22e3b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x173ee0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: find_object_info
static const struct uuid_info *find_object_info(const u8 *uuid)
{
	size_t k;
	for(k=0; k<DE_ARRAYCOUNT(object_info_arr); k++) {
		if(!de_memcmp(uuid, object_info_arr[k].uuid, 16)) {
			return &object_info_arr[k];
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x24, -0x18(%rbp)
jae 0x22ec1
movq -0x10(%rbp), %rax
leaq 0x1f0d4e(%rip), %rcx    # 0x213bc0
imulq $0x28, -0x18(%rbp), %rdx
addq %rdx, %rcx
addq $0x8, %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x22eb1
leaq 0x1f0d1d(%rip), %rax    # 0x213bc0
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x22ec9
jmp 0x22eb3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x22e60
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: handler_Header
static void handler_Header(deark *c, lctx *d, struct handler_params *hp)
{
	i64 numhdrobj;

	if(hp->dlen<6) return;
	numhdrobj = de_getu32le(hp->dpos);
	de_dbg(c, "number of header objects: %u", (unsigned int)numhdrobj);
	do_object_sequence(c, d, hp->dpos+6, hp->dlen-6, hp->level+1, 1, numhdrobj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x6, 0x18(%rax)
jge 0x22ef1
jmp 0x22f61
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x165540
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x17b55e(%rip), %rsi    # 0x19e479
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
addq $0x6, %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
subq $0x6, %rcx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %r8d
addl $0x1, %r8d
movq -0x20(%rbp), %rax
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x229c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: handler_HeaderExtension
static void handler_HeaderExtension(deark *c, lctx *d, struct handler_params *hp)
{
	i64 datasize;

	if(hp->dlen<22) return;
	datasize = de_getu32le(hp->dpos+18);
	de_dbg(c, "extension data size: %u", (unsigned int)datasize);
	if(datasize > hp->dlen-22) datasize = hp->dlen-22;
	do_object_sequence(c, d, hp->dpos+22, datasize, hp->level+1, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x16, 0x18(%rax)
jge 0x23604
jmp 0x23694
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x12, %rsi
callq 0x165540
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x17b091(%rip), %rsi    # 0x19e6c3
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x16, %rcx
cmpq %rcx, %rax
jle 0x2365e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x16, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
addq $0x16, %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %r8d
addl $0x1, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x229c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: handler_CodecList
static void handler_CodecList(deark *c, lctx *d, struct handler_params *hp)
{
	i64 numentries;
	i64 k;
	i64 pos;

	if(hp->dlen<20) return;
	numentries = de_getu32le(hp->dpos+16);
	de_dbg(c, "number of codec entries: %d", (int)numentries);

	pos = hp->dpos+20;
	for(k=0; k<numentries; k++) {
		i64 bytes_consumed = 0;
		int ret;

		if(pos >= hp->dpos + hp->dlen) break;
		ret = do_codec_entry(c, d, pos, hp->dpos+hp->dlen-pos, &bytes_consumed);
		if(!ret || (bytes_consumed<8)) break;
		pos += bytes_consumed;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x14, 0x18(%rax)
jge 0x236c4
jmp 0x23796
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x10, %rsi
callq 0x165540
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x17afe9(%rip), %rsi    # 0x19e6db
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x14, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x23796
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jl 0x2373e
jmp 0x23796
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x18(%rax), %rcx
subq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x249b0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x23777
cmpq $0x8, -0x38(%rbp)
jge 0x23779
jmp 0x23796
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23711
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/asf.c
// Function: handler_ContentDescr
static void handler_ContentDescr(deark *c, lctx *d, struct handler_params *hp)
{
	i64 lengths[5];
	const char *names[5] = { "title", "author", "copyright",
		"description", "rating" };
	de_ucstring *s = NULL;
	i64 pos = hp->dpos;
	size_t k;

	if(hp->dlen<10) return;

	for(k=0; k<5; k++) {
		lengths[k] = de_getu16le_p(&pos);
	}

	s = ucstring_create(c);
	for(k=0; k<5; k++) {
		if(pos+lengths[k] > hp->dpos+hp->dlen) break;
		ucstring_empty(s);
		dbuf_read_to_ucstring_n(c->infile, pos, lengths[k], DE_DBG_MAX_STRLEN*2, s,
			0, DE_ENCODING_UTF16LE);
		ucstring_truncate_at_NUL(s);
		de_dbg(c, "%s: \"%s\"", names[k], ucstring_getpsz_d(s));
		pos += lengths[k];
	}

	ucstring_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x1f08ce(%rip), %rsi    # 0x2143e0
movl $0x28, %edx
callq 0x191e0
movq $0x0, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
cmpq $0xa, 0x18(%rax)
jge 0x23b40
jmp 0x23c95
movq $0x0, -0x88(%rbp)
cmpq $0x5, -0x88(%rbp)
jae 0x23b89
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1652c0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x40(%rbp,%rax,8)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x23b4b
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x78(%rbp)
movq $0x0, -0x88(%rbp)
cmpq $0x5, -0x88(%rbp)
jae 0x23c8c
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
addq -0x40(%rbp,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jle 0x23bd9
jmp 0x23c8c
movq -0x78(%rbp), %rdi
callq 0x171210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rdx
movq -0x78(%rbp), %r8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %r9d, %r9d
movl $0x3, (%rsp)
callq 0x166a40
movq -0x78(%rbp), %rdi
callq 0x1712b0
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rax
movq -0x70(%rbp,%rax,8), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rdi
callq 0x172650
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq %rax, %rcx
leaq 0x193fac(%rip), %rsi    # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x88(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
addq -0x80(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x23ba1
movq -0x78(%rbp), %rdi
callq 0x171750
addq $0xa0, %rsp
popq %rbp
retq
nop