LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: do_mbk
static void do_mbk(deark *c, lctx *d)
{
	i64 pos = 0;
	const char *bt = "?";

	de_dbg(c, "MBK header at %d", (int)pos);
	de_dbg_indent(c, 1);

	de_dbg(c, "bank number: %d", (int)d->banknum);

	d->banksize = de_getu32be(14);
	d->banktype = (u8)(d->banksize>>24);
	d->banksize &= (i64)0x00ffffff;

	switch(d->banktype) {
	case 0x01: bt = "work"; break;
	case 0x02: bt = "screen"; break;
	case 0x81: bt = "data"; break;
	case 0x82: bt = "datascreen"; break;
	case 0x84: bt = "set"; break;
	case 0x85: bt = "packed files"; break;
	}

	de_dbg(c, "bank type: 0x%02x (%s)", (unsigned int)d->banktype, bt);
	de_dbg(c, "bank size: %d", (int)d->banksize);

	de_dbg_indent(c, -1);

	pos += 18;

	if(d->banktype==0x81) {
		do_mbk_data_bank(c, d, pos);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xdbd9e(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xdff2d(%rip), %rsi     # 0x1bbdce
xorl %eax, %eax
movb %al, -0x25(%rbp)
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movb -0x25(%rbp), %al
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %edx
leaq 0xdff11(%rip), %rsi     # 0x1bbddf
callq 0x15b0d0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xe, %esi
callq 0x165470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movb 0x23(%rax), %cl
movb %cl, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xdbf58
jmp 0xdbf1e
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xdbf65
jmp 0xdbf28
movl -0x24(%rbp), %eax
subl $0x81, %eax
je 0xdbf72
jmp 0xdbf34
movl -0x24(%rbp), %eax
subl $0x82, %eax
je 0xdbf7f
jmp 0xdbf40
movl -0x24(%rbp), %eax
subl $0x84, %eax
je 0xdbf8c
jmp 0xdbf4c
movl -0x24(%rbp), %eax
subl $0x85, %eax
je 0xdbf99
jmp 0xdbfa4
leaq 0xdfe90(%rip), %rax     # 0x1bbdef
movq %rax, -0x20(%rbp)
jmp 0xdbfa4
leaq 0xdfee1(%rip), %rax     # 0x1bbe4d
movq %rax, -0x20(%rbp)
jmp 0xdbfa4
leaq 0xe9c00(%rip), %rax     # 0x1c5b79
movq %rax, -0x20(%rbp)
jmp 0xdbfa4
leaq 0xdfe6e(%rip), %rax     # 0x1bbdf4
movq %rax, -0x20(%rbp)
jmp 0xdbfa4
leaq 0xce7ca(%rip), %rax     # 0x1aa75d
movq %rax, -0x20(%rbp)
jmp 0xdbfa4
leaq 0xdfe5f(%rip), %rax     # 0x1bbdff
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %edx
movq -0x20(%rbp), %rcx
leaq 0xdfe51(%rip), %rsi     # 0x1bbe0c
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, %edx
leaq 0xdfe4c(%rip), %rsi     # 0x1bbe23
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x18(%rbp), %rax
addq $0x12, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x81, %eax
jne 0xdc018
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdc900
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: do_mbk_data_bank
static void do_mbk_data_bank(deark *c, lctx *d, i64 pos)
{
	const char *bn = "?";

	de_dbg(c, "STOS data bank at %d", (int)pos);
	de_dbg_indent(c, 1);
	d->data_bank_id = (u32)de_getu32be(pos);

	switch(d->data_bank_id) {
	case BANKID_PKSCREEN: bn = "packed screen"; break;
	case 0x13490157U: bn = "music bank"; break;
	case 0x28091960U: bn = "icon bank"; break;
	case BANKID_SPRITE: bn = "sprite bank"; break;
	case 0x4d414553U: bn = "Maestro!"; break;
	}

	de_dbg(c, "data bank id: 0x%08x (%s)", (unsigned int)d->data_bank_id, bn);

	switch(d->data_bank_id) {
	case BANKID_SPRITE:
		do_sprite_bank(c, d, pos);
		break;
	case 0x28091960U:
		do_icon_bank(c, d, pos);
		break;
	case BANKID_PKSCREEN:
		do_pkscreen_bank(c, d, pos);
		break;
	}
	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)
leaq 0xdb312(%rip), %rax     # 0x1b7c2d
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0xdf504(%rip), %rsi     # 0x1bbe31
xorl %eax, %eax
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165470
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x6071963, %eax        # imm = 0x6071963
je 0xdc99f
jmp 0xdc96f
movl -0x24(%rbp), %eax
subl $0x13490157, %eax       # imm = 0x13490157
je 0xdc9ac
jmp 0xdc97b
movl -0x24(%rbp), %eax
subl $0x19861987, %eax       # imm = 0x19861987
je 0xdc9c6
jmp 0xdc987
movl -0x24(%rbp), %eax
subl $0x28091960, %eax       # imm = 0x28091960
je 0xdc9b9
jmp 0xdc993
movl -0x24(%rbp), %eax
subl $0x4d414553, %eax       # imm = 0x4D414553
je 0xdc9d3
jmp 0xdc9de
leaq 0xdf4a0(%rip), %rax     # 0x1bbe46
movq %rax, -0x20(%rbp)
jmp 0xdc9de
leaq 0xdf4a1(%rip), %rax     # 0x1bbe54
movq %rax, -0x20(%rbp)
jmp 0xdc9de
leaq 0xdf49f(%rip), %rax     # 0x1bbe5f
movq %rax, -0x20(%rbp)
jmp 0xdc9de
leaq 0xdf49c(%rip), %rax     # 0x1bbe69
movq %rax, -0x20(%rbp)
jmp 0xdc9de
leaq 0xdf49b(%rip), %rax     # 0x1bbe75
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x20(%rbp), %rcx
leaq 0xdf48a(%rip), %rsi     # 0x1bbe7e
xorl %eax, %eax
callq 0x15b0d0
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x6071963, %eax        # imm = 0x6071963
je 0xdca4c
jmp 0xdca0e
movl -0x28(%rbp), %eax
subl $0x19861987, %eax       # imm = 0x19861987
je 0xdca26
jmp 0xdca1a
movl -0x28(%rbp), %eax
subl $0x28091960, %eax       # imm = 0x28091960
je 0xdca39
jmp 0xdca5d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdc020
jmp 0xdca5d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdca80
jmp 0xdca5d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdc1e0
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/mbk.c
// Function: do_icon_bank
static void do_icon_bank(deark *c, lctx *d, i64 pos)
{
	i64 num_icons;
	i64 k;

	num_icons = de_getu16be(pos+4);
	de_dbg(c, "number of icons: %d", (int)num_icons);
	for(k=0; k<num_icons; k++) {
		do_icon(c, d, k, pos+6+84*k);
	}
}

// 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
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x1651d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0xdf3da(%rip), %rsi     # 0x1bbe98
movb $0x0, %al
callq 0x15b0d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0xdcb06
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x6, %rcx
imulq $0x54, -0x28(%rbp), %rax
addq %rax, %rcx
callq 0xdcb10
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdcacd
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: read_sprite_palette
static void read_sprite_palette(deark *c, lctx *d, i64 pos)
{
	i64 n;

	if(pos>=c->infile->len) return;

	n = de_getu32be(pos);
	if(n!=0x50414c54) {
		de_warn(c, "Sprite palette not found (expected at %d)", (int)pos);
		d->pal[0] = DE_STOCKCOLOR_WHITE;
		return;
	}
	de_dbg(c, "sprite palette at %d", (int)pos);
	de_dbg_indent(c, 1);
	fmtutil_read_atari_palette(c, c->infile, pos+4, d->pal, 16, 16, 0);
	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 -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0xdcd1b
jmp 0xdcdc6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x165470
movq %rax, -0x20(%rbp)
cmpq $0x50414c54, -0x20(%rbp) # imm = 0x50414C54
je 0xdcd5f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdf1d4(%rip), %rsi     # 0x1bbf1f
movb $0x0, %al
callq 0x15bc10
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
jmp 0xdcdc6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq 0xdf1d9(%rip), %rsi     # 0x1bbf49
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), %rsi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
movq -0x10(%rbp), %rcx
addq $0x2c, %rcx
movl $0x10, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
callq 0x174460
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: do_sprite_param_blocks
static void do_sprite_param_blocks(deark *c, lctx *d, i64 res,
	i64 nsprites, i64 pos)
{
	i64 k;
	de_dbg(c, "%s-res sprite param blocks at %d", sprite_res_name[res],
		(int)pos);

	de_dbg_indent(c, 1);
	for(k=0; k<nsprites; k++) {
		do_sprite_param_block(c, d, res, k, pos, pos + 8*k);
	}
	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), %rcx
leaq 0x148a45(%rip), %rax    # 0x225840
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
leaq 0xdf152(%rip), %rsi     # 0x1bbf5e
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0xdce69
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r9
callq 0xdce80
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xdce29
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: render_stos_pictbank1
static void render_stos_pictbank1(deark *c, lctx *d, struct pkpic_ctx *pp,
	dbuf *unc_pixels, de_bitmap *img, UI num_planes)
{
	struct pictbank_params *pb;

	pb = de_malloc(c, sizeof(struct pictbank_params));
	pb->num_planes = num_planes;
	pb->bits_per_pixel = pb->num_planes;
	pb->width_in_bytes = pp->width_in_words * 2;
	pb->height_in_lumps = pp->height_in_lumps;
	pb->lines_per_lump = pp->lines_per_lump;
	pb->pseudoheight = pp->pseudoheight;
	pb->unc_pixels = unc_pixels;
	pb->img = img;
	pb->pal = d->pal;

	if(pp->imgtype==PKPIC_IMGTYPE_PP1) {
		render_stos_pp1(c, pb);
	}
	else if(pp->imgtype==PKPIC_IMGTYPE_PP3) {
		render_stos_pp3(c, pb, pp->width_in_words);
	}
	else if(pp->imgtype==PKPIC_IMGTYPE_M4P) {
		render_stos_med4plane(c, pb);
	}
	else {
		render_stos_pictbank_std(c, pb);
	}

	de_free(c, pb);
}

// 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)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x15b780
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
addq $0x2c, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpl $0x6e, 0x4(%rax)
jne 0xdd32e
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xdd390
jmp 0xdd379
movq -0x18(%rbp), %rax
cmpl $0x70, 0x4(%rax)
jne 0xdd34f
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xdd600
jmp 0xdd377
movq -0x18(%rbp), %rax
cmpl $0x78, 0x4(%rax)
jne 0xdd368
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xdd830
jmp 0xdd375
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xdda90
jmp 0xdd377
jmp 0xdd379
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x15b820
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mbk.c
// Function: is_stos_packedscreen
static int is_stos_packedscreen(deark *c, UI *res)
{
	u8 buf[24];
	u8 is_mbk = 0;
	UI id = 0;
	UI field14;
	UI field18;
	i64 bpos = 0;

	*res = 0;
	de_read(buf, 0, sizeof(buf));

	if(!de_memcmp(buf, g_lion_sig, 10)) is_mbk = 1;
	if(is_mbk) {
		if((UI)de_getu32be_direct(&buf[10]) == 0) return 0; // screen out MBS
		if(buf[14] != 0x81) return 0; // must be type 'data'
		bpos = 18;
	}

	id = (UI)de_getu32be_direct(&buf[bpos]);
	if(id!=BANKID_PKSCREEN) return 0;
	*res = (UI)de_getu16be_direct(&buf[bpos+4]);
	if(*res > 2) return 0;

	field14 = (UI)de_getu16be_direct(&buf[bpos+14]);
	if(field14>=1 && field14<=6) {
		// It's likely that this is the AMOS format, not the STOS format.
		field18 = (UI)de_getu16be_direct(&buf[bpos+18]);
		// Expecting STOS flags to be small
		if(field18>=8) return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x18, %ecx
callq 0x164d10
leaq -0x30(%rbp), %rdi
movq 0x147b0e(%rip), %rsi    # 0x225830
movl $0xa, %edx
callq 0x19170
cmpl $0x0, %eax
jne 0xddd35
movb $0x1, -0x31(%rbp)
cmpb $0x0, -0x31(%rbp)
je 0xddd78
leaq -0x30(%rbp), %rdi
addq $0xa, %rdi
callq 0x165430
cmpl $0x0, %eax
jne 0xddd59
movl $0x0, -0x4(%rbp)
jmp 0xdde1d
movzbl -0x22(%rbp), %eax
cmpl $0x81, %eax
je 0xddd70
movl $0x0, -0x4(%rbp)
jmp 0xdde1d
movq $0x12, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
addq -0x48(%rbp), %rdi
callq 0x165430
movl %eax, -0x38(%rbp)
cmpl $0x6071963, -0x38(%rbp) # imm = 0x6071963
je 0xddd9d
movl $0x0, -0x4(%rbp)
jmp 0xdde1d
movq -0x48(%rbp), %rax
addq $0x4, %rax
leaq -0x30(%rbp), %rdi
addq %rax, %rdi
callq 0x1651b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0xdddcb
movl $0x0, -0x4(%rbp)
jmp 0xdde1d
movq -0x48(%rbp), %rax
addq $0xe, %rax
leaq -0x30(%rbp), %rdi
addq %rax, %rdi
callq 0x1651b0
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x3c(%rbp)
jb 0xdde16
cmpl $0x6, -0x3c(%rbp)
ja 0xdde16
movq -0x48(%rbp), %rax
addq $0x12, %rax
leaq -0x30(%rbp), %rdi
addq %rax, %rdi
callq 0x1651b0
movl %eax, -0x40(%rbp)
cmpl $0x8, -0x40(%rbp)
jb 0xdde14
movl $0x0, -0x4(%rbp)
jmp 0xdde1d
jmp 0xdde16
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/mmm.c
// Function: de_module_mmm
void de_module_mmm(deark *c, struct deark_module_info *mi)
{
	mi->id = "mmm";
	mi->desc = "RIFF Multimedia Movie";
	mi->run_fn = de_run_mmm;
	mi->identify_fn = de_identify_mmm;
	mi->help_fn = de_help_mmm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xde379(%rip), %rcx     # 0x1bc1c0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xde36f(%rip), %rcx     # 0x1bc1c4
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xdde90
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x2ed(%rip), %rcx       # 0xde160
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x33e(%rip), %rcx       # 0xde1c0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: read_alt_palette_file
static int read_alt_palette_file(deark *c, struct mmm_ctx *d)
{
	dbuf *palfile = NULL;
	struct de_iffctx *ictx = NULL;
	const char *palfn;
	int retval = 1;

	palfn = de_get_ext_option(c, "file2");
	if(!palfn) {
		goto done;
	}

	d->use_alt_palfile = 1;
	palfile = dbuf_open_input_file(c, palfn);
	if(!palfile) {
		retval = 0;
		goto done;
	}

	ictx = fmtutil_create_iff_decoder(c);
	setup_ictx_for_mmm(c, d, ictx);
	ictx->f = palfile;

	d->pass = 100;
	de_dbg(c, "reading alt pal file");
	de_dbg_indent(c, 1);
	fmtutil_read_iff_format(ictx, 0, palfile->len);
	de_dbg_indent(c, -1);

	if(!d->have_pal) {
		if(d->force_pal) {
			de_err(c, "Palette %d not found", d->pal_id_to_use);
		}
		else {
			de_err(c, "No palette found");
		}
		retval = 0;
		goto done;
	}

done:
	fmtutil_destroy_iff_decoder(ictx);
	dbuf_close(palfile);

	// (hack) Reset some things that this function isn't supposed to change.
	d->errflag = 0;
	d->clut_count = 0;
	d->dib_count = 0;

	return retval;
}

// 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)
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbe336(%rip), %rsi     # 0x19c578
callq 0x15cb30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xde257
jmp 0xde346
movq -0x10(%rbp), %rax
movb $0x1, 0x5(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x168de0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xde283
movl $0x0, -0x2c(%rbp)
jmp 0xde346
movq -0x8(%rbp), %rdi
callq 0x18c8b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xde380
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x64, (%rax)
movq -0x8(%rbp), %rdi
leaq 0xddfa7(%rip), %rsi     # 0x1bc269
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x18c920
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movq -0x10(%rbp), %rax
cmpb $0x0, 0x20(%rax)
jne 0xde344
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0xde329
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdded1(%rip), %rsi     # 0x1bc1f1
movb $0x0, %al
callq 0x15bfb0
jmp 0xde33b
movq -0x8(%rbp), %rdi
leaq 0xddf4a(%rip), %rsi     # 0x1bc27e
movb $0x0, %al
callq 0x15bfb0
movl $0x0, -0x2c(%rbp)
jmp 0xde346
jmp 0xde346
movq -0x20(%rbp), %rdi
callq 0x18c8f0
movq -0x18(%rbp), %rdi
callq 0x1676a0
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: setup_ictx_for_mmm
static void setup_ictx_for_mmm(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx)
{
	ictx->userdata = (void*)d;
	ictx->is_le = 1;
	ictx->handle_chunk_fn = my_mmm_chunk_handler;
	ictx->handle_nonchunk_data_fn = my_mmm_handle_nonchunk_data_fn;
	ictx->preprocess_chunk_fn = my_preprocess_mmm_chunk_fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x58(%rax)
movq -0x18(%rbp), %rax
leaq 0x5e(%rip), %rcx        # 0xde410
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x31f(%rip), %rcx       # 0xde6e0
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
leaq 0x3b0(%rip), %rcx       # 0xde780
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: my_mmm_handle_nonchunk_data_fn
static int my_mmm_handle_nonchunk_data_fn(struct de_iffctx *ictx,
	i64 pos, i64 *plen)
{
	u8 buf[6];

	dbuf_read(ictx->f, buf, pos, sizeof(buf));

	if(buf[0]<65 || buf[1]<65) {
		if(looks_like_a_4cc_b(&buf[2])) {
			*plen = 2;
			de_dbg(ictx->c, "[%"I64_FMT" non-RIFF bytes at %"I64_FMT"]", *plen, pos);
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x26(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %ecx
callq 0x164d10
movzbl -0x26(%rbp), %eax
cmpl $0x41, %eax
jl 0xde720
movzbl -0x25(%rbp), %eax
cmpl $0x41, %eax
jge 0xde768
leaq -0x26(%rbp), %rdi
addq $0x2, %rdi
callq 0xdf9c0
cmpl $0x0, %eax
je 0xde766
movq -0x20(%rbp), %rax
movq $0x2, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0xddc67(%rip), %rsi     # 0x1bc3bd
movb $0x0, %al
callq 0x15b0d0
movl $0x1, -0x4(%rbp)
jmp 0xde76f
jmp 0xde768
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: my_preprocess_mmm_chunk_fn
static int my_preprocess_mmm_chunk_fn(struct de_iffctx *ictx)
{
	size_t k;
	struct mmmnames_struct {
		u32 id1, id2;
		const char *name;
	};
	static const struct mmmnames_struct mmmnames[] = {
		{ CODE_CFTC, CODE_cftc, "table of contents" },
		{ CODE_CLUT, CODE_clut, "palette" },
		{ CODE_DIB,  CODE_dib,  "bitmap" },
		{ CODE_McNm, CODE_mcnm, "movie name" },
		{ CODE_SCVW, CODE_scvw, "director score" },
		{ CODE_snd,  CODE_snd,  "sound resource" },
		{ CODE_STR,  CODE_str,  "string table" },
		{ CODE_STXT, CODE_stxt, "styled text" },
		{ CODE_Ver_, CODE_ver,  "converter version" },
		{ CODE_VWAC, CODE_vwac, "script commands" },
		{ CODE_VWCF, CODE_vwcf, "movie config" },
		{ CODE_VWCR, CODE_vwcr, "cast record array" },
		{ CODE_VWFM, CODE_vwfm, "font mapping" },
		{ CODE_VWLB, CODE_vwlb, "label list" },
		{ CODE_VWSC, CODE_vwsc, "movie score" },
		{ CODE_VWtc, CODE_vwtc, "timecode" },
		{ CODE_VWTL, CODE_vwtl, "pixel pattern tile" }
		// Other known chunks: VWFI vwfi VWCI vwci
		// crsr CURS FOND fwst
		// icl4 icl8 ICN# ics# ics4 ics8
		// NFNT pict vers XCMD XCOD XFCN
	};

	for(k=0; k<DE_ARRAYCOUNT(mmmnames); k++) {
		if((ictx->chunkctx->chunk4cc.id == mmmnames[k].id1) ||
			(ictx->chunkctx->chunk4cc.id == mmmnames[k].id2))
		{
			ictx->chunkctx->chunk_name = mmmnames[k].name;
			break;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x11, -0x10(%rbp)
jae 0xde81e
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rdx
leaq 0x13ce2c(%rip), %rcx    # 0x21b5e0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
je 0xde7e4
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rdx
leaq 0x13ce08(%rip), %rcx    # 0x21b5e0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0xde80b
movq -0x10(%rbp), %rcx
leaq 0x13cdf1(%rip), %rax    # 0x21b5e0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rcx, 0x58(%rax)
jmp 0xde81e
jmp 0xde80d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xde790
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: do_mmm_cftc
static void do_mmm_cftc(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx,
	i64 dpos1, i64 dlen)
{
	i64 nentries;
	i64 i;
	i64 pos;
	struct de_fourcc tmp4cc;

	if(dlen<4) goto done;
	nentries = (dlen-4)/16;

	pos = dpos1+4;
	for(i=0; i<nentries; i++) {
		int chk_id;
		i64 chk_pos;
		i64 chk_dlen;
		de_zeromem(&tmp4cc, sizeof(struct de_fourcc));
		dbuf_read_fourcc(ictx->f, pos, &tmp4cc, 4, 0);
		pos += 4;
		if(tmp4cc.id==0) break;
		chk_dlen = dbuf_getu32le_p(ictx->f, &pos);
		chk_id = (int)dbuf_geti32le_p(ictx->f, &pos);
		chk_pos = dbuf_getu32le_p(ictx->f, &pos);
		de_dbg(c, "toc entry '%s' id=%d pos=%"I64_FMT" dlen=%"I64_FMT,
			tmp4cc.id_sanitized_sz, chk_id, chk_pos, chk_dlen);
	}

done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jge 0xde8ab
jmp 0xde9a0
movq -0x28(%rbp), %rax
subq $0x4, %rax
movl $0x10, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0xde99e
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19140
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x169860
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x6c(%rbp)
jne 0xde924
jmp 0xde99e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x165580
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x165670
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x165580
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
addq $0x8, %rdx
movl -0x74(%rbp), %ecx
movq -0x80(%rbp), %r8
movq -0x88(%rbp), %r9
leaq 0xdd909(%rip), %rsi     # 0x1bc28f
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xde8d5
jmp 0xde9a0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: mmm_read_name_p
static void mmm_read_name_p(deark *c, struct mmm_ctx *d, struct de_iffctx *ictx,
	i64 *ppos, const char *name)
{
	i64 pos = *ppos;
	i64 namelen;

	ucstring_empty(d->tmp_namestr);
	namelen = (i64)dbuf_getbyte(ictx->f, pos);
	if(namelen) {
		dbuf_read_to_ucstring(ictx->f, pos+1, namelen, d->tmp_namestr, 0, d->input_encoding);
		de_dbg(c, "%s: \"%s\"", (name ? name : "name"), ucstring_getpsz_d(d->tmp_namestr));
	}
	*ppos += de_pad_to_2(1+namelen);
}

// 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 -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x171210
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x165060
movzbl %al, %eax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdf757
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r9d
xorl %r8d, %r8d
callq 0x1669f0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xdf71c
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xdf729
leaq 0xd48cb(%rip), %rax     # 0x1b3fee
movq %rax, -0x48(%rbp)
jmp 0xdf729
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x172650
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0xd84b6(%rip), %rsi     # 0x1b7c06
movb $0x0, %al
callq 0x15b0d0
movq -0x38(%rbp), %rdi
addq $0x1, %rdi
callq 0x15cdf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: mmm_default_pal16
static void mmm_default_pal16(deark *c, struct mmm_ctx *d)
{
	de_make_grayscale_palette(d->pal, 16, 0);
	d->have_pal = 1;

	// TODO: Figure out if there is a default 16-color palette.
	if(d->opt_allowbad) {
		de_warn(c, "No palette found. Colors will be wrong.");
	}
	else {
		de_err(c, "No palette found");
		mmm_allowbad_note(c);
		d->errflag = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x16d580
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0xdf7ca
movq -0x8(%rbp), %rdi
leaq 0xdcb41(%rip), %rsi     # 0x1bc302
movb $0x0, %al
callq 0x15bc10
jmp 0xdf7ed
movq -0x8(%rbp), %rdi
leaq 0xdcaa9(%rip), %rsi     # 0x1bc27e
movb $0x0, %al
callq 0x15bfb0
movq -0x8(%rbp), %rdi
callq 0xde3e0
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mmm.c
// Function: looks_like_a_4cc_b
static int looks_like_a_4cc_b(const u8 *buf)
{
	i64 i;

	for(i=0; i<4; i++) {
		if(buf[i]<32 || buf[i]>126) return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jge 0xdfa12
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jl 0xdf9f9
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x7e, %eax
jle 0xdfa02
movl $0x0, -0x4(%rbp)
jmp 0xdfa19
jmp 0xdfa04
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xdf9d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_module_apetag
void de_module_apetag(deark *c, struct deark_module_info *mi)
{
	mi->id = "apetag";
	mi->desc = "APE tag";
	mi->run_fn = de_run_apetag;
	mi->identify_fn = NULL;
	mi->flags |= DE_MODFLAG_HIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xdcc39(%rip), %rcx     # 0x1bc670
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xdcc32(%rip), %rcx     # 0x1bc677
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x2c(%rip), %rcx        # 0xdfa80
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_run_apetag
static void de_run_apetag(deark *c, de_module_params *mparams)
{
	i64 endpos;
	i64 bytes_consumed = 0;

	// The calling module should provide a slice that starts at the beginning
	// of the file, and ends at the end of the APE tag (which is often, but
	// not always, the end of the file).
	// This does not very flexible, but it can be improved if need be.

	// If we successfully process an APE tag, we set the
	// 0x1 bit of mparams->out_params.flags, and set
	// mparams->out_params.int64_1 to the total size of the APE tag.

	endpos = c->infile->len;

	if(!do_ape_tag_internal(c, endpos, &bytes_consumed)) goto done;
	if(mparams) {
		mparams->out_params.flags = 0x1;
		mparams->out_params.int64_1 = bytes_consumed;
	}
done:
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xe0000
cmpl $0x0, %eax
jne 0xdfac0
jmp 0xdfae0
cmpq $0x0, -0x10(%rbp)
je 0xdfade
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0xdfae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_module_mpegaudio
void de_module_mpegaudio(deark *c, struct deark_module_info *mi)
{
	mi->id = "mpegaudio";
	mi->id_alias[0] = "mp3";
	mi->desc = "MP3 / MPEG audio";
	mi->run_fn = de_run_mpegaudio;
	mi->identify_fn = de_identify_mpegaudio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xdcb78(%rip), %rcx     # 0x1bc67f
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xdcb74(%rip), %rcx     # 0x1bc689
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0xdcb69(%rip), %rcx     # 0x1bc68d
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d(%rip), %rcx        # 0xdfb50
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xfe(%rip), %rcx        # 0xdfc40
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_run_mpegaudio
static void de_run_mpegaudio(deark *c, de_module_params *mparams)
{
	mp3ctx *d = NULL;
	i64 pos;
	i64 endpos;
	i64 ape_tag_len;
	struct de_id3info id3i;

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

	fmtutil_handle_id3(c, c->infile, &id3i, 0);
	d->has_id3v2 = id3i.has_id3v2;
	pos = id3i.main_start;
	endpos = id3i.main_end;

	if(!id3i.has_id3v2) {
		if(!dbuf_memcmp(c->infile, endpos-10, "3DI", 3)) {
			de_warn(c, "Possible ID3v2 tag found at end of file (footer at %"I64_FMT"). "
				"This is not supported.", endpos-10);
		}
	}

	do_ape_tag_if_exists(c, endpos, &ape_tag_len);
	endpos -= ape_tag_len;

	do_mp3_data(c, d, pos, endpos-pos);

	de_free(c, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x34, %esi
callq 0x15b780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x48(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1753e0
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0xdfbf2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
subq $0xa, %rsi
leaq 0xdcc0a(%rip), %rdx     # 0x1bc7d1
movl $0x3, %ecx
callq 0x166ab0
cmpl $0x0, %eax
jne 0xdfbf0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
subq $0xa, %rdx
leaq 0xdcbec(%rip), %rsi     # 0x1bc7d5
movb $0x0, %al
callq 0x15bc10
jmp 0xdfbf2
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe09d0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
callq 0xe0af0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15b820
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_module_monkeys_audio
void de_module_monkeys_audio(deark *c, struct deark_module_info *mi)
{
	mi->id = "monkeys_audio";
	mi->desc = "Monkey's Audio (.ape)";
	mi->run_fn = de_run_monkeys_audio;
	mi->identify_fn = de_identify_monkeys_audio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xdc817(%rip), %rcx     # 0x1bc69e
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xdc817(%rip), %rcx     # 0x1bc6ac
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x1c(%rip), %rcx        # 0xdfec0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xad(%rip), %rcx        # 0xdff60
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: de_run_monkeys_audio
static void de_run_monkeys_audio(deark *c, de_module_params *mparams)
{
	i64 endpos = c->infile->len;

	if(is_apetag_sig_at(c->infile, endpos-32)) {
		de_dbg(c, "APE tag found, ending at %"I64_FMT, endpos);
		de_dbg_indent(c, 1);
		de_run_module_by_id_on_slice2(c, "apetag", 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 -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
subq $0x20, %rsi
callq 0xe00e0
cmpl $0x0, %eax
je 0xdff50
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xdc91c(%rip), %rsi     # 0x1bc825
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 0xdc73b(%rip), %rsi     # 0x1bc670
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x15cab0
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/mp3.c
// Function: de_identify_monkeys_audio
static int de_identify_monkeys_audio(deark *c)
{
	unsigned int n;

	if(dbuf_memcmp(c->infile, 0, "MAC ", 4)) return 0;
	n = (unsigned int)de_getu16le(6);
	if(ma_is_known_cmpr(n)) return 100;
	n = (unsigned int)de_getu16le(52);
	if(ma_is_known_cmpr(n)) 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 0xdcb8c(%rip), %rdx     # 0x1bcb0b
movl $0x4, %ecx
callq 0x166ab0
cmpl $0x0, %eax
je 0xdff97
movl $0x0, -0x4(%rbp)
jmp 0xdfff4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x6, %esi
callq 0x165280
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xe1430
cmpl $0x0, %eax
je 0xdffc2
movl $0x64, -0x4(%rbp)
jmp 0xdfff4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x34, %esi
callq 0x165280
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xe1430
cmpl $0x0, %eax
je 0xdffed
movl $0x64, -0x4(%rbp)
jmp 0xdfff4
movl $0x0, -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/mp3.c
// Function: do_ape_tag_internal
static int do_ape_tag_internal(deark *c, i64 endpos, i64 *ape_tag_bytes_consumed)
{
	struct ape_tag_header_footer *af = NULL;
	i64 footer_startpos = endpos - 32;
	int retval = 0;

	if(!is_apetag_sig_at(c->infile, footer_startpos)) {
		de_warn(c, "Expected APE tag footer not found at %"I64_FMT, footer_startpos);
		goto done;
	}
	af = de_malloc(c, sizeof(struct ape_tag_header_footer));
	if(!do_ape_tag_header_or_footer(c, af, footer_startpos, 1)) goto done;
	*ape_tag_bytes_consumed = af->tag_size_total;

	do_ape_item_list(c, af, af->items_startpos, af->tag_size_raw - 32);

	retval = 1;
done:
	de_free(c, af);
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xe00e0
cmpl $0x0, %eax
jne 0xe005d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xdc66e(%rip), %rsi     # 0x1bc6c2
movb $0x0, %al
callq 0x15bc10
jmp 0xe00c3
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x15b780
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0xe0120
cmpl $0x0, %eax
jne 0xe008c
jmp 0xe00c3
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x20, %rcx
callq 0xe0380
movl $0x1, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15b820
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: do_ape_item_list
static void do_ape_item_list(deark *c, struct ape_tag_header_footer *ah,
	i64 pos1, i64 len)
{
	i64 pos = pos1;

	de_dbg(c, "APE items at %"I64_FMT", len=%"I64_FMT, pos1, len);
	de_dbg_indent(c, 1);
	while(1) {
		i64 bytes_consumed = 0;

		if(pos >= pos1+len) break;
		if(!do_ape_item(c, ah, pos, pos1+len-pos, &bytes_consumed)) {
			goto done;
		}
		if(bytes_consumed<1) goto done;

		pos += bytes_consumed;
	}
done:
	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 -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xdc3a9(%rip), %rsi     # 0x1bc75c
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jl 0xe03e3
jmp 0xe0422
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0xe0440
cmpl $0x0, %eax
jne 0xe040b
jmp 0xe0424
cmpq $0x1, -0x30(%rbp)
jge 0xe0414
jmp 0xe0424
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xe03c8
jmp 0xe0424
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: get_ape_item_type_name
static const char *get_ape_item_type_name(unsigned int t)
{
	const char *name;

	switch(t) {
	case 0: name = "UTF-8 text"; break;
	case 1: name = "binary"; break;
	case 2: name = "locator"; break;
	default: name = "?";
	}
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0xe06f7
jmp 0xe06e3
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0xe0704
jmp 0xe06ed
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xe0711
jmp 0xe071e
leaq 0xdc0ac(%rip), %rax     # 0x1bc7aa
movq %rax, -0x10(%rbp)
jmp 0xe0729
leaq 0xeb8ed(%rip), %rax     # 0x1cbff8
movq %rax, -0x10(%rbp)
jmp 0xe0729
leaq 0xdc09d(%rip), %rax     # 0x1bc7b5
movq %rax, -0x10(%rbp)
jmp 0xe0729
leaq 0xd7508(%rip), %rax     # 0x1b7c2d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: do_ape_text_item
static void do_ape_text_item(deark *c, struct ape_tag_header_footer *ah,
   i64 pos, i64 len)
{
	de_encoding encoding;
	de_ucstring *s = NULL;

	encoding = (ah->ape_ver>=2000)?DE_ENCODING_UTF8:DE_ENCODING_ASCII;
	s = ucstring_create(c);
	dbuf_read_to_ucstring_n(c->infile, pos, len, DE_DBG_MAX_STRLEN,
		s, 0, encoding);
	de_dbg(c, "value: \"%s\"", ucstring_getpsz(s));
	ucstring_destroy(s);
}

// 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 $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x7d0, %edx            # imm = 0x7D0
cmovael %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1711d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movl -0x24(%rbp), %eax
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x166a40
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x172500
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xbe06c(%rip), %rsi     # 0x19e82b
movb $0x0, %al
callq 0x15b0d0
movq -0x30(%rbp), %rdi
callq 0x171750
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: do_ape_tag_if_exists
static int do_ape_tag_if_exists(deark *c, i64 endpos, i64 *ape_tag_bytes_consumed)
{
	i64 footer_startpos;
	de_module_params *mparams = NULL;
	int saved_indent_level;
	int retval = 0;

	de_dbg_indent_save(c, &saved_indent_level);
	*ape_tag_bytes_consumed = 0;

	footer_startpos = endpos-32;
	if(!is_apetag_sig_at(c->infile, footer_startpos)) {
		goto done;
	}

	de_dbg(c, "APE tag found, ending at %"I64_FMT, endpos);
	de_dbg_indent(c, 1);
	mparams = de_malloc(c, sizeof(de_module_params));
	de_run_module_by_id_on_slice(c, "apetag", mparams, c->infile, 0, endpos);
	if(mparams->out_params.flags & 0x1) {
		// apetag module told us the size of the APE tag data.
		*ape_tag_bytes_consumed = mparams->out_params.int64_1;
	}
	else {
		goto done;
	}
	de_dbg_indent(c, -1);

	retval = 1;
done:
	de_free(c, mparams);
	de_dbg_indent_restore(c, saved_indent_level);
	return retval;
}

// 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)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x15b580
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xe00e0
cmpl $0x0, %eax
jne 0xe0a32
jmp 0xe0ac4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xdbde4(%rip), %rsi     # 0x1bc825
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movl $0x70, %esi
callq 0x15b780
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %r9
leaq 0xdbbed(%rip), %rsi     # 0x1bc670
xorl %eax, %eax
movl %eax, %r8d
callq 0x15c9f0
movq -0x28(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xe0aad
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe0aaf
jmp 0xe0ac4
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
movl $0x1, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x15b820
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x15b5a0
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/modules/mp3.c
// Function: do_mp3_data
static void do_mp3_data(deark *c, mp3ctx *d, i64 pos1, i64 len)
{
	de_dbg(c, "MP3/MPA data at %"I64_FMT", len=%"I64_FMT, pos1, len);
	de_dbg_indent(c, 1);
	do_mp3_frame(c, d, pos1, len);
	// TODO: There are probably many frames. Should we look for more frames
	// (in some cases?)?
	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 %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xdbd27(%rip), %rsi     # 0x1bc842
movb $0x0, %al
callq 0x15b0d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x15b560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xe0b60
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15b560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)