LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/insetpix.c
// Function: get_item_name
static void get_item_name(struct insetpix_item_data *itd, char *nbuf, size_t nbuf_len)
{
	const char *n1;

	if(itd->is_tile) {
		de_snprintf(nbuf, nbuf_len, "tile #%u", itd->tile_num);
		return;
	}

	switch(itd->id) {
	case 0: n1 = "image info"; break;
	case 1: n1 = "palette"; break;
	case 2: n1 = "tile info"; break;
	case 17: n1 = "printing options"; break;
	case 0xff: n1 = "empty"; break;
	default: n1 = "?";
	}
	de_strlcpy(nbuf, n1, nbuf_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x9(%rax)
je 0xb8be0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0xfc81b(%rip), %rdx     # 0x1b53ef
movb $0x0, %al
callq 0x15a980
jmp 0xb8c76
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xb8c19
jmp 0xb8bef
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xb8c26
jmp 0xb8bf9
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xb8c33
jmp 0xb8c03
movl -0x24(%rbp), %eax
subl $0x11, %eax
je 0xb8c40
jmp 0xb8c0d
movl -0x24(%rbp), %eax
subl $0xff, %eax
je 0xb8c4d
jmp 0xb8c5a
leaq 0xfc7d8(%rip), %rax     # 0x1b53f8
movq %rax, -0x20(%rbp)
jmp 0xb8c65
leaq 0x109189(%rip), %rax    # 0x1c1db6
movq %rax, -0x20(%rbp)
jmp 0xb8c65
leaq 0xfc7c9(%rip), %rax     # 0x1b5403
movq %rax, -0x20(%rbp)
jmp 0xb8c65
leaq 0xfc7c6(%rip), %rax     # 0x1b540d
movq %rax, -0x20(%rbp)
jmp 0xb8c65
leaq 0xe9db1(%rip), %rax     # 0x1a2a05
movq %rax, -0x20(%rbp)
jmp 0xb8c65
leaq 0xfefcc(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15aa30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/insetpix.c
// Function: get_board_type_name
static const char *get_board_type_name(u8 bt)
{
	const char *name = NULL;

	switch(bt & 0x7e) {
	case 0: name="none"; break;
	case 8: name="CGA"; break;
	case 16: name="Hercules"; break;
	case 24: name="EGA"; break;
	}
	return name?name:"?";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x7e, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x18, %eax
ja 0xb8cea
movq -0x18(%rbp), %rax
leaq 0xfc571(%rip), %rcx     # 0x1b5220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe3a4e(%rip), %rax     # 0x19c70d
movq %rax, -0x10(%rbp)
jmp 0xb8cea
leaq 0x108a0e(%rip), %rax    # 0x1c16da
movq %rax, -0x10(%rbp)
jmp 0xb8cea
leaq 0xed884(%rip), %rax     # 0x1a655d
movq %rax, -0x10(%rbp)
jmp 0xb8cea
leaq 0xed880(%rip), %rax     # 0x1a6566
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb8cfb
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xb8d08
leaq 0xfef2b(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
jmp 0xb8d08
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: de_module_iptc
void de_module_iptc(deark *c, struct deark_module_info *mi)
{
	mi->id = "iptc";
	mi->desc = "IPTC-IIM metadata";
	mi->run_fn = de_run_iptc;
	mi->identify_fn = de_identify_iptc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x11cceb(%rip), %rcx    # 0x1d5f22
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfc408(%rip), %rcx     # 0x1b564d
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xb9270
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xbd(%rip), %rcx        # 0xb9320
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: de_run_iptc
static void de_run_iptc(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos;
	i64 bytes_consumed;
	i64 ds_count;

	d = de_malloc(c, sizeof(lctx));
	d->charset = DE_ENCODING_UNKNOWN;

	pos = 0;
	ds_count = 0;
	while(1) {
		if(pos>=c->infile->len) break;
		if(!do_dataset(c, d, ds_count, pos, &bytes_consumed)) break;
		if(bytes_consumed<=0) break;
		ds_count++;
		pos += bytes_consumed;
	}

	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 $0x4, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xb92c8
jmp 0xb930b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0xb93b0
cmpl $0x0, %eax
jne 0xb92e8
jmp 0xb930b
cmpq $0x0, -0x28(%rbp)
jg 0xb92f1
jmp 0xb930b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xb92b4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: de_identify_iptc
static int de_identify_iptc(deark *c)
{
	u8 b;

	// First byte of each dataset is 0x1c.
	if(de_getbyte(0)!=0x1c) return 0;

	// Check the record number. Record numbers 1-9 are known.
	b = de_getbyte(1);
	if(b<1 || b>15) return 0;

	// This is not meant to imply that .iptc is an official file extension for
	// IPTC data. It's just that it's sometimes used by Deark when extracting
	// IPTC data to a file.
	if(!de_input_file_has_ext(c, "iptc")) return 0;

	return 60;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165060
movzbl %al, %eax
cmpl $0x1c, %eax
je 0xb934e
movl $0x0, -0x4(%rbp)
jmp 0xb93a3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jl 0xb9375
movzbl -0x11(%rbp), %eax
cmpl $0xf, %eax
jle 0xb937e
movl $0x0, -0x4(%rbp)
jmp 0xb93a3
movq -0x10(%rbp), %rdi
leaq 0x11cb99(%rip), %rsi    # 0x1d5f22
callq 0x15d180
cmpl $0x0, %eax
jne 0xb939c
movl $0x0, -0x4(%rbp)
jmp 0xb93a3
movl $0x3c, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: lookup_ds_info
static int lookup_ds_info(u8 recnum, u8 dsnum, struct ds_info *dsi)
{
	size_t i;

	de_zeromem(dsi, sizeof(struct ds_info));

	for(i=0; i<DE_ARRAYCOUNT(ds_info_arr); i++) {
		if(ds_info_arr[i].recnum==recnum && ds_info_arr[i].dsnum==dsnum) {
			*dsi = ds_info_arr[i]; // struct copy
			return 1;
		}
	}

	// Not found
	dsi->recnum = recnum;
	dsi->dsnum = dsnum;
	dsi->dsname = "?";
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x19140
movq $0x0, -0x18(%rbp)
cmpq $0x4d, -0x18(%rbp)
jae 0xb96be
leaq 0x15fea2(%rip), %rax    # 0x2194f0
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl (%rax), %eax
movzbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb96ae
leaq 0x15fe88(%rip), %rax    # 0x2194f0
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
movzbl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb96ae
movq -0x10(%rbp), %rax
leaq 0x15fe69(%rip), %rcx    # 0x2194f0
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb96e7
jmp 0xb96b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb9640
movb -0x5(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x6(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
leaq 0xfe551(%rip), %rcx     # 0x1b7c2d
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: read_dflen
static int read_dflen(deark *c, dbuf *f, i64 pos,
	i64 *dflen, i64 *bytes_consumed)
{
	i64 x;

	x = dbuf_getu16be(f, pos);
	if(x<32768) { // "Standard DataSet" format
		*dflen = x;
		*bytes_consumed = 2;
	}
	else { // "Extended DataSet" format
		i64 length_of_length;
		i64 i;

		length_of_length = x - 32768;
		*dflen = 0;
		*bytes_consumed = 2 + length_of_length;

		for(i=0; i<length_of_length; i++) {
			*dflen = ((*dflen)<<8) | dbuf_getbyte(f, pos+2+i);

			// IPTC seems to support fields up to (2^262136)-1 bytes.
			// We arbitrarily limit it (2^48)-1.
			if((*dflen)>=0x1000000000000LL) {
				de_err(c, "Bad or unsupported IPTC data field length");
				return 0;
			}
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1651d0
movq %rax, -0x38(%rbp)
cmpq $0x8000, -0x38(%rbp)    # imm = 0x8000
jge 0xb9742
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x2, (%rax)
jmp 0xb97f1
movq -0x38(%rbp), %rax
subq $0x8000, %rax           # imm = 0x8000
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x40(%rbp), %rcx
addq $0x2, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0xb97ef
movq -0x28(%rbp), %rax
movq (%rax), %rax
shlq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x2, %rsi
addq -0x48(%rbp), %rsi
callq 0x165060
movq -0x50(%rbp), %rcx
movzbl %al, %eax
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movabsq $0x1000000000000, %rcx  # imm = 0x1000000000000
cmpq %rcx, (%rax)
jl 0xb97df
movq -0x10(%rbp), %rdi
leaq 0xfc42e(%rip), %rsi     # 0x1b5bfd
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x4(%rbp)
jmp 0xb97f8
jmp 0xb97e1
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xb9772
jmp 0xb97f1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: handle_text
static void handle_text(deark *c, lctx *d, const struct ds_info *dsi,
	i64 pos, i64 len)
{
	de_encoding encoding;
	de_ucstring *s = NULL;

	s = ucstring_create(c);
	encoding = get_ds_encoding(c, d, dsi->recnum);
	if(encoding==DE_ENCODING_UNKNOWN)
		encoding = DE_ENCODING_ASCII;
	dbuf_read_to_ucstring(c->infile, pos, len, s, 0, encoding);
	de_dbg(c, "%s: \"%s\"", dsi->dsname, ucstring_getpsz_d(s));
	ucstring_destroy(s);
}

// 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)
movq %r8, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movzbl (%rax), %edx
callq 0xb9b60
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xb9865
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r9d
xorl %r8d, %r8d
callq 0x1669f0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x172650
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0xfe352(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rdi
callq 0x171750
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: handle_1_90
static void handle_1_90(deark *c, lctx *d, const struct ds_info *dsi,
	i64 pos, i64 len)
{
	const char *csname;

	d->charset = DE_ENCODING_UNKNOWN;

	// TODO: Fully interpret this field.

	if(len>=3 && !dbuf_memcmp(c->infile, pos, "\x1b\x25\x47", 3)) {
		d->charset = DE_ENCODING_UTF8;
	}

	if(d->charset==DE_ENCODING_UTF8)
		csname="utf-8";
	else
		csname="unknown";

	de_dbg(c, "charset: %s", csname);
}

// 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 -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x3, -0x28(%rbp)
jl 0xb9989
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq 0xfc263(%rip), %rdx     # 0x1b5bd3
movl $0x3, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0xb9989
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xb999f
leaq 0xfc23e(%rip), %rax     # 0x1b5bd7
movq %rax, -0x30(%rbp)
jmp 0xb99aa
leaq 0xe4bb6(%rip), %rax     # 0x19e55c
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xfc224(%rip), %rsi     # 0x1b5bdd
movb $0x0, %al
callq 0x15b0d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: handle_2_120
static void handle_2_120(deark *c, lctx *d, const struct ds_info *dsi,
	i64 pos, i64 len)
{
	dbuf *outf = NULL;
	de_encoding encoding;

	if(c->extract_level<2) {
		handle_text(c, d, dsi, pos, len);
		goto done;
	}

	// Note that this code for extracting captions while decoding IPTC is not
	// easily reached, because it requires the -a option, and -a usually causes
	// IPTC to be extracted instead of decoded.
	// It can be reached when reading a raw IPTC file, or when using
	// "-a -opt extractiptc=0".

	encoding = get_ds_encoding(c, d, dsi->recnum);

	outf = dbuf_create_output_file(c, "caption.txt", NULL, DE_CREATEFLAG_IS_AUX);

	dbuf_copy_slice_convert_to_utf8(c->infile, pos, len,
		DE_EXTENC_MAKE(encoding, DE_ENCSUBTYPE_HYBRID),
		outf, 0x1|0x4);

done:
	if(outf) dbuf_close(outf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x90(%rax)
jge 0xb9a1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xb9810
jmp 0xb9a7e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movzbl (%rax), %edx
callq 0xb9b60
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfc1ab(%rip), %rsi     # 0x1b5be9
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x166c60
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x34(%rbp), %ecx
andl $0xff, %ecx
orl $0x300, %ecx            # imm = 0x300
movq -0x30(%rbp), %r8
movl $0x5, %r9d
callq 0x169da0
cmpq $0x0, -0x30(%rbp)
je 0xb9a8e
movq -0x30(%rbp), %rdi
callq 0x1676a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/iptc.c
// Function: handle_2_125
static void handle_2_125(deark *c, lctx *d, const struct ds_info *dsi,
	i64 pos, i64 len)
{
	de_bitmap *img = NULL;
	i64 rowspan;
	i64 width1, height1;

	// I can't find any examples of this field, so this may not be correct.
	// The format seems to be well-documented, though the pixels are in an
	// unusual order.

	width1 = 128; // (Will be rotated to be 460x128)
	height1 = 460;
	rowspan = width1/8;
	if(len < rowspan * height1) goto done;
	img = de_bitmap_create(c, width1, height1, 1);
	de_convert_image_bilevel(c->infile, pos, rowspan, img, DE_CVTF_WHITEISZERO);
	de_bitmap_transpose(img);
	de_bitmap_write_to_file(img, "caption", DE_CREATEFLAG_IS_AUX|DE_CREATEFLAG_FLIP_IMAGE|
		DE_CREATEFLAG_IS_BWIMG);
done:
	de_bitmap_destroy(img);
}

// 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)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x80, -0x40(%rbp)
movq $0x1cc, -0x48(%rbp)     # imm = 0x1CC
movq -0x40(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
imulq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jge 0xb9afa
jmp 0xb9b51
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl $0x1, %ecx
callq 0x16b750
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1, %r8d
callq 0x16bee0
movq -0x30(%rbp), %rdi
callq 0x16cb90
movq -0x30(%rbp), %rdi
leaq 0xfc0ae(%rip), %rsi     # 0x1b5bf5
movl $0xd, %edx
callq 0x16afd0
movq -0x30(%rbp), %rdi
callq 0x16af60
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jbf.c
// Function: de_module_jbf
void de_module_jbf(deark *c, struct deark_module_info *mi)
{
	mi->id = "jbf";
	mi->desc = "PaintShop Pro Browser Cache (pspbrwse.jbf)";
	mi->run_fn = de_run_jbf;
	mi->identify_fn = de_identify_jbf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xfc419(%rip), %rcx     # 0x1b5fd0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfc40f(%rip), %rcx     # 0x1b5fd4
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xb9bf0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x11d(%rip), %rcx       # 0xb9d00
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jbf.c
// Function: de_run_jbf
static void de_run_jbf(deark *c, de_module_params *mparams)
{
	lctx *d = NULL;
	i64 pos = 0;
	i64 bytes_consumed;
	i64 count = 0;

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

	if(!do_read_header(c, d, pos)) goto done;
	pos += 1024;

	count = 0;
	while(1) {
		if(count>=d->image_count) break;
		if(pos>=c->infile->len) goto done;

		bytes_consumed = 0;
		if(!do_one_thumbnail(c, d, pos, count, &bytes_consumed)) {
			goto done;
		}
		if(bytes_consumed<1) goto done;
		pos += bytes_consumed;
		count++;
	}

done:
	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 $0x0, -0x20(%rbp)
movq $0x0, -0x30(%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 $0x9, %edx
callq 0x15e4a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb9d50
cmpl $0x0, %eax
jne 0xb9c5f
jmp 0xb9ce6
movq -0x20(%rbp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jl 0xb9c85
jmp 0xb9ce4
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xb9c99
jmp 0xb9ce6
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0xb9ef0
cmpl $0x0, %eax
jne 0xb9cc1
jmp 0xb9ce6
cmpq $0x1, -0x28(%rbp)
jge 0xb9cca
jmp 0xb9ce6
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb9c75
jmp 0xb9ce6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jbf.c
// Function: read_FILETIME
static void read_FILETIME(deark *c, lctx *d, struct page_ctx *pg, i64 pos)
{
	i64 ft;
	char timestamp_buf[64];

	ft = de_geti64le(pos);
	de_FILETIME_to_timestamp(ft, &pg->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], 0x1);
	de_timestamp_to_string(&pg->fi->timestamp[DE_TIMESTAMPIDX_MODIFY], timestamp_buf, sizeof(timestamp_buf), 0);
	de_dbg(c, "mod time: %s", timestamp_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1657e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
movl $0x1, %edx
callq 0x15d580
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0x15e130
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq 0xf01db(%rip), %rsi     # 0x1aa70b
movb $0x0, %al
callq 0x15b0d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jbf.c
// Function: get_type_name
static const char *get_type_name(UI filetype_code)
{
	const char *nm = "unknown";

	switch(filetype_code) {
	// There are many more PSP file types. These are just some common ones.
	case 0x00: nm="none"; break;
	case 0x01: nm="BMP"; break;
	case 0x0a: nm="GIF"; break;
	case 0x11: nm="JPEG"; break;
	case 0x18: nm="PCX"; break;
	case 0x1c: nm="PNG"; break;
	case 0x1f: nm="PSP"; break;
	case 0x23: nm="TGA"; break;
	case 0x24: nm="TIFF"; break;
	}
	return nm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0xe400e(%rip), %rax     # 0x19e55c
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x24, %rax
ja 0xba5ea
movq -0x18(%rbp), %rax
leaq 0xfb6c2(%rip), %rcx     # 0x1b5c30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe218f(%rip), %rax     # 0x19c70d
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xf4aff(%rip), %rax     # 0x1af08a
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xfbbca(%rip), %rax     # 0x1b6162
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xe4092(%rip), %rax     # 0x19e637
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xfbbb4(%rip), %rax     # 0x1b6166
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0x1089ae(%rip), %rax    # 0x1c2f6d
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xfbb9e(%rip), %rax     # 0x1b616a
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0xfbb95(%rip), %rax     # 0x1b616e
movq %rax, -0x10(%rbp)
jmp 0xba5ea
leaq 0x11bc08(%rip), %rax    # 0x1d61ee
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jovianvi.c
// Function: de_module_jovianvi
void de_module_jovianvi(deark *c, struct deark_module_info *mi)
{
	mi->id = "jovianvi";
	mi->desc = "Jovian Logic VI";
	mi->run_fn = de_run_jovianvi;
	mi->identify_fn = de_identify_jovianvi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xfb779(%rip), %rcx     # 0x1b6220
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfb774(%rip), %rcx     # 0x1b6229
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xbaae0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x5bd(%rip), %rcx       # 0xbb090
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jovianvi.c
// Function: de_identify_jovianvi
static int de_identify_jovianvi(deark *c)
{
	u8 t;

	if(dbuf_memcmp(c->infile, 0, "VI", 2)) return 0;
	t = de_getbyte(2);
	if((t>=0x10 && t<=0x11) ||
		(t>=0x20 && t<=0x23) ||
		(t>=0x30 && t<=0x31))
	{
		return 100;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xfb187(%rip), %rdx     # 0x1b6236
movl $0x2, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xbb0c7
movl $0x0, -0x4(%rbp)
jmp 0xbb122
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x165060
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x10, %eax
jl 0xbb0ee
movzbl -0x11(%rbp), %eax
cmpl $0x11, %eax
jle 0xbb112
movzbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jl 0xbb100
movzbl -0x11(%rbp), %eax
cmpl $0x23, %eax
jle 0xbb112
movzbl -0x11(%rbp), %eax
cmpl $0x30, %eax
jl 0xbb11b
movzbl -0x11(%rbp), %eax
cmpl $0x31, %eax
jg 0xbb11b
movl $0x64, -0x4(%rbp)
jmp 0xbb122
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jovianvi.c
// Function: do_convert_rgb
static void do_convert_rgb(deark *c, lctx *d, de_bitmap *img)
{
	i64 i, j;
	u32 clr;
	u8 b0, b1;

	for(j=0; j<d->h; j++) {
		for(i=0; i<d->pdwidth; i++) {
			if(d->bitdepth==16) {
				b0 = de_getbyte(d->bitspos + j*d->rowspan + i*2);
				b1 = de_getbyte(d->bitspos + j*d->rowspan + i*2 + 1);
				clr = (((u32)b1)<<8) | b0;
				clr = de_rgb565_to_888(clr);
			}
			else {
				clr = dbuf_getRGB(c->infile, d->bitspos+j*d->rowspan+i*3, 0);
			}
			de_bitmap_setpixel_rgb(img, i, j, clr);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0xbb426
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xbb413
movq -0x10(%rbp), %rax
cmpq $0x10, 0x20(%rax)
jne 0xbb3bc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x30(%rcx), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
shlq %rax
addq %rax, %rsi
callq 0x165060
movb %al, -0x2d(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x30(%rcx), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
shlq %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x165060
movb %al, -0x2e(%rbp)
movzbl -0x2e(%rbp), %eax
shll $0x8, %eax
movzbl -0x2d(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1618a0
movl %eax, -0x2c(%rbp)
jmp 0xbb3ee
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x30(%rcx), %rax
addq %rax, %rsi
imulq $0x3, -0x20(%rbp), %rax
addq %rax, %rsi
xorl %edx, %edx
callq 0x165ff0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x16b310
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbb316
jmp 0xbb415
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xbb2fc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_module_jpeg
void de_module_jpeg(deark *c, struct deark_module_info *mi)
{
	mi->id = "jpeg";
	mi->desc = "JPEG image";
	mi->desc2 = "resources only";
	mi->run_fn = de_run_jpeg;
	mi->identify_fn = de_identify_jpeg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xe8219(%rip), %rcx     # 0x1a3660
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfafcb(%rip), %rcx     # 0x1b6420
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0xe5d75(%rip), %rcx     # 0x1a11d9
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0xbb490
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x22e(%rip), %rcx       # 0xbb6b0
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_run_jpegscan
static void de_run_jpegscan(deark *c, de_module_params *mparams)
{
	i64 pos = 0;
	i64 foundpos = 0;
	scanctx *d = NULL;
	int ret;

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

	while(1) {
		if(pos >= c->infile->len) break;

		ret = dbuf_search(c->infile, (const u8*)"\xff\xd8\xff", 3,
			pos, c->infile->len-pos, &foundpos);
		if(!ret) break; // No more JPEGs in file.

		de_dbg(c, "Found possible JPEG file at %d", (int)foundpos);

		pos = foundpos;

		if(detect_jpeg_len(c, d, pos, c->infile->len-pos)) {
			de_dbg(c, "length=%d", (int)d->len);
			dbuf_create_file_from_slice(c->infile, pos, d->len,
				d->is_jpegls ? "jls" : "jpg", NULL, 0);
			pos += d->len;
		}
		else {
			de_dbg(c, "Doesn't seem to be a valid JPEG.");
			pos++;
		}
	}

	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 $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xbb791
jmp 0xbb8a4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r8
subq -0x18(%rbp), %r8
leaq 0xe4bda(%rip), %rsi     # 0x1a038e
movl $0x3, %edx
leaq -0x20(%rbp), %r9
callq 0x169370
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xbb7d0
jmp 0xbb8a4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0xfbca7(%rip), %rsi     # 0x1b7488
movb $0x0, %al
callq 0x15b0d0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
subq -0x18(%rbp), %rcx
callq 0xc0f20
cmpl $0x0, %eax
je 0xbb881
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
leaq 0xfbc7d(%rip), %rsi     # 0x1b74a7
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %r8d
leaq 0x103aa5(%rip), %rcx    # 0x1bf2f9
leaq 0xfbc56(%rip), %rax     # 0x1b74b1
cmpl $0x0, %r8d
cmovneq %rax, %rcx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x166be0
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbb89f
movq -0x8(%rbp), %rdi
leaq 0xfbc29(%rip), %rsi     # 0x1b74b5
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbb77a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_module_syberia_syj
void de_module_syberia_syj(deark *c, struct deark_module_info *mi)
{
	mi->id = "syberia_syj";
	mi->desc = "Syberia texture";
	mi->run_fn = de_run_syberia_syj;
	mi->identify_fn = de_identify_syberia_syj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xfab8f(%rip), %rcx     # 0x1b6466
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfab8d(%rip), %rcx     # 0x1b6472
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xbb910
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x8d(%rip), %rcx        # 0xbb990
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_run_syberia_syj
static void de_run_syberia_syj(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "jpg", NULL, 0);
	dbuf_write(outf, (const u8*)"\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49\x46", 10);
	dbuf_copy(c->infile, 0, c->infile->len, outf);
	dbuf_close(outf);
}

// 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
leaq 0x1039c6(%rip), %rsi    # 0x1bf2f9
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xfaaaa(%rip), %rsi     # 0x1b63f7
movl $0xa, %edx
callq 0x166170
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_syberia_syj
static int de_identify_syberia_syj(deark *c)
{
	if(de_getu16be(0) != 0x0001) return 0;
	if(!de_input_file_has_ext(c, "syj")) return 0;
	if(dbuf_memcmp(c->infile, 8, (const void*)"\0\0\xff", 3)) {
		return 0;
	}
	if(de_getu16be(c->infile->len-2) != 0xffd9) return 0;
	return 80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1651d0
cmpq $0x1, %rax
je 0xbb9bc
movl $0x0, -0x4(%rbp)
jmp 0xbba3b
movq -0x10(%rbp), %rdi
leaq 0xfaaa7(%rip), %rsi     # 0x1b646e
callq 0x15d180
cmpl $0x0, %eax
jne 0xbb9da
movl $0x0, -0x4(%rbp)
jmp 0xbba3b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x8, %esi
leaq 0xfbb3b(%rip), %rdx     # 0x1b7529
movl $0x3, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xbba06
movl $0x0, -0x4(%rbp)
jmp 0xbba3b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
subq $0x2, %rsi
callq 0x1651d0
cmpq $0xffd9, %rax           # imm = 0xFFD9
je 0xbba34
movl $0x0, -0x4(%rbp)
jmp 0xbba3b
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_module_esm_pix
void de_module_esm_pix(deark *c, struct deark_module_info *mi)
{
	mi->id = "esm_pix";
	mi->desc = "Esm Software PIX";
	mi->run_fn = de_run_esm_pix;
	mi->identify_fn = de_identify_esm_pix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xfaa1b(%rip), %rcx     # 0x1b6482
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfaa15(%rip), %rcx     # 0x1b648a
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xbbaa0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x7d(%rip), %rcx        # 0xbbb10
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_run_esm_pix
static void de_run_esm_pix(deark *c, de_module_params *mparams)
{
	dbuf *outf = NULL;

	outf = dbuf_create_output_file(c, "jpg", NULL, 0);
	dbuf_copy(c->infile, 21, c->infile->len - 21, outf);
	dbuf_close(outf);
}

// 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
leaq 0x103836(%rip), %rsi    # 0x1bf2f9
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdx
subq $0x15, %rdx
movq -0x18(%rbp), %rcx
movl $0x15, %esi
callq 0x166070
movq -0x18(%rbp), %rdi
callq 0x1676a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_esm_pix
static int de_identify_esm_pix(deark *c)
{
	if(dbuf_memcmp(c->infile, 0, (const void*)"Esm ", 4)) {
		return 0;
	}
	if(dbuf_memcmp(c->infile, 13, (const void*)"PIX ", 4)) {
		return 0;
	}
	if((UI)de_getu16be(21) != 0xffd8) return 0;
	return 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xfb9c2(%rip), %rdx     # 0x1b74f1
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xbbb47
movl $0x0, -0x4(%rbp)
jmp 0xbbb9c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xd, %esi
leaq 0xfb99b(%rip), %rdx     # 0x1b74f6
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xbbb73
movl $0x0, -0x4(%rbp)
jmp 0xbbb9c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x15, %esi
callq 0x1651d0
cmpl $0xffd8, %eax           # imm = 0xFFD8
je 0xbbb95
movl $0x0, -0x4(%rbp)
jmp 0xbbb9c
movl $0x64, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_module_pegasus_pic2
void de_module_pegasus_pic2(deark *c, struct deark_module_info *mi)
{
	mi->id = "pegasus_pic2";
	mi->desc = "Pegasus PIC2";
	mi->run_fn = de_run_pegasus_pic2;
	mi->identify_fn = de_identify_pegasus_pic2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xfa8d4(%rip), %rcx     # 0x1b649b
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xfa8d3(%rip), %rcx     # 0x1b64a8
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xbbc00
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x6d(%rip), %rcx        # 0xbbc60
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_run_pegasus_pic2
static void de_run_pegasus_pic2(deark *c, de_module_params *mparams)
{
	struct pic2_ctx *d = NULL;

	d = de_malloc(c, sizeof(struct pic2_ctx));
	de_declare_fmt(c, "Pegasus PIC2");
	pic2_main(c, d);
	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 $0x1, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfa873(%rip), %rsi     # 0x1b64a8
callq 0x15e380
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc11a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: de_identify_pegasus_pic2
static int de_identify_pegasus_pic2(deark *c)
{
	UI n;
	u8 b;

	n = (UI)de_getu32be(0);
#define CODE_PIC2 0x50494332U
	if(n!=CODE_PIC2) return 0;
	b = de_getbyte(4); // segment type, expecting 1
	if(b!=1) return 0;
	n = (UI)de_getu32le(5); // segment len, expecting 8
	if(n<4 || n>32) return 0;
	return 87;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x165470
movl %eax, -0x14(%rbp)
cmpl $0x50494332, -0x14(%rbp) # imm = 0x50494332
je 0xbbc92
movl $0x0, -0x4(%rbp)
jmp 0xbbcea
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x165060
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x1, %eax
je 0xbbcb9
movl $0x0, -0x4(%rbp)
jmp 0xbbcea
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x5, %esi
callq 0x165540
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jb 0xbbcda
cmpl $0x20, -0x14(%rbp)
jbe 0xbbce3
movl $0x0, -0x4(%rbp)
jmp 0xbbcea
movl $0x57, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: do_afcp_segment
static void do_afcp_segment(deark *c, lctx *d, i64 endpos)
{
	d->has_afcp = 1;
	de_dbg(c, "AFCP segment found at end of file");

	de_dbg_indent(c, 1);
	de_run_module_by_id_on_slice(c, "afcp", NULL, c->infile, 0, endpos);
	de_dbg_indent(c, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rbp), %rdi
leaq 0xfb3d8(%rip), %rsi     # 0x1b736f
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %r9
leaq 0xe4277(%rip), %rsi     # 0x1a023a
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x15c9f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: do_segment
static void do_segment(deark *c, lctx *d, const struct marker_info *mi,
	i64 payload_pos, i64 payload_size)
{
	de_dbg(c, "segment 0x%02x (%s) at %d, dpos=%d, dlen=%d",
		(unsigned int)mi->seg_type, mi->longname, (int)(payload_pos-4),
		(int)payload_pos, (int)payload_size);

	if(mi->hfn) {
		// If a handler function is available, use it.
		de_dbg_indent(c, 1);
		mi->hfn(c, d, mi, payload_pos, payload_size);
		de_dbg_indent(c, -1);
	}
}

// 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 -0x18(%rbp), %rax
movzbl (%rax), %edx
movq -0x18(%rbp), %rcx
addq $0x14, %rcx
movq -0x20(%rbp), %rax
subq $0x4, %rax
movl %eax, %r8d
movq -0x20(%rbp), %rax
movl %eax, %r9d
movq -0x28(%rbp), %rax
leaq 0xfa9e3(%rip), %rsi     # 0x1b726f
movl %eax, (%rsp)
movb $0x0, %al
callq 0x15b0d0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xbc8db
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: do_post_sof_stuff
static void do_post_sof_stuff(deark *c, lctx *d)
{
	if(d->is_jpegls) return;

	if(d->has_jfif_seg && d->has_exif_seg && !d->exif_before_jfif &&
		(d->jfif_ver_h==1 && (d->jfif_ver_l==1 || d->jfif_ver_l==2)))
	{
		if(d->exif_orientation>1) {
			de_dbg(c, "Note: Image has an ambiguous orientation: JFIF says "
				"%s; Exif says %s",
				fmtutil_tiff_orientation_name(1),
				fmtutil_tiff_orientation_name((i64)d->exif_orientation));
		}

		if(d->exif_cosited && d->is_subsampled && d->ncomp>1) {
			de_dbg(c, "Note: Image has an ambiguous subsampling position: JFIF says "
				"centered; Exif says cosited");
		}

		// TODO: Another thing we could check for is a significant conflict in
		// the JFIF and Exif density settings.
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xbc90e
jmp 0xbc9ed
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0xbc9ed
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x0, %eax
je 0xbc9ed
movq -0x10(%rbp), %rax
cmpb $0x0, 0xa(%rax)
jne 0xbc9ed
movq -0x10(%rbp), %rax
movzbl 0x38(%rax), %eax
cmpl $0x1, %eax
jne 0xbc9ed
movq -0x10(%rbp), %rax
movzbl 0x39(%rax), %eax
cmpl $0x1, %eax
je 0xbc96d
movq -0x10(%rbp), %rax
movzbl 0x39(%rax), %eax
cmpl $0x2, %eax
jne 0xbc9ed
movq -0x10(%rbp), %rax
cmpl $0x1, 0x3c(%rax)
jbe 0xbc9b4
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x174f10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, %edi
callq 0x174f10
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0xfa8ee(%rip), %rsi     # 0x1b729b
movb $0x0, %al
callq 0x15b0d0
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
je 0xbc9eb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x98(%rax)
je 0xbc9eb
movq -0x10(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jle 0xbc9eb
movq -0x8(%rbp), %rdi
leaq 0xfa8fc(%rip), %rsi     # 0x1b72e0
movb $0x0, %al
callq 0x15b0d0
jmp 0xbc9ed
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: do_at_end_of_jpeg
static void do_at_end_of_jpeg(deark *c, lctx *d)
{
	dbuf_close(d->iccprofile_file);
	d->iccprofile_file = NULL;
	dbuf_close(d->hdr_residual_file);
	d->hdr_residual_file = NULL;
	destroy_fpxr_data(c, d);

	if(d->extxmp_membuf && !d->extxmp_error_flag) {
		dbuf *tmpdbuf = NULL;
		tmpdbuf = dbuf_create_output_file(c, "xmp", NULL, DE_CREATEFLAG_IS_AUX);
		dbuf_copy(d->extxmp_membuf, 0, d->extxmp_total_len, tmpdbuf);
		dbuf_close(tmpdbuf);
	}
	dbuf_close(d->extxmp_membuf);
	d->extxmp_membuf = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc05e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xbcc72
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xbcc72
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x10678f(%rip), %rsi    # 0x1c33c6
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x166c60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x166070
movq -0x18(%rbp), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/jpeg.c
// Function: handler_dht
static void handler_dht(deark *c, lctx *d,
	const struct marker_info *mi, i64 pos1, i64 data_size)
{
	i64 pos = pos1;
	u8 b;
	u8 table_class;
	u8 table_id;
	i64 num_huff_codes;
	i64 k;
	u8 codecounts[16];

	while(1) {
		if(pos >= pos1+data_size) goto done;

		b = de_getbyte(pos);
		table_class = b>>4;
		table_id = b&0x0f;
		de_dbg(c, "table: %s%d, at %d", table_class==0?"DC":"AC",
			(int)table_id, (int)pos);

		de_read(codecounts, pos+1, 16);
		num_huff_codes = 0;
		for(k=0; k<16; k++) {
			num_huff_codes += (i64)codecounts[k];
		}
		de_dbg_indent(c, 1);
		dump_htable_summary(c, d, codecounts);
		de_dbg(c, "number of codes: %d", (int)num_huff_codes);
		pos += 1 + 16;
		dump_htable_details(c, d, pos, codecounts, num_huff_codes);
		de_dbg_indent(c, -1);
		pos += num_huff_codes;
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jl 0xbd41a
jmp 0xbd547
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x165060
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
sarl $0x4, %eax
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
andl $0xf, %eax
movb %al, -0x33(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x32(%rbp), %ecx
leaq 0xf9149(%rip), %rdx     # 0x1b659a
leaq 0xe9bd7(%rip), %rax     # 0x1a702f
cmpl $0x0, %ecx
cmoveq %rax, %rdx
movzbl -0x33(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %eax, %r8d
leaq 0xf925c(%rip), %rsi     # 0x1b66cd
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
movl $0x10, %ecx
callq 0x164d10
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
cmpq $0x10, -0x48(%rbp)
jge 0xbd4cc
movq -0x48(%rbp), %rax
movzbl -0x60(%rbp,%rax), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbd4a6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0xbdb00
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %edx
leaq 0xf91e4(%rip), %rsi     # 0x1b66e0
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rax
addq $0x11, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0xbdc00
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xbd404
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)