LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper
int GET_DISPLAY_SURFACE_SIZE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  GET_DISPLAY_SURFACE_SIZE_PARAMETERS *d = (GET_DISPLAY_SURFACE_SIZE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usX_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usX_Size)-start), FILL(14), d->usX_Size, d->usX_Size);
    printf ("%s%04x:  USHORT usY_Size%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usY_Size)-start), FILL(14), d->usY_Size, d->usY_Size);
  }
  return sizeof (GET_DISPLAY_SURFACE_SIZE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x181d1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2414b(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzwl (%rbx), %r8d
leaq 0x151d9(%rip), %rdi     # 0x2d36d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2410b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x151dc(%rip), %rdi     # 0x2d39b
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: INDIRECT_IO_ACCESS_dumper
int INDIRECT_IO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  INDIRECT_IO_ACCESS *d = (INDIRECT_IO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < -1; i++) {
      printf ("%s%04x:  UCHAR IOAccessSequence%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->IOAccessSequence[i])-start), FILL(25+(i>9)), i, d->IOAccessSequence[i], d->IOAccessSequence[i]); }
  }
  return RETURN_ALL (ATOM_INDIRECT_IO_ACCESS, UCHAR);
}

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

// Assembly:
testq %rsi, %rsi
je 0x182dd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x24056(%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 0xa94b(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x2400d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x107e7(%rip), %rdi     # 0x28aa2
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xfc33
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TV_MODE_dumper
int ATOM_TV_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TV_MODE *d = (ATOM_TV_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVMode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVMode_Num)-start), FILL(16), d->ucVMode_Num, d->ucVMode_Num);
    printf ("%s%04x:  UCHAR ucTV_Mode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTV_Mode_Num)-start), FILL(18), d->ucTV_Mode_Num, d->ucTV_Mode_Num);
  }
  return sizeof (ATOM_TV_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x18366
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23fb6(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x150a0(%rip), %rdi     # 0x2d3c9
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23f76(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x150a7(%rip), %rdi     # 0x2d3fb
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_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TV_MODE_SCALER_PTR_dumper
int ATOM_TV_MODE_SCALER_PTR_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TV_MODE_SCALER_PTR *d = (ATOM_TV_MODE_SCALER_PTR *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT ucFilter0_Offset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFilter0_Offset)-start), FILL(22), d->ucFilter0_Offset, d->ucFilter0_Offset);
    printf ("%s%04x:  USHORT usFilter1_Offset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFilter1_Offset)-start), FILL(22), d->usFilter1_Offset, d->usFilter1_Offset);
    printf ("%s%04x:  UCHAR ucTV_Mode_Num%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTV_Mode_Num)-start), FILL(18), d->ucTV_Mode_Num, d->ucTV_Mode_Num);
  }
  return sizeof (ATOM_TV_MODE_SCALER_PTR);
}

// Assembly:
testq %rsi, %rsi
je 0x1856d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23ddb(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x1503d(%rip), %rdi     # 0x2d541
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23d9b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x15047(%rip), %rdi     # 0x2d577
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23d6f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x14ea0(%rip), %rdi     # 0x2d3fb
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_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_STANDARD_VESA_TIMING_dumper
int ATOM_STANDARD_VESA_TIMING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_STANDARD_VESA_TIMING *d = (ATOM_STANDARD_VESA_TIMING *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_DTD_FORMAT aModeTimings%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->aModeTimings[i])-start), FILL(31+(i>9)), i); ATOM_DTD_FORMAT_dumper (start, (uint8_t*) &d->aModeTimings[i], indent+1); }
  }
  return sizeof (ATOM_STANDARD_VESA_TIMING);
}

// Assembly:
testq %rsi, %rsi
je 0x18639
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x23d1a(%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 0xa615(%rip), %rdi      # 0x22bd1
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 0x5f74
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x23cc5(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x1f, %rcx
leaq 0x11d12(%rip), %rdi     # 0x2a314
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x10cca
incq %r13
addq $0x1c, %r14
addl $0x1c, %ebp
cmpq $0x10, %r13
jne 0x185e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1c4, %eax            # imm = 0x1C4
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_STD_FORMAT_dumper
int ATOM_STD_FORMAT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_STD_FORMAT *d = (ATOM_STD_FORMAT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSTD_HDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_HDisp)-start), FILL(17), d->usSTD_HDisp, d->usSTD_HDisp);
    printf ("%s%04x:  USHORT usSTD_VDisp%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_VDisp)-start), FILL(17), d->usSTD_VDisp, d->usSTD_VDisp);
    printf ("%s%04x:  USHORT usSTD_RefreshRate%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSTD_RefreshRate)-start), FILL(23), d->usSTD_RefreshRate, d->usSTD_RefreshRate);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_STD_FORMAT);
}

// Assembly:
testq %rsi, %rsi
je 0x1871e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23c56(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x14f24(%rip), %rdi     # 0x2d5ad
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23c16(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14f29(%rip), %rdi     # 0x2d5de
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23bea(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x14f2e(%rip), %rdi     # 0x2d60f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23bbe(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xff6b(%rip), %rdi      # 0x28677
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: ATOM_VESA_TO_EXTENDED_MODE_dumper
int ATOM_VESA_TO_EXTENDED_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VESA_TO_EXTENDED_MODE *d = (ATOM_VESA_TO_EXTENDED_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usVESA_ModeNumber%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVESA_ModeNumber)-start), FILL(23), d->usVESA_ModeNumber, d->usVESA_ModeNumber);
    printf ("%s%04x:  USHORT usExtendedModeNumber%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usExtendedModeNumber)-start), FILL(26), d->usExtendedModeNumber, d->usExtendedModeNumber);
  }
  return sizeof (ATOM_VESA_TO_EXTENDED_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x187a7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23b75(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x14edc(%rip), %rdi     # 0x2d646
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23b35(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14ee8(%rip), %rdi     # 0x2d67d
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: ATOM_VESA_TO_INTENAL_MODE_LUT_dumper
int ATOM_VESA_TO_INTENAL_MODE_LUT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VESA_TO_INTENAL_MODE_LUT *d = (ATOM_VESA_TO_INTENAL_MODE_LUT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < COUNT_ALL (ATOM_VESA_TO_INTENAL_MODE_LUT, ATOM_VESA_TO_EXTENDED_MODE); i++) {
      printf ("%s%04x:  ATOM_VESA_TO_EXTENDED_MODE asVESA_ToExtendedModeInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asVESA_ToExtendedModeInfo[i])-start), FILL(55+(i>9)), i); ATOM_VESA_TO_EXTENDED_MODE_dumper (start, (uint8_t*) &d->asVESA_ToExtendedModeInfo[i], indent+1); }
  }
  return RETURN_ALL (ATOM_VESA_TO_INTENAL_MODE_LUT, ATOM_VESA_TO_EXTENDED_MODE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x18888
movl %edx, %ebx
movq %rsi, %r14
movq 0x23adf(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %r14d, %edx
movq (%rsp), %r12
subl %r12d, %edx
addq $0x1f, %rcx
leaq 0xa3d0(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movzwl (%r14), %eax
movl %eax, %ecx
andl $-0x4, %ecx
cmpw $0x4, %cx
je 0x18881
leaq 0x4(%r14), %r12
movl %r14d, %ebp
subl (%rsp), %ebp
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x23a73(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
addq $0x32, %rcx
leaq 0x14e6b(%rip), %rdi     # 0x2d6b7
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x18724
incq %r13
movzwl (%r14), %eax
leaq -0x4(%rax), %rcx
shrq $0x2, %rcx
addq $0x4, %r12
addl $0x4, %ebp
cmpq %r13, %rcx
ja 0x18836
andl $0xfffc, %eax           # imm = 0xFFFC
jmp 0x1888a
xorl %eax, %eax
addq $0x8, %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_MEMORY_VENDOR_BLOCK_dumper
int ATOM_MEMORY_VENDOR_BLOCK_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_VENDOR_BLOCK *d = (ATOM_MEMORY_VENDOR_BLOCK *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucMemoryType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMemoryType)-start), FILL(17), d->ucMemoryType, d->ucMemoryType);
    printf ("%s%04x:  UCHAR ucMemoryVendor%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMemoryVendor)-start), FILL(19), d->ucMemoryVendor, d->ucMemoryVendor);
    printf ("%s%04x:  UCHAR ucAdjMCId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAdjMCId)-start), FILL(14), d->ucAdjMCId, d->ucAdjMCId);
    printf ("%s%04x:  UCHAR ucDynClkId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDynClkId)-start), FILL(15), d->ucDynClkId, d->ucDynClkId);
    printf ("%s%04x:  ULONG ulDllResetClkRange%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDllResetClkRange)-start), FILL(23), d->ulDllResetClkRange, d->ulDllResetClkRange);
  }
  return sizeof (ATOM_MEMORY_VENDOR_BLOCK);
}

// Assembly:
testq %rsi, %rsi
je 0x189a3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x239fc(%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 0xf390(%rip), %rdi      # 0x27c73
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x239bc(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x14df0(%rip), %rdi     # 0x2d6ff
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23990(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14df9(%rip), %rdi     # 0x2d734
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23964(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x14dfd(%rip), %rdi     # 0x2d764
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23938(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movl 0x4(%rbx), %r8d
leaq 0x14e04(%rip), %rdi     # 0x2d795
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: ATOM_MEMORY_SETTING_ID_CONFIG_dumper
int ATOM_MEMORY_SETTING_ID_CONFIG_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_SETTING_ID_CONFIG *d = (ATOM_MEMORY_SETTING_ID_CONFIG *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulMemClockRange:24%s = 0x%08x (%d)\n", IND(indent), FILL(23), d->ulMemClockRange, d->ulMemClockRange);
    printf ("%s       ULONG ucMemBlkId:8%s = 0x%08x (%d)\n", IND(indent), FILL(17), d->ucMemBlkId, d->ucMemBlkId);
  }
  return sizeof (ATOM_MEMORY_SETTING_ID_CONFIG);
}

// Assembly:
testq %rsi, %rsi
je 0x18a24
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x238f4(%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 $0x17, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x14ddf(%rip), %rdi     # 0x2d7c8
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x238b3(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x11, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x14deb(%rip), %rdi     # 0x2d7fb
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS_dumper
int ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS *d = (ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_MEMORY_SETTING_ID_CONFIG slAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->slAccess)-start), FILL(45)); ATOM_MEMORY_SETTING_ID_CONFIG_dumper (start, (uint8_t*) &d->slAccess, indent+1);
    printf ("%s%04x:  (union) ULONG ulAccess%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulAccess)-start), FILL(21), d->ulAccess, d->ulAccess);
  }
  return sizeof (ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0x18aba
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x2386a(%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 $0x2d, %rcx
leaq 0x14db6(%rip), %rdi     # 0x2d828
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x189a9
movq 0x23821(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x15, %rcx
movl (%rbx), %r8d
leaq 0x14dc5(%rip), %rdi     # 0x2d865
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 $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MEMORY_SETTING_DATA_BLOCK_dumper
int ATOM_MEMORY_SETTING_DATA_BLOCK_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_SETTING_DATA_BLOCK *d = (ATOM_MEMORY_SETTING_DATA_BLOCK *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS ulMemoryID%s :\n", IND(indent), (int)(((uint8_t*)&d->ulMemoryID)-start), FILL(46)); ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS_dumper (start, (uint8_t*) &d->ulMemoryID, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ULONG aulMemData%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->aulMemData[i])-start), FILL(19+(i>9)), i, d->aulMemData[i], d->aulMemData[i]); }
  }
  return sizeof (ATOM_MEMORY_SETTING_DATA_BLOCK);
}

// Assembly:
testq %rsi, %rsi
je 0x18b5b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x237d1(%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 $0x2e, %rcx
leaq 0x14d8c(%rip), %rdi     # 0x2d896
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x18a2a
movq 0x23789(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x14d90(%rip), %rdi     # 0x2d8d4
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_INIT_REG_INDEX_FORMAT_dumper
int ATOM_INIT_REG_INDEX_FORMAT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_INIT_REG_INDEX_FORMAT *d = (ATOM_INIT_REG_INDEX_FORMAT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usRegIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRegIndex)-start), FILL(16), d->usRegIndex, d->usRegIndex);
    printf ("%s%04x:  UCHAR ucPreRegDataLength%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPreRegDataLength)-start), FILL(23), d->ucPreRegDataLength, d->ucPreRegDataLength);
  }
  return sizeof (ATOM_INIT_REG_INDEX_FORMAT);
}

// Assembly:
testq %rsi, %rsi
je 0x18be4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23738(%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 0x14d5d(%rip), %rdi     # 0x2d904
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x236f8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14d62(%rip), %rdi     # 0x2d934
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_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_INIT_REG_BLOCK_dumper
int ATOM_INIT_REG_BLOCK_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_INIT_REG_BLOCK *d = (ATOM_INIT_REG_BLOCK *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usRegIndexTblSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRegIndexTblSize)-start), FILL(23), d->usRegIndexTblSize, d->usRegIndexTblSize);
    printf ("%s%04x:  USHORT usRegDataBlkSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRegDataBlkSize)-start), FILL(22), d->usRegDataBlkSize, d->usRegDataBlkSize);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_INIT_REG_INDEX_FORMAT asRegIndexBuf%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asRegIndexBuf[i])-start), FILL(43+(i>9)), i); ATOM_INIT_REG_INDEX_FORMAT_dumper (start, (uint8_t*) &d->asRegIndexBuf[i], indent+1); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_MEMORY_SETTING_DATA_BLOCK asRegDataBuf%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asRegDataBuf[i])-start), FILL(46+(i>9)), i); ATOM_MEMORY_SETTING_DATA_BLOCK_dumper (start, (uint8_t*) &d->asRegDataBuf[i], indent+1); }
  }
  return sizeof (ATOM_INIT_REG_BLOCK);
}

// Assembly:
testq %rsi, %rsi
je 0x18cec
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x236a5(%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 $0x17, %rcx
movzwl (%r14), %r8d
leaq 0x14d32(%rip), %rdi     # 0x2d96d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23664(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x14d3d(%rip), %rdi     # 0x2d9a4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23638(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2b, %rcx
leaq 0x14d49(%rip), %rdi     # 0x2d9da
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x18b61
movq 0x235ff(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x7, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x14d4d(%rip), %rdi     # 0x2da16
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18ac0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0xf, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MEMORY_TIMING_FORMAT_dumper
int ATOM_MEMORY_TIMING_FORMAT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_TIMING_FORMAT *d = (ATOM_MEMORY_TIMING_FORMAT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulClkRange%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulClkRange)-start), FILL(15), d->ulClkRange, d->ulClkRange);
    printf ("%s  <unparsable> line 3269:   union{\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (ATOM_MEMORY_TIMING_FORMAT);
}

// Assembly:
testq %rsi, %rsi
je 0x19894
pushq %rbx
movq 0x22a72(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0xf, %rcx
movl (%rsi), %r8d
leaq 0x147d0(%rip), %rdi     # 0x2e03b
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x22a31(%rip), %rbx     # 0x3c2b0
leaq 0x147e0(%rip), %rdi     # 0x2e066
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x18, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MEMORY_FORMAT_dumper
int ATOM_MEMORY_FORMAT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_FORMAT *d = (ATOM_MEMORY_FORMAT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulDllDisClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDllDisClock)-start), FILL(18), d->ulDllDisClock, d->ulDllDisClock);
    printf ("%s  <unparsable> line 3374:   union{\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (ATOM_MEMORY_FORMAT);
}

// Assembly:
testq %rsi, %rsi
je 0x1a389
pushq %rbx
movq 0x21f7d(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x12, %rcx
movl (%rsi), %r8d
leaq 0x14262(%rip), %rdi     # 0x2e5c2
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x21f3c(%rip), %rbx     # 0x3c2b0
leaq 0x14275(%rip), %rdi     # 0x2e5f0
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8c, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_INFO_V2_dumper
int ATOM_VRAM_INFO_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_INFO_V2 *d = (ATOM_VRAM_INFO_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  UCHAR ucNumOfVRAMModule%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfVRAMModule)-start), FILL(22), d->ucNumOfVRAMModule, d->ucNumOfVRAMModule);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_VRAM_MODULE_V3 aVramInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->aVramInfo[i])-start), FILL(32+(i>9)), i); ATOM_VRAM_MODULE_V3_dumper (start, (uint8_t*) &d->aVramInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_INFO_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1b770
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20c15(%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 0x7510(%rip), %rdi      # 0x22bd1
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 0x5f74
movq 0x20bca(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x13326(%rip), %rdi     # 0x2ea27
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x5, %r14
addl $0x5, %ebp
xorl %r13d, %r13d
movq 0x20b94(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x20, %rcx
leaq 0x1332c(%rip), %rdi     # 0x2ea5f
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1a38f
incq %r13
addq $0x9c, %r14
addl $0x9c, %ebp
cmpq $0x10, %r13
jne 0x1b715
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x9c5, %eax            # imm = 0x9C5
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_GPIO_DETECTION_INFO_dumper
int ATOM_VRAM_GPIO_DETECTION_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_GPIO_DETECTION_INFO *d = (ATOM_VRAM_GPIO_DETECTION_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 < 9; i++) {
      printf ("%s%04x:  UCHAR aVID_PinsShift%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->aVID_PinsShift[i])-start), FILL(23+(i>9)), i, d->aVID_PinsShift[i], d->aVID_PinsShift[i]); }
  }
  return sizeof (ATOM_VRAM_GPIO_DETECTION_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1bf7c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x203c8(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x1f, %rcx
leaq 0x6cc3(%rip), %rdi      # 0x22bd1
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5f74
addl $0x4, %r14d
leaq 0x12bfe(%rip), %r15     # 0x2eb36
xorl %r12d, %r12d
movq 0x2036e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x17, %rcx
movzbl 0x4(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x9, %r12
jne 0x1bf3b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xd, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MEMORY_TRAINING_INFO_dumper
int ATOM_MEMORY_TRAINING_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MEMORY_TRAINING_INFO *d = (ATOM_MEMORY_TRAINING_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:  UCHAR ucTrainingLoop%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTrainingLoop)-start), FILL(19), d->ucTrainingLoop, d->ucTrainingLoop);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucReserved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved[i])-start), FILL(19+(i>9)), i, d->ucReserved[i], d->ucReserved[i]); }
    printf ("%s%04x:  ATOM_INIT_REG_BLOCK asMemTrainingSetting%s :\n", IND(indent), (int)(((uint8_t*)&d->asMemTrainingSetting)-start), FILL(39)); ATOM_INIT_REG_BLOCK_dumper (start, (uint8_t*) &d->asMemTrainingSetting, indent+1);
  }
  return sizeof (ATOM_MEMORY_TRAINING_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1c0a8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20308(%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 0x6c03(%rip), %rdi      # 0x22bd1
movl %r14d, %r13d
subl %r15d, %r13d
movl %r13d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x202bc(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
movq %r15, 0x10(%rsp)
subl %r15d, %edx
addq $0x13, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12d36(%rip), %rdi     # 0x2ed4a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r13d
leaq 0x89d8(%rip), %rbp      # 0x24a01
xorl %r15d, %r15d
movq 0x2027d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leal (%r15,%r13), %edx
addq $0x13, %rcx
movzbl 0x5(%r14,%r15), %r9d
movl %r9d, (%rsp)
movq %rbp, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
cmpq $0x3, %r15
jne 0x1c02c
movq 0x2024a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x12cfc(%rip), %rdi     # 0x2ed7f
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18bea
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x17, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SW_I2C_IO_DATA_PARAMETERS_dumper
int SW_I2C_IO_DATA_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  SW_I2C_IO_DATA_PARAMETERS *d = (SW_I2C_IO_DATA_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT GPIO_Info%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->GPIO_Info)-start), FILL(15), d->GPIO_Info, d->GPIO_Info);
    printf ("%s%04x:  UCHAR ucAct%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAct)-start), FILL(10), d->ucAct, d->ucAct);
    printf ("%s%04x:  UCHAR ucData%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucData)-start), FILL(11), d->ucData, d->ucData);
  }
  return sizeof (SW_I2C_IO_DATA_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1c161
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x201e7(%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 $0xf, %rcx
movzwl (%rbx), %r8d
leaq 0x12cbe(%rip), %rdi     # 0x2edb6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x201a7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xa, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x12cc1(%rip), %rdi     # 0x2ede5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2017b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x97a3(%rip), %rdi      # 0x258f2
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: PTR_32_BIT_STRUCTURE_dumper
int PTR_32_BIT_STRUCTURE_dumper (uint8_t *start, uint8_t *data, int indent) {
  PTR_32_BIT_STRUCTURE *d = (PTR_32_BIT_STRUCTURE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT Offset16%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->Offset16)-start), FILL(14), d->Offset16, d->Offset16);
    printf ("%s%04x:  USHORT Segment16%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->Segment16)-start), FILL(15), d->Segment16, d->Segment16);
  }
  return sizeof (PTR_32_BIT_STRUCTURE);
}

// Assembly:
testq %rsi, %rsi
je 0x1c1ea
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20132(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzwl (%rbx), %r8d
leaq 0x12c64(%rip), %rdi     # 0x2ee11
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x200f2(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x12c67(%rip), %rdi     # 0x2ee3f
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: PTR_32_BIT_UNION_dumper
int PTR_32_BIT_UNION_dumper (uint8_t *start, uint8_t *data, int indent) {
  PTR_32_BIT_UNION *d = (PTR_32_BIT_UNION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) PTR_32_BIT_STRUCTURE SegmentOffset%s :\n", IND(indent), (int)(((uint8_t*)&d->SegmentOffset)-start), FILL(41)); PTR_32_BIT_STRUCTURE_dumper (start, (uint8_t*) &d->SegmentOffset, indent+1);
    printf ("%s%04x:  (union) ULONG Ptr32_Bit%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->Ptr32_Bit)-start), FILL(22), d->Ptr32_Bit, d->Ptr32_Bit);
  }
  return sizeof (PTR_32_BIT_UNION);
}

// Assembly:
testq %rsi, %rsi
je 0x1c285
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x200a0(%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, %r12d
subl %r14d, %r12d
addq $0x29, %rcx
leaq 0x12c32(%rip), %rdi     # 0x2ee6e
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1c167
movq 0x20054(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
addq $0x16, %rcx
movl (%rbx), %r8d
leaq 0x12c3a(%rip), %rdi     # 0x2eea7
movq %r15, %rsi
movl %r12d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: VBE_2_0_INFO_BLOCK_UPDATABLE_dumper
int VBE_2_0_INFO_BLOCK_UPDATABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  VBE_2_0_INFO_BLOCK_UPDATABLE *d = (VBE_2_0_INFO_BLOCK_UPDATABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  VBE_1_2_INFO_BLOCK_UPDATABLE CommonBlock%s :\n", IND(indent), (int)(((uint8_t*)&d->CommonBlock)-start), FILL(39)); VBE_1_2_INFO_BLOCK_UPDATABLE_dumper (start, (uint8_t*) &d->CommonBlock, indent+1);
    printf ("%s%04x:  USHORT OemSoftRev%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->OemSoftRev)-start), FILL(16), d->OemSoftRev, d->OemSoftRev);
    printf ("%s%04x:  PTR_32_BIT_UNION OemVendorNamePtr%s :\n", IND(indent), (int)(((uint8_t*)&d->OemVendorNamePtr)-start), FILL(32)); PTR_32_BIT_UNION_dumper (start, (uint8_t*) &d->OemVendorNamePtr, indent+1);
    printf ("%s%04x:  PTR_32_BIT_UNION OemProductNamePtr%s :\n", IND(indent), (int)(((uint8_t*)&d->OemProductNamePtr)-start), FILL(33)); PTR_32_BIT_UNION_dumper (start, (uint8_t*) &d->OemProductNamePtr, indent+1);
    printf ("%s%04x:  PTR_32_BIT_UNION OemProductRevPtr%s :\n", IND(indent), (int)(((uint8_t*)&d->OemProductRevPtr)-start), FILL(32)); PTR_32_BIT_UNION_dumper (start, (uint8_t*) &d->OemProductRevPtr, indent+1);
  }
  return sizeof (VBE_2_0_INFO_BLOCK_UPDATABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x1c577
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fe4e(%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 0x12b74(%rip), %rdi     # 0x2f002
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c28b
movq 0x1fe05(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x14(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzwl 0x14(%r14), %r8d
leaq 0x12b73(%rip), %rdi     # 0x2f039
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1fdd9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x16(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x12b79(%rip), %rdi     # 0x2f069
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1c1f0
movq 0x1fda5(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1a(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x12b75(%rip), %rdi     # 0x2f099
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1c1f0
movq 0x1fd71(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x1e, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x12b73(%rip), %rdi     # 0x2f0ca
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c1f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: VBE_VERSION_UNION_dumper
int VBE_VERSION_UNION_dumper (uint8_t *start, uint8_t *data, int indent) {
  VBE_VERSION_UNION *d = (VBE_VERSION_UNION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) VBE_2_0_INFO_BLOCK_UPDATABLE VBE_2_0_InfoBlock%s :\n", IND(indent), (int)(((uint8_t*)&d->VBE_2_0_InfoBlock)-start), FILL(53)); VBE_2_0_INFO_BLOCK_UPDATABLE_dumper (start, (uint8_t*) &d->VBE_2_0_InfoBlock, indent+1);
    printf ("%s%04x:  (union) VBE_1_2_INFO_BLOCK_UPDATABLE VBE_1_2_InfoBlock%s :\n", IND(indent), (int)(((uint8_t*)&d->VBE_1_2_InfoBlock)-start), FILL(53)); VBE_1_2_INFO_BLOCK_UPDATABLE_dumper (start, (uint8_t*) &d->VBE_1_2_InfoBlock, indent+1);
  }
  return sizeof (VBE_VERSION_UNION);
}

// Assembly:
testq %rsi, %rsi
je 0x1c617
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fd13(%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, %ebp
subl %r15d, %ebp
addq $0x32, %rcx
leaq 0x12b31(%rip), %rdi     # 0x2f0fa
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c441
movq 0x1fcc8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x32, %rcx
leaq 0x12b49(%rip), %rdi     # 0x2f13f
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c28b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: VBE_INFO_BLOCK_dumper
int VBE_INFO_BLOCK_dumper (uint8_t *start, uint8_t *data, int indent) {
  VBE_INFO_BLOCK *d = (VBE_INFO_BLOCK *) data;
  int i;
  if (d) {
    printf ("%s%04x:  VBE_VERSION_UNION UpdatableVBE_Info%s :\n", IND(indent), (int)(((uint8_t*)&d->UpdatableVBE_Info)-start), FILL(34)); VBE_VERSION_UNION_dumper (start, (uint8_t*) &d->UpdatableVBE_Info, indent+1);
    for (i = 0; i < 222; i++) {
      printf ("%s%04x:  UCHAR Reserved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->Reserved[i])-start), FILL(17+(i>9)), i, d->Reserved[i], d->Reserved[i]); }
    for (i = 0; i < 256; i++) {
      printf ("%s%04x:  UCHAR OemData%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->OemData[i])-start), FILL(16+(i>9)), i, d->OemData[i], d->OemData[i]); }
  }
  return sizeof (VBE_INFO_BLOCK);
}

// Assembly:
testq %rsi, %rsi
je 0x1c73a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1fc6f(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbp
leaq (%rcx,%rbp), %rsi
addq $0x22, %rcx
leaq 0x12b1d(%rip), %rdi     # 0x2f184
movl %ebx, %r15d
subl %r14d, %r15d
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1c57d
addl $0x22, %r15d
leaq 0xebd9(%rip), %r12      # 0x2b26c
xorl %r13d, %r13d
movq 0x1fc13(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbp), %rsi
leal (%r15,%r13), %edx
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x11, %rcx
movzbl 0x22(%rbx,%r13), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r13
cmpq $0xde, %r13
jne 0x1c696
movl %ebx, %r12d
subl %r14d, %r12d
addl $0x100, %r12d           # imm = 0x100
leaq 0x12ace(%rip), %r14     # 0x2f1b6
xorl %r15d, %r15d
movq 0x1fbbe(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbp), %rsi
leal (%r12,%r15), %edx
cmpq $0xa, %r15
sbbq $-0x1, %rcx
addq $0x10, %rcx
movzbl 0x100(%rbx,%r15), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
cmpq $0x100, %r15            # imm = 0x100
jne 0x1c6eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x200, %eax            # imm = 0x200
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ASIC_ENCODER_INFO_dumper
int ASIC_ENCODER_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ASIC_ENCODER_INFO *d = (ASIC_ENCODER_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEncoderID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEncoderID)-start), FILL(16), d->ucEncoderID, d->ucEncoderID);
    printf ("%s%04x:  UCHAR ucEncoderConfig%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEncoderConfig)-start), FILL(20), d->ucEncoderConfig, d->ucEncoderConfig);
    printf ("%s%04x:  USHORT usEncoderCmdTblId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usEncoderCmdTblId)-start), FILL(23), d->usEncoderCmdTblId, d->usEncoderCmdTblId);
  }
  return sizeof (ASIC_ENCODER_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d38f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1efb9(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x7feb(%rip), %rdi      # 0x25311
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ef79(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x12a86(%rip), %rdi     # 0x2fdd8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ef4d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x12a91(%rip), %rdi     # 0x2fe0e
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq