LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lengjingzju[P]json/json.c
// Function: pjson_add_new_item_to_object
json_object *pjson_add_new_item_to_object(json_object *object, json_type_t type, json_string_t *jkey, void *value, json_mem_t *mem)
{
    json_object *item = NULL;

    if (object->type_member == JSON_OBJECT) {
        switch (type) {
        case JSON_NULL:
        case JSON_BOOL:
        case JSON_INT:
        case JSON_HEX:
        case JSON_LINT:
        case JSON_LHEX:
        case JSON_DOUBLE:
        case JSON_STRING:
        case JSON_ARRAY:
        case JSON_OBJECT:
            if ((item = pjson_create_item(type, value, mem)) == NULL) {
                JsonErr("create item failed!\n");
                return NULL;
            }
            if (pjson_set_key(item, jkey, mem) < 0) {
                JsonErr("add key failed!\n");
                return NULL;
            }
            json_list_add_tail(&item->list, &object->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x3f8c
cmpl $0x9, %esi
ja 0x3f90
movq %r8, %r15
movq %rdx, %r12
movq %rdi, %r14
movl %esi, %edi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x21c0
testq %rax, %rax
je 0x3fb5
movq %rax, %rbx
leaq 0x8(%rax), %rsi
addq $0x28, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x2220
testl %eax, %eax
js 0x3fda
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x4002
xorl %ebx, %ebx
jmp 0x4002
leaq 0x6309(%rip), %rdi      # 0xa2a0
leaq 0x63fc(%rip), %rsi      # 0xa39a
xorl %ebx, %ebx
movl $0x566, %edx            # imm = 0x566
xorl %eax, %eax
callq 0x2100
leaq 0x6777(%rip), %rdi      # 0xa72a
jmp 0x3ffd
leaq 0x62e4(%rip), %rdi      # 0xa2a0
leaq 0x63d7(%rip), %rsi      # 0xa39a
xorl %ebx, %ebx
movl $0x55c, %edx            # imm = 0x55C
xorl %eax, %eax
callq 0x2100
leaq 0x673e(%rip), %rdi      # 0xa716
jmp 0x3ffd
leaq 0x62bf(%rip), %rdi      # 0xa2a0
leaq 0x63b2(%rip), %rsi      # 0xa39a
xorl %ebx, %ebx
movl $0x560, %edx            # imm = 0x560
xorl %eax, %eax
callq 0x2100
leaq 0x6709(%rip), %rdi      # 0xa706
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/9-File/read_eof.c
// Function: main
int main(void)
{
	int ret;
	char c;
	unsigned long long count = 0;
	while(1)
	{
		ret = read(fileno(stdin), &c, 1);
		if(ret == 0)
			break;
		else
		{
			count += ret;
			if(c == EOF)
				printf("WoW!\n");
		}
	}
	printf("EOF is reached. Read %lld bytes.\n", count);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
movq 0x2e5e(%rip), %r13      # 0x3fe0
leaq 0xf(%rsp), %r14
pushq $0x1
popq %r15
leaq 0xe94(%rip), %r12       # 0x2026
movq (%r13), %rdi
callq 0x1060
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
je 0x11c2
cltq
addq %rax, %rbx
cmpb $-0x1, 0xf(%rsp)
jne 0x1192
movq %r12, %rdi
callq 0x1030
jmp 0x1192
leaq 0xe3b(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_init
int mtgp32_init(mtgp32_ref_t *mtgp32,
		const mtgp32_params_ref_t *para, uint32_t seed) {
    int i;
    int size = para->mexp / 32 + 1;
    uint32_t hidden_seed;
    uint32_t tmp;
    mtgp32_status_ref_t *st;

    st = (mtgp32_status_ref_t *)malloc(sizeof(mtgp32_status_ref_t)
				     + sizeof(uint32_t) * size);
    if (st == NULL) {
	return -1;
    }
    hidden_seed = para->tbl[2] ^ (para->tbl[3] << 16);
    tmp = hidden_seed;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(st->array, tmp & 0xff, sizeof(uint32_t) * size);
    mtgp32->params = *para;
    mtgp32->status = st;
    st->size = size;
    st->idx = size - 1;
    st->array[0] = seed;
    st->array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	st->array[i] ^= UINT32_C(1812433253) * (st->array[i - 1]
						^ (st->array[i - 1] >> 30))
	    + i;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %eax
pushq $0x20
popq %rcx
cltd
idivl %ecx
movslq %eax, %r13
leaq 0xc(,%r13,4), %rdi
callq 0x10d0
testq %rax, %rax
je 0x1296
movq %rax, %r14
leal 0x1(%r13), %eax
movl %eax, 0x4(%rsp)
leaq 0x4(,%r13,4), %rdx
movl 0x1c(%r12), %ebp
shll $0x10, %ebp
xorl 0x18(%r12), %ebp
movl %ebp, %eax
shrl $0x10, %eax
addl %ebp, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
movq %r14, %rdi
addq $0x8, %rdi
callq 0x1090
pushq $0x13
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
rep  movsl (%rsi), %es:(%rdi)
movq %r14, 0x50(%r15)
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movl %r13d, 0x4(%r14)
movl %ebx, 0x8(%r14)
movl %ebp, 0xc(%r14)
pushq $0x1
popq %rax
cmpq %r13, %rax
jg 0x1292
movl %ebx, %ecx
shrl $0x1e, %ecx
xorl %ebx, %ecx
imull $0x6c078965, %ecx, %ebx # imm = 0x6C078965
addl %eax, %ebx
xorl 0x8(%r14,%rax,4), %ebx
movl %ebx, 0x8(%r14,%rax,4)
incq %rax
jmp 0x126f
xorl %eax, %eax
jmp 0x1299
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_print_idstring
void mtgp32_print_idstring(const mtgp32_ref_t *mtgp32, FILE *fp) {
    int i;
    fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x7bf(%rip), %rsi       # 0x200c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
pushq $-0x14
popq %r12
leaq 0x7b5(%rip), %r15       # 0x2017
testq %r12, %r12
je 0x187f
movzbl 0x48(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
jmp 0x1862
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-ref.c
// Function: mtgp32_genrand_uint32
static void next_state(mtgp32_ref_t *mtgp32) {
    uint32_t *array = mtgp32->status->array;
    int idx;
    int size = mtgp32->status->size;
    uint32_t x;
    uint32_t y;
    uint32_t yl;

    mtgp32->status->idx += 1;
    if (mtgp32->status->idx >= size) {
	mtgp32->status->idx = 0;
    }
    idx = mtgp32->status->idx;
    x = (array[idx] & mtgp32->params.mask) ^ array[(idx + 1) % size];
    y = array[(idx + mtgp32->params.pos) % size];
    x ^= x << mtgp32->params.sh1;
    y = x ^ (y >> mtgp32->params.sh2);
    yl = y & 0x0f;
    if (yl & 1) {
	y ^= mtgp32->params.tbl[0];
    }
    if (yl & 2) {
	y ^= mtgp32->params.tbl[1];
    }
    if (yl & 4) {
	y ^= mtgp32->params.tbl[2];
    }
    if (yl & 8) {
	y ^= mtgp32->params.tbl[3];
    }
    array[idx] = y;
}

// Assembly:
movq 0x50(%rdi), %rsi
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
incl %eax
xorl %edx, %edx
cmpl %ecx, %eax
cmovll %eax, %edx
movl %edx, 0x4(%rsi)
movslq %edx, %r8
movl 0x30(%rdi), %r9d
andl 0x8(%rsi,%r8,4), %r9d
leal 0x1(%r8), %eax
cltd
idivl %ecx
movslq %edx, %rax
xorl 0x8(%rsi,%rax,4), %r9d
movl 0x4(%rdi), %eax
addl %r8d, %eax
cltd
idivl %ecx
movslq %edx, %rax
movl 0x8(%rsi,%rax,4), %r10d
movb 0x8(%rdi), %cl
movb 0xc(%rdi), %al
movl %r9d, %edx
shll %cl, %edx
movl %eax, %ecx
shrl %cl, %r10d
xorl %r9d, %edx
xorl %r10d, %edx
movl %edx, %eax
testb $0x1, %dl
je 0x18f8
movl 0x10(%rdi), %eax
xorl %edx, %eax
testb $0x2, %dl
je 0x1900
xorl 0x14(%rdi), %eax
testb $0x4, %dl
je 0x1908
xorl 0x18(%rdi), %eax
testb $0x8, %dl
je 0x1910
xorl 0x1c(%rdi), %eax
movl %eax, 0x8(%rsi,%r8,4)
movq 0x50(%rdi), %rsi
movslq 0x4(%rsi), %rax
movl 0x8(%rsi,%rax,4), %ecx
movl 0x4(%rdi), %edx
addl %edx, %eax
decl %eax
cltd
idivl (%rsi)
movslq %edx, %rax
movl 0x8(%rsi,%rax,4), %eax
movl %eax, %edx
shrl $0x10, %edx
xorl %eax, %edx
movl %edx, %eax
shrl $0x8, %eax
xorl %edx, %eax
testb $0x1, %al
je 0x1947
xorl 0x20(%rdi), %ecx
testb $0x2, %al
je 0x194e
xorl 0x24(%rdi), %ecx
testb $0x4, %al
je 0x1955
xorl 0x28(%rdi), %ecx
testb $0x8, %al
je 0x195c
xorl 0x2c(%rdi), %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
callq 0x1895
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movd %eax, %xmm0
addss 0x650(%rip), %xmm0      # 0x2004
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebp
pushq $0x4
popq %rbx
leaq 0x645(%rip), %r15       # 0x201c
movl %ebp, 0x4(%rsp)
xorl %r12d, %r12d
movl %r12d, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %ebp
jb 0x1a1c
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1895
movq %r15, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1080
testl %r13d, %r13d
jne 0x1a15
pushq $0xa
popq %rdi
callq 0x1040
incl %r12d
decl %ebx
jmp 0x19de
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1a3e
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x5b2(%rip), %r15       # 0x2022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1ab4
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x195f
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1aae
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1a75
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1ac8
pushq $0xa
popq %rdi
callq 0x1040
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x521(%rip), %r15       # 0x2022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1b45
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1973
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1b3f
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1b06
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1b67
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x489(%rip), %r15       # 0x2022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1bdd
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1983
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1bd7
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1b9e
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1bff
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x3f1(%rip), %r15       # 0x2022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1c75
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x199a
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1c6f
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1c36
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1c97
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leal 0x1(%rdi), %eax
movq %rsp, %rbx
imulq $0xff, %rax, %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x118c
leaq 0xd70(%rip), %rdi       # 0x2004
movq %rbx, %rsi
callq 0x1040
testl %eax, %eax
jne 0x12c3
leaq 0x1fe(%rbx), %rsi
addq $0xff, %rbx
movq %rbx, %rdi
callq 0x1060
testl %eax, %eax
js 0x12cc
xorl %eax, %eax
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
leaq 0xd4e(%rip), %rdi       # 0x2018
jmp 0x12d3
leaq 0xd36(%rip), %rdi       # 0x2009
callq 0x1050
jmp 0x12ba
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movl $0x2000000, %esi        # imm = 0x2000000
cmpl $0x2, %edi
jl 0x12eb
movq 0x8(%rax), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x1100
movq %rax, %rsi
shll $0x14, %esi
leaq 0x5ede(%rip), %rdi      # 0x71d0
callq 0x15ac
movl $0x2000000, %edi        # imm = 0x2000000
callq 0x13e6
pushq $0x2
popq %rbp
leaq 0x2d26(%rip), %r13      # 0x4031
pushq $0x20
popq %rbx
pushq $0x1
popq %r14
cmpl $0x8, %ebp
je 0x13d5
leaq 0x2cfe(%rip), %rdi      # 0x4020
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
xorl %edi, %edi
callq 0x11b0
leaq 0x2cf3(%rip), %rdi      # 0x402c
callq 0x10b0
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x5e84(%rip), %rdi      # 0x71d0
movl %ebp, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
callq 0x1921
leaq 0x2cc6(%rip), %rdi      # 0x4033
movq %r13, %rsi
callq 0x10a0
movq %rax, 0x5ed4(%rip)      # 0x7250
movl 0x5ed6(%rip), %eax      # 0x7258
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x13c2
movq 0x5ec9(%rip), %rdi      # 0x7260
cmpq $0x0, (%rdi,%r15)
je 0x13b9
addq %r15, %rdi
movq 0x5ea8(%rip), %rcx      # 0x7250
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1150
movl 0x5e9f(%rip), %eax      # 0x7258
incq %r12
addq $0x20, %r15
jmp 0x1388
movq 0x5e87(%rip), %rdi      # 0x7250
callq 0x1130
incl %ebp
jmp 0x1312
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x1412
movq %rax, 0x5e2e(%rip)      # 0x7268
xorl %ebx, %ebx
leaq 0x5e2d(%rip), %r14      # 0x7270
leaq 0x6536(%rip), %r15      # 0x7980
cmpq $0x708, %rbx            # imm = 0x708
je 0x146b
callq 0x1412
movq %rax, (%rbx,%r14)
callq 0x1412
movq %rax, (%rbx,%r15)
addq $0x8, %rbx
jmp 0x144a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x8(%rsp), %rcx
movslq 0x6b6f(%rip), %rsi      # 0x8088
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq 0x6b68(%rip), %rax      # 0x8090
movslq %edx, %rdx
shlq $0x5, %rdx
movaps 0x8(%rsp), %xmm0
movaps 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%rdx)
movups %xmm0, (%rax,%rdx)
movslq 0x5d0f(%rip), %rsi      # 0x7258
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movl 0x10(%rsp), %esi
movq 0x5d04(%rip), %rax      # 0x7260
movslq %edx, %rcx
shlq $0x5, %rcx
cmpl 0x8(%rax,%rcx), %esi
jle 0x157f
leaq 0x8(%rsp), %rdx
addq %rcx, %rax
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x159b(%rip), %rdi      # 0x3143
pushq $0x1e
popq %r15
pushq $0x1
popq %r14
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x159d(%rip), %rdi      # 0x3162
pushq $0x23
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x15ac(%rip), %rdi      # 0x3186
pushq $0x30
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x15c8(%rip), %rdi      # 0x31b7
pushq $0x2b
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x15df(%rip), %rdi      # 0x31e3
pushq $0x21
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x15ec(%rip), %rdi      # 0x3205
pushq $0x2c
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x1604(%rip), %rdi      # 0x3232
pushq $0x25
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x1615(%rip), %rdi      # 0x3258
pushq $0x20
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x1621(%rip), %rdi      # 0x3279
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
leaq 0x162b(%rip), %rdi      # 0x3298
pushq $0x1a
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
shrq $0x20, %rax
xorq %rdi, %rax
movabsq $0x25b751109e05be63, %rcx # imm = 0x25B751109E05BE63
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
xorq %rcx, %rax
movabsq $0x2330e1453ed4b9b9, %rcx # imm = 0x2330E1453ED4B9B9
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rdi
xorl %r12d, %r12d
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x1070
cmpq $0x10000, %r12          # imm = 0x10000
je 0x1d41
movq %r14, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0x1f8d
movl %eax, %ebp
movq %rsp, %r13
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x1d3c
movl %r12d, %edx
btcl %r15d, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1f8d
xorl %ebp, %eax
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x1d30
btl %ecx, %eax
adcq $0x0, (%r13,%rcx,8)
incq %rcx
jmp 0x1d1c
incq %r15
addq $0x100, %r13            # imm = 0x100
jmp 0x1d01
incq %r12
jmp 0x1ce3
xorpd %xmm0, %xmm0
movq %rsp, %rax
xorl %ecx, %ecx
movq $-0x8000, %rdx          # imm = 0x8000
movsd 0x12b7(%rip), %xmm1     # 0x3010
movsd 0x12b7(%rip), %xmm2     # 0x3018
cmpq $0x10, %rcx
je 0x1d9b
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x1d90
movq (%rax,%rsi,8), %rdi
addq %rdx, %rdi
cvtsi2sd %rdi, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rsi
jmp 0x1d69
incq %rcx
addq $0x100, %rax            # imm = 0x100
jmp 0x1d61
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1dbb
sqrtsd %xmm0, %xmm0
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %r8d, %r8d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %r8, %rcx
cmpq %r8, %rax
je 0x1f81
movl (%rdi,%rcx,8), %r9d
leaq 0x1(%rcx), %r8
btl %r9d, %edx
jae 0x1f6b
movslq %esi, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %eax
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
leaq 0x10e5(%rip), %r9       # 0x3084
leaq 0x311a(%rip), %r10      # 0x50c0
cmpq %r8, %rsi
je 0x2038
movl (%rdi,%r8,8), %ecx
cmpq $0x9, %rcx
ja 0x202d
movslq (%r9,%rcx,4), %rcx
addq %r9, %rcx
jmpq *%rcx
xorl 0x4(%rdi,%r8,8), %eax
jmp 0x202d
notl %eax
jmp 0x202d
movl %eax, %eax
movzwl (%r10,%rax,2), %eax
jmp 0x202d
addl 0x4(%rdi,%r8,8), %eax
jmp 0x202d
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %r11d
shll %cl, %r11d
movb $0x10, %dl
subb %cl, %dl
movl %edx, %ecx
shrl %cl, %eax
orl %r11d, %eax
jmp 0x202d
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
addl %edx, %eax
jmp 0x202d
imull 0x4(%rdi,%r8,8), %eax
jmp 0x202d
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
jmp 0x201e
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shrl %cl, %edx
xorl %edx, %eax
jmp 0x202d
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
subl %edx, %eax
movzwl %ax, %eax
incq %r8
jmp 0x1fa6
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movabsq $0x7c3c3267d015ceb5, %rdx # imm = 0x7C3C3267D015CEB5
imulq %rax, %rdx
incq %rdx
movq %rdx, (%rdi)
shrq $0x30, %rax
xorl %eax, %ecx
imull $0x60857ba9, %ecx, %eax # imm = 0x60857BA9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x103e(%rip), %rax      # 0x30ac
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rsi, %rdi
callq 0x2039
pushq $0xf
popq %rcx
xorl %edx, %edx
divl %ecx
incl %edx
jmp 0x20b2
xorl %edx, %edx
jmp 0x20b2
movq %rsi, %rdi
callq 0x2039
movq %rax, %rdx
shrq $0x10, %rdx
jmp 0x20b2
movq %rsi, %rdi
callq 0x2039
movq %rax, %rdx
shrq $0x10, %rdx
orq $0x1, %rdx
shlq $0x20, %rdx
orq %rdx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x1080
callq 0x1050
movl %eax, %ebx
pushq $0x40
popq %rdi
callq 0x1060
movq %rax, %r14
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x2ee9(%rip)     # 0x40c0
leaq 0x2ee2(%rip), %r15      # 0x40c0
callq 0x1070
leaq 0x2e86(%rip), %rsi      # 0x4070
pushq $0x8
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq $0x4
callq 0x10a0
addq $0x10, %rsp
leaq 0xdf7(%rip), %r15       # 0x2004
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x122e
movq (%r14,%r12,8), %rcx
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1030
incq %r12
jmp 0x1210
callq 0x1070
movq %r14, %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x26c9
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x7ba5(%rip)      # 0xa204
je 0x268a
movq 0x18(%rbx), %rdi
callq 0x5ccb
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x5ea2
movq 0x18(%rbx), %rdi
callq 0x5cfa
movq 0x18(%rbx), %rdi
callq 0x5c7d
movq 0x30(%rbx), %rdi
callq 0x2040
cmpb $0x0, 0x7b2e(%rip)      # 0xa1c8
je 0x26a5
movq 0x40(%rbx), %rdi
callq 0x2040
movq 0x50(%rbx), %rdi
callq 0x2040
cmpb $0x0, 0x7b13(%rip)      # 0xa1c8
je 0x26c0
movq 0x60(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x7bc4(%rip), %rbx      # 0xa2a0
movq 0x7bc5(%rip), %r14      # 0xa2a8
xorl %r15d, %r15d
pushq $-0x1
popq %r13
pushq $0x1
popq %r12
movq 0x7bfb(%rip), %rdi      # 0xa2f0
callq 0x5ccb
movq 0x7bef(%rip), %rdi      # 0xa2f0
xorl %esi, %esi
movq %r15, %rdx
callq 0x5ea2
movq 0x7be6(%rip), %rbp      # 0xa2f8
movq 0x28(%rbp), %rax
movq %rax, 0x7bdb(%rip)      # 0xa2f8
movq 0x7bcc(%rip), %rdi      # 0xa2f0
movq %r13, %rdx
testq %rax, %rax
je 0x272f
movq (%rax), %rdx
xorl %esi, %esi
callq 0x5e4d
cmpl $0x0, 0x8(%rbp)
je 0x278a
movq 0x50(%rbp), %rdi
movslq 0x58(%rbp), %rdx
movq %r12, %rsi
movq %rbx, %rcx
callq 0x22c0
cmpb $0x0, 0x7a72(%rip)      # 0xa1c8
je 0x276b
movq 0x60(%rbp), %rdi
movslq 0x68(%rbp), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x22c0
movq 0x18(%rbp), %rdi
callq 0x5ccb
movq 0x18(%rbp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x5e4d
incq %r15
jmp 0x26ee
movq 0x18(%rbp), %rdi
callq 0x5ccb
movq 0x18(%rbp), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x5e4d
movq 0x7b48(%rip), %rdi      # 0xa2f0
callq 0x5ccb
cmpq $0x0, 0x7b43(%rip)      # 0xa2f8
jne 0x27d6
movq 0x7b32(%rip), %rdi      # 0xa2f0
pushq $-0x1
popq %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5e4d
movq 0x781b(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x4869(%rip), %rdi      # 0x7050
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq $0x70
popq %rdi
callq 0x21c0
movq %rax, %rbx
andq $0x0, 0x40(%rax)
andq $0x0, 0x50(%rax)
andq $0x0, 0x60(%rax)
andq $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
cmpb $0x0, 0x7742(%rip)      # 0xa204
je 0x2acf
xorl %edi, %edi
callq 0x5c1c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: get_space
local space* get_space(struct pool* pool){
	struct space* space;
	possess(pool->have);
	
	if (pool->limit == 0){
		wait_for(pool->have, NOT_TO_BE, 0);
	}
	
	if (pool->head != NULL){
		space = pool->head;
		possess(space->use);
		pool->head = space->next;
		twist(pool->have,BY,-1);
		twist(space->use,TO,1);
		return(space);
	}
	if (pool->limit > 0){
		pool->limit--;
	}
	release(pool->have);
	space = new_space(pool);
	return(space);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x77e8(%rip), %rdi      # 0xa2c8
callq 0x5ccb
cmpl $0x0, 0x77ec(%rip)      # 0xa2d8
jne 0x2aff
movq 0x77d3(%rip), %rdi      # 0xa2c8
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x5ea2
movq 0x77ca(%rip), %rbx      # 0xa2d0
testq %rbx, %rbx
je 0x2b46
movq (%rbx), %rdi
callq 0x5ccb
movq 0x10(%rbx), %rax
movq %rax, 0x77b2(%rip)      # 0xa2d0
movq 0x77a3(%rip), %rdi      # 0xa2c8
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
callq 0x5e4d
movq (%rbx), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x5e4d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x778c(%rip), %eax      # 0xa2d8
testl %eax, %eax
jle 0x2b58
decl %eax
movl %eax, 0x7780(%rip)      # 0xa2d8
leaq 0x7769(%rip), %r14      # 0xa2c8
movq 0x7762(%rip), %rdi      # 0xa2c8
callq 0x5cfa
pushq $0x20
popq %rdi
callq 0x21c0
movq %rax, %rbx
pushq $0x1
popq %r15
movq %r15, %rdi
callq 0x5c1c
movq %rax, (%rbx)
movq %r14, 0x18(%rbx)
andq $0x0, 0x10(%rbx)
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl $0x6e078, %esi          # imm = 0x6E078
movq %r15, %rdi
callq 0x2140
andq $0x0, 0x8(%r14)
movq %rax, 0x10(%r14)
movl $0x1428, %esi           # imm = 0x1428
movq %r15, %rdi
callq 0x2140
movq %rax, (%r14)
movq 0x764e(%rip), %rdi      # 0xa218
cmpb $0x0, (%rdi)
je 0x2be4
movl 0x7653(%rip), %esi      # 0xa228
callq 0x62d0
movq (%r14), %rcx
movq %rax, 0x1420(%rcx)
cmpb $0x0, 0x75dd(%rip)      # 0xa1c8
je 0x2b3d
pushq $0x1
popq %rdi
movl $0x1428, %esi           # imm = 0x1428
callq 0x2140
movq %rax, 0x8(%r14)
movq 0x7617(%rip), %rdi      # 0xa220
cmpb $0x0, (%rdi)
je 0x2b3d
movl 0x7610(%rip), %esi      # 0xa228
callq 0x62d0
movq 0x8(%r14), %rcx
movq %rax, 0x1420(%rcx)
jmp 0x2b3d
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: readn
local int readn(struct space* space){
	if (!space->pool->term) return(0);
	readline* read1 = space->readclass->read1;
	if (!gzgets(g.gzfp1,read1->reads[0],1024)) return(0);
	else g.read1Count++;
	if (!gzgets(g.gzfp1,read1->reads[1],1024))	return(0);
	if (!gzgets(g.gzfp1,read1->reads[2],1024))	return(0);
	if (!gzgets(g.gzfp1,read1->reads[3],1024))	return(0);

	if (g.single_or_pair){
		readline* read2 = space->readclass->read2;
		if (!gzgets(g.gzfp2,read2->reads[0],1024)) return(0);
		else g.read2Count++;
		if (!gzgets(g.gzfp2,read2->reads[1],1024))	return(0);
		if (!gzgets(g.gzfp2,read2->reads[2],1024))	return(0);
		if (!gzgets(g.gzfp2,read2->reads[3],1024))	return(0);
	}
	return(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
xorl %ebx, %ebx
cmpb $0x0, 0x14(%rax)
je 0x2d6a
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %r15
movq 0x762d(%rip), %rdi      # 0xa280
leaq 0x1d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
incq 0x7597(%rip)            # 0xa208
movq 0x7608(%rip), %rdi      # 0xa280
leaq 0x41d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
movq 0x75e7(%rip), %rdi      # 0xa280
leaq 0x81d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
movq 0x75c6(%rip), %rdi      # 0xa280
addq $0xc1d, %r15            # imm = 0xC1D
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
cmpb $0x0, 0x74ea(%rip)      # 0xa1c8
je 0x2d67
movq 0x8(%r14), %rax
movq 0x8(%rax), %r14
movq 0x7595(%rip), %rdi      # 0xa288
leaq 0x1d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
incq 0x7503(%rip)            # 0xa210
movq 0x7574(%rip), %rdi      # 0xa288
leaq 0x41d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
movq 0x7557(%rip), %rdi      # 0xa288
leaq 0x81d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
movq 0x753a(%rip), %rdi      # 0xa288
addq $0xc1d, %r14            # imm = 0xC1D
movq %r14, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x2d6a
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: new_pool
local void new_pool(pool* pool, int limit){
	pool->have = new_lock(0);
	pool->head = NULL;
	pool->limit = limit;
	pool->term = 1;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
xorl %edi, %edi
callq 0x5c1c
movq %rax, 0x6d07(%rip)      # 0xa2c8
andq $0x0, 0x6d07(%rip)      # 0xa2d0
movl %ebx, 0x6d09(%rip)      # 0xa2d8
movb $0x1, 0x6d06(%rip)      # 0xa2dc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: to_buffer_raw
local void to_buffer_raw(struct readclass* readclass, struct job* job){
	if (job->buffer1_raw == NULL) {job->buffer1_raw = malloc(1024*4);memset(job->buffer1_raw,0,1024*4);}
	char* cur1 = job->buffer1_raw;
	char (*reads1)[1024] = readclass->read1->reads;
	int i,j;
	for (i=0;i<4;i++){
		j=0;
		while( (*cur1++ = reads1[i][j++]) != '\n' ){}
	}
	*cur1 = '\0';
	job->l1_r = strlen(job->buffer1_raw);
	if (g.single_or_pair){
		if (job->buffer2_raw == NULL) {job->buffer2_raw = malloc(1024*4);memset(job->buffer2_raw,0,1024*4);}
		char* cur2 = job->buffer2_raw;
		char (*reads2)[1024] = readclass->read2->reads;
		for (i=0;i<4;i++){
			j=0;
			while( (*cur2++ = reads2[i][j++]) != '\n' ){}
		}
		*cur2 = '\0';
		job->l2_r = strlen(job->buffer2_raw);
	}
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %rax
testq %rax, %rax
jne 0x35fc
pushq $0x1
popq %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2140
movq %rax, 0x50(%rbx)
movq (%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x362c
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x360e
incq %rdx
addq $0x400, %rcx            # imm = 0x400
jmp 0x3605
movb $0x0, (%rax)
movq 0x50(%rbx), %rdi
callq 0x20c0
movl %eax, 0x58(%rbx)
cmpb $0x0, 0x6b86(%rip)      # 0xa1c8
je 0x369e
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x365e
pushq $0x1
popq %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2140
movq %rax, 0x60(%rbx)
movq 0x8(%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x368f
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x3671
incq %rdx
addq $0x400, %rcx            # imm = 0x400
jmp 0x3668
movb $0x0, (%rax)
movq 0x60(%rbx), %rdi
callq 0x20c0
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: substr_
local inline void substr_(const char* line, char* str){
	while(*line++ != '\n'){
		*str = *line;
		str++;
	}
	*str = '\0';
}

// Assembly:
movb (%rdi), %cl
xorl %eax, %eax
cmpb $0xa, %cl
je 0x36bb
movb 0x1(%rdi,%rax), %cl
movb %cl, (%rsi,%rax)
incq %rax
jmp 0x36aa
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: raw_Q30
local void raw_Q30(struct readclass* readclass){
	int i=0;
	int curqual;
	readline* read1 = readclass->read1;
	
	STAT* stat = readclass->stat;
	char* qual=(read1->reads)[3];
	while (i < read1->seqlen){
		curqual=(int)*(qual + i) - g.ASCII;
		if (curqual >= g.HIGHQ){
			stat->raw_Q30_bases++;
		}
		i++;
	}
	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		i = 0;
		qual=(read2->reads)[3];
		while (i < read2->seqlen){
			curqual=(int)*(qual + i) - g.ASCII;
			if (curqual >= g.HIGHQ){
				stat->raw_Q30_bases++;
			}
			i++;
		}
	}
		
	
}

// Assembly:
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movl (%rsi), %r8d
movl 0x6b2c(%rip), %ecx      # 0xa1fc
movl 0x6b0e(%rip), %edx      # 0xa1e4
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
cmpq %r9, %r8
je 0x36ff
movsbl 0xc1d(%rsi,%r9), %r10d
subl %ecx, %r10d
cmpl %edx, %r10d
jl 0x36fa
incq 0x40(%rax)
incq %r9
jmp 0x36e0
cmpb $0x0, 0x6ac2(%rip)      # 0xa1c8
je 0x3736
movq 0x8(%rdi), %rsi
movl (%rsi), %edi
xorl %r8d, %r8d
testl %edi, %edi
cmovlel %r8d, %edi
cmpq %r8, %rdi
je 0x3736
movsbl 0xc1d(%rsi,%r8), %r9d
subl %ecx, %r9d
cmpl %edx, %r9d
jl 0x3731
incq 0x40(%rax)
incq %r8
jmp 0x3717
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: cutseq
local void cutseq(struct readclass* readclass){
	readline* read1 = readclass->read1;
	memcpy((read1->reads)[1],(read1->reads)[1] + g.start,g.CUT);
	*((read1->reads)[1] + g.CUT) = '\n';
	*((read1->reads)[1] + g.CUT + 1) = '\0';
	memcpy((read1->reads)[3],(read1->reads)[3] + g.start,g.CUT);
	*((read1->reads)[3] + g.CUT) = '\n';
	*((read1->reads)[3] + g.CUT + 1) = '\0';
	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		memcpy((read2->reads)[1],(read2->reads)[1],g.CUT);
		*((read2->reads)[1] + g.CUT) = '\n';
		*((read2->reads)[1] + g.CUT + 1) = '\0';
		memcpy((read2->reads)[3],(read2->reads)[3],g.CUT);
		*((read2->reads)[3] + g.CUT) = '\n';
		*((read2->reads)[3] + g.CUT + 1) = '\0';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x41d(%r15), %rdi
movslq 0x6a7d(%rip), %rax      # 0xa1d0
leaq (%r15,%rax), %rsi
addq $0x41d, %rsi            # imm = 0x41D
movslq 0x6a67(%rip), %r14      # 0xa1cc
movq %r14, %rdx
callq 0x2170
movb $0xa, %bpl
movb %bpl, 0x41d(%r15,%r14)
movslq 0x6a4d(%rip), %rax      # 0xa1cc
xorl %r12d, %r12d
movb %r12b, 0x41e(%r15,%rax)
leaq 0xc1d(%r15), %rdi
movslq 0x6a38(%rip), %rax      # 0xa1d0
leaq (%r15,%rax), %rsi
addq $0xc1d, %rsi            # imm = 0xC1D
movslq 0x6a22(%rip), %r14      # 0xa1cc
movq %r14, %rdx
callq 0x2170
movb %bpl, 0xc1d(%r15,%r14)
movslq 0x6a0b(%rip), %rax      # 0xa1cc
movb %r12b, 0xc1e(%r15,%rax)
cmpb %r12b, 0x69f8(%rip)     # 0xa1c8
je 0x3812
movq 0x8(%rbx), %rax
movslq 0x69ef(%rip), %rcx      # 0xa1cc
movb %bpl, 0x41d(%rax,%rcx)
movslq 0x69e0(%rip), %rcx      # 0xa1cc
xorl %edx, %edx
movb %dl, 0x41e(%rax,%rcx)
movslq 0x69d0(%rip), %rcx      # 0xa1cc
movb %bpl, 0xc1d(%rax,%rcx)
movslq 0x69c1(%rip), %rcx      # 0xa1cc
movb %dl, 0xc1e(%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: checkadapter
local char checkadapter(struct readclass* readclass){
	char a,b;
	b = 1;
	readline* read1 = readclass->read1;
	if (read1->adapter){
		read1->adapter->n = read1->seqlen;
		read1->adapter->s2 = (read1->reads)[1];
		a = match(read1->adapter);
	}else{
		a= get_index(g.table1, read1->id);
	}

	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		if (read2->adapter){
			read2->adapter->n = read2->seqlen;
			read2->adapter->s2 = (read2->reads)[1];
			b = match(read2->adapter);
		}else{
			b= get_index(g.table2, read2->id);
		}
	}
	return(a * b);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x1420(%rsi), %rdi
testq %rdi, %rdi
je 0x384b
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x632c
jmp 0x385e
movq 0x69de(%rip), %rdi      # 0xa230
addq $0x101d, %rsi           # imm = 0x101D
callq 0x6286
movl %eax, %ebx
cmpb $0x0, 0x6961(%rip)      # 0xa1c8
je 0x3893
movq 0x8(%r14), %rsi
movq 0x1420(%rsi), %rdi
testq %rdi, %rdi
je 0x3897
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x632c
jmp 0x38aa
movb $0x1, %al
jmp 0x38aa
movq 0x699a(%rip), %rdi      # 0xa238
addq $0x101d, %rsi           # imm = 0x101D
callq 0x6286
mulb %bl
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: check_ployAT
local char check_ployAT(char* seq, int ployAT){
	if (ployAT>0){
		int seqlen = strlen(seq);
		int i;
		int count;
		if (seq[0] == 'A' || seq[0] == 'T') count = 1;
		for(i=1;i<seqlen;i++){
			if (seq[i]=='A' || seq[i]=='T'){
				if (seq[i] == seq[i-1]){
					count++;
					if (count == ployAT) return(1);
					continue;
				}
			}
			count = 0;
		}
	}
	return(0);
}

// Assembly:
testl %esi, %esi
jle 0x3b13
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x20c0
movslq %eax, %rcx
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
jge 0x3b18
movzbl (%r14,%rdx), %edi
cmpl $0x54, %edi
je 0x3afd
cmpl $0x41, %edi
jne 0x3b0c
cmpb -0x1(%r14,%rdx), %dil
jne 0x3b0c
incl %esi
movl %esi, %eax
cmpl %ebx, %esi
je 0x3b16
incq %rdx
movl %eax, %esi
jmp 0x3ae7
xorl %eax, %eax
retq
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq