LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TABLE_ATTRIBUTE_dumper
int ATOM_TABLE_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TABLE_ATTRIBUTE *d = (ATOM_TABLE_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s       USHORT WS_SizeInBytes:8%s = 0x%04x     (%d)\n", IND(indent), FILL(22), d->WS_SizeInBytes, d->WS_SizeInBytes);
    printf ("%s       USHORT PS_SizeInBytes:7%s = 0x%04x     (%d)\n", IND(indent), FILL(22), d->PS_SizeInBytes, d->PS_SizeInBytes);
    printf ("%s       USHORT UpdatedByUtility:1%s = 0x%04x     (%d)\n", IND(indent), FILL(24), d->UpdatedByUtility, d->UpdatedByUtility);
  }
  return sizeof (ATOM_TABLE_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x70c8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x36264(%rip), %rdx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rcx
subl %eax, %ecx
movslq %ecx, %r14
leaq (%rdx,%r14), %rsi
addq $0x16, %rdx
movzbl (%rbx), %ecx
leaq 0x1c0e6(%rip), %rdi     # 0x2314e
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x36237(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x16, %rdx
movzbl 0x1(%rbx), %ecx
andl $0x7f, %ecx
leaq 0x1c0f5(%rip), %rdi     # 0x23184
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x36210(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x18, %rdx
movzwl (%rbx), %ecx
shrl $0xf, %ecx
leaq 0x1c106(%rip), %rdi     # 0x231ba
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TABLE_ATTRIBUTE_ACCESS_dumper
int ATOM_TABLE_ATTRIBUTE_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TABLE_ATTRIBUTE_ACCESS *d = (ATOM_TABLE_ATTRIBUTE_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_TABLE_ATTRIBUTE sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(37)); ATOM_TABLE_ATTRIBUTE_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) USHORT susAccess%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->susAccess)-start), FILL(23), d->susAccess, d->susAccess);
  }
  return sizeof (ATOM_TABLE_ATTRIBUTE_ACCESS);
}

