LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(12), d->ulClock, d->ulClock);
    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:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
    printf ("%s%04x:  UCHAR ucFbDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFbDiv)-start), FILL(12), d->ucFbDiv, d->ucFbDiv);
    printf ("%s%04x:  UCHAR ucPostDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7686
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34d19(%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
movl (%rbx), %r8d
leaq 0x1cd9b(%rip), %rdi     # 0x24360
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34cda(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1cd97(%rip), %rdi     # 0x24388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34cae(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1b92f(%rip), %rdi     # 0x22f4c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34c82(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x1cd6e(%rip), %rdi     # 0x243b7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34c56(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1cd71(%rip), %rdi     # 0x243e5
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: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(12), d->ulClock, d->ulClock);
    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:  USHORT usFbDiv%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDiv)-start), FILL(13), d->usFbDiv, d->usFbDiv);
    printf ("%s%04x:  UCHAR ucPostDiv%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x776a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34c09(%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
movl (%rbx), %r8d
leaq 0x1cc8b(%rip), %rdi     # 0x24360
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34bca(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1cc87(%rip), %rdi     # 0x24388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34b9e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x5(%rbx), %r8d
leaq 0x1cce8(%rip), %rdi     # 0x24415
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34b72(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1cc8d(%rip), %rdi     # 0x243e5
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_COMPUTE_CLOCK_FREQ_dumper
int ATOM_COMPUTE_CLOCK_FREQ_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMPUTE_CLOCK_FREQ *d = (ATOM_COMPUTE_CLOCK_FREQ *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulClockFreq:24%s = 0x%08x (%d)\n", IND(indent), FILL(19), d->ulClockFreq, d->ulClockFreq);
    printf ("%s       ULONG ulComputeClockFlag:8%s = 0x%08x (%d)\n", IND(indent), FILL(25), d->ulComputeClockFlag, d->ulComputeClockFlag);
  }
  return sizeof (ATOM_COMPUTE_CLOCK_FREQ);
}

// Assembly:
testq %rsi, %rsi
je 0x77eb
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x34b2d(%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 $0x13, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x1cb14(%rip), %rdi     # 0x242c4
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34aec(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x19, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x1cc6b(%rip), %rdi     # 0x24442
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_S_MPLL_FB_DIVIDER_dumper
int ATOM_S_MPLL_FB_DIVIDER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_S_MPLL_FB_DIVIDER *d = (ATOM_S_MPLL_FB_DIVIDER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usFbDivFrac%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDivFrac)-start), FILL(17), d->usFbDivFrac, d->usFbDivFrac);
    printf ("%s%04x:  USHORT usFbDiv%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFbDiv)-start), FILL(13), d->usFbDiv, d->usFbDiv);
  }
  return sizeof (ATOM_S_MPLL_FB_DIVIDER);
}

// Assembly:
testq %rsi, %rsi
je 0x7874
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34aa8(%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 0x1cc40(%rip), %rdi     # 0x24477
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34a68(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1cbb3(%rip), %rdi     # 0x24415
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: COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4_dumper
int COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 *d = (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 *) data;
  int i;
  if (d) {
    printf ("%s       ULONG ulClock:24%s = 0x%08x (%d)\n", IND(indent), FILL(15), d->ulClock, d->ulClock);
    printf ("%s%04x:  ULONG ucPostDiv%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPostDiv)-start), FILL(14), d->ucPostDiv, d->ucPostDiv);
  }
  return sizeof (COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4);
}

// Assembly:
testq %rsi, %rsi
je 0x7945
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x349dc(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r15
leaq (%rax,%r15), %rsi
addq $0xf, %rax
movzwl (%rbx), %edx
movzbl 0x2(%rbx), %ecx
shll $0x10, %ecx
orl %edx, %ecx
leaq 0x1cbd4(%rip), %rdi     # 0x244da
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34996(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movl 0x3(%rbx), %r8d
leaq 0x1cbd2(%rip), %rdi     # 0x24505
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMICE_MEMORY_SETTINGS_PARAMETER_dumper
int DYNAMICE_MEMORY_SETTINGS_PARAMETER_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMICE_MEMORY_SETTINGS_PARAMETER *d = (DYNAMICE_MEMORY_SETTINGS_PARAMETER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMPUTE_CLOCK_FREQ ulClock%s :\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(30)); ATOM_COMPUTE_CLOCK_FREQ_dumper (start, (uint8_t*) &d->ulClock, indent+1);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  ULONG ulReserved%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulReserved[i])-start), FILL(19+(i>9)), i, d->ulReserved[i], d->ulReserved[i]); }
  }
  return sizeof (DYNAMICE_MEMORY_SETTINGS_PARAMETER);
}

// Assembly:
testq %rsi, %rsi
je 0x7a5a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34902(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
leaq 0x1cb88(%rip), %rdi     # 0x24561
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7770
leaq 0x4(%rbx), %rdx
movq 0x348b9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
subl %r14d, %edx
addq $0x13, %rcx
movl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1cb7e(%rip), %r12     # 0x2458f
movq %r12, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3488b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMICE_ENGINE_SETTINGS_PARAMETER_dumper
int DYNAMICE_ENGINE_SETTINGS_PARAMETER_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMICE_ENGINE_SETTINGS_PARAMETER *d = (DYNAMICE_ENGINE_SETTINGS_PARAMETER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMPUTE_CLOCK_FREQ ulClock%s :\n", IND(indent), (int)(((uint8_t*)&d->ulClock)-start), FILL(30)); ATOM_COMPUTE_CLOCK_FREQ_dumper (start, (uint8_t*) &d->ulClock, indent+1);
    printf ("%s%04x:  ULONG ulMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMemoryClock)-start), FILL(18), d->ulMemoryClock, d->ulMemoryClock);
    printf ("%s%04x:  ULONG ulReserved%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulReserved)-start), FILL(15), d->ulReserved, d->ulReserved);
  }
  return sizeof (DYNAMICE_ENGINE_SETTINGS_PARAMETER);
}

// Assembly:
testq %rsi, %rsi
je 0x7b1f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34831(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
leaq 0x1cab7(%rip), %rdi     # 0x24561
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7770
movq 0x347ec(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1cae1(%rip), %rdi     # 0x245bf
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x347c1(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movl 0x8(%rbx), %r8d
leaq 0x1cae5(%rip), %rdi     # 0x245ed
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_ENGINE_CLOCK_PS_ALLOCATION_dumper
int SET_ENGINE_CLOCK_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_ENGINE_CLOCK_PS_ALLOCATION *d = (SET_ENGINE_CLOCK_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulTargetEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulTargetEngineClock)-start), FILL(24), d->ulTargetEngineClock, d->ulTargetEngineClock);
    printf ("%s%04x:  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(45)); COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_ENGINE_CLOCK_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7c11
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3471b(%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 $0x18, %rcx
movl (%r14), %r8d
leaq 0x1ca54(%rip), %rdi     # 0x24618
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x346db(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1ca5f(%rip), %rdi     # 0x2464c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x757c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: SET_MEMORY_CLOCK_PS_ALLOCATION_dumper
int SET_MEMORY_CLOCK_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  SET_MEMORY_CLOCK_PS_ALLOCATION *d = (SET_MEMORY_CLOCK_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulTargetMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulTargetMemoryClock)-start), FILL(24), d->ulTargetMemoryClock, d->ulTargetMemoryClock);
    printf ("%s%04x:  COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(45)); COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (SET_MEMORY_CLOCK_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7d03
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x34629(%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 $0x18, %rcx
movl (%r14), %r8d
leaq 0x1c9d3(%rip), %rdi     # 0x24689
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x345e9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1c96d(%rip), %rdi     # 0x2464c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x757c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ASIC_INIT_PARAMETERS_dumper
int ASIC_INIT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ASIC_INIT_PARAMETERS *d = (ASIC_INIT_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulDefaultEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDefaultEngineClock)-start), FILL(25), d->ulDefaultEngineClock, d->ulDefaultEngineClock);
    printf ("%s%04x:  ULONG ulDefaultMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulDefaultMemoryClock)-start), FILL(25), d->ulDefaultMemoryClock, d->ulDefaultMemoryClock);
  }
  return sizeof (ASIC_INIT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7d8a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34590(%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
movl (%rbx), %r8d
leaq 0x1c96f(%rip), %rdi     # 0x246bd
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34551(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1c97a(%rip), %rdi     # 0x246f2
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: ASIC_INIT_PS_ALLOCATION_dumper
int ASIC_INIT_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  ASIC_INIT_PS_ALLOCATION *d = (ASIC_INIT_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ASIC_INIT_PARAMETERS sASICInitClocks%s :\n", IND(indent), (int)(((uint8_t*)&d->sASICInitClocks)-start), FILL(35)); ASIC_INIT_PARAMETERS_dumper (start, (uint8_t*) &d->sASICInitClocks, indent+1);
    printf ("%s%04x:  SET_ENGINE_CLOCK_PS_ALLOCATION sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(39)); SET_ENGINE_CLOCK_PS_ALLOCATION_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (ASIC_INIT_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x7e33
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x34500(%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 $0x23, %rcx
leaq 0x1c94b(%rip), %rdi     # 0x24727
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7d09
movq 0x344b7(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x1c949(%rip), %rdi     # 0x2475a
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7b75
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x14, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DYNAMIC_CLOCK_GATING_PARAMETERS_dumper
int DYNAMIC_CLOCK_GATING_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DYNAMIC_CLOCK_GATING_PARAMETERS *d = (DYNAMIC_CLOCK_GATING_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);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (DYNAMIC_CLOCK_GATING_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7ee6
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 0x3444c(%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 0x1c90e(%rip), %rax     # 0x24791
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1c91d(%rip), %r15     # 0x247c0
xorl %r12d, %r12d
movq 0x34403(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %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 0x7ea6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS_dumper
int ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS *d = (ENABLE_ASIC_STATIC_PWR_MGT_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);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ENABLE_ASIC_STATIC_PWR_MGT_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x7f99
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 0x34399(%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 0x1c85b(%rip), %rax     # 0x24791
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1c86a(%rip), %r15     # 0x247c0
xorl %r12d, %r12d
movq 0x34350(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leal (%r14,%r12), %edx
addq $0x12, %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 0x7f59
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DAC_LOAD_DETECTION_PARAMETERS_dumper
int DAC_LOAD_DETECTION_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_LOAD_DETECTION_PARAMETERS *d = (DAC_LOAD_DETECTION_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceID)-start), FILL(16), d->usDeviceID, d->usDeviceID);
    printf ("%s%04x:  UCHAR ucDacType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDacType)-start), FILL(14), d->ucDacType, d->ucDacType);
    printf ("%s%04x:  UCHAR ucMisc%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMisc)-start), FILL(11), d->ucMisc, d->ucMisc);
  }
  return sizeof (DAC_LOAD_DETECTION_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x8052
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x342f6(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzwl (%rbx), %r8d
leaq 0x1c80c(%rip), %rdi     # 0x247f5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x342b6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1c810(%rip), %rdi     # 0x24825
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3428a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1c815(%rip), %rdi     # 0x24855
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: DAC_LOAD_DETECTION_PS_ALLOCATION_dumper
int DAC_LOAD_DETECTION_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_LOAD_DETECTION_PS_ALLOCATION *d = (DAC_LOAD_DETECTION_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DAC_LOAD_DETECTION_PARAMETERS sDacload%s :\n", IND(indent), (int)(((uint8_t*)&d->sDacload)-start), FILL(37)); DAC_LOAD_DETECTION_PARAMETERS_dumper (start, (uint8_t*) &d->sDacload, indent+1);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  ULONG Reserved%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->Reserved[i])-start), FILL(17+(i>9)), i, d->Reserved[i], d->Reserved[i]); }
  }
  return sizeof (DAC_LOAD_DETECTION_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x812b
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34234(%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 0x1c7db(%rip), %rdi     # 0x24882
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7f9f
leaq 0x4(%rbx), %rdx
movq 0x341e8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
subl %r14d, %edx
addq $0x11, %rcx
movl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1c7d5(%rip), %r12     # 0x248b7
movq %r12, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x341ba(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DAC_ENCODER_CONTROL_PARAMETERS_dumper
int DAC_ENCODER_CONTROL_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DAC_ENCODER_CONTROL_PARAMETERS *d = (DAC_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:  UCHAR ucDacStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDacStandard)-start), FILL(18), d->ucDacStandard, d->ucDacStandard);
    printf ("%s%04x:  UCHAR ucAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAction)-start), FILL(13), d->ucAction, d->ucAction);
  }
  return sizeof (DAC_ENCODER_CONTROL_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x81e4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34164(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x1c76a(%rip), %rdi     # 0x248e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34124(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1c770(%rip), %rdi     # 0x24917
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x340f8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1c1b6(%rip), %rdi     # 0x24388
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_DIG_ENCODER_CONFIG_V2_dumper
int ATOM_DIG_ENCODER_CONFIG_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_ENCODER_CONFIG_V2 *d = (ATOM_DIG_ENCODER_CONFIG_V2 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDPLinkRate:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucDPLinkRate, d->ucDPLinkRate);
    printf ("%s       UCHAR ucReserved:1%s = 0x%02x       (%d)\n", IND(indent), FILL(17), d->ucReserved, d->ucReserved);
    printf ("%s       UCHAR ucLinkSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(16), d->ucLinkSel, d->ucLinkSel);
    printf ("%s       UCHAR ucTransmitterSel:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucTransmitterSel, d->ucTransmitterSel);
    printf ("%s       UCHAR ucReserved1:2%s = 0x%02x       (%d)\n", IND(indent), FILL(18), d->ucReserved1, d->ucReserved1);
  }
  return sizeof (ATOM_DIG_ENCODER_CONFIG_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x8452
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33f43(%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 $0x13, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1c67b(%rip), %rdi     # 0x24a14
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33f03(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1c685(%rip), %rdi     # 0x24a49
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33edb(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1c68f(%rip), %rdi     # 0x24a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33eb2(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x1c698(%rip), %rdi     # 0x24aae
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33e89(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x5, %ecx
andl $0x3, %ecx
leaq 0x1c6a9(%rip), %rdi     # 0x24ae7
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_ENCODER_CONFIG_V3_dumper
int ATOM_DIG_ENCODER_CONFIG_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_ENCODER_CONFIG_V3 *d = (ATOM_DIG_ENCODER_CONFIG_V3 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDPLinkRate:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucDPLinkRate, d->ucDPLinkRate);
    printf ("%s       UCHAR ucReserved:3%s = 0x%02x       (%d)\n", IND(indent), FILL(17), d->ucReserved, d->ucReserved);
    printf ("%s       UCHAR ucDigSel:3%s = 0x%02x       (%d)\n", IND(indent), FILL(15), d->ucDigSel, d->ucDigSel);
    printf ("%s       UCHAR ucReserved1:1%s = 0x%02x       (%d)\n", IND(indent), FILL(18), d->ucReserved1, d->ucReserved1);
  }
  return sizeof (ATOM_DIG_ENCODER_CONFIG_V3);
}

// Assembly:
testq %rsi, %rsi
je 0x86a0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33cc9(%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 $0x13, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1c401(%rip), %rdi     # 0x24a14
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33c89(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x7, %ecx
leaq 0x1c53e(%rip), %rdi     # 0x24b7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33c61(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0xf, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x1c548(%rip), %rdi     # 0x24baf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33c38(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x1c554(%rip), %rdi     # 0x24be0
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_ENCODER_CONFIG_V4_dumper
int ATOM_DIG_ENCODER_CONFIG_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_ENCODER_CONFIG_V4 *d = (ATOM_DIG_ENCODER_CONFIG_V4 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDPLinkRate:2%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucDPLinkRate, d->ucDPLinkRate);
    printf ("%s       UCHAR ucReserved:2%s = 0x%02x       (%d)\n", IND(indent), FILL(17), d->ucReserved, d->ucReserved);
    printf ("%s       UCHAR ucDigSel:3%s = 0x%02x       (%d)\n", IND(indent), FILL(15), d->ucDigSel, d->ucDigSel);
    printf ("%s       UCHAR ucReserved1:1%s = 0x%02x       (%d)\n", IND(indent), FILL(18), d->ucReserved1, d->ucReserved1);
  }
  return sizeof (ATOM_DIG_ENCODER_CONFIG_V4);
}

// Assembly:
testq %rsi, %rsi
je 0x88ef
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33a7b(%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 $0x13, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x1c419(%rip), %rdi     # 0x24c7a
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33a3b(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x1c422(%rip), %rdi     # 0x24caf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33a12(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0xf, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x1c2f9(%rip), %rdi     # 0x24baf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x339e9(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x1c305(%rip), %rdi     # 0x24be0
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DIG_ENCODER_CONTROL_PARAMETERS_V4_dumper
int DIG_ENCODER_CONTROL_PARAMETERS_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  DIG_ENCODER_CONTROL_PARAMETERS_V4 *d = (DIG_ENCODER_CONTROL_PARAMETERS_V4 *) 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  <unparsable> line 789:   union{\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (DIG_ENCODER_CONTROL_PARAMETERS_V4);
}

// Assembly:
testq %rsi, %rsi
je 0x8959
pushq %rbx
movq 0x339ae(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x12, %rcx
movzwl (%rsi), %r8d
leaq 0x1bfb5(%rip), %rdi     # 0x248e5
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x3396c(%rip), %rbx     # 0x3c2b0
leaq 0x1c397(%rip), %rdi     # 0x24ce2
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DP_VS_MODE_dumper
int ATOM_DP_VS_MODE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DP_VS_MODE *d = (ATOM_DP_VS_MODE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucLaneSel%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLaneSel)-start), FILL(14), d->ucLaneSel, d->ucLaneSel);
    printf ("%s%04x:  UCHAR ucLaneSet%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLaneSet)-start), FILL(14), d->ucLaneSet, d->ucLaneSet);
  }
  return sizeof (ATOM_DP_VS_MODE);
}

// Assembly:
testq %rsi, %rsi
je 0x89e2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3393a(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzbl (%rbx), %r8d
leaq 0x1c370(%rip), %rdi     # 0x24d15
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x338fa(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1c375(%rip), %rdi     # 0x24d45
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_TRANSMITTER_CONFIG_V2_dumper
int ATOM_DIG_TRANSMITTER_CONFIG_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_TRANSMITTER_CONFIG_V2 *d = (ATOM_DIG_TRANSMITTER_CONFIG_V2 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR fDualLinkConnector:1%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->fDualLinkConnector, d->fDualLinkConnector);
    printf ("%s       UCHAR fCoherentMode:1%s = 0x%02x       (%d)\n", IND(indent), FILL(20), d->fCoherentMode, d->fCoherentMode);
    printf ("%s       UCHAR ucLinkSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(16), d->ucLinkSel, d->ucLinkSel);
    printf ("%s       UCHAR ucEncoderSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucEncoderSel, d->ucEncoderSel);
    printf ("%s       UCHAR fDPConnector:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->fDPConnector, d->fDPConnector);
    printf ("%s       UCHAR ucReserved:1%s = 0x%02x       (%d)\n", IND(indent), FILL(17), d->ucReserved, d->ucReserved);
    printf ("%s       UCHAR ucTransmitterSel:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucTransmitterSel, d->ucTransmitterSel);
  }
  return sizeof (ATOM_DIG_TRANSMITTER_CONFIG_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x8b72
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33872(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x19, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1c33c(%rip), %rdi     # 0x24da6
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33832(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1c34c(%rip), %rdi     # 0x24de1
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3380a(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1bfbe(%rip), %rdi     # 0x24a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x337e1(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq 0x1c330(%rip), %rdi     # 0x24e17
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x337b8(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x1, %ecx
leaq 0x1c33c(%rip), %rdi     # 0x24e4c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3378f(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl $0x5, %ecx
andl $0x1, %ecx
leaq 0x1bf10(%rip), %rdi     # 0x24a49
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33766(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x1bf50(%rip), %rdi     # 0x24aae
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_TRANSMITTER_CONFIG_V3_dumper
int ATOM_DIG_TRANSMITTER_CONFIG_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_TRANSMITTER_CONFIG_V3 *d = (ATOM_DIG_TRANSMITTER_CONFIG_V3 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR fDualLinkConnector:1%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->fDualLinkConnector, d->fDualLinkConnector);
    printf ("%s       UCHAR fCoherentMode:1%s = 0x%02x       (%d)\n", IND(indent), FILL(20), d->fCoherentMode, d->fCoherentMode);
    printf ("%s       UCHAR ucLinkSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(16), d->ucLinkSel, d->ucLinkSel);
    printf ("%s       UCHAR ucEncoderSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucEncoderSel, d->ucEncoderSel);
    printf ("%s       UCHAR ucRefClkSource:2%s = 0x%02x       (%d)\n", IND(indent), FILL(21), d->ucRefClkSource, d->ucRefClkSource);
    printf ("%s       UCHAR ucTransmitterSel:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucTransmitterSel, d->ucTransmitterSel);
  }
  return sizeof (ATOM_DIG_TRANSMITTER_CONFIG_V3);
}

// Assembly:
testq %rsi, %rsi
je 0x8cd9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x336e2(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x19, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1c1ac(%rip), %rdi     # 0x24da6
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x336a2(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1c1bc(%rip), %rdi     # 0x24de1
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3367a(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1be2e(%rip), %rdi     # 0x24a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33651(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq 0x1c1a0(%rip), %rdi     # 0x24e17
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33628(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x15, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x1c212(%rip), %rdi     # 0x24eb2
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x335ff(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x1bde9(%rip), %rdi     # 0x24aae
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DP_VS_MODE_V4_dumper
int ATOM_DP_VS_MODE_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DP_VS_MODE_V4 *d = (ATOM_DP_VS_MODE_V4 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucLaneSel%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucLaneSel)-start), FILL(14), d->ucLaneSel, d->ucLaneSel);
    printf ("%s  <unparsable> line 889:   union\n%sskipping...\n", IND(indent), IND(indent));
  }
  return sizeof (ATOM_DP_VS_MODE_V4);
}

// Assembly:
testq %rsi, %rsi
je 0x8d82
pushq %rbx
movq 0x33585(%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 $0xe, %rcx
movzbl (%rsi), %r8d
leaq 0x1bfbc(%rip), %rdi     # 0x24d15
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x33543(%rip), %rbx     # 0x3c2b0
leaq 0x1c1a6(%rip), %rdi     # 0x24f1a
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DIG_TRANSMITTER_CONFIG_V4_dumper
int ATOM_DIG_TRANSMITTER_CONFIG_V4_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DIG_TRANSMITTER_CONFIG_V4 *d = (ATOM_DIG_TRANSMITTER_CONFIG_V4 *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR fDualLinkConnector:1%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->fDualLinkConnector, d->fDualLinkConnector);
    printf ("%s       UCHAR fCoherentMode:1%s = 0x%02x       (%d)\n", IND(indent), FILL(20), d->fCoherentMode, d->fCoherentMode);
    printf ("%s       UCHAR ucLinkSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(16), d->ucLinkSel, d->ucLinkSel);
    printf ("%s       UCHAR ucEncoderSel:1%s = 0x%02x       (%d)\n", IND(indent), FILL(19), d->ucEncoderSel, d->ucEncoderSel);
    printf ("%s       UCHAR ucRefClkSource:2%s = 0x%02x       (%d)\n", IND(indent), FILL(21), d->ucRefClkSource, d->ucRefClkSource);
    printf ("%s       UCHAR ucTransmitterSel:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucTransmitterSel, d->ucTransmitterSel);
  }
  return sizeof (ATOM_DIG_TRANSMITTER_CONFIG_V4);
}

// Assembly:
testq %rsi, %rsi
je 0x8eaa
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x33511(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x19, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1bfdb(%rip), %rdi     # 0x24da6
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x334d1(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1bfeb(%rip), %rdi     # 0x24de1
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x334a9(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1bc5d(%rip), %rdi     # 0x24a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33480(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq 0x1bfcf(%rip), %rdi     # 0x24e17
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x33457(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x15, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x1c041(%rip), %rdi     # 0x24eb2
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3342e(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x1bc18(%rip), %rdi     # 0x24aae
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_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_V3_dumper
int EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_V3_dumper (uint8_t *start, uint8_t *data, int indent) {
  EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_V3 *d = (EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_V3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  EXTERNAL_ENCODER_CONTROL_PARAMETERS_V3 sExtEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sExtEncoder)-start), FILL(49)); EXTERNAL_ENCODER_CONTROL_PARAMETERS_V3_dumper (start, (uint8_t*) &d->sExtEncoder, indent+1);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  ULONG ulReserved%s [%d] = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulReserved[i])-start), FILL(19+(i>9)), i, d->ulReserved[i], d->ulReserved[i]); }
  }
  return sizeof (EXTERNAL_ENCODER_CONTROL_PS_ALLOCATION_V3);
}

// Assembly:
testq %rsi, %rsi
je 0x9021
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3335e(%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 $0x31, %rcx
leaq 0x1c034(%rip), %rdi     # 0x24fb1
xorl %eax, %eax
callq 0x40b0
cmpl $0x18, %ebp
movl $0x18, %eax
cmovll %ebp, %eax
addl %eax, %eax
movl $0x30, %ecx
subl %eax, %ecx
movslq %ecx, %rdx
addq 0x3330e(%rip), %rdx     # 0x3c2b0
leaq 0x1bfd5(%rip), %rdi     # 0x24f7e
movq %rdx, %rsi
xorl %eax, %eax
callq 0x40b0
leaq 0x8(%rbx), %rdx
movq 0x332f2(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
subl %r14d, %edx
addq $0x13, %rcx
movl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1b5b7(%rip), %r12     # 0x2458f
movq %r12, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x332c4(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0xc(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movl 0xc(%rbx), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x10, %eax
retq