LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x20789
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1bbbf(%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 0x1076f(%rip), %rdi     # 0x30e8f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bb7f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x15, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x1077a(%rip), %rdi     # 0x30ec6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1bb53(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x14, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x11556(%rip), %rdi     # 0x31ccd
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_O1/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 0x2112a
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b226(%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 0x111c8(%rip), %rdi     # 0x32281
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b1e6(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x1(%rbx), %rdx
subl %r14d, %edx
addq $0x16, %rcx
movzbl 0x1(%rbx), %r8d
leaq 0x111d1(%rip), %rdi     # 0x322b6
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b1ba(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x17, %rcx
movzbl 0x2(%rbx), %r9d
movl %r9d, (%rsp)
leaq 0x111da(%rip), %rdi     # 0x322ee
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_O1/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 0x211e3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b165(%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 0x111ae(%rip), %rdi     # 0x32328
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b125(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x111b2(%rip), %rdi     # 0x32358
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b0f9(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0xb076(%rip), %rdi      # 0x2c247
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_O1/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 0x21288
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1b0a7(%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 0x11151(%rip), %rdi     # 0x3238a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1b066(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x1115c(%rip), %rdi     # 0x323bd
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x21130
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x213c5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b007(%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 0x1112b(%rip), %rdi     # 0x32403
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1afc7(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x1112e(%rip), %rdi     # 0x32432
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af9b(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x11133(%rip), %rdi     # 0x32463
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af6f(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x11136(%rip), %rdi     # 0x32492
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af43(%rip), %rcx     # 0x3c2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x1113b(%rip), %rdi     # 0x324c3
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1af17(%rip), %rcx     # 0x3c2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x8(%rbx), %r8d
leaq 0x1113c(%rip), %rdi     # 0x324ef
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_O1/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 0x2146a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1aec5(%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 0x10f6f(%rip), %rdi     # 0x3238a
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1ae84(%rip), %rcx     # 0x3c2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x30, %rcx
leaq 0x110d9(%rip), %rdi     # 0x3251c
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2128e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xb, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ae48(%rip), %r9d     # 0x3c2c0
testl %r9d, %r9d
sets %al
cmpl %edi, %r9d
setg %r8b
orb %al, %r8b
je 0x2148e
xorl %eax, %eax
jmp 0x214c7
leaq 0x1ae2b(%rip), %r8      # 0x3c2c0
xorl %eax, %eax
cmpl %edi, %r9d
jne 0x214b5
movl 0x4(%r8), %r9d
testl %r9d, %r9d
jle 0x214aa
cmpl (%rsi), %r9d
jne 0x214b5
movl 0x8(%r8), %r9d
cmpl (%rdx), %r9d
cmovleq %r8, %rax
movl 0x20(%r8), %r9d
testl %r9d, %r9d
js 0x214c7
addq $0x20, %r8
cmpl %edi, %r9d
jle 0x21497
testq %rax, %rax
je 0x214e7
movl 0x4(%rax), %edi
movl %edi, (%rsi)
movl 0x8(%rax), %esi
movl %esi, (%rdx)
testq %rcx, %rcx
je 0x214e2
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x20c9
leaq 0x100(%rsp), %r14
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x20e0
movq %r14, %rdi
callq 0x1626
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 0x165a
movl %eax, %ebx
movl %ebx, %eax
addq $0x2108, %rsp           # imm = 0x2108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1130
callq 0x1155
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
movl 0x19245(%rip), %eax     # 0x1d354
cmpl $-0x1, %eax
je 0x414b
cmpl $0x1, %eax
je 0x414b
movq 0x19248(%rip), %rdi     # 0x1d368
callq 0x3080
movq 0x1923c(%rip), %rdi     # 0x1d368
testq %rdi, %rdi
je 0x4141
callq 0x3050
movq $0x0, 0x19227(%rip) # 0x1d368
movl $0xffffffff, 0x19209(%rip) # imm = 0xFFFFFFFF
movl %ebx, %eax
negl %eax
testl %ebx, %ebx
movl $0x4, %edi
cmovsl %eax, %edi
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0x4, %r14d
callq 0x3520
movl $0xf, %ecx
xorl %edx, %edx
movzbl (%rax), %esi
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x419e
leal (%rdx,%rdx,4), %edx
leal (%rsi,%rdx,2), %edx
addl $-0x30, %edx
jmp 0x41b8
shlq $0x4, %rbx
cmpl $0xf, %edx
cmovgel %ecx, %edx
movslq %edx, %rdx
addq %rdx, %rbx
decl %r14d
xorl %edx, %edx
cmpl $0x2e, %esi
jne 0x41c3
incq %rax
testl %r14d, %r14d
jne 0x4187
xorl %r14d, %r14d
leal (,%r14,4), %ecx
shlq %cl, %rbx
cmpl $0x3, %r14d
movq $-0x1, %rax
cmovlq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0xd8, %rsp
testb %al, %al
je 0x47ad
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %rax
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r8, 0x20(%rax)
movq %r9, 0x28(%rax)
movl $0x1, 0x18b70(%rip)     # 0x1d340
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x66bb
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x663b
movl $0x3, %ecx
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0xebb4(%rip), %rdx      # 0x15190
testb $0x1, %dil
jne 0x65f9
movl %esi, %eax
movq %rdi, %r8
shrq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x65dc
jmp 0x663a
movl %ecx, %eax
andl $0x1f, %eax
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d       # imm = 0x80000000
testl %r8d, %r9d
je 0x661a
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0x65e4
shrl %r9d
movl %esi, %r10d
shrl %r10d
movl %r10d, %r11d
xorl $0xedb88320, %r11d      # imm = 0xEDB88320
testb $0x1, %sil
cmovel %r10d, %r11d
movl %r11d, %esi
jmp 0x660a
retq
movl $0x80000000, %eax       # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
cmpb $0x0, (%rdi)
je 0x66a6
movq %rdi, %rcx
incq %rdi
xorl %esi, %esi
movsbq -0x1(%rdi), %r8
leal -0x3a(%r8), %eax
cmpb $-0xa, %al
jb 0x668e
testq %rsi, %rsi
je 0x6674
movl $0x2f, %eax
subq %r8, %rax
xorl %edx, %edx
divq %rsi
cmpq $0x9, %rax
jbe 0x668e
leaq (%rsi,%rsi,4), %rax
leaq (%r8,%rax,2), %rsi
addq $-0x30, %rsi
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x664f
movq %rsi, %rax
popq %rcx
retq
leaq 0xf109(%rip), %rsi      # 0x1579e
movl $0x16, %edi
movq %rcx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe575
leaq 0xf0d1(%rip), %rsi      # 0x1577e
movl $0x16, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe575
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0xd8, %rsp
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6833
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
leaq 0xfa72(%rip), %rdi      # 0x162cc
callq 0x66bb
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x31a0
movq %rax, %r14
cmpq $0x5, %rax
jb 0x68d4
addq %r14, %rbx
addq $-0x4, %rbx
leaq 0xec5c(%rip), %rsi      # 0x154e6
movq %rbx, %rdi
callq 0x3320
movl $0x4, %r14d
testl %eax, %eax
je 0x699b
leaq 0xf963(%rip), %rsi      # 0x1620a
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
leaq 0xf951(%rip), %rsi      # 0x1620f
movq %rbx, %rdi
callq 0x3320
movl $0x4, %r14d
testl %eax, %eax
je 0x699b
cmpq $0x4, %r14
jb 0x693d
incq %rbx
leaq 0xeb49(%rip), %rsi      # 0x1542d
movq %rbx, %rdi
callq 0x3320
movl $0x3, %r14d
testl %eax, %eax
je 0x699b
leaq 0xf901(%rip), %rsi      # 0x16202
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
leaq 0xecab(%rip), %rsi      # 0x155c3
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
leaq 0xf8db(%rip), %rsi      # 0x16206
movq %rbx, %rdi
callq 0x3320
movl $0x3, %r14d
testl %eax, %eax
je 0x699b
cmpq $0x3, %r14
jne 0x6998
incq %rbx
leaq 0xf8a9(%rip), %rsi      # 0x161f6
movq %rbx, %rdi
callq 0x3320
movl $0x2, %r14d
testl %eax, %eax
je 0x699b
leaq 0xf893(%rip), %rsi      # 0x161f9
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
leaq 0xf883(%rip), %rsi      # 0x161fc
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
leaq 0xf873(%rip), %rsi      # 0x161ff
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x699b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl $-0x1, 0x26b22(%rip)    # 0x2d4d0
je 0x6a36
movq 0x26b1d(%rip), %rdi     # 0x2d4d8
leaq 0xe93e(%rip), %rbx      # 0x15300
movl $0xa4e, %edx            # imm = 0xA4E
movq %rbx, %rsi
callq 0xdf23
movq 0x26b02(%rip), %rdi     # 0x2d4d8
movl $0xa4f, %r8d            # imm = 0xA4F
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xdfde
movq 0x26ae9(%rip), %rdi     # 0x2d4d8
movl $0x2, %edx
movl $0xa50, %r8d            # imm = 0xA50
xorl %esi, %esi
movq %rbx, %rcx
callq 0xdf81
movq 0x26ad5(%rip), %rdi     # 0x2d4e0
movl $0xa53, %edx            # imm = 0xA53
movq %rbx, %rsi
callq 0xe280
movq 0x26ab9(%rip), %rdi     # 0x2d4d8
movl $0xa54, %edx            # imm = 0xA54
movq %rbx, %rsi
callq 0xe0a3
movl $0xffffffff, 0x26a9a(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x1ea2f(%rip) # 0x25470
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1ea26(%rip)     # 0x25478
movl 0x168f8(%rip), %edi     # 0x1d350
testl %edi, %edi
je 0x6a61
callq 0x3270
movq 0x169a8(%rip), %rdi     # 0x1d410
testq %rdi, %rdi
je 0x6a7d
callq 0x3050
movq $0x0, 0x16993(%rip) # 0x1d410
movq 0x16994(%rip), %rdi     # 0x1d418
testq %rdi, %rdi
je 0x6a99
callq 0x3050
movq $0x0, 0x1697f(%rip) # 0x1d418
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0x3430
testq %rax, %rax
je 0x9aff
popq %rcx
retq
leaq 0xc9ff(%rip), %rsi      # 0x16505
movl $0xc, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe575
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movl 0x1386d(%rip), %eax     # 0x1d38c
cmpl $-0x1, %eax
je 0x9b70
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl 0x13823(%rip), %edi     # 0x1d354
movl $0x1, %edx
callq 0xbcde
incq 0x1b946(%rip)           # 0x25488
jmp 0x9b70
movl 0x1380a(%rip), %edi     # 0x1d354
movq 0x1b917(%rip), %rsi     # 0x25468
movq %rbx, %rdx
callq 0xbcde
addq %rbx, 0x1b928(%rip)     # 0x25488
movq $0x0, 0x1b905(%rip) # 0x25470
callq 0xadbc
movq 0x1b8f9(%rip), %rbx     # 0x25470
testq %rbx, %rbx
jne 0x9b44
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: vmemcpy
local inline size_t vmemcpy(char **mem, size_t *size, size_t off,
                            void *cpy, size_t len) {
    size_t need;

    need = off + len;
    if (need < off)
        throw(ERANGE, "overflow");
    if (need > *size) {
        need = grow(need);
        if (off == 0) {
            RELEASE(*mem);
            *size = 0;
        }
        *mem = alloc(*mem, need);
        *size = need;
    }
    memcpy(*mem + off, cpy, len);
    return off + len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
addq %rdx, %r14
jb 0xa8c7
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r13
cmpq (%rsi), %r14
jbe 0xa8a3
movq %rcx, (%rsp)
movq %r14, %rax
shrq $0x2, %rax
addq %r14, %rax
movl $0x3, %ecx
movq %rax, %rdx
cmpq $0x8, %rax
jb 0xa83d
movq %rax, %rsi
movq %rax, %rdx
shrq %rdx
incq %rcx
cmpq $0xf, %rsi
movq %rdx, %rsi
ja 0xa82e
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdx
cmoveq %rsi, %rax
cmpq $0x11, %rax
movl $0x10, %ecx
cmovaeq %rax, %rcx
cmpq %r14, %rcx
movq $-0x1, %r15
cmovaq %rcx, %r15
testq %r12, %r12
jne 0xa88b
movq (%r13), %rdi
testq %rdi, %rdi
je 0xa883
callq 0x3050
movq $0x0, (%r13)
movq $0x0, (%rbp)
movq (%r13), %rdi
movq %r15, %rsi
callq 0x9af2
movq %rax, (%r13)
movq %r15, (%rbp)
movq (%rsp), %rcx
addq (%r13), %r12
movq %r12, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
callq 0x3360
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbbed(%rip), %rsi      # 0x164bb
movl $0x22, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe575
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: load_wait
local void load_wait(void) {
    if (g.in_which == -1)
        return;
    possess(g.load_state);
    wait_for(g.load_state, TO_BE, 0);
    release(g.load_state);
}

// Assembly:
cmpl $-0x1, 0x22bed(%rip)    # 0x2d4d0
je 0xa92f
pushq %rbx
movq 0x22beb(%rip), %rdi     # 0x2d4d8
leaq 0xaa0c(%rip), %rbx      # 0x15300
movl $0x9fd, %edx            # imm = 0x9FD
movq %rbx, %rsi
callq 0xdf23
movq 0x22bd0(%rip), %rdi     # 0x2d4d8
movl $0x9fe, %r8d            # imm = 0x9FE
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xdfde
movq 0x22bb7(%rip), %rdi     # 0x2d4d8
movl $0x9ff, %edx            # imm = 0x9FF
movq %rbx, %rsi
popq %rbx
jmp 0xdf52
retq
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: readn
local size_t readn(int desc, unsigned char *buf, size_t len) {
    ssize_t ret;
    size_t got;

    got = 0;
    while (len) {
        ret = read(desc, buf, len);
        if (ret < 0)
            throw(errno, "read error on %s (%s)", g.inf, strerror(errno));
        if (ret == 0)
            break;
        buf += ret;
        len -= (size_t)ret;
        got += (size_t)ret;
    }
    return got;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xaf86
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x32c0
testq %rax, %rax
js 0xaf96
je 0xaf88
addq %rax, %r15
addq %rax, %rbx
subq %rax, %r14
jne 0xaf65
jmp 0xaf88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x123b4(%rip), %r14     # 0x1d358
movl %ebx, %edi
callq 0x35a0
leaq 0xb361(%rip), %rsi      # 0x16313
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe575
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: dos2time
local time_t dos2time(unsigned long dos) {
    struct tm tm;

    if (dos == 0)
        return time(NULL);
    tm.tm_year = ((int)(dos >> 25) & 0x7f) + 80;
    tm.tm_mon  = ((int)(dos >> 21) & 0xf) - 1;
    tm.tm_mday = (int)(dos >> 16) & 0x1f;
    tm.tm_hour = (int)(dos >> 11) & 0x1f;
    tm.tm_min  = (int)(dos >> 5) & 0x3f;
    tm.tm_sec  = (int)(dos << 1) & 0x3e;
    tm.tm_isdst = -1;           // figure out if DST or not
    return mktime(&tm);
}

// Assembly:
testq %rdi, %rdi
je 0xb229
subq $0x38, %rsp
movl %edi, %ecx
shrl $0x19, %ecx
addl $0x50, %ecx
movq %rsp, %rax
movl %ecx, 0x14(%rax)
movl %edi, %ecx
shrl $0x15, %ecx
andl $0xf, %ecx
decl %ecx
movl %ecx, 0x10(%rax)
movl %edi, %ecx
shrl $0x10, %ecx
andl $0x1f, %ecx
movl %ecx, 0xc(%rax)
movl %edi, %ecx
shrl $0xb, %ecx
andl $0x1f, %ecx
movl %ecx, 0x8(%rax)
movl %edi, %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movl %ecx, 0x4(%rax)
addl %edi, %edi
andl $0x3e, %edi
movl %edi, (%rax)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x3400
addq $0x38, %rsp
retq
xorl %edi, %edi
jmp 0x3380
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: crc32z
local unsigned long crc32z(unsigned long crc,
                           unsigned char const *buf, size_t len) {
    while (len > UINT_MAX && buf != NULL) {
        crc = crc32(crc, buf, UINT_MAX);
        buf += UINT_MAX;
        len -= UINT_MAX;
    }
    return crc32(crc, buf, (unsigned)len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movq %rdx, %rcx
shrq $0x20, %rcx
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0xbb53
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movabsq $-0xffffffff, %r12      # imm = 0xFFFFFFFF00000001
addq %r12, %rbx
movq %rax, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3120
addq %r15, %r14
movq %rbx, %rcx
shrq $0x20, %rcx
jne 0xbb34
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: inb
local unsigned inb(void *desc, unsigned char **buf) {
    (void)desc;
    if (g.in_left == 0)
        load();
    *buf = g.in_next;
    unsigned len = g.in_left > UINT_MAX ? UINT_MAX : (unsigned)g.in_left;
    g.in_next += len;
    g.in_left -= len;
    return len;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x198f9(%rip)     # 0x25470
jne 0xbb7e
callq 0xadbc
movq 0x198e3(%rip), %rax     # 0x25468
movq %rax, (%rbx)
movq 0x198e1(%rip), %rcx     # 0x25470
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rcx
cmovbq %rcx, %rax
addq %rax, 0x198c6(%rip)     # 0x25468
subq %rax, %rcx
movq %rcx, 0x198c4(%rip)     # 0x25470
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: adler32_comb
local unsigned long adler32_comb(unsigned long adler1, unsigned long adler2,
                                 size_t len2) {
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    // the derivation of this formula is left as an exercise for the reader
    rem = (unsigned)(len2 % BASE);
    sum1 = adler1 & LOW16;
    sum2 = (rem * sum1) % BASE;
    sum1 += (adler2 & LOW16) + BASE - 1;
    sum2 += ((adler1 >> 16) & LOW16) + ((adler2 >> 16) & LOW16) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
movq %rdx, %rcx
movabsq $0xf00e10d2fc5cd, %rdx  # imm = 0xF00E10D2FC5CD
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %rcx
movl $0xffff, %r9d           # imm = 0xFFFF
movq %rdi, %r10
andq %r9, %r10
movq %rcx, %r8
imulq %r10, %r8
movabsq $0x1000f00e10d30, %rdx  # imm = 0x1000F00E10D30
movq %r8, %rax
mulq %rdx
andq %rsi, %r9
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
imulq $0xfff1, %rdx, %rax     # imm = 0xFFF1
subq %rax, %r8
leaq (%r10,%r9), %rax
addl $0xfff0, %eax           # imm = 0xFFF0
addq %r8, %rsi
movl $0xfff1, %ecx           # imm = 0xFFF1
leaq (%rsi,%rcx), %rdx
cmpl $0xfff1, %eax           # imm = 0xFFF1
leaq -0x1(%r10,%r9), %rax
movl $0xfff0, %edi           # imm = 0xFFF0
cmovaeq %rax, %rdi
movq $-0xfff1, %rax          # imm = 0xFFFF000F
leaq (%rdi,%rax), %r8
cmpq %rcx, %rdi
cmovbq %rdi, %r8
addq %rax, %rsi
cmpq $0x1ffe2, %rdx          # imm = 0x1FFE2
cmovbq %rdx, %rsi
movq %rsi, %rdx
shlq $0x10, %rdx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rdx, %rax
cmpq %rcx, %rsi
cmovbq %rdx, %rax
orq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: writen
local size_t writen(int desc, void const *buf, size_t len) {
    char const *next = buf;
    size_t left = len;

    while (left) {
        size_t const max = SSIZE_MAX;
        ssize_t ret = write(desc, next, left > max ? max : left);
        if (ret < 1)
            throw(errno, "write error on %s (%s)", g.outf, strerror(errno));
        next += ret;
        left -= (size_t)ret;
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0xbd21
movq %rsi, %r14
movl %edi, %ebp
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x3130
testq %rax, %rax
jle 0xbd2d
addq %rax, %r14
subq %rax, %r12
jne 0xbd00
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x1162d(%rip), %r14     # 0x1d368
movl %ebx, %edi
callq 0x35a0
leaq 0xa72e(%rip), %rsi      # 0x16477
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe575
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: outb_write
local void outb_write(void *dummy) {
    size_t len;
    ball_t err;                     // error information from throw()

    (void)dummy;

    Trace(("-- launched decompress write thread"));
    try {
        do {
            possess(outb_write_more);
            wait_for(outb_write_more, TO_BE, 1);
            len = out_len;
            if (len && g.decode == 1)
                writen(g.outd, out_copy, len);
            Trace(("-- decompress wrote %lu bytes", len));
            twist(outb_write_more, TO, 0);
        } while (len);
    }
    catch (err) {
        THREADABORT(err);
    }
    Trace(("-- exited decompress write thread"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl $0x1, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe508
leaq 0x318d5(%rip), %r14     # 0x3d674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0xbee4
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xbe5e
leaq 0x9526(%rip), %rbx      # 0x15300
xorl %ebp, %ebp
movl $0x1, %r15d
movl $0xd1a, %r12d           # imm = 0xD1A
movl $0xd1f, %r13d           # imm = 0xD1F
movq 0x2970b(%rip), %rdi     # 0x35500
movq %rbx, %rsi
movl $0xd19, %edx            # imm = 0xD19
callq 0xdf23
movq 0x296f7(%rip), %rdi     # 0x35500
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0xdfde
movq 0x296f0(%rip), %r14     # 0x35510
testq %r14, %r14
je 0xbe43
cmpl $0x1, 0x1159c(%rip)     # 0x1d3c8
jne 0xbe43
movl 0x11520(%rip), %edi     # 0x1d354
leaq 0x296e5(%rip), %rsi     # 0x35520
movq %r14, %rdx
callq 0xbcde
movq 0x296b6(%rip), %rdi     # 0x35500
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r13, %r8
callq 0xdf81
testq %r14, %r14
jne 0xbdee
cmpl $0x0, 0xc(%rsp)
je 0xbe8b
leaq 0x31808(%rip), %rax     # 0x3d674
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0xbf03
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xbea8
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xe0(%rsp), %r14d
movq 0xe8(%rsp), %rbx
cmpl $0x20, %ebp
je 0xbece
leaq 0x9548(%rip), %rdi      # 0x1540c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x476b
testl %r14d, %r14d
je 0xbedb
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x4106
leaq 0x93e5(%rip), %rdi      # 0x152d0
leaq 0x940e(%rip), %rsi      # 0x15300
leaq 0xa963(%rip), %rcx      # 0x1685c
movl $0xd17, %edx            # imm = 0xD17
callq 0x3220
leaq 0x93c6(%rip), %rdi      # 0x152d0
leaq 0x93ef(%rip), %rsi      # 0x15300
leaq 0xa944(%rip), %rcx      # 0x1685c
movl $0xd22, %edx            # imm = 0xD22
callq 0x3220
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: outb_check
local void outb_check(void *dummy) {
    size_t len;
    ball_t err;                     // error information from throw()

    (void)dummy;

    Trace(("-- launched decompress check thread"));
    try {
        do {
            possess(outb_check_more);
            wait_for(outb_check_more, TO_BE, 1);
            len = out_len;
            g.out_check = CHECK(g.out_check, out_copy, len);
            Trace(("-- decompress checked %lu bytes", len));
            twist(outb_check_more, TO, 0);
        } while (len);
    }
    catch (err) {
        THREADABORT(err);
    }
    Trace(("-- exited decompress check thread"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl $0x1, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe508
leaq 0x3170e(%rip), %r14     # 0x3d674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0xc0ba
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xc034
leaq 0x935f(%rip), %rbx      # 0x15300
xorl %ebp, %ebp
movl $0xd33, %r12d           # imm = 0xD33
leaq 0x29570(%rip), %r13     # 0x35520
movl $0xd37, %r14d           # imm = 0xD37
movq 0x2954b(%rip), %rdi     # 0x35508
movq %rbx, %rsi
movl $0xd32, %edx            # imm = 0xD32
callq 0xdf23
movq 0x29537(%rip), %rdi     # 0x35508
movl %ebp, %esi
movl $0x1, %edx
movq %rbx, %rcx
movq %r12, %r8
callq 0xdfde
movq 0x29526(%rip), %r15     # 0x35510
cmpl $0x1, 0x11397(%rip)     # 0x1d388
movq 0x19498(%rip), %rdi     # 0x25490
jne 0xc007
movl %r15d, %edx
movq %r13, %rsi
callq 0x3390
jmp 0xc012
movq %r13, %rsi
movq %r15, %rdx
callq 0xbaff
movq %rax, 0x19477(%rip)     # 0x25490
movq 0x294e8(%rip), %rdi     # 0x35508
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xdf81
testq %r15, %r15
jne 0xbfb6
cmpl $0x0, 0xc(%rsp)
je 0xc061
leaq 0x31632(%rip), %rax     # 0x3d674
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0xc0d9
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xc07e
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xe0(%rsp), %r14d
movq 0xe8(%rsp), %rbx
cmpl $0x20, %ebp
je 0xc0a4
leaq 0x9372(%rip), %rdi      # 0x1540c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x476b
testl %r14d, %r14d
je 0xc0b1
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x4106
leaq 0x920f(%rip), %rdi      # 0x152d0
leaq 0x9238(%rip), %rsi      # 0x15300
leaq 0xa7a5(%rip), %rcx      # 0x16874
movl $0xd30, %edx            # imm = 0xD30
callq 0x3220
leaq 0x91f0(%rip), %rdi      # 0x152d0
leaq 0x9219(%rip), %rsi      # 0x15300
leaq 0xa786(%rip), %rcx      # 0x16874
movl $0xd3a, %edx            # imm = 0xD3A
callq 0x3220
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: get_space
space *get_space(struct pool *pool) {
    struct space *space;

    // if can't create any more, wait for a space to show up
    possess(pool->have);
    if (pool->limit == 0)
        wait_for(pool->have, NOT_TO_BE, 0);

    // if a space is available, pull it from the list and return it
    if (pool->head != NULL) {
        space = pool->head;
        pool->head = space->next;
        twist(pool->have, BY, -1);      // one less in pool
        possess(space->use);
        twist(space->use, TO, 1);       // initially one user
        space->len = 0;
        return space;
    }

    // nothing available, don't want to wait, make a new space
    assert(pool->limit != 0);
    if (pool->limit > 0)
        pool->limit--;
    pool->made++;
    release(pool->have);
    space = alloc(NULL, sizeof(struct space));
    space->use = new_lock(1);           // initially one user
    space->buf = alloc(NULL, pool->size);
    space->size = pool->size;
    space->len = 0;
    space->pool = pool;                 // remember the pool this belongs to
    return space;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8e29(%rip), %rsi      # 0x15300
movl $0x5bf, %edx            # imm = 0x5BF
callq 0xdf23
cmpl $0x0, 0x18(%rbx)
jne 0xc503
movq (%rbx), %rdi
leaq 0x8e0f(%rip), %rcx      # 0x15300
movl $0x5c1, %r8d            # imm = 0x5C1
movl $0x1, %esi
xorl %edx, %edx
callq 0xdfde
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xc56a
movq 0x28(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x8de2(%rip), %rbx      # 0x15300
movl $0x5c7, %r8d            # imm = 0x5C7
movl $0x1, %esi
movq $-0x1, %rdx
movq %rbx, %rcx
callq 0xdf81
movq (%r14), %rdi
movl $0x5c8, %edx            # imm = 0x5C8
movq %rbx, %rsi
callq 0xdf23
movq (%r14), %rdi
movl $0x1, %edx
movl $0x5c9, %r8d            # imm = 0x5C9
xorl %esi, %esi
movq %rbx, %rcx
callq 0xdf81
movq $0x0, 0x18(%r14)
jmp 0xc5d9
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0xc5e2
jle 0xc578
decl %eax
movl %eax, 0x18(%rbx)
incl 0x1c(%rbx)
movq (%rbx), %rdi
leaq 0x8d7b(%rip), %r15      # 0x15300
movl $0x5d3, %edx            # imm = 0x5D3
movq %r15, %rsi
callq 0xdf52
movl $0x30, %esi
xorl %edi, %edi
callq 0x9af2
movq %rax, %r14
movl $0x1, %edi
movl $0x5d5, %edx            # imm = 0x5D5
movq %r15, %rsi
callq 0xddaf
movq %rax, (%r14)
movq 0x10(%rbx), %rsi
xorl %edi, %edi
callq 0x9af2
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa336(%rip), %rdi      # 0x1691f
leaq 0x8d10(%rip), %rsi      # 0x15300
leaq 0xa339(%rip), %rcx      # 0x16930
movl $0x5cf, %edx            # imm = 0x5CF
callq 0x3220
// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: append_len
local void append_len(struct job *job, size_t len) {
    struct space *lens;

    assert(len < 539000896UL);
    if (job->lens == NULL)
        job->lens = get_space(&lens_pool);
    lens = job->lens;
    if (lens->size < lens->len + 3)
        grow_space(lens);
    if (len < 64)
        lens->buf[lens->len++] = (unsigned char)(len + 128);
    else if (len < 32832U) {
        len -= 64;
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
    else if (len < 2129984UL) {
        len -= 32832U;
        lens->buf[lens->len++] = (unsigned char)((len >> 16) + 192);
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
    else {
        len -= 2129984UL;
        lens->buf[lens->len++] = (unsigned char)((len >> 24) + 224);
        lens->buf[lens->len++] = (unsigned char)(len >> 16);
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x20208040, %rsi       # imm = 0x20208040
jae 0xc727
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xc632
leaq 0x30f95(%rip), %rdi     # 0x3d5b8
movq %rsi, %r14
callq 0xc4c5
movq %r14, %rsi
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rax
addq $0x3, %rax
cmpq %rax, 0x10(%rbx)
jae 0xc652
movq %rbx, %rdi
movq %rsi, %r14
callq 0xdbb6
movq %r14, %rsi
cmpq $0x3f, %rsi
ja 0xc661
orb $-0x80, %sil
jmp 0xc70b
cmpq $0x803f, %rsi           # imm = 0x803F
ja 0xc683
addq $-0x40, %rsi
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq %rsi, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
jmp 0xc6c3
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq %rsi, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
cmpq $0x20803f, %rsi         # imm = 0x20803F
ja 0xc6c8
addq $-0x8040, %rax          # imm = 0xFFFF7FC0
movl %eax, %edx
shrl $0x10, %edx
addb $-0x40, %dl
movb %dl, (%rdi,%rcx)
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %rax, %rsi
movb %ah, (%rdi,%rcx)
jmp 0xc70b
addq $-0x208040, %rax        # imm = 0xFFDF7FC0
movl %eax, %edx
movq %rax, %r8
shrl $0x18, %edx
addb $-0x20, %dl
movb %dl, (%rdi,%rcx)
shrl $0x10, %eax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%rbx)
movb %al, (%rcx,%rdx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %r8, %rdx
movq %r8, %rsi
movb %dh, (%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movb %sil, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xa229(%rip), %rdi      # 0x16957
leaq 0x8bcb(%rip), %rsi      # 0x15300
leaq 0xa22d(%rip), %rcx      # 0x16969
movl $0x7fa, %edx            # imm = 0x7FA
callq 0x3220