LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_INFO_dumper
int ATOM_VOLTAGE_OBJECT_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT_INFO *d = (ATOM_VOLTAGE_OBJECT_INFO *) 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);
    for (i = 0; i < (count_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d)); i++) {
      printf ("%s%04x:  ATOM_VOLTAGE_OBJECT asVoltageObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&*(offset_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d,i)))-start), FILL(35+(i>9)), i); ATOM_VOLTAGE_OBJECT_dumper (start, (uint8_t*) &*(offset_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d,i)), indent+1); }
  }
  return 0;
}

// Assembly:
testq %rsi, %rsi
je 0x15e4e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x265b7(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
leaq (%rcx,%rax), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xcea7(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
leaq 0x4(%r14), %r12
movl %r12d, %eax
subl %r15d, %eax
movl %eax, 0xc(%rsp)
movl $0x1, %ebp
xorl %r13d, %r13d
movzwl (%r14), %eax
movl $0x1, %ecx
xorl %esi, %esi
xorl %r8d, %r8d
movl %r8d, %edx
movq %r12, %rdi
testl %r8d, %r8d
je 0x15d86
movl %ecx, %r8d
movq %r12, %rdi
movzbl 0x1(%rdi), %r9d
addq %r9, %rdi
decl %r8d
cmpl $0x1, %r8d
jg 0x15d75
cmpq %rsi, %rdi
je 0x15d9f
movq %rdi, %r9
subq %r14, %r9
leal 0x1(%rdx), %r8d
incl %ecx
movq %rdi, %rsi
cmpq %rax, %r9
jl 0x15d64
cmpl %edx, %r13d
jae 0x15e40
movq 0x26501(%rip), %rcx     # 0x3c2b0
movq 0x10(%rsp), %rax
leaq (%rcx,%rax), %rsi
testl %r13d, %r13d
je 0x15e10
movl %ebp, %eax
movq %r12, %rdx
movq %rdx, %rdi
movzbl 0x1(%rdx), %edx
addq %rdi, %rdx
decl %eax
cmpl $0x1, %eax
jg 0x15dc2
subl %r15d, %edx
cmpl $0xa, %r13d
sbbq $-0x1, %rcx
addq $0x23, %rcx
leaq 0x163c1(%rip), %rdi     # 0x2c1aa
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
testl %r13d, %r13d
je 0x15e2c
movl %ebp, %eax
movq %r12, %rsi
movzbl 0x1(%rsi), %ecx
addq %rcx, %rsi
decl %eax
cmpl $0x1, %eax
jg 0x15e00
jmp 0x15e2c
addq $0x23, %rcx
leaq 0x1638f(%rip), %rdi     # 0x2c1aa
movl 0xc(%rsp), %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x15acf
incl %r13d
incl %ebp
jmp 0x15d56
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_INFO_V2_dumper
int ATOM_VOLTAGE_OBJECT_INFO_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT_INFO_V2 *d = (ATOM_VOLTAGE_OBJECT_INFO_V2 *) 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);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  ATOM_VOLTAGE_OBJECT_V2 asVoltageObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asVoltageObj[i])-start), FILL(38+(i>9)), i); ATOM_VOLTAGE_OBJECT_V2_dumper (start, (uint8_t*) &d->asVoltageObj[i], indent+1); }
  }
  return sizeof (ATOM_VOLTAGE_OBJECT_INFO_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x15f15
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2643c(%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 $0x1f, %rcx
leaq 0xcd37(%rip), %rdi      # 0x22bd1
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x263e7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x26, %rcx
leaq 0x16306(%rip), %rdi     # 0x2c1de
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x15bd1
incq %r13
addq $0x96, %r14
addl $0x96, %ebp
cmpq $0x3, %r13
jne 0x15ec2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1c6, %eax            # imm = 0x1C6
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_LEAKID_VOLTAGE_dumper
int ATOM_LEAKID_VOLTAGE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LEAKID_VOLTAGE *d = (ATOM_LEAKID_VOLTAGE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucLeakageId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLeakageId)-start), FILL(16), d->ucLeakageId, d->ucLeakageId);
    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:  USHORT usVoltage%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltage)-start), FILL(15), d->usVoltage, d->usVoltage);
  }
  return sizeof (ATOM_LEAKID_VOLTAGE);
}

// Assembly:
testq %rsi, %rsi
je 0x15fce
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2637a(%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
movzbl (%rbx), %r8d
leaq 0x162b0(%rip), %rdi     # 0x2c215
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2633a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0xcfde(%rip), %rdi      # 0x22f6f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2630e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1628b(%rip), %rdi     # 0x2c247
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_ASIC_PROFILING_INFO_dumper
int ATOM_ASIC_PROFILING_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_PROFILING_INFO *d = (ATOM_ASIC_PROFILING_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER asHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->asHeader)-start), FILL(32)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->asHeader, indent+1);
    printf ("%s%04x:  ATOM_ASIC_PROFILE_VOLTAGE asVoltage%s :\n", IND(indent), (int)(((uint8_t*)&d->asVoltage)-start), FILL(34)); ATOM_ASIC_PROFILE_VOLTAGE_dumper (start, (uint8_t*) &d->asVoltage, indent+1);
  }
  return sizeof (ATOM_ASIC_PROFILING_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1623e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x260f5(%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 $0x20, %rcx
leaq 0x16163(%rip), %rdi     # 0x2c34a
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x260ac(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x1615e(%rip), %rdi     # 0x2c37a
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x15fd4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_POWER_SOURCE_INFO_dumper
int ATOM_POWER_SOURCE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_POWER_SOURCE_INFO *d = (ATOM_POWER_SOURCE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER asHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->asHeader)-start), FILL(32)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->asHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  UCHAR asPwrbehave%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->asPwrbehave[i])-start), FILL(20+(i>9)), i, d->asPwrbehave[i], d->asPwrbehave[i]); }
    for (i = 0; i < COUNT_REMAINDER (ATOM_POWER_SOURCE_INFO, asPwrObj[0], ATOM_POWER_SOURCE_OBJECT); i++) {
      printf ("%s%04x:  ATOM_POWER_SOURCE_OBJECT asPwrObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asPwrObj[i])-start), FILL(36+(i>9)), i); ATOM_POWER_SOURCE_OBJECT_dumper (start, (uint8_t*) &d->asPwrObj[i], indent+1); }
  }
  return RETURN_REMAINDER (ATOM_POWER_SOURCE_INFO, asPwrObj[0], ATOM_POWER_SOURCE_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x1659f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x25e5e(%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
addq $0x20, %rcx
leaq 0x15ed2(%rip), %rdi     # 0x2c34a
movl %r14d, %r12d
subl %ebx, %r12d
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ebx
movl %ebp, %edx
callq 0x5f74
addl $0x4, %r12d
leaq 0x160e6(%rip), %r13     # 0x2c58f
xorl %ebp, %ebp
movq 0x25dfe(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leal (%r12,%rbp), %edx
cmpq $0xa, %rbp
sbbq $-0x1, %rcx
addq $0x14, %rcx
movzbl 0x4(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
cmpq $0x10, %rbp
jne 0x164ab
movzwl (%r14), %ecx
movzwl %cx, %eax
addq $-0x14, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
cmpq $0xc, %rax
jb 0x16578
leaq 0x14(%r14), %r12
movl %r14d, %ebp
subl 0x10(%rsp), %ebp
addl $0x14, %ebp
xorl %r13d, %r13d
movl %ebx, 0xc(%rsp)
movq 0x25d93(%rip), %rcx     # 0x3c2b0
movq %rsi, %rbx
leaq (%rcx,%r15), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x24, %rcx
leaq 0x1608f(%rip), %rdi     # 0x2c5c6
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl 0xc(%rsp), %edx
callq 0x16244
movq %rbx, %rsi
incq %r13
movzwl (%r14), %ecx
movzwl %cx, %eax
addq $-0x14, %rax
mulq %rbx
shrq $0x3, %rdx
addq $0xc, %r12
addl $0xc, %ebp
cmpq %r13, %rdx
ja 0x16516
movzwl %cx, %eax
addq $-0x14, %rax
mulq %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx,2), %eax
leal 0x14(,%rax,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CLK_VOLT_CAPABILITY_dumper
int ATOM_CLK_VOLT_CAPABILITY_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CLK_VOLT_CAPABILITY *d = (ATOM_CLK_VOLT_CAPABILITY *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulVoltageIndex%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulVoltageIndex)-start), FILL(19), d->ulVoltageIndex, d->ulVoltageIndex);
    printf ("%s%04x:  ULONG ulMaximumSupportedCLK%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaximumSupportedCLK)-start), FILL(26), d->ulMaximumSupportedCLK, d->ulMaximumSupportedCLK);
  }
  return sizeof (ATOM_CLK_VOLT_CAPABILITY);
}

// Assembly:
testq %rsi, %rsi
je 0x16623
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25cf7(%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 $0x13, %rcx
movl (%rbx), %r8d
leaq 0x16014(%rip), %rdi     # 0x2c5fb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25cb8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movl 0x4(%rbx), %r8d
leaq 0x16019(%rip), %rdi     # 0x2c62a
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_AVAILABLE_SCLK_LIST_dumper
int ATOM_AVAILABLE_SCLK_LIST_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_AVAILABLE_SCLK_LIST *d = (ATOM_AVAILABLE_SCLK_LIST *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulSupportedSCLK%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulSupportedSCLK)-start), FILL(20), d->ulSupportedSCLK, d->ulSupportedSCLK);
    printf ("%s%04x:  USHORT usVoltageIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageIndex)-start), FILL(20), d->usVoltageIndex, d->usVoltageIndex);
    printf ("%s%04x:  USHORT usVoltageID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageID)-start), FILL(17), d->usVoltageID, d->usVoltageID);
  }
  return sizeof (ATOM_AVAILABLE_SCLK_LIST);
}

// Assembly:
testq %rsi, %rsi
je 0x166db
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25c6c(%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 $0x14, %rcx
movl (%rbx), %r8d
leaq 0x15fee(%rip), %rdi     # 0x2c660
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25c2d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x15ff2(%rip), %rdi     # 0x2c690
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25c01(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x15ffb(%rip), %rdi     # 0x2c6c4
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_I2C_DATA_RECORD_dumper
int ATOM_I2C_DATA_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_DATA_RECORD *d = (ATOM_I2C_DATA_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNunberOfBytes%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNunberOfBytes)-start), FILL(20), d->ucNunberOfBytes, d->ucNunberOfBytes);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucI2CData%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CData[i])-start), FILL(18+(i>9)), i, d->ucI2CData[i], d->ucI2CData[i]); }
  }
  return sizeof (ATOM_I2C_DATA_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x17001
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25323(%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 $0x14, %rcx
movzbl (%rbx), %r8d
leaq 0x15c9c(%rip), %rdi     # 0x2cc58
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x252e3(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x15ca3(%rip), %rdi     # 0x2cc8e
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_I2C_DEVICE_SETUP_INFO_dumper
int ATOM_I2C_DEVICE_SETUP_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_DEVICE_SETUP_INFO *d = (ATOM_I2C_DEVICE_SETUP_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG_ACCESS sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(33)); ATOM_I2C_ID_CONFIG_ACCESS_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
    printf ("%s%04x:  UCHAR ucSSChipID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSSChipID)-start), FILL(15), d->ucSSChipID, d->ucSSChipID);
    printf ("%s%04x:  UCHAR ucSSChipSlaveAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSSChipSlaveAddr)-start), FILL(22), d->ucSSChipSlaveAddr, d->ucSSChipSlaveAddr);
    printf ("%s%04x:  UCHAR ucNumOfI2CDataRecords%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfI2CDataRecords)-start), FILL(26), d->ucNumOfI2CDataRecords, d->ucNumOfI2CDataRecords);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_I2C_DATA_RECORD asI2CData%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asI2CData[i])-start), FILL(33+(i>9)), i); ATOM_I2C_DATA_RECORD_dumper (start, (uint8_t*) &d->asI2CData[i], indent+1); }
  }
  return sizeof (ATOM_I2C_DEVICE_SETUP_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x17131
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x25289(%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 $0x21, %rcx
leaq 0x11a4f(%rip), %rdi     # 0x28aa2
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xfc33
movq 0x25240(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x15c38(%rip), %rdi     # 0x2ccc3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25214(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x15c3d(%rip), %rdi     # 0x2ccf4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x251e8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0x1a, %rcx
movzbl 0x3(%r14), %r8d
leaq 0x15c49(%rip), %rdi     # 0x2cd2c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x251bc(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x15c5c(%rip), %rdi     # 0x2cd68
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x16f6e
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_ASIC_MVDD_INFO_dumper
int ATOM_ASIC_MVDD_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_MVDD_INFO *d = (ATOM_ASIC_MVDD_INFO *) 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);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_I2C_DEVICE_SETUP_INFO asI2CSetup%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asI2CSetup[i])-start), FILL(40+(i>9)), i); ATOM_I2C_DEVICE_SETUP_INFO_dumper (start, (uint8_t*) &d->asI2CSetup[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_MVDD_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x171dd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x25159(%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 0xba4e(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x25110(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x28, %rcx
leaq 0x15be2(%rip), %rdi     # 0x2cd9a
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17007
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO *d = (ATOM_ASIC_INTERNAL_SS_INFO *) 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);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(43+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x17567
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24de4(%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 $0x1f, %rcx
leaq 0xb6df(%rip), %rdi      # 0x22bd1
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x24d8f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x2b, %rcx
leaq 0x159b8(%rip), %rdi     # 0x2cee8
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x171e3
incq %r13
addq $0xc, %r14
addl $0xc, %ebp
cmpq $0x4, %r13
jne 0x1751a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x34, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_V2_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO_V2 *d = (ATOM_ASIC_INTERNAL_SS_INFO_V2 *) 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);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT_V2 asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(46+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_V2_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x17613
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24d23(%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 0xb618(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x24cda(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x15936(%rip), %rdi     # 0x2cf24
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17346
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_V3_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO_V3 *d = (ATOM_ASIC_INTERNAL_SS_INFO_V3 *) 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);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT_V3 asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(46+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_V3_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO_V3);
}

// Assembly:
testq %rsi, %rsi
je 0x17822
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24b14(%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 0xb409(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x24acb(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x15766(%rip), %rdi     # 0x2cf63
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17619
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: MEMORY_PLLINIT_PARAMETERS_dumper
int MEMORY_PLLINIT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  MEMORY_PLLINIT_PARAMETERS *d = (MEMORY_PLLINIT_PARAMETERS *) 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:  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 ucFbDiv_Hi%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFbDiv_Hi)-start), FILL(15), d->ucFbDiv_Hi, d->ucFbDiv_Hi);
    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 (MEMORY_PLLINIT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17932
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x24a6d(%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 $0x18, %rcx
movl (%rbx), %r8d
leaq 0xce3b(%rip), %rdi      # 0x246ac
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24a2e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0xcb0e(%rip), %rdi      # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24a02(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x156d9(%rip), %rdi     # 0x2cfa2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x249d6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0xcae5(%rip), %rdi      # 0x243da
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x249aa(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xcae8(%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: GPIO_PIN_CONTROL_PARAMETERS_dumper
int GPIO_PIN_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  GPIO_PIN_CONTROL_PARAMETERS *d = (GPIO_PIN_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucGPIO_ID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIO_ID)-start), FILL(14), d->ucGPIO_ID, d->ucGPIO_ID);
    printf ("%s%04x:  UCHAR ucGPIOBitShift%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOBitShift)-start), FILL(19), d->ucGPIOBitShift, d->ucGPIOBitShift);
    printf ("%s%04x:  UCHAR ucGPIOBitVal%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOBitVal)-start), FILL(17), d->ucGPIOBitVal, d->ucGPIOBitVal);
    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 (GPIO_PIN_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17a17
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2495d(%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 $0xe, %rcx
movzbl (%rbx), %r8d
leaq 0x12c48(%rip), %rdi     # 0x2a5ca
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2491d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x15625(%rip), %rdi     # 0x2cfd3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x248f1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1562e(%rip), %rdi     # 0x2d008
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x248c5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xc9a6(%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: ENABLE_SCALER_PARAMETERS_dumper
int ENABLE_SCALER_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_SCALER_PARAMETERS *d = (ENABLE_SCALER_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucScaler%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucScaler)-start), FILL(13), d->ucScaler, d->ucScaler);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucTVStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTVStandard)-start), FILL(17), d->ucTVStandard, d->ucTVStandard);
    for (i = 0; i < 1; 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_SCALER_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17b08
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x24874(%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 $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x155d0(%rip), %rdi     # 0x2d03b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24834(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0xcd1d(%rip), %rdi      # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24808(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x155a7(%rip), %rdi     # 0x2d06a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x247dc(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0xccf1(%rip), %rdi      # 0x247e3
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper
int ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS *d = (ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG usHWIconHorzVertPosn%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHWIconHorzVertPosn)-start), FILL(25), d->usHWIconHorzVertPosn, d->usHWIconHorzVertPosn);
    printf ("%s%04x:  UCHAR ucHWIconVertOffset%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWIconVertOffset)-start), FILL(23), d->ucHWIconVertOffset, d->ucHWIconVertOffset);
    printf ("%s%04x:  UCHAR ucHWIconHorzOffset%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWIconHorzOffset)-start), FILL(23), d->ucHWIconHorzOffset, d->ucHWIconHorzOffset);
    printf ("%s%04x:  UCHAR ucSelection%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSelection)-start), FILL(16), d->ucSelection, d->ucSelection);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
  }
  return sizeof (ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17c18
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x24787(%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 0x15546(%rip), %rdi     # 0x2d09d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24748(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1554f(%rip), %rdi     # 0x2d0d2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2471c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1555c(%rip), %rdi     # 0x2d10b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x246f0(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x15569(%rip), %rdi     # 0x2d144
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x246c4(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xcbae(%rip), %rdi      # 0x247b4
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: ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION_dumper
int ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION *d = (ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS sEnableIcon%s :\n", IND(indent), (int)(((uint8_t*)&d->sEnableIcon)-start), FILL(49)); ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper (start, (uint8_t*) &d->sEnableIcon, indent+1);
    printf ("%s%04x:  ENABLE_CRTC_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(31)); ENABLE_CRTC_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x17cc1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24672(%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 $0x31, %rcx
leaq 0x1550c(%rip), %rdi     # 0x2d176
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17b0e
movq 0x24629(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x15518(%rip), %rdi     # 0x2d1b7
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x911a
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: ENABLE_GRAPH_SURFACE_PARAMETERS_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS *d = (ENABLE_GRAPH_SURFACE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    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_GRAPH_SURFACE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17dcd
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 0x245bb(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x154d2(%rip), %rdi     # 0x2d1e6
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24582(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x154ca(%rip), %rdi     # 0x2d213
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24556(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x154cb(%rip), %rdi     # 0x2d240
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r14d
leaq 0xca59(%rip), %r15      # 0x247e3
xorl %r12d, %r12d
movq 0x2451c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x5(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x17d8d
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: ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2 *d = (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    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 < 2; 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_GRAPH_SURFACE_PARAMETERS_V1_2);
}

// Assembly:
testq %rsi, %rsi
je 0x17f05
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 0x244af(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x153c6(%rip), %rdi     # 0x2d1e6
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24476(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x153be(%rip), %rdi     # 0x2d213
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2444a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x153bf(%rip), %rdi     # 0x2d240
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2441e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x5(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc907(%rip), %rdi      # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x6, %r14d
leaq 0xc921(%rip), %r15      # 0x247e3
xorl %r12d, %r12d
movq 0x243e4(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %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 0x17ec5
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: ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3 *d = (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  USHORT usDeviceId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceId)-start), FILL(16), d->usDeviceId, d->usDeviceId);
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3);
}

// Assembly:
testq %rsi, %rsi
je 0x18016
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2438a(%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 $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x15291(%rip), %rdi     # 0x2d1e6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2434a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x15292(%rip), %rdi     # 0x2d213
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2431e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x15293(%rip), %rdi     # 0x2d240
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x242f2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc7db(%rip), %rdi      # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x242c6(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1526c(%rip), %rdi     # 0x2d270
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: ENABLE_GRAPH_SURFACE_PS_ALLOCATION_dumper
int ENABLE_GRAPH_SURFACE_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PS_ALLOCATION *d = (ENABLE_GRAPH_SURFACE_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ENABLE_GRAPH_SURFACE_PARAMETERS sSetSurface%s :\n", IND(indent), (int)(((uint8_t*)&d->sSetSurface)-start), FILL(42)); ENABLE_GRAPH_SURFACE_PARAMETERS_dumper (start, (uint8_t*) &d->sSetSurface, indent+1);
    printf ("%s%04x:  ENABLE_YUV_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(30)); ENABLE_YUV_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x180bf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24274(%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 $0x2a, %rcx
leaq 0x15238(%rip), %rdi     # 0x2d2a0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17cc7
movq 0x2422b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1e, %rcx
leaq 0x1523d(%rip), %rdi     # 0x2d2da
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa162
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: MEMORY_CLEAN_UP_PARAMETERS_dumper
int MEMORY_CLEAN_UP_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  MEMORY_CLEAN_UP_PARAMETERS *d = (MEMORY_CLEAN_UP_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usMemoryStart%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMemoryStart)-start), FILL(19), d->usMemoryStart, d->usMemoryStart);
    printf ("%s%04x:  USHORT usMemorySize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMemorySize)-start), FILL(18), d->usMemorySize, d->usMemorySize);
  }
  return sizeof (MEMORY_CLEAN_UP_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x18148
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x241d4(%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 $0x13, %rcx
movzwl (%rbx), %r8d
leaq 0x151fd(%rip), %rdi     # 0x2d308
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24194(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x15205(%rip), %rdi     # 0x2d33b
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq