LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_DVO_CF_RECORD_dumper
int ATOM_ENCODER_DVO_CF_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_DVO_CF_RECORD *d = (ATOM_ENCODER_DVO_CF_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:  ULONG ulStrengthControl%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulStrengthControl)-start), FILL(22), d->ulStrengthControl, d->ulStrengthControl);
    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]); }
  }
  return sizeof (ATOM_ENCODER_DVO_CF_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14ca0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x276d8(%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
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x166ad(%rip), %rdi     # 0x2b2b0
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x2768d(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movl 0x2(%rbx), %r8d
leaq 0x16d8f(%rip), %rdi     # 0x2b9cc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %rbx
movb $0x1, %bpl
leaq 0xfb6b(%rip), %r12      # 0x247c0
movq 0x27654(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq (%rbx,%r15), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl (%rbx,%r15), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x14c55
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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_ENCODER_CAP_RECORD_dumper
int ATOM_ENCODER_CAP_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_CAP_RECORD *d = (ATOM_ENCODER_CAP_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  <unparsable> line 2623:   union {\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (ATOM_ENCODER_CAP_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14d2a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x275ee(%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 $0x20, %rcx
leaq 0x165c2(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13f7e
addq 0x275a5(%rip), %r12     # 0x3c2b0
leaq 0x16cec(%rip), %rdi     # 0x2b9fe
movq %r12, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_CF_RECORD_dumper
int ATOM_CONNECTOR_CF_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_CF_RECORD *d = (ATOM_CONNECTOR_CF_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:  USHORT usMaxPixClk%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxPixClk)-start), FILL(17), d->usMaxPixClk, d->usMaxPixClk);
    printf ("%s%04x:  UCHAR ucFlowCntlGpioId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFlowCntlGpioId)-start), FILL(21), d->ucFlowCntlGpioId, d->ucFlowCntlGpioId);
    printf ("%s%04x:  UCHAR ucSwapCntlGpioId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSwapCntlGpioId)-start), FILL(21), d->ucSwapCntlGpioId, d->ucSwapCntlGpioId);
    printf ("%s%04x:  UCHAR ucConnectedDvoBundle%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConnectedDvoBundle)-start), FILL(25), d->ucConnectedDvoBundle, d->ucConnectedDvoBundle);
    printf ("%s%04x:  UCHAR ucPadding%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding)-start), FILL(14), d->ucPadding, d->ucPadding);
  }
  return sizeof (ATOM_CONNECTOR_CF_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14e78
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27561(%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 0x16536(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x27519(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x16c81(%rip), %rdi     # 0x2ba33
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x274ed(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x16c86(%rip), %rdi     # 0x2ba64
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x274c1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x16c91(%rip), %rdi     # 0x2ba9b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27495(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x16c9c(%rip), %rdi     # 0x2bad2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27469(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1042e(%rip), %rdi     # 0x2528f
movq %r15, %rsi
movl %r8d, %r9d
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_CONNECTOR_HARDCODE_DTD_RECORD_dumper
int ATOM_CONNECTOR_HARDCODE_DTD_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_HARDCODE_DTD_RECORD *d = (ATOM_CONNECTOR_HARDCODE_DTD_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_DTD_FORMAT asTiming%s :\n", IND(indent), (int)(((uint8_t*)&d->asTiming)-start), FILL(23)); ATOM_DTD_FORMAT_dumper (start, (uint8_t*) &d->asTiming, indent+1);
  }
  return sizeof (ATOM_CONNECTOR_HARDCODE_DTD_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14f21
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x27412(%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 $0x20, %rcx
leaq 0x163e6(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13f7e
movq 0x273c9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x2, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x17, %rcx
leaq 0x16c0e(%rip), %rdi     # 0x2bb0d
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x10e28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x1e, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_PCIE_SUBCONNECTOR_RECORD_dumper
int ATOM_CONNECTOR_PCIE_SUBCONNECTOR_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_PCIE_SUBCONNECTOR_RECORD *d = (ATOM_CONNECTOR_PCIE_SUBCONNECTOR_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:  UCHAR ucSubConnectorType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSubConnectorType)-start), FILL(23), d->ucSubConnectorType, d->ucSubConnectorType);
    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_CONNECTOR_PCIE_SUBCONNECTOR_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14feb
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2736a(%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 0x1633f(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x27322(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x16b8b(%rip), %rdi     # 0x2bb34
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x272f6(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xdf78(%rip), %rdi      # 0x22f4c
movq %r15, %rsi
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_ROUTER_DDC_PATH_SELECT_RECORD_dumper
int ATOM_ROUTER_DDC_PATH_SELECT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ROUTER_DDC_PATH_SELECT_RECORD *d = (ATOM_ROUTER_DDC_PATH_SELECT_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:  UCHAR ucMuxType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMuxType)-start), FILL(14), d->ucMuxType, d->ucMuxType);
    printf ("%s%04x:  UCHAR ucMuxControlPin%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMuxControlPin)-start), FILL(20), d->ucMuxControlPin, d->ucMuxControlPin);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucMuxState%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMuxState[i])-start), FILL(19+(i>9)), i, d->ucMuxState[i], d->ucMuxState[i]); }
  }
  return sizeof (ATOM_ROUTER_DDC_PATH_SELECT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x15109
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2729c(%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
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x16271(%rip), %rdi     # 0x2b2b0
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x27251(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x16af3(%rip), %rdi     # 0x2bb6d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27225(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x16af7(%rip), %rdi     # 0x2bb9d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x4, %rbx
movb $0x1, %bpl
leaq 0x16b15(%rip), %r12     # 0x2bbd3
movq 0x271eb(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq (%rbx,%r15), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl (%rbx,%r15), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x150be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_HPDPIN_LUT_RECORD_dumper
int ATOM_CONNECTOR_HPDPIN_LUT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_HPDPIN_LUT_RECORD *d = (ATOM_CONNECTOR_HPDPIN_LUT_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);
    for (i = 0; i < 8; i++) {
      printf ("%s%04x:  UCHAR ucHPDPINMap%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHPDPINMap[i])-start), FILL(20+(i>9)), i, d->ucHPDPINMap[i], d->ucHPDPINMap[i]); }
  }
  return sizeof (ATOM_CONNECTOR_HPDPIN_LUT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x152e4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x27060(%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 $0x20, %rcx
leaq 0x1603a(%rip), %rdi     # 0x2b2b0
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 0x13f7e
addl $0x2, %r14d
leaq 0x16969(%rip), %r15     # 0x2bc09
xorl %r12d, %r12d
movq 0x27006(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x14, %rcx
movzbl 0x2(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x8, %r12
jne 0x152a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_AUXDDC_LUT_RECORD_dumper
int ATOM_CONNECTOR_AUXDDC_LUT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_AUXDDC_LUT_RECORD *d = (ATOM_CONNECTOR_AUXDDC_LUT_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);
    for (i = 0; i < 8; i++) {
      printf ("%s%04x:  ATOM_I2C_ID_CONFIG ucAUXDDCMap%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->ucAUXDDCMap[i])-start), FILL(33+(i>9)), i); ATOM_I2C_ID_CONFIG_dumper (start, (uint8_t*) &d->ucAUXDDCMap[i], indent+1); }
  }
  return sizeof (ATOM_CONNECTOR_AUXDDC_LUT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x153a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r13
movq 0x26fa3(%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 $0x20, %rcx
leaq 0x15f7d(%rip), %rdi     # 0x2b2b0
movl %r14d, %r15d
subl %r13d, %r15d
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13f7e
addq $0x2, %r14
addl $0x2, %r15d
xorl %r13d, %r13d
movq 0x26f4c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq (%r14,%r13), %rbp
leal (%r15,%r13), %edx
addq $0x21, %rcx
leaq 0x168c5(%rip), %rdi     # 0x2bc40
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %rbp, %rsi
movl %ebx, %edx
callq 0xfcf9
incq %r13
cmpq $0x8, %r13
jne 0x1535d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_LINK_RECORD_dumper
int ATOM_OBJECT_LINK_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT_LINK_RECORD *d = (ATOM_OBJECT_LINK_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:  USHORT usObjectID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usObjectID)-start), FILL(16), d->usObjectID, d->usObjectID);
  }
  return sizeof (ATOM_OBJECT_LINK_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x15444
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26ee5(%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 0x15eba(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x26e9d(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x15865(%rip), %rdi     # 0x2ac92
movq %r15, %rsi
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_CONNECTOR_REMOTE_CAP_RECORD_dumper
int ATOM_CONNECTOR_REMOTE_CAP_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_REMOTE_CAP_RECORD *d = (ATOM_CONNECTOR_REMOTE_CAP_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:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_CONNECTOR_REMOTE_CAP_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x154e2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26e47(%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 0x15e1c(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x26dff(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x13189(%rip), %rdi     # 0x28654
movq %r15, %rsi
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_VOLTAGE_INFO_dumper
int ATOM_VOLTAGE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_INFO *d = (ATOM_VOLTAGE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  ATOM_VOLTAGE_INFO_HEADER viHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->viHeader)-start), FILL(32)); ATOM_VOLTAGE_INFO_HEADER_dumper (start, (uint8_t*) &d->viHeader, indent+1);
    for (i = 0; i < 64; i++) {
      printf ("%s%04x:  UCHAR ucVoltageEntries%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageEntries[i])-start), FILL(25+(i>9)), i, d->ucVoltageEntries[i], d->ucVoltageEntries[i]); }
  }
  return sizeof (ATOM_VOLTAGE_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1579c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x26be4(%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 0xd4bc(%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
movq 0x26b98(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %r12
movl %r12d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x16718(%rip), %rdi     # 0x2be49
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x154e8
addl $0xf, %r14d
leaq 0x16729(%rip), %r15     # 0x2be79
xorl %r12d, %r12d
movq 0x26b56(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
cmpq $0xa, %r12
sbbq $-0x1, %rcx
addq $0x19, %rcx
movzbl 0xf(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x40, %r12
jne 0x15753
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x4f, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: VOLTAGE_LUT_ENTRY_dumper
int VOLTAGE_LUT_ENTRY_dumper (uint8_t *start, uint8_t *data, int indent) {
  VOLTAGE_LUT_ENTRY *d = (VOLTAGE_LUT_ENTRY *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usVoltageCode%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageCode)-start), FILL(19), d->usVoltageCode, d->usVoltageCode);
    printf ("%s%04x:  USHORT usVoltageValue%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageValue)-start), FILL(20), d->usVoltageValue, d->usVoltageValue);
  }
  return sizeof (VOLTAGE_LUT_ENTRY);
}

// Assembly:
testq %rsi, %rsi
je 0x159c8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x26954(%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 $0x13, %rcx
movzwl (%rbx), %r8d
leaq 0x16630(%rip), %rdi     # 0x2bfbb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26914(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x16638(%rip), %rdi     # 0x2bfee
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_VOLTAGE_FORMULA_V2_dumper
int ATOM_VOLTAGE_FORMULA_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_FORMULA_V2 *d = (ATOM_VOLTAGE_FORMULA_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumOfVoltageEntries%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfVoltageEntries)-start), FILL(26), d->ucNumOfVoltageEntries, d->ucNumOfVoltageEntries);
    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]); }
    for (i = 0; i < 32; i++) {
      printf ("%s%04x:  VOLTAGE_LUT_ENTRY asVIDAdjustEntries%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asVIDAdjustEntries[i])-start), FILL(39+(i>9)), i); VOLTAGE_LUT_ENTRY_dumper (start, (uint8_t*) &d->asVIDAdjustEntries[i], indent+1); }
  }
  return sizeof (ATOM_VOLTAGE_FORMULA_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x15ae0
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 0x268b1(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
addq $0x1a, %rcx
movzbl (%r14), %r8d
leaq 0x16289(%rip), %rdi     # 0x2bca7
movl %r14d, %r12d
movq %r9, 0x10(%rsp)
subl %r9d, %r12d
movl %r12d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r12d
leaq 0xef9e(%rip), %r13      # 0x249de
xorl %ebp, %ebp
movq 0x26867(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leal (%r12,%rbp), %edx
addq $0x13, %rcx
movzbl 0x1(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
cmpq $0x3, %rbp
jne 0x15a42
leaq 0x4(%r14), %r12
incl %ebx
movq 0x10(%rsp), %r13
subl %r13d, %r14d
addl $0x4, %r14d
xorl %ebp, %ebp
movq 0x26820(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
cmpq $0xa, %rbp
sbbq $-0x1, %rcx
addq $0x27, %rcx
leaq 0x1657b(%rip), %rdi     # 0x2c022
movl %r14d, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r13, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x15945
incq %rbp
addq $0x4, %r12
addl $0x4, %r14d
cmpq $0x20, %rbp
jne 0x15a89
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x84, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_dumper
int ATOM_VOLTAGE_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT *d = (ATOM_VOLTAGE_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVoltageType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageType)-start), FILL(18), d->ucVoltageType, d->ucVoltageType);
    printf ("%s%04x:  UCHAR ucSize%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSize)-start), FILL(11), d->ucSize, d->ucSize);
    printf ("%s%04x:  ATOM_VOLTAGE_CONTROL asControl%s :\n", IND(indent), (int)(((uint8_t*)&d->asControl)-start), FILL(29)); ATOM_VOLTAGE_CONTROL_dumper (start, (uint8_t*) &d->asControl, indent+1);
    printf ("%s%04x:  ATOM_VOLTAGE_FORMULA asFormula%s :\n", IND(indent), (int)(((uint8_t*)&d->asFormula)-start), FILL(29)); ATOM_VOLTAGE_FORMULA_dumper (start, (uint8_t*) &d->asFormula, indent+1);
  }
  return sizeof (ATOM_VOLTAGE_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x15d72
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26619(%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 $0x12, %rcx
movzbl (%r14), %r8d
leaq 0x10188(%rip), %rdi     # 0x25e4f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x265d8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
subl %r15d, %edx
addq $0xb, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x163dd(%rip), %rdi     # 0x2c0d0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x265ac(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x1d, %rcx
leaq 0x163e0(%rip), %rdi     # 0x2c0fd
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x15ae6
movq 0x26576(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x12, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1d, %rcx
leaq 0x163d8(%rip), %rdi     # 0x2c12a
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x157a2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x3a, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_V2_dumper
int ATOM_VOLTAGE_OBJECT_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT_V2 *d = (ATOM_VOLTAGE_OBJECT_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucVoltageType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVoltageType)-start), FILL(18), d->ucVoltageType, d->ucVoltageType);
    printf ("%s%04x:  UCHAR ucSize%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSize)-start), FILL(11), d->ucSize, d->ucSize);
    printf ("%s%04x:  ATOM_VOLTAGE_CONTROL asControl%s :\n", IND(indent), (int)(((uint8_t*)&d->asControl)-start), FILL(29)); ATOM_VOLTAGE_CONTROL_dumper (start, (uint8_t*) &d->asControl, indent+1);
    printf ("%s%04x:  ATOM_VOLTAGE_FORMULA_V2 asFormula%s :\n", IND(indent), (int)(((uint8_t*)&d->asFormula)-start), FILL(32)); ATOM_VOLTAGE_FORMULA_V2_dumper (start, (uint8_t*) &d->asFormula, indent+1);
  }
  return sizeof (ATOM_VOLTAGE_OBJECT_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x15e74
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26517(%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 $0x12, %rcx
movzbl (%r14), %r8d
leaq 0x10086(%rip), %rdi     # 0x25e4f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x264d6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%r14), %rdx
subl %r15d, %edx
addq $0xb, %rcx
movzbl 0x1(%r14), %r8d
leaq 0x162db(%rip), %rdi     # 0x2c0d0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x264aa(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x1d, %rcx
leaq 0x162de(%rip), %rdi     # 0x2c0fd
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x15ae6
movq 0x26474(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x12, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x16303(%rip), %rdi     # 0x2c157
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x159ce
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x96, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_INFO_dumper
int ATOM_VOLTAGE_OBJECT_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT_INFO *d = (ATOM_VOLTAGE_OBJECT_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < (count_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d)); i++) {
      printf ("%s%04x:  ATOM_VOLTAGE_OBJECT asVoltageObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&*(offset_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d,i)))-start), FILL(35+(i>9)), i); ATOM_VOLTAGE_OBJECT_dumper (start, (uint8_t*) &*(offset_ATOM_VOLTAGE_OBJECT_INFO_asVoltageObj(d,i)), indent+1); }
  }
  return 0;
}

// Assembly:
testq %rsi, %rsi
je 0x15ff4
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 0x26410(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
leaq (%rcx,%rax), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0xccdd(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
leaq 0x4(%r14), %r12
movl %r12d, %eax
subl %r15d, %eax
movl %eax, 0xc(%rsp)
movl $0x1, %ebp
xorl %r13d, %r13d
movzwl (%r14), %eax
movl $0x1, %ecx
xorl %esi, %esi
xorl %r9d, %r9d
movl %r9d, %edx
testl %r9d, %r9d
je 0x15f31
movl %ecx, %r8d
movq %r12, %rdi
movq %rdi, %r9
movzbl 0x1(%rdi), %edi
addq %r9, %rdi
decl %r8d
cmpl $0x1, %r8d
ja 0x15f19
movq %rdi, %r8
jmp 0x15f37
movq %r12, %r8
movq %r12, %rdi
cmpq %rsi, %rdi
je 0x15f4d
subq %r14, %r8
leal 0x1(%rdx), %r9d
incl %ecx
movq %rdi, %rsi
cmpq %rax, %r8
jl 0x15f0b
cmpl %edx, %r13d
jae 0x15fe6
movq 0x26353(%rip), %rcx     # 0x3c2b0
movq 0x10(%rsp), %rax
leaq (%rcx,%rax), %rsi
testl %r13d, %r13d
je 0x15fb6
movl %ebp, %eax
movq %r12, %rdx
movq %rdx, %rdi
movzbl 0x1(%rdx), %edx
addq %rdi, %rdx
decl %eax
cmpl $0x1, %eax
ja 0x15f70
subl %r15d, %edx
cmpl $0xa, %r13d
sbbq $-0x1, %rcx
addq $0x23, %rcx
leaq 0x161f0(%rip), %rdi     # 0x2c187
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movl %ebp, %eax
movq %r12, %rsi
movzbl 0x1(%rsi), %ecx
addq %rcx, %rsi
decl %eax
cmpl $0x1, %eax
ja 0x15fa6
jmp 0x15fd2
addq $0x23, %rcx
leaq 0x161c6(%rip), %rdi     # 0x2c187
movl 0xc(%rsp), %edx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x15c76
incl %r13d
incl %ebp
jmp 0x15efd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VOLTAGE_OBJECT_INFO_V2_dumper
int ATOM_VOLTAGE_OBJECT_INFO_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VOLTAGE_OBJECT_INFO_V2 *d = (ATOM_VOLTAGE_OBJECT_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);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  ATOM_VOLTAGE_OBJECT_V2 asVoltageObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asVoltageObj[i])-start), FILL(38+(i>9)), i); ATOM_VOLTAGE_OBJECT_V2_dumper (start, (uint8_t*) &d->asVoltageObj[i], indent+1); }
  }
  return sizeof (ATOM_VOLTAGE_OBJECT_INFO_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x160bb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x26296(%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 0xcb6e(%rip), %rdi      # 0x22bae
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
addq $0x4, %r14
addl $0x4, %ebp
xorl %r13d, %r13d
movq 0x26241(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x26, %rcx
leaq 0x1613d(%rip), %rdi     # 0x2c1bb
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x15d78
incq %r13
addq $0x96, %r14
addl $0x96, %ebp
cmpq $0x3, %r13
jne 0x16068
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1c6, %eax            # imm = 0x1C6
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_LEAKID_VOLTAGE_dumper
int ATOM_LEAKID_VOLTAGE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_LEAKID_VOLTAGE *d = (ATOM_LEAKID_VOLTAGE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucLeakageId%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLeakageId)-start), FILL(16), d->ucLeakageId, d->ucLeakageId);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
    printf ("%s%04x:  USHORT usVoltage%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltage)-start), FILL(15), d->usVoltage, d->usVoltage);
  }
  return sizeof (ATOM_LEAKID_VOLTAGE);
}

// Assembly:
testq %rsi, %rsi
je 0x16174
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x261d4(%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 0x160e7(%rip), %rdi     # 0x2c1f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26194(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0xce15(%rip), %rdi      # 0x22f4c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x26168(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x160c2(%rip), %rdi     # 0x2c224
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_ASIC_PROFILING_INFO_dumper
int ATOM_ASIC_PROFILING_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ASIC_PROFILING_INFO *d = (ATOM_ASIC_PROFILING_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER asHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->asHeader)-start), FILL(32)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->asHeader, indent+1);
    printf ("%s%04x:  ATOM_ASIC_PROFILE_VOLTAGE asVoltage%s :\n", IND(indent), (int)(((uint8_t*)&d->asVoltage)-start), FILL(34)); ATOM_ASIC_PROFILE_VOLTAGE_dumper (start, (uint8_t*) &d->asVoltage, indent+1);
  }
  return sizeof (ATOM_ASIC_PROFILING_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x163e4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x25f4f(%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 $0x20, %rcx
leaq 0x15f9a(%rip), %rdi     # 0x2c327
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x25f06(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x15f95(%rip), %rdi     # 0x2c357
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1617a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x22, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_POWER_SOURCE_INFO_dumper
int ATOM_POWER_SOURCE_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_POWER_SOURCE_INFO *d = (ATOM_POWER_SOURCE_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER asHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->asHeader)-start), FILL(32)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->asHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  UCHAR asPwrbehave%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->asPwrbehave[i])-start), FILL(20+(i>9)), i, d->asPwrbehave[i], d->asPwrbehave[i]); }
    for (i = 0; i < COUNT_REMAINDER (ATOM_POWER_SOURCE_INFO, asPwrObj[0], ATOM_POWER_SOURCE_OBJECT); i++) {
      printf ("%s%04x:  ATOM_POWER_SOURCE_OBJECT asPwrObj%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asPwrObj[i])-start), FILL(36+(i>9)), i); ATOM_POWER_SOURCE_OBJECT_dumper (start, (uint8_t*) &d->asPwrObj[i], indent+1); }
  }
  return RETURN_REMAINDER (ATOM_POWER_SOURCE_INFO, asPwrObj[0], ATOM_POWER_SOURCE_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x16736
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x25cb8(%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
addq $0x20, %rcx
leaq 0x15d09(%rip), %rdi     # 0x2c327
movl %r14d, %r12d
subl %ebx, %r12d
movl %r12d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
callq 0x5fe4
addl $0x4, %r12d
leaq 0x15f1b(%rip), %r13     # 0x2c56c
xorl %ebp, %ebp
movq 0x25c56(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leal (%r12,%rbp), %edx
cmpq $0xa, %rbp
sbbq $-0x1, %rcx
addq $0x14, %rcx
movzbl 0x4(%r14,%rbp), %r9d
movl %r9d, (%rsp)
movq %r13, %rdi
movl %ebp, %r8d
xorl %eax, %eax
callq 0x40b0
incq %rbp
cmpq $0x10, %rbp
jne 0x16653
movzwl (%r14), %ecx
addq $-0x14, %rcx
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
cmpq $0xc, %rcx
jb 0x16713
leaq 0x14(%r14), %r12
movl %r14d, %ebp
subl 0x10(%rsp), %ebp
addl $0x14, %ebp
xorl %r13d, %r13d
movq 0x25bf2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
cmpq $0xa, %r13
sbbq $-0x1, %rcx
addq $0x24, %rcx
leaq 0x15ece(%rip), %rdi     # 0x2c5a3
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl 0xc(%rsp), %edx
callq 0x163ea
incq %r13
movzwl (%r14), %ecx
addq $-0x14, %rcx
movq %rcx, %rax
mulq %rbx
shrq $0x3, %rdx
addq $0xc, %r12
addl $0xc, %ebp
cmpq %r13, %rdx
ja 0x166b7
movq %rcx, %rax
mulq %rbx
shrq $0x3, %rdx
leal (%rdx,%rdx,2), %eax
leal 0x14(,%rax,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CLK_VOLT_CAPABILITY_dumper
int ATOM_CLK_VOLT_CAPABILITY_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CLK_VOLT_CAPABILITY *d = (ATOM_CLK_VOLT_CAPABILITY *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulVoltageIndex%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulVoltageIndex)-start), FILL(19), d->ulVoltageIndex, d->ulVoltageIndex);
    printf ("%s%04x:  ULONG ulMaximumSupportedCLK%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaximumSupportedCLK)-start), FILL(26), d->ulMaximumSupportedCLK, d->ulMaximumSupportedCLK);
  }
  return sizeof (ATOM_CLK_VOLT_CAPABILITY);
}

// Assembly:
testq %rsi, %rsi
je 0x167ba
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25b60(%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 $0x13, %rcx
movl (%rbx), %r8d
leaq 0x15e5a(%rip), %rdi     # 0x2c5d8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25b21(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x1a, %rcx
movl 0x4(%rbx), %r8d
leaq 0x15e5f(%rip), %rdi     # 0x2c607
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_AVAILABLE_SCLK_LIST_dumper
int ATOM_AVAILABLE_SCLK_LIST_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_AVAILABLE_SCLK_LIST *d = (ATOM_AVAILABLE_SCLK_LIST *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulSupportedSCLK%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulSupportedSCLK)-start), FILL(20), d->ulSupportedSCLK, d->ulSupportedSCLK);
    printf ("%s%04x:  USHORT usVoltageIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageIndex)-start), FILL(20), d->usVoltageIndex, d->usVoltageIndex);
    printf ("%s%04x:  USHORT usVoltageID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltageID)-start), FILL(17), d->usVoltageID, d->usVoltageID);
  }
  return sizeof (ATOM_AVAILABLE_SCLK_LIST);
}

// Assembly:
testq %rsi, %rsi
je 0x16872
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25ad5(%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 $0x14, %rcx
movl (%rbx), %r8d
leaq 0x15e34(%rip), %rdi     # 0x2c63d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25a96(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x15e38(%rip), %rdi     # 0x2c66d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x25a6a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x15e41(%rip), %rdi     # 0x2c6a1
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_I2C_DATA_RECORD_dumper
int ATOM_I2C_DATA_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_DATA_RECORD *d = (ATOM_I2C_DATA_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNunberOfBytes%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNunberOfBytes)-start), FILL(20), d->ucNunberOfBytes, d->ucNunberOfBytes);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucI2CData%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CData[i])-start), FILL(18+(i>9)), i, d->ucI2CData[i], d->ucI2CData[i]); }
  }
  return sizeof (ATOM_I2C_DATA_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x17198
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2518c(%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 $0x14, %rcx
movzbl (%rbx), %r8d
leaq 0x15ae2(%rip), %rdi     # 0x2cc35
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2514c(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x15ae9(%rip), %rdi     # 0x2cc6b
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq