LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x205b1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1cd93(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0x10, %rcx
movzwl (%rbx), %r8d
leaq 0x10dbd(%rip), %rdi     # 0x31305
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cd57(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0x10, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x10dc1(%rip), %rdi     # 0x31335
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cd2b(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0xac85(%rip), %rdi      # 0x2b224
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20650
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ccdb(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x11, %rcx
movzbl (%r14), %r8d
leaq 0x10d66(%rip), %rdi     # 0x31367
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cc9e(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x32, %rcx
leaq 0x10d71(%rip), %rdi     # 0x3139a
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20502
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mikebdp2[P]AtomDis/./datastructs_gen.c
// Function: ATOM_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 0x20787
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1cc41(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r15
leaq (%rcx,%r15), %rsi
movl %ebx, %edx
subl %r14d, %edx
addq $0xf, %rcx
movzwl (%rbx), %r8d
leaq 0x10d46(%rip), %rdi     # 0x313e0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cc05(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x2(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x2(%rbx), %r8d
leaq 0x10d49(%rip), %rdi     # 0x3140f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cbd9(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x3(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzwl 0x3(%rbx), %r8d
leaq 0x10d4e(%rip), %rdi     # 0x31440
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cbad(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x5(%rbx), %rdx
subl %r14d, %edx
addq $0xf, %rcx
movzbl 0x5(%rbx), %r8d
leaq 0x10d51(%rip), %rdi     # 0x3146f
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cb81(%rip), %rcx     # 0x3d2b0
leaq (%rcx,%r15), %rsi
leaq 0x6(%rbx), %rdx
subl %r14d, %edx
addq $0xc, %rcx
movzwl 0x6(%rbx), %r8d
leaq 0x10d56(%rip), %rdi     # 0x314a0
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cb55(%rip), %rcx     # 0x3d2b0
addq %rcx, %r15
leaq 0x8(%rbx), %rdx
subl %r14d, %edx
addq $0xd, %rcx
movzwl 0x8(%rbx), %r8d
leaq 0x10d57(%rip), %rdi     # 0x314cc
movq %r15, %rsi
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
popq %rbx
popq %r14
popq %r15
pushq $0xa
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20826
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1cb05(%rip), %rcx     # 0x3d2b0
cmpl $0x19, %edx
pushq $0x19
popq %rax
cmovll %edx, %eax
addl %eax, %eax
pushq $0x32
popq %rdx
subl %eax, %edx
movslq %edx, %r12
leaq (%rcx,%r12), %rsi
movl %r14d, %edx
subl %r15d, %edx
addq $0x11, %rcx
movzbl (%r14), %r8d
leaq 0x10b90(%rip), %rdi     # 0x31367
movl %r8d, %r9d
xorl %eax, %eax
callq 0x40b0
movq 0x1cac8(%rip), %rcx     # 0x3d2b0
addq %rcx, %r12
incq %r14
movl %r14d, %edx
subl %r15d, %edx
addq $0x30, %rcx
leaq 0x10cfa(%rip), %rdi     # 0x314f9
movq %r12, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x40b0
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20654
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
pushq $0xb
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x1ca8e(%rip), %r8      # 0x3d2c0
xorl %eax, %eax
movl (%r8), %r9d
testl %r9d, %r9d
js 0x20862
cmpl %edi, %r9d
jg 0x20862
jne 0x2085c
movl 0x4(%r8), %r9d
testl %r9d, %r9d
jle 0x20851
cmpl (%rsi), %r9d
jne 0x2085c
movl 0x8(%r8), %r9d
cmpl (%rdx), %r9d
cmovleq %r8, %rax
addq $0x20, %r8
jmp 0x20834
testq %rax, %rax
je 0x20882
movl 0x4(%rax), %edi
movl %edi, (%rsi)
movl 0x8(%rax), %esi
movl %esi, (%rdx)
testq %rcx, %rcx
je 0x2087d
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rax
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x12f1
movq %rsi, %r14
movq 0x8(%rsi), %rdi
pushq $0x2
popq %rbx
movl %ebx, %esi
xorl %eax, %eax
callq 0x10e0
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
movl $0x20000, %esi          # imm = 0x20000
xorl %edi, %edi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x1070
movq %rax, 0x3e44(%rip)      # 0x50a8
cmpq $-0x1, %rax
je 0x130f
callq 0x1324
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 0x1f5f
leaq 0x100(%rsp), %r14
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f76
movq %r14, %rdi
callq 0x15ab
cmpl $-0x1, %eax
je 0x12e1
movl %eax, %ebp
movq %rsp, %rsi
movl %eax, %edi
callq 0x1393
testl %eax, %eax
jle 0x12d5
pushq $0x11
popq %rbx
jmp 0x12e1
movq %rsp, %rsi
movl %ebp, %edi
callq 0x15d7
movl %eax, %ebx
movl %ebx, %eax
addq $0x2108, %rsp           # imm = 0x2108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3d00(%rip), %rax      # 0x4ff8
movq (%rax), %rcx
leaq 0x1d02(%rip), %rdi      # 0x3004
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
callq 0x1110
jmp 0x131b
leaq 0x1d23(%rip), %rdi      # 0x3039
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1100
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1858b(%rip), %eax     # 0x1c354
cmpl $-0x1, %eax
je 0x3dff
cmpl $0x1, %eax
je 0x3dff
movq 0x1858e(%rip), %rdi     # 0x1c368
callq 0x3080
movq 0x18582(%rip), %rdi     # 0x1c368
testq %rdi, %rdi
je 0x3df8
callq 0x3050
andq $0x0, 0x18570(%rip)     # 0x1c368
orl $-0x1, 0x18555(%rip)    # 0x1c354
movl %ebx, %eax
negl %eax
testl %ebx, %ebx
pushq $0x4
popq %rdi
cmovsl %eax, %edi
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %r14
callq 0x3520
pushq $0xf
popq %rdx
xorl %esi, %esi
movzbl (%rax), %edi
leal -0x30(%rdi), %ecx
cmpb $0x9, %cl
ja 0x3e4b
imull $0xa, %esi, %ecx
leal (%rcx,%rdi), %esi
addl $-0x30, %esi
jmp 0x3e6c
movq %rbx, %rcx
shlq $0x4, %rcx
cmpl $0xf, %esi
cmovgel %edx, %esi
movslq %esi, %rbx
addq %rcx, %rbx
leal -0x1(%r14), %ecx
xorl %esi, %esi
cmpl $0x2e, %edi
jne 0x3e76
movl %ecx, %r14d
incq %rax
testl %r14d, %r14d
jne 0x3e35
jmp 0x3e87
shll $0x2, %ecx
shlq %cl, %rbx
cmpl $0x4, %r14d
pushq $-0x1
popq %rax
cmovgeq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x17fa9(%rip)     # 0x1c370
jne 0x43ca
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x17c17(%rip), %r14     # 0x1bff0
leaq 0xfe30(%rip), %r15      # 0x14210
leaq 0x11460(%rip), %rbx     # 0x15847
xorl %r12d, %r12d
movq (%r14), %rdi
cmpq $0xa8, %r12
je 0x440d
movslq (%r12,%r15), %rdx
addq %r15, %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3340
addq $0x4, %r12
jmp 0x43ea
callq 0x33e0
xorl %edi, %edi
callq 0x3540
// File: /workspace/github_c_makefile_star2_O2/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 0x445b
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, 0x17ec2(%rip)     # 0x1c340
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x5dec
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x80000000, %eax       # imm = 0x80000000
pushq $0x3
popq %rbp
leaq 0xe477(%rip), %r14      # 0x14190
testq %rbx, %rbx
je 0x5d3a
testb $0x1, %bl
je 0x5d33
movl %ebp, %ecx
andl $0x1f, %ecx
movl (%r14,%rcx,4), %edi
movl %eax, %esi
callq 0x5d3f
shrq %rbx
incl %ebp
jmp 0x5d19
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movl $0x80000000, %ecx       # imm = 0x80000000
testl %edi, %ecx
je 0x5d53
xorl %esi, %eax
leal -0x1(%rcx), %edx
testl %edi, %edx
je 0x5d70
shrl %ecx
movl %esi, %edx
shrl %edx
movl %edx, %r8d
xorl $0xedb88320, %r8d       # imm = 0xEDB88320
testb $0x1, %sil
cmovel %edx, %r8d
movl %r8d, %esi
jmp 0x5d46
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rcx
movb (%rdi), %dil
testb %dil, %dil
je 0x5dd9
leaq 0x1(%rcx), %r8
xorl %esi, %esi
leal -0x3a(%rdi), %eax
cmpb $-0xa, %al
jb 0x5dc3
testq %rsi, %rsi
je 0x5da3
movb $0x2f, %al
subb %dil, %al
movsbq %al, %rax
xorl %edx, %edx
divq %rsi
cmpq $0x9, %rax
jbe 0x5dc3
imulq $0xa, %rsi, %rax
movzbl %dil, %edx
leaq (%rax,%rdx), %rsi
addq $-0x30, %rsi
movb (%r8), %dil
incq %r8
testb %dil, %dil
jne 0x5d83
movq %rsi, %rax
popq %rcx
retq
leaq 0xe9d4(%rip), %rsi      # 0x1479e
pushq $0x16
popq %rdi
movq %rcx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xdd45
leaq 0xe99e(%rip), %rsi      # 0x1477e
pushq $0x16
popq %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xdd45
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x1657d(%rip)     # 0x1c370
jg 0x5df6
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x161e8(%rip), %r15     # 0x1bff0
movq (%r15), %rdi
movq 0x16536(%rip), %rdx     # 0x1c348
leaq 0xf3d8(%rip), %rsi      # 0x151f1
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3500
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3310
movq (%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x33e0
// File: /workspace/github_c_makefile_star2_O2/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 0x5edd
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 0xf3d0(%rip), %rdi      # 0x152d4
callq 0x5dec
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x5, %rax
jb 0x5f74
addq %rax, %rbx
addq $-0x4, %rbx
leaq 0xe5b5(%rip), %rsi      # 0x144e6
movq %rbx, %rdi
callq 0x3320
pushq $0x4
popq %r14
testl %eax, %eax
je 0x6017
leaq 0xf2be(%rip), %rsi      # 0x1520a
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x6017
leaq 0xf2ac(%rip), %rsi      # 0x1520f
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
jne 0x5f84
jmp 0x6017
cmpq $0x3, %rax
je 0x5fd7
cmpq $0x4, %rax
jne 0x6014
incq %rbx
leaq 0xe49f(%rip), %rsi      # 0x1442d
movq %rbx, %rdi
callq 0x3320
pushq $0x3
popq %r14
testl %eax, %eax
je 0x6017
leaq 0xf25d(%rip), %rsi      # 0x15202
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x6017
leaq 0xe60b(%rip), %rsi      # 0x145c3
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x6017
leaq 0xf23b(%rip), %rsi      # 0x15206
movq %rbx, %rdi
callq 0x3320
testl %eax, %eax
je 0x6017
movzbl 0x1(%rbx), %eax
cmpl $0x2d, %eax
je 0x6008
cmpl $0x5f, %eax
je 0x6008
cmpl $0x2e, %eax
jne 0x6014
cmpb $0x7a, 0x2(%rbx)
pushq $0x2
popq %r14
jne 0x5ffa
cmpb $0x0, 0x3(%rbx)
je 0x6017
cmpb $0x5a, 0x2(%rbx)
jne 0x6014
cmpb $0x0, 0x3(%rbx)
jne 0x6014
jmp 0x6017
cmpb $0x7a, 0x2(%rbx)
jne 0x6014
cmpb $0x0, 0x3(%rbx)
je 0x6022
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x2
popq %r14
jmp 0x6017
// File: /workspace/github_c_makefile_star2_O2/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, 0x26484(%rip)    # 0x2c4d0
je 0x60cb
movq 0x26483(%rip), %rdi     # 0x2c4d8
leaq 0xe2a4(%rip), %rbx      # 0x14300
movl $0xa4e, %edx            # imm = 0xA4E
movq %rbx, %rsi
callq 0xd763
movq 0x26468(%rip), %rdi     # 0x2c4d8
movl $0xa4f, %r8d            # imm = 0xA4F
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd81e
movq 0x2644f(%rip), %rdi     # 0x2c4d8
pushq $0x2
popq %rdx
movl $0xa50, %r8d            # imm = 0xA50
xorl %esi, %esi
movq %rbx, %rcx
callq 0xd7c1
movq 0x2643d(%rip), %rdi     # 0x2c4e0
movl $0xa53, %edx            # imm = 0xA53
movq %rbx, %rsi
callq 0xda9f
movq 0x26421(%rip), %rdi     # 0x2c4d8
movl $0xa54, %edx            # imm = 0xA54
movq %rbx, %rsi
callq 0xd8e3
orl $-0x1, 0x26405(%rip)    # 0x2c4d0
andq $0x0, 0x1e39d(%rip)     # 0x24470
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1e394(%rip)     # 0x24478
movl 0x16266(%rip), %edi     # 0x1c350
testl %edi, %edi
je 0x60f3
callq 0x3270
movq 0x16316(%rip), %rdi     # 0x1c410
testq %rdi, %rdi
je 0x610c
callq 0x3050
andq $0x0, 0x16304(%rip)     # 0x1c410
movq 0x16305(%rip), %rdi     # 0x1c418
testq %rdi, %rdi
je 0x6125
callq 0x3050
andq $0x0, 0x162f3(%rip)     # 0x1c418
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9dc3
popq %rcx
retq
leaq 0xb743(%rip), %rsi      # 0x1550d
pushq $0xc
popq %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xdd45
// File: /workspace/github_c_makefile_star2_O2/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 0x125ab(%rip), %eax     # 0x1c38c
cmpl $-0x1, %eax
je 0x9e2d
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl 0x12561(%rip), %edi     # 0x1c354
pushq $0x1
popq %rdx
callq 0xb58d
incq 0x1a686(%rip)           # 0x24488
jmp 0x9e2d
movl 0x1254a(%rip), %edi     # 0x1c354
movq 0x1a657(%rip), %rsi     # 0x24468
movq %rbx, %rdx
callq 0xb58d
addq %rbx, 0x1a668(%rip)     # 0x24488
andq $0x0, 0x1a648(%rip)     # 0x24470
callq 0xb020
movq 0x1a63c(%rip), %rbx     # 0x24470
testq %rbx, %rbx
jne 0x9e04
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab35
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpq (%rsi), %r14
jbe 0xab11
movq %rcx, (%rsp)
movq %r14, %rdi
callq 0xab48
movq %rax, %r15
movq (%rbp), %rdi
testq %r12, %r12
jne 0xaaf8
testq %rdi, %rdi
je 0xaaf1
callq 0x3050
andq $0x0, (%rbp)
andq $0x0, (%r13)
xorl %edi, %edi
movq %r15, %rsi
callq 0x9db6
movq %rax, %rdi
movq %rax, (%rbp)
movq %r15, (%r13)
movq (%rsp), %rcx
jmp 0xab15
movq (%rbp), %rdi
addq %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 0xa987(%rip), %rsi      # 0x154c3
pushq $0x22
popq %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xdd45
// File: /workspace/github_c_makefile_star2_O2/madler[P]pigz/pigz.c
// Function: grow
local inline size_t grow(size_t size) {
    size_t was, top;
    int shift;

    was = size;
    size += size >> 2;
    top = size;
    for (shift = 0; top > 7; shift++)
        top >>= 1;
    if (top == 7)
        size = (size_t)1 << (shift + 3);
    if (size < 16)
        size = 16;
    if (size <= was)
        size = (size_t)0 - 1;
    return size;
}

// Assembly:
movq %rdi, %rax
shrq $0x2, %rax
addq %rdi, %rax
pushq $0x3
popq %rcx
movq %rax, %rdx
cmpq $0x8, %rdx
jb 0xab66
shrq %rdx
incq %rcx
jmp 0xab58
pushq $0x1
popq %rsi
shlq %cl, %rsi
cmpq $0x7, %rdx
cmoveq %rsi, %rax
cmpq $0x11, %rax
pushq $0x10
popq %rcx
cmovaeq %rax, %rcx
cmpq %rdi, %rcx
pushq $-0x1
popq %rax
cmovaq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x2193f(%rip)    # 0x2c4d0
je 0xabdd
pushq %rbx
movq 0x2193d(%rip), %rdi     # 0x2c4d8
leaq 0x975e(%rip), %rbx      # 0x14300
movl $0x9fd, %edx            # imm = 0x9FD
movq %rbx, %rsi
callq 0xd763
movq 0x21922(%rip), %rdi     # 0x2c4d8
movl $0x9fe, %r8d            # imm = 0x9FE
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd81e
movq 0x21909(%rip), %rdi     # 0x2c4d8
movl $0x9ff, %edx            # imm = 0x9FF
movq %rbx, %rsi
popq %rbx
jmp 0xd792
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r15d, %r15d
testq %rbx, %rbx
je 0xb1dd
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32c0
testq %rax, %rax
js 0xb1eb
je 0xb1dd
addq %rax, %r14
subq %rax, %rbx
addq %rax, %r15
jmp 0xb1b9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x1115f(%rip), %r14     # 0x1c358
movl %ebx, %edi
callq 0x35a0
leaq 0xa114(%rip), %rsi      # 0x1531b
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xdd45
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
pushq $-0x1
popq %rbp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movabsq $-0xffffffff, %r12      # imm = 0xFFFFFFFF00000001
movq %rbx, %rax
shrq $0x20, %rax
je 0xb45d
testq %r14, %r14
je 0xb45d
movq %r14, %rsi
movl %ebp, %edx
callq 0x3120
movq %rax, %rdi
addq %r15, %r14
addq %r12, %rbx
jmp 0xb43a
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x18ff6(%rip), %rcx     # 0x24470
testq %rcx, %rcx
jne 0xb48b
callq 0xb020
movq 0x18fe5(%rip), %rcx     # 0x24470
movq 0x18fd6(%rip), %rdx     # 0x24468
movq %rdx, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rcx
cmovbq %rcx, %rax
addq %rax, %rdx
movq %rdx, 0x18fbd(%rip)     # 0x24468
subq %rax, %rcx
movq %rcx, 0x18fbb(%rip)     # 0x24470
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rax
movl $0xfff1, %r8d           # imm = 0xFFF1
xorl %edx, %edx
divq %r8
movq %rdx, %rcx
movl $0xffff, %edx           # imm = 0xFFFF
movq %rdi, %rax
andq %rdx, %rax
andq %rsi, %rdx
leaq (%rax,%rdx), %r9
leaq (%rax,%rdx), %r10
decq %r10
imull %ecx, %eax
movl $0xfff1, %r11d          # imm = 0xFFF1
xorl %edx, %edx
divl %r11d
addl $0xfff0, %r9d           # imm = 0xFFF0
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
addq %rdx, %rsi
leaq (%rsi,%r8), %rax
cmpl %r11d, %r9d
movl $0xfff0, %ecx           # imm = 0xFFF0
cmovaeq %r10, %rcx
movq $-0xfff1, %rdx          # imm = 0xFFFF000F
leaq (%rcx,%rdx), %rdi
cmpq %r8, %rcx
cmovbq %rcx, %rdi
addq %rdx, %rsi
cmpq $0x1ffe2, %rax          # imm = 0x1FFE2
cmovbq %rax, %rsi
movq %rsi, %rcx
shlq $0x10, %rcx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rcx, %rax
cmpq %r8, %rsi
cmovbq %rcx, %rax
orq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movl %edi, %ebp
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movq %rdx, %r12
testq %r12, %r12
je 0xb5d0
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x3130
testq %rax, %rax
jle 0xb5dc
addq %rax, %r14
subq %rax, %r12
jmp 0xb5aa
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x10d7e(%rip), %r14     # 0x1c368
movl %ebx, %edi
callq 0x35a0
leaq 0x9e87(%rip), %rsi      # 0x1547f
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xdd45
// File: /workspace/github_c_makefile_star2_O2/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)
leaq 0x10(%rsp), %rbx
andq $0x0, 0xc8(%rbx)
andl $0x0, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
callq 0xdcdc
leaq 0x31029(%rip), %r14     # 0x3c674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0xb78e
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xb708
leaq 0x8c7a(%rip), %rbx      # 0x14300
xorl %ebp, %ebp
pushq $0x1
popq %r15
movl $0xd1a, %r12d           # imm = 0xD1A
movl $0xd1f, %r13d           # imm = 0xD1F
movq 0x28e61(%rip), %rdi     # 0x34500
movq %rbx, %rsi
movl $0xd19, %edx            # imm = 0xD19
callq 0xd763
movq 0x28e4d(%rip), %rdi     # 0x34500
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0xd81e
movq 0x28e46(%rip), %r14     # 0x34510
testq %r14, %r14
je 0xb6ed
cmpl $0x1, 0x10cf2(%rip)     # 0x1c3c8
jne 0xb6ed
movl 0x10c76(%rip), %edi     # 0x1c354
leaq 0x28e3b(%rip), %rsi     # 0x34520
movq %r14, %rdx
callq 0xb58d
movq 0x28e0c(%rip), %rdi     # 0x34500
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r13, %r8
callq 0xd7c1
testq %r14, %r14
jne 0xb698
cmpl $0x0, 0xc(%rsp)
je 0xb735
leaq 0x30f5e(%rip), %rax     # 0x3c674
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0xb7ad
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xb752
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 0xb778
leaq 0x8c9e(%rip), %rdi      # 0x1440c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x4419
testl %r14d, %r14d
je 0xb785
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x3dc0
leaq 0x8b3b(%rip), %rdi      # 0x142d0
leaq 0x8b64(%rip), %rsi      # 0x14300
leaq 0xa0c1(%rip), %rcx      # 0x15864
movl $0xd17, %edx            # imm = 0xD17
callq 0x3220
leaq 0x8b1c(%rip), %rdi      # 0x142d0
leaq 0x8b45(%rip), %rsi      # 0x14300
leaq 0xa0a2(%rip), %rcx      # 0x15864
movl $0xd22, %edx            # imm = 0xD22
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/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)
leaq 0x10(%rsp), %rbx
andq $0x0, 0xc8(%rbx)
andl $0x0, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
callq 0xdcdc
leaq 0x30e67(%rip), %r14     # 0x3c674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0xb95f
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xb8d9
leaq 0x8ab8(%rip), %rbx      # 0x14300
xorl %ebp, %ebp
movl $0xd33, %r12d           # imm = 0xD33
leaq 0x28cc9(%rip), %r13     # 0x34520
movl $0xd37, %r14d           # imm = 0xD37
movq 0x28ca4(%rip), %rdi     # 0x34508
movq %rbx, %rsi
movl $0xd32, %edx            # imm = 0xD32
callq 0xd763
movq 0x28c90(%rip), %rdi     # 0x34508
movl %ebp, %esi
pushq $0x1
popq %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0xd81e
movq 0x28c81(%rip), %r15     # 0x34510
cmpl $0x1, 0x10af2(%rip)     # 0x1c388
movq 0x18bf3(%rip), %rdi     # 0x24490
jne 0xb8ac
movl %r15d, %edx
movq %r13, %rsi
callq 0x3390
jmp 0xb8b7
movq %r13, %rsi
movq %r15, %rdx
callq 0xb419
movq %rax, 0x18bd2(%rip)     # 0x24490
movq 0x28c43(%rip), %rdi     # 0x34508
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xd7c1
testq %r15, %r15
jne 0xb85d
cmpl $0x0, 0xc(%rsp)
je 0xb906
leaq 0x30d8d(%rip), %rax     # 0x3c674
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0xb97e
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xb923
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 0xb949
leaq 0x8acd(%rip), %rdi      # 0x1440c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x4419
testl %r14d, %r14d
je 0xb956
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x3dc0
leaq 0x896a(%rip), %rdi      # 0x142d0
leaq 0x8993(%rip), %rsi      # 0x14300
leaq 0x9f08(%rip), %rcx      # 0x1587c
movl $0xd30, %edx            # imm = 0xD30
callq 0x3220
leaq 0x894b(%rip), %rdi      # 0x142d0
leaq 0x8974(%rip), %rsi      # 0x14300
leaq 0x9ee9(%rip), %rcx      # 0x1587c
movl $0xd3a, %edx            # imm = 0xD3A
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/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 0x858c(%rip), %rsi      # 0x14300
movl $0x5bf, %edx            # imm = 0x5BF
callq 0xd763
cmpl $0x0, 0x18(%rbx)
jne 0xbd9e
movq (%rbx), %rdi
leaq 0x8572(%rip), %rcx      # 0x14300
pushq $0x1
popq %rsi
movl $0x5c1, %r8d            # imm = 0x5C1
xorl %edx, %edx
callq 0xd81e
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xbdfa
movq 0x28(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x8547(%rip), %rbx      # 0x14300
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
movl $0x5c7, %r8d            # imm = 0x5C7
movq %rbx, %rcx
callq 0xd7c1
movq (%r14), %rdi
movl $0x5c8, %edx            # imm = 0x5C8
movq %rbx, %rsi
callq 0xd763
movq (%r14), %rdi
pushq $0x1
popq %rdx
movl $0x5c9, %r8d            # imm = 0x5C9
xorl %esi, %esi
movq %rbx, %rcx
callq 0xd7c1
andq $0x0, 0x18(%r14)
jmp 0xbe62
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0xbe6b
jle 0xbe08
decl %eax
movl %eax, 0x18(%rbx)
incl 0x1c(%rbx)
movq (%rbx), %rdi
leaq 0x84eb(%rip), %r15      # 0x14300
movl $0x5d3, %edx            # imm = 0x5D3
movq %r15, %rsi
callq 0xd792
pushq $0x30
popq %rsi
xorl %edi, %edi
callq 0x9db6
movq %rax, %r14
pushq $0x1
popq %rdi
movl $0x5d5, %edx            # imm = 0x5D5
movq %r15, %rsi
callq 0xd5df
movq %rax, (%r14)
movq 0x10(%rbx), %rsi
xorl %edi, %edi
callq 0x9db6
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
andq $0x0, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9ab5(%rip), %rdi      # 0x15927
leaq 0x8487(%rip), %rsi      # 0x14300
leaq 0x9ab8(%rip), %rcx      # 0x15938
movl $0x5cf, %edx            # imm = 0x5CF
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/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 0xbfb1
movq %rdi, %r14
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
jne 0xbec0
leaq 0x3070a(%rip), %rdi     # 0x3c5b8
movq %rsi, %rbx
callq 0xbd62
movq %rbx, %rsi
movq %rax, %rbx
movq %rax, 0x20(%r14)
movq 0x18(%rbx), %rax
addq $0x3, %rax
cmpq %rax, 0x10(%rbx)
jae 0xbedc
movq %rbx, %rdi
movq %rsi, %r14
callq 0xd43f
movq %r14, %rsi
cmpq $0x3f, %rsi
ja 0xbeeb
orb $-0x80, %sil
jmp 0xbf95
cmpq $0x803f, %rsi           # imm = 0x803F
ja 0xbf0d
addq $-0x40, %rsi
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq %rsi, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
jmp 0xbf4d
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 0xbf52
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 0xbf95
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 0x99a7(%rip), %rdi      # 0x1595f
leaq 0x8341(%rip), %rsi      # 0x14300
leaq 0x99ab(%rip), %rcx      # 0x15971
movl $0x7fa, %edx            # imm = 0x7FA
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/madler[P]pigz/pigz.c
// Function: use_space
local void use_space(struct space *space) {
    long use;

    possess(space->use);
    use = peek_lock(space->use);
    assert(use != 0);
    twist(space->use, BY, +1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8322(%rip), %rsi      # 0x14300
movl $0x5f0, %edx            # imm = 0x5F0
callq 0xd763
movq (%rbx), %rdi
callq 0xd8de
testq %rax, %rax
je 0xc011
movq (%rbx), %rdi
leaq 0x8301(%rip), %rcx      # 0x14300
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
movl $0x5f3, %r8d            # imm = 0x5F3
popq %rbx
jmp 0xd7c1
leaq 0x997f(%rip), %rdi      # 0x15997
leaq 0x82e1(%rip), %rsi      # 0x14300
leaq 0x997a(%rip), %rcx      # 0x159a0
movl $0x5f2, %edx            # imm = 0x5F2
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/madler[P]pigz/pigz.c
// Function: drop_space
local void drop_space(struct space *space) {
    long use;
    struct pool *pool;

    if (space == NULL)
        return;
    possess(space->use);
    use = peek_lock(space->use);
    assert(use != 0);
    twist(space->use, BY, -1);
    if (use == 1) {
        pool = space->pool;
        possess(pool->have);
        space->next = pool->head;
        pool->head = space;
        twist(pool->have, BY, +1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xca18
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x7966(%rip), %rsi      # 0x14300
movl $0x5fd, %edx            # imm = 0x5FD
callq 0xd763
movq (%rbx), %rdi
callq 0xd8de
testq %rax, %rax
je 0xca1e
movq %rax, %r14
movq (%rbx), %rdi
leaq 0x7942(%rip), %rcx      # 0x14300
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
movl $0x600, %r8d            # imm = 0x600
callq 0xd7c1
cmpq $0x1, %r14
jne 0xca18
movq 0x20(%rbx), %r15
movq (%r15), %rdi
leaq 0x791d(%rip), %r14      # 0x14300
movl $0x603, %edx            # imm = 0x603
movq %r14, %rsi
callq 0xd763
movq 0x8(%r15), %rax
movq %rax, 0x28(%rbx)
movq %rbx, 0x8(%r15)
movq (%r15), %rdi
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
movl $0x606, %r8d            # imm = 0x606
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xd7c1
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8f72(%rip), %rdi      # 0x15997
leaq 0x78d4(%rip), %rsi      # 0x14300
leaq 0x9039(%rip), %rcx      # 0x15a6c
movl $0x5ff, %edx            # imm = 0x5FF
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/madler[P]pigz/pigz.c
// Function: new_pool
local void new_pool(struct pool *pool, size_t size, int limit) {
    pool->have = new_lock(0);
    pool->head = NULL;
    pool->size = size;
    pool->limit = limit;
    pool->made = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x78af(%rip), %rsi      # 0x14300
movl $0x5b2, %edx            # imm = 0x5B2
xorl %edi, %edi
callq 0xd5df
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
movq %r14, 0x10(%r15)
movl %ebx, 0x18(%r15)
andl $0x0, 0x1c(%r15)
popq %rbx
popq %r14
popq %r15
retq