// Assembly:
testq %rsi, %rsi
je 0x7159
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq 0x361c8(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r14
leaq (%rcx,%r14), %rsi
movl %ebx, %r15d
subl %edi, %r15d
addq $0x25, %rcx
leaq 0x1c0e2(%rip), %rdi     # 0x231f2
movl %r15d, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x702c
movq 0x36183(%rip), %rcx     # 0x3d2b0
addq %rcx, %r14
addq $0x17, %rcx
movzwl (%rbx), %r8d
leaq 0x1c0e8(%rip), %rdi     # 0x23227
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
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_COMMON_ROM_COMMAND_TABLE_HEADER_dumper
int ATOM_COMMON_ROM_COMMAND_TABLE_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_ROM_COMMAND_TABLE_HEADER *d = (ATOM_COMMON_ROM_COMMAND_TABLE_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER CommonHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->CommonHeader)-start), FILL(36)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->CommonHeader, indent+1);
    printf ("%s%04x:  ATOM_TABLE_ATTRIBUTE TableAttribute%s :\n", IND(indent), (int)(((uint8_t*)&d->TableAttribute)-start), FILL(34)); ATOM_TABLE_ATTRIBUTE_dumper (start, (uint8_t*) &d->TableAttribute, indent+1);
  }
  return sizeof (ATOM_COMMON_ROM_COMMAND_TABLE_HEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x71f9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x36133(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x24, %rcx
leaq 0x1c0b9(%rip), %rdi     # 0x2325e
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5d40
movq 0x360ee(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x22, %rcx
leaq 0x1c0b8(%rip), %rdi     # 0x23292
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r14, %rsi
movl %ebx, %edx
callq 0x702c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ADJUST_MEMORY_CLOCK_FREQ_dumper
int ATOM_ADJUST_MEMORY_CLOCK_FREQ_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ADJUST_MEMORY_CLOCK_FREQ *d = (ATOM_ADJUST_MEMORY_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 ulMemoryModuleNumber:7%s = 0x%08x (%d)\n", IND(indent), FILL(27), d->ulMemoryModuleNumber, d->ulMemoryModuleNumber);
    printf ("%s       ULONG ulPointerReturnFlag:1%s = 0x%08x (%d)\n", IND(indent), FILL(26), d->ulPointerReturnFlag, d->ulPointerReturnFlag);
  }
  return sizeof (ATOM_ADJUST_MEMORY_CLOCK_FREQ);
}

// Assembly:
testq %rsi, %rsi
je 0x729f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x3609c(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x1c087(%rip), %rdi     # 0x232c4
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3605f(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x1b, %rdx
movzbl 0x3(%rbx), %ecx
andl $0x7f, %ecx
leaq 0x1c08c(%rip), %rdi     # 0x232f3
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x36038(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x1a, %rdx
movl (%rbx), %ecx
shrl $0x1f, %ecx
leaq 0x1c09f(%rip), %rdi     # 0x2332a
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73a9
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35ff2(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xc, %rcx
movl (%rbx), %r8d
leaq 0x1c078(%rip), %rdi     # 0x23360
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35fb7(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1c074(%rip), %rdi     # 0x23388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35f8b(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x1ac0c(%rip), %rdi     # 0x21f4c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35f5f(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzbl 0x6(%rbx), %r8d
leaq 0x1c04b(%rip), %rdi     # 0x233b7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35f33(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1c04e(%rip), %rdi     # 0x233e5
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7487
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35ee8(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xc, %rcx
movl (%rbx), %r8d
leaq 0x1bf6e(%rip), %rdi     # 0x23360
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35ead(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1bf6a(%rip), %rdi     # 0x23388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35e81(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x5(%rbx), %r8d
leaq 0x1bfcb(%rip), %rdi     # 0x23415
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35e55(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x7(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x7(%rbx), %r8d
leaq 0x1bf70(%rip), %rdi     # 0x233e5
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7502
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x35e12(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl (%rbx), %ecx
leaq 0x1bdfd(%rip), %rdi     # 0x232c4
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x35dd5(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x19, %rdx
movl (%rbx), %ecx
shrl $0x18, %ecx
leaq 0x1bf54(%rip), %rdi     # 0x23442
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7585
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35d93(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x1bf2f(%rip), %rdi     # 0x23477
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35d57(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1bea2(%rip), %rdi     # 0x23415
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7646
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35cd7(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
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 0x1bed3(%rip), %rdi     # 0x234da
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x35c95(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movl 0x3(%rbx), %r8d
leaq 0x1bed1(%rip), %rdi     # 0x23505
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x7
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7733
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq 0x35c0b(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1e, %rcx
leaq 0x1be9a(%rip), %rax     # 0x23561
movl %ebx, %ebp
subl %edi, %ebp
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %r14d
movq %rbx, %rsi
movl %r14d, %edx
callq 0x748b
addl $0x4, %ebp
leaq 0x1bea0(%rip), %r14     # 0x2358f
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x7727
movq 0x35bb1(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x13, %rcx
movl 0x4(%rbx,%r15,4), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x4, %ebp
jmp 0x76f2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x77f2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35b5a(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1e, %rcx
leaq 0x1bde4(%rip), %rdi     # 0x23561
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x748b
movq 0x35b19(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1be0e(%rip), %rdi     # 0x235bf
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35aee(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movl 0x8(%rbx), %r8d
leaq 0x1be12(%rip), %rdi     # 0x235ed
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x78d8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x35a50(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x18, %rcx
movl (%r14), %r8d
leaq 0x1bd8d(%rip), %rdi     # 0x23618
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35a14(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1bd98(%rip), %rdi     # 0x2364c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x72a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x79be
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3596a(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x18, %rcx
movl (%r14), %r8d
leaq 0x1bd18(%rip), %rdi     # 0x23689
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3592e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2d, %rcx
leaq 0x1bcb2(%rip), %rdi     # 0x2364c
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x72a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a3f
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x358d7(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x19, %rcx
movl (%rbx), %r8d
leaq 0x1bcba(%rip), %rdi     # 0x236bd
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3589c(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movl 0x4(%rbx), %r8d
leaq 0x1bcc5(%rip), %rdi     # 0x236f2
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ae2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3584d(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x23, %rcx
leaq 0x1bc9c(%rip), %rdi     # 0x23727
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x79c2
movq 0x35808(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x27, %rcx
leaq 0x1bc9a(%rip), %rdi     # 0x2375a
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7840
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x14
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7b91
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x357a1(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x1bc65(%rip), %rax     # 0x23791
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1bc74(%rip), %r15     # 0x237c0
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x7b84
movq 0x35754(%rip), %rcx     # 0x3d2b0
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
jmp 0x7b4f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7c40
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
movq 0x356f2(%rip), %rcx     # 0x3d2b0
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
addq $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x1bbb6(%rip), %rax     # 0x23791
movl %ebx, %r14d
subl %edi, %r14d
movq %rax, %rdi
movl %r14d, %edx
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
incl %r14d
leaq 0x1bbc5(%rip), %r15     # 0x237c0
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x7c33
movq 0x356a5(%rip), %rcx     # 0x3d2b0
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
jmp 0x7bfe
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7cf3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x35651(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzwl (%rbx), %r8d
leaq 0x1bb6b(%rip), %rdi     # 0x237f5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x35615(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1bb6f(%rip), %rdi     # 0x23825
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x355e9(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xb, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1bb74(%rip), %rdi     # 0x23855
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7dab
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x35594(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x25, %rcx
leaq 0x1bb44(%rip), %rdi     # 0x23882
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 0x7c44
addl $0x4, %ebp
leaq 0x1bb50(%rip), %r14     # 0x238b7
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x7d9f
movq 0x35539(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r12), %rsi
addq $0x11, %rcx
movl 0x4(%rbx,%r15,4), %r9d
movl %r9d, (%rsp)
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
incq %r15
addl $0x4, %ebp
jmp 0x7d6a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
pushq $0xc
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7e5e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x354e6(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x12, %rcx
movzwl (%rbx), %r8d
leaq 0x1baf0(%rip), %rdi     # 0x238e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x354aa(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1baf6(%rip), %rdi     # 0x23917
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x3547e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1b53c(%rip), %rdi     # 0x23388
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x80ba
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x352d7(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1ba13(%rip), %rdi     # 0x23a14
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3529b(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1ba1d(%rip), %rdi     # 0x23a49
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x35273(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1ba27(%rip), %rdi     # 0x23a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3524a(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x1ba30(%rip), %rdi     # 0x23aae
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x35221(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x5, %ecx
andl $0x3, %ecx
leaq 0x1ba41(%rip), %rdi     # 0x23ae7
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x82fc
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x35069(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1b7a5(%rip), %rdi     # 0x23a14
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x3502d(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x7, %ecx
leaq 0x1b8e2(%rip), %rdi     # 0x23b7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x35005(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0xf, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x1b8ec(%rip), %rdi     # 0x23baf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34fdc(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x1b8f8(%rip), %rdi     # 0x23be0
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x853f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x34e27(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x13, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x1b7c9(%rip), %rdi     # 0x23c7a
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34deb(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x1b7d2(%rip), %rdi     # 0x23caf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34dc2(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0xf, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x7, %ecx
leaq 0x1b6a9(%rip), %rdi     # 0x23baf
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34d99(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x12, %rdx
movzbl (%rbx), %ecx
shrl $0x7, %ecx
leaq 0x1b6b5(%rip), %rdi     # 0x23be0
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x85a3
pushq %rbx
movq 0x34d60(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %rbx
leaq (%rcx,%rbx), %rax
movl %esi, %edx
subl %edi, %edx
addq $0x12, %rcx
movzwl (%rsi), %r8d
leaq 0x1b36b(%rip), %rdi     # 0x238e5
movq %rax, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq 0x34d22(%rip), %rbx     # 0x3d2b0
leaq 0x1b74d(%rip), %rdi     # 0x23ce2
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40b0
popq %rbx
pushq $0x8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8626
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x34cf2(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xe, %rcx
movzbl (%rbx), %r8d
leaq 0x1b72c(%rip), %rdi     # 0x23d15
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x34cb6(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1b731(%rip), %rdi     # 0x23d45
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x87aa
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x34c36(%rip), %rax     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rcx
cmovll %edx, %ecx
addl %ecx, %ecx
pushq $0x32
popq %rdx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x19, %rax
movzbl (%rbx), %ecx
andl $0x1, %ecx
leaq 0x1b704(%rip), %rdi     # 0x23da6
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34bfa(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x14, %rdx
movzbl (%rbx), %ecx
shrl %ecx
andl $0x1, %ecx
leaq 0x1b714(%rip), %rdi     # 0x23de1
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34bd2(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x10, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
leaq 0x1b386(%rip), %rdi     # 0x23a7c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34ba9(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq 0x1b6f8(%rip), %rdi     # 0x23e17
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34b80(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x13, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x1, %ecx
leaq 0x1b704(%rip), %rdi     # 0x23e4c
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34b57(%rip), %rdx     # 0x3d2b0
leaq (%rdx,%r14), %rsi
addq $0x11, %rdx
movzbl (%rbx), %ecx
shrl $0x5, %ecx
andl $0x1, %ecx
leaq 0x1b2d8(%rip), %rdi     # 0x23a49
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x34b2e(%rip), %rdx     # 0x3d2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x1b318(%rip), %rdi     # 0x23aae
movq %r14, %rsi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
pushq $0x1
popq %rax
retq