LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DPCD_INFO_dumper
int ATOM_DPCD_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DPCD_INFO *d = (ATOM_DPCD_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRevisionNumber%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRevisionNumber)-start), FILL(21), d->ucRevisionNumber, d->ucRevisionNumber);
    printf ("%s%04x:  UCHAR ucMaxLinkRate%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxLinkRate)-start), FILL(18), d->ucMaxLinkRate, d->ucMaxLinkRate);
    printf ("%s%04x:  UCHAR ucMaxLane%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxLane)-start), FILL(14), d->ucMaxLane, d->ucMaxLane);
    printf ("%s%04x:  UCHAR ucMaxDownSpread%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxDownSpread)-start), FILL(20), d->ucMaxDownSpread, d->ucMaxDownSpread);
  }
  return sizeof (ATOM_DPCD_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x11d22
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b64e(%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 0x17694(%rip), %rdi     # 0x29321
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b612(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1769f(%rip), %rdi     # 0x29358
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b5e6(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x176a7(%rip), %rdi     # 0x2938c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b5ba(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x176ac(%rip), %rdi     # 0x293bc
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: ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper
int ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_VRAM_RESERVE_INFO *d = (ATOM_FIRMWARE_VRAM_RESERVE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulStartAddrUsedByFirmware%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStartAddrUsedByFirmware)-start), FILL(30), d->ulStartAddrUsedByFirmware, d->ulStartAddrUsedByFirmware);
    printf ("%s%04x:  USHORT usFirmwareUseInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFirmwareUseInKb)-start), FILL(23), d->usFirmwareUseInKb, d->usFirmwareUseInKb);
    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_FIRMWARE_VRAM_RESERVE_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x11dd4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b56f(%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 $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x17687(%rip), %rdi     # 0x293f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b534(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17695(%rip), %rdi     # 0x2942c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b508(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x15892(%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
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_USAGE_BY_FIRMWARE_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE *d = (ATOM_VRAM_USAGE_BY_FIRMWARE *) 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_FIRMWARE_VRAM_RESERVE_INFO asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(60+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE);
}

// Assembly:
testq %rsi, %rsi
je 0x11e7a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2b4b8(%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 0xfd8e(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x2b473(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x1760e(%rip), %rdi     # 0x29463
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x11d26
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: ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper
int ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 *d = (ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulStartAddrUsedByFirmware%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStartAddrUsedByFirmware)-start), FILL(30), d->ulStartAddrUsedByFirmware, d->ulStartAddrUsedByFirmware);
    printf ("%s%04x:  USHORT usFirmwareUseInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFirmwareUseInKb)-start), FILL(23), d->usFirmwareUseInKb, d->usFirmwareUseInKb);
    printf ("%s%04x:  USHORT usFBUsedByDrvInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFBUsedByDrvInKb)-start), FILL(23), d->usFBUsedByDrvInKb, d->usFBUsedByDrvInKb);
  }
  return sizeof (ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5);
}

// Assembly:
testq %rsi, %rsi
je 0x11f2c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b417(%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 $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x1752f(%rip), %rdi     # 0x293f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b3dc(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1753d(%rip), %rdi     # 0x2942c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b3b0(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17596(%rip), %rdi     # 0x294b0
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_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *d = (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *) 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_FIRMWARE_VRAM_RESERVE_INFO_V1_5 asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(65+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5);
}

// Assembly:
testq %rsi, %rsi
je 0x11fd2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2b360(%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 0xfc36(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x2b31b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x1753a(%rip), %rdi     # 0x294e7
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x11e7e
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: ATOM_GPIO_PIN_ASSIGNMENT_dumper
int ATOM_GPIO_PIN_ASSIGNMENT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_ASSIGNMENT *d = (ATOM_GPIO_PIN_ASSIGNMENT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usGpioPin_AIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGpioPin_AIndex)-start), FILL(22), d->usGpioPin_AIndex, d->usGpioPin_AIndex);
    printf ("%s%04x:  UCHAR ucGpioPinBitShift%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGpioPinBitShift)-start), FILL(22), d->ucGpioPinBitShift, d->ucGpioPinBitShift);
    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);
  }
  return sizeof (ATOM_GPIO_PIN_ASSIGNMENT);
}

// Assembly:
testq %rsi, %rsi
je 0x12085
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b2bf(%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 0x1751d(%rip), %rdi     # 0x29539
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b283(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17527(%rip), %rdi     # 0x2956f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b257(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17534(%rip), %rdi     # 0x295a7
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: ATOM_GPIO_PIN_LUT_dumper
int ATOM_GPIO_PIN_LUT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_LUT *d = (ATOM_GPIO_PIN_LUT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < COUNT_ALL (ATOM_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT); i++) {
      printf ("%s%04x:  ATOM_GPIO_PIN_ASSIGNMENT asGPIO_Pin%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asGPIO_Pin[i])-start), FILL(38+(i>9)), i); ATOM_GPIO_PIN_ASSIGNMENT_dumper (start, (uint8_t*) &d->asGPIO_Pin[i], indent+1); }
  }
  return RETURN_ALL (ATOM_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT);
}

// Assembly:
testq %rsi, %rsi
je 0x1216e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r12
movq 0x2b203(%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, %rax
movq %rax, (%rsp)
leaq (%rcx,%rax), %rsi
addq $0x1f, %rcx
leaq 0xfadb(%rip), %rdi      # 0x21bae
movl %r14d, %ebp
subl %r12d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r13d
movq %r12, %rbx
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %r15d
movl %r13d, %edx
callq 0x5d40
leaq 0x4(%r14), %r12
addl $0x4, %ebp
xorl %r13d, %r13d
movzwl (%r14), %eax
leaq -0x4(%rax), %rcx
shrq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x1215c
movq 0x2b195(%rip), %rcx     # 0x3d2b0
movq (%rsp), %rax
leaq (%rcx,%rax), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x26, %rcx
leaq 0x174a1(%rip), %rdi     # 0x295d7
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x11fd6
incq %r13
addq $0x4, %r12
addl $0x4, %ebp
jmp 0x12103
andl $-0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_INFO_dumper
int ATOM_GPIO_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_INFO *d = (ATOM_GPIO_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usAOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usAOffset)-start), FILL(15), d->usAOffset, d->usAOffset);
    printf ("%s%04x:  UCHAR ucSettings%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSettings)-start), FILL(15), d->ucSettings, d->ucSettings);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
  }
  return sizeof (ATOM_GPIO_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x12220
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b124(%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 $0xf, %rcx
movzwl (%rbx), %r8d
leaq 0x17457(%rip), %rdi     # 0x2960e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b0e8(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1745a(%rip), %rdi     # 0x2963d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2b0bc(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xfd3e(%rip), %rdi      # 0x21f4c
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: ATOM_DISPLAY_OBJECT_PATH_dumper
int ATOM_DISPLAY_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH *d = (ATOM_DISPLAY_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    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:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x12d15
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a68f(%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 0x16eab(%rip), %rdi     # 0x29af7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a653(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x16eb0(%rip), %rdi     # 0x29b28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a627(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x16eb0(%rip), %rdi     # 0x29b54
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a5fb(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x16eb8(%rip), %rdi     # 0x29b88
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a5cf(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x16ebc(%rip), %rdi     # 0x29bbb
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
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_DISPLAY_EXTERNAL_OBJECT_PATH_dumper
int ATOM_DISPLAY_EXTERNAL_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *d = (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    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:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x12e45
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x2a56c(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x16d96(%rip), %rdi     # 0x29af7
movl %ebx, %ebp
subl %r14d, %ebp
movl %ebp, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a537(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x16d94(%rip), %rdi     # 0x29b28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a50b(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x16d94(%rip), %rdi     # 0x29b54
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a4df(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x16d9c(%rip), %rdi     # 0x29b88
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x8, %ebp
leaq 0x16dbb(%rip), %r14     # 0x29bbb
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x12e39
movq 0x2a4a0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x19, %rcx
movzwl 0x8(%rbx,%r15,2), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x2, %ebp
jmp 0x12e03
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper
int ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH_TABLE *d = (ATOM_DISPLAY_OBJECT_PATH_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumOfDispPath%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfDispPath)-start), FILL(20), d->ucNumOfDispPath, d->ucNumOfDispPath);
    printf ("%s%04x:  UCHAR ucVersion%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVersion)-start), FILL(14), d->ucVersion, d->ucVersion);
    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]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_DISPLAY_OBJECT_PATH asDispPath%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asDispPath[i])-start), FILL(38+(i>9)), i); ATOM_DISPLAY_OBJECT_PATH_dumper (start, (uint8_t*) &d->asDispPath[i], indent+1); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x12f5c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r13
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x2a438(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
addq $0x14, %rcx
movzbl (%r14), %r8d
leaq 0x16d60(%rip), %rdi     # 0x29bf5
movl %r14d, %r12d
subl %r13d, %r12d
movl %r12d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a401(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%r14), %rdx
movq %r13, 0x10(%rsp)
subl %r13d, %edx
addq $0xe, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x16d5c(%rip), %rdi     # 0x29c2b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x2, %r12d
leaq 0x108dc(%rip), %r13     # 0x237c0
xorl %ebp, %ebp
movq 0x2a3c3(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
cmpq $0x2, %rbp
je 0x12f1b
leal (%r12,%rbp), %edx
addq $0x12, %rcx
movzbl 0x2(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
jmp 0x12ee6
addq $0x4, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x26, %rcx
leaq 0x16d26(%rip), %rdi     # 0x29c5b
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12c02
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0xe
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_dumper
int ATOM_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT *d = (ATOM_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usObjectID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usObjectID)-start), FILL(16), d->usObjectID, d->usObjectID);
    printf ("%s%04x:  USHORT usSrcDstTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSrcDstTableOffset)-start), FILL(25), d->usSrcDstTableOffset, d->usSrcDstTableOffset);
    printf ("%s%04x:  USHORT usRecordOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRecordOffset)-start), FILL(20), d->usRecordOffset, d->usRecordOffset);
    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_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x1303b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a335(%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
movzwl (%rbx), %r8d
leaq 0x16cec(%rip), %rdi     # 0x29c92
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a2f9(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x16cf0(%rip), %rdi     # 0x29cc2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a2cd(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x16cfd(%rip), %rdi     # 0x29cfb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a2a1(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1462b(%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
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_TABLE_dumper
int ATOM_OBJECT_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT_TABLE *d = (ATOM_OBJECT_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumberOfObjects%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfObjects)-start), FILL(22), d->ucNumberOfObjects, d->ucNumberOfObjects);
    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]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_OBJECT asObjects%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asObjects[i])-start), FILL(24+(i>9)), i); ATOM_OBJECT_dumper (start, (uint8_t*) &d->asObjects[i], indent+1); }
  }
  return sizeof (ATOM_OBJECT_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x13125
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r9
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x2a242(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
addq $0x16, %rcx
movzbl (%r14), %r8d
leaq 0x16ca4(%rip), %rdi     # 0x29d2f
movl %r14d, %r12d
movq %r9, 0x10(%rsp)
subl %r9d, %r12d
movl %r12d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r12d
leaq 0x10713(%rip), %r13     # 0x237c0
xorl %ebp, %ebp
movq 0x2a1fa(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
cmpq $0x3, %rbp
je 0x130e4
leal (%r12,%rbp), %edx
addq $0x12, %rcx
movzbl 0x1(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
jmp 0x130af
addq $0x4, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x18, %rcx
leaq 0x16c69(%rip), %rdi     # 0x29d67
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12f60
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT_dumper
int ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *d = (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumberOfSrc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfSrc)-start), FILL(18), d->ucNumberOfSrc, d->ucNumberOfSrc);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usSrcObjectID%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSrcObjectID[i])-start), FILL(23+(i>9)), i, d->usSrcObjectID[i], d->usSrcObjectID[i]); }
    printf ("%s%04x:  UCHAR ucNumberOfDst%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfDst)-start), FILL(18), d->ucNumberOfDst, d->ucNumberOfDst);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usDstObjectID%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDstObjectID[i])-start), FILL(23+(i>9)), i, d->usDstObjectID[i], d->usDstObjectID[i]); }
  }
  return sizeof (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x13214
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a168(%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 $0x12, %rcx
movzbl (%rbx), %r8d
leaq 0x16c1d(%rip), %rdi     # 0x29d90
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a12c(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x16c21(%rip), %rdi     # 0x29dc4
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2a0fc(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x16c2d(%rip), %rdi     # 0x29dfc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a0d0(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x16c32(%rip), %rdi     # 0x29e30
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
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_DP_CONN_CHANNEL_MAPPING_dumper
int ATOM_DP_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DP_CONN_CHANNEL_MAPPING *d = (ATOM_DP_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDP_Lane0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane0_Source, d->ucDP_Lane0_Source);
    printf ("%s       UCHAR ucDP_Lane1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane1_Source, d->ucDP_Lane1_Source);
    printf ("%s       UCHAR ucDP_Lane2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane2_Source, d->ucDP_Lane2_Source);
    printf ("%s       UCHAR ucDP_Lane3_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane3_Source, d->ucDP_Lane3_Source);
  }
  return sizeof (ATOM_DP_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x132e5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2a081(%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 $0x18, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x16c11(%rip), %rdi     # 0x29e68
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2a045(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x16c1f(%rip), %rdi     # 0x29ea2
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2a01c(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x16c30(%rip), %rdi     # 0x29edc
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x29ff3(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x16c45(%rip), %rdi     # 0x29f16
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_DVI_CONN_CHANNEL_MAPPING_dumper
int ATOM_DVI_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DVI_CONN_CHANNEL_MAPPING *d = (ATOM_DVI_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDVI_DATA2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA2_Source, d->ucDVI_DATA2_Source);
    printf ("%s       UCHAR ucDVI_DATA1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA1_Source, d->ucDVI_DATA1_Source);
    printf ("%s       UCHAR ucDVI_DATA0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA0_Source, d->ucDVI_DATA0_Source);
    printf ("%s       UCHAR ucDVI_CLK_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucDVI_CLK_Source, d->ucDVI_CLK_Source);
  }
  return sizeof (ATOM_DVI_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x133b6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x29fb0(%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 $0x19, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x16c28(%rip), %rdi     # 0x29f50
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x29f74(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x16c37(%rip), %rdi     # 0x29f8b
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x29f4b(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x16c49(%rip), %rdi     # 0x29fc6
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x29f22(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x16c5f(%rip), %rdi     # 0x2a001
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_COMMON_RECORD_HEADER_dumper
int ATOM_COMMON_RECORD_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_RECORD_HEADER *d = (ATOM_COMMON_RECORD_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucRecordSize%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordSize)-start), FILL(17), d->ucRecordSize, d->ucRecordSize);
  }
  return sizeof (ATOM_COMMON_RECORD_HEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x13759
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29bbf(%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 0x157ee(%rip), %rdi     # 0x28f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29b83(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x16b36(%rip), %rdi     # 0x2a27d
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_I2C_RECORD_dumper
int ATOM_I2C_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_RECORD *d = (ATOM_I2C_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(26)); ATOM_I2C_ID_CONFIG_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
    printf ("%s%04x:  UCHAR ucI2CAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CAddr)-start), FILL(14), d->ucI2CAddr, d->ucI2CAddr);
  }
  return sizeof (ATOM_I2C_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x13821
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29b33(%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 $0x20, %rcx
leaq 0x16b0c(%rip), %rdi     # 0x2a2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x136da
movq 0x29aef(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %r12
movl %r12d, %edx
subl %r14d, %edx
addq $0x1a, %rcx
leaq 0x16b06(%rip), %rdi     # 0x2a2e0
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
movl %ebp, %edx
callq 0xf671
movq 0x29abe(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x16afe(%rip), %rdi     # 0x2a30a
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_HPD_INT_RECORD_dumper
int ATOM_HPD_INT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_HPD_INT_RECORD *d = (ATOM_HPD_INT_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucHPDIntGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHPDIntGPIOID)-start), FILL(19), d->ucHPDIntGPIOID, d->ucHPDIntGPIOID);
    printf ("%s%04x:  UCHAR ucPlugged_PinState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPlugged_PinState)-start), FILL(23), d->ucPlugged_PinState, d->ucPlugged_PinState);
  }
  return sizeof (ATOM_HPD_INT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x138e5
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29a6c(%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 $0x20, %rcx
leaq 0x16a45(%rip), %rdi     # 0x2a2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x136da
movq 0x29a28(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x16a97(%rip), %rdi     # 0x2a33a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x299fc(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x16aa1(%rip), %rdi     # 0x2a36f
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OUTPUT_PROTECTION_RECORD_dumper
int ATOM_OUTPUT_PROTECTION_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OUTPUT_PROTECTION_RECORD *d = (ATOM_OUTPUT_PROTECTION_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucProtectionFlag%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucProtectionFlag)-start), FILL(21), d->ucProtectionFlag, d->ucProtectionFlag);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
  }
  return sizeof (ATOM_OUTPUT_PROTECTION_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x139a9
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x299a8(%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 $0x20, %rcx
leaq 0x16981(%rip), %rdi     # 0x2a2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x136da
movq 0x29964(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x16a41(%rip), %rdi     # 0x2a3a8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29938(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xe5ba(%rip), %rdi      # 0x21f4c
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_DEVICE_TAG_dumper
int ATOM_CONNECTOR_DEVICE_TAG_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DEVICE_TAG *d = (ATOM_CONNECTOR_DEVICE_TAG *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulACPIDeviceEnum%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulACPIDeviceEnum)-start), FILL(21), d->ulACPIDeviceEnum, d->ulACPIDeviceEnum);
    printf ("%s%04x:  USHORT usDeviceID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceID)-start), FILL(16), d->usDeviceID, d->usDeviceID);
    printf ("%s%04x:  USHORT usPadding%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPadding)-start), FILL(15), d->usPadding, d->usPadding);
  }
  return sizeof (ATOM_CONNECTOR_DEVICE_TAG);
}

// Assembly:
testq %rsi, %rsi
je 0x13a5b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x298e8(%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
movl (%rbx), %r8d
leaq 0x169ed(%rip), %rdi     # 0x2a3df
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x298ad(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0xfdd7(%rip), %rdi      # 0x237f5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29881(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x169c7(%rip), %rdi     # 0x2a410
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_CONNECTOR_DEVICE_TAG_RECORD_dumper
int ATOM_CONNECTOR_DEVICE_TAG_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DEVICE_TAG_RECORD *d = (ATOM_CONNECTOR_DEVICE_TAG_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucNumberOfDevice%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfDevice)-start), FILL(21), d->ucNumberOfDevice, d->ucNumberOfDevice);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_DEVICE_TAG asDeviceTag%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asDeviceTag[i])-start), FILL(40+(i>9)), i); ATOM_CONNECTOR_DEVICE_TAG_dumper (start, (uint8_t*) &d->asDeviceTag[i], indent+1); }
  }
  return sizeof (ATOM_CONNECTOR_DEVICE_TAG_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x13b59
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x29831(%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 $0x20, %rcx
leaq 0x16809(%rip), %rdi     # 0x2a2b0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x136da
movq 0x297ec(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x16960(%rip), %rdi     # 0x2a43f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x297c0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzbl 0x3(%r14), %r8d
leaq 0xe441(%rip), %rdi      # 0x21f4c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29794(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x28, %rcx
leaq 0x16942(%rip), %rdi     # 0x2a476
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x139ad
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: ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD_dumper
int ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD *d = (ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucConfigGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConfigGPIOID)-start), FILL(19), d->ucConfigGPIOID, d->ucConfigGPIOID);
    printf ("%s%04x:  UCHAR ucConfigGPIOState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConfigGPIOState)-start), FILL(22), d->ucConfigGPIOState, d->ucConfigGPIOState);
    printf ("%s%04x:  UCHAR ucFlowinGPIPID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFlowinGPIPID)-start), FILL(19), d->ucFlowinGPIPID, d->ucFlowinGPIPID);
    printf ("%s%04x:  UCHAR ucExtInGPIPID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucExtInGPIPID)-start), FILL(18), d->ucExtInGPIPID, d->ucExtInGPIPID);
  }
  return sizeof (ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x13c75
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29734(%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 $0x20, %rcx
leaq 0x1670d(%rip), %rdi     # 0x2a2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x136da
movq 0x296f0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x168d4(%rip), %rdi     # 0x2a4af
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x296c4(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x168dd(%rip), %rdi     # 0x2a4e4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29698(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x168e9(%rip), %rdi     # 0x2a51c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2966c(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x168f3(%rip), %rdi     # 0x2a551
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x6
popq %rax
retq