LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x18b5b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23844(%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 0xf1b5(%rip), %rdi      # 0x27c50
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23804(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x14c15(%rip), %rdi     # 0x2d6dc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x237d8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14c1e(%rip), %rdi     # 0x2d711
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x237ac(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x14c22(%rip), %rdi     # 0x2d741
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23780(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movl 0x4(%rbx), %r8d
leaq 0x14c29(%rip), %rdi     # 0x2d772
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x18bdc
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2373c(%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 0x14c04(%rip), %rdi     # 0x2d7a5
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x236fb(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x11, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x14c10(%rip), %rdi     # 0x2d7d8
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_O3/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 0x18c72
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x236b2(%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 0x14bdb(%rip), %rdi     # 0x2d805
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x18b61
movq 0x23669(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x15, %rcx
movl (%rbx), %r8d
leaq 0x14bea(%rip), %rdi     # 0x2d842
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_O3/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 0x18d13
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23619(%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 0x14bb1(%rip), %rdi     # 0x2d873
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x18be2
movq 0x235d1(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x14bb5(%rip), %rdi     # 0x2d8b1
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_O3/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 0x18d9c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23580(%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 0x14b82(%rip), %rdi     # 0x2d8e1
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23540(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x14b87(%rip), %rdi     # 0x2d911
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x18ea4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x234ed(%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 0x14b57(%rip), %rdi     # 0x2d94a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x234ac(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x14b62(%rip), %rdi     # 0x2d981
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x23480(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2b, %rcx
leaq 0x14b6e(%rip), %rdi     # 0x2d9b7
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x18d19
movq 0x23447(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x7, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x14b72(%rip), %rdi     # 0x2d9f3
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18c78
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0xf, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19a54
pushq %rbx
movq 0x228b2(%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 0x145ed(%rip), %rdi     # 0x2e018
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x22871(%rip), %rbx     # 0x3c2b0
leaq 0x145fd(%rip), %rdi     # 0x2e043
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x18, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a549
pushq %rbx
movq 0x21dbd(%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 0x1407f(%rip), %rdi     # 0x2e59f
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x21d7c(%rip), %rbx     # 0x3c2b0
leaq 0x14092(%rip), %rdi     # 0x2e5cd
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8c, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b930
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20a55(%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 0x732d(%rip), %rdi      # 0x22bae
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x20a0a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x16, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x13143(%rip), %rdi     # 0x2ea04
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x5, %r14
addl $0x5, %ebp
xorl %r13d, %r13d
movq 0x209d4(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x20, %rcx
leaq 0x13149(%rip), %rdi     # 0x2ea3c
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1a54f
incq %r13
addq $0x9c, %r14
addl $0x9c, %ebp
cmpq $0x10, %r13
jne 0x1b8d5
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_O3/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 0x1c13b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20209(%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 0x6ae1(%rip), %rdi      # 0x22bae
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 0x5fe4
addl $0x4, %r14d
leaq 0x12a1c(%rip), %r15     # 0x2eb13
xorl %r12d, %r12d
movq 0x201af(%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 0x1c0fa
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_O3/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 0x1c267
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 0x20149(%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 0x6a21(%rip), %rdi      # 0x22bae
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 0x5fe4
movq 0x200fd(%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 0x12b54(%rip), %rdi     # 0x2ed27
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x5, %r13d
leaq 0x87f6(%rip), %rbp      # 0x249de
xorl %r15d, %r15d
movq 0x200be(%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 0x1c1eb
movq 0x2008b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x12b1a(%rip), %rdi     # 0x2ed5c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18da2
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_O3/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 0x1c320
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20028(%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 0x12adc(%rip), %rdi     # 0x2ed93
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ffe8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xa, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x12adf(%rip), %rdi     # 0x2edc2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ffbc(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x95c1(%rip), %rdi      # 0x258cf
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1c3a9
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1ff73(%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 0x12a82(%rip), %rdi     # 0x2edee
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ff33(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x12a85(%rip), %rdi     # 0x2ee1c
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1c444
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1fee1(%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 0x12a50(%rip), %rdi     # 0x2ee4b
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1c326
movq 0x1fe95(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
addq $0x16, %rcx
movl (%rbx), %r8d
leaq 0x12a58(%rip), %rdi     # 0x2ee84
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_O3/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 0x1c71f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fca6(%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 0x129a9(%rip), %rdi     # 0x2efdf
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c44a
movq 0x1fc5d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x14(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzwl 0x14(%r14), %r8d
leaq 0x129a8(%rip), %rdi     # 0x2f016
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1fc31(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x16(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x129ae(%rip), %rdi     # 0x2f046
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1c3af
movq 0x1fbfd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1a(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0x129aa(%rip), %rdi     # 0x2f076
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1c3af
movq 0x1fbc9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x1e, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x129a8(%rip), %rdi     # 0x2f0a7
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c3af
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c7bf
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fb6b(%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 0x12966(%rip), %rdi     # 0x2f0d7
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c5e9
movq 0x1fb20(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x32, %rcx
leaq 0x1297e(%rip), %rdi     # 0x2f11c
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c44a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c8e2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1fac7(%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 0x12952(%rip), %rdi     # 0x2f161
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 0x1c725
addl $0x22, %r15d
leaq 0xea0e(%rip), %r12      # 0x2b249
xorl %r13d, %r13d
movq 0x1fa6b(%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 0x1c83e
movl %ebx, %r12d
subl %r14d, %r12d
addl $0x100, %r12d           # imm = 0x100
leaq 0x12903(%rip), %r14     # 0x2f193
xorl %r15d, %r15d
movq 0x1fa16(%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 0x1c893
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_O3/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 0x1d537
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1ee11(%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 0x7e20(%rip), %rdi      # 0x252ee
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1edd1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x128bb(%rip), %rdi     # 0x2fdb5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1eda5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x128c6(%rip), %rdi     # 0x2fdeb
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x1d671
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ed52(%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 0x5624(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x1ed09(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x18, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x12860(%rip), %rdi     # 0x2fe22
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ecdd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x6(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x6(%r14), %r8d
leaq 0x1286c(%rip), %rdi     # 0x2fe5a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ecb1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x8(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x12876(%rip), %rdi     # 0x2fe8e
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1d2ef
movq 0x1ec7a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x12, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x1287b(%rip), %rdi     # 0x2fec9
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d484
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x16, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d89c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x1eaae(%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 0x5386(%rip), %rdi      # 0x22bae
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 0x5fe4
addl $0x4, %ebp
leaq 0x126e5(%rip), %r14     # 0x2ff36
xorl %r15d, %r15d
movq 0x1ea55(%rip), %rcx     # 0x3c2b0
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
cmpq $0x10, %r15
jne 0x1d854
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x24, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d96f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e9f3(%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), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x12684(%rip), %rdi     # 0x2ff71
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e9b2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x1268a(%rip), %rdi     # 0x2ffa3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e986(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x1268d(%rip), %rdi     # 0x2ffd2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e95a(%rip), %rbx     # 0x3c2b0
leaq 0x126a7(%rip), %rdi     # 0x30004
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1da42
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e920(%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), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x125b1(%rip), %rdi     # 0x2ff71
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e8df(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x125b7(%rip), %rdi     # 0x2ffa3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e8b3(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x125ba(%rip), %rdi     # 0x2ffd2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e887(%rip), %rbx     # 0x3c2b0
leaq 0x12606(%rip), %rdi     # 0x30036
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: 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 0x1daac
pushq %rbx
movq 0x1e85b(%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 $0x11, %rcx
movzwl (%rsi), %r8d
leaq 0x125e5(%rip), %rdi     # 0x30068
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e819(%rip), %rbx     # 0x3c2b0
leaq 0x125fb(%rip), %rdi     # 0x30099
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper
int DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *d = (DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DP_ENCODER_SERVICE_PARAMETERS_V2 asDPServiceParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asDPServiceParam)-start), FILL(48)); DP_ENCODER_SERVICE_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asDPServiceParam, indent+1);
    printf ("%s%04x:  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 asAuxParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asAuxParam)-start), FILL(55)); PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asAuxParam, indent+1);
  }
  return sizeof (DP_ENCODER_SERVICE_PS_ALLOCATION_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1dcc1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e672(%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 $0x30, %rcx
leaq 0x124ee(%rip), %rdi     # 0x30158
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1dab2
movq 0x1e629(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x124f9(%rip), %rdi     # 0x30198
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d975
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper
int PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *d = (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucI2CSpeed%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CSpeed)-start), FILL(15), d->ucI2CSpeed, d->ucI2CSpeed);
    printf ("%s  <unparsable> line 3859:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1dd2b
pushq %rbx
movq 0x1e5dc(%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
movzbl (%rsi), %r8d
leaq 0x124dd(%rip), %rdi     # 0x301df
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e59a(%rip), %rbx     # 0x3c2b0
leaq 0x124f3(%rip), %rdi     # 0x30210
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper
int SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_HWBLOCK_INSTANCE_PARAMETER_V2 *d = (SET_HWBLOCK_INSTANCE_PARAMETER_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucHWBlkInst%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWBlkInst)-start), FILL(16), d->ucHWBlkInst, d->ucHWBlkInst);
    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]); }
  }
  return sizeof (SET_HWBLOCK_INSTANCE_PARAMETER_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1ddde
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x1e554(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x124c8(%rip), %rax     # 0x30243
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x6c43(%rip), %r15      # 0x249de
xorl %r12d, %r12d
movq 0x1e50b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x13, %rcx
movzbl 0x1(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x1dd9e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq