LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_setpt1
int op_setpt1 (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    last_reg_index = op->srcindex + *(uint16_t *) &d[1];
    if (last_reg_index == INDEX_REG_MM && opt_reg_addresses)
	addrtypes_shift[D_REG] = 2;
    else
	addrtypes_shift[D_REG] = 0;
    return op_1x16 (d, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d850(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x1(%rcx), %ecx
addl %ecx, %eax
movl %eax, 0x60ba2(%rip)     # 0x65144
cmpl $0x5, 0x60b9b(%rip)     # 0x65144
jne 0x45c0
cmpl $0x0, 0x60b9a(%rip)     # 0x6514c
je 0x45c0
movl $0x2, 0x60b32(%rip)     # 0x650f0
jmp 0x45ca
movl $0x0, 0x60b26(%rip)     # 0x650f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_setpt0
int op_setpt0 (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    last_reg_index = op->srcindex;
    /* is never INDEX_REG_MM */
    addrtypes_shift[D_REG] = 0;
    return op_0x (d, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d7d0(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x60b2c(%rip)     # 0x65144
movl $0x0, 0x60ace(%rip)     # 0x650f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_src
int op_src (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    uint8_t       *t    = d+1;
    int            attr = *t++;
    out += sprintf (out, "%-5s  ", op->name);
    t   += sub_src (t, out, attr & 0x07, (attr & 0x38) >> 3, size_align[(attr & 0x38)>>3], op->srcindex);
    return t - d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d710(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x47d5a(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
andl $0x7, %edx
movl -0x24(%rbp), %ecx
andl $0x38, %ecx
sarl $0x3, %ecx
movl -0x24(%rbp), %eax
andl $0x38, %eax
sarl $0x3, %eax
movslq %eax, %r8
leaq 0x479b0(%rip), %rax     # 0x4c0f0
movl (%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl 0x14(%rax), %r9d
callq 0x54f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_1x16
int op_1x16 (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    const char    *ind;
    out += sprintf (out, "%-5s  ", op->name);
    out += sprintf (out, addrtypes [op->desttype],
		    (*(uint16_t *) &d[1]) << addrtypes_shift [op->desttype]);
    if ( (ind = get_index (op->destindex, d[1])) )
	out += sprintf (out, "  (%s)", ind);
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d370(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x479db(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x5f6c8(%rip), %rax     # 0x64170
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzwl 0x1(%rax), %edx
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x6062d(%rip), %rax     # 0x650f0
movl (%rax,%rcx,4), %ecx
shll %cl, %edx
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x4b6b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4b23
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x47add(%rip), %rsi     # 0x4c5e9
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_1x8
int op_1x8 (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    const char    *ind;
    out += sprintf (out, "%-5s  ", op->name);
    out += sprintf (out, addrtypes [op->desttype],
		    d[1] << addrtypes_shift [op->desttype]);
    if ( (ind = get_index (op->destindex, d[1])) )
	out += sprintf (out, "  (%s)", ind);
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d280(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x478eb(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x5f5d8(%rip), %rax     # 0x64170
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %edx
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x6053d(%rip), %rax     # 0x650f0
movl (%rax,%rcx,4), %ecx
shll %cl, %edx
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x4b6b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4c13
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x479ed(%rip), %rsi     # 0x4c5e9
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_dest
int op_dest (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    uint8_t *t    = d+1;
    int      attr = *t++;
    out += sprintf  (out, "%-5s  ", op->name);
    t   += sub_src (t, out, op->desttype, (attr & 0x38) >> 3, size_align[(attr & 0x38)>>3], op->destindex);
    return t - d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d190(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x477da(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movl -0x24(%rbp), %ecx
andl $0x38, %ecx
sarl $0x3, %ecx
movl -0x24(%rbp), %eax
andl $0x38, %eax
sarl $0x3, %eax
movslq %eax, %r8
leaq 0x4742f(%rip), %rax     # 0x4c0f0
movl (%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %r9d
callq 0x54f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_sdb
int op_sdb (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    const char    *ind;
    out += sprintf (out, "%-5s  ", op->name);
    out += sprintf (out, addrtypes [op->desttype],
		    d[1] << addrtypes_shift [op->desttype]);
    if (d[1] == 0xff)
	out += sprintf (out, "  (this table)");
    else if ( (ind = get_index (op->destindex, d[1])) )
	out += sprintf (out, "  (%s)", ind);
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5ce90(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x474fb(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x5f1e8(%rip), %rax     # 0x64170
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %edx
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x6014d(%rip), %rax     # 0x650f0
movl (%rax,%rcx,4), %ecx
shll %cl, %edx
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xff, %eax
jne 0x4ff2
movq -0x10(%rbp), %rdi
leaq 0x47444(%rip), %rsi     # 0x4c41d
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x5038
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x4b6b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5036
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x475ca(%rip), %rsi     # 0x4c5e9
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x5038
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_ds
int op_ds (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    uint16_t size = *(uint16_t *) &d[1];
    /* Multiline, because even the hexdump typically needs lots of space */
    out += sprintf (out, "\n                          %-5s  %d bytes", op->name, size);
    return size + 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5cd60(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movw 0x1(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movzwl -0x1a(%rbp), %ecx
leaq 0x47355(%rip), %rsi     # 0x4c3f3
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movzwl -0x1a(%rbp), %eax
addl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: get_pointers
bios_tables_t *get_pointers (uint8_t *data)
{
    static bios_tables_t tabs;		/* FIXME: */

    tabs.base = data;
    tabs.AtomRomHeader = (ATOM_ROM_HEADER *) (data + *(uint16_t *) (data + OFFSET_TO_POINTER_TO_ATOM_ROM_HEADER));
    if (strcmp ((char *) tabs.AtomRomHeader->uaFirmWareSignature, "ATOM") != 0) {
	fprintf (stderr, "No AtomBIOS\n");
	exit (1);
    }
    tabs.MasterCommandTables = (uint16_t *)
	& ((ATOM_MASTER_COMMAND_TABLE *)
	   (data + tabs.AtomRomHeader->usMasterCommandTableOffset))
	->ListOfCommandTables;
    tabs.MasterDataTables    = (uint16_t *)
	& ((ATOM_MASTER_DATA_TABLE *)
	   (data + tabs.AtomRomHeader->usMasterDataTableOffset))
	->ListOfDataTables;
    
    return &tabs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x60039(%rip)     # 0x65120
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movzwl 0x48(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x60028(%rip)     # 0x65128
movq 0x60021(%rip), %rdi     # 0x65128
addq $0x4, %rdi
leaq 0x47275(%rip), %rsi     # 0x4c387
callq 0x4110
cmpl $0x0, %eax
je 0x513e
movq 0x5eed5(%rip), %rax     # 0x63ff8
movq (%rax), %rdi
leaq 0x4725f(%rip), %rsi     # 0x4c38c
movb $0x0, %al
callq 0x4130
movl $0x1, %edi
callq 0x41c0
movq -0x8(%rbp), %rax
movq 0x5ffdf(%rip), %rcx     # 0x65128
movzwl 0x1e(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x4, %rax
movq %rax, 0x5ffd2(%rip)     # 0x65130
movq -0x8(%rbp), %rax
movq 0x5ffbf(%rip), %rcx     # 0x65128
movzwl 0x20(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x4, %rax
movq %rax, 0x5ffba(%rip)     # 0x65138
leaq 0x5ff9b(%rip), %rax     # 0x65120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: get_table_offset
int get_table_offset(uint16_t *table, int idx) {
    int i, last = 0, offset = 0;
    static int wrapwarning = 0;

    if (! table || ! table[idx])
	return 0;

    for (i = 0; i <= idx; i++) {
	int off = table[i];
	if (off) {
	    if (off < last)
		offset += 0x10000;
	    last = off - 0x8000;
	}
    }

    if (offset && ! wrapwarning++)
	printf ("*** Wrap around of table offset - assuming offset\n");
    return table[idx] + offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x51c3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpw $0x0, (%rax,%rcx,2)
jne 0x51cf
movl $0x0, -0x4(%rbp)
jmp 0x525a
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x521e
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5211
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5206
movl -0x20(%rbp), %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x1c(%rbp)
jmp 0x5213
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x51d6
cmpl $0x0, -0x20(%rbp)
je 0x5248
movl 0x5ff16(%rip), %eax     # 0x65140
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x5ff0b(%rip)     # 0x65140
cmpl $0x0, %eax
jne 0x5248
leaq 0x47158(%rip), %rdi     # 0x4c399
movb $0x0, %al
callq 0x4090
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: do_info
void do_info (bios_tables_t *tabs)
{
    fprintf (stdout,
	     "Table Format Rev.   %02x\n"
	     "Table Content Rev.  %02x\n"
	     "BIOS Boot Message:  '%s'\n"
	     "Subsystem Vendor ID %04x\n"
	     "Subsystem ID        %04x\n\n",
	     tabs->AtomRomHeader->sHeader.ucTableFormatRevision,
	     tabs->AtomRomHeader->sHeader.ucTableContentRevision,
	     (char *) (tabs->base + tabs->AtomRomHeader->usBIOS_BootupMessageOffset),
	     tabs->AtomRomHeader->usSubsystemVendorID,
	     tabs->AtomRomHeader->usSubsystemID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5e85d(%rip), %rax     # 0x63fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x2(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x3(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x10(%rax), %eax
cltq
addq %rax, %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x18(%rax), %r9d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x1a(%rax), %eax
leaq 0x46cef(%rip), %rsi     # 0x4c4a5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: do_data
void do_data (uint8_t *data, int off, int nr)
{
    int len;
    const char *comment = NULL;
    int frev = data[off+2];
    int crev = data[off+3];
    data_dumper_t *dt = get_data_dumper (nr, &frev, &crev, &comment);

    if (! dt)
	return;
    if (frev == 0)
	fprintf (stdout, "  NOTE: General revisionless dumper only.\n");
    else if (frev != data[off+2] || crev != data[off+3])
	fprintf (stdout, "  NOTE: Dumper revision differs.   "
		 "Used:   Format Rev. %02x  Content Rev. %02x\n", frev, crev);
    if (comment)
	fprintf (stdout, "  NOTE: %s\n", comment);
    if (frev == 0 || frev != data[off+2] || crev != data[off+3] || comment)
	fputs ("\n", stdout);
    len = (*dt) (data+off, data+off, 1);
    fprintf (stdout, "\n  Total data structure size:  %04x\n\n", len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x10(%rbp), %edi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x4b5c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5e76
jmp 0x5f9b
cmpl $0x0, -0x24(%rbp)
jne 0x5e96
movq 0x5e13d(%rip), %rax     # 0x63fc0
movq (%rax), %rdi
leaq 0x46854(%rip), %rsi     # 0x4c6e1
movb $0x0, %al
callq 0x4130
jmp 0x5ee6
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x5ec6
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x5ee4
movq 0x5e0f3(%rip), %rax     # 0x63fc0
movq (%rax), %rdi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
leaq 0x4682f(%rip), %rsi     # 0x4c70c
movb $0x0, %al
callq 0x4130
jmp 0x5ee6
cmpq $0x0, -0x20(%rbp)
je 0x5f09
movq 0x5e0cc(%rip), %rax     # 0x63fc0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x4685a(%rip), %rsi     # 0x4c75c
movb $0x0, %al
callq 0x4130
cmpl $0x0, -0x24(%rbp)
je 0x5f46
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x5f46
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x5f46
cmpq $0x0, -0x20(%rbp)
je 0x5f5c
movq 0x5e073(%rip), %rax     # 0x63fc0
movq (%rax), %rsi
leaq 0x46c25(%rip), %rdi     # 0x4cb7c
callq 0x40a0
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
addq %rcx, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rcx
addq %rcx, %rsi
movl $0x1, %edx
callq *%rax
movl %eax, -0x14(%rbp)
movq 0x5e039(%rip), %rax     # 0x63fc0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x467d4(%rip), %rsi     # 0x4c768
movb $0x0, %al
callq 0x4130
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_COMMON_TABLE_HEADER_dumper
int ATOM_COMMON_TABLE_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_TABLE_HEADER *d = (ATOM_COMMON_TABLE_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usStructureSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usStructureSize)-start), FILL(21), d->usStructureSize, d->usStructureSize);
    printf ("%s%04x:  UCHAR ucTableFormatRevision%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTableFormatRevision)-start), FILL(26), d->ucTableFormatRevision, d->ucTableFormatRevision);
    printf ("%s%04x:  UCHAR ucTableContentRevision%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTableContentRevision)-start), FILL(27), d->ucTableContentRevision, d->ucTableContentRevision);
  }
  return sizeof (ATOM_COMMON_TABLE_HEADER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6c86
movq 0x5d763(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x6b51
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x6b57
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5d720(%rip), %rcx     # 0x642a0
addq $0x15, %rcx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movq -0x20(%rbp), %rax
movzwl (%rax), %r9d
leaq 0x46016(%rip), %rdi     # 0x4cbb1
movb $0x0, %al
callq 0x4090
movq 0x5d6f7(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x6bbd
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x6bc3
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5d6b0(%rip), %rcx     # 0x642a0
addq $0x1a, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r9d
leaq 0x45fd9(%rip), %rdi     # 0x4cbe6
movb $0x0, %al
callq 0x4090
movq 0x5d685(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x6c2f
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0x6c35
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5d63e(%rip), %rcx     # 0x642a0
addq $0x1b, %rcx
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %r9d
leaq 0x45fa3(%rip), %rdi     # 0x4cc22
movb $0x0, %al
callq 0x4090
movl $0x4, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MASTER_COMMAND_TABLE_dumper
int ATOM_MASTER_COMMAND_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MASTER_COMMAND_TABLE *d = (ATOM_MASTER_COMMAND_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  ATOM_MASTER_LIST_OF_COMMAND_TABLES ListOfCommandTables%s :\n", IND(indent), (int)(((uint8_t*)&d->ListOfCommandTables)-start), FILL(53)); ATOM_MASTER_LIST_OF_COMMAND_TABLES_dumper (start, (uint8_t*) &d->ListOfCommandTables, indent+1);
  }
  return sizeof (ATOM_MASTER_COMMAND_TABLE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9f7c
movq 0x5a403(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x9eb1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x9eb7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5a3c0(%rip), %rcx     # 0x642a0
addq $0x1f, %rcx
leaq 0x42d74(%rip), %rdi     # 0x4cc5f
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x6b10
movq 0x5a394(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x9f20
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x9f26
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5a34d(%rip), %rcx     # 0x642a0
addq $0x32, %rcx
leaq 0x4425c(%rip), %rdi     # 0x4e1ba
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x75c0
movl $0xa4, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TABLE_ATTRIBUTE_dumper
int ATOM_TABLE_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TABLE_ATTRIBUTE *d = (ATOM_TABLE_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s       USHORT WS_SizeInBytes:8%s = 0x%04x     (%d)\n", IND(indent), FILL(22), d->WS_SizeInBytes, d->WS_SizeInBytes);
    printf ("%s       USHORT PS_SizeInBytes:7%s = 0x%04x     (%d)\n", IND(indent), FILL(22), d->PS_SizeInBytes, d->PS_SizeInBytes);
    printf ("%s       USHORT UpdatedByUtility:1%s = 0x%04x     (%d)\n", IND(indent), FILL(24), d->UpdatedByUtility, d->UpdatedByUtility);
  }
  return sizeof (ATOM_TABLE_ATTRIBUTE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa102
movq 0x5a2e3(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x9fd1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x9fd7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x5a2ad(%rip), %rdx     # 0x642a0
addq $0x16, %rdx
movq -0x20(%rbp), %rax
movw (%rax), %ax
andw $0xff, %ax
movzwl %ax, %ecx
movq -0x20(%rbp), %rax
movw (%rax), %ax
andw $0xff, %ax
movzwl %ax, %r8d
leaq 0x441e4(%rip), %rdi     # 0x4e1ff
movb $0x0, %al
callq 0x4090
movq 0x5a277(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa03d
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xa043
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x5a241(%rip), %rdx     # 0x642a0
addq $0x16, %rdx
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x7f, %ax
movzwl %ax, %ecx
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x8, %ax
andw $0x7f, %ax
movzwl %ax, %r8d
leaq 0x441a6(%rip), %rdi     # 0x4e235
movb $0x0, %al
callq 0x4090
movq 0x5a203(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa0b1
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0xa0b7
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x5a1cd(%rip), %rdx     # 0x642a0
addq $0x18, %rdx
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0xf, %ax
movzwl %ax, %ecx
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0xf, %ax
movzwl %ax, %r8d
leaq 0x44170(%rip), %rdi     # 0x4e26b
movb $0x0, %al
callq 0x4090
movl $0x2, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TABLE_ATTRIBUTE_ACCESS_dumper
int ATOM_TABLE_ATTRIBUTE_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TABLE_ATTRIBUTE_ACCESS *d = (ATOM_TABLE_ATTRIBUTE_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_TABLE_ATTRIBUTE sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(37)); ATOM_TABLE_ATTRIBUTE_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) USHORT susAccess%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->susAccess)-start), FILL(23), d->susAccess, d->susAccess);
  }
  return sizeof (ATOM_TABLE_ATTRIBUTE_ACCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa211
movq 0x5a163(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa151
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xa157
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5a120(%rip), %rcx     # 0x642a0
addq $0x25, %rcx
leaq 0x44118(%rip), %rdi     # 0x4e2a3
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x9f90
movq 0x5a0f4(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa1c0
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xa1c6
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5a0b1(%rip), %rcx     # 0x642a0
addq $0x17, %rcx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movq -0x20(%rbp), %rax
movzwl (%rax), %r9d
leaq 0x440ce(%rip), %rdi     # 0x4e2d8
movb $0x0, %al
callq 0x4090
movl $0x2, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_COMMON_ROM_COMMAND_TABLE_HEADER_dumper
int ATOM_COMMON_ROM_COMMAND_TABLE_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_ROM_COMMAND_TABLE_HEADER *d = (ATOM_COMMON_ROM_COMMAND_TABLE_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER CommonHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->CommonHeader)-start), FILL(36)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->CommonHeader, indent+1);
    printf ("%s%04x:  ATOM_TABLE_ATTRIBUTE TableAttribute%s :\n", IND(indent), (int)(((uint8_t*)&d->TableAttribute)-start), FILL(34)); ATOM_TABLE_ATTRIBUTE_dumper (start, (uint8_t*) &d->TableAttribute, indent+1);
  }
  return sizeof (ATOM_COMMON_ROM_COMMAND_TABLE_HEADER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa32c
movq 0x5a053(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa261
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xa267
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x5a010(%rip), %rcx     # 0x642a0
addq $0x24, %rcx
leaq 0x44074(%rip), %rdi     # 0x4e30f
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x6b10
movq 0x59fe4(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa2d0
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xa2d6
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x59f9d(%rip), %rcx     # 0x642a0
addq $0x22, %rcx
leaq 0x44035(%rip), %rdi     # 0x4e343
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x9f90
movl $0x6, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ADJUST_MEMORY_CLOCK_FREQ_dumper
int ATOM_ADJUST_MEMORY_CLOCK_FREQ_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ADJUST_MEMORY_CLOCK_FREQ *d = (ATOM_ADJUST_MEMORY_CLOCK_FREQ *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulClockFreq:24%s = 0x%08x (%d)\n", IND(indent), FILL(19), d->ulClockFreq, d->ulClockFreq);
    printf ("%s       ULONG ulMemoryModuleNumber:7%s = 0x%08x (%d)\n", IND(indent), FILL(27), d->ulMemoryModuleNumber, d->ulMemoryModuleNumber);
    printf ("%s       ULONG ulPointerReturnFlag:1%s = 0x%08x (%d)\n", IND(indent), FILL(26), d->ulPointerReturnFlag, d->ulPointerReturnFlag);
  }
  return sizeof (ATOM_ADJUST_MEMORY_CLOCK_FREQ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa49c
movq 0x59f33(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa381
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xa387
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x59efd(%rip), %rdx     # 0x642a0
addq $0x13, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movq -0x20(%rbp), %rax
movl (%rax), %r8d
andl $0xffffff, %r8d         # imm = 0xFFFFFF
leaq 0x43fad(%rip), %rdi     # 0x4e375
movb $0x0, %al
callq 0x4090
movq 0x59eca(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa3ea
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xa3f0
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x59e94(%rip), %rdx     # 0x642a0
addq $0x1b, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shrl $0x18, %ecx
andl $0x7f, %ecx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
shrl $0x18, %r8d
andl $0x7f, %r8d
leaq 0x43f72(%rip), %rdi     # 0x4e3a4
movb $0x0, %al
callq 0x4090
movq 0x59e60(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa454
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0xa45a
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x59e2a(%rip), %rdx     # 0x642a0
addq $0x1a, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shrl $0x1f, %ecx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
shrl $0x1f, %r8d
leaq 0x43f46(%rip), %rdi     # 0x4e3db
movb $0x0, %al
callq 0x4090
movl $0x4, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_COMPUTE_CLOCK_FREQ_dumper
int ATOM_COMPUTE_CLOCK_FREQ_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMPUTE_CLOCK_FREQ *d = (ATOM_COMPUTE_CLOCK_FREQ *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulClockFreq:24%s = 0x%08x (%d)\n", IND(indent), FILL(19), d->ulClockFreq, d->ulClockFreq);
    printf ("%s       ULONG ulComputeClockFlag:8%s = 0x%08x (%d)\n", IND(indent), FILL(25), d->ulComputeClockFlag, d->ulComputeClockFlag);
  }
  return sizeof (ATOM_COMPUTE_CLOCK_FREQ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaa12
movq 0x59953(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa961
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xa967
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x5991d(%rip), %rdx     # 0x642a0
addq $0x13, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movq -0x20(%rbp), %rax
movl (%rax), %r8d
andl $0xffffff, %r8d         # imm = 0xFFFFFF
leaq 0x439cd(%rip), %rdi     # 0x4e375
movb $0x0, %al
callq 0x4090
movq 0x598ea(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xa9ca
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xa9d0
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x598b4(%rip), %rdx     # 0x642a0
addq $0x19, %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shrl $0x18, %ecx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
shrl $0x18, %r8d
leaq 0x43ae8(%rip), %rdi     # 0x4e4f3
movb $0x0, %al
callq 0x4090
movl $0x4, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_S_MPLL_FB_DIVIDER_dumper
int ATOM_S_MPLL_FB_DIVIDER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_S_MPLL_FB_DIVIDER *d = (ATOM_S_MPLL_FB_DIVIDER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usFbDivFrac%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDivFrac)-start), FILL(17), d->usFbDivFrac, d->usFbDivFrac);
    printf ("%s%04x:  USHORT usFbDiv%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDiv)-start), FILL(13), d->usFbDiv, d->usFbDiv);
  }
  return sizeof (ATOM_S_MPLL_FB_DIVIDER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xab24
movq 0x59853(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xaa61
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xaa67
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x59810(%rip), %rcx     # 0x642a0
addq $0x11, %rcx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movq -0x20(%rbp), %rax
movzwl (%rax), %r9d
leaq 0x43a7d(%rip), %rdi     # 0x4e528
movb $0x0, %al
callq 0x4090
movq 0x597e7(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xaacd
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xaad3
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x597a0(%rip), %rcx     # 0x642a0
addq $0xd, %rcx
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %r8d
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %r9d
leaq 0x439a9(%rip), %rdi     # 0x4e4c6
movb $0x0, %al
callq 0x4090
movl $0x4, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3 *) data;
  int i;
  if (d) {
    printf ("%s  <unparsable> line 529:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xabd9
movq 0x59743(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xab71
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xab77
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq 0x59708(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xabac
movl $0x19, %eax
movl %eax, -0x4c(%rbp)
jmp 0xabb2
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x4c(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rdx
leaq 0x43987(%rip), %rdi     # 0x4e559
movb $0x0, %al
callq 0x4090
movl $0x8, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulClock:24%s = 0x%08x (%d)\n", IND(indent), FILL(15), d->ulClock, d->ulClock);
    printf ("%s%04x:  ULONG ucPostDiv%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xacea
movq 0x59683(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xac31
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xac37
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
addl %ecx, %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq 0x5964d(%rip), %rdx     # 0x642a0
addq $0xf, %rdx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl %eax, %r8d
movl %r8d, %ecx
leaq 0x43918(%rip), %rdi     # 0x4e58b
movb $0x0, %al
callq 0x4090
movq 0x5961f(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xac95
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xac9b
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x595d8(%rip), %rcx     # 0x642a0
addq $0xe, %rcx
movq -0x20(%rbp), %rax
movl 0x3(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x3(%rax), %r9d
leaq 0x438d3(%rip), %rdi     # 0x4e5b6
movb $0x0, %al
callq 0x4090
movl $0x7, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5 *) data;
  int i;
  if (d) {
    printf ("%s  <unparsable> line 553:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xada9
movq 0x59573(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xad41
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xad47
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq 0x59538(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xad7c
movl $0x19, %eax
movl %eax, -0x4c(%rbp)
jmp 0xad82
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x4c(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rdx
leaq 0x4383e(%rip), %rdi     # 0x4e5e0
movb $0x0, %al
callq 0x4090
movl $0x8, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMICE_MEMORY_SETTINGS_PARAMETER_dumper
int DYNAMICE_MEMORY_SETTINGS_PARAMETER_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMICE_MEMORY_SETTINGS_PARAMETER *d = (DYNAMICE_MEMORY_SETTINGS_PARAMETER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMPUTE_CLOCK_FREQ ulClock%s :\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(30)); ATOM_COMPUTE_CLOCK_FREQ_dumper (start, (uint8_t*) &d->ulClock, indent+1);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  ULONG ulReserved%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulReserved[i])-start), FILL(19+(i>9)), i, d->ulReserved[i], d->ulReserved[i]); }
  }
  return sizeof (DYNAMICE_MEMORY_SETTINGS_PARAMETER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaf4a
movq 0x594b3(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xae01
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0xae07
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x59470(%rip), %rcx     # 0x642a0
addq $0x1e, %rcx
leaq 0x437d7(%rip), %rdi     # 0x4e612
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa920
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0xaf48
movq 0x59433(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0xae81
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0xae87
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x54(%rbp)
movq 0x593db(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x13, %eax
cmpl $0x32, %eax
jle 0xaee7
movl $0x32, %eax
movl %eax, -0x64(%rbp)
jmp 0xaef9
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x13, %eax
movl %eax, -0x64(%rbp)
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdi
movl 0x4(%rax,%rdi,4), %r9d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdi
movl 0x4(%rax,%rdi,4), %eax
leaq 0x43710(%rip), %rdi     # 0x4e640
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4090
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xae5c
jmp 0xaf4a
movl $0xc, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)