LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper
int DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *d = (DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DP_ENCODER_SERVICE_PARAMETERS_V2 asDPServiceParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asDPServiceParam)-start), FILL(48)); DP_ENCODER_SERVICE_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asDPServiceParam, indent+1);
    printf ("%s%04x:  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 asAuxParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asAuxParam)-start), FILL(55)); PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asAuxParam, indent+1);
  }
  return sizeof (DP_ENCODER_SERVICE_PS_ALLOCATION_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1cff5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2033a(%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 $0x30, %rcx
leaq 0x121ba(%rip), %rdi     # 0x2f158
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1cdf6
movq 0x202f5(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x121c5(%rip), %rdi     # 0x2f198
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1ccc5
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: PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper
int PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *d = (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucI2CSpeed%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CSpeed)-start), FILL(15), d->ucI2CSpeed, d->ucI2CSpeed);
    printf ("%s  <unparsable> line 3859:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1d059
pushq %rbx
movq 0x202aa(%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, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0xf, %rcx
movzbl (%rsi), %r8d
leaq 0x121af(%rip), %rdi     # 0x2f1df
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x2026c(%rip), %rbx     # 0x3d2b0
leaq 0x121c5(%rip), %rdi     # 0x2f210
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper
int SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_HWBLOCK_INSTANCE_PARAMETER_V2 *d = (SET_HWBLOCK_INSTANCE_PARAMETER_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucHWBlkInst%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWBlkInst)-start), FILL(16), d->ucHWBlkInst, d->ucHWBlkInst);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucReserved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved[i])-start), FILL(19+(i>9)), i, d->ucReserved[i], d->ucReserved[i]); }
  }
  return sizeof (SET_HWBLOCK_INSTANCE_PARAMETER_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1d108
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x2022a(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x121a0(%rip), %rax     # 0x2f243
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x691b(%rip), %r15      # 0x239de
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x1d0fb
movq 0x201dd(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x13, %rcx
movzbl 0x1(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
jmp 0x1d0c6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DAC_INFO_dumper
int ATOM_DAC_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DAC_INFO *d = (ATOM_DAC_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:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    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_DAC_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d1cc
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20185(%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 $0x1f, %rcx
leaq 0x4a5c(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5d40
movq 0x20141(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x120eb(%rip), %rdi     # 0x2f275
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20115(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xa49f(%rip), %rdi      # 0x27654
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_dumper
int ATOM_CONNECTOR_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO *d = (ATOM_CONNECTOR_INFO *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR bfAssociatedDAC:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfAssociatedDAC, d->bfAssociatedDAC);
    printf ("%s       UCHAR bfConnectorType:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfConnectorType, d->bfConnectorType);
  }
  return sizeof (ATOM_CONNECTOR_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d64f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x1fcc5(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x16, %rax
movzbl (%rbx), %ecx
andl $0xf, %ecx
leaq 0x121ba(%rip), %rdi     # 0x2f7cd
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x1fc89(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x16, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
leaq 0x121ca(%rip), %rdi     # 0x2f805
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_ACCESS_dumper
int ATOM_CONNECTOR_INFO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO_ACCESS *d = (ATOM_CONNECTOR_INFO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_CONNECTOR_INFO sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(36)); ATOM_CONNECTOR_INFO_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) UCHAR ucAccess%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAccess)-start), FILL(21), d->ucAccess, d->ucAccess);
  }
  return sizeof (ATOM_CONNECTOR_INFO_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0x1d6e0
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x1fc41(%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, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x24, %rcx
leaq 0x121a6(%rip), %rdi     # 0x2f83d
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1d5d8
movq 0x1fbfc(%rip), %rcx     # 0x3d2b0
addq %rcx, %r14
addq $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0xa1aa(%rip), %rdi      # 0x27870
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_I2C_dumper
int ATOM_CONNECTOR_INFO_I2C_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO_I2C *d = (ATOM_CONNECTOR_INFO_I2C *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_CONNECTOR_INFO_ACCESS sucConnectorInfo%s :\n", IND(indent), (int)(((uint8_t*)&d->sucConnectorInfo)-start), FILL(42)); ATOM_CONNECTOR_INFO_ACCESS_dumper (start, (uint8_t*) &d->sucConnectorInfo, 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_CONNECTOR_INFO_I2C);
}

// Assembly:
testq %rsi, %rsi
je 0x1d782
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fbac(%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 0x12145(%rip), %rdi     # 0x2f871
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d653
movq 0x1fb67(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0xa31f(%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 $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SUPPORTED_DEVICES_INFO_dumper
int ATOM_SUPPORTED_DEVICES_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SUPPORTED_DEVICES_INFO *d = (ATOM_SUPPORTED_DEVICES_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:  USHORT usDeviceSupport%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceSupport)-start), FILL(21), d->usDeviceSupport, d->usDeviceSupport);
    for (i = 0; i < 10; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INFO_I2C asConnInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asConnInfo[i])-start), FILL(37+(i>9)), i); ATOM_CONNECTOR_INFO_I2C_dumper (start, (uint8_t*) &d->asConnInfo[i], indent+1); }
  }
  return sizeof (ATOM_SUPPORTED_DEVICES_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d86e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fb07(%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 0x43e3(%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
movq 0x1fac0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzwl 0x4(%r14), %r8d
leaq 0xc138(%rip), %rdi      # 0x29943
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
cmpq $0xa, %r13
je 0x1d860
movq 0x1fa84(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x25, %rcx
leaq 0x12070(%rip), %rdi     # 0x2f8ab
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d6e4
incq %r13
addq $0x2, %r14
addl $0x2, %ebp
jmp 0x1d81f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0x1a
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SUPPORTED_DEVICES_INFO_2_dumper
int ATOM_SUPPORTED_DEVICES_INFO_2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SUPPORTED_DEVICES_INFO_2 *d = (ATOM_SUPPORTED_DEVICES_INFO_2 *) 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:  USHORT usDeviceSupport%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceSupport)-start), FILL(21), d->usDeviceSupport, d->usDeviceSupport);
    for (i = 0; i < 10; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INFO_I2C asConnInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asConnInfo[i])-start), FILL(37+(i>9)), i); ATOM_CONNECTOR_INFO_I2C_dumper (start, (uint8_t*) &d->asConnInfo[i], indent+1); }
    for (i = 0; i < 10; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INC_SRC_BITMAP asIntSrcInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asIntSrcInfo[i])-start), FILL(45+(i>9)), i); ATOM_CONNECTOR_INC_SRC_BITMAP_dumper (start, (uint8_t*) &d->asIntSrcInfo[i], indent+1); }
  }
  return sizeof (ATOM_SUPPORTED_DEVICES_INFO_2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x1da06
movl %edx, %ebx
movq 0x1f9c9(%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, %r14
leaq (%rcx,%r14), %rsi
addq $0x1f, %rcx
leaq 0x42a5(%rip), %rdi      # 0x21bae
movq 0x10(%rsp), %r12
movl %r12d, %ebp
movq 0x8(%rsp), %r15
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x1f978(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
leaq 0x4(%r12), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzwl 0x4(%r12), %r8d
leaq 0xbfee(%rip), %rdi      # 0x29943
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r12
addl $0x6, %ebp
leaq 0x11f3e(%rip), %r15     # 0x2f8ab
xorl %r13d, %r13d
cmpq $0xa, %r13
je 0x1d9af
movq 0x1f933(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
addq $0x25, %rcx
movq %r15, %rdi
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1d6e4
incq %r13
addq $0x2, %r12
addl $0x2, %ebp
jmp 0x1d970
movq 0x10(%rsp), %r15
leaq 0x1a(%r15), %r12
subl 0x8(%rsp), %r15d
addl $0x1a, %r15d
xorl %r13d, %r13d
cmpq $0xa, %r13
je 0x1da06
movq 0x1f8df(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
leaq (%r12,%r13), %rbp
leal (%r15,%r13), %edx
addq $0x2d, %rcx
leaq 0x11f2e(%rip), %rdi     # 0x2f916
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0x1d872
incq %r13
jmp 0x1d9c4
pushq $0x24
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SUPPORTED_DEVICES_INFO_2d1_dumper
int ATOM_SUPPORTED_DEVICES_INFO_2d1_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SUPPORTED_DEVICES_INFO_2d1 *d = (ATOM_SUPPORTED_DEVICES_INFO_2d1 *) 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:  USHORT usDeviceSupport%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceSupport)-start), FILL(21), d->usDeviceSupport, d->usDeviceSupport);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INFO_I2C asConnInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asConnInfo[i])-start), FILL(37+(i>9)), i); ATOM_CONNECTOR_INFO_I2C_dumper (start, (uint8_t*) &d->asConnInfo[i], indent+1); }
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INC_SRC_BITMAP asIntSrcInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asIntSrcInfo[i])-start), FILL(45+(i>9)), i); ATOM_CONNECTOR_INC_SRC_BITMAP_dumper (start, (uint8_t*) &d->asIntSrcInfo[i], indent+1); }
  }
  return sizeof (ATOM_SUPPORTED_DEVICES_INFO_2d1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x1db71
movl %edx, %ebx
movq 0x1f86e(%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, %r14
leaq (%rcx,%r14), %rsi
addq $0x1f, %rcx
leaq 0x414a(%rip), %rdi      # 0x21bae
movq 0x10(%rsp), %r12
movl %r12d, %ebp
movq 0x8(%rsp), %r15
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x1f81d(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
leaq 0x4(%r12), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzwl 0x4(%r12), %r8d
leaq 0xbe93(%rip), %rdi      # 0x29943
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r12
addl $0x6, %ebp
leaq 0x11de3(%rip), %r15     # 0x2f8ab
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x1db12
movq 0x1f7d8(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x25, %rcx
movq %r15, %rdi
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1d6e4
incq %r13
addq $0x2, %r12
addl $0x2, %ebp
jmp 0x1dacb
movq 0x10(%rsp), %r15
leaq 0x26(%r15), %r12
subl 0x8(%rsp), %r15d
addl $0x26, %r15d
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x1db71
movq 0x1f77c(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r14), %rsi
leaq (%r12,%r13), %rbp
leal (%r15,%r13), %edx
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x2d, %rcx
leaq 0x11dc3(%rip), %rdi     # 0x2f916
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0x1d872
incq %r13
jmp 0x1db27
pushq $0x36
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MISC_CONTROL_INFO_dumper
int ATOM_MISC_CONTROL_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MISC_CONTROL_INFO *d = (ATOM_MISC_CONTROL_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFrequency)-start), FILL(17), d->usFrequency, d->usFrequency);
    printf ("%s%04x:  UCHAR ucPLL_ChargePump%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_ChargePump)-start), FILL(21), d->ucPLL_ChargePump, d->ucPLL_ChargePump);
    printf ("%s%04x:  UCHAR ucPLL_DutyCycle%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_DutyCycle)-start), FILL(20), d->ucPLL_DutyCycle, d->ucPLL_DutyCycle);
    printf ("%s%04x:  UCHAR ucPLL_VCO_Gain%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VCO_Gain)-start), FILL(19), d->ucPLL_VCO_Gain, d->ucPLL_VCO_Gain);
    printf ("%s%04x:  UCHAR ucPLL_VoltageSwing%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VoltageSwing)-start), FILL(23), d->ucPLL_VoltageSwing, d->ucPLL_VoltageSwing);
  }
  return sizeof (ATOM_MISC_CONTROL_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1dc8a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1f712(%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 0x11d8b(%rip), %rdi     # 0x2f954
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f6d6(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x11d90(%rip), %rdi     # 0x2f985
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f6aa(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x11d9b(%rip), %rdi     # 0x2f9bc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f67e(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x11da5(%rip), %rdi     # 0x2f9f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f652(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x11daf(%rip), %rdi     # 0x2fa27
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TMDS_INFO_dumper
int ATOM_TMDS_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TMDS_INFO *d = (ATOM_TMDS_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:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  ATOM_MISC_CONTROL_INFO asMiscInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asMiscInfo[i])-start), FILL(36+(i>9)), i); ATOM_MISC_CONTROL_INFO_dumper (start, (uint8_t*) &d->asMiscInfo[i], indent+1); }
  }
  return sizeof (ATOM_TMDS_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1dd76
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f5ff(%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 0x3edb(%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
movq 0x1f5b8(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x11562(%rip), %rdi     # 0x2f275
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
cmpq $0x4, %r13
je 0x1dd68
movq 0x1f57c(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x24, %rcx
leaq 0x11d1d(%rip), %rdi     # 0x2fa60
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1db83
incq %r13
addq $0x6, %r14
addl $0x6, %ebp
jmp 0x1dd27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0x1e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper
int ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ANALOG_ATTRIBUTE *d = (ATOM_ENCODER_ANALOG_ATTRIBUTE *) data;
  int i;
  if (d) {
    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 (ATOM_ENCODER_ANALOG_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1de09
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1f517(%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
movzbl (%rbx), %r8d
leaq 0xe283(%rip), %rdi      # 0x2c047
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f4db(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x59cd(%rip), %rdi      # 0x237c0
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_ENCODER_DIGITAL_ATTRIBUTE_dumper
int ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_DIGITAL_ATTRIBUTE *d = (ATOM_ENCODER_DIGITAL_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucAttribute%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAttribute)-start), FILL(16), d->ucAttribute, d->ucAttribute);
    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 (ATOM_ENCODER_DIGITAL_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1de9c
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1f484(%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 0x11c3e(%rip), %rdi     # 0x2fa95
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f448(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x593a(%rip), %rdi      # 0x237c0
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_ENCODER_ATTRIBUTE_dumper
int ATOM_ENCODER_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ATTRIBUTE *d = (ATOM_ENCODER_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_ENCODER_ANALOG_ATTRIBUTE sAlgAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sAlgAttrib)-start), FILL(47)); ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (start, (uint8_t*) &d->sAlgAttrib, indent+1);
    printf ("%s%04x:  (union) ATOM_ENCODER_DIGITAL_ATTRIBUTE sDigAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sDigAttrib)-start), FILL(48)); ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (start, (uint8_t*) &d->sDigAttrib, indent+1);
  }
  return sizeof (ATOM_ENCODER_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1df36
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f3f0(%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, %ebp
subl %r15d, %ebp
addq $0x2f, %rcx
leaq 0x11bdf(%rip), %rdi     # 0x2fac7
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1dd7a
movq 0x1f3a9(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x30, %rcx
leaq 0x11bf1(%rip), %rdi     # 0x2fb06
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1de0d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PARAMETERS_dumper
int DVO_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PARAMETERS *d = (DVO_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  USHORT usEncoderID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usEncoderID)-start), FILL(17), d->usEncoderID, d->usEncoderID);
    printf ("%s%04x:  UCHAR ucDeviceType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDeviceType)-start), FILL(17), d->ucDeviceType, d->ucDeviceType);
    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:  ATOM_ENCODER_ATTRIBUTE usDevAttr%s :\n", IND(indent), (int)(((uint8_t*)&d->usDevAttr)-start), FILL(31)); ATOM_ENCODER_ATTRIBUTE_dumper (start, (uint8_t*) &d->usDevAttr, indent+1);
  }
  return sizeof (DVO_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1e057
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f356(%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 $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x595f(%rip), %rdi      # 0x238e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f319(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x11b94(%rip), %rdi     # 0x2fb46
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f2ed(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x11b99(%rip), %rdi     # 0x2fb77
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f2c1(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x5(%r14), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x5(%r14), %r8d
leaq 0x537e(%rip), %rdi      # 0x23388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1f295(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x6, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x11b77(%rip), %rdi     # 0x2fbaa
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1dea0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper
int DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PS_ALLOCATION *d = (DVO_ENCODER_CONTROL_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DVO_ENCODER_CONTROL_PARAMETERS sDVOEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sDVOEncoder)-start), FILL(41)); DVO_ENCODER_CONTROL_PARAMETERS_dumper (start, (uint8_t*) &d->sDVOEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (DVO_ENCODER_CONTROL_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x1e0fa
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f235(%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 $0x29, %rcx
leaq 0x11b36(%rip), %rdi     # 0x2fbd9
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1df3a
movq 0x1f1f0(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x6c5a(%rip), %rdi      # 0x24d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa00b
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: DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper
int DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DFP_DPMS_STATUS_CHANGE_PARAMETERS *d = (DFP_DPMS_STATUS_CHANGE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucDevice%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDevice)-start), FILL(13), d->ucDevice, d->ucDevice);
    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 (DFP_DPMS_STATUS_CHANGE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1e37d
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 0x1efdf(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x54a3(%rip), %rdi      # 0x23791
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1efa8(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leaq 0x1(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x5f9c(%rip), %rdi      # 0x242bf
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x2, %r14d
leaq 0x5488(%rip), %r15      # 0x237c0
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x1e370
movq 0x1ef68(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x2(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
jmp 0x1e33b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_STATE_dumper
int ATOM_PPLIB_STATE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_STATE *d = (ATOM_PPLIB_STATE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNonClockStateIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNonClockStateIndex)-start), FILL(25), d->ucNonClockStateIndex, d->ucNonClockStateIndex);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucClockStateIndices%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucClockStateIndices[i])-start), FILL(28+(i>9)), i, d->ucClockStateIndices[i], d->ucClockStateIndices[i]); }
  }
  return sizeof (ATOM_PPLIB_STATE);
}

// Assembly:
testq %rsi, %rsi
je 0x1f0a2
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1e27e(%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
movzbl (%rbx), %r8d
leaq 0x11267(%rip), %rdi     # 0x302c4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e242(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x1c, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x11273(%rip), %rdi     # 0x302ff
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_PPLIB_EXTENDEDHEADER_dumper
int ATOM_PPLIB_EXTENDEDHEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_EXTENDEDHEADER *d = (ATOM_PPLIB_EXTENDEDHEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  ULONG ulMaxEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxEngineClock)-start), FILL(21), d->ulMaxEngineClock, d->ulMaxEngineClock);
    printf ("%s%04x:  ULONG ulMaxMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxMemoryClock)-start), FILL(21), d->ulMaxMemoryClock, d->ulMaxMemoryClock);
  }
  return sizeof (ATOM_PPLIB_EXTENDEDHEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x1f2e2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1e060(%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 $0xc, %rcx
movzwl (%rbx), %r8d
leaq 0xa8ad(%rip), %rdi      # 0x29b28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e024(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x2(%rbx), %r8d
leaq 0x1120d(%rip), %rdi     # 0x304b3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1dff9(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x6(%rbx), %r8d
leaq 0x11214(%rip), %rdi     # 0x304e4
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0xa
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_POWERPLAYTABLE2_dumper
int ATOM_PPLIB_POWERPLAYTABLE2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE2 *d = (ATOM_PPLIB_POWERPLAYTABLE2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE basicTable%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable)-start), FILL(35)); ATOM_PPLIB_POWERPLAYTABLE_dumper (start, (uint8_t*) &d->basicTable, indent+1);
    printf ("%s%04x:  UCHAR ucNumCustomThermalPolicy%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumCustomThermalPolicy)-start), FILL(29), d->ucNumCustomThermalPolicy, d->ucNumCustomThermalPolicy);
    printf ("%s%04x:  USHORT usCustomThermalPolicyArrayOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usCustomThermalPolicyArrayOffset)-start), FILL(38), d->usCustomThermalPolicyArrayOffset, d->usCustomThermalPolicyArrayOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE2);
}

// Assembly:
testq %rsi, %rsi
je 0x1f6ac
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1dca5(%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 $0x23, %rcx
leaq 0x1121d(%rip), %rdi     # 0x3084f
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1f2e6
movq 0x1dc61(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x25(%rbx), %rdx
subl %r14d, %edx
addq $0x1d, %rcx
movzbl 0x25(%rbx), %r8d
leaq 0x11218(%rip), %rdi     # 0x30882
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1dc35(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x26(%rbx), %rdx
subl %r14d, %edx
addq $0x26, %rcx
movzwl 0x26(%rbx), %r8d
leaq 0x1122c(%rip), %rdi     # 0x308c1
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x28
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_POWERPLAYTABLE3_dumper
int ATOM_PPLIB_POWERPLAYTABLE3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE3 *d = (ATOM_PPLIB_POWERPLAYTABLE3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE2 basicTable2%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable2)-start), FILL(37)); ATOM_PPLIB_POWERPLAYTABLE2_dumper (start, (uint8_t*) &d->basicTable2, indent+1);
    printf ("%s%04x:  USHORT usFormatID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFormatID)-start), FILL(16), d->usFormatID, d->usFormatID);
    printf ("%s%04x:  USHORT usFanTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFanTableOffset)-start), FILL(22), d->usFanTableOffset, d->usFanTableOffset);
    printf ("%s%04x:  USHORT usExtendendedHeaderOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usExtendendedHeaderOffset)-start), FILL(31), d->usExtendendedHeaderOffset, d->usExtendendedHeaderOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE3);
}

// Assembly:
testq %rsi, %rsi
je 0x1f79c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1dbe1(%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 $0x25, %rcx
leaq 0x11211(%rip), %rdi     # 0x30907
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1f5ec
movq 0x1db9d(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x28(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x28(%rbx), %r8d
leaq 0x1120e(%rip), %rdi     # 0x3093c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1db71(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2a(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2a(%rbx), %r8d
leaq 0x11212(%rip), %rdi     # 0x3096c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1db45(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2c(%rbx), %rdx
subl %r14d, %edx
addq $0x1f, %rcx
movzwl 0x2c(%rbx), %r8d
leaq 0x1121d(%rip), %rdi     # 0x309a2
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x2e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_THERMAL_STATE_dumper
int ATOM_PPLIB_THERMAL_STATE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_THERMAL_STATE *d = (ATOM_PPLIB_THERMAL_STATE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucMinTemperature%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMinTemperature)-start), FILL(21), d->ucMinTemperature, d->ucMinTemperature);
    printf ("%s%04x:  UCHAR ucMaxTemperature%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxTemperature)-start), FILL(21), d->ucMaxTemperature, d->ucMaxTemperature);
    printf ("%s%04x:  UCHAR ucThermalAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucThermalAction)-start), FILL(20), d->ucThermalAction, d->ucThermalAction);
  }
  return sizeof (ATOM_PPLIB_THERMAL_STATE);
}

// Assembly:
testq %rsi, %rsi
je 0x1fb7d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d7c7(%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 $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0x10358(%rip), %rdi     # 0x2fe6c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d78b(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x10363(%rip), %rdi     # 0x2fea3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d75f(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1113f(%rip), %rdi     # 0x30caa
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_STATE_V2_dumper
int ATOM_PPLIB_STATE_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_STATE_V2 *d = (ATOM_PPLIB_STATE_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumDPMLevels%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumDPMLevels)-start), FILL(19), d->ucNumDPMLevels, d->ucNumDPMLevels);
    printf ("%s%04x:  UCHAR nonClockInfoIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->nonClockInfoIndex)-start), FILL(22), d->nonClockInfoIndex, d->nonClockInfoIndex);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR clockInfoIndex%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->clockInfoIndex[i])-start), FILL(23+(i>9)), i, d->clockInfoIndex[i], d->clockInfoIndex[i]); }
  }
  return sizeof (ATOM_PPLIB_STATE_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x204fe
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1ce4e(%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
movzbl (%rbx), %r8d
leaq 0x10dd1(%rip), %rdi     # 0x3125e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ce12(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x10dda(%rip), %rdi     # 0x31293
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cde6(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x10de3(%rip), %rdi     # 0x312cb
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
pushq $0x3
popq %rax
retq