LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xb275
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x310be(%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 0x1aad0(%rip), %rdi     # 0x25cee
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb0ea
movq 0x31075(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1aadf(%rip), %rdi     # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
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_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 0xb31e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x31015(%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 0x1aaa9(%rip), %rdi     # 0x25d70
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xaf81
movq 0x30fcc(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1aa36(%rip), %rdi     # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
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: 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 0xb3c7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30f6c(%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 0x1aa3f(%rip), %rdi     # 0x25daf
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x81ea
movq 0x30f23(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1a98d(%rip), %rdi     # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
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: 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 0xb4d3
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 0x30eb5(%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 0x194cb(%rip), %rdi     # 0x248e5
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30e7c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1a999(%rip), %rdi     # 0x25de8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30e50(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x3(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x18f0d(%rip), %rdi     # 0x24388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x4, %r14d
leaq 0x1a98a(%rip), %r15     # 0x25e1a
xorl %r12d, %r12d
movq 0x30e16(%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 0xb493
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: 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 0xb5b8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30dbc(%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 0x1a92c(%rip), %rdi     # 0x25e4f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30d7c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1a934(%rip), %rdi     # 0x25e83
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30d50(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1a93c(%rip), %rdi     # 0x25eb7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30d24(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x179a6(%rip), %rdi     # 0x22f4c
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: 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 0xb671
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30cd7(%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 0x1a847(%rip), %rdi     # 0x25e4f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30c97(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1a84f(%rip), %rdi     # 0x25e83
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30c6b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1a88d(%rip), %rdi     # 0x25eec
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: 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 0xb71a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30c19(%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 0x1a85d(%rip), %rdi     # 0x25f20
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb4d9
movq 0x30bd0(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1a63a(%rip), %rdi     # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
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: 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 0xb7d3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30b75(%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 0x1917b(%rip), %rdi     # 0x248e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30b35(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1a7bf(%rip), %rdi     # 0x25f55
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30b09(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x18bc7(%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: 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 0xb87c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30ab7(%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 0x1a763(%rip), %rdi     # 0x25f88
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb720
movq 0x30a6e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x1a4d8(%rip), %rdi     # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
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: 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 0xbf32
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30401(%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 0x16cd3(%rip), %rdi     # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x303b8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2f, %rcx
leaq 0x1a7b5(%rip), %rdi     # 0x266c5
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xb882
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x48, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc07f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30359(%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 0x16c2c(%rip), %rdi     # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5fe4
movq 0x30311(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1a74b(%rip), %rdi     # 0x26704
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x302e6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x8(%rbx), %r8d
leaq 0x1a74b(%rip), %rdi     # 0x26730
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x302ba(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x9(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x9(%rbx), %r8d
leaq 0x1a750(%rip), %rdi     # 0x26761
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3028e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0xa(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0xa(%rbx), %r8d
leaq 0x1a757(%rip), %rdi     # 0x26794
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x30262(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0xb(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0xb(%rbx), %r8d
leaq 0x1a762(%rip), %rdi     # 0x267ca
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_O3/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 0xc5b8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2fd6d(%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 0x1a772(%rip), %rdi     # 0x26ce1
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xc332
movq 0x2fd24(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x17c89(%rip), %rdi     # 0x24227
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_O3/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 0xfda1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2c5a0(%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 0x18a60(%rip), %rdi     # 0x2879c
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2c560(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x18a6a(%rip), %rdi     # 0x287d2
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2c537(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x18a7b(%rip), %rdi     # 0x28808
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_O3/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 0xfe38
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2c4ed(%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 0x18a4e(%rip), %rdi     # 0x2883d
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xfcf9
movq 0x2c4a4(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0x18a52(%rip), %rdi     # 0x28870
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_O3/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, 0x8(%rsp)
testq %rsi, %rsi
je 0x102da
movl %edx, %ebx
movq %rsi, %r14
movq 0x2c0bf(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
leaq (%rcx,%rax), %rsi
movl %r14d, %edx
movq 0x8(%rsp), %r15
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x12987(%rip), %rdi     # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movzwl (%r14), %ecx
addq $-0x4, %rcx
movabsq $-0x684bda12f684bda1, %r15 # imm = 0x97B425ED097B425F
cmpq $0x1b, %rcx
jb 0x102c5
leaq 0x4(%r14), %r12
movl %r14d, %ebp
subl 0x8(%rsp), %ebp
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x2c043(%rip), %rcx     # 0x3c2b0
movq 0x10(%rsp), %rax
leaq (%rcx,%rax), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x26, %rcx
leaq 0x189f9(%rip), %rdi     # 0x28c82
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0xfe3e
incq %r13
movzwl (%r14), %ecx
addq $-0x4, %rcx
movq %rcx, %rax
mulq %r15
shrq $0x4, %rdx
addq $0x1b, %r12
addl $0x1b, %ebp
cmpq %r13, %rdx
ja 0x10266
movq %rcx, %rax
mulq %r15
shrq $0x4, %rdx
leal (%rdx,%rdx,8), %eax
leal (%rax,%rax,2), %eax
addl $0x4, %eax
jmp 0x102dc
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_O3/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 0x10571
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2bdb4(%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 0x189d0(%rip), %rdi     # 0x28ef8
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x102eb
movq 0x2bd6b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x189d5(%rip), %rdi     # 0x28f2c
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PATCH_RECORD_MODE_dumper
int ATOM_PATCH_RECORD_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PATCH_RECORD_MODE *d = (ATOM_PATCH_RECORD_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  USHORT usHDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHDisp)-start), FILL(13), d->usHDisp, d->usHDisp);
    printf ("%s%04x:  USHORT usVDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVDisp)-start), FILL(13), d->usVDisp, d->usVDisp);
  }
  return sizeof (ATOM_PATCH_RECORD_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x11baa
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a79e(%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
movzbl (%rbx), %r8d
leaq 0x183c9(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a75e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x1(%rbx), %r8d
leaq 0x183d0(%rip), %rdi     # 0x29f3d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a732(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x183d2(%rip), %rdi     # 0x29f6a
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_LCD_RTS_RECORD_dumper
int ATOM_LCD_RTS_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LCD_RTS_RECORD *d = (ATOM_LCD_RTS_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucRTSValue%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRTSValue)-start), FILL(15), d->ucRTSValue, d->ucRTSValue);
  }
  return sizeof (ATOM_LCD_RTS_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x11c33
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a6e9(%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
movzbl (%rbx), %r8d
leaq 0x18314(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a6a9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x18376(%rip), %rdi     # 0x29f97
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_LCD_MODE_CONTROL_CAP_dumper
int ATOM_LCD_MODE_CONTROL_CAP_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LCD_MODE_CONTROL_CAP *d = (ATOM_LCD_MODE_CONTROL_CAP *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  USHORT usLCDCap%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usLCDCap)-start), FILL(14), d->usLCDCap, d->usLCDCap);
  }
  return sizeof (ATOM_LCD_MODE_CONTROL_CAP);
}

// Assembly:
testq %rsi, %rsi
je 0x11cbc
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a660(%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
movzbl (%rbx), %r8d
leaq 0x1828b(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a620(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzwl 0x1(%rbx), %r8d
leaq 0x1831e(%rip), %rdi     # 0x29fc8
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_FAKE_EDID_PATCH_RECORD_dumper
int ATOM_FAKE_EDID_PATCH_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FAKE_EDID_PATCH_RECORD *d = (ATOM_FAKE_EDID_PATCH_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucFakeEDIDLength%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFakeEDIDLength)-start), FILL(21), d->ucFakeEDIDLength, d->ucFakeEDIDLength);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucFakeEDIDString%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFakeEDIDString[i])-start), FILL(25+(i>9)), i, d->ucFakeEDIDString[i], d->ucFakeEDIDString[i]); }
  }
  return sizeof (ATOM_FAKE_EDID_PATCH_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x11d81
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a5cf(%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
movzbl (%rbx), %r8d
leaq 0x181fa(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a58f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x182ba(%rip), %rdi     # 0x29ff6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a563(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzbl 0x2(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x182c2(%rip), %rdi     # 0x2a02d
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PANEL_RESOLUTION_PATCH_RECORD_dumper
int ATOM_PANEL_RESOLUTION_PATCH_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PANEL_RESOLUTION_PATCH_RECORD *d = (ATOM_PANEL_RESOLUTION_PATCH_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  USHORT usHSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usHSize)-start), FILL(13), d->usHSize, d->usHSize);
    printf ("%s%04x:  USHORT usVSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVSize)-start), FILL(13), d->usVSize, d->usVSize);
  }
  return sizeof (ATOM_PANEL_RESOLUTION_PATCH_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x11e3a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a50e(%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
movzbl (%rbx), %r8d
leaq 0x18139(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a4ce(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x1(%rbx), %r8d
leaq 0x1826c(%rip), %rdi     # 0x2a069
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a4a2(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x1826e(%rip), %rdi     # 0x2a096
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_SPREAD_SPECTRUM_INFO_dumper
int ATOM_SPREAD_SPECTRUM_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SPREAD_SPECTRUM_INFO *d = (ATOM_SPREAD_SPECTRUM_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 < 16; i++) {
      printf ("%s%04x:  ATOM_SPREAD_SPECTRUM_ASSIGNMENT asSS_Info%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSS_Info[i])-start), FILL(44+(i>9)), i); ATOM_SPREAD_SPECTRUM_ASSIGNMENT_dumper (start, (uint8_t*) &d->asSS_Info[i], indent+1); }
  }
  return sizeof (ATOM_SPREAD_SPECTRUM_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1206f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2a2e4(%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 0x10bbc(%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 0x2a28f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x2c, %rcx
leaq 0x18158(%rip), %rdi     # 0x2a190
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x11e40
incq %r13
addq $0x8, %r14
addl $0x8, %ebp
cmpq $0x10, %r13
jne 0x1201a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x84, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DPCD_INFO_dumper
int ATOM_DPCD_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DPCD_INFO *d = (ATOM_DPCD_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRevisionNumber%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRevisionNumber)-start), FILL(21), d->ucRevisionNumber, d->ucRevisionNumber);
    printf ("%s%04x:  UCHAR ucMaxLinkRate%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxLinkRate)-start), FILL(18), d->ucMaxLinkRate, d->ucMaxLinkRate);
    printf ("%s%04x:  UCHAR ucMaxLane%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxLane)-start), FILL(14), d->ucMaxLane, d->ucMaxLane);
    printf ("%s%04x:  UCHAR ucMaxDownSpread%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxDownSpread)-start), FILL(20), d->ucMaxDownSpread, d->ucMaxDownSpread);
  }
  return sizeof (ATOM_DPCD_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x12473
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29f01(%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 $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0x17f43(%rip), %rdi     # 0x2a321
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29ec1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x17f4e(%rip), %rdi     # 0x2a358
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29e95(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17f56(%rip), %rdi     # 0x2a38c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29e69(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17f5b(%rip), %rdi     # 0x2a3bc
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_FIRMWARE_VRAM_RESERVE_INFO_dumper
int ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_VRAM_RESERVE_INFO *d = (ATOM_FIRMWARE_VRAM_RESERVE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulStartAddrUsedByFirmware%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStartAddrUsedByFirmware)-start), FILL(30), d->ulStartAddrUsedByFirmware, d->ulStartAddrUsedByFirmware);
    printf ("%s%04x:  USHORT usFirmwareUseInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFirmwareUseInKb)-start), FILL(23), d->usFirmwareUseInKb, d->usFirmwareUseInKb);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_FIRMWARE_VRAM_RESERVE_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1252b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29e1c(%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 $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x17f30(%rip), %rdi     # 0x2a3f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29ddd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17f3e(%rip), %rdi     # 0x2a42c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29db1(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1613b(%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_VRAM_USAGE_BY_FIRMWARE_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE *d = (ATOM_VRAM_USAGE_BY_FIRMWARE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_FIRMWARE_VRAM_RESERVE_INFO asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(60+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE);
}

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

// Assembly:
testq %rsi, %rsi
je 0x1268f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29cb8(%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 $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x17dcc(%rip), %rdi     # 0x2a3f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29c79(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17dda(%rip), %rdi     # 0x2a42c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29c4d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17e33(%rip), %rdi     # 0x2a4b0
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq