LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/main.c
// Function: do_diss
void do_diss (uint8_t *data, int off, int size, const char *addrformat)
{
    int j, len;
    uint8_t  *d = data + off;
    char buf[256];

    for (d = data + off; d < data+size; d += len) {
	if (optable[*d].process) {
	    len = optable[*d].process (d, buf);
	} else {
	    sprintf (buf, "<unknown> %02x", *d);
	    len = 1;
	}
	fputs ("  ", stdout);
	fprintf (stdout, addrformat, d - data);
	for (j = 0; j < len; j++) {
	    if (j && ! (j & 31))
		fprintf (stdout, "\n        ");
	    fprintf (stdout, "%02x", d[j]);
	}
	fputs (&"                "[j>8?16:j<<1], stdout);
	fprintf (stdout, "  %s\n", buf);
    }
    putc ('\n', stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rcx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
cmpl %edx, %esi
jge 0x5841
movslq %edx, %rcx
movq 0x8(%rsp), %rax
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movslq %esi, %r15
addq %rax, %r15
leaq 0x20(%rsp), %r14
movq 0x368a0(%rip), %r13     # 0x3bfc0
leaq 0x1cc2f(%rip), %rbp     # 0x22356
movzbl (%r15), %edx
movl %edx, %eax
shll $0x5, %eax
leaq 0x34699(%rip), %rcx     # 0x39dd0
movq (%rax,%rcx), %rax
testq %rax, %rax
je 0x574f
movq %r15, %rdi
movq %r14, %r12
movq %r14, %rsi
callq *%rax
movl %eax, %ebx
jmp 0x5768
movq %r14, %r12
movq %r14, %rdi
leaq 0x1cf4f(%rip), %rsi     # 0x226ab
xorl %eax, %eax
callq 0x41d0
movl $0x1, %ebx
movq (%r13), %rsi
leaq 0x1cc28(%rip), %rdi     # 0x2239b
callq 0x40c0
movq (%r13), %rdi
movq %r15, %rdx
subq 0x8(%rsp), %rdx
xorl %r14d, %r14d
movq 0x18(%rsp), %rsi
xorl %eax, %eax
callq 0x4150
testl %ebx, %ebx
jle 0x57f2
movl %ebx, 0x4(%rsp)
movl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x1cf13(%rip), %r12     # 0x226ba
testq %r14, %r14
sete %al
testb $0x1f, %r14b
setne %cl
orb %al, %cl
jne 0x57ce
movq (%r13), %rcx
movl $0x9, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x41f0
movq (%r13), %rdi
movzbl (%r15,%r14), %edx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x4150
incq %r14
cmpq %r14, %rbx
jne 0x57a7
leaq 0x20(%rsp), %r12
movl 0x4(%rsp), %ebx
leal (%r14,%r14), %eax
cmpl $0x9, %r14d
movl $0x10, %ecx
cmovael %ecx, %eax
movslq %eax, %rdi
leaq 0x1d306(%rip), %rax     # 0x22b12
addq %rax, %rdi
movq (%r13), %rsi
callq 0x40c0
movq (%r13), %rdi
leaq 0x1cea1(%rip), %rsi     # 0x226c4
movq %r12, %r14
movq %r12, %rdx
xorl %eax, %eax
callq 0x4150
movslq %ebx, %rax
addq %rax, %r15
cmpq 0x10(%rsp), %r15
jb 0x5727
movq 0x36778(%rip), %rax     # 0x3bfc0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x4140
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/main.c
// Function: do_test
void do_test (uint8_t *data)
{
    int i, j;
    for (i = 0; i < 0x100; i++) {
	if (! optable[i].name)
	    fprintf (stdout, "%02x:  -\n", i);
	else if (optable[i].desttype < 8)
	    fprintf (stdout, "%02x:  %s_%s\n", i, optable[i].name, addrnames[optable[i].desttype]);
	else
	    fprintf (stdout, "%02x:  %s  (%s)\n", i, optable[i].name, addrnames[optable[i].desttype]);
    }
    for (i = 0; i < INDEXTABLE_SIZEOF; i++) {
	fprintf (stdout, "\nindex_table %s len %02x\n ", index_tables[i].name, index_tables[i].len);
	for (j = 0; j < index_tables[i].len; j++)
	    if (index_tables[i].tab[j])
		fprintf (stdout, " %02x=%s", j, index_tables[i].tab[j]);
	putc ('\n', stdout);
    }
    putc ('\n', stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x34567(%rip), %rbp     # 0x39de0
movq 0x36740(%rip), %r13     # 0x3bfc0
leaq 0x1ce43(%rip), %rbx     # 0x226ca
leaq 0x36892(%rip), %r14     # 0x3c120
leaq 0x1ce4d(%rip), %r15     # 0x226e2
xorl %r12d, %r12d
movq -0x8(%rbp), %rcx
testq %rcx, %rcx
je 0x58bc
movslq (%rbp), %rax
movq (%r13), %rdi
cmpq $0x7, %rax
jg 0x58cf
movq (%r14,%rax,8), %r8
leaq 0x1ce1a(%rip), %rsi     # 0x226d4
jmp 0x58d6
movq (%r13), %rdi
movq %rbx, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x4150
jmp 0x58e0
movq (%r14,%rax,8), %r8
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x4150
incq %r12
addq $0x20, %rbp
cmpq $0x100, %r12            # imm = 0x100
jne 0x5898
leaq 0x376e9(%rip), %r12     # 0x3cfe0
leaq 0x1ce10(%rip), %r14     # 0x2270e
xorl %ebp, %ebp
movq (%r13), %rdi
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
movq (%r12,%rbx,8), %rdx
movl 0x10(%r12,%rbx,8), %ecx
leaq 0x1cdd4(%rip), %rsi     # 0x226f3
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0x10(%r12,%rbx,8)
jle 0x595f
leaq (%r12,%rbx,8), %rbx
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rcx
testq %rcx, %rcx
je 0x5953
movq (%r13), %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4150
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x5935
movq (%r13), %rsi
movl $0xa, %edi
callq 0x4140
incq %rbp
cmpq $0xb, %rbp
jne 0x5900
movq (%r13), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x6027
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x36321(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x15, %rcx
movzwl (%rbx), %r8d
leaq 0x1cb65(%rip), %rdi     # 0x22b23
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x362e1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1cb6e(%rip), %rdi     # 0x22b58
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x362b5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x1b, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1cb7f(%rip), %rdi     # 0x22b94
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x7277
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x350bc(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x1b9b1(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x35073(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x1ced7(%rip), %rdi     # 0x2412c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x637f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x731d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x35011(%rip), %rdx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %ecx
subl %eax, %ecx
movslq %ecx, %r14
leaq (%rdx,%r14), %rsi
addq $0x16, %rdx
movzbl (%rbx), %ecx
leaq 0x1ceb4(%rip), %rdi     # 0x24171
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34fe2(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x16, %rdx
movzbl 0x1(%rbx), %ecx
andl $0x7f, %ecx
leaq 0x1cec3(%rip), %rdi     # 0x241a7
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34fbb(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x18, %rdx
movzwl (%rbx), %ecx
shrl $0xf, %ecx
leaq 0x1ced4(%rip), %rdi     # 0x241dd
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x73b4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x34f71(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x25, %rcx
leaq 0x1ceaa(%rip), %rdi     # 0x24215
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x727d
movq 0x34f28(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x1ceb0(%rip), %rdi     # 0x2424a
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x745a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x34ed6(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x24, %rcx
leaq 0x1ce7b(%rip), %rdi     # 0x24281
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x34e8d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x1ce7a(%rip), %rdi     # 0x242b5
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r14, %rsi
movl %ebx, %edx
callq 0x727d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x7506
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x34e39(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x1ce43(%rip), %rdi     # 0x242e7
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34df8(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x1b, %rdx
movzbl 0x3(%rbx), %ecx
andl $0x7f, %ecx
leaq 0x1ce48(%rip), %rdi     # 0x24316
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34dd1(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x1a, %rdx
movl (%rbx), %ecx
shrl $0x1f, %ecx
leaq 0x1ce5b(%rip), %rdi     # 0x2434d
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(12), d->ulClock, d->ulClock);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
    printf ("%s%04x:  UCHAR ucFbDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFbDiv)-start), FILL(12), d->ucFbDiv, d->ucFbDiv);
    printf ("%s%04x:  UCHAR ucPostDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7616
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34d89(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xc, %rcx
movl (%rbx), %r8d
leaq 0x1ce2e(%rip), %rdi     # 0x24383
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34d4a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1ce2a(%rip), %rdi     # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34d1e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1b9c2(%rip), %rdi     # 0x22f6f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34cf2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x1ce01(%rip), %rdi     # 0x243da
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34cc6(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1ce04(%rip), %rdi     # 0x24408
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(12), d->ulClock, d->ulClock);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    printf ("%s%04x:  USHORT usFbDiv%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDiv)-start), FILL(13), d->usFbDiv, d->usFbDiv);
    printf ("%s%04x:  UCHAR ucPostDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x76fa
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34c79(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xc, %rcx
movl (%rbx), %r8d
leaq 0x1cd1e(%rip), %rdi     # 0x24383
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34c3a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1cd1a(%rip), %rdi     # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34c0e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x5(%rbx), %r8d
leaq 0x1cd7b(%rip), %rdi     # 0x24438
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34be2(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1cd20(%rip), %rdi     # 0x24408
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x777b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x34b9d(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x1cba7(%rip), %rdi     # 0x242e7
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34b5c(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x19, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x1ccfe(%rip), %rdi     # 0x24465
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x7804
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34b18(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x1ccd3(%rip), %rdi     # 0x2449a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34ad8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1cc46(%rip), %rdi     # 0x24438
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x78d5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34a4c(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r15
leaq (%rax,%r15), %rsi
addq $0xf, %rax
movzwl (%rbx), %edx
movzbl 0x2(%rbx), %ecx
shll $0x10, %ecx
orl %edx, %ecx
leaq 0x1cc67(%rip), %rdi     # 0x244fd
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34a06(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movl 0x3(%rbx), %r8d
leaq 0x1cc65(%rip), %rdi     # 0x24528
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x79cc
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq 0x34974(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1e, %rcx
leaq 0x1cc22(%rip), %rax     # 0x24584
movl %ebx, %ebp
subl %edi, %ebp
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r14d
movq %rbx, %rsi
movl %r14d, %edx
callq 0x7700
addl $0x4, %ebp
leaq 0x1cc28(%rip), %r14     # 0x245b2
xorl %r15d, %r15d
movq 0x3491c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x13, %rcx
movl 0x4(%rbx,%r15,4), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x4, %ebp
cmpq $0x1, %r15
je 0x798d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMICE_ENGINE_SETTINGS_PARAMETER_dumper
int DYNAMICE_ENGINE_SETTINGS_PARAMETER_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMICE_ENGINE_SETTINGS_PARAMETER *d = (DYNAMICE_ENGINE_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);
    printf ("%s%04x:  ULONG ulMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMemoryClock)-start), FILL(18), d->ulMemoryClock, d->ulMemoryClock);
    printf ("%s%04x:  ULONG ulReserved%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulReserved)-start), FILL(15), d->ulReserved, d->ulReserved);
  }
  return sizeof (DYNAMICE_ENGINE_SETTINGS_PARAMETER);
}

// Assembly:
testq %rsi, %rsi
je 0x7a91
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x348bf(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
leaq 0x1cb68(%rip), %rdi     # 0x24584
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7700
movq 0x3487a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1cb92(%rip), %rdi     # 0x245e2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3484f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movl 0x8(%rbx), %r8d
leaq 0x1cb96(%rip), %rdi     # 0x24610
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_ENGINE_CLOCK_PS_ALLOCATION_dumper
int SET_ENGINE_CLOCK_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_ENGINE_CLOCK_PS_ALLOCATION *d = (SET_ENGINE_CLOCK_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulTargetEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulTargetEngineClock)-start), FILL(24), d->ulTargetEngineClock, d->ulTargetEngineClock);
    printf ("%s%04x:  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(45)); COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_ENGINE_CLOCK_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7b83
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x347a9(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x18, %rcx
movl (%r14), %r8d
leaq 0x1cb05(%rip), %rdi     # 0x2463b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34769(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1cb10(%rip), %rdi     # 0x2466f
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x750c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_MEMORY_CLOCK_PS_ALLOCATION_dumper
int SET_MEMORY_CLOCK_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_MEMORY_CLOCK_PS_ALLOCATION *d = (SET_MEMORY_CLOCK_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulTargetMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulTargetMemoryClock)-start), FILL(24), d->ulTargetMemoryClock, d->ulTargetMemoryClock);
    printf ("%s%04x:  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(45)); COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_MEMORY_CLOCK_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7c75
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x346b7(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x18, %rcx
movl (%r14), %r8d
leaq 0x1ca84(%rip), %rdi     # 0x246ac
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34677(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1ca1e(%rip), %rdi     # 0x2466f
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x750c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ASIC_INIT_PARAMETERS_dumper
int ASIC_INIT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ASIC_INIT_PARAMETERS *d = (ASIC_INIT_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulDefaultEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDefaultEngineClock)-start), FILL(25), d->ulDefaultEngineClock, d->ulDefaultEngineClock);
    printf ("%s%04x:  ULONG ulDefaultMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDefaultMemoryClock)-start), FILL(25), d->ulDefaultMemoryClock, d->ulDefaultMemoryClock);
  }
  return sizeof (ASIC_INIT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7cfc
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3461e(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x19, %rcx
movl (%rbx), %r8d
leaq 0x1ca20(%rip), %rdi     # 0x246e0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x345df(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1ca2b(%rip), %rdi     # 0x24715
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ASIC_INIT_PS_ALLOCATION_dumper
int ASIC_INIT_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ASIC_INIT_PS_ALLOCATION *d = (ASIC_INIT_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ASIC_INIT_PARAMETERS sASICInitClocks%s :\n", IND(indent), (int)(((uint8_t*)&d->sASICInitClocks)-start), FILL(35)); ASIC_INIT_PARAMETERS_dumper (start, (uint8_t*) &d->sASICInitClocks, indent+1);
    printf ("%s%04x:  SET_ENGINE_CLOCK_PS_ALLOCATION sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(39)); SET_ENGINE_CLOCK_PS_ALLOCATION_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ASIC_INIT_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7da5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3458e(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x23, %rcx
leaq 0x1c9fc(%rip), %rdi     # 0x2474a
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7c7b
movq 0x34545(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x1c9fa(%rip), %rdi     # 0x2477d
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7ae7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x14, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMIC_CLOCK_GATING_PARAMETERS_dumper
int DYNAMIC_CLOCK_GATING_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMIC_CLOCK_GATING_PARAMETERS *d = (DYNAMIC_CLOCK_GATING_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (DYNAMIC_CLOCK_GATING_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7e58
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x344da(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x1c9bf(%rip), %rax     # 0x247b4
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1c9ce(%rip), %r15     # 0x247e3
xorl %r12d, %r12d
movq 0x34491(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x1(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x7e18
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS_dumper
int ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS *d = (ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7f0b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x34427(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x1c90c(%rip), %rax     # 0x247b4
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1c91b(%rip), %r15     # 0x247e3
xorl %r12d, %r12d
movq 0x343de(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x1(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x7ecb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DAC_LOAD_DETECTION_PARAMETERS_dumper
int DAC_LOAD_DETECTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_LOAD_DETECTION_PARAMETERS *d = (DAC_LOAD_DETECTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceID)-start), FILL(16), d->usDeviceID, d->usDeviceID);
    printf ("%s%04x:  UCHAR ucDacType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDacType)-start), FILL(14), d->ucDacType, d->ucDacType);
    printf ("%s%04x:  UCHAR ucMisc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMisc)-start), FILL(11), d->ucMisc, d->ucMisc);
  }
  return sizeof (DAC_LOAD_DETECTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7fc4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34384(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzwl (%rbx), %r8d
leaq 0x1c8bd(%rip), %rdi     # 0x24818
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34344(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1c8c1(%rip), %rdi     # 0x24848
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34318(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1c8c6(%rip), %rdi     # 0x24878
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DAC_LOAD_DETECTION_PS_ALLOCATION_dumper
int DAC_LOAD_DETECTION_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_LOAD_DETECTION_PS_ALLOCATION *d = (DAC_LOAD_DETECTION_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DAC_LOAD_DETECTION_PARAMETERS sDacload%s :\n", IND(indent), (int)(((uint8_t*)&d->sDacload)-start), FILL(37)); DAC_LOAD_DETECTION_PARAMETERS_dumper (start, (uint8_t*) &d->sDacload, indent+1);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  ULONG Reserved%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->Reserved[i])-start), FILL(17+(i>9)), i, d->Reserved[i], d->Reserved[i]); }
  }
  return sizeof (DAC_LOAD_DETECTION_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x8080
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x342c1(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x25, %rcx
leaq 0x1c890(%rip), %rdi     # 0x248a5
movl %ebx, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r14d
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x7f11
addl $0x4, %ebp
leaq 0x1c89c(%rip), %r14     # 0x248da
xorl %r15d, %r15d
movq 0x34268(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x11, %rcx
movl 0x4(%rbx,%r15,4), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x4, %ebp
cmpq $0x1, %r15
je 0x8041
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DAC_ENCODER_CONTROL_PARAMETERS_dumper
int DAC_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_ENCODER_CONTROL_PARAMETERS *d = (DAC_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  UCHAR ucDacStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDacStandard)-start), FILL(18), d->ucDacStandard, d->ucDacStandard);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
  }
  return sizeof (DAC_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x8139
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3420f(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x1c838(%rip), %rdi     # 0x24908
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x341cf(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1c83e(%rip), %rdi     # 0x2493a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x341a3(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1c284(%rip), %rdi     # 0x243ab
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DIG_ENCODER_CONTROL_PARAMETERS_dumper
int DIG_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DIG_ENCODER_CONTROL_PARAMETERS *d = (DIG_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  UCHAR ucConfig%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConfig)-start), FILL(13), d->ucConfig, d->ucConfig);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    printf ("%s%04x:  UCHAR ucEncoderMode%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEncoderMode)-start), FILL(18), d->ucEncoderMode, d->ucEncoderMode);
    printf ("%s%04x:  UCHAR ucLaneNum%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLaneNum)-start), FILL(14), d->ucLaneNum, d->ucLaneNum);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucReserved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved[i])-start), FILL(19+(i>9)), i, d->ucReserved[i], d->ucReserved[i]); }
  }
  return sizeof (DIG_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x829d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x34143(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x1c77c(%rip), %rdi     # 0x24908
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3410a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1c7ad(%rip), %rdi     # 0x2496e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x340de(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x3(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1c1be(%rip), %rdi     # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x340b2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0x12, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1c784(%rip), %rdi     # 0x2499d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34086(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x5(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1c78c(%rip), %rdi     # 0x249d1
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x6, %r14d
leaq 0x1c7a7(%rip), %r15     # 0x24a01
xorl %r12d, %r12d
movq 0x3404c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x13, %rcx
movzbl 0x6(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x1, %r12
je 0x825d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_ENCODER_CONFIG_V2_dumper
int ATOM_DIG_ENCODER_CONFIG_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_ENCODER_CONFIG_V2 *d = (ATOM_DIG_ENCODER_CONFIG_V2 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDPLinkRate:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucDPLinkRate, d->ucDPLinkRate);
    printf ("%s       UCHAR ucReserved:1%s = 0x%02x       (%d)\n", IND(indent), FILL(17), d->ucReserved, d->ucReserved);
    printf ("%s       UCHAR ucLinkSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(16), d->ucLinkSel, d->ucLinkSel);
    printf ("%s       UCHAR ucTransmitterSel:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucTransmitterSel, d->ucTransmitterSel);
    printf ("%s       UCHAR ucReserved1:2%s = 0x%02x       (%d)\n", IND(indent), FILL(18), d->ucReserved1, d->ucReserved1);
  }
  return sizeof (ATOM_DIG_ENCODER_CONFIG_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x839f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33ff6(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1c751(%rip), %rdi     # 0x24a37
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33fb6(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1c75b(%rip), %rdi     # 0x24a6c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33f8e(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1c765(%rip), %rdi     # 0x24a9f
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33f65(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x1c76e(%rip), %rdi     # 0x24ad1
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33f3c(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x5, %ecx
andl $0x3, %ecx
leaq 0x1c77f(%rip), %rdi     # 0x24b0a
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x1, %eax
retq