LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISP_OUT_INFO_dumper
int ATOM_DISP_OUT_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISP_OUT_INFO *d = (ATOM_DISP_OUT_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT ptrTransmitterInfo%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ptrTransmitterInfo)-start), FILL(24), d->ptrTransmitterInfo, d->ptrTransmitterInfo);
    printf ("%s%04x:  USHORT ptrEncoderInfo%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ptrEncoderInfo)-start), FILL(20), d->ptrEncoderInfo, d->ptrEncoderInfo);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ASIC_TRANSMITTER_INFO asTransmitterInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asTransmitterInfo[i])-start), FILL(42+(i>9)), i); ASIC_TRANSMITTER_INFO_dumper (start, (uint8_t*) &d->asTransmitterInfo[i], indent+1); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ASIC_ENCODER_INFO asEncoderInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asEncoderInfo[i])-start), FILL(34+(i>9)), i); ASIC_ENCODER_INFO_dumper (start, (uint8_t*) &d->asEncoderInfo[i], indent+1); }
  }
  return sizeof (ATOM_DISP_OUT_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d4c9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1eefa(%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 0x57ef(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x1eeb1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x18, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x12a2b(%rip), %rdi     # 0x2fe45
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ee85(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x6(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x6(%r14), %r8d
leaq 0x12a37(%rip), %rdi     # 0x2fe7d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ee59(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x8(%r14), %r13
movl %r13d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x12a41(%rip), %rdi     # 0x2feb1
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1d147
movq 0x1ee22(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x12, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x12a46(%rip), %rdi     # 0x2feec
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d2dc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x16, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_DEVICE_PRIORITY_INFO_dumper
int ATOM_DISPLAY_DEVICE_PRIORITY_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_DEVICE_PRIORITY_INFO *d = (ATOM_DISPLAY_DEVICE_PRIORITY_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 16; i++) {
      printf ("%s%04x:  USHORT asDevicePriority%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->asDevicePriority[i])-start), FILL(26+(i>9)), i, d->asDevicePriority[i], d->asDevicePriority[i]); }
  }
  return sizeof (ATOM_DISPLAY_DEVICE_PRIORITY_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1d6f4
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x1ec56(%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 0x5551(%rip), %rdi      # 0x22bd1
movl %ebx, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r14d
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x5f74
addl $0x4, %ebp
leaq 0x128b0(%rip), %r14     # 0x2ff59
xorl %r15d, %r15d
movq 0x1ebfd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
cmpq $0xa, %r15
sbbq $-0x1, %rcx
addq $0x1a, %rcx
movzwl 0x4(%rbx,%r15,2), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x2, %ebp
cmpq $0x10, %r15
jne 0x1d6ac
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x24, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_dumper
int PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS *d = (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT lpAuxRequest%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpAuxRequest)-start), FILL(18), d->lpAuxRequest, d->lpAuxRequest);
    printf ("%s%04x:  USHORT lpDataOut%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpDataOut)-start), FILL(15), d->lpDataOut, d->lpDataOut);
    printf ("%s%04x:  UCHAR ucChannelID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucChannelID)-start), FILL(16), d->ucChannelID, d->ucChannelID);
    printf ("%s  <unparsable> line 3798:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1d7c7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1eb9b(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x1284f(%rip), %rdi     # 0x2ff94
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1eb5a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x12855(%rip), %rdi     # 0x2ffc6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1eb2e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12858(%rip), %rdi     # 0x2fff5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1eb02(%rip), %rbx     # 0x3c2b0
leaq 0x12872(%rip), %rdi     # 0x30027
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper
int PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 *d = (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT lpAuxRequest%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpAuxRequest)-start), FILL(18), d->lpAuxRequest, d->lpAuxRequest);
    printf ("%s%04x:  USHORT lpDataOut%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->lpDataOut)-start), FILL(15), d->lpDataOut, d->lpDataOut);
    printf ("%s%04x:  UCHAR ucChannelID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucChannelID)-start), FILL(16), d->ucChannelID, d->ucChannelID);
    printf ("%s  <unparsable> line 3813:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1d89a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1eac8(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x1277c(%rip), %rdi     # 0x2ff94
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ea87(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x12782(%rip), %rdi     # 0x2ffc6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ea5b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%rbx), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x10, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12785(%rip), %rdi     # 0x2fff5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1ea2f(%rip), %rbx     # 0x3c2b0
leaq 0x127d1(%rip), %rdi     # 0x30059
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DP_ENCODER_SERVICE_PARAMETERS_dumper
int DP_ENCODER_SERVICE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DP_ENCODER_SERVICE_PARAMETERS *d = (DP_ENCODER_SERVICE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT ucLinkClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLinkClock)-start), FILL(17), d->ucLinkClock, d->ucLinkClock);
    printf ("%s  <unparsable> line 3829:  union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (DP_ENCODER_SERVICE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1d904
pushq %rbx
movq 0x1ea03(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x11, %rcx
movzwl (%rsi), %r8d
leaq 0x127b0(%rip), %rdi     # 0x3008b
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e9c1(%rip), %rbx     # 0x3c2b0
leaq 0x127c6(%rip), %rdi     # 0x300bc
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper
int DP_ENCODER_SERVICE_PS_ALLOCATION_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *d = (DP_ENCODER_SERVICE_PS_ALLOCATION_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DP_ENCODER_SERVICE_PARAMETERS_V2 asDPServiceParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asDPServiceParam)-start), FILL(48)); DP_ENCODER_SERVICE_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asDPServiceParam, indent+1);
    printf ("%s%04x:  PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2 asAuxParam%s :\n", IND(indent), (int)(((uint8_t*)&d->asAuxParam)-start), FILL(55)); PROCESS_AUX_CHANNEL_TRANSACTION_PARAMETERS_V2_dumper (start, (uint8_t*) &d->asAuxParam, indent+1);
  }
  return sizeof (DP_ENCODER_SERVICE_PS_ALLOCATION_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1db11
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e822(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x30, %rcx
leaq 0x126c1(%rip), %rdi     # 0x3017b
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d90a
movq 0x1e7d9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x126cc(%rip), %rdi     # 0x301bb
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1d7cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper
int PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *d = (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucI2CSpeed%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CSpeed)-start), FILL(15), d->ucI2CSpeed, d->ucI2CSpeed);
    printf ("%s  <unparsable> line 3859:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (PROCESS_I2C_CHANNEL_TRANSACTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1db7b
pushq %rbx
movq 0x1e78c(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0xf, %rcx
movzbl (%rsi), %r8d
leaq 0x126b0(%rip), %rdi     # 0x30202
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x1e74a(%rip), %rbx     # 0x3c2b0
leaq 0x126c6(%rip), %rdi     # 0x30233
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper
int SET_HWBLOCK_INSTANCE_PARAMETER_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_HWBLOCK_INSTANCE_PARAMETER_V2 *d = (SET_HWBLOCK_INSTANCE_PARAMETER_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucHWBlkInst%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHWBlkInst)-start), FILL(16), d->ucHWBlkInst, d->ucHWBlkInst);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucReserved%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved[i])-start), FILL(19+(i>9)), i, d->ucReserved[i], d->ucReserved[i]); }
  }
  return sizeof (SET_HWBLOCK_INSTANCE_PARAMETER_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x1dc2e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x1e704(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x1269b(%rip), %rax     # 0x30266
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x6e16(%rip), %r15      # 0x24a01
xorl %r12d, %r12d
movq 0x1e6bb(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x13, %rcx
movzbl 0x1(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x3, %r12
jne 0x1dbee
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DAC_INFO_dumper
int ATOM_DAC_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DAC_INFO *d = (ATOM_DAC_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    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_DAC_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1dcf8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1e65d(%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 $0x1f, %rcx
leaq 0x4f53(%rip), %rdi      # 0x22bd1
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5f74
movq 0x1e615(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x125e2(%rip), %rdi     # 0x30298
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e5e9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xa996(%rip), %rdi      # 0x28677
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_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_dumper
int ATOM_CONNECTOR_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO *d = (ATOM_CONNECTOR_INFO *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR bfAssociatedDAC:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfAssociatedDAC, d->bfAssociatedDAC);
    printf ("%s       UCHAR bfConnectorType:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfConnectorType, d->bfConnectorType);
  }
  return sizeof (ATOM_CONNECTOR_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e187
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x1e191(%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 $0x16, %rax
movzbl (%rbx), %ecx
andl $0xf, %ecx
leaq 0x126a5(%rip), %rdi     # 0x307f0
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x1e151(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x16, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
leaq 0x126b5(%rip), %rdi     # 0x30828
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_CONNECTOR_INFO_ACCESS_dumper
int ATOM_CONNECTOR_INFO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO_ACCESS *d = (ATOM_CONNECTOR_INFO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_CONNECTOR_INFO sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(36)); ATOM_CONNECTOR_INFO_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) UCHAR ucAccess%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAccess)-start), FILL(21), d->ucAccess, d->ucAccess);
  }
  return sizeof (ATOM_CONNECTOR_INFO_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0x1e21e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x1e107(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x24, %rcx
leaq 0x1268b(%rip), %rdi     # 0x30860
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1e10c
movq 0x1e0be(%rip), %rcx     # 0x3c2b0
addq %rcx, %r14
addq $0x15, %rcx
movzbl (%rbx), %r8d
leaq 0xa68f(%rip), %rdi      # 0x28893
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_I2C_dumper
int ATOM_CONNECTOR_INFO_I2C_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO_I2C *d = (ATOM_CONNECTOR_INFO_I2C *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_CONNECTOR_INFO_ACCESS sucConnectorInfo%s :\n", IND(indent), (int)(((uint8_t*)&d->sucConnectorInfo)-start), FILL(42)); ATOM_CONNECTOR_INFO_ACCESS_dumper (start, (uint8_t*) &d->sucConnectorInfo, indent+1);
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG_ACCESS sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(33)); ATOM_I2C_ID_CONFIG_ACCESS_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
  }
  return sizeof (ATOM_CONNECTOR_INFO_I2C);
}

// Assembly:
testq %rsi, %rsi
je 0x1e2c6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e06c(%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 $0x2a, %rcx
leaq 0x12624(%rip), %rdi     # 0x30894
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e18d
movq 0x1e023(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0xa7fe(%rip), %rdi      # 0x28aa2
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xfc33
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SUPPORTED_DEVICES_INFO_dumper
int ATOM_SUPPORTED_DEVICES_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SUPPORTED_DEVICES_INFO *d = (ATOM_SUPPORTED_DEVICES_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usDeviceSupport%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceSupport)-start), FILL(21), d->usDeviceSupport, d->usDeviceSupport);
    for (i = 0; i < 10; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INFO_I2C asConnInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asConnInfo[i])-start), FILL(37+(i>9)), i); ATOM_CONNECTOR_INFO_I2C_dumper (start, (uint8_t*) &d->asConnInfo[i], indent+1); }
  }
  return sizeof (ATOM_SUPPORTED_DEVICES_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e3b6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1dfc1(%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 0x48bc(%rip), %rdi      # 0x22bd1
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x1df76(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzwl 0x4(%r14), %r8d
leaq 0xc611(%rip), %rdi      # 0x2a966
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
movq 0x1df40(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x25, %rcx
leaq 0x1254f(%rip), %rdi     # 0x308ce
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e224
incq %r13
addq $0x2, %r14
addl $0x2, %ebp
cmpq $0xa, %r13
jne 0x1e369
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1a, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MISC_CONTROL_INFO_dumper
int ATOM_MISC_CONTROL_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MISC_CONTROL_INFO *d = (ATOM_MISC_CONTROL_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFrequency)-start), FILL(17), d->usFrequency, d->usFrequency);
    printf ("%s%04x:  UCHAR ucPLL_ChargePump%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_ChargePump)-start), FILL(21), d->ucPLL_ChargePump, d->ucPLL_ChargePump);
    printf ("%s%04x:  UCHAR ucPLL_DutyCycle%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_DutyCycle)-start), FILL(20), d->ucPLL_DutyCycle, d->ucPLL_DutyCycle);
    printf ("%s%04x:  UCHAR ucPLL_VCO_Gain%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VCO_Gain)-start), FILL(19), d->ucPLL_VCO_Gain, d->ucPLL_VCO_Gain);
    printf ("%s%04x:  UCHAR ucPLL_VoltageSwing%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VoltageSwing)-start), FILL(23), d->ucPLL_VoltageSwing, d->ucPLL_VoltageSwing);
  }
  return sizeof (ATOM_MISC_CONTROL_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e818
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1db88(%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 0x12220(%rip), %rdi     # 0x30977
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1db48(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x12225(%rip), %rdi     # 0x309a8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1db1c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x12230(%rip), %rdi     # 0x309df
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1daf0(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1223a(%rip), %rdi     # 0x30a15
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1dac4(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x12244(%rip), %rdi     # 0x30a4a
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
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_TMDS_INFO_dumper
int ATOM_TMDS_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TMDS_INFO *d = (ATOM_TMDS_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  ATOM_MISC_CONTROL_INFO asMiscInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asMiscInfo[i])-start), FILL(36+(i>9)), i); ATOM_MISC_CONTROL_INFO_dumper (start, (uint8_t*) &d->asMiscInfo[i], indent+1); }
  }
  return sizeof (ATOM_TMDS_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e908
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1da6f(%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 0x436a(%rip), %rdi      # 0x22bd1
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5f74
movq 0x1da24(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x119f1(%rip), %rdi     # 0x30298
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
movq 0x1d9ee(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x24, %rcx
leaq 0x121b2(%rip), %rdi     # 0x30a83
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e70d
incq %r13
addq $0x6, %r14
addl $0x6, %ebp
cmpq $0x4, %r13
jne 0x1e8bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1e, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper
int ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ANALOG_ATTRIBUTE *d = (ATOM_ENCODER_ANALOG_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucTVStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTVStandard)-start), FILL(17), d->ucTVStandard, d->ucTVStandard);
    for (i = 0; i < 1; 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_ANALOG_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1e9a1
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d983(%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 0xe70e(%rip), %rdi      # 0x2d06a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d943(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x5e58(%rip), %rdi      # 0x247e3
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
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_ENCODER_DIGITAL_ATTRIBUTE_dumper
int ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_DIGITAL_ATTRIBUTE *d = (ATOM_ENCODER_DIGITAL_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucAttribute%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAttribute)-start), FILL(16), d->ucAttribute, d->ucAttribute);
    for (i = 0; i < 1; 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_DIGITAL_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1ea3a
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d8ea(%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 0x120c3(%rip), %rdi     # 0x30ab8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d8aa(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x5dbf(%rip), %rdi      # 0x247e3
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
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_ENCODER_ATTRIBUTE_dumper
int ATOM_ENCODER_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ATTRIBUTE *d = (ATOM_ENCODER_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_ENCODER_ANALOG_ATTRIBUTE sAlgAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sAlgAttrib)-start), FILL(47)); ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (start, (uint8_t*) &d->sAlgAttrib, indent+1);
    printf ("%s%04x:  (union) ATOM_ENCODER_DIGITAL_ATTRIBUTE sDigAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sDigAttrib)-start), FILL(48)); ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (start, (uint8_t*) &d->sDigAttrib, indent+1);
  }
  return sizeof (ATOM_ENCODER_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1eada
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d850(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %ebp
subl %r15d, %ebp
addq $0x2f, %rcx
leaq 0x1205e(%rip), %rdi     # 0x30aea
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e90e
movq 0x1d805(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x30, %rcx
leaq 0x12070(%rip), %rdi     # 0x30b29
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e9a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PARAMETERS_dumper
int DVO_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PARAMETERS *d = (DVO_ENCODER_CONTROL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usPixelClock%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPixelClock)-start), FILL(18), d->usPixelClock, d->usPixelClock);
    printf ("%s%04x:  USHORT usEncoderID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usEncoderID)-start), FILL(17), d->usEncoderID, d->usEncoderID);
    printf ("%s%04x:  UCHAR ucDeviceType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDeviceType)-start), FILL(17), d->ucDeviceType, d->ucDeviceType);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
    printf ("%s%04x:  ATOM_ENCODER_ATTRIBUTE usDevAttr%s :\n", IND(indent), (int)(((uint8_t*)&d->usDevAttr)-start), FILL(31)); ATOM_ENCODER_ATTRIBUTE_dumper (start, (uint8_t*) &d->usDevAttr, indent+1);
  }
  return sizeof (DVO_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1ec01
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d7b0(%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
movzwl (%r14), %r8d
leaq 0x5dd8(%rip), %rdi      # 0x24908
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d76f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x1200d(%rip), %rdi     # 0x30b69
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d743(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x12012(%rip), %rdi     # 0x30b9a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d717(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x5(%r14), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x5(%r14), %r8d
leaq 0x57f7(%rip), %rdi      # 0x243ab
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d6eb(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x6, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x11ff0(%rip), %rdi     # 0x30bcd
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1ea40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper
int DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PS_ALLOCATION *d = (DVO_ENCODER_CONTROL_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DVO_ENCODER_CONTROL_PARAMETERS sDVOEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sDVOEncoder)-start), FILL(41)); DVO_ENCODER_CONTROL_PARAMETERS_dumper (start, (uint8_t*) &d->sDVOEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (DVO_ENCODER_CONTROL_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x1ecaa
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d689(%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 $0x29, %rcx
leaq 0x11fa9(%rip), %rdi     # 0x30bfc
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1eae0
movq 0x1d640(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x70cd(%rip), %rdi      # 0x25d55
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa3f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper
int DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DFP_DPMS_STATUS_CHANGE_PARAMETERS *d = (DFP_DPMS_STATUS_CHANGE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucDevice%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDevice)-start), FILL(13), d->ucDevice, d->ucDevice);
    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 (DFP_DPMS_STATUS_CHANGE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1ef37
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
movq 0x1d425(%rip), %rcx     # 0x3c2b0
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x590a(%rip), %rdi      # 0x247b4
movl %ebx, %r14d
subl %r15d, %r14d
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d3ec(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x1(%rbx), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x6403(%rip), %rdi      # 0x252e2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addl $0x2, %r14d
leaq 0x58ef(%rip), %r15      # 0x247e3
xorl %r12d, %r12d
movq 0x1d3b2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %rcx
movzbl 0x2(%rbx,%r12), %r9d
movl %r9d, (%rsp)
movq %r15, %rdi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r12
cmpq $0x1, %r12
je 0x1eef7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_STATE_dumper
int ATOM_PPLIB_STATE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_STATE *d = (ATOM_PPLIB_STATE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNonClockStateIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNonClockStateIndex)-start), FILL(25), d->ucNonClockStateIndex, d->ucNonClockStateIndex);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucClockStateIndices%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucClockStateIndices[i])-start), FILL(28+(i>9)), i, d->ucClockStateIndices[i], d->ucClockStateIndices[i]); }
  }
  return sizeof (ATOM_PPLIB_STATE);
}

// Assembly:
testq %rsi, %rsi
je 0x1fc80
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c6a4(%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 $0x19, %rcx
movzbl (%rbx), %r8d
leaq 0x116ac(%rip), %rdi     # 0x312e7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c664(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x1c, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x116b8(%rip), %rdi     # 0x31322
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
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_PPLIB_EXTENDEDHEADER_dumper
int ATOM_PPLIB_EXTENDEDHEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_EXTENDEDHEADER *d = (ATOM_PPLIB_EXTENDEDHEADER *) data;
  int i;
  if (d) {
    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:  ULONG ulMaxEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxEngineClock)-start), FILL(21), d->ulMaxEngineClock, d->ulMaxEngineClock);
    printf ("%s%04x:  ULONG ulMaxMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxMemoryClock)-start), FILL(21), d->ulMaxMemoryClock, d->ulMaxMemoryClock);
  }
  return sizeof (ATOM_PPLIB_EXTENDEDHEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x1fecc
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c47a(%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 $0xc, %rcx
movzwl (%rbx), %r8d
leaq 0xace6(%rip), %rdi      # 0x2ab4b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c43a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x2(%rbx), %r8d
leaq 0x11646(%rip), %rdi     # 0x314d6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c40f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x6(%rbx), %r8d
leaq 0x1164d(%rip), %rdi     # 0x31507
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
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_PPLIB_POWERPLAYTABLE2_dumper
int ATOM_PPLIB_POWERPLAYTABLE2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE2 *d = (ATOM_PPLIB_POWERPLAYTABLE2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE basicTable%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable)-start), FILL(35)); ATOM_PPLIB_POWERPLAYTABLE_dumper (start, (uint8_t*) &d->basicTable, indent+1);
    printf ("%s%04x:  UCHAR ucNumCustomThermalPolicy%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumCustomThermalPolicy)-start), FILL(29), d->ucNumCustomThermalPolicy, d->ucNumCustomThermalPolicy);
    printf ("%s%04x:  USHORT usCustomThermalPolicyArrayOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usCustomThermalPolicyArrayOffset)-start), FILL(38), d->usCustomThermalPolicyArrayOffset, d->usCustomThermalPolicyArrayOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE2);
}

// Assembly:
testq %rsi, %rsi
je 0x202a2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c0b3(%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 $0x23, %rcx
leaq 0x1164a(%rip), %rdi     # 0x31872
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1fed2
movq 0x1c06b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x25(%rbx), %rdx
subl %r14d, %edx
addq $0x1d, %rcx
movzbl 0x25(%rbx), %r8d
leaq 0x11645(%rip), %rdi     # 0x318a5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c03f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x26(%rbx), %rdx
subl %r14d, %edx
addq $0x26, %rcx
movzwl 0x26(%rbx), %r8d
leaq 0x11659(%rip), %rdi     # 0x318e4
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x28, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_POWERPLAYTABLE3_dumper
int ATOM_PPLIB_POWERPLAYTABLE3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE3 *d = (ATOM_PPLIB_POWERPLAYTABLE3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE2 basicTable2%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable2)-start), FILL(37)); ATOM_PPLIB_POWERPLAYTABLE2_dumper (start, (uint8_t*) &d->basicTable2, indent+1);
    printf ("%s%04x:  USHORT usFormatID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFormatID)-start), FILL(16), d->usFormatID, d->usFormatID);
    printf ("%s%04x:  USHORT usFanTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFanTableOffset)-start), FILL(22), d->usFanTableOffset, d->usFanTableOffset);
    printf ("%s%04x:  USHORT usExtendendedHeaderOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usExtendendedHeaderOffset)-start), FILL(31), d->usExtendendedHeaderOffset, d->usExtendendedHeaderOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE3);
}

// Assembly:
testq %rsi, %rsi
je 0x20398
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1bfe9(%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 $0x25, %rcx
leaq 0x11638(%rip), %rdi     # 0x3192a
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x201de
movq 0x1bfa1(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x28(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x28(%rbx), %r8d
leaq 0x11635(%rip), %rdi     # 0x3195f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bf75(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2a(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2a(%rbx), %r8d
leaq 0x11639(%rip), %rdi     # 0x3198f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bf49(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2c(%rbx), %rdx
subl %r14d, %edx
addq $0x1f, %rcx
movzwl 0x2c(%rbx), %r8d
leaq 0x11644(%rip), %rdi     # 0x319c5
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x2e, %eax
retq