LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x15d88
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2758e(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x13, %rcx
movl (%rbx), %r8d
leaq 0x1588c(%rip), %rdi     # 0x2b5d8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27553(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movl 0x4(%rbx), %r8d
leaq 0x15891(%rip), %rdi     # 0x2b607
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15e3a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27509(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x14, %rcx
movl (%rbx), %r8d
leaq 0x1586c(%rip), %rdi     # 0x2b63d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x274ce(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x15870(%rip), %rdi     # 0x2b66d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x274a2(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x15879(%rip), %rdi     # 0x2b6a1
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16745
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26bdb(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x14, %rcx
movzbl (%rbx), %r8d
leaq 0x15535(%rip), %rdi     # 0x2bc35
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26b9f(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1553c(%rip), %rdi     # 0x2bc6b
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1686f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26b47(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x112ee(%rip), %rdi     # 0x27a7f
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xf719
movq 0x26b02(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x154d7(%rip), %rdi     # 0x2bca0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26ad6(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x154dc(%rip), %rdi     # 0x2bcd1
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26aaa(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0x1a, %rcx
movzbl 0x3(%r14), %r8d
leaq 0x154e8(%rip), %rdi     # 0x2bd09
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26a7e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x154fb(%rip), %rdi     # 0x2bd45
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x166b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16915
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26a1d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xb2f3(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x269d8(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x28, %rcx
leaq 0x15487(%rip), %rdi     # 0x2bd77
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x16749
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xa
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16c93
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x266b6(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0xaf92(%rip), %rdi      # 0x21bae
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 0x5d40
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
cmpq $0x4, %r13
je 0x16c85
movq 0x2665f(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x2b, %rcx
leaq 0x15265(%rip), %rdi     # 0x2bec5
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x16919
incq %r13
addq $0xc, %r14
addl $0xc, %ebp
jmp 0x16c44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0x34
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16d39
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x265f9(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xaecf(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x265b4(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x151ed(%rip), %rdi     # 0x2bf01
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x16a78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x10
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16f3e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x263f4(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xacca(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x263af(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x15027(%rip), %rdi     # 0x2bf40
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x16d3d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x10
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17048
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26353(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x18, %rcx
movl (%rbx), %r8d
leaq 0xc702(%rip), %rdi      # 0x23689
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26318(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0xc3d5(%rip), %rdi      # 0x23388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x262ec(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x14fa0(%rip), %rdi     # 0x2bf7f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x262c0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0xc3ac(%rip), %rdi      # 0x233b7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26294(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xc3af(%rip), %rdi      # 0x233e5
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17127
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26249(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzbl (%rbx), %r8d
leaq 0x12515(%rip), %rdi     # 0x295a7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2620d(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x14ef2(%rip), %rdi     # 0x2bfb0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x261e1(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14efb(%rip), %rdi     # 0x2bfe5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x261b5(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xc273(%rip), %rdi      # 0x23388
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17212
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26166(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x14ea3(%rip), %rdi     # 0x2c018
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2612a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0xc5f0(%rip), %rdi      # 0x23791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x260fe(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14e7a(%rip), %rdi     # 0x2c047
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x260d2(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0xc5c4(%rip), %rdi      # 0x237c0
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1731c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2607f(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x19, %rcx
movl (%rbx), %r8d
leaq 0x14e1f(%rip), %rdi     # 0x2c07a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26044(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14e28(%rip), %rdi     # 0x2c0af
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26018(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x14e35(%rip), %rdi     # 0x2c0e8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25fec(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x14e42(%rip), %rdi     # 0x2c121
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25fc0(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xc487(%rip), %rdi      # 0x23791
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x173bf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x25f70(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x31, %rcx
leaq 0x14deb(%rip), %rdi     # 0x2c153
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17216
movq 0x25f2b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x14df7(%rip), %rdi     # 0x2c194
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x8da8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x174c7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x25ec1(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x14db7(%rip), %rdi     # 0x2c1c3
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25e8a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14daf(%rip), %rdi     # 0x2c1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25e5e(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14db0(%rip), %rdi     # 0x2c21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r14d
leaq 0xc33e(%rip), %r15      # 0x237c0
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x174ba
movq 0x25e1e(%rip), %rcx     # 0x3d2b0
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
jmp 0x17485
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x175fb
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x25db9(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x14caf(%rip), %rdi     # 0x2c1c3
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25d82(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14ca7(%rip), %rdi     # 0x2c1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25d56(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14ca8(%rip), %rdi     # 0x2c21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25d2a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x5(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc1f0(%rip), %rdi      # 0x23791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x6, %r14d
leaq 0xc20a(%rip), %r15      # 0x237c0
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x175ee
movq 0x25cea(%rip), %rcx     # 0x3d2b0
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
jmp 0x175b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17706
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25c96(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x14b7e(%rip), %rdi     # 0x2c1c3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25c5a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14b7f(%rip), %rdi     # 0x2c1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25c2e(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14b80(%rip), %rdi     # 0x2c21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25c02(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc0c8(%rip), %rdi      # 0x23791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25bd6(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x14b59(%rip), %rdi     # 0x2c24d
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x177a9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x25b86(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x14b2b(%rip), %rdi     # 0x2c27d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x173c3
movq 0x25b41(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1e, %rcx
leaq 0x14b30(%rip), %rdi     # 0x2c2b7
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9d90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1782c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25aec(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x13, %rcx
movzwl (%rbx), %r8d
leaq 0x14af6(%rip), %rdi     # 0x2c2e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25ab0(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14afe(%rip), %rdi     # 0x2c318
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper
int GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  GET_DISPLAY_SURFACE_SIZE_PARAMETERS *d = (GET_DISPLAY_SURFACE_SIZE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usX_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usX_Size)-start), FILL(14), d->usX_Size, d->usX_Size);
    printf ("%s%04x:  USHORT usY_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usY_Size)-start), FILL(14), d->usY_Size, d->usY_Size);
  }
  return sizeof (GET_DISPLAY_SURFACE_SIZE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x178af
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25a69(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzwl (%rbx), %r8d
leaq 0x14ad8(%rip), %rdi     # 0x2c34a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25a2d(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14adb(%rip), %rdi     # 0x2c378
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: INDIRECT_IO_ACCESS_dumper
int INDIRECT_IO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  INDIRECT_IO_ACCESS *d = (INDIRECT_IO_ACCESS *) 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:  UCHAR IOAccessSequence%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->IOAccessSequence[i])-start), FILL(25+(i>9)), i, d->IOAccessSequence[i], d->IOAccessSequence[i]); }
  }
  return RETURN_ALL (ATOM_INDIRECT_IO_ACCESS, UCHAR);
}

// Assembly:
testq %rsi, %rsi
je 0x1790f
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x259e5(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rsi
addq %rcx, %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1f, %rcx
leaq 0xa2bd(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5d40
movzwl (%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OEM_INFO_dumper
int ATOM_OEM_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OEM_INFO *d = (ATOM_OEM_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);
    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);
  }
  return sizeof (ATOM_OEM_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x179b1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2597e(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xa254(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x25939(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x100f0(%rip), %rdi     # 0x27a7f
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xf719
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TV_MODE_dumper
int ATOM_TV_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TV_MODE *d = (ATOM_TV_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVMode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVMode_Num)-start), FILL(16), d->ucVMode_Num, d->ucVMode_Num);
    printf ("%s%04x:  UCHAR ucTV_Mode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTV_Mode_Num)-start), FILL(18), d->ucTV_Mode_Num, d->ucTV_Mode_Num);
  }
  return sizeof (ATOM_TV_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x17a34
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x258e4(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x149af(%rip), %rdi     # 0x2c3a6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x258a8(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x149b6(%rip), %rdi     # 0x2c3d8
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TV_MODE_SCALER_PTR_dumper
int ATOM_TV_MODE_SCALER_PTR_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TV_MODE_SCALER_PTR *d = (ATOM_TV_MODE_SCALER_PTR *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT ucFilter0_Offset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFilter0_Offset)-start), FILL(22), d->ucFilter0_Offset, d->ucFilter0_Offset);
    printf ("%s%04x:  USHORT usFilter1_Offset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFilter1_Offset)-start), FILL(22), d->usFilter1_Offset, d->usFilter1_Offset);
    printf ("%s%04x:  UCHAR ucTV_Mode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTV_Mode_Num)-start), FILL(18), d->ucTV_Mode_Num, d->ucTV_Mode_Num);
  }
  return sizeof (ATOM_TV_MODE_SCALER_PTR);
}

// Assembly:
testq %rsi, %rsi
je 0x17c2f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25715(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x14958(%rip), %rdi     # 0x2c51e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x256d9(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14962(%rip), %rdi     # 0x2c554
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x256ad(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x147bb(%rip), %rdi     # 0x2c3d8
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_STANDARD_VESA_TIMING_dumper
int ATOM_STANDARD_VESA_TIMING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_STANDARD_VESA_TIMING *d = (ATOM_STANDARD_VESA_TIMING *) 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 < 16; i++) {
      printf ("%s%04x:  ATOM_DTD_FORMAT aModeTimings%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->aModeTimings[i])-start), FILL(31+(i>9)), i); ATOM_DTD_FORMAT_dumper (start, (uint8_t*) &d->aModeTimings[i], indent+1); }
  }
  return sizeof (ATOM_STANDARD_VESA_TIMING);
}

// Assembly:
testq %rsi, %rsi
je 0x17cf7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2565a(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0x9f36(%rip), %rdi      # 0x21bae
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 0x5d40
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x17ce9
movq 0x25603(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x1f, %rcx
leaq 0x1162d(%rip), %rdi     # 0x292f1
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1073d
incq %r13
addq $0x1c, %r14
addl $0x1c, %ebp
jmp 0x17ca0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1c4, %eax            # imm = 0x1C4
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_STD_FORMAT_dumper
int ATOM_STD_FORMAT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_STD_FORMAT *d = (ATOM_STD_FORMAT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSTD_HDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_HDisp)-start), FILL(17), d->usSTD_HDisp, d->usSTD_HDisp);
    printf ("%s%04x:  USHORT usSTD_VDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_VDisp)-start), FILL(17), d->usSTD_VDisp, d->usSTD_VDisp);
    printf ("%s%04x:  USHORT usSTD_RefreshRate%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_RefreshRate)-start), FILL(23), d->usSTD_RefreshRate, d->usSTD_RefreshRate);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_STD_FORMAT);
}

// Assembly:
testq %rsi, %rsi
je 0x17dd8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25598(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x14847(%rip), %rdi     # 0x2c58a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2555c(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1484c(%rip), %rdi     # 0x2c5bb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25530(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x14851(%rip), %rdi     # 0x2c5ec
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25504(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xf88e(%rip), %rdi      # 0x27654
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq