LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x17e5b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x254bd(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x14805(%rip), %rdi     # 0x2c623
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25481(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x14811(%rip), %rdi     # 0x2c65a
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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:
testq %rsi, %rsi
je 0x17f3c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r12
movq 0x2542d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rax
movq %rax, (%rsp)
leaq (%rcx,%rax), %rsi
addq $0x1f, %rcx
leaq 0x9d05(%rip), %rdi      # 0x21bae
movl %r14d, %ebp
subl %r12d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r13d
movq %r12, %rbx
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %r15d
movl %r13d, %edx
callq 0x5d40
leaq 0x4(%r14), %r12
addl $0x4, %ebp
xorl %r13d, %r13d
movzwl (%r14), %eax
leaq -0x4(%rax), %rcx
shrq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x17f2a
movq 0x253bf(%rip), %rcx     # 0x3d2b0
movq (%rsp), %rax
leaq (%rcx,%rax), %rsi
addq $0x32, %rcx
leaq 0x14790(%rip), %rdi     # 0x2c694
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x17ddc
incq %r13
addq $0x4, %r12
addl $0x4, %ebp
jmp 0x17ed9
andl $-0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x18045
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25356(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzbl (%rbx), %r8d
leaq 0xeccb(%rip), %rdi      # 0x26c50
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2531a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1472b(%rip), %rdi     # 0x2c6dc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x252ee(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14734(%rip), %rdi     # 0x2c711
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x252c2(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x14738(%rip), %rdi     # 0x2c741
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25296(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1473f(%rip), %rdi     # 0x2c772
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x180c0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x25254(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x17, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x14720(%rip), %rdi     # 0x2c7a5
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x25217(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x11, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x1472c(%rip), %rdi     # 0x2c7d8
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18150
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x251d0(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x2d, %rcx
leaq 0x146fd(%rip), %rdi     # 0x2c805
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x18049
movq 0x2518b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r14
addq $0x15, %rcx
movl (%rbx), %r8d
leaq 0x1470c(%rip), %rdi     # 0x2c842
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
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x181eb
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2513d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x2e, %rcx
leaq 0x146d9(%rip), %rdi     # 0x2c873
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x180c4
movq 0x250f9(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x146dd(%rip), %rdi     # 0x2c8b1
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1826e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x250aa(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzwl (%rbx), %r8d
leaq 0x146b0(%rip), %rdi     # 0x2c8e1
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2506e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x146b5(%rip), %rdi     # 0x2c911
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18370
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2501d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x17, %rcx
movzwl (%r14), %r8d
leaq 0x1468b(%rip), %rdi     # 0x2c94a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24fe0(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x14696(%rip), %rdi     # 0x2c981
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x24fb4(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2b, %rcx
leaq 0x146a2(%rip), %rdi     # 0x2c9b7
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x181ef
movq 0x24f7b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x7, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x146a6(%rip), %rdi     # 0x2c9f3
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18154
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0xf
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18ef7
pushq %rbx
movq 0x2440b(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0xf, %rcx
movl (%rsi), %r8d
leaq 0x1414a(%rip), %rdi     # 0x2d018
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x243ce(%rip), %rbx     # 0x3d2b0
leaq 0x1415a(%rip), %rdi     # 0x2d043
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
pushq $0x18
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x199da
pushq %rbx
movq 0x23928(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x12, %rcx
movl (%rsi), %r8d
leaq 0x13bee(%rip), %rdi     # 0x2d59f
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x238eb(%rip), %rbx     # 0x3d2b0
leaq 0x13c01(%rip), %rdi     # 0x2d5cd
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8c, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ad84
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x225ff(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0x6edb(%rip), %rdi      # 0x21bae
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 0x5d40
movq 0x225b8(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12cf1(%rip), %rdi     # 0x2da04
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x5, %r14
addl $0x5, %ebp
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x1ad76
movq 0x2257c(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x20, %rcx
leaq 0x12cf1(%rip), %rdi     # 0x2da3c
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x199e0
incq %r13
addq $0x9c, %r14
addl $0x9c, %ebp
jmp 0x1ad27
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_O2/mikebdp2[P]AtomDis/./atombios_rev.h
// Function: offset_ATOM_VRAM_INFO_V3_aVramInfo
static inline char *offset_ATOM_VRAM_INFO_V3_aVramInfo(ATOM_VRAM_INFO_V3 *d, int i) {
    char *r = (char *)&d->aVramInfo[0];
    while (i-- > 0)
	r += ((ATOM_VRAM_MODULE_V3 *)r)->usSize;
    return r;
}

// Assembly:
movq %rdi, %rax
addq $0x14, %rax
testl %esi, %esi
jle 0x1afd5
decl %esi
movzwl 0x4(%rax), %ecx
addq %rcx, %rax
jmp 0x1afc6
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b501
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x21e41(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x1f, %rcx
leaq 0x671d(%rip), %rdi      # 0x21bae
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 0x5d40
addl $0x4, %r14d
leaq 0x12658(%rip), %r15     # 0x2db13
xorl %r12d, %r12d
cmpq $0x9, %r12
je 0x1b4f3
movq 0x21de5(%rip), %rcx     # 0x3d2b0
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
jmp 0x1b4be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0xd
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b61b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r13
movq 0x21d85(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
addq $0x1f, %rcx
leaq 0x6661(%rip), %rdi      # 0x21bae
movl %r14d, %r12d
subl %r13d, %r12d
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x21d3d(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%r14), %rdx
movq %r13, 0x10(%rsp)
subl %r13d, %edx
addq $0x13, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12794(%rip), %rdi     # 0x2dd27
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r12d
leaq 0x8436(%rip), %r13      # 0x239de
xorl %ebp, %ebp
movq 0x21cff(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
cmpq $0x3, %rbp
je 0x1b5df
leal (%r12,%rbp), %edx
addq $0x13, %rcx
movzbl 0x5(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
jmp 0x1b5aa
addq $0x8, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x12763(%rip), %rdi     # 0x2dd5c
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18272
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
pushq $0x17
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6ce
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x21c76(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xf, %rcx
movzwl (%rbx), %r8d
leaq 0x1272e(%rip), %rdi     # 0x2dd93
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x21c3a(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xa, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x12731(%rip), %rdi     # 0x2ddc2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x21c0e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x9213(%rip), %rdi      # 0x248cf
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1b751
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x21bc7(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzwl (%rbx), %r8d
leaq 0x126da(%rip), %rdi     # 0x2ddee
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x21b8b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x126dd(%rip), %rdi     # 0x2de1c
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1b7e6
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x21b3b(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %r12d
subl %r14d, %r12d
addq $0x29, %rcx
leaq 0x126ae(%rip), %rdi     # 0x2de4b
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1b6d2
movq 0x21af3(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
addq $0x16, %rcx
movl (%rbx), %r8d
leaq 0x126b6(%rip), %rdi     # 0x2de84
movq %r15, %rsi
movl %r12d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1baa3
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2191e(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x12625(%rip), %rdi     # 0x2dfdf
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1b7ea
movq 0x218d9(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x14(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzwl 0x14(%r14), %r8d
leaq 0x12624(%rip), %rdi     # 0x2e016
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x218ad(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x16(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x1262a(%rip), %rdi     # 0x2e046
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1b755
movq 0x21879(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x1a(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x12626(%rip), %rdi     # 0x2e076
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1b755
movq 0x21845(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x1e, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x12624(%rip), %rdi     # 0x2e0a7
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1b755
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x22
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bb3d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x217e9(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %ebp
subl %r15d, %ebp
addq $0x32, %rcx
leaq 0x125e8(%rip), %rdi     # 0x2e0d7
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1b971
movq 0x217a2(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x32, %rcx
leaq 0x12600(%rip), %rdi     # 0x2e11c
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1b7ea
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0x22
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bc5e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2174b(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbp
leaq (%rcx,%rbp), %rsi
addq $0x22, %rcx
leaq 0x125da(%rip), %rdi     # 0x2e161
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 0x1baa7
addl $0x22, %r15d
leaq 0xe696(%rip), %r12      # 0x2a249
xorl %r13d, %r13d
cmpq $0xde, %r13
je 0x1bbf6
movq 0x216ea(%rip), %rcx     # 0x3d2b0
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
jmp 0x1bbb6
movl %ebx, %r12d
subl %r14d, %r12d
addl $0x100, %r12d           # imm = 0x100
leaq 0x12589(%rip), %r14     # 0x2e193
xorl %r15d, %r15d
cmpq $0x100, %r15            # imm = 0x100
je 0x1bc50
movq 0x21693(%rip), %rcx     # 0x3d2b0
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
jmp 0x1bc0d
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_O2/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 0x1c89f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20aa5(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x7ab8(%rip), %rdi      # 0x242ee
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20a69(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x12553(%rip), %rdi     # 0x2edb5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20a3d(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1255e(%rip), %rdi     # 0x2edeb
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISP_OUT_INFO_dumper
int ATOM_DISP_OUT_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISP_OUT_INFO *d = (ATOM_DISP_OUT_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:  USHORT ptrTransmitterInfo%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ptrTransmitterInfo)-start), FILL(24), d->ptrTransmitterInfo, d->ptrTransmitterInfo);
    printf ("%s%04x:  USHORT ptrEncoderInfo%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ptrEncoderInfo)-start), FILL(20), d->ptrEncoderInfo, d->ptrEncoderInfo);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ASIC_TRANSMITTER_INFO asTransmitterInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asTransmitterInfo[i])-start), FILL(42+(i>9)), i); ASIC_TRANSMITTER_INFO_dumper (start, (uint8_t*) &d->asTransmitterInfo[i], indent+1); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ASIC_ENCODER_INFO asEncoderInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asEncoderInfo[i])-start), FILL(34+(i>9)), i); ASIC_ENCODER_INFO_dumper (start, (uint8_t*) &d->asEncoderInfo[i], indent+1); }
  }
  return sizeof (ATOM_DISP_OUT_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1c9d3
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x209ec(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x52c2(%rip), %rdi      # 0x21bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x209a7(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x18, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x124fe(%rip), %rdi     # 0x2ee22
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2097b(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x6(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x6(%r14), %r8d
leaq 0x1250a(%rip), %rdi     # 0x2ee5a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2094f(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
leaq 0x8(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x12514(%rip), %rdi     # 0x2ee8e
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1c661
movq 0x20918(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x12, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x12519(%rip), %rdi     # 0x2eec9
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c7f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x16
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_DEVICE_PRIORITY_INFO_dumper
int ATOM_DISPLAY_DEVICE_PRIORITY_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_DEVICE_PRIORITY_INFO *d = (ATOM_DISPLAY_DEVICE_PRIORITY_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:  USHORT asDevicePriority%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->asDevicePriority[i])-start), FILL(26+(i>9)), i, d->asDevicePriority[i], d->asDevicePriority[i]); }
  }
  return sizeof (ATOM_DISPLAY_DEVICE_PRIORITY_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1cbf4
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20754(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0x5030(%rip), %rdi      # 0x21bae
movl %ebx, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r14d
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x5d40
addl $0x4, %ebp
leaq 0x1238f(%rip), %r14     # 0x2ef36
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x1cbe8
movq 0x206f9(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r15
sbbq $-0x1, %rcx
addq $0x1a, %rcx
movzwl 0x4(%rbx,%r15,2), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x2, %ebp
jmp 0x1cbaa
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0x24
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_dumper
int PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS *d = (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT lpAuxRequest%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpAuxRequest)-start), FILL(18), d->lpAuxRequest, d->lpAuxRequest);
    printf ("%s%04x:  USHORT lpDataOut%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpDataOut)-start), FILL(15), d->lpDataOut, d->lpDataOut);
    printf ("%s%04x:  UCHAR ucChannelID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucChannelID)-start), FILL(16), d->ucChannelID, d->ucChannelID);
    printf ("%s  <unparsable> line 3798:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1ccc1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2069d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x12332(%rip), %rdi     # 0x2ef71
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20660(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x12338(%rip), %rdi     # 0x2efa3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20634(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x1233b(%rip), %rdi     # 0x2efd2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x20608(%rip), %rbx     # 0x3d2b0
leaq 0x12355(%rip), %rdi     # 0x2f004
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper
int PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 *d = (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT lpAuxRequest%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpAuxRequest)-start), FILL(18), d->lpAuxRequest, d->lpAuxRequest);
    printf ("%s%04x:  USHORT lpDataOut%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpDataOut)-start), FILL(15), d->lpDataOut, d->lpDataOut);
    printf ("%s%04x:  UCHAR ucChannelID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucChannelID)-start), FILL(16), d->ucChannelID, d->ucChannelID);
    printf ("%s  <unparsable> line 3813:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1cd8e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x205d0(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x12265(%rip), %rdi     # 0x2ef71
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20593(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x1226b(%rip), %rdi     # 0x2efa3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x20567(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x1226e(%rip), %rdi     # 0x2efd2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x2053b(%rip), %rbx     # 0x3d2b0
leaq 0x122ba(%rip), %rdi     # 0x2f036
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DP_ENCODER_SERVICE_PARAMETERS_dumper
int DP_ENCODER_SERVICE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DP_ENCODER_SERVICE_PARAMETERS *d = (DP_ENCODER_SERVICE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT ucLinkClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLinkClock)-start), FILL(17), d->ucLinkClock, d->ucLinkClock);
    printf ("%s  <unparsable> line 3829:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (DP_ENCODER_SERVICE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1cdf2
pushq %rbx
movq 0x20511(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x11, %rcx
movzwl (%rsi), %r8d
leaq 0x1229f(%rip), %rdi     # 0x2f068
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x204d3(%rip), %rbx     # 0x3d2b0
leaq 0x122b5(%rip), %rdi     # 0x2f099
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
pushq $0x8
popq %rax
retq