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

// Assembly:
testq %rsi, %rsi
je 0x11a43
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a905(%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 0x18553(%rip), %rdi     # 0x29f2d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a8c5(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x1(%rbx), %r8d
leaq 0x1855a(%rip), %rdi     # 0x29f60
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a899(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x1855c(%rip), %rdi     # 0x29f8d
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_LCD_RTS_RECORD_dumper
int ATOM_LCD_RTS_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LCD_RTS_RECORD *d = (ATOM_LCD_RTS_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucRTSValue%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRTSValue)-start), FILL(15), d->ucRTSValue, d->ucRTSValue);
  }
  return sizeof (ATOM_LCD_RTS_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x11acc
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a850(%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 0x1849e(%rip), %rdi     # 0x29f2d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a810(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x18500(%rip), %rdi     # 0x29fba
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_LCD_MODE_CONTROL_CAP_dumper
int ATOM_LCD_MODE_CONTROL_CAP_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LCD_MODE_CONTROL_CAP *d = (ATOM_LCD_MODE_CONTROL_CAP *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  USHORT usLCDCap%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usLCDCap)-start), FILL(14), d->usLCDCap, d->usLCDCap);
  }
  return sizeof (ATOM_LCD_MODE_CONTROL_CAP);
}

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

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

// Assembly:
testq %rsi, %rsi
je 0x11cd3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a675(%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 0x182c3(%rip), %rdi     # 0x29f2d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a635(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x1(%rbx), %r8d
leaq 0x183f6(%rip), %rdi     # 0x2a08c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a609(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x183f8(%rip), %rdi     # 0x2a0b9
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SPREAD_SPECTRUM_INFO_dumper
int ATOM_SPREAD_SPECTRUM_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SPREAD_SPECTRUM_INFO *d = (ATOM_SPREAD_SPECTRUM_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  ATOM_SPREAD_SPECTRUM_ASSIGNMENT asSS_Info%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asSS_Info[i])-start), FILL(44+(i>9)), i); ATOM_SPREAD_SPECTRUM_ASSIGNMENT_dumper (start, (uint8_t*) &d->asSS_Info[i], indent+1); }
  }
  return sizeof (ATOM_SPREAD_SPECTRUM_INFO);
}

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

// Assembly:
testq %rsi, %rsi
je 0x122f5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a07f(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0x180e4(%rip), %rdi     # 0x2a344
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a03f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x180ef(%rip), %rdi     # 0x2a37b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2a013(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x180f7(%rip), %rdi     # 0x2a3af
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29fe7(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x180fc(%rip), %rdi     # 0x2a3df
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper
int ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_VRAM_RESERVE_INFO *d = (ATOM_FIRMWARE_VRAM_RESERVE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulStartAddrUsedByFirmware%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStartAddrUsedByFirmware)-start), FILL(30), d->ulStartAddrUsedByFirmware, d->ulStartAddrUsedByFirmware);
    printf ("%s%04x:  USHORT usFirmwareUseInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFirmwareUseInKb)-start), FILL(23), d->usFirmwareUseInKb, d->usFirmwareUseInKb);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_FIRMWARE_VRAM_RESERVE_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x123ad
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29f9a(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x180d1(%rip), %rdi     # 0x2a415
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29f5b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x180df(%rip), %rdi     # 0x2a44f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29f2f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x162dc(%rip), %rdi     # 0x28677
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_USAGE_BY_FIRMWARE_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE *d = (ATOM_VRAM_USAGE_BY_FIRMWARE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_FIRMWARE_VRAM_RESERVE_INFO asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(60+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE);
}

// Assembly:
testq %rsi, %rsi
je 0x12459
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x29edd(%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 0x107d2(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x29e94(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x18052(%rip), %rdi     # 0x2a486
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x122fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper
int ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 *d = (ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulStartAddrUsedByFirmware%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStartAddrUsedByFirmware)-start), FILL(30), d->ulStartAddrUsedByFirmware, d->ulStartAddrUsedByFirmware);
    printf ("%s%04x:  USHORT usFirmwareUseInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFirmwareUseInKb)-start), FILL(23), d->usFirmwareUseInKb, d->usFirmwareUseInKb);
    printf ("%s%04x:  USHORT usFBUsedByDrvInKb%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFBUsedByDrvInKb)-start), FILL(23), d->usFBUsedByDrvInKb, d->usFBUsedByDrvInKb);
  }
  return sizeof (ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5);
}

// Assembly:
testq %rsi, %rsi
je 0x12511
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29e36(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
movl (%rbx), %r8d
leaq 0x17f6d(%rip), %rdi     # 0x2a415
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29df7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17f7b(%rip), %rdi     # 0x2a44f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29dcb(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17fd4(%rip), %rdi     # 0x2a4d3
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *d = (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(65+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5);
}

// Assembly:
testq %rsi, %rsi
je 0x125bd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x29d79(%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 0x1066e(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x29d30(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x17f72(%rip), %rdi     # 0x2a50a
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1245f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_PIN_ASSIGNMENT_dumper
int ATOM_GPIO_PIN_ASSIGNMENT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_ASSIGNMENT *d = (ATOM_GPIO_PIN_ASSIGNMENT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usGpioPin_AIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGpioPin_AIndex)-start), FILL(22), d->usGpioPin_AIndex, d->usGpioPin_AIndex);
    printf ("%s%04x:  UCHAR ucGpioPinBitShift%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGpioPinBitShift)-start), FILL(22), d->ucGpioPinBitShift, d->ucGpioPinBitShift);
    printf ("%s%04x:  UCHAR ucGPIO_ID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIO_ID)-start), FILL(14), d->ucGPIO_ID, d->ucGPIO_ID);
  }
  return sizeof (ATOM_GPIO_PIN_ASSIGNMENT);
}

// Assembly:
testq %rsi, %rsi
je 0x12676
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29cd2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x17f4f(%rip), %rdi     # 0x2a55c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29c92(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17f59(%rip), %rdi     # 0x2a592
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29c66(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17f66(%rip), %rdi     # 0x2a5ca
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_PIN_LUT_dumper
int ATOM_GPIO_PIN_LUT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_LUT *d = (ATOM_GPIO_PIN_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_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT); i++) {
      printf ("%s%04x:  ATOM_GPIO_PIN_ASSIGNMENT asGPIO_Pin%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asGPIO_Pin[i])-start), FILL(38+(i>9)), i); ATOM_GPIO_PIN_ASSIGNMENT_dumper (start, (uint8_t*) &d->asGPIO_Pin[i], indent+1); }
  }
  return RETURN_ALL (ATOM_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x1275f
movl %edx, %ebx
movq %rsi, %r14
movq 0x29c10(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %r14d, %edx
movq (%rsp), %r12
subl %r12d, %edx
addq $0x1f, %rcx
leaq 0x10501(%rip), %rdi     # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movzwl (%r14), %eax
movl %eax, %ecx
andl $-0x4, %ecx
cmpw $0x4, %cx
je 0x12758
leaq 0x4(%r14), %r12
movl %r14d, %ebp
subl (%rsp), %ebp
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x29ba4(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x26, %rcx
leaq 0x17ed7(%rip), %rdi     # 0x2a5fa
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x125c3
incq %r13
movzwl (%r14), %eax
leaq -0x4(%rax), %rcx
shrq $0x2, %rcx
addq $0x4, %r12
addl $0x4, %ebp
cmpq %r13, %rcx
ja 0x12705
andl $0xfffc, %eax           # imm = 0xFFFC
jmp 0x12761
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_INFO_dumper
int ATOM_GPIO_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_INFO *d = (ATOM_GPIO_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usAOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usAOffset)-start), FILL(15), d->usAOffset, d->usAOffset);
    printf ("%s%04x:  UCHAR ucSettings%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSettings)-start), FILL(15), d->ucSettings, d->ucSettings);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
  }
  return sizeof (ATOM_GPIO_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x12823
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29b25(%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 0x17e77(%rip), %rdi     # 0x2a631
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29ae5(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17e7a(%rip), %rdi     # 0x2a660
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29ab9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1075e(%rip), %rdi     # 0x22f6f
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_OBJECT_PATH_dumper
int ATOM_DISPLAY_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH *d = (ATOM_DISPLAY_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x133dc
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28fcc(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x17807(%rip), %rdi     # 0x2ab1a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28f8c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1780c(%rip), %rdi     # 0x2ab4b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28f60(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1780c(%rip), %rdi     # 0x2ab77
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28f34(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17814(%rip), %rdi     # 0x2abab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28f08(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x17818(%rip), %rdi     # 0x2abde
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_EXTERNAL_OBJECT_PATH_dumper
int ATOM_DISPLAY_EXTERNAL_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *d = (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x13510
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x28ea1(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x176ec(%rip), %rdi     # 0x2ab1a
movl %ebx, %ebp
subl %r14d, %ebp
movl %ebp, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28e6a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x176ea(%rip), %rdi     # 0x2ab4b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28e3e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x176ea(%rip), %rdi     # 0x2ab77
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28e12(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x176f2(%rip), %rdi     # 0x2abab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x8, %ebp
leaq 0x17711(%rip), %r14     # 0x2abde
xorl %r15d, %r15d
movq 0x28dd9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x19, %rcx
movzwl 0x8(%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 $0x1, %r15
je 0x134d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper
int ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH_TABLE *d = (ATOM_DISPLAY_OBJECT_PATH_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumOfDispPath%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfDispPath)-start), FILL(20), d->ucNumOfDispPath, d->ucNumOfDispPath);
    printf ("%s%04x:  UCHAR ucVersion%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVersion)-start), FILL(14), d->ucVersion, d->ucVersion);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_DISPLAY_OBJECT_PATH asDispPath%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asDispPath[i])-start), FILL(38+(i>9)), i); ATOM_DISPLAY_OBJECT_PATH_dumper (start, (uint8_t*) &d->asDispPath[i], indent+1); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x13639
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x28d69(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x14, %rcx
movzbl (%r14), %r8d
leaq 0x176b2(%rip), %rdi     # 0x2ac18
movl %r14d, %r13d
subl %r15d, %r13d
movl %r13d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28d30(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
movq %r15, 0x10(%rsp)
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x176ae(%rip), %rdi     # 0x2ac4e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x2, %r13d
leaq 0x1122e(%rip), %rbp     # 0x247e3
xorl %r15d, %r15d
movq 0x28cf1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leal (%r15,%r13), %edx
addq $0x12, %rcx
movzbl 0x2(%r14,%r15), %r9d
movl %r9d, (%rsp)
movq %rbp, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
cmpq $0x1, %r15
je 0x135b8
movq 0x28cbe(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x26, %rcx
leaq 0x1766f(%rip), %rdi     # 0x2ac7e
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x132c5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xe, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_dumper
int ATOM_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT *d = (ATOM_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usObjectID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usObjectID)-start), FILL(16), d->usObjectID, d->usObjectID);
    printf ("%s%04x:  USHORT usSrcDstTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSrcDstTableOffset)-start), FILL(25), d->usSrcDstTableOffset, d->usSrcDstTableOffset);
    printf ("%s%04x:  USHORT usRecordOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRecordOffset)-start), FILL(20), d->usRecordOffset, d->usRecordOffset);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x1371e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28c56(%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 0x1762c(%rip), %rdi     # 0x2acb5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28c16(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x17630(%rip), %rdi     # 0x2ace5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28bea(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1763d(%rip), %rdi     # 0x2ad1e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28bbe(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x14f6b(%rip), %rdi     # 0x28677
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_TABLE_dumper
int ATOM_OBJECT_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT_TABLE *d = (ATOM_OBJECT_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumberOfObjects%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfObjects)-start), FILL(22), d->ucNumberOfObjects, d->ucNumberOfObjects);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_OBJECT asObjects%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asObjects[i])-start), FILL(24+(i>9)), i); ATOM_OBJECT_dumper (start, (uint8_t*) &d->asObjects[i], indent+1); }
  }
  return sizeof (ATOM_OBJECT_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x1381a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r9
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x28b5b(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x16, %rcx
movzbl (%r14), %r8d
leaq 0x175de(%rip), %rdi     # 0x2ad52
movl %r14d, %r13d
movq %r9, 0x10(%rsp)
subl %r9d, %r13d
movl %r13d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r13d
leaq 0x1104d(%rip), %rbp     # 0x247e3
xorl %r15d, %r15d
movq 0x28b10(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leal (%r15,%r13), %edx
addq $0x12, %rcx
movzbl 0x1(%r14,%r15), %r9d
movl %r9d, (%rsp)
movq %rbp, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
cmpq $0x3, %r15
jne 0x13799
movq 0x28add(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
movq 0x10(%rsp), %r15
subl %r15d, %edx
addq $0x18, %rcx
leaq 0x1759a(%rip), %rdi     # 0x2ad8a
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1363f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT_dumper
int ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *d = (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumberOfSrc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfSrc)-start), FILL(18), d->ucNumberOfSrc, d->ucNumberOfSrc);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usSrcObjectID%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSrcObjectID[i])-start), FILL(23+(i>9)), i, d->usSrcObjectID[i], d->usSrcObjectID[i]); }
    printf ("%s%04x:  UCHAR ucNumberOfDst%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfDst)-start), FILL(18), d->ucNumberOfDst, d->ucNumberOfDst);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usDstObjectID%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDstObjectID[i])-start), FILL(23+(i>9)), i, d->usDstObjectID[i], d->usDstObjectID[i]); }
  }
  return sizeof (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x1390f
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28a71(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x12, %rcx
movzbl (%rbx), %r8d
leaq 0x17545(%rip), %rdi     # 0x2adb3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28a31(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x17549(%rip), %rdi     # 0x2ade7
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x28a01(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17555(%rip), %rdi     # 0x2ae1f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x289d5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1755a(%rip), %rdi     # 0x2ae53
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DP_CONN_CHANNEL_MAPPING_dumper
int ATOM_DP_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DP_CONN_CHANNEL_MAPPING *d = (ATOM_DP_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDP_Lane0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane0_Source, d->ucDP_Lane0_Source);
    printf ("%s       UCHAR ucDP_Lane1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane1_Source, d->ucDP_Lane1_Source);
    printf ("%s       UCHAR ucDP_Lane2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane2_Source, d->ucDP_Lane2_Source);
    printf ("%s       UCHAR ucDP_Lane3_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane3_Source, d->ucDP_Lane3_Source);
  }
  return sizeof (ATOM_DP_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x139e6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28984(%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 $0x18, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x17533(%rip), %rdi     # 0x2ae8b
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x28944(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x17541(%rip), %rdi     # 0x2aec5
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2891b(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x17552(%rip), %rdi     # 0x2aeff
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x288f2(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x17567(%rip), %rdi     # 0x2af39
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DVI_CONN_CHANNEL_MAPPING_dumper
int ATOM_DVI_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DVI_CONN_CHANNEL_MAPPING *d = (ATOM_DVI_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDVI_DATA2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA2_Source, d->ucDVI_DATA2_Source);
    printf ("%s       UCHAR ucDVI_DATA1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA1_Source, d->ucDVI_DATA1_Source);
    printf ("%s       UCHAR ucDVI_DATA0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA0_Source, d->ucDVI_DATA0_Source);
    printf ("%s       UCHAR ucDVI_CLK_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucDVI_CLK_Source, d->ucDVI_CLK_Source);
  }
  return sizeof (ATOM_DVI_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x13abd
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x288ad(%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 $0x19, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x17544(%rip), %rdi     # 0x2af73
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2886d(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x17553(%rip), %rdi     # 0x2afae
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x28844(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x17565(%rip), %rdi     # 0x2afe9
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2881b(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x1757b(%rip), %rdi     # 0x2b024
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_COMMON_RECORD_HEADER_dumper
int ATOM_COMMON_RECORD_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_RECORD_HEADER *d = (ATOM_COMMON_RECORD_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucRecordSize%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordSize)-start), FILL(17), d->ucRecordSize, d->ucRecordSize);
  }
  return sizeof (ATOM_COMMON_RECORD_HEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x13e7e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2849e(%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 0x160ec(%rip), %rdi     # 0x29f2d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2845e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x17434(%rip), %rdi     # 0x2b2a0
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_I2C_RECORD_dumper
int ATOM_I2C_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_RECORD *d = (ATOM_I2C_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(26)); ATOM_I2C_ID_CONFIG_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
    printf ("%s%04x:  UCHAR ucI2CAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CAddr)-start), FILL(14), d->ucI2CAddr, d->ucI2CAddr);
  }
  return sizeof (ATOM_I2C_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x13f4c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2840c(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x17404(%rip), %rdi     # 0x2b2d3
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13dfb
movq 0x283c4(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %r12
movl %r12d, %edx
subl %r14d, %edx
addq $0x1a, %rcx
leaq 0x173fe(%rip), %rdi     # 0x2b303
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
movl %ebp, %edx
callq 0xfb85
movq 0x28393(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x173f6(%rip), %rdi     # 0x2b32d
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq