LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_genrand_close1_open2
float mtgp32_genrand_close1_open2(mtgp32_ref_t *mtgp32) {
    union {
	uint32_t u;
	float f;
    } x;
    x.u = mtgp32_genrand_uint32(mtgp32);
    x.u = (x.u >> 9) | UINT32_C(0x3f800000);
    return x.f;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x24f0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_genrand_open_open
float mtgp32_genrand_open_open(mtgp32_ref_t *mtgp32) {
    union {
	uint32_t u;
	float f;
    } x;
    x.u = mtgp32_genrand_uint32(mtgp32);
    x.u = (x.u >> 9) | UINT32_C(0x3f800001);
    return x.f - 1.0F;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x24f0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movl %eax, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss 0x7af(%rip), %xmm1      # 0x3004
subss %xmm1, %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: print_uint32
void print_uint32(mtgp32_ref_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%10"PRIu32" ", mtgp32_genrand_uint32(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x28c7
movq 0x10(%rsp), %rdi
callq 0x24f0
movl %eax, %esi
leaq 0x78a(%rip), %rdi       # 0x301c
movb $0x0, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x28b8
leaq 0x788(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
jmp 0x28ba
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2875
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x28e6
leaq 0x75a(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: print_close1_open2
void print_close1_open2(mtgp32_ref_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close1_open2(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2959
movq 0x10(%rsp), %rdi
callq 0x27a0
cvtss2sd %xmm0, %xmm0
leaq 0x6fe(%rip), %rdi       # 0x3022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x294a
leaq 0x6f6(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
jmp 0x294c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2905
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2978
leaq 0x6c8(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
leaq 0x6ba(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: print_close_open
void print_close_open(mtgp32_ref_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close_open(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x29f9
movq 0x10(%rsp), %rdi
callq 0x27e0
cvtss2sd %xmm0, %xmm0
leaq 0x65e(%rip), %rdi       # 0x3022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x29ea
leaq 0x656(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
jmp 0x29ec
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x29a5
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2a18
leaq 0x628(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: print_open_close
void print_open_close(mtgp32_ref_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_open_close(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2a89
movq 0x10(%rsp), %rdi
callq 0x2800
cvtss2sd %xmm0, %xmm0
leaq 0x5ce(%rip), %rdi       # 0x3022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x2a7a
leaq 0x5c6(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
jmp 0x2a7c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2a35
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2aa8
leaq 0x598(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: print_open_open
void print_open_open(mtgp32_ref_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_open_open(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2b19
movq 0x10(%rsp), %rdi
callq 0x2820
cvtss2sd %xmm0, %xmm0
leaq 0x53e(%rip), %rdi       # 0x3022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x2b0a
leaq 0x536(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
jmp 0x2b0c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2ac5
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2b38
leaq 0x508(%rip), %rdi       # 0x3039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/MOVE.c
// Function: main
int main(int argc, char** argv){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    char* srcname = lines[1];
    char* dstname = lines[2];
    if((strcmp("move",lines[0])==0)) {
        if(rename(srcname, dstname)<0){
            perror("Rename error!\n");
        }
    }
    else {
        perror("sytax error\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x38(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1190
movq -0x38(%rbp), %rsi
movq %rsi, %rax
addq $0xff, %rax
movq %rax, -0x28(%rbp)
movq %rsi, %rax
addq $0x1fe, %rax            # imm = 0x1FE
movq %rax, -0x30(%rbp)
leaq 0xc55(%rip), %rdi       # 0x2004
callq 0x1040
cmpl $0x0, %eax
jne 0x13d9
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jge 0x13d7
leaq 0xc37(%rip), %rdi       # 0x2009
callq 0x1060
jmp 0x13e5
leaq 0xc38(%rip), %rdi       # 0x2018
callq 0x1060
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/book.c
// Function: main
int main(int numargs, char * args[])
{
    struct thudboard * board = & board_data;

    int memuse = 1024 * 1024 * (numargs > 1 ? strtol(args[1], NULL, 10)
                                            : sizeof(struct tableentry));

    setupgame(board, memuse);

    initbtable(1024 * 1024 * sizeof(struct tableentry));

    for (int depth=2; depth <= DEPTH; depth += 1)
    {
        printf("depth %d   ", depth); fflush(0);
        int _ = system("date");
        absearch(board, depth, INT_MAX, INT_MIN, INT_MAX, NULL, 0, NULL);

	book = fopen(BOOKFILENAME, "w");
	for (int i=0; i < BTABLESIZE; ++i)
	{
	    if (btable[i].hash != 0)
	    {
		fwrite(& (btable[i]), sizeof(struct tableentry), 1, book);
	    }
	}
	fclose(book);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7ef3(%rip), %rax      # 0x91f0
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1323
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1110
movq %rax, -0x30(%rbp)
jmp 0x132e
movl $0x20, %eax
movq %rax, -0x30(%rbp)
jmp 0x132e
movq -0x30(%rbp), %rax
shlq $0x14, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1780
movl $0x2000000, %edi        # imm = 0x2000000
callq 0x1460
movl $0x2, -0x20(%rbp)
cmpl $0x7, -0x20(%rbp)
jg 0x144c
movl -0x20(%rbp), %esi
leaq 0x4c9a(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
movl %eax, %edi
callq 0x11d0
leaq 0x4c8f(%rip), %rdi      # 0x6010
callq 0x10d0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %edx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x1c50
movq 0x7d40(%rip), %rdi      # 0x9100
leaq 0x4c4e(%rip), %rsi      # 0x6015
callq 0x10c0
movq %rax, 0x7e9d(%rip)      # 0x9270
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x7e95(%rip), %eax      # 0x9278
jge 0x1432
movq 0x7e94(%rip), %rax      # 0x9280
movslq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1425
movq 0x7e7c(%rip), %rdi      # 0x9280
movslq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq 0x7e5a(%rip), %rcx      # 0x9270
movl $0x20, %esi
movl $0x1, %edx
callq 0x1160
jmp 0x1427
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x13da
movq 0x7e37(%rip), %rdi      # 0x9270
callq 0x1140
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1356
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/book.c
// Function: inithash
void inithash(void)
{
    turnhash = randomhash();

    for (int i=0; i < SIZE*SIZE; ++i)
    {
        dwarfhash[i] = randomhash();
        trollhash[i] = randomhash();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x14b0
movq %rax, 0x7d94(%rip)      # 0x9288
movl $0x0, -0x4(%rbp)
cmpl $0xe1, -0x4(%rbp)
jge 0x153d
callq 0x14b0
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x7d79(%rip), %rax      # 0x9290
movq %rdx, (%rax,%rcx,8)
callq 0x14b0
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x8472(%rip), %rax      # 0x99a0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x14fb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/book.c
// Function: ttput
void ttput(struct tableentry entry)
{
    int index = ttindex(entry.hash);
    ttable[index] = entry;

    int bindex = btindex(entry.hash);
    if (entry.depth > btable[bindex].depth) btable[bindex] = entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1620
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x4(%rbp)
movq 0x8a28(%rip), %rcx      # 0xa0b0
movslq -0x4(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%rcx)
movq (%rax), %rdi
callq 0x1640
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x8(%rbp)
movl 0x8(%rax), %eax
movq 0x7bb4(%rip), %rcx      # 0x9280
movslq -0x8(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jle 0x1710
movq -0x10(%rbp), %rcx
movq 0x7b99(%rip), %rax      # 0x9280
movslq -0x8(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/reverb3/reverb3.c
// Function: reverb
static double
reverb(int channel,int t,int samples)
    {
    double total;

    total = ingain * unfiltered[channel][t%size];
    total += outgain * filtered[channel][(t - delay1 + size) % size]; 
    total += outgain * 0.7 * invert * filtered[channel][(t - delay2 + size) % size];

    return total;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movsd 0xd71b(%rip), %xmm0     # 0x10190
movq 0xd9cc(%rip), %rax      # 0x10448
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
cltd
idivl 0xd6f6(%rip)            # 0x10188
movq -0x30(%rbp), %rax
movslq %edx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xd6e9(%rip), %xmm0     # 0x10198
movq 0xd98a(%rip), %rax      # 0x10440
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
subl 0xd6b5(%rip), %eax      # 0x10180
addl 0xd6b7(%rip), %eax      # 0x10188
cltd
idivl 0xd6b0(%rip)            # 0x10188
movq -0x28(%rbp), %rax
movslq %edx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x950a(%rip), %xmm0     # 0xc008
mulsd 0xd692(%rip), %xmm0     # 0x10198
cvtsi2sdl 0xd692(%rip), %xmm1 # 0x101a0
mulsd %xmm1, %xmm0
movq 0xd927(%rip), %rax      # 0x10440
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
subl 0xd656(%rip), %eax      # 0x10184
addl 0xd654(%rip), %eax      # 0x10188
cltd
idivl 0xd64d(%rip)            # 0x10188
movq -0x20(%rbp), %rax
movslq %edx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: usage
static void
usage(FILE *f)
{
    fprintf(f, "hp16: [-HISX] [-hmr] [-n INT]\n");
    fprintf(f, "  -A     mode: evaluate AXS hashes\n");
    fprintf(f, "  -H     mode: random hash prospector (default)\n");
    fprintf(f, "  -I     mode: smarter (?) hash prospector\n");
    fprintf(f, "  -S     mode: s-box prospector \n");
    fprintf(f, "  -X     mode: xorshift-multiply prospector\n");
    fprintf(f, "  -h     print this message and exit\n");
    fprintf(f, "  -m     exclude multiplication\n");
    fprintf(f, "  -n INT number of operations\n");
    fprintf(f, "  -r     exclude rotation\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17b3(%rip), %rsi      # 0x322a
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x17c0(%rip), %rsi      # 0x3249
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x17d2(%rip), %rsi      # 0x326d
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x17f1(%rip), %rsi      # 0x329e
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x180b(%rip), %rsi      # 0x32ca
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x181b(%rip), %rsi      # 0x32ec
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x1836(%rip), %rsi      # 0x3319
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x184a(%rip), %rsi      # 0x333f
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x1859(%rip), %rsi      # 0x3360
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
leaq 0x1866(%rip), %rsi      # 0x337f
movb $0x0, %al
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hash64
static unsigned long long
hash64(unsigned long long x)
{
    x ^= x >> 32;
    x *= 0x25b751109e05be63;
    x &= 0xffffffffffffffff;
    x ^= x >> 32;
    x *= 0x2330e1453ed4b9b9;
    x &= 0xffffffffffffffff;
    x ^= x >> 32;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x25b751109e05be63, %rax # imm = 0x25B751109E05BE63
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x2330e1453ed4b9b9, %rax # imm = 0x2330E1453ED4B9B9
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: score
static double
score(const struct hf_op *ops, int n)
{
    long bins[32][32] = {{0}};
    for (long x = 0; x < 1L<<16; x++) {
        unsigned h0 = hf_apply(ops, n, x);
        for (int j = 0; j < 16; j++) {
            unsigned bit = 1U << j;
            unsigned h1 = hf_apply(ops, n, x^bit);
            unsigned set = h0 ^ h1;
            for (int k = 0; k < 16; k++)
                bins[j][k] += (set >> k) & 1;
        }
    }

    double mean = 0.0;
    for (int j = 0; j < 16; j++) {
        for (int k = 0; k < 16; k++) {
            double diff = (bins[j][k] - (1<<15)) / (double)(1<<15);
            mean += (diff * diff) / (16 * 16);
        }
    }
    return sqrt(mean);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x2010(%rbp), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x1080
movq $0x0, -0x2018(%rbp)
cmpq $0x10000, -0x2018(%rbp) # imm = 0x10000
jge 0x1f48
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x2018(%rbp), %rax
movl %eax, %edx
callq 0x2650
movl %eax, -0x201c(%rbp)
movl $0x0, -0x2020(%rbp)
cmpl $0x10, -0x2020(%rbp)
jge 0x1f2f
movl -0x2020(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2024(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x2018(%rbp), %rax
movl -0x2024(%rbp), %ecx
xorq %rcx, %rax
movl %eax, %edx
callq 0x2650
movl %eax, -0x2028(%rbp)
movl -0x201c(%rbp), %eax
xorl -0x2028(%rbp), %eax
movl %eax, -0x202c(%rbp)
movl $0x0, -0x2030(%rbp)
cmpl $0x10, -0x2030(%rbp)
jge 0x1f19
movl -0x202c(%rbp), %eax
movl -0x2030(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movslq -0x2020(%rbp), %rcx
leaq -0x2010(%rbp), %rax
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x2030(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x2030(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2030(%rbp)
jmp 0x1ec6
jmp 0x1f1b
movl -0x2020(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2020(%rbp)
jmp 0x1e66
jmp 0x1f31
movq -0x2018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2018(%rbp)
jmp 0x1e30
xorps %xmm0, %xmm0
movsd %xmm0, -0x2038(%rbp)
movl $0x0, -0x203c(%rbp)
cmpl $0x10, -0x203c(%rbp)
jge 0x2012
movl $0x0, -0x2040(%rbp)
cmpl $0x10, -0x2040(%rbp)
jge 0x1ffc
movslq -0x203c(%rbp), %rcx
leaq -0x2010(%rbp), %rax
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x2040(%rbp), %rcx
movq (%rax,%rcx,8), %rax
subq $0x8000, %rax           # imm = 0x8000
cvtsi2sd %rax, %xmm0
movsd 0x1068(%rip), %xmm1     # 0x3018
divsd %xmm1, %xmm0
movsd %xmm0, -0x2048(%rbp)
movsd -0x2048(%rbp), %xmm0
mulsd -0x2048(%rbp), %xmm0
movsd 0x103c(%rip), %xmm1     # 0x3010
divsd %xmm1, %xmm0
addsd -0x2038(%rbp), %xmm0
movsd %xmm0, -0x2038(%rbp)
movl -0x2040(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2040(%rbp)
jmp 0x1f74
jmp 0x1ffe
movl -0x203c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x203c(%rbp)
jmp 0x1f5d
movsd -0x2038(%rbp), %xmm0
callq 0x10f0
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_genfunc
static void
hf_genfunc(struct hf_op *ops, int n, unsigned long long s[1])
{
    for (int i = 0; i < n; i++) {
        do {
            enum hf_type type = u32(s) % HF16_SBOX;  // (exclude sbox)
            ops[i] = hf_gen(type, s);
        } while (i > 0 && !hf_type_valid(ops[i-1].type, ops[i].type));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2304
jmp 0x2268
movq -0x18(%rbp), %rdi
callq 0x27c0
movl $0x9, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x2840
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x39(%rbp)
jle 0x22e9
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,8), %edi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x28d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2268
jmp 0x22f6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x225a
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: match
static int
match(const struct hf_op *ops, int n, int types)
{
    for (int i = 0; i < n; i++) {
        if (1<<ops[i].type & types) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x235d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
movl $0x1, %eax
shll %cl, %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x2350
movl $0x1, -0x4(%rbp)
jmp 0x2364
jmp 0x2352
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2325
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_gensmart
static void
hf_gensmart(struct hf_op *ops, int n, unsigned long long s[1])
{
    int dir = 0;
    for (int i = 0; i < n; i++) {
        int newdir;
        do {
            ops[i] = hf_gen(u32(s)%HF16_SBOX, s);
            newdir = opdir(ops[i]);
        } while (dir && newdir == dir);
        dir = newdir ? newdir : dir;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x243e
jmp 0x239f
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27c0
movl $0x9, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %edi
movq -0x18(%rbp), %rsi
callq 0x2840
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq %rdx, -0x2c(%rbp)
movq -0x2c(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2930
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x41(%rbp)
je 0x240f
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x239f
cmpl $0x0, -0x24(%rbp)
je 0x2424
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x242a
movl -0x1c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2391
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_genxormul
static void
hf_genxormul(struct hf_op *ops, int n, unsigned long long s[1])
{
    ops[0].type = HF16_XORR;
    ops[0].imm = 1 + popcount(u32(s) >> 18);
    for (int i = 0; i < n; i++) {
        ops[2*i+1].type = HF16_MUL;
        ops[2*i+1].imm = u32(s)>>16 | 1;
        ops[2*i+2].type = HF16_XORR;
        ops[2*i+2].imm = 1 + popcount(u32(s) >> 18);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rdi
callq 0x27c0
shrq $0x12, %rax
movl %eax, %edi
callq 0x29b0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x252c
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x27c0
shrq $0x10, %rax
orq $0x1, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl $0x6, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x27c0
shrq $0x12, %rax
movl %eax, %edi
callq 0x29b0
movl %eax, %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2494
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: sbox_shuffle
static void
sbox_shuffle(unsigned long long s[1])
{
    for (long i = 0xffff; i > 0; i--) {
        long j = randint(i + 1, s);
        unsigned swap = sbox[i];
        sbox[i] = sbox[j];
        sbox[j] = swap;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
cmpq $0x0, -0x10(%rbp)
jle 0x25c3
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rsi
callq 0x29e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x2b55(%rip), %rax      # 0x50d0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x2b43(%rip), %rax      # 0x50d0
movw (%rax,%rcx,2), %dx
movq -0x10(%rbp), %rcx
leaq 0x2b34(%rip), %rax      # 0x50d0
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rcx
leaq 0x2b1f(%rip), %rax      # 0x50d0
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2554
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_apply
static unsigned
hf_apply(const struct hf_op *ops, int n, unsigned x)
{
    for (int i = 0; i < n; i++) {
        switch (ops[i].type) {
        case HF16_XOR:  x ^= ops[i].imm; break;
        case HF16_MUL:  x *= ops[i].imm; break;
        case HF16_ADD:  x += ops[i].imm; break;
        case HF16_ROT:  x  = x<<ops[i].imm | x>>(16 - ops[i].imm); break;
        case HF16_NOT:  x  = ~x; break;
        case HF16_XORL: x ^= x << ops[i].imm; break;
        case HF16_XORR: x ^= x >> ops[i].imm; break;
        case HF16_ADDL: x += x << ops[i].imm; break;
        case HF16_SUBL: x -= x << ops[i].imm; break;
        case HF16_SBOX: x  = sbox[x]; break;
        }
        x &= 0xffff;
    }
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27b6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq %rax, -0x20(%rbp)
subq $0x9, %rax
ja 0x279d
movq -0x20(%rbp), %rax
leaq 0xaab(%rip), %rcx       # 0x3140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
shll %cl, %eax
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdi
movl $0x10, %ecx
subl 0x4(%rsi,%rdi,8), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
shll %cl, %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
shrl %cl, %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
shll %cl, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
shll %cl, %eax
movl %eax, %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x279d
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x293a(%rip), %rax      # 0x50d0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2665
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: u32
static unsigned long
u32(unsigned long long *s)
{
    unsigned long r = *s >> 32;
    *s = *s*0x7c3c3267d015ceb5 + 1;
    r &= 0xffffffff;
    r ^= r >> 16;
    r *= 0x60857ba9;
    return r & 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movabsq $0x7c3c3267d015ceb5, %rcx # imm = 0x7C3C3267D015CEB5
imulq (%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
imulq $0x60857ba9, -0x10(%rbp), %rax # imm = 0x60857BA9
movq %rax, -0x10(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_gen
static struct hf_op
hf_gen(enum hf_type type, unsigned long long s[1])
{
    struct hf_op op;
    op.type = type;
    switch (op.type) {
    case HF16_NOT:
    case HF16_SBOX: op.imm = 0; break;
    case HF16_XOR:
    case HF16_ADD:  op.imm = u32(s)>>16; break;
    case HF16_MUL:  op.imm = u32(s)>>16 | 1; break;
    case HF16_ROT:
    case HF16_XORL:
    case HF16_XORR:
    case HF16_ADDL:
    case HF16_SUBL: op.imm = 1 + u32(s)%15; break;
    }
    return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x9, %rax
ja 0x28c3
movq -0x20(%rbp), %rax
leaq 0x8fb(%rip), %rcx       # 0x3168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x28c3
movq -0x18(%rbp), %rdi
callq 0x27c0
shrq $0x10, %rax
movl %eax, -0x4(%rbp)
jmp 0x28c3
movq -0x18(%rbp), %rdi
callq 0x27c0
shrq $0x10, %rax
orq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0x28c3
movq -0x18(%rbp), %rdi
callq 0x27c0
movl $0xf, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: hf_type_valid
static int
hf_type_valid(enum hf_type a, enum hf_type b)
{
    switch (a) {
    case HF16_NOT:
    case HF16_XOR:
    case HF16_MUL:
    case HF16_ADD:
    case HF16_ROT:
    case HF16_SBOX: return a != b;
    case HF16_XORL:
    case HF16_XORR:
    case HF16_ADDL:
    case HF16_SUBL: return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x5, %eax
jb 0x28fe
jmp 0x28e7
movl -0x10(%rbp), %eax
addl $-0x5, %eax
subl $0x4, %eax
jb 0x2911
jmp 0x28f4
movl -0x10(%rbp), %eax
subl $0x9, %eax
jne 0x291a
jmp 0x28fe
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2921
movl $0x1, -0x4(%rbp)
jmp 0x2921
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: opdir
static int
opdir(struct hf_op op)
{
    switch (op.type) {
    case HF16_NOT:
    case HF16_XOR:
    case HF16_ADD:
    case HF16_SBOX: return 0;
    case HF16_MUL:
    case HF16_XORL:
    case HF16_ADDL:
    case HF16_SUBL: return +1;
    case HF16_XORR: return -1;
    case HF16_ROT:  if (op.imm < 8) return +1;
                    if (op.imm > 8) return -1;
                    return 0;
    }
    abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x299f
movq -0x18(%rbp), %rax
leaq 0x83c(%rip), %rcx       # 0x3190
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x29a4
movl $0x1, -0x4(%rbp)
jmp 0x29a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29a4
cmpl $0x8, -0x8(%rbp)
jae 0x2987
movl $0x1, -0x4(%rbp)
jmp 0x29a4
cmpl $0x8, -0x8(%rbp)
jbe 0x2996
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29a4
movl $0x0, -0x4(%rbp)
jmp 0x29a4
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hp16.c
// Function: randint
static unsigned long
randint(unsigned long r, unsigned long long s[1])
{
    unsigned long long x = u32(s);
    unsigned long long m = x * r;
    unsigned long y = m & 0xffffffff;
    if (y < r) {
        unsigned long t = -r % r;
        while (y < t) {
            x = u32(s);
            m = x * r;
            y = m & 0xffffffff;
        }
    }
    return m >> 32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
imulq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x2a72
xorl %eax, %eax
subq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x8(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x2a70
movq -0x10(%rbp), %rdi
callq 0x27c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
imulq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2a38
jmp 0x2a72
movq -0x20(%rbp), %rax
shrq $0x20, %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/bcast3.c
// Function: main
int
main(void)
{
    int i;
    long *target;
    static long source[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int nlong = 8;
    int me;

    shmem_init();
    me = shmem_my_pe();

    target = (long *) shmem_malloc(8 * sizeof(*target));

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }
    shmem_barrier_all();

    shmem_broadcast64(target, source, nlong, 1, 0, 0, 4, pSync);

    for (i = 0; i < 8; i++) {
        printf("%d: target[%d] = %ld\n", me, i, target[i]);
    }

    shmem_barrier_all();

    shmem_free(target);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl $0x8, 0x14(%rsp)
callq 0x1080
callq 0x1050
movl %eax, 0x10(%rsp)
movl $0x40, %edi
callq 0x1060
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x2, 0x20(%rsp)
jge 0x1211
movslq 0x20(%rsp), %rcx
leaq 0x2ec4(%rip), %rax      # 0x40c0
movq $-0x1, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x11e9
callq 0x1070
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
leaq 0x2e49(%rip), %rsi      # 0x4070
movl $0x1, %ecx
xorl %r9d, %r9d
leaq 0x2e8a(%rip), %rax      # 0x40c0
movl %r9d, %r8d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10a0
movl $0x0, 0x20(%rsp)
cmpl $0x8, 0x20(%rsp)
jge 0x128a
movl 0x10(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xd8e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1252
callq 0x1070
movq 0x18(%rsp), %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: drop_space
local void drop_space(struct space* space){
	int use;
	struct pool* pool;
	if (space == NULL) return;
	possess(space->use);
	use = peek_lock(space->use);
	if (use == 1){
		pool = space->pool;
		possess(pool->have);
		space->next = pool->head;
		pool->head = space;
		twist(pool->have,BY,+1);
	}
	twist(space->use,BY,-1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2696
jmp 0x2721
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x8040
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x86a0
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jne 0x2708
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8040
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x8280
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x8280
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: free_job
local void free_job(struct job* job){
	if (job == NULL) return;
	if (g.outraw){
		possess(job->calc);
		wait_for(job->calc,TO,1);
		release(job->calc);
		free_lock(job->calc);
	}
	if (job->buffer1 != NULL) free(job->buffer1);
	if (g.single_or_pair) if (job->buffer2 != NULL) free(job->buffer2);
	if (job->buffer1_raw != NULL) free(job->buffer1_raw);
	if (g.single_or_pair) if (job->buffer2_raw != NULL) free(job->buffer2_raw);
	free(job);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2741
jmp 0x2804
cmpb $0x0, 0xaacc(%rip)      # 0xd214
je 0x2785
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8040
movq (%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x8310
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8080
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x7fe0
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x279d
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
cmpb $0x0, 0xaa34(%rip)      # 0xd1d8
je 0x27c0
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x27be
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
jmp 0x27c0
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x27d8
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x2040
cmpb $0x0, 0xa9f9(%rip)      # 0xd1d8
je 0x27fb
movq (%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x27f9
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x2040
jmp 0x27fb
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: writen_raw
void writen_raw(void){
	struct job* job;
	long seq = 0;
	FILE* fpout1_raw = g.fpout1_raw;
	FILE* fpout2_raw = g.fpout2_raw;
	for(;;){
		possess(write_first_raw);
		wait_for(write_first_raw,TO_BE,seq);
		job = write_head_raw;
		write_head_raw = job->next1;
		twist(write_first_raw,TO,write_head_raw == NULL? -1:write_head_raw->seq);
		seq++;
		if (!job->more) break;
		fwrite(job->buffer1_raw,sizeof(char),job->l1_r,fpout1_raw);
		if (g.single_or_pair) fwrite(job->buffer2_raw,sizeof(char),job->l2_r,fpout2_raw);
		possess(job->calc);
		twist(job->calc,TO,1);
	}

	possess(job->calc);
	twist(job->calc,TO,1);

	possess(write_first_raw);
	if (write_head_raw != NULL)
		fail();
	twist(write_first_raw,TO,-1);
}

// Assembly:
subq $0x38, %rsp
movq $0x0, 0x28(%rsp)
movq 0xaa8c(%rip), %rax      # 0xd2b0
movq %rax, 0x20(%rsp)
movq 0xaa88(%rip), %rax      # 0xd2b8
movq %rax, 0x18(%rsp)
movq 0xaac4(%rip), %rdi      # 0xd300
callq 0x8040
movq 0xaab8(%rip), %rdi      # 0xd300
movq 0x28(%rsp), %rdx
xorl %esi, %esi
callq 0x8310
movq 0xaaad(%rip), %rax      # 0xd308
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0xaa98(%rip)      # 0xd308
movq 0xaa89(%rip), %rax      # 0xd300
movq %rax, 0x10(%rsp)
cmpq $0x0, 0xaa84(%rip)      # 0xd308
jne 0x2894
movq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x28a3
movq 0xaa6d(%rip), %rax      # 0xd308
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x28cf
jmp 0x2942
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x30(%rsp), %rax
movslq 0x58(%rax), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0x22b0
cmpb $0x0, 0xa8e1(%rip)      # 0xd1d8
je 0x291a
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x30(%rsp), %rax
movslq 0x68(%rax), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x22b0
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8040
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x8280
jmp 0x2835
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8040
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x8280
movq 0xa994(%rip), %rdi      # 0xd300
callq 0x8040
cmpq $0x0, 0xa98f(%rip)      # 0xd308
je 0x299a
movq 0xa676(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x79d4(%rip), %rsi      # 0xa360
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0xa95f(%rip), %rdi      # 0xd300
xorl %esi, %esi
movq $-0x1, %rdx
callq 0x8280
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: parallel_filter_main
void parallel_filter_main(void){
	setup_jobs();
	struct job* job = NULL;
	int more;
	long seq = 0;
	int cthreads = 0;
	thread* writeth = launch((void*)writen,NULL);
	thread* writeth_raw = NULL;
	if (g.outraw) {
		writeth_raw= launch((void*)writen_raw,NULL);
	}
	if (g.Nthread <= 0) {
		fprintf(stderr, "Nthread is wrong!\n");
		exit(0);
	}

	do{
		job = new_job();
		job->in = get_space(&in_pool);
		more = readn(job->in);
		job->more = more;
		job->seq = seq;

		if (cthreads++ < g.Nthread){
			launch((void*)filter_pair,NULL);
		}
		seq++;
		possess(compress_have);
		job->next = NULL;
		*compress_tail = job;
		compress_tail = &(job->next);
		twist(compress_have,BY,+1);
	}while(more);

	join(writeth);
	if (writeth_raw != NULL) join(writeth_raw);
	finish_jobs();
}

// Assembly:
subq $0x38, %rsp
callq 0x2b50
movq $0x0, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
leaq -0x59a(%rip), %rdi      # 0x2450
xorl %eax, %eax
movl %eax, %esi
callq 0x80c0
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpb $0x0, 0xa80c(%rip)      # 0xd214
je 0x2a1f
leaq -0x201(%rip), %rdi      # 0x2810
xorl %eax, %eax
movl %eax, %esi
callq 0x80c0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xa7ea(%rip)      # 0xd210
jg 0x2a47
movq 0xa5c9(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x792e(%rip), %rsi      # 0xa367
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x2a49
callq 0x2c10
movq %rax, 0x30(%rsp)
leaq 0xa87e(%rip), %rdi      # 0xd2d8
callq 0x2c90
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2d80
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rsp)
cmpl 0xa767(%rip), %eax      # 0xd210
jge 0x2abb
leaq 0x4ee(%rip), %rdi       # 0x2fa0
xorl %eax, %eax
movl %eax, %esi
callq 0x80c0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0xa820(%rip), %rdi      # 0xd2f0
callq 0x8040
movq 0x30(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x30(%rsp), %rcx
movq 0xa822(%rip), %rax      # 0xd310
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xa80f(%rip)      # 0xd310
movq 0xa7e8(%rip), %rdi      # 0xd2f0
movl $0x1, %esi
movl $0x1, %edx
callq 0x8280
cmpl $0x0, 0x2c(%rsp)
jne 0x2a49
movq 0x10(%rsp), %rdi
callq 0x84b0
cmpq $0x0, 0x8(%rsp)
je 0x2b3e
movq 0x8(%rsp), %rdi
callq 0x84b0
callq 0x3550
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: setup_jobs
local void setup_jobs(void) {
	if (compress_have != NULL)
		return;
    // allocate locks and initialize lists
    compress_have = new_lock(0);
    compress_head = NULL;
    compress_tail = &compress_head;
    write_first = new_lock(-1);
    write_head = NULL;
    write_first_raw = new_lock(-1);
    write_head_raw = NULL;
    if (g.outraw) g.Nthread-=3;
    else g.Nthread-=2;
    new_pool(&in_pool, g.Nthread);
}

// Assembly:
pushq %rax
cmpq $0x0, 0xa797(%rip)      # 0xd2f0
je 0x2b60
jmp 0x2c00
xorl %eax, %eax
movl %eax, %edi
callq 0x7f60
movq %rax, 0xa780(%rip)      # 0xd2f0
movq $0x0, 0xa77d(%rip) # 0xd2f8
leaq 0xa776(%rip), %rax      # 0xd2f8
movq %rax, 0xa787(%rip)      # 0xd310
movq $-0x1, %rdi
callq 0x7f60
movq %rax, 0xa72c(%rip)      # 0xd2c8
movq $0x0, 0xa729(%rip) # 0xd2d0
movq $-0x1, %rdi
callq 0x7f60
movq %rax, 0xa746(%rip)      # 0xd300
movq $0x0, 0xa743(%rip) # 0xd308
cmpb $0x0, 0xa648(%rip)      # 0xd214
je 0x2bdf
movl 0xa63c(%rip), %eax      # 0xd210
subl $0x3, %eax
movl %eax, 0xa633(%rip)      # 0xd210
jmp 0x2bee
movl 0xa62b(%rip), %eax      # 0xd210
subl $0x2, %eax
movl %eax, 0xa622(%rip)      # 0xd210
movl 0xa61c(%rip), %esi      # 0xd210
leaq 0xa6dd(%rip), %rdi      # 0xd2d8
callq 0x3cf0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: new_job
local job* new_job(void){
	job* job = (struct job*)malloc(sizeof(struct job));
	job->next = NULL;
	job->next1 = NULL;
	job->buffer1 = NULL;
	job->buffer2 = NULL;
	job->buffer1_raw = NULL;
	job->buffer2_raw = NULL;
	if (g.outraw){
		job->calc = new_lock(0);
	}
	return(job);
}

// Assembly:
pushq %rax
movl $0x70, %edi
callq 0x21b0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
cmpb $0x0, 0xa5a6(%rip)      # 0xd214
je 0x2c84
xorl %eax, %eax
movl %eax, %edi
callq 0x7f60
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)