LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_DAC_INFO_dumper
int ATOM_DAC_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_DAC_INFO *d = (ATOM_DAC_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    printf ("%s%04x:  USHORT usReserved%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usReserved)-start), FILL(16), d->usReserved, d->usReserved);
  }
  return sizeof (ATOM_DAC_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1dea8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1e4ad(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x1f, %rcx
leaq 0x4d80(%rip), %rdi      # 0x22bae
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5fe4
movq 0x1e465(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzwl 0x4(%rbx), %r8d
leaq 0x1240f(%rip), %rdi     # 0x30275
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1e439(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0xa7c3(%rip), %rdi      # 0x28654
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_CONNECTOR_INFO_dumper
int ATOM_CONNECTOR_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO *d = (ATOM_CONNECTOR_INFO *) data;
  int i;
  if (d) {
    printf ("%s       UCHAR bfAssociatedDAC:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfAssociatedDAC, d->bfAssociatedDAC);
    printf ("%s       UCHAR bfConnectorType:4%s = 0x%02x       (%d)\n", IND(indent), FILL(22), d->bfConnectorType, d->bfConnectorType);
  }
  return sizeof (ATOM_CONNECTOR_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e337
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x1dfe1(%rip), %rax     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %ecx
cmovll %edx, %ecx
addl %ecx, %ecx
movl $0x32, %edx
subl %ecx, %edx
movslq %edx, %r14
leaq (%rax,%r14), %rsi
addq $0x16, %rax
movzbl (%rbx), %ecx
andl $0xf, %ecx
leaq 0x124d2(%rip), %rdi     # 0x307cd
movq %rax, %rdx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x40b0
movq 0x1dfa1(%rip), %rdx     # 0x3c2b0
addq %rdx, %r14
addq $0x16, %rdx
movzbl (%rbx), %ecx
shrl $0x4, %ecx
leaq 0x124e2(%rip), %rdi     # 0x30805
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_CONNECTOR_INFO_ACCESS_dumper
int ATOM_CONNECTOR_INFO_ACCESS_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_CONNECTOR_INFO_ACCESS *d = (ATOM_CONNECTOR_INFO_ACCESS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_CONNECTOR_INFO sbfAccess%s :\n", IND(indent), (int)(((uint8_t*)&d->sbfAccess)-start), FILL(36)); ATOM_CONNECTOR_INFO_dumper (start, (uint8_t*) &d->sbfAccess, indent+1);
    printf ("%s%04x:  (union) UCHAR ucAccess%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAccess)-start), FILL(21), d->ucAccess, d->ucAccess);
  }
  return sizeof (ATOM_CONNECTOR_INFO_ACCESS);
}

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

// Assembly:
testq %rsi, %rsi
je 0x1e476
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1debc(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x2a, %rcx
leaq 0x12451(%rip), %rdi     # 0x30871
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e33d
movq 0x1de73(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x21, %rcx
leaq 0xa62b(%rip), %rdi      # 0x28a7f
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xfda7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_SUPPORTED_DEVICES_INFO_dumper
int ATOM_SUPPORTED_DEVICES_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_SUPPORTED_DEVICES_INFO *d = (ATOM_SUPPORTED_DEVICES_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usDeviceSupport%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usDeviceSupport)-start), FILL(21), d->usDeviceSupport, d->usDeviceSupport);
    for (i = 0; i < 10; i++) {
      printf ("%s%04x:  ATOM_CONNECTOR_INFO_I2C asConnInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asConnInfo[i])-start), FILL(37+(i>9)), i); ATOM_CONNECTOR_INFO_I2C_dumper (start, (uint8_t*) &d->asConnInfo[i], indent+1); }
  }
  return sizeof (ATOM_SUPPORTED_DEVICES_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e566
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1de11(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0x46e9(%rip), %rdi      # 0x22bae
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x1ddc6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x15, %rcx
movzwl 0x4(%r14), %r8d
leaq 0xc43e(%rip), %rdi      # 0x2a943
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
movq 0x1dd90(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x25, %rcx
leaq 0x1237c(%rip), %rdi     # 0x308ab
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e3d4
incq %r13
addq $0x2, %r14
addl $0x2, %ebp
cmpq $0xa, %r13
jne 0x1e519
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1a, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_MISC_CONTROL_INFO_dumper
int ATOM_MISC_CONTROL_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_MISC_CONTROL_INFO *d = (ATOM_MISC_CONTROL_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFrequency)-start), FILL(17), d->usFrequency, d->usFrequency);
    printf ("%s%04x:  UCHAR ucPLL_ChargePump%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_ChargePump)-start), FILL(21), d->ucPLL_ChargePump, d->ucPLL_ChargePump);
    printf ("%s%04x:  UCHAR ucPLL_DutyCycle%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_DutyCycle)-start), FILL(20), d->ucPLL_DutyCycle, d->ucPLL_DutyCycle);
    printf ("%s%04x:  UCHAR ucPLL_VCO_Gain%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VCO_Gain)-start), FILL(19), d->ucPLL_VCO_Gain, d->ucPLL_VCO_Gain);
    printf ("%s%04x:  UCHAR ucPLL_VoltageSwing%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPLL_VoltageSwing)-start), FILL(23), d->ucPLL_VoltageSwing, d->ucPLL_VoltageSwing);
  }
  return sizeof (ATOM_MISC_CONTROL_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1e9c8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d9d8(%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 0x1204d(%rip), %rdi     # 0x30954
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d998(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x12052(%rip), %rdi     # 0x30985
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d96c(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x3(%rbx), %r8d
leaq 0x1205d(%rip), %rdi     # 0x309bc
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d940(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x4(%rbx), %rdx
subl %r14d, %edx
addq $0x13, %rcx
movzbl 0x4(%rbx), %r8d
leaq 0x12067(%rip), %rdi     # 0x309f2
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d914(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x12071(%rip), %rdi     # 0x30a27
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_TMDS_INFO_dumper
int ATOM_TMDS_INFO_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_TMDS_INFO *d = (ATOM_TMDS_INFO *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_COMMON_TABLE_HEADER sHeader%s :\n", IND(indent), (int)(((uint8_t*)&d->sHeader)-start), FILL(31)); ATOM_COMMON_TABLE_HEADER_dumper (start, (uint8_t*) &d->sHeader, indent+1);
    printf ("%s%04x:  USHORT usMaxFrequency%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMaxFrequency)-start), FILL(20), d->usMaxFrequency, d->usMaxFrequency);
    for (i = 0; i < 4; i++) {
      printf ("%s%04x:  ATOM_MISC_CONTROL_INFO asMiscInfo%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->asMiscInfo[i])-start), FILL(36+(i>9)), i); ATOM_MISC_CONTROL_INFO_dumper (start, (uint8_t*) &d->asMiscInfo[i], indent+1); }
  }
  return sizeof (ATOM_TMDS_INFO);
}

// Assembly:
testq %rsi, %rsi
je 0x1eab8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d8bf(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
addq $0x1f, %rcx
leaq 0x4197(%rip), %rdi      # 0x22bae
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5fe4
movq 0x1d874(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x14, %rcx
movzwl 0x4(%r14), %r8d
leaq 0x1181e(%rip), %rdi     # 0x30275
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x6, %r14
addl $0x6, %ebp
xorl %r13d, %r13d
movq 0x1d83e(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
addq $0x24, %rcx
leaq 0x11fdf(%rip), %rdi     # 0x30a60
movl %ebp, %edx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1e8bd
incq %r13
addq $0x6, %r14
addl $0x6, %ebp
cmpq $0x4, %r13
jne 0x1ea6b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1e, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper
int ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ANALOG_ATTRIBUTE *d = (ATOM_ENCODER_ANALOG_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucTVStandard%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucTVStandard)-start), FILL(17), d->ucTVStandard, d->ucTVStandard);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ATOM_ENCODER_ANALOG_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1eb51
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d7d3(%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 0xe53b(%rip), %rdi      # 0x2d047
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d793(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x5c85(%rip), %rdi      # 0x247c0
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper
int ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_DIGITAL_ATTRIBUTE *d = (ATOM_ENCODER_DIGITAL_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucAttribute%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucAttribute)-start), FILL(16), d->ucAttribute, d->ucAttribute);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (ATOM_ENCODER_DIGITAL_ATTRIBUTE);
}

// Assembly:
testq %rsi, %rsi
je 0x1ebea
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d73a(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzbl (%rbx), %r8d
leaq 0x11ef0(%rip), %rdi     # 0x30a95
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d6fa(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x5bec(%rip), %rdi      # 0x247c0
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_ENCODER_ATTRIBUTE_dumper
int ATOM_ENCODER_ATTRIBUTE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_ENCODER_ATTRIBUTE *d = (ATOM_ENCODER_ATTRIBUTE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  (union) ATOM_ENCODER_ANALOG_ATTRIBUTE sAlgAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sAlgAttrib)-start), FILL(47)); ATOM_ENCODER_ANALOG_ATTRIBUTE_dumper (start, (uint8_t*) &d->sAlgAttrib, indent+1);
    printf ("%s%04x:  (union) ATOM_ENCODER_DIGITAL_ATTRIBUTE sDigAttrib%s :\n", IND(indent), (int)(((uint8_t*)&d->sDigAttrib)-start), FILL(48)); ATOM_ENCODER_DIGITAL_ATTRIBUTE_dumper (start, (uint8_t*) &d->sDigAttrib, indent+1);
  }
  return sizeof (ATOM_ENCODER_ATTRIBUTE);
}

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

// Assembly:
testq %rsi, %rsi
je 0x1edb1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d600(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x12, %rcx
movzwl (%r14), %r8d
leaq 0x5c05(%rip), %rdi      # 0x248e5
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d5bf(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x2(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzwl 0x2(%r14), %r8d
leaq 0x11e3a(%rip), %rdi     # 0x30b46
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d593(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x4(%r14), %rdx
subl %r15d, %edx
addq $0x11, %rcx
movzbl 0x4(%r14), %r8d
leaq 0x11e3f(%rip), %rdi     # 0x30b77
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d567(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r12), %rsi
leaq 0x5(%r14), %rdx
subl %r15d, %edx
addq $0xd, %rcx
movzbl 0x5(%r14), %r8d
leaq 0x5624(%rip), %rdi      # 0x24388
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d53b(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x6, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x1f, %rcx
leaq 0x11e1d(%rip), %rdi     # 0x30baa
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1ebf0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x8, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper
int DVO_ENCODER_CONTROL_PS_ALLOCATION_dumper (uint8_t *start, uint8_t *data, int indent) {
  DVO_ENCODER_CONTROL_PS_ALLOCATION *d = (DVO_ENCODER_CONTROL_PS_ALLOCATION *) data;
  int i;
  if (d) {
    printf ("%s%04x:  DVO_ENCODER_CONTROL_PARAMETERS sDVOEncoder%s :\n", IND(indent), (int)(((uint8_t*)&d->sDVOEncoder)-start), FILL(41)); DVO_ENCODER_CONTROL_PARAMETERS_dumper (start, (uint8_t*) &d->sDVOEncoder, indent+1);
    printf ("%s%04x:  WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS sReserved%s :\n", IND(indent), (int)(((uint8_t*)&d->sReserved)-start), FILL(46)); WRITE_ONE_BYTE_HW_I2C_DATA_PARAMETERS_dumper (start, (uint8_t*) &d->sReserved, indent+1);
  }
  return sizeof (DVO_ENCODER_CONTROL_PS_ALLOCATION);
}

// Assembly:
testq %rsi, %rsi
je 0x1ee5a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d4d9(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x29, %rcx
leaq 0x11dd6(%rip), %rdi     # 0x30bd9
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1ec90
movq 0x1d490(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
addq $0x8, %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x2e, %rcx
leaq 0x6efa(%rip), %rdi      # 0x25d32
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xa4f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x10, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper
int DFP_DPMS_STATUS_CHANGE_PARAMETERS_dumper (uint8_t *start, uint8_t *data, int indent) {
  DFP_DPMS_STATUS_CHANGE_PARAMETERS *d = (DFP_DPMS_STATUS_CHANGE_PARAMETERS *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucEnable%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucEnable)-start), FILL(13), d->ucEnable, d->ucEnable);
    printf ("%s%04x:  UCHAR ucDevice%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucDevice)-start), FILL(13), d->ucDevice, d->ucDevice);
    for (i = 0; i < 2; i++) {
      printf ("%s%04x:  UCHAR ucPadding%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucPadding[i])-start), FILL(18+(i>9)), i, d->ucPadding[i], d->ucPadding[i]); }
  }
  return sizeof (DFP_DPMS_STATUS_CHANGE_PARAMETERS);
}

// Assembly:
testq %rsi, %rsi
je 0x1f0ef
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d282(%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 $0xd, %rcx
movzbl (%rbx), %r8d
leaq 0x5734(%rip), %rdi      # 0x24791
xorl %r15d, %r15d
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1d23f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x6233(%rip), %rdi      # 0x252bf
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x2, %rbx
movb $0x1, %bpl
leaq 0x571c(%rip), %r12      # 0x247c0
movq 0x1d205(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r13), %rsi
leaq (%rbx,%r15), %rdx
subl %r14d, %edx
addq $0x12, %rcx
movzbl (%rbx,%r15), %r9d
movl %r9d, (%rsp)
movq %r12, %rdi
movl %r15d, %r8d
xorl %eax, %eax
callq 0x40b0
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1f0a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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_PPLIB_STATE_dumper
int ATOM_PPLIB_STATE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_STATE *d = (ATOM_PPLIB_STATE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNonClockStateIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNonClockStateIndex)-start), FILL(25), d->ucNonClockStateIndex, d->ucNonClockStateIndex);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR ucClockStateIndices%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucClockStateIndices[i])-start), FILL(28+(i>9)), i, d->ucClockStateIndices[i], d->ucClockStateIndices[i]); }
  }
  return sizeof (ATOM_PPLIB_STATE);
}

// Assembly:
testq %rsi, %rsi
je 0x1fe38
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c4ec(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x19, %rcx
movzbl (%rbx), %r8d
leaq 0x114d1(%rip), %rdi     # 0x312c4
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c4ac(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x1c, %rcx
movzbl 0x1(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x114dd(%rip), %rdi     # 0x312ff
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_EXTENDEDHEADER_dumper
int ATOM_PPLIB_EXTENDEDHEADER_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_EXTENDEDHEADER *d = (ATOM_PPLIB_EXTENDEDHEADER *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSize%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSize)-start), FILL(12), d->usSize, d->usSize);
    printf ("%s%04x:  ULONG ulMaxEngineClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxEngineClock)-start), FILL(21), d->ulMaxEngineClock, d->ulMaxEngineClock);
    printf ("%s%04x:  ULONG ulMaxMemoryClock%s = 0x%08x (%d)\n", IND(indent), (int)(((uint8_t*)&d->ulMaxMemoryClock)-start), FILL(21), d->ulMaxMemoryClock, d->ulMaxMemoryClock);
  }
  return sizeof (ATOM_PPLIB_EXTENDEDHEADER);
}

// Assembly:
testq %rsi, %rsi
je 0x20084
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c2c2(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xc, %rcx
movzwl (%rbx), %r8d
leaq 0xab0b(%rip), %rdi      # 0x2ab28
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c282(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x2(%rbx), %r8d
leaq 0x1146b(%rip), %rdi     # 0x314b3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1c257(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movl 0x6(%rbx), %r8d
leaq 0x11472(%rip), %rdi     # 0x314e4
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_POWERPLAYTABLE2_dumper
int ATOM_PPLIB_POWERPLAYTABLE2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE2 *d = (ATOM_PPLIB_POWERPLAYTABLE2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE basicTable%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable)-start), FILL(35)); ATOM_PPLIB_POWERPLAYTABLE_dumper (start, (uint8_t*) &d->basicTable, indent+1);
    printf ("%s%04x:  UCHAR ucNumCustomThermalPolicy%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumCustomThermalPolicy)-start), FILL(29), d->ucNumCustomThermalPolicy, d->ucNumCustomThermalPolicy);
    printf ("%s%04x:  USHORT usCustomThermalPolicyArrayOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usCustomThermalPolicyArrayOffset)-start), FILL(38), d->usCustomThermalPolicyArrayOffset, d->usCustomThermalPolicyArrayOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE2);
}

// Assembly:
testq %rsi, %rsi
je 0x2045a
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1befb(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x23, %rcx
leaq 0x1146f(%rip), %rdi     # 0x3184f
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2008a
movq 0x1beb3(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x25(%rbx), %rdx
subl %r14d, %edx
addq $0x1d, %rcx
movzbl 0x25(%rbx), %r8d
leaq 0x1146a(%rip), %rdi     # 0x31882
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1be87(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x26(%rbx), %rdx
subl %r14d, %edx
addq $0x26, %rcx
movzwl 0x26(%rbx), %r8d
leaq 0x1147e(%rip), %rdi     # 0x318c1
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x28, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_POWERPLAYTABLE3_dumper
int ATOM_PPLIB_POWERPLAYTABLE3_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_POWERPLAYTABLE3 *d = (ATOM_PPLIB_POWERPLAYTABLE3 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  ATOM_PPLIB_POWERPLAYTABLE2 basicTable2%s :\n", IND(indent), (int)(((uint8_t*)&d->basicTable2)-start), FILL(37)); ATOM_PPLIB_POWERPLAYTABLE2_dumper (start, (uint8_t*) &d->basicTable2, indent+1);
    printf ("%s%04x:  USHORT usFormatID%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFormatID)-start), FILL(16), d->usFormatID, d->usFormatID);
    printf ("%s%04x:  USHORT usFanTableOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usFanTableOffset)-start), FILL(22), d->usFanTableOffset, d->usFanTableOffset);
    printf ("%s%04x:  USHORT usExtendendedHeaderOffset%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usExtendendedHeaderOffset)-start), FILL(31), d->usExtendendedHeaderOffset, d->usExtendendedHeaderOffset);
  }
  return sizeof (ATOM_PPLIB_POWERPLAYTABLE3);
}

// Assembly:
testq %rsi, %rsi
je 0x20550
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1be31(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x25, %rcx
leaq 0x1145d(%rip), %rdi     # 0x31907
xorl %eax, %eax
callq 0x40b0
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x20396
movq 0x1bde9(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x28(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzwl 0x28(%rbx), %r8d
leaq 0x1145a(%rip), %rdi     # 0x3193c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bdbd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2a(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzwl 0x2a(%rbx), %r8d
leaq 0x1145e(%rip), %rdi     # 0x3196c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bd91(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2c(%rbx), %rdx
subl %r14d, %edx
addq $0x1f, %rcx
movzwl 0x2c(%rbx), %r8d
leaq 0x11469(%rip), %rdi     # 0x319a2
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl $0x2e, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_THERMAL_STATE_dumper
int ATOM_PPLIB_THERMAL_STATE_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_THERMAL_STATE *d = (ATOM_PPLIB_THERMAL_STATE *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucMinTemperature%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMinTemperature)-start), FILL(21), d->ucMinTemperature, d->ucMinTemperature);
    printf ("%s%04x:  UCHAR ucMaxTemperature%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMaxTemperature)-start), FILL(21), d->ucMaxTemperature, d->ucMaxTemperature);
    printf ("%s%04x:  UCHAR ucThermalAction%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucThermalAction)-start), FILL(20), d->ucThermalAction, d->ucThermalAction);
  }
  return sizeof (ATOM_PPLIB_THERMAL_STATE);
}

// Assembly:
testq %rsi, %rsi
je 0x2094b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b9fd(%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
movzbl (%rbx), %r8d
leaq 0x1058a(%rip), %rdi     # 0x30e6c
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b9bd(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x10595(%rip), %rdi     # 0x30ea3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b991(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x11371(%rip), %rdi     # 0x31caa
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_STATE_V2_dumper
int ATOM_PPLIB_STATE_V2_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_STATE_V2 *d = (ATOM_PPLIB_STATE_V2 *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumDPMLevels%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumDPMLevels)-start), FILL(19), d->ucNumDPMLevels, d->ucNumDPMLevels);
    printf ("%s%04x:  UCHAR nonClockInfoIndex%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->nonClockInfoIndex)-start), FILL(22), d->nonClockInfoIndex, d->nonClockInfoIndex);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  UCHAR clockInfoIndex%s [%d] = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->clockInfoIndex[i])-start), FILL(23+(i>9)), i, d->clockInfoIndex[i], d->clockInfoIndex[i]); }
  }
  return sizeof (ATOM_PPLIB_STATE_V2);
}

// Assembly:
testq %rsi, %rsi
je 0x21307
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b049(%rip), %rcx     # 0x3c2b0
cmpl $0x19, %edx
movl $0x19, %eax
cmovll %edx, %eax
addl %eax, %eax
movl $0x32, %edx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x13, %rcx
movzbl (%rbx), %r8d
leaq 0x10fc8(%rip), %rdi     # 0x3225e
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b009(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x10fd1(%rip), %rdi     # 0x32293
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1afdd(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x10fda(%rip), %rdi     # 0x322cb
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_Clock_Voltage_Dependency_Record_dumper
int ATOM_PPLIB_Clock_Voltage_Dependency_Record_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_Clock_Voltage_Dependency_Record *d = (ATOM_PPLIB_Clock_Voltage_Dependency_Record *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usClockLow%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usClockLow)-start), FILL(16), d->usClockLow, d->usClockLow);
    printf ("%s%04x:  UCHAR ucClockHigh%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucClockHigh)-start), FILL(16), d->ucClockHigh, d->ucClockHigh);
    printf ("%s%04x:  USHORT usVoltage%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVoltage)-start), FILL(15), d->usVoltage, d->usVoltage);
  }
  return sizeof (ATOM_PPLIB_Clock_Voltage_Dependency_Record);
}

// Assembly:
testq %rsi, %rsi
je 0x213c0
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1af88(%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 0x10fae(%rip), %rdi     # 0x32305
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af48(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x10fb2(%rip), %rdi     # 0x32335
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af1c(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0xae76(%rip), %rdi      # 0x2c224
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_Clock_Voltage_Dependency_Table_dumper
int ATOM_PPLIB_Clock_Voltage_Dependency_Table_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_Clock_Voltage_Dependency_Table *d = (ATOM_PPLIB_Clock_Voltage_Dependency_Table *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumEntries%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumEntries)-start), FILL(17), d->ucNumEntries, d->ucNumEntries);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_PPLIB_Clock_Voltage_Dependency_Record entries%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->entries[i])-start), FILL(53+(i>9)), i); ATOM_PPLIB_Clock_Voltage_Dependency_Record_dumper (start, (uint8_t*) &d->entries[i], indent+1); }
  }
  return sizeof (ATOM_PPLIB_Clock_Voltage_Dependency_Table);
}

// Assembly:
testq %rsi, %rsi
je 0x21465
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1aeca(%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 $0x11, %rcx
movzbl (%r14), %r8d
leaq 0x10f51(%rip), %rdi     # 0x32367
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ae89(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x10f5c(%rip), %rdi     # 0x3239a
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2130d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_Clock_Voltage_Limit_Record_dumper
int ATOM_PPLIB_Clock_Voltage_Limit_Record_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_Clock_Voltage_Limit_Record *d = (ATOM_PPLIB_Clock_Voltage_Limit_Record *) data;
  int i;
  if (d) {
    printf ("%s%04x:  USHORT usSclkLow%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usSclkLow)-start), FILL(15), d->usSclkLow, d->usSclkLow);
    printf ("%s%04x:  UCHAR ucSclkHigh%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucSclkHigh)-start), FILL(15), d->ucSclkHigh, d->ucSclkHigh);
    printf ("%s%04x:  USHORT usMclkLow%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usMclkLow)-start), FILL(15), d->usMclkLow, d->usMclkLow);
    printf ("%s%04x:  UCHAR ucMclkHigh%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucMclkHigh)-start), FILL(15), d->ucMclkHigh, d->ucMclkHigh);
    printf ("%s%04x:  USHORT usVddc%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVddc)-start), FILL(12), d->usVddc, d->usVddc);
    printf ("%s%04x:  USHORT usVddci%s = 0x%04x     (%d)\n", IND(indent), (int)(((uint8_t*)&d->usVddci)-start), FILL(13), d->usVddci, d->usVddci);
  }
  return sizeof (ATOM_PPLIB_Clock_Voltage_Limit_Record);
}

// Assembly:
testq %rsi, %rsi
je 0x215a2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1ae2a(%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 0x10f2b(%rip), %rdi     # 0x323e0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1adea(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x10f2e(%rip), %rdi     # 0x3240f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1adbe(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x10f33(%rip), %rdi     # 0x32440
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ad92(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x10f36(%rip), %rdi     # 0x3246f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ad66(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x10f3b(%rip), %rdi     # 0x324a0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ad3a(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x8(%rbx), %r8d
leaq 0x10f3c(%rip), %rdi     # 0x324cc
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
movl $0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_PPLIB_Clock_Voltage_Limit_Table_dumper
int ATOM_PPLIB_Clock_Voltage_Limit_Table_dumper (uint8_t *start, uint8_t *data, int indent) {
  ATOM_PPLIB_Clock_Voltage_Limit_Table *d = (ATOM_PPLIB_Clock_Voltage_Limit_Table *) data;
  int i;
  if (d) {
    printf ("%s%04x:  UCHAR ucNumEntries%s = 0x%02x       (%d)\n", IND(indent), (int)(((uint8_t*)&d->ucNumEntries)-start), FILL(17), d->ucNumEntries, d->ucNumEntries);
    for (i = 0; i < 1; i++) {
      printf ("%s%04x:  ATOM_PPLIB_Clock_Voltage_Limit_Record entries%s [%d] :\n", IND(indent), (int)(((uint8_t*)&d->entries[i])-start), FILL(48+(i>9)), i); ATOM_PPLIB_Clock_Voltage_Limit_Record_dumper (start, (uint8_t*) &d->entries[i], indent+1); }
  }
  return sizeof (ATOM_PPLIB_Clock_Voltage_Limit_Table);
}

// Assembly:
testq %rsi, %rsi
je 0x21647
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ace8(%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 $0x11, %rcx
movzbl (%r14), %r8d
leaq 0x10d6f(%rip), %rdi     # 0x32367
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1aca7(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x30, %rcx
leaq 0x10ed9(%rip), %rdi     # 0x324f9
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2146b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xb, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mikebdp2[P]AtomDis/datastructs.c
// Function: get_data_dumper
data_dumper_t *get_data_dumper (int ind, int *version, int *revision,
				const char **comment)
{
    data_dumper_struct_t *dt, *found = NULL;
    for (dt = data_dumpers; dt->id >= 0 && dt->id <= ind; dt++) {
	if (dt->id != ind)
	    continue;
	if (dt->vers != *version && dt->vers > 0)
	    continue;
	if (dt->rev > *revision)
	    continue;
	found     = dt;
    }
    if (found) {
	*version  = found->vers;
	*revision = found->rev;
	if (comment)
	    *comment = found->comment;
	return found->dumper;
    }
    return NULL;
}

// Assembly:
movl 0x1ac6b(%rip), %r9d     # 0x3c2c0
testl %r9d, %r9d
sets %al
cmpl %edi, %r9d
setg %r8b
orb %al, %r8b
jne 0x216c0
leaq 0x1ac52(%rip), %r8      # 0x3c2c0
xorl %eax, %eax
cmpl %edi, %r9d
jne 0x2168e
movl 0x4(%r8), %r9d
testl %r9d, %r9d
jle 0x21683
cmpl (%rsi), %r9d
jne 0x2168e
movl 0x8(%r8), %r9d
cmpl (%rdx), %r9d
cmovleq %r8, %rax
movl 0x20(%r8), %r9d
testl %r9d, %r9d
js 0x216a0
addq $0x20, %r8
cmpl %edi, %r9d
jle 0x21670
testq %rax, %rax
je 0x216c0
movl 0x4(%rax), %edi
movl %edi, (%rsi)
movl 0x8(%rax), %esi
movl %esi, (%rdx)
testq %rcx, %rcx
je 0x216bb
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Carben-dev[P]ext2fs-simple-utilities/ext2_mkdir.c
// Function: main
int main(int argc, const char * argv[]) {
    if(argc != 3) {
        fprintf(stderr, "Usage: <image file name> <absolute path of new dir>\n");
        exit(1);
    }
    int fd = open(argv[1], O_RDWR);
    
    // map disk img into memory
    disk = mmap(NULL, 128 * 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(disk == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }
    
    // Init utils
    ext2_utils_init();
    
    char path[PATH_MAX];
    char new_dir_name[EXT2_NAME_LEN];
    char parent_path[PATH_MAX];
    
    // Copy argv[2] to user stack
    memcpy(path, argv[2], strlen(argv[2]));
    
    // Case: handle user input path end with '/'
    // For example.
    //      "/d1/" -> "/d1"
    clear_end_slash(path);
    
    
    
    // Prepare parent path and new dir name
    // For example.
    //      "/d1/d2" -> parent path: "/d1" , new dir name: "d2"
    //      "/d1"    -> parent path: "/"   , new dir name: "d1"
    cut_path(path, parent_path, new_dir_name);
    
    
    
    // Find out in which inode this dir should be created
    int in_which_inode = get_inode_number_by_path(parent_path);
    if (in_which_inode == -1) {
        return ENOENT;
    }
    
    // Check if dir already exists
    if (get_inode_number_by_name(in_which_inode, new_dir_name) > 0) {
        return EEXIST;
    }
    
    // create dir
    int rs;
    if ((rs = inode_mkdir(in_which_inode, new_dir_name)) != 0) {
        return rs;
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2108, %rsp           # imm = 0x2108
cmpl $0x3, %edi
jne 0x133a
movq %rsi, %r14
movq 0x8(%rsi), %rdi
movl $0x2, %ebx
movl $0x2, %esi
xorl %eax, %eax
callq 0x10e0
movl $0x20000, %esi          # imm = 0x20000
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x1070
movq %rax, 0x3dfb(%rip)      # 0x50a8
cmpq $-0x1, %rax
je 0x133f
callq 0x1344
movq 0x10(%r14), %r14
movq %r14, %rdi
callq 0x1060
leaq 0x1100(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x10b0
movq %r15, %rdi
callq 0x2187
leaq 0x100(%rsp), %r14
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x219e
movq %r14, %rdi
callq 0x15e9
cmpl $-0x1, %eax
je 0x132a
movl %eax, %ebp
movq %rsp, %rsi
movl %eax, %edi
callq 0x13b3
movl $0x11, %ebx
testl %eax, %eax
jg 0x132a
movq %rsp, %rsi
movl %ebp, %edi
callq 0x161d
movl %eax, %ebx
movl %ebx, %eax
addq $0x2108, %rsp           # imm = 0x2108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1130
callq 0x1155