LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper
int ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *d = (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5 asFirmwareVramReserveInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asFirmwareVramReserveInfo[i])-start), FILL(65+(i>9)), i); ATOM_FIRMWARE_VRAM_RESERVE_INFO_V1_5_dumper (start, (uint8_t*) &d->asFirmwareVramReserveInfo[i], indent+1); }
  }
  return sizeof (ATOM_VRAM_USAGE_BY_FIRMWARE_V1_5);
}

// Assembly:
testq %rsi, %rsi
je 0x1273b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x29bfb(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x104cd(%rip), %rdi     # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x29bb2(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x17dd1(%rip), %rdi     # 0x2a4e7
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x125dd
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: ATOM_GPIO_PIN_ASSIGNMENT_dumper
int ATOM_GPIO_PIN_ASSIGNMENT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_ASSIGNMENT *d = (ATOM_GPIO_PIN_ASSIGNMENT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usGpioPin_AIndex%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGpioPin_AIndex)-start), FILL(22), d->usGpioPin_AIndex, d->usGpioPin_AIndex);
    printf ("%s%04x:  UCHAR ucGpioPinBitShift%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGpioPinBitShift)-start), FILL(22), d->ucGpioPinBitShift, d->ucGpioPinBitShift);
    printf ("%s%04x:  UCHAR ucGPIO_ID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIO_ID)-start), FILL(14), d->ucGPIO_ID, d->ucGPIO_ID);
  }
  return sizeof (ATOM_GPIO_PIN_ASSIGNMENT);
}

// Assembly:
testq %rsi, %rsi
je 0x127f4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x29b54(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x16, %rcx
movzwl (%rbx), %r8d
leaq 0x17dae(%rip), %rdi     # 0x2a539
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29b14(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17db8(%rip), %rdi     # 0x2a56f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29ae8(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17dc5(%rip), %rdi     # 0x2a5a7
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_GPIO_PIN_LUT_dumper
int ATOM_GPIO_PIN_LUT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_LUT *d = (ATOM_GPIO_PIN_LUT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    for (i = 0; i < COUNT_ALL (ATOM_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT); i++) {
      printf ("%s%04x:  ATOM_GPIO_PIN_ASSIGNMENT asGPIO_Pin%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asGPIO_Pin[i])-start), FILL(38+(i>9)), i); ATOM_GPIO_PIN_ASSIGNMENT_dumper (start, (uint8_t*) &d->asGPIO_Pin[i], indent+1); }
  }
  return RETURN_ALL (ATOM_GPIO_PIN_LUT, ATOM_GPIO_PIN_ASSIGNMENT);
}

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

// Assembly:
testq %rsi, %rsi
je 0x129a2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x299a6(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xf, %rcx
movzwl (%rbx), %r8d
leaq 0x17cd5(%rip), %rdi     # 0x2a60e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x29966(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17cd8(%rip), %rdi     # 0x2a63d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2993a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x105bc(%rip), %rdi     # 0x22f4c
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_DISPLAY_OBJECT_PATH_dumper
int ATOM_DISPLAY_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH *d = (ATOM_DISPLAY_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x13545
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28e63(%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 0x1767b(%rip), %rdi     # 0x2aaf7
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28e23(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x17680(%rip), %rdi     # 0x2ab28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28df7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17680(%rip), %rdi     # 0x2ab54
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28dcb(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17688(%rip), %rdi     # 0x2ab88
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28d9f(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x8(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x1768c(%rip), %rdi     # 0x2abbb
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_EXTERNAL_OBJECT_PATH_dumper
int ATOM_DISPLAY_EXTERNAL_OBJECT_PATH_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *d = (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usDeviceTag%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceTag)-start), FILL(17), d->usDeviceTag, d->usDeviceTag);
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  USHORT usConnObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usConnObjectId)-start), FILL(20), d->usConnObjectId, d->usConnObjectId);
    printf ("%s%04x:  USHORT usGPUObjectId%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGPUObjectId)-start), FILL(19), d->usGPUObjectId, d->usGPUObjectId);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  USHORT usGraphicObjIds%s [%d] = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usGraphicObjIds[i])-start), FILL(25+(i>9)), i, d->usGraphicObjIds[i], d->usGraphicObjIds[i]); }
  }
  return sizeof (ATOM_DISPLAY_EXTERNAL_OBJECT_PATH);
}

// Assembly:
testq %rsi, %rsi
je 0x13686
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28d44(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r13
leaq (%rcx,%r13), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzwl (%rbx), %r8d
leaq 0x1755c(%rip), %rdi     # 0x2aaf7
xorl %r15d, %r15d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28d01(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1755e(%rip), %rdi     # 0x2ab28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28cd5(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1755e(%rip), %rdi     # 0x2ab54
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28ca9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17566(%rip), %rdi     # 0x2ab88
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rbx
movb $0x1, %bpl
leaq 0x17581(%rip), %r12     # 0x2abbb
movq 0x28c6f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq (%rbx,%r15,2), %rax
movzwl (%rax), %r9d
movl %eax, %edx
subl %r14d, %edx
addq $0x19, %rcx
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1363a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xc, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper
int ATOM_DISPLAY_OBJECT_PATH_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DISPLAY_OBJECT_PATH_TABLE *d = (ATOM_DISPLAY_OBJECT_PATH_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumOfDispPath%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumOfDispPath)-start), FILL(20), d->ucNumOfDispPath, d->ucNumOfDispPath);
    printf ("%s%04x:  UCHAR ucVersion%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucVersion)-start), FILL(14), d->ucVersion, d->ucVersion);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_DISPLAY_OBJECT_PATH asDispPath%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asDispPath[i])-start), FILL(38+(i>9)), i); ATOM_DISPLAY_OBJECT_PATH_dumper (start, (uint8_t*) &d->asDispPath[i], indent+1); }
  }
  return sizeof (ATOM_DISPLAY_OBJECT_PATH_TABLE);
}

// Assembly:
testq %rsi, %rsi
je 0x137bc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x28c00(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
movl %edx, 0xc(%rsp)
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %ebx, %edx
subl %r15d, %edx
addq $0x14, %rcx
movzbl (%rbx), %r8d
leaq 0x17512(%rip), %rdi     # 0x2abf5
xorl %r13d, %r13d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28bb9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x1(%rbx), %rdx
subl %r15d, %edx
addq $0xe, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x17519(%rip), %rdi     # 0x2ac2b
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq %rbx, 0x10(%rsp)
addq $0x2, %rbx
movb $0x1, %r14b
leaq 0x11091(%rip), %rbp     # 0x247c0
movq 0x28b7a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq (%rbx,%r13), %rdx
subl %r15d, %edx
addq $0x12, %rcx
movzbl (%rbx,%r13), %r9d
movl %r9d, (%rsp)
movq %rbp, %rdi
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r13d
testb $0x1, %r14b
movl $0x0, %r14d
jne 0x1372f
movq 0x28b3c(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
movq 0x10(%rsp), %rbx
addq $0x4, %rbx
movl %ebx, %edx
subl %r15d, %edx
addq $0x26, %rcx
leaq 0x174cb(%rip), %rdi     # 0x2ac5b
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movl 0xc(%rsp), %edx
incl %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1342e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xe, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OBJECT_dumper
int ATOM_OBJECT_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT *d = (ATOM_OBJECT *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usObjectID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usObjectID)-start), FILL(16), d->usObjectID, d->usObjectID);
    printf ("%s%04x:  USHORT usSrcDstTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSrcDstTableOffset)-start), FILL(25), d->usSrcDstTableOffset, d->usSrcDstTableOffset);
    printf ("%s%04x:  USHORT usRecordOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usRecordOffset)-start), FILL(20), d->usRecordOffset, d->usRecordOffset);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_OBJECT);
}

// Assembly:
testq %rsi, %rsi
je 0x138a1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28ad3(%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 0x17486(%rip), %rdi     # 0x2ac92
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28a93(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x19, %rcx
movzwl 0x2(%rbx), %r8d
leaq 0x1748a(%rip), %rdi     # 0x2acc2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28a67(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x17497(%rip), %rdi     # 0x2acfb
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28a3b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x14dc5(%rip), %rdi     # 0x28654
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_OBJECT_TABLE_dumper
int ATOM_OBJECT_TABLE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT_TABLE *d = (ATOM_OBJECT_TABLE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumberOfObjects%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfObjects)-start), FILL(22), d->ucNumberOfObjects, d->ucNumberOfObjects);
    for (i = 0; i < 3; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_OBJECT asObjects%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asObjects[i])-start), FILL(24+(i>9)), i); ATOM_OBJECT_dumper (start, (uint8_t*) &d->asObjects[i], indent+1); }
  }
  return sizeof (ATOM_OBJECT_TABLE);
}

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

// Assembly:
testq %rsi, %rsi
je 0x13a92
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x288ee(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x12, %rcx
movzbl (%rbx), %r8d
leaq 0x1739f(%rip), %rdi     # 0x2ad90
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x288ae(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x173a3(%rip), %rdi     # 0x2adc4
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2887e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x173af(%rip), %rdi     # 0x2adfc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28852(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzwl 0x4(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x173b4(%rip), %rdi     # 0x2ae30
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DP_CONN_CHANNEL_MAPPING_dumper
int ATOM_DP_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DP_CONN_CHANNEL_MAPPING *d = (ATOM_DP_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDP_Lane0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane0_Source, d->ucDP_Lane0_Source);
    printf ("%s       UCHAR ucDP_Lane1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane1_Source, d->ucDP_Lane1_Source);
    printf ("%s       UCHAR ucDP_Lane2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane2_Source, d->ucDP_Lane2_Source);
    printf ("%s       UCHAR ucDP_Lane3_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(24), d->ucDP_Lane3_Source, d->ucDP_Lane3_Source);
  }
  return sizeof (ATOM_DP_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x13b69
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28801(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x18, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x1738d(%rip), %rdi     # 0x2ae68
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x287c1(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x1739b(%rip), %rdi     # 0x2aea2
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x28798(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x173ac(%rip), %rdi     # 0x2aedc
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x2876f(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x18, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x173c1(%rip), %rdi     # 0x2af16
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_DVI_CONN_CHANNEL_MAPPING_dumper
int ATOM_DVI_CONN_CHANNEL_MAPPING_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DVI_CONN_CHANNEL_MAPPING *d = (ATOM_DVI_CONN_CHANNEL_MAPPING *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR ucDVI_DATA2_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA2_Source, d->ucDVI_DATA2_Source);
    printf ("%s       UCHAR ucDVI_DATA1_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA1_Source, d->ucDVI_DATA1_Source);
    printf ("%s       UCHAR ucDVI_DATA0_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(25), d->ucDVI_DATA0_Source, d->ucDVI_DATA0_Source);
    printf ("%s       UCHAR ucDVI_CLK_Source:2%s = 0x%02x       (%d)\n", IND(indent), FILL(23), d->ucDVI_CLK_Source, d->ucDVI_CLK_Source);
  }
  return sizeof (ATOM_DVI_CONN_CHANNEL_MAPPING);
}

// Assembly:
testq %rsi, %rsi
je 0x13c40
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2872a(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x19, %rax
movzbl (%rbx), %ecx
andl $0x3, %ecx
leaq 0x1739e(%rip), %rdi     # 0x2af50
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x286ea(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
leaq 0x173ad(%rip), %rdi     # 0x2af8b
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x286c1(%rip), %rdx     # 0x3c2b0
leaq (%rdx,%r14), %rsi
addq $0x19, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
leaq 0x173bf(%rip), %rdi     # 0x2afc6
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x28698(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x17, %rdx
movzbl (%rbx), %ecx
shrl $0x6, %ecx
leaq 0x173d5(%rip), %rdi     # 0x2b001
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_COMMON_RECORD_HEADER_dumper
int ATOM_COMMON_RECORD_HEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_COMMON_RECORD_HEADER *d = (ATOM_COMMON_RECORD_HEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucRecordType%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordType)-start), FILL(17), d->ucRecordType, d->ucRecordType);
    printf ("%s%04x:  UCHAR ucRecordSize%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucRecordSize)-start), FILL(17), d->ucRecordSize, d->ucRecordSize);
  }
  return sizeof (ATOM_COMMON_RECORD_HEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x14001
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2831b(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x11, %rcx
movzbl (%rbx), %r8d
leaq 0x15f46(%rip), %rdi     # 0x29f0a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x282db(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x11, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1728e(%rip), %rdi     # 0x2b27d
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_I2C_RECORD_dumper
int ATOM_I2C_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_I2C_RECORD *d = (ATOM_I2C_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  ATOM_I2C_ID_CONFIG sucI2cId%s :\n", IND(indent), (int)(((uint8_t*)&d->sucI2cId)-start), FILL(26)); ATOM_I2C_ID_CONFIG_dumper (start, (uint8_t*) &d->sucI2cId, indent+1);
    printf ("%s%04x:  UCHAR ucI2CAddr%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucI2CAddr)-start), FILL(14), d->ucI2CAddr, d->ucI2CAddr);
  }
  return sizeof (ATOM_I2C_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x140cf
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28289(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x1725e(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x28241(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %r12
movl %r12d, %edx
subl %r14d, %edx
addq $0x1a, %rcx
leaq 0x17258(%rip), %rdi     # 0x2b2e0
xorl %eax, %eax
callq 0x40b0
movq %r12, %rsi
movl %ebp, %edx
callq 0xfcf9
movq 0x28210(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xe, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17250(%rip), %rdi     # 0x2b30a
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_HPD_INT_RECORD_dumper
int ATOM_HPD_INT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_HPD_INT_RECORD *d = (ATOM_HPD_INT_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucHPDIntGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucHPDIntGPIOID)-start), FILL(19), d->ucHPDIntGPIOID, d->ucHPDIntGPIOID);
    printf ("%s%04x:  UCHAR ucPlugged_PinState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPlugged_PinState)-start), FILL(23), d->ucPlugged_PinState, d->ucPlugged_PinState);
  }
  return sizeof (ATOM_HPD_INT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14199
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x281bc(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x17191(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x28174(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x171e3(%rip), %rdi     # 0x2b33a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x28148(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x171ed(%rip), %rdi     # 0x2b36f
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_OUTPUT_PROTECTION_RECORD_dumper
int ATOM_OUTPUT_PROTECTION_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OUTPUT_PROTECTION_RECORD *d = (ATOM_OUTPUT_PROTECTION_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucProtectionFlag%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucProtectionFlag)-start), FILL(21), d->ucProtectionFlag, d->ucProtectionFlag);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
  }
  return sizeof (ATOM_OUTPUT_PROTECTION_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14263
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x280f2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x170c7(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x280aa(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17187(%rip), %rdi     # 0x2b3a8
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2807e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0xed00(%rip), %rdi      # 0x22f4c
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_DEVICE_TAG_dumper
int ATOM_CONNECTOR_DEVICE_TAG_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DEVICE_TAG *d = (ATOM_CONNECTOR_DEVICE_TAG *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ULONG ulACPIDeviceEnum%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulACPIDeviceEnum)-start), FILL(21), d->ulACPIDeviceEnum, d->ulACPIDeviceEnum);
    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:  USHORT usPadding%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usPadding)-start), FILL(15), d->usPadding, d->usPadding);
  }
  return sizeof (ATOM_CONNECTOR_DEVICE_TAG);
}

// Assembly:
testq %rsi, %rsi
je 0x1431b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2802c(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x15, %rcx
movl (%rbx), %r8d
leaq 0x1712d(%rip), %rdi     # 0x2b3df
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27fed(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x10517(%rip), %rdi     # 0x247f5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27fc1(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x17107(%rip), %rdi     # 0x2b410
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_CONNECTOR_DEVICE_TAG_RECORD_dumper
int ATOM_CONNECTOR_DEVICE_TAG_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DEVICE_TAG_RECORD *d = (ATOM_CONNECTOR_DEVICE_TAG_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucNumberOfDevice%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfDevice)-start), FILL(21), d->ucNumberOfDevice, d->ucNumberOfDevice);
    printf ("%s%04x:  UCHAR ucReserved%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucReserved)-start), FILL(15), d->ucReserved, d->ucReserved);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_DEVICE_TAG asDeviceTag%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asDeviceTag[i])-start), FILL(40+(i>9)), i); ATOM_CONNECTOR_DEVICE_TAG_dumper (start, (uint8_t*) &d->asDeviceTag[i], indent+1); }
  }
  return sizeof (ATOM_CONNECTOR_DEVICE_TAG_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x1441f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x27f6f(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x16f43(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13f7e
movq 0x27f26(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x1709a(%rip), %rdi     # 0x2b43f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27efa(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0xf, %rcx
movzbl 0x3(%r14), %r8d
leaq 0xeb7b(%rip), %rdi      # 0x22f4c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27ece(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x28, %rcx
leaq 0x1707c(%rip), %rdi     # 0x2b476
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x14269
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: ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD_dumper
int ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD *d = (ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucConfigGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConfigGPIOID)-start), FILL(19), d->ucConfigGPIOID, d->ucConfigGPIOID);
    printf ("%s%04x:  UCHAR ucConfigGPIOState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucConfigGPIOState)-start), FILL(22), d->ucConfigGPIOState, d->ucConfigGPIOState);
    printf ("%s%04x:  UCHAR ucFlowinGPIPID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFlowinGPIPID)-start), FILL(19), d->ucFlowinGPIPID, d->ucFlowinGPIPID);
    printf ("%s%04x:  UCHAR ucExtInGPIPID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucExtInGPIPID)-start), FILL(18), d->ucExtInGPIPID, d->ucExtInGPIPID);
  }
  return sizeof (ATOM_CONNECTOR_DVI_EXT_INPUT_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14541
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27e6c(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x16e41(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x27e24(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x17008(%rip), %rdi     # 0x2b4af
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27df8(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x17011(%rip), %rdi     # 0x2b4e4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27dcc(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x1701d(%rip), %rdi     # 0x2b51c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27da0(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x17027(%rip), %rdi     # 0x2b551
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_CVTV_SHARE_DIN_RECORD_dumper
int ATOM_CONNECTOR_CVTV_SHARE_DIN_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_CVTV_SHARE_DIN_RECORD *d = (ATOM_CONNECTOR_CVTV_SHARE_DIN_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOID)-start), FILL(13), d->ucGPIOID, d->ucGPIOID);
    printf ("%s%04x:  UCHAR ucTVActiveState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTVActiveState)-start), FILL(20), d->ucTVActiveState, d->ucTVActiveState);
  }
  return sizeof (ATOM_CONNECTOR_CVTV_SHARE_DIN_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x147fc
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27b59(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x20, %rcx
leaq 0x16b2e(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x13f7e
movq 0x27b11(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x16f3f(%rip), %rdi     # 0x2b6f9
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27ae5(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x16f43(%rip), %rdi     # 0x2b728
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_GPIO_PIN_CONTROL_PAIR_dumper
int ATOM_GPIO_PIN_CONTROL_PAIR_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_GPIO_PIN_CONTROL_PAIR *d = (ATOM_GPIO_PIN_CONTROL_PAIR *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucGPIOID%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIOID)-start), FILL(13), d->ucGPIOID, d->ucGPIOID);
    printf ("%s%04x:  UCHAR ucGPIO_PinState%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucGPIO_PinState)-start), FILL(20), d->ucGPIO_PinState, d->ucGPIO_PinState);
  }
  return sizeof (ATOM_GPIO_PIN_CONTROL_PAIR);
}

// Assembly:
testq %rsi, %rsi
je 0x14aab
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27871(%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 $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x16c8b(%rip), %rdi     # 0x2b6f9
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x27831(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x16e65(%rip), %rdi     # 0x2b8fe
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_OBJECT_GPIO_CNTL_RECORD_dumper
int ATOM_OBJECT_GPIO_CNTL_RECORD_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_OBJECT_GPIO_CNTL_RECORD *d = (ATOM_OBJECT_GPIO_CNTL_RECORD *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_RECORD_HEADER sheader%s :\n", IND(indent), (int)(((uint8_t*)&d->sheader)-start), FILL(32)); ATOM_COMMON_RECORD_HEADER_dumper (start, (uint8_t*) &d->sheader, indent+1);
    printf ("%s%04x:  UCHAR ucFlags%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucFlags)-start), FILL(12), d->ucFlags, d->ucFlags);
    printf ("%s%04x:  UCHAR ucNumberOfPins%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumberOfPins)-start), FILL(19), d->ucNumberOfPins, d->ucNumberOfPins);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_GPIO_PIN_CONTROL_PAIR asGpio%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asGpio[i])-start), FILL(36+(i>9)), i); ATOM_GPIO_PIN_CONTROL_PAIR_dumper (start, (uint8_t*) &d->asGpio[i], indent+1); }
  }
  return sizeof (ATOM_OBJECT_GPIO_CNTL_RECORD);
}

// Assembly:
testq %rsi, %rsi
je 0x14baf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x277df(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x20, %rcx
leaq 0x167b3(%rip), %rdi     # 0x2b2b0
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13f7e
movq 0x27796(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0xc, %rcx
movzbl 0x2(%r14), %r8d
leaq 0x16dff(%rip), %rdi     # 0x2b934
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2776a(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x3(%r14), %rdx
subl %r15d, %edx
addq $0x13, %rcx
movzbl 0x3(%r14), %r8d
leaq 0x16e01(%rip), %rdi     # 0x2b962
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x2773e(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x4, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x24, %rcx
leaq 0x16e0d(%rip), %rdi     # 0x2b997
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x14a28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x6, %eax
retq