LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_UP_HW_I2C_DATA_PARAMETERS_dumper
int SET_UP_HW_I2C_DATA_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_UP_HW_I2C_DATA_PARAMETERS *d = (SET_UP_HW_I2C_DATA_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPrescale%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPrescale)-start), FILL(16), d->usPrescale, d->usPrescale);
    printf ("%s%04x:  UCHAR ucSlaveAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSlaveAddr)-start), FILL(16), d->ucSlaveAddr, d->ucSlaveAddr);
    printf ("%s%04x:  UCHAR ucLineNumber%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLineNumber)-start), FILL(17), d->ucLineNumber, d->ucLineNumber);
  }
  return sizeof (SET_UP_HW_I2C_DATA_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xa5e3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x31d65(%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
movzwl (%rbx), %r8d
leaq 0x1b250(%rip), %rdi     # 0x257ca
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31d25(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1b2b5(%rip), %rdi     # 0x2585b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31cf9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1b2bc(%rip), %rdi     # 0x2588d
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: POWER_CONNECTOR_DETECTION_PARAMETERS_dumper
int POWER_CONNECTOR_DETECTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  POWER_CONNECTOR_DETECTION_PARAMETERS *d = (POWER_CONNECTOR_DETECTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucPowerConnectorStatus%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPowerConnectorStatus)-start), FILL(27), d->ucPowerConnectorStatus, d->ucPowerConnectorStatus);
    printf ("%s%04x:  UCHAR ucPwrBehaviorId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPwrBehaviorId)-start), FILL(20), d->ucPwrBehaviorId, d->ucPwrBehaviorId);
    printf ("%s%04x:  USHORT usPwrBudget%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPwrBudget)-start), FILL(17), d->usPwrBudget, d->usPwrBudget);
  }
  return sizeof (POWER_CONNECTOR_DETECTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xa69c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x31cac(%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 $0x1b, %rcx
movzbl (%rbx), %r8d
leaq 0x1b2ec(%rip), %rdi     # 0x2591f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31c6c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1b2fd(%rip), %rdi     # 0x2595c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31c40(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1b308(%rip), %rdi     # 0x25992
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_LVDS_SS_PARAMETERS_dumper
int ENABLE_LVDS_SS_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_LVDS_SS_PARAMETERS *d = (ENABLE_LVDS_SS_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSpreadSpectrumPercentage%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumPercentage)-start), FILL(32), d->usSpreadSpectrumPercentage, d->usSpreadSpectrumPercentage);
    printf ("%s%04x:  UCHAR ucSpreadSpectrumType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSpreadSpectrumType)-start), FILL(25), d->ucSpreadSpectrumType, d->ucSpreadSpectrumType);
    printf ("%s%04x:  UCHAR ucSpreadSpectrumStepSize_Delay%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSpreadSpectrumStepSize_Delay)-start), FILL(35), d->ucSpreadSpectrumStepSize_Delay, d->ucSpreadSpectrumStepSize_Delay);
    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 < 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_LVDS_SS_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xa7d4
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 0x31be0(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x20, %rcx
movzwl (%rbx), %r8d
leaq 0x1b2d4(%rip), %rdi     # 0x259c3
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31ba7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0x19, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1b2df(%rip), %rdi     # 0x25a03
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31b7b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x3(%rbx), %rdx
subl %r15d, %edx
addq $0x23, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1b2ee(%rip), %rdi     # 0x25a3e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31b4f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1a038(%rip), %rdi     # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r14d
leaq 0x1a052(%rip), %r15     # 0x247e3
xorl %r12d, %r12d
movq 0x31b15(%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 0xa794
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_SPREAD_SPECTRUM_ON_PPLL_V2_dumper
int ENABLE_SPREAD_SPECTRUM_ON_PPLL_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_SPREAD_SPECTRUM_ON_PPLL_V2 *d = (ENABLE_SPREAD_SPECTRUM_ON_PPLL_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSpreadSpectrumPercentage%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumPercentage)-start), FILL(32), d->usSpreadSpectrumPercentage, d->usSpreadSpectrumPercentage);
    printf ("%s%04x:  UCHAR ucSpreadSpectrumType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSpreadSpectrumType)-start), FILL(25), d->ucSpreadSpectrumType, d->ucSpreadSpectrumType);
    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 usSpreadSpectrumAmount%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumAmount)-start), FILL(28), d->usSpreadSpectrumAmount, d->usSpreadSpectrumAmount);
    printf ("%s%04x:  USHORT usSpreadSpectrumStep%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumStep)-start), FILL(26), d->usSpreadSpectrumStep, d->usSpreadSpectrumStep);
  }
  return sizeof (ENABLE_SPREAD_SPECTRUM_ON_PPLL_V2);
}

// Assembly:
testq %rsi, %rsi
je 0xabb7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x317e9(%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 $0x20, %rcx
movzwl (%rbx), %r8d
leaq 0x1aecd(%rip), %rdi     # 0x259c3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x317a9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1aee1(%rip), %rdi     # 0x25a03
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3177d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x19c66(%rip), %rdi     # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31751(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x1c, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1afbc(%rip), %rdi     # 0x25b36
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31725(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1afcd(%rip), %rdi     # 0x25b72
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_SPREAD_SPECTRUM_ON_PPLL_V3_dumper
int ENABLE_SPREAD_SPECTRUM_ON_PPLL_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_SPREAD_SPECTRUM_ON_PPLL_V3 *d = (ENABLE_SPREAD_SPECTRUM_ON_PPLL_V3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSpreadSpectrumAmountFrac%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumAmountFrac)-start), FILL(32), d->usSpreadSpectrumAmountFrac, d->usSpreadSpectrumAmountFrac);
    printf ("%s%04x:  UCHAR ucSpreadSpectrumType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSpreadSpectrumType)-start), FILL(25), d->ucSpreadSpectrumType, d->ucSpreadSpectrumType);
    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 usSpreadSpectrumAmount%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumAmount)-start), FILL(28), d->usSpreadSpectrumAmount, d->usSpreadSpectrumAmount);
    printf ("%s%04x:  USHORT usSpreadSpectrumStep%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSpreadSpectrumStep)-start), FILL(26), d->usSpreadSpectrumStep, d->usSpreadSpectrumStep);
  }
  return sizeof (ENABLE_SPREAD_SPECTRUM_ON_PPLL_V3);
}

// Assembly:
testq %rsi, %rsi
je 0xacc8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x316d8(%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 $0x20, %rcx
movzwl (%rbx), %r8d
leaq 0x1afa5(%rip), %rdi     # 0x25bac
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31698(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1add0(%rip), %rdi     # 0x25a03
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3166c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x19b55(%rip), %rdi     # 0x247b4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31640(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x1c, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1aeab(%rip), %rdi     # 0x25b36
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31614(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1aebc(%rip), %rdi     # 0x25b72
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_PIXEL_CLOCK_PS_ALLOCATION_dumper
int SET_PIXEL_CLOCK_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_PIXEL_CLOCK_PS_ALLOCATION *d = (SET_PIXEL_CLOCK_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  PIXEL_CLOCK_PARAMETERS sPCLKInput%s :\n", IND(indent), (int)(((uint8_t*)&d->sPCLKInput)-start), FILL(32)); PIXEL_CLOCK_PARAMETERS_dumper (start, (uint8_t*) &d->sPCLKInput, indent+1);
    printf ("%s%04x:  ENABLE_SPREAD_SPECTRUM_ON_PPLL sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(39)); ENABLE_SPREAD_SPECTRUM_ON_PPLL_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_PIXEL_CLOCK_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0xad71
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x315c2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x1aed2(%rip), %rdi     # 0x25bec
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9608
movq 0x31579(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0xc, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x1aecd(%rip), %rdi     # 0x25c1c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa943
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x14, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: LVDS_ENCODER_CONTROL_PARAMETERS_dumper
int LVDS_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  LVDS_ENCODER_CONTROL_PARAMETERS *d = (LVDS_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  UCHAR ucMisc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMisc)-start), FILL(11), d->ucMisc, d->ucMisc);
    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 (LVDS_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xae7a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x314ce(%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 $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x19af7(%rip), %rdi     # 0x24908
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3148e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x19a3b(%rip), %rdi     # 0x24878
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31462(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x19543(%rip), %rdi     # 0x243ab
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS_dumper
int ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS *d = (ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucMisc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMisc)-start), FILL(11), d->ucMisc, d->ucMisc);
    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_EXTERNAL_TMDS_ENCODER_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xb0c3
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 0x31299(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x1977e(%rip), %rdi     # 0x247b4
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x31260(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x1(%rbx), %rdx
subl %r15d, %edx
addq $0xb, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1980d(%rip), %rdi     # 0x24878
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x2, %r14d
leaq 0x19763(%rip), %r15     # 0x247e3
xorl %r12d, %r12d
movq 0x31226(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x2(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x1, %r12
je 0xb083
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_dumper
int ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION *d = (ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS sXTmdsEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sXTmdsEncoder)-start), FILL(52)); ENABLE_EXTERNAL_TMDS_ENCODER_PARAMETERS_dumper (start, (uint8_t*) &d->sXTmdsEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0xb16c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x311c7(%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 $0x32, %rcx
leaq 0x1abfc(%rip), %rdi     # 0x25d11
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xafe9
movq 0x3117e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1ac0b(%rip), %rdi     # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_V2_dumper
int ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_V2 *d = (ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  LVDS_ENCODER_CONTROL_PARAMETERS_V2 sXTmdsEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sXTmdsEncoder)-start), FILL(47)); LVDS_ENCODER_CONTROL_PARAMETERS_V2_dumper (start, (uint8_t*) &d->sXTmdsEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ENABLE_EXTERNAL_TMDS_ENCODER_PS_ALLOCATION_V2);
}

// Assembly:
testq %rsi, %rsi
je 0xb215
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3111e(%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 $0x2f, %rcx
leaq 0x1abd5(%rip), %rdi     # 0x25d93
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xae80
movq 0x310d5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1ab62(%rip), %rdi     # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_dumper
int EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION *d = (EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DIG_ENCODER_CONTROL_PARAMETERS sDigEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sDigEncoder)-start), FILL(41)); DIG_ENCODER_CONTROL_PARAMETERS_dumper (start, (uint8_t*) &d->sDigEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0xb2be
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x31075(%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 $0x29, %rcx
leaq 0x1ab6b(%rip), %rdi     # 0x25dd2
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x813f
movq 0x3102c(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1aab9(%rip), %rdi     # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PARAMETERS_V3_dumper
int DVO_ENCODER_CONTROL_PARAMETERS_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PARAMETERS_V3 *d = (DVO_ENCODER_CONTROL_PARAMETERS_V3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  UCHAR ucDVOConfig%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDVOConfig)-start), FILL(16), d->ucDVOConfig, d->ucDVOConfig);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  UCHAR ucReseved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReseved[i])-start), FILL(18+(i>9)), i, d->ucReseved[i], d->ucReseved[i]); }
  }
  return sizeof (DVO_ENCODER_CONTROL_PARAMETERS_V3);
}

// Assembly:
testq %rsi, %rsi
je 0xb3ca
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 0x30fbe(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x195f7(%rip), %rdi     # 0x24908
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30f85(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1aac5(%rip), %rdi     # 0x25e0b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30f59(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x3(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x19039(%rip), %rdi     # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x4, %r14d
leaq 0x1aab6(%rip), %r15     # 0x25e3d
xorl %r12d, %r12d
movq 0x30f1f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x4(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x4, %r12
jne 0xb38a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_VOLTAGE_PARAMETERS_dumper
int SET_VOLTAGE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_VOLTAGE_PARAMETERS *d = (SET_VOLTAGE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVoltageType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageType)-start), FILL(18), d->ucVoltageType, d->ucVoltageType);
    printf ("%s%04x:  UCHAR ucVoltageMode%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageMode)-start), FILL(18), d->ucVoltageMode, d->ucVoltageMode);
    printf ("%s%04x:  UCHAR ucVoltageIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageIndex)-start), FILL(19), d->ucVoltageIndex, d->ucVoltageIndex);
    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 (SET_VOLTAGE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xb4af
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30ec5(%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 $0x12, %rcx
movzbl (%rbx), %r8d
leaq 0x1aa58(%rip), %rdi     # 0x25e72
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30e85(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1aa60(%rip), %rdi     # 0x25ea6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30e59(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1aa68(%rip), %rdi     # 0x25eda
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30e2d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17ad2(%rip), %rdi     # 0x22f6f
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_VOLTAGE_PARAMETERS_V2_dumper
int SET_VOLTAGE_PARAMETERS_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_VOLTAGE_PARAMETERS_V2 *d = (SET_VOLTAGE_PARAMETERS_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVoltageType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageType)-start), FILL(18), d->ucVoltageType, d->ucVoltageType);
    printf ("%s%04x:  UCHAR ucVoltageMode%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageMode)-start), FILL(18), d->ucVoltageMode, d->ucVoltageMode);
    printf ("%s%04x:  USHORT usVoltageLevel%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageLevel)-start), FILL(20), d->usVoltageLevel, d->usVoltageLevel);
  }
  return sizeof (SET_VOLTAGE_PARAMETERS_V2);
}

// Assembly:
testq %rsi, %rsi
je 0xb568
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30de0(%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 $0x12, %rcx
movzbl (%rbx), %r8d
leaq 0x1a973(%rip), %rdi     # 0x25e72
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30da0(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1a97b(%rip), %rdi     # 0x25ea6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30d74(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1a9b9(%rip), %rdi     # 0x25f0f
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_VOLTAGE_PS_ALLOCATION_dumper
int SET_VOLTAGE_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_VOLTAGE_PS_ALLOCATION *d = (SET_VOLTAGE_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  SET_VOLTAGE_PARAMETERS sASICSetVoltage%s :\n", IND(indent), (int)(((uint8_t*)&d->sASICSetVoltage)-start), FILL(37)); SET_VOLTAGE_PARAMETERS_dumper (start, (uint8_t*) &d->sASICSetVoltage, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_VOLTAGE_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0xb611
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30d22(%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 $0x25, %rcx
leaq 0x1a989(%rip), %rdi     # 0x25f43
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb3d0
movq 0x30cd9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1a766(%rip), %rdi     # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: TV_ENCODER_CONTROL_PARAMETERS_dumper
int TV_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  TV_ENCODER_CONTROL_PARAMETERS *d = (TV_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  UCHAR ucTvStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTvStandard)-start), FILL(17), d->ucTvStandard, d->ucTvStandard);
    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 (TV_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0xb6ca
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30c7e(%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 $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x192a7(%rip), %rdi     # 0x24908
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30c3e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1a8eb(%rip), %rdi     # 0x25f78
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30c12(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x18cf3(%rip), %rdi     # 0x243ab
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: TV_ENCODER_CONTROL_PS_ALLOCATION_dumper
int TV_ENCODER_CONTROL_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  TV_ENCODER_CONTROL_PS_ALLOCATION *d = (TV_ENCODER_CONTROL_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  TV_ENCODER_CONTROL_PARAMETERS sTVEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sTVEncoder)-start), FILL(39)); TV_ENCODER_CONTROL_PARAMETERS_dumper (start, (uint8_t*) &d->sTVEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (TV_ENCODER_CONTROL_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0xb773
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30bc0(%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 $0x27, %rcx
leaq 0x1a88f(%rip), %rdi     # 0x25fab
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb617
movq 0x30b77(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1a604(%rip), %rdi     # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MASTER_DATA_TABLE_dumper
int ATOM_MASTER_DATA_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MASTER_DATA_TABLE *d = (ATOM_MASTER_DATA_TABLE *) 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_MASTER_LIST_OF_DATA_TABLES ListOfDataTables%s :\n", IND(indent), (int)(((uint8_t*)&d->ListOfDataTables)-start), FILL(47)); ATOM_MASTER_LIST_OF_DATA_TABLES_dumper (start, (uint8_t*) &d->ListOfDataTables, indent+1);
  }
  return sizeof (ATOM_MASTER_DATA_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0xbe29
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3050a(%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 0x16dff(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x304c1(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2f, %rcx
leaq 0x1a8e1(%rip), %rdi     # 0x266e8
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb779
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x48, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MULTIMEDIA_CAPABILITY_INFO_dumper
int ATOM_MULTIMEDIA_CAPABILITY_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MULTIMEDIA_CAPABILITY_INFO *d = (ATOM_MULTIMEDIA_CAPABILITY_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:  ULONG ulSignature%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulSignature)-start), FILL(16), d->ulSignature, d->ulSignature);
    printf ("%s%04x:  UCHAR ucI2C_Type%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2C_Type)-start), FILL(15), d->ucI2C_Type, d->ucI2C_Type);
    printf ("%s%04x:  UCHAR ucTV_OutInfo%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTV_OutInfo)-start), FILL(17), d->ucTV_OutInfo, d->ucTV_OutInfo);
    printf ("%s%04x:  UCHAR ucVideoPortInfo%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVideoPortInfo)-start), FILL(20), d->ucVideoPortInfo, d->ucVideoPortInfo);
    printf ("%s%04x:  UCHAR ucHostPortInfo%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHostPortInfo)-start), FILL(19), d->ucHostPortInfo, d->ucHostPortInfo);
  }
  return sizeof (ATOM_MULTIMEDIA_CAPABILITY_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0xbf76
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30462(%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 $0x1f, %rcx
leaq 0x16d58(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5f74
movq 0x3041a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1a877(%rip), %rdi     # 0x26727
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x303ef(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x8(%rbx), %r8d
leaq 0x1a877(%rip), %rdi     # 0x26753
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x303c3(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x9(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x9(%rbx), %r8d
leaq 0x1a87c(%rip), %rdi     # 0x26784
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30397(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0xa(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0xa(%rbx), %r8d
leaq 0x1a883(%rip), %rdi     # 0x267b7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3036b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0xb(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0xb(%rbx), %r8d
leaq 0x1a88e(%rip), %rdi     # 0x267ed
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_FIRMWARE_CAPABILITY_ACCESS_dumper
int ATOM_FIRMWARE_CAPABILITY_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_CAPABILITY_ACCESS *d = (ATOM_FIRMWARE_CAPABILITY_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_FIRMWARE_CAPABILITY sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(41)); ATOM_FIRMWARE_CAPABILITY_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) USHORT susAccess%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->susAccess)-start), FILL(23), d->susAccess, d->susAccess);
  }
  return sizeof (ATOM_FIRMWARE_CAPABILITY_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0xc4af
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2fe76(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x29, %rcx
leaq 0x1a89e(%rip), %rdi     # 0x26d04
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xc229
movq 0x2fe2d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x17db5(%rip), %rdi     # 0x2424a
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_I2C_ID_CONFIG_dumper
int ATOM_I2C_ID_CONFIG_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_ID_CONFIG *d = (ATOM_I2C_ID_CONFIG *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR bfI2C_LineMux:4%s = 0x%02x       (%d)\n", IND(indent), FILL(20), d->bfI2C_LineMux, d->bfI2C_LineMux);
    printf ("%s       UCHAR bfHW_EngineID:3%s = 0x%02x       (%d)\n", IND(indent), FILL(20), d->bfHW_EngineID, d->bfHW_EngineID);
    printf ("%s       UCHAR bfHW_Capable:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->bfHW_Capable, d->bfHW_Capable);
  }
  return sizeof (ATOM_I2C_ID_CONFIG);
}

// Assembly:
testq %rsi, %rsi
je 0xfc2d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2c714(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x14, %rax
movzbl (%rbx), %ecx
andl $0xf, %ecx
leaq 0x18bf7(%rip), %rdi     # 0x287bf
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2c6d4(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x18c01(%rip), %rdi     # 0x287f5
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2c6ab(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x18c12(%rip), %rdi     # 0x2882b
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_I2C_ID_CONFIG_ACCESS_dumper
int ATOM_I2C_ID_CONFIG_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_ID_CONFIG_ACCESS *d = (ATOM_I2C_ID_CONFIG_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_I2C_ID_CONFIG sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(35)); ATOM_I2C_ID_CONFIG_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) UCHAR ucAccess%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAccess)-start), FILL(21), d->ucAccess, d->ucAccess);
  }
  return sizeof (ATOM_I2C_ID_CONFIG_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0xfcc4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2c661(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x23, %rcx
leaq 0x18be5(%rip), %rdi     # 0x28860
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xfb85
movq 0x2c618(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0x18be9(%rip), %rdi     # 0x28893
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_I2C_INFO_dumper
int ATOM_GPIO_I2C_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_I2C_INFO *d = (ATOM_GPIO_I2C_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < COUNT_ALL (ATOM_GPIO_I2C_INFO, ATOM_GPIO_I2C_ASSIGMENT); i++) {
      printf ("%s%04x:  ATOM_GPIO_I2C_ASSIGMENT asGPIO_Info%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asGPIO_Info[i])-start), FILL(38+(i>9)), i); ATOM_GPIO_I2C_ASSIGMENT_dumper (start, (uint8_t*) &d->asGPIO_Info[i], indent+1); }
  }
  return RETURN_ALL (ATOM_GPIO_I2C_INFO, ATOM_GPIO_I2C_ASSIGMENT);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x1017c
movl %edx, %ebx
movq 0x2c231(%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
movq 0x8(%rsp), %r14
movl %r14d, %edx
movq 0x10(%rsp), %r12
subl %r12d, %edx
addq $0x1f, %rcx
leaq 0x12b1c(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movzwl (%r14), %ecx
movzwl %cx, %eax
addq $-0x4, %rax
movabsq $-0x684bda12f684bda1, %rsi # imm = 0x97B425ED097B425F
cmpq $0x1b, %rax
jb 0x10163
movq 0x8(%rsp), %rax
leaq 0x4(%rax), %r12
movl %eax, %ebp
subl 0x10(%rsp), %ebp
addl $0x4, %ebp
xorl %r13d, %r13d
movl %ebx, %r14d
movq 0x2c1ab(%rip), %rcx     # 0x3c2b0
movq %rsi, %rbx
leaq (%rcx,%r15), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x26, %rcx
leaq 0x18b86(%rip), %rdi     # 0x28ca5
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0xfcca
movq %rbx, %rsi
incq %r13
movq 0x8(%rsp), %rax
movzwl (%rax), %ecx
movzwl %cx, %eax
addq $-0x4, %rax
mulq %rbx
shrq $0x4, %rdx
addq $0x1b, %r12
addl $0x1b, %ebp
cmpq %r13, %rdx
ja 0x100fe
movzwl %cx, %eax
addq $-0x4, %rax
mulq %rsi
shrq $0x4, %rdx
leal (%rdx,%rdx,8), %eax
leal (%rax,%rax,2), %eax
addl $0x4, %eax
jmp 0x1017e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MODE_MISC_INFO_ACCESS_dumper
int ATOM_MODE_MISC_INFO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MODE_MISC_INFO_ACCESS *d = (ATOM_MODE_MISC_INFO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_MODE_MISC_INFO sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(36)); ATOM_MODE_MISC_INFO_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) USHORT usAccess%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usAccess)-start), FILL(22), d->usAccess, d->usAccess);
  }
  return sizeof (ATOM_MODE_MISC_INFO_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0x10413
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2bf12(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x24, %rcx
leaq 0x18b51(%rip), %rdi     # 0x28f1b
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1018d
movq 0x2bec9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x18b56(%rip), %rdi     # 0x28f4f
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x2, %eax
retq