LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_I2C_DEVICE_SETUP_INFO_dumper
int ATOM_I2C_DEVICE_SETUP_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_DEVICE_SETUP_INFO *d = (ATOM_I2C_DEVICE_SETUP_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG_ACCESS sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(33)); ATOM_I2C_ID_CONFIG_ACCESS_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
    printf ("%s%04x:  UCHAR ucSSChipID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSSChipID)-start), FILL(15), d->ucSSChipID, d->ucSSChipID);
    printf ("%s%04x:  UCHAR ucSSChipSlaveAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSSChipSlaveAddr)-start), FILL(22), d->ucSSChipSlaveAddr, d->ucSSChipSlaveAddr);
    printf ("%s%04x:  UCHAR ucNumOfI2CDataRecords%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfI2CDataRecords)-start), FILL(26), d->ucNumOfI2CDataRecords, d->ucNumOfI2CDataRecords);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_I2C_DATA_RECORD asI2CData%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asI2CData[i])-start), FILL(33+(i>9)), i); ATOM_I2C_DATA_RECORD_dumper (start, (uint8_t*) &d->asI2CData[i], indent+1); }
  }
  return sizeof (ATOM_I2C_DEVICE_SETUP_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x172c8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x250f2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x11895(%rip), %rdi     # 0x28a7f
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xfda7
movq 0x250a9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x15a7e(%rip), %rdi     # 0x2cca0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2507d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x15a83(%rip), %rdi     # 0x2ccd1
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25051(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0x1a, %rcx
movzbl 0x3(%r14), %r8d
leaq 0x15a8f(%rip), %rdi     # 0x2cd09
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25025(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x15aa2(%rip), %rdi     # 0x2cd45
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17105
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_MVDD_INFO_dumper
int ATOM_ASIC_MVDD_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_MVDD_INFO *d = (ATOM_ASIC_MVDD_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_I2C_DEVICE_SETUP_INFO asI2CSetup%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asI2CSetup[i])-start), FILL(40+(i>9)), i); ATOM_I2C_DEVICE_SETUP_INFO_dumper (start, (uint8_t*) &d->asI2CSetup[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_MVDD_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x17374
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24fc2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xb894(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x24f79(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x28, %rcx
leaq 0x15a28(%rip), %rdi     # 0x2cd77
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1719e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO *d = (ATOM_ASIC_INTERNAL_SS_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(43+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1770e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24c3d(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0xb515(%rip), %rdi      # 0x22bae
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 0x5fe4
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x24be8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x2b, %rcx
leaq 0x157ee(%rip), %rdi     # 0x2cec5
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1737a
incq %r13
addq $0xc, %r14
addl $0xc, %ebp
cmpq $0x4, %r13
jne 0x176c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x34, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_V2_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO_V2 *d = (ATOM_ASIC_INTERNAL_SS_INFO_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT_V2 asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(46+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_V2_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x177ba
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24b7c(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xb44e(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x24b33(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1576c(%rip), %rdi     # 0x2cf01
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x174e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ASIC_INTERNAL_SS_INFO_V3_dumper
int ATOM_ASIC_INTERNAL_SS_INFO_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_INTERNAL_SS_INFO_V3 *d = (ATOM_ASIC_INTERNAL_SS_INFO_V3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_ASIC_SS_ASSIGNMENT_V3 asSpreadSpectrum%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSpreadSpectrum[i])-start), FILL(46+(i>9)), i); ATOM_ASIC_SS_ASSIGNMENT_V3_dumper (start, (uint8_t*) &d->asSpreadSpectrum[i], indent+1); }
  }
  return sizeof (ATOM_ASIC_INTERNAL_SS_INFO_V3);
}

// Assembly:
testq %rsi, %rsi
je 0x179d1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24965(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xb237(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x2491c(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x15594(%rip), %rdi     # 0x2cf40
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x177c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: MEMORY_PLLINIT_PARAMETERS_dumper
int MEMORY_PLLINIT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  MEMORY_PLLINIT_PARAMETERS *d = (MEMORY_PLLINIT_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulTargetMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulTargetMemoryClock)-start), FILL(24), d->ulTargetMemoryClock, d->ulTargetMemoryClock);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    printf ("%s%04x:  UCHAR ucFbDiv_Hi%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFbDiv_Hi)-start), FILL(15), d->ucFbDiv_Hi, d->ucFbDiv_Hi);
    printf ("%s%04x:  UCHAR ucFbDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFbDiv)-start), FILL(12), d->ucFbDiv, d->ucFbDiv);
    printf ("%s%04x:  UCHAR ucPostDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (MEMORY_PLLINIT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17ae1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x248be(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x18, %rcx
movl (%rbx), %r8d
leaq 0xcc69(%rip), %rdi      # 0x24689
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2487f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0xc93c(%rip), %rdi      # 0x24388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24853(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x15507(%rip), %rdi     # 0x2cf7f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24827(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0xc913(%rip), %rdi      # 0x243b7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x247fb(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xc916(%rip), %rdi      # 0x243e5
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: GPIO_PIN_CONTROL_PARAMETERS_dumper
int GPIO_PIN_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  GPIO_PIN_CONTROL_PARAMETERS *d = (GPIO_PIN_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucGPIO_ID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIO_ID)-start), FILL(14), d->ucGPIO_ID, d->ucGPIO_ID);
    printf ("%s%04x:  UCHAR ucGPIOBitShift%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOBitShift)-start), FILL(19), d->ucGPIOBitShift, d->ucGPIOBitShift);
    printf ("%s%04x:  UCHAR ucGPIOBitVal%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOBitVal)-start), FILL(17), d->ucGPIOBitVal, d->ucGPIOBitVal);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
  }
  return sizeof (GPIO_PIN_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17bc6
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x247ae(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzbl (%rbx), %r8d
leaq 0x12a76(%rip), %rdi     # 0x2a5a7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2476e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x15453(%rip), %rdi     # 0x2cfb0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24742(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1545c(%rip), %rdi     # 0x2cfe5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24716(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xc7d4(%rip), %rdi      # 0x24388
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_SCALER_PARAMETERS_dumper
int ENABLE_SCALER_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_SCALER_PARAMETERS *d = (ENABLE_SCALER_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucScaler%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucScaler)-start), FILL(13), d->ucScaler, d->ucScaler);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucTVStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTVStandard)-start), FILL(17), d->ucTVStandard, d->ucTVStandard);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ENABLE_SCALER_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17cb7
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x246c5(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x153fe(%rip), %rdi     # 0x2d018
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24685(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0xcb4b(%rip), %rdi      # 0x24791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24659(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x153d5(%rip), %rdi     # 0x2d047
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2462d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0xcb1f(%rip), %rdi      # 0x247c0
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper
int ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS *d = (ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG usHWIconHorzVertPosn%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHWIconHorzVertPosn)-start), FILL(25), d->usHWIconHorzVertPosn, d->usHWIconHorzVertPosn);
    printf ("%s%04x:  UCHAR ucHWIconVertOffset%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWIconVertOffset)-start), FILL(23), d->ucHWIconVertOffset, d->ucHWIconVertOffset);
    printf ("%s%04x:  UCHAR ucHWIconHorzOffset%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWIconHorzOffset)-start), FILL(23), d->ucHWIconHorzOffset, d->ucHWIconHorzOffset);
    printf ("%s%04x:  UCHAR ucSelection%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSelection)-start), FILL(16), d->ucSelection, d->ucSelection);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
  }
  return sizeof (ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17dc7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x245d8(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x19, %rcx
movl (%rbx), %r8d
leaq 0x15374(%rip), %rdi     # 0x2d07a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24599(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1537d(%rip), %rdi     # 0x2d0af
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2456d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1538a(%rip), %rdi     # 0x2d0e8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24541(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x15397(%rip), %rdi     # 0x2d121
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24515(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0xc9dc(%rip), %rdi      # 0x24791
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION_dumper
int ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION *d = (ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS sEnableIcon%s :\n", IND(indent), (int)(((uint8_t*)&d->sEnableIcon)-start), FILL(49)); ENABLE_HARDWARE_ICON_CURSOR_PARAMETERS_dumper (start, (uint8_t*) &d->sEnableIcon, indent+1);
    printf ("%s%04x:  ENABLE_CRTC_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(31)); ENABLE_CRTC_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_HARDWARE_ICON_CURSOR_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x17e70
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x244c3(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x31, %rcx
leaq 0x1533a(%rip), %rdi     # 0x2d153
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17cbd
movq 0x2447a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x15346(%rip), %rdi     # 0x2d194
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x91eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_GRAPH_SURFACE_PARAMETERS_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS *d = (ENABLE_GRAPH_SURFACE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x17f7c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x2440c(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x15300(%rip), %rdi     # 0x2d1c3
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x243d3(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x152f8(%rip), %rdi     # 0x2d1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x243a7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x152f9(%rip), %rdi     # 0x2d21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r14d
leaq 0xc887(%rip), %r15      # 0x247c0
xorl %r12d, %r12d
movq 0x2436d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x5(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x17f3c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2 *d = (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_2);
}

// Assembly:
testq %rsi, %rsi
je 0x180bc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2430d(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x151f1(%rip), %rdi     # 0x2d1c3
xorl %r15d, %r15d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x242ca(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x151ef(%rip), %rdi     # 0x2d1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2429e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x151f0(%rip), %rdi     # 0x2d21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24272(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc738(%rip), %rdi      # 0x24791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %rbx
movb $0x1, %bpl
leaq 0xc74f(%rip), %r12      # 0x247c0
movq 0x24238(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq (%rbx,%r15), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl (%rbx,%r15), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x18071
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3_dumper
int ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3 *d = (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usHight%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHight)-start), FILL(13), d->usHight, d->usHight);
    printf ("%s%04x:  USHORT usWidth%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usWidth)-start), FILL(13), d->usWidth, d->usWidth);
    printf ("%s%04x:  UCHAR ucSurface%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSurface)-start), FILL(14), d->ucSurface, d->ucSurface);
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  USHORT usDeviceId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceId)-start), FILL(16), d->usDeviceId, d->usDeviceId);
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PARAMETERS_V1_3);
}

// Assembly:
testq %rsi, %rsi
je 0x181cd
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x241d3(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xd, %rcx
movzwl (%rbx), %r8d
leaq 0x150b7(%rip), %rdi     # 0x2d1c3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24193(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x150b8(%rip), %rdi     # 0x2d1f0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24167(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x150b9(%rip), %rdi     # 0x2d21d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2413b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0xc601(%rip), %rdi      # 0x24791
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2410f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x15092(%rip), %rdi     # 0x2d24d
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_GRAPH_SURFACE_PS_ALLOCATION_dumper
int ENABLE_GRAPH_SURFACE_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_GRAPH_SURFACE_PS_ALLOCATION *d = (ENABLE_GRAPH_SURFACE_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ENABLE_GRAPH_SURFACE_PARAMETERS sSetSurface%s :\n", IND(indent), (int)(((uint8_t*)&d->sSetSurface)-start), FILL(42)); ENABLE_GRAPH_SURFACE_PARAMETERS_dumper (start, (uint8_t*) &d->sSetSurface, indent+1);
    printf ("%s%04x:  ENABLE_YUV_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(30)); ENABLE_YUV_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_GRAPH_SURFACE_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x18276
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x240bd(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x1505e(%rip), %rdi     # 0x2d27d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x17e76
movq 0x24074(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1e, %rcx
leaq 0x15063(%rip), %rdi     # 0x2d2b7
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa25b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: MEMORY_CLEAN_UP_PARAMETERS_dumper
int MEMORY_CLEAN_UP_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  MEMORY_CLEAN_UP_PARAMETERS *d = (MEMORY_CLEAN_UP_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usMemoryStart%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMemoryStart)-start), FILL(19), d->usMemoryStart, d->usMemoryStart);
    printf ("%s%04x:  USHORT usMemorySize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMemorySize)-start), FILL(18), d->usMemorySize, d->usMemorySize);
  }
  return sizeof (MEMORY_CLEAN_UP_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x182ff
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2401d(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x13, %rcx
movzwl (%rbx), %r8d
leaq 0x15023(%rip), %rdi     # 0x2d2e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23fdd(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1502b(%rip), %rdi     # 0x2d318
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper
int GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  GET_DISPLAY_SURFACE_SIZE_PARAMETERS *d = (GET_DISPLAY_SURFACE_SIZE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usX_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usX_Size)-start), FILL(14), d->usX_Size, d->usX_Size);
    printf ("%s%04x:  USHORT usY_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usY_Size)-start), FILL(14), d->usY_Size, d->usY_Size);
  }
  return sizeof (GET_DISPLAY_SURFACE_SIZE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x18388
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23f94(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzwl (%rbx), %r8d
leaq 0x14fff(%rip), %rdi     # 0x2d34a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23f54(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x15002(%rip), %rdi     # 0x2d378
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: INDIRECT_IO_ACCESS_dumper
int INDIRECT_IO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  INDIRECT_IO_ACCESS *d = (INDIRECT_IO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < -1; i++) {
      printf ("%s%04x:  UCHAR IOAccessSequence%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->IOAccessSequence[i])-start), FILL(25+(i>9)), i, d->IOAccessSequence[i], d->IOAccessSequence[i]); }
  }
  return RETURN_ALL (ATOM_INDIRECT_IO_ACCESS, UCHAR);
}

// Assembly:
testq %rsi, %rsi
je 0x183ee
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23f0a(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rsi
addq %rcx, %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1f, %rcx
leaq 0xa7de(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5fe4
movzwl (%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OEM_INFO_dumper
int ATOM_OEM_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OEM_INFO *d = (ATOM_OEM_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG_ACCESS sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(33)); ATOM_I2C_ID_CONFIG_ACCESS_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
  }
  return sizeof (ATOM_OEM_INFO);
}

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

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

// Assembly:
testq %rsi, %rsi
je 0x18724
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23c24(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x14e63(%rip), %rdi     # 0x2d51e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23be4(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14e6d(%rip), %rdi     # 0x2d554
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23bb8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14cc6(%rip), %rdi     # 0x2d3d8
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_STANDARD_VESA_TIMING_dumper
int ATOM_STANDARD_VESA_TIMING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_STANDARD_VESA_TIMING *d = (ATOM_STANDARD_VESA_TIMING *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_DTD_FORMAT aModeTimings%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->aModeTimings[i])-start), FILL(31+(i>9)), i); ATOM_DTD_FORMAT_dumper (start, (uint8_t*) &d->aModeTimings[i], indent+1); }
  }
  return sizeof (ATOM_STANDARD_VESA_TIMING);
}

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

// Assembly:
testq %rsi, %rsi
je 0x188d5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23a9f(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x14d4a(%rip), %rdi     # 0x2d58a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23a5f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14d4f(%rip), %rdi     # 0x2d5bb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23a33(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x14d54(%rip), %rdi     # 0x2d5ec
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23a07(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xfd91(%rip), %rdi      # 0x28654
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VESA_TO_EXTENDED_MODE_dumper
int ATOM_VESA_TO_EXTENDED_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VESA_TO_EXTENDED_MODE *d = (ATOM_VESA_TO_EXTENDED_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usVESA_ModeNumber%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVESA_ModeNumber)-start), FILL(23), d->usVESA_ModeNumber, d->usVESA_ModeNumber);
    printf ("%s%04x:  USHORT usExtendedModeNumber%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usExtendedModeNumber)-start), FILL(26), d->usExtendedModeNumber, d->usExtendedModeNumber);
  }
  return sizeof (ATOM_VESA_TO_EXTENDED_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x1895e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x239be(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x14d02(%rip), %rdi     # 0x2d623
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2397e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14d0e(%rip), %rdi     # 0x2d65a
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VESA_TO_INTENAL_MODE_LUT_dumper
int ATOM_VESA_TO_INTENAL_MODE_LUT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VESA_TO_INTENAL_MODE_LUT *d = (ATOM_VESA_TO_INTENAL_MODE_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_VESA_TO_INTENAL_MODE_LUT, ATOM_VESA_TO_EXTENDED_MODE); i++) {
      printf ("%s%04x:  ATOM_VESA_TO_EXTENDED_MODE asVESA_ToExtendedModeInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asVESA_ToExtendedModeInfo[i])-start), FILL(55+(i>9)), i); ATOM_VESA_TO_EXTENDED_MODE_dumper (start, (uint8_t*) &d->asVESA_ToExtendedModeInfo[i], indent+1); }
  }
  return RETURN_ALL (ATOM_VESA_TO_INTENAL_MODE_LUT, ATOM_VESA_TO_EXTENDED_MODE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x18a40
movl %edx, %ebx
movq %rsi, %r14
movq 0x23928(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %r14d, %edx
movq (%rsp), %r12
subl %r12d, %edx
addq $0x1f, %rcx
leaq 0xa1f6(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movzwl (%r14), %ecx
andl $-0x4, %ecx
movl $0x4, %eax
cmpw $0x4, %cx
je 0x18a42
leaq 0x4(%r14), %r12
movl %r14d, %ebp
subl (%rsp), %ebp
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x238b9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
addq $0x32, %rcx
leaq 0x14c8e(%rip), %rdi     # 0x2d694
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x188db
incq %r13
movzwl (%r14), %eax
leaq -0x4(%rax), %rcx
shrq $0x2, %rcx
addq $0x4, %r12
addl $0x4, %ebp
cmpq %r13, %rcx
ja 0x189f0
andl $-0x4, %eax
jmp 0x18a42
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq