LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x44f64
movq 0x1f413(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x44ea1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x44ea7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1f3d0(%rip), %rcx     # 0x642a0
addq $0x2f, %rcx
leaq 0x15cd9(%rip), %rdi     # 0x5abb4
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x44b40
movq 0x1f3a4(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x44f10
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x44f16
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1f361(%rip), %rcx     # 0x642a0
addq $0x30, %rcx
leaq 0x15ca9(%rip), %rdi     # 0x5abf3
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x44cd0
movl $0x2, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x452ec
movq 0x1f093(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x45221
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x45227
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1f050(%rip), %rcx     # 0x642a0
addq $0x29, %rcx
leaq 0x15a6b(%rip), %rdi     # 0x5acc6
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x44f70
movq 0x1f024(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x45290
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x45296
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1efdd(%rip), %rcx     # 0x642a0
addq $0x2e, %rcx
leaq 0xab15(%rip), %rdi      # 0x4fde3
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x111e0
movl $0x10, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47a75
movq 0x1c983(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x47931
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x47937
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1c940(%rip), %rcx     # 0x642a0
addq $0x19, %rcx
movq -0x20(%rbp), %rax
movzbl (%rax), %r8d
movq -0x20(%rbp), %rax
movzbl (%rax), %r9d
leaq 0x13a36(%rip), %rdi     # 0x5b3b1
movb $0x0, %al
callq 0x4090
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x47a73
movq 0x1c906(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x479ae
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x479b4
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x54(%rbp)
movq 0x1c8b2(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x1c, %eax
cmpl $0x32, %eax
jle 0x47a10
movl $0x32, %eax
movl %eax, -0x64(%rbp)
jmp 0x47a22
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x1c, %eax
movl %eax, -0x64(%rbp)
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdi
movzbl 0x1(%rax,%rdi), %r9d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdi
movzbl 0x1(%rax,%rdi), %eax
leaq 0x13991(%rip), %rdi     # 0x5b3ec
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4090
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x47989
jmp 0x47a75
movl $0x2, %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47fe2
movq 0x1c403(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x47eb1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x47eb7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1c3c0(%rip), %rcx     # 0x642a0
addq $0xc, %rcx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movq -0x20(%rbp), %rax
movzwl (%rax), %r9d
leaq 0xccde(%rip), %rdi      # 0x54bd9
movb $0x0, %al
callq 0x4090
movq 0x1c397(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x47f1d
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x47f23
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1c350(%rip), %rcx     # 0x642a0
addq $0x15, %rcx
movq -0x20(%rbp), %rax
movl 0x2(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x2(%rax), %r9d
leaq 0x13635(%rip), %rdi     # 0x5b5a0
movb $0x0, %al
callq 0x4090
movq 0x1c327(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x47f8d
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0x47f93
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x6, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1c2e0(%rip), %rcx     # 0x642a0
addq $0x15, %rcx
movq -0x20(%rbp), %rax
movl 0x6(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x6(%rax), %r9d
leaq 0x135f6(%rip), %rdi     # 0x5b5d1
movb $0x0, %al
callq 0x4090
movl $0xa, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x48969
movq 0x1ba83(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x48831
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x48837
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1ba40(%rip), %rcx     # 0x642a0
addq $0x23, %rcx
leaq 0x130d1(%rip), %rdi     # 0x5b93c
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x47ff0
movq 0x1ba14(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x488a0
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x488a6
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x25, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1b9cd(%rip), %rcx     # 0x642a0
addq $0x1d, %rcx
movq -0x20(%rbp), %rax
movzbl 0x25(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x25(%rax), %r9d
leaq 0x1307f(%rip), %rdi     # 0x5b96f
movb $0x0, %al
callq 0x4090
movq 0x1b9a2(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x48912
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0x48918
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x26, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1b95b(%rip), %rcx     # 0x642a0
addq $0x26, %rcx
movq -0x20(%rbp), %rax
movzwl 0x26(%rax), %r8d
movq -0x20(%rbp), %rax
movzwl 0x26(%rax), %r9d
leaq 0x1304c(%rip), %rdi     # 0x5b9ae
movb $0x0, %al
callq 0x4090
movl $0x28, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x494e6
movq 0x1af03(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x493b1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x493b7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1aec0(%rip), %rcx     # 0x642a0
addq $0x15, %rcx
movq -0x20(%rbp), %rax
movzbl (%rax), %r8d
movq -0x20(%rbp), %rax
movzbl (%rax), %r9d
leaq 0x11b5e(%rip), %rdi     # 0x5af59
movb $0x0, %al
callq 0x4090
movq 0x1ae97(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4941d
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x49423
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1ae50(%rip), %rcx     # 0x642a0
addq $0x15, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %r9d
leaq 0x11b23(%rip), %rdi     # 0x5af90
movb $0x0, %al
callq 0x4090
movq 0x1ae25(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4948f
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0x49495
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1adde(%rip), %rcx     # 0x642a0
addq $0x14, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r9d
leaq 0x128b8(%rip), %rdi     # 0x5bd97
movb $0x0, %al
callq 0x4090
movl $0x3, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4af66
movq 0x19483(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4ae31
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x4ae37
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x19440(%rip), %rcx     # 0x642a0
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
movq -0x20(%rbp), %rax
movzwl (%rax), %r9d
leaq 0x11577(%rip), %rdi     # 0x5c3f2
movb $0x0, %al
callq 0x4090
movq 0x19417(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4ae9d
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x4aea3
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x193d0(%rip), %rcx     # 0x642a0
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %r9d
leaq 0x11535(%rip), %rdi     # 0x5c422
movb $0x0, %al
callq 0x4090
movq 0x193a5(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4af0f
movl $0x19, %eax
movl %eax, -0x54(%rbp)
jmp 0x4af15
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x1935e(%rip), %rcx     # 0x642a0
addq $0xf, %rcx
movq -0x20(%rbp), %rax
movzwl 0x3(%rax), %r8d
movq -0x20(%rbp), %rax
movzwl 0x3(%rax), %r9d
leaq 0xb376(%rip), %rdi      # 0x562d5
movb $0x0, %al
callq 0x4090
movl $0x5, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b10d
movq 0x192f3(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4afc1
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x4afc7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x192b0(%rip), %rcx     # 0x642a0
addq $0x11, %rcx
movq -0x20(%rbp), %rax
movzbl (%rax), %r8d
movq -0x20(%rbp), %rax
movzbl (%rax), %r9d
leaq 0x11449(%rip), %rdi     # 0x5c454
movb $0x0, %al
callq 0x4090
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x4b10b
movq 0x19276(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4b03e
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x4b044
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movslq -0x24(%rbp), %rcx
imulq $0x5, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x54(%rbp)
movq 0x1921e(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x35, %eax
cmpl $0x32, %eax
jle 0x4b0a4
movl $0x32, %eax
movl %eax, -0x64(%rbp)
jmp 0x4b0b6
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x35, %eax
movl %eax, -0x64(%rbp)
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
leaq 0x113b3(%rip), %rdi     # 0x5c487
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movslq -0x24(%rbp), %rax
imulq $0x5, %rax, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x4adf0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4b019
jmp 0x4b10d
movl $0x6, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b59d
movq 0x18e63(%rip), %rax     # 0x642a0
movq %rax, -0x30(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4b451
movl $0x19, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b457
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %ecx
shll %ecx
movl $0x32, %eax
subl %ecx, %eax
cltq
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq 0x18e20(%rip), %rcx     # 0x642a0
addq $0x11, %rcx
movq -0x20(%rbp), %rax
movzbl (%rax), %r8d
movq -0x20(%rbp), %rax
movzbl (%rax), %r9d
leaq 0x10fb9(%rip), %rdi     # 0x5c454
movb $0x0, %al
callq 0x4090
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x4b59b
movq 0x18de6(%rip), %rax     # 0x642a0
movq %rax, -0x40(%rbp)
cmpl $0x19, -0x14(%rbp)
jle 0x4b4ce
movl $0x19, %eax
movl %eax, -0x44(%rbp)
jmp 0x4b4d4
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
shll %edx
movl $0x32, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movslq -0x24(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x54(%rbp)
movq 0x18d8e(%rip), %rax     # 0x642a0
movq %rax, -0x50(%rbp)
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x30, %eax
cmpl $0x32, %eax
jle 0x4b534
movl $0x32, %eax
movl %eax, -0x64(%rbp)
jmp 0x4b546
cmpl $0x9, -0x24(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl $0x30, %eax
movl %eax, -0x64(%rbp)
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
leaq 0x11082(%rip), %rdi     # 0x5c5e6
movb $0x0, %al
callq 0x4090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movslq -0x24(%rbp), %rax
imulq $0xa, %rax, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x4b120
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4b4a9
jmp 0x4b59d
movl $0xb, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
leaq 0x18cce(%rip), %rax     # 0x642b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x39(%rbp)
jl 0x4b603
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4b60c
jmp 0x4b65b
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x4b619
jmp 0x4b64d
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4b634
movq -0x30(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x4b634
jmp 0x4b64d
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x4b645
jmp 0x4b64d
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x4b5e6
cmpq $0x0, -0x38(%rbp)
je 0x4b6a0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4b692
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b6a8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/indices.c
// Function: get_index
const char *get_index (int type, int val)
{
    if (type < 0 || val < 0 ||
	type >= sizeof (index_tables) / sizeof (const struct index_table_s))
	return NULL;
    if (! index_tables[type].tab || val >= index_tables[type].len)
	return NULL;
    return index_tables[type].tab[val];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4b6d0
cmpl $0x0, -0x10(%rbp)
jl 0x4b6d0
movslq -0xc(%rbp), %rax
cmpq $0xb, %rax
jb 0x4b6da
movq $0x0, -0x8(%rbp)
jmp 0x4b739
movslq -0xc(%rbp), %rcx
leaq 0x198eb(%rip), %rax     # 0x64fd0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x4b70d
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x198cf(%rip), %rcx     # 0x64fd0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jl 0x4b717
movq $0x0, -0x8(%rbp)
jmp 0x4b739
movslq -0xc(%rbp), %rcx
leaq 0x198ae(%rip), %rax     # 0x64fd0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: cut_short
local void cut_short(int sig) {
    if (sig == SIGINT) {
        Trace(("termination by user"));
    }
    if (g.outd != -1 && g.outd != 1) {
        unlink(g.outf);
        RELEASE(g.outf);
        g.outd = -1;
    }
    log_dump();
    _exit(sig < 0 ? -sig : EINTR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0x3f33
jmp 0x3f33
cmpl $-0x1, 0x1f85a(%rip)    # 0x23794
je 0x3f7e
cmpl $0x1, 0x1f851(%rip)     # 0x23794
je 0x3f7e
movq 0x1f85c(%rip), %rdi     # 0x237a8
callq 0x3080
cmpq $0x0, 0x1f84f(%rip)     # 0x237a8
je 0x3f72
movq 0x1f846(%rip), %rdi     # 0x237a8
callq 0x3050
movq $0x0, 0x1f836(%rip) # 0x237a8
jmp 0x3f74
movl $0xffffffff, 0x1f816(%rip) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
jge 0x3f8e
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x3f98
movl $0x4, %eax
movl %eax, -0x8(%rbp)
jmp 0x3f98
movl -0x8(%rbp), %edi
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: zlib_vernum
local long zlib_vernum(void) {
    char const *ver = zlibVersion();
    long num = 0;
    int left = 4;
    int comp = 0;
    do {
        if (*ver >= '0' && *ver <= '9')
            comp = 10 * comp + *ver - '0';
        else {
            num = (num << 4) + (comp > 0xf ? 0xf : comp);
            left--;
            if (*ver != '.')
                break;
            comp = 0;
        }
        ver++;
    } while (left);
    return left < 3 ? num << (left << 2) : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x3520
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x4104
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x4104
imull $0xa, -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
jmp 0x4155
movq -0x10(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x20(%rbp)
cmpl $0xf, -0x18(%rbp)
jle 0x4120
movl $0xf, %eax
movl %eax, -0x24(%rbp)
jmp 0x4126
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x414e
jmp 0x416b
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x40d7
cmpl $0x3, -0x14(%rbp)
jge 0x4186
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x30(%rbp)
jmp 0x4193
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4193
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: help
local void help(void) {
    int n;

    if (g.verbosity == 0)
        return;
    for (n = 0; n < (int)(sizeof(helptext) / sizeof(char *)); n++)
        fprintf(stderr, "%s\n", helptext[n]);
    fflush(stderr);
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1ee31(%rip)     # 0x237b0
jne 0x4987
addq $0x10, %rsp
popq %rbp
retq
movl $0x0, -0x4(%rbp)
cmpl $0x2a, -0x4(%rbp)
jge 0x49c6
movq 0x1e65d(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0x1ebf7(%rip), %rax     # 0x235a0
movq (%rax,%rcx,8), %rdx
leaq 0x18df1(%rip), %rsi     # 0x1d7a5
movb $0x0, %al
callq 0x3340
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x498e
movq 0x1e62b(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
callq 0x33e0
xorl %edi, %edi
callq 0x3540
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: complain
local int complain(char *fmt, ...) {
    g.ret = 1;
    va_list ap;
    va_start(ap, fmt);
    message(fmt, ap);
    va_end(ap);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4a15
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, 0x1ed3a(%rip)     # 0x23780
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6010
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: x2nmodp
local crc_t x2nmodp(size_t n, unsigned k) {
    crc_t p = (crc_t)1 << 31;       // x^0 == 1
    while (n) {
        if (n & 1)
            p = multmodp(x2n_table[k & 31], p);
        n >>= 1;
        k++;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x80000000, -0x10(%rbp) # imm = 0x80000000
cmpq $0x0, -0x8(%rbp)
je 0x5e70
movq -0x8(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5e5a
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x162f4(%rip), %rax     # 0x1c140
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %esi
callq 0x5eb0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e26
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: multmodp
local crc_t multmodp(crc_t a, crc_t b) {
    crc_t m = (crc_t)1 << 31;
    crc_t p = 0;
    for (;;) {
        if (a & m) {
            p ^= b;
            if ((a & (m - 1)) == 0)
                break;
        }
        m >>= 1;
        b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x80000000, -0xc(%rbp) # imm = 0x80000000
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x5ef0
movl -0x8(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x5eee
jmp 0x5f22
jmp 0x5ef0
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5f12
movl -0x8(%rbp), %eax
shrl %eax
xorl $0xedb88320, %eax       # imm = 0xEDB88320
movl %eax, -0x14(%rbp)
jmp 0x5f1a
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x5ec8
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: num
local size_t num(char *arg) {
    char *str = arg;
    size_t val = 0;

    if (*str == 0)
        throw(EINVAL, "internal error: empty parameter");
    do {
        if (*str < '0' || *str > '9' ||
            (val && ((~(size_t)0) - (size_t)(*str - '0')) / val < 10))
            throw(EINVAL, "invalid numeric parameter: %s", arg);
        val = val * 10 + (size_t)(*str - '0');
    } while (*++str);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5f6f
movl $0x16, %edi
leaq 0x16764(%rip), %rsi     # 0x1c6c8
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x122d0
jmp 0x5f71
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x5fb5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x5fb5
cmpq $0x0, -0x18(%rbp)
je 0x5fd0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movslq %eax, %rcx
movq $-0x1, %rax
subq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq $0xa, %rax
jae 0x5fd0
movq -0x8(%rbp), %rdx
movl $0x16, %edi
leaq 0x16723(%rip), %rsi     # 0x1c6e8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x122d0
imulq $0xa, -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, 0x1(%rax)
jne 0x5f71
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: message
local void message(char *fmt, va_list ap) {
    if (g.verbosity > 0) {
        fprintf(stderr, "%s: ", g.prog);
        vfprintf(stderr, fmt, ap);
        putc('\n', stderr);
        fflush(stderr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x1d789(%rip)     # 0x237b0
jle 0x6082
movq 0x1cfc8(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq 0x1d74e(%rip), %rdx     # 0x23788
leaq 0x170fa(%rip), %rsi     # 0x1d13b
movb $0x0, %al
callq 0x3340
movq 0x1cfa9(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3500
movq 0x1cf92(%rip), %rax     # 0x22ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3310
movq 0x1cf7e(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
callq 0x33e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: grumble
local int grumble(char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    message(fmt, ap);
    va_end(ap);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x6135
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6010
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: compressed_suffix
local size_t compressed_suffix(char *nm) {
    size_t len;

    len = strlen(nm);
    if (len > 4) {
        nm += len - 4;
        len = 4;
        if (strcmp(nm, ".zip") == 0 || strcmp(nm, ".ZIP") == 0 ||
            strcmp(nm, ".tgz") == 0)
            return 4;
    }
    if (len > 3) {
        nm += len - 3;
        len = 3;
        if (strcmp(nm, ".gz") == 0 || strcmp(nm, "-gz") == 0 ||
            strcmp(nm, ".zz") == 0 || strcmp(nm, "-zz") == 0)
            return 3;
    }
    if (len > 2) {
        nm += len - 2;
        if (strcmp(nm, ".z") == 0 || strcmp(nm, "-z") == 0 ||
            strcmp(nm, "_z") == 0 || strcmp(nm, ".Z") == 0)
            return 2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jbe 0x6226
movq -0x18(%rbp), %rax
subq $0x4, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x4, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1624d(%rip), %rsi     # 0x1c430
callq 0x3320
cmpl $0x0, %eax
je 0x6217
movq -0x10(%rbp), %rdi
leaq 0x16f5c(%rip), %rsi     # 0x1d154
callq 0x3320
cmpl $0x0, %eax
je 0x6217
movq -0x10(%rbp), %rdi
leaq 0x16f4c(%rip), %rsi     # 0x1d159
callq 0x3320
cmpl $0x0, %eax
jne 0x6224
movq $0x4, -0x8(%rbp)
jmp 0x6327
jmp 0x6226
cmpq $0x3, -0x18(%rbp)
jbe 0x62a8
movq -0x18(%rbp), %rax
subq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x3, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x16127(%rip), %rsi     # 0x1c377
callq 0x3320
cmpl $0x0, %eax
je 0x6299
movq -0x10(%rbp), %rdi
leaq 0x16ee7(%rip), %rsi     # 0x1d14c
callq 0x3320
cmpl $0x0, %eax
je 0x6299
movq -0x10(%rbp), %rdi
leaq 0x16293(%rip), %rsi     # 0x1c50d
callq 0x3320
cmpl $0x0, %eax
je 0x6299
movq -0x10(%rbp), %rdi
leaq 0x16ec1(%rip), %rsi     # 0x1d150
callq 0x3320
cmpl $0x0, %eax
jne 0x62a6
movq $0x3, -0x8(%rbp)
jmp 0x6327
jmp 0x62a8
cmpq $0x2, -0x18(%rbp)
jbe 0x631f
movq -0x18(%rbp), %rax
subq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x16e76(%rip), %rsi     # 0x1d140
callq 0x3320
cmpl $0x0, %eax
je 0x6313
movq -0x10(%rbp), %rdi
leaq 0x16e64(%rip), %rsi     # 0x1d143
callq 0x3320
cmpl $0x0, %eax
je 0x6313
movq -0x10(%rbp), %rdi
leaq 0x16e52(%rip), %rsi     # 0x1d146
callq 0x3320
cmpl $0x0, %eax
je 0x6313
movq -0x10(%rbp), %rdi
leaq 0x16e40(%rip), %rsi     # 0x1d149
callq 0x3320
cmpl $0x0, %eax
jne 0x631d
movq $0x2, -0x8(%rbp)
jmp 0x6327
jmp 0x631f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: load_end
local void load_end(void) {
#ifndef NOTHREAD
    // if the read thread is running, then end it
    if (g.in_which != -1) {
        // wait for the previously requested read to complete and send the
        // thread a message to exit
        possess(g.load_state);
        wait_for(g.load_state, TO_BE, 0);
        twist(g.load_state, TO, 2);

        // join the thread (which has exited or will very shortly) and clean up
        join(g.load_thread);
        free_lock(g.load_state);
        g.in_which = -1;
    }
#endif
    g.in_left = 0;
    g.in_short = 1;
    g.in_eof = 1;
    if (g.ind != 0)
        close(g.ind);
    RELEASE(g.hname);
    RELEASE(g.hcomm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x2d065(%rip)    # 0x33910
je 0x6942
movq 0x2d060(%rip), %rdi     # 0x33918
leaq 0x1598b(%rip), %rsi     # 0x1c24a
movl $0xa4e, %edx            # imm = 0xA4E
callq 0x11900
movq 0x2d048(%rip), %rdi     # 0x33918
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x1596d(%rip), %rcx     # 0x1c24a
movl $0xa4f, %r8d            # imm = 0xA4F
callq 0x11a50
movq 0x2d029(%rip), %rdi     # 0x33918
xorl %esi, %esi
movl $0x2, %edx
leaq 0x1594d(%rip), %rcx     # 0x1c24a
movl $0xa50, %r8d            # imm = 0xA50
callq 0x119a0
movq 0x2d011(%rip), %rdi     # 0x33920
leaq 0x15934(%rip), %rsi     # 0x1c24a
movl $0xa53, %edx            # imm = 0xA53
callq 0x11ec0
movq 0x2cff1(%rip), %rdi     # 0x33918
leaq 0x1591c(%rip), %rsi     # 0x1c24a
movl $0xa54, %edx            # imm = 0xA54
callq 0x11c00
movl $0xffffffff, 0x2cfce(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x24f63(%rip) # 0x2b8b0
movl $0x1, 0x24f65(%rip)     # 0x2b8bc
movl $0x1, 0x24f57(%rip)     # 0x2b8b8
cmpl $0x0, 0x1ce28(%rip)     # 0x23790
je 0x6975
movl 0x1ce20(%rip), %edi     # 0x23790
callq 0x3270
jmp 0x6977
cmpq $0x0, 0x1ced1(%rip)     # 0x23850
je 0x6998
movq 0x1cec8(%rip), %rdi     # 0x23850
callq 0x3050
movq $0x0, 0x1ceb8(%rip) # 0x23850
jmp 0x699a
jmp 0x699c
cmpq $0x0, 0x1ceb4(%rip)     # 0x23858
je 0x69bd
movq 0x1ceab(%rip), %rdi     # 0x23858
callq 0x3050
movq $0x0, 0x1ce9b(%rip) # 0x23858
jmp 0x69bf
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: in_init
local void in_init(void) {
    g.in_left = 0;
    g.in_eof = 0;
    g.in_short = 0;
    g.in_tot = 0;
#ifndef NOTHREAD
    g.in_which = -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x24ed1(%rip) # 0x2b8b0
movl $0x0, 0x24ecf(%rip)     # 0x2b8b8
movl $0x0, 0x24ec9(%rip)     # 0x2b8bc
movq $0x0, 0x24ec2(%rip) # 0x2b8c0
movl $0xffffffff, 0x2cf08(%rip) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: alloc
local void *alloc(void *ptr, size_t size) {
    ptr = REALLOC(ptr, size);
    if (ptr == NULL)
        throw(ENOMEM, "not enough memory");
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3430
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xac9f
movl $0xc, %edi
leaq 0x127d3(%rip), %rsi     # 0x1d467
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x122d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: cat
local void cat(void) {
    // copy the first header byte read, if any
    if (g.magic1 != -1) {
        unsigned char buf[1] = {g.magic1};
        g.out_tot += writen(g.outd, buf, 1);
    }

    // copy the remainder of the input to the output
    while (g.in_left) {
        g.out_tot += writen(g.outd, g.in_next, g.in_left);
        g.in_left = 0;
        load();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x18b0d(%rip)    # 0x237cc
je 0xacec
movl 0x18b05(%rip), %eax     # 0x237cc
movb %al, -0x1(%rbp)
movl 0x18ac4(%rip), %edi     # 0x23794
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0xe2c0
addq 0x20be3(%rip), %rax     # 0x2b8c8
movq %rax, 0x20bdc(%rip)     # 0x2b8c8
jmp 0xacee
cmpq $0x0, 0x20bba(%rip)     # 0x2b8b0
je 0xad31
movl 0x18a96(%rip), %edi     # 0x23794
movq 0x20ba3(%rip), %rsi     # 0x2b8a8
movq 0x20ba4(%rip), %rdx     # 0x2b8b0
callq 0xe2c0
addq 0x20bb0(%rip), %rax     # 0x2b8c8
movq %rax, 0x20ba9(%rip)     # 0x2b8c8
movq $0x0, 0x20b86(%rip) # 0x2b8b0
callq 0xcd80
jmp 0xacee
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/madler[P]pigz/pigz.c
// Function: out_push
local void out_push(void) {
    if (g.outd == -1)
        return;
#if defined(F_FULLSYNC)
    int ret = fcntl(g.outd, F_FULLSYNC);
#elif defined(_WIN32)
    int ret = _commit(g.outd);
#else
    int ret = fsync(g.outd);
#endif
    if (ret == -1)
        throw(errno, "sync error on %s (%s)", g.outf, strerror(errno));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $-0x1, 0x17465(%rip)    # 0x23794
jne 0xc333
jmp 0xc385
movl 0x1745b(%rip), %edi     # 0x23794
callq 0x34c0
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0xc385
callq 0x3070
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x17450(%rip), %rax     # 0x237a8
movq %rax, -0x10(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x3590
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
movq %rax, %rcx
leaq 0x11694(%rip), %rsi     # 0x1da0d
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x122d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)