LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_object
int pjson_copy_item_to_object(json_object *object, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

    if (object->type_member == JSON_OBJECT) {
        if ((node = pjson_deepcopy(item, mem)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &object->value.head);
        return 0;
    }

    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x9, %eax
jne 0x5bd4
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2170
testq %rax, %rax
je 0x5bae
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x5bd4
leaq 0x66e7(%rip), %rdi      # 0xc29c
leaq 0x67a4(%rip), %rsi      # 0xc360
movl $0x522, %edx            # imm = 0x522
xorl %eax, %eax
callq 0x20e0
leaq 0x6b26(%rip), %rdi      # 0xc6f5
callq 0x2080
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lengjingzju[P]json/json.c
// Function: pjson_add_new_item_to_array
json_object *pjson_add_new_item_to_array(json_object *array, json_type_t type, void *value, json_mem_t *mem)
{
    json_object *item = NULL;

    if (array->type_member == JSON_ARRAY) {
        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;
            }
            json_list_add_tail(&item->list, &array->value.head);
            return item;
        default:
            JsonErr("not support json type.\n");
            return NULL;
        }
    }

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x5c1d
cmpl $0x9, %esi
ja 0x5c21
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x2190
testq %rax, %rax
je 0x5c46
movq %rax, %rbx
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x5c6e
xorl %ebx, %ebx
jmp 0x5c6e
leaq 0x6674(%rip), %rdi      # 0xc29c
leaq 0x674b(%rip), %rsi      # 0xc37a
xorl %ebx, %ebx
movl $0x543, %edx            # imm = 0x543
xorl %eax, %eax
callq 0x20e0
leaq 0x6ae2(%rip), %rdi      # 0xc726
jmp 0x5c69
leaq 0x664f(%rip), %rdi      # 0xc29c
leaq 0x6726(%rip), %rsi      # 0xc37a
xorl %ebx, %ebx
movl $0x53d, %edx            # imm = 0x53D
xorl %eax, %eax
callq 0x20e0
leaq 0x6aa9(%rip), %rdi      # 0xc712
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5cd9
cmpl $0x9, %esi
ja 0x5cdd
movq %r8, %r15
movq %rdx, %r12
movq %rdi, %r14
movl %esi, %edi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x2190
testq %rax, %rax
je 0x5d02
movq %rax, %rbx
leaq 0x8(%rax), %rsi
addq $0x28, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x21f0
testl %eax, %eax
js 0x5d27
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x5d4f
xorl %ebx, %ebx
jmp 0x5d4f
leaq 0x65b8(%rip), %rdi      # 0xc29c
leaq 0x66ab(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x566, %edx            # imm = 0x566
xorl %eax, %eax
callq 0x20e0
leaq 0x6a26(%rip), %rdi      # 0xc726
jmp 0x5d4a
leaq 0x6593(%rip), %rdi      # 0xc29c
leaq 0x6686(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x55c, %edx            # imm = 0x55C
xorl %eax, %eax
callq 0x20e0
leaq 0x69ed(%rip), %rdi      # 0xc712
jmp 0x5d4a
leaq 0x656e(%rip), %rdi      # 0xc29c
leaq 0x6661(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x560, %edx            # imm = 0x560
xorl %eax, %eax
callq 0x20e0
leaq 0x69b8(%rip), %rdi      # 0xc702
callq 0x2080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r15
movl (%rsi), %r13d
leal 0x1f(%r13), %eax
testl %r13d, %r13d
cmovnsl %r13d, %eax
movq %rdi, %r12
sarl $0x5, %eax
movslq %eax, %rbp
leaq 0xc(,%rbp,4), %rdi
callq 0x10d0
testq %rax, %rax
je 0x12b6
movq %rax, %r14
leal 0x1(%rbp), %eax
movl %eax, 0xc(%rsp)
leaq 0x4(,%rbp,4), %rdx
movq %r12, 0x10(%rsp)
movl 0x1c(%r15), %r12d
shll $0x10, %r12d
xorl 0x18(%r15), %r12d
movl %r12d, %eax
shrl $0x10, %eax
addl %r12d, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
movq %r14, %rdi
addq $0x8, %rdi
callq 0x1090
movl $0x13, %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r15, %rsi
rep  movsl (%rsi), %es:(%rdi)
movl 0xc(%rsp), %ecx
movq %r14, 0x50(%rax)
movl %ecx, (%r14)
movl %ebp, 0x4(%r14)
movl %ebx, 0x8(%r14)
movl %r12d, 0xc(%r14)
xorl %eax, %eax
cmpl $0x20, %r13d
jl 0x12bb
movl %ecx, %ecx
movl $0x1, %edx
movl %ebx, %esi
shrl $0x1e, %esi
xorl %ebx, %esi
imull $0x6c078965, %esi, %ebx # imm = 0x6C078965
addl %edx, %ebx
xorl 0x8(%r14,%rdx,4), %ebx
movl %ebx, 0x8(%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x1293
jmp 0x12bb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x71b(%rip), %rsi       # 0x200c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x715(%rip), %r15       # 0x2017
xorl %r12d, %r12d
movzbl 0x34(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
cmpq $0x14, %r12
jne 0x1905
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O3/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 0x199c
movl 0x10(%rdi), %eax
xorl %edx, %eax
testb $0x2, %dl
je 0x19a4
xorl 0x14(%rdi), %eax
testb $0x4, %dl
je 0x19ac
xorl 0x18(%rdi), %eax
testb $0x8, %dl
je 0x19b4
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 0x19eb
xorl 0x20(%rdi), %ecx
testb $0x2, %al
je 0x19f2
xorl 0x24(%rdi), %ecx
testb $0x4, %al
je 0x19f9
xorl 0x28(%rdi), %ecx
testb $0x8, %al
je 0x1a00
xorl 0x2c(%rdi), %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1939
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movd %eax, %xmm0
addss 0x597(%rip), %xmm0      # 0x2004
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1b01
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x4, %ebp
leaq 0x58b(%rip), %r15       # 0x201c
movl %esi, 0x4(%rsp)
movl %esi, %r13d
xorl %ebx, %ebx
movl %ebx, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %r12d
movq %r14, %rdi
callq 0x1939
movq %r15, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1080
addl %ebp, %r12d
jne 0x1ad0
movl $0xa, %edi
callq 0x1040
incl %ebx
decl %ebp
decl %r13d
jne 0x1a9a
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jb 0x1b01
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1ba1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x4fb(%rip), %r15       # 0x2022
movl %esi, 0x4(%rsp)
movl %esi, %ebx
movl %ebp, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %r13d
movq %r14, %rdi
callq 0x1939
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1b71
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1b2d
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
jb 0x1b93
movl $0xa, %edi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1c53
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x452(%rip), %r15       # 0x2022
movl %esi, 0x4(%rsp)
movl %esi, %ebx
movl %ebp, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %r13d
movq %r14, %rdi
callq 0x1939
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movd %eax, %xmm0
addss 0x3ff(%rip), %xmm0      # 0x2004
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1c22
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1bd6
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jb 0x1c53
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1d03
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x3a9(%rip), %r15       # 0x2022
movl %esi, 0x4(%rsp)
movl %esi, %ebx
movl %ebp, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %r13d
movq %r14, %rdi
callq 0x1939
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movd %eax, %xmm0
movss 0x35a(%rip), %xmm1      # 0x2008
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1cd2
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1c7f
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jb 0x1d03
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1dac
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x2f9(%rip), %r15       # 0x2022
movl %esi, 0x4(%rsp)
movl %esi, %ebx
movl %ebp, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %r13d
movq %r14, %rdi
callq 0x1939
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movd %eax, %xmm0
addss 0x2a6(%rip), %xmm0      # 0x2004
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1d7b
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1d2f
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jb 0x1dac
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rax    # imm = 0x1FFFFFFFFF0
andq %rcx, %rax
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x118c
leaq 0xd3b(%rip), %rdi       # 0x2004
movq %rbx, %rsi
callq 0x1040
testl %eax, %eax
jne 0x12f8
leaq 0x1fe(%rbx), %rsi
addq $0xff, %rbx
movq %rbx, %rdi
callq 0x1060
testl %eax, %eax
js 0x1301
xorl %eax, %eax
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
leaq 0xd19(%rip), %rdi       # 0x2018
jmp 0x1308
leaq 0xd01(%rip), %rdi       # 0x2009
callq 0x1050
jmp 0x12ef
// File: /workspace/github_c_makefile_star2_O3/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 0x131d
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1100
movq %rax, %rsi
shll $0x14, %esi
leaq 0x6eac(%rip), %rdi      # 0x81d0
callq 0x1658
movl $0x100000, 0x6f25(%rip) # imm = 0x100000
movl $0x2000000, %esi        # imm = 0x2000000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1190
movq %rax, 0x6f07(%rip)      # 0x8260
movl $0x2, %ebp
leaq 0x3cc7(%rip), %r15      # 0x502c
leaq 0x3cc7(%rip), %r12      # 0x5033
leaq 0x3cbe(%rip), %r13      # 0x5031
leaq 0x3ca6(%rip), %rdi      # 0x5020
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
xorl %edi, %edi
callq 0x11b0
movq %r15, %rdi
callq 0x10b0
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x6e30(%rip), %rdi      # 0x81d0
movl %ebp, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
callq 0x19f1
movq %r12, %rdi
movq %r13, %rsi
callq 0x10a0
movq %rax, 0x6e84(%rip)      # 0x8250
movl 0x6e86(%rip), %ecx      # 0x8258
testl %ecx, %ecx
jle 0x1425
movq 0x6e83(%rip), %rdi      # 0x8260
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq $0x0, (%rdi,%rbx)
je 0x140f
addq %rbx, %rdi
movq 0x6e5d(%rip), %rcx      # 0x8250
movl $0x20, %esi
movl $0x1, %edx
callq 0x1150
movq 0x6e57(%rip), %rdi      # 0x8260
movl 0x6e49(%rip), %ecx      # 0x8258
incq %r14
movslq %ecx, %rax
addq $0x20, %rbx
cmpq %rax, %r14
jl 0x13e2
movq 0x6e2b(%rip), %rax      # 0x8250
movq %rax, %rdi
callq 0x1130
incl %ebp
cmpl $0x8, %ebp
jne 0x1373
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_O3/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 %r12
pushq %rbx
pushq %rax
callq 0x1140
movq %rax, %rbx
shlq $0x20, %rbx
callq 0x1140
xorq %rbx, %rax
movq %rax, 0x6db3(%rip)      # 0x8268
xorl %r14d, %r14d
leaq 0x6db1(%rip), %r15      # 0x8270
leaq 0x74ba(%rip), %r12      # 0x8980
callq 0x1140
movq %rax, %rbx
shlq $0x20, %rbx
callq 0x1140
xorq %rbx, %rax
movq %rax, (%r14,%r15)
callq 0x1140
movq %rax, %rbx
shlq $0x20, %rbx
callq 0x1140
xorq %rbx, %rax
movq %rax, (%r14,%r12)
addq $0x8, %r14
cmpq $0x708, %r14            # imm = 0x708
jne 0x14c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7ac5(%rip), %rsi      # 0x9088
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq 0x7abe(%rip), %rax      # 0x9090
movslq %edx, %rdx
shlq $0x5, %rdx
movaps 0x8(%rsp), %xmm0
movaps 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%rdx)
movups %xmm0, (%rax,%rdx)
movslq 0x6c65(%rip), %rsi      # 0x8258
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movl 0x10(%rsp), %esi
movq 0x6c5a(%rip), %rax      # 0x8260
movslq %edx, %rcx
shlq $0x5, %rcx
cmpl 0x8(%rax,%rcx), %esi
jle 0x1629
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_O3/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 %rbx
movq %rdi, %rbx
leaq 0x1397(%rip), %rdi      # 0x316b
movl $0x1e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x139d(%rip), %rdi      # 0x318a
movl $0x23, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13a8(%rip), %rdi      # 0x31ae
movl $0x30, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13c0(%rip), %rdi      # 0x31df
movl $0x2b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13d3(%rip), %rdi      # 0x320b
movl $0x21, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13dc(%rip), %rdi      # 0x322d
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13f0(%rip), %rdi      # 0x325a
movl $0x25, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x13fd(%rip), %rdi      # 0x3280
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x1405(%rip), %rdi      # 0x32a1
movl $0x1e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10e0
leaq 0x140b(%rip), %rdi      # 0x32c0
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O3/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
movq %r14, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0x21d0
movl %eax, %ebp
movq %rsp, %r13
xorl %r15d, %r15d
movl %r12d, %edx
btcl %r15d, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x21d0
xorl %ebp, %eax
xorl %ecx, %ecx
btl %ecx, %eax
adcq $0x0, (%r13,%rcx,8)
incq %rcx
cmpq $0x10, %rcx
jne 0x1f1a
incq %r15
addq $0x100, %r13            # imm = 0x100
cmpq $0x10, %r15
jne 0x1f05
incq %r12
cmpq $0x10000, %r12          # imm = 0x10000
jne 0x1ef0
xorpd %xmm0, %xmm0
movq %rsp, %rax
xorl %ecx, %ecx
movq $-0x8000, %rdx          # imm = 0x8000
movsd 0x10d8(%rip), %xmm1     # 0x3038
movsd 0x10d8(%rip), %xmm2     # 0x3040
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
addq %rdx, %rdi
xorps %xmm3, %xmm3
cvtsi2sd %rdi, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rsi
cmpq $0x10, %rsi
jne 0x1f6a
incq %rcx
addq $0x100, %rax            # imm = 0x100
cmpq $0x10, %rcx
jne 0x1f68
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1fc1
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_O3/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
testl %esi, %esi
jle 0x227a
movl %esi, %esi
xorl %r8d, %r8d
leaq 0xec6(%rip), %r9        # 0x30ac
leaq 0x2ed3(%rip), %r10      # 0x50c0
movl (%rdi,%r8,8), %ecx
cmpq $0x9, %rcx
ja 0x226b
movslq (%r9,%rcx,4), %rcx
addq %r9, %rcx
jmpq *%rcx
xorl 0x4(%rdi,%r8,8), %eax
jmp 0x226b
notl %eax
jmp 0x226b
movl %eax, %eax
movzwl (%r10,%rax,2), %eax
jmp 0x226b
addl 0x4(%rdi,%r8,8), %eax
jmp 0x226b
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 0x226b
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
addl %edx, %eax
jmp 0x226b
imull 0x4(%rdi,%r8,8), %eax
jmp 0x226b
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
jmp 0x225c
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shrl %cl, %edx
xorl %edx, %eax
jmp 0x226b
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
subl %edx, %eax
movzwl %ax, %eax
incq %r8
cmpq %r8, %rsi
jne 0x21ed
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %edi, %eax
leaq 0xe50(%rip), %rcx       # 0x30d4
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq (%rsi), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rcx, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rcx
xorl %ecx, %edx
imull $0x60857ba9, %edx, %ecx # imm = 0x60857BA9
movl $0x88888889, %edx       # imm = 0x88888889
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx,4), %edx
leal (%rdx,%rdx,2), %edx
negl %edx
addl %edx, %ecx
incl %ecx
jmp 0x2336
xorl %ecx, %ecx
jmp 0x2336
movq (%rsi), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rcx, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rcx
xorl %ecx, %edx
imull $0x60857ba9, %edx, %ecx # imm = 0x60857BA9
shrl $0x10, %ecx
jmp 0x2336
movq (%rsi), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rcx, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rcx
xorl %ecx, %edx
imull $0x60857ba9, %edx, %ecx # imm = 0x60857BA9
shrl $0x10, %ecx
orq $0x1, %rcx
shlq $0x20, %rcx
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/annoroad[P]fqtools_plus/fqtools.c
// Function: writen
void writen(void){
	struct job* job = NULL;
	long seq = 0;
	long clean_seq = 0;
	FILE* fpout1 = g.fpout1;
	FILE* fpout2 = g.fpout2;
	for(;;){
		possess(write_first);
		wait_for(write_first,TO_BE,seq);
		job = write_head;
		if (clean_seq == g.QUOTA) {
			possess(in_pool.have);
			in_pool.term = 0;
			release(in_pool.have);
		}
		drop_space(job->in);
		write_head = job->next;
		twist(write_first,TO,write_head == NULL? -1:write_head->seq);
		
		seq++;
		if (!job->more) break;
		if (job->buffer1 == NULL){
			free_job(job);
			continue;
		}

		fwrite(job->buffer1,sizeof(char),job->l1,fpout1);
		if (g.single_or_pair) fwrite(job->buffer2,sizeof(char),job->l2,fpout2);
		free_job(job);
		clean_seq++;
	}

	free_job(job);

	possess(compress_have);
	if (compress_head->more != 0)
		fail();
	release(compress_have);
	possess(write_first);
	if (write_head != NULL)
		fail();
	twist(write_first,TO,-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x89a2(%rip), %rbx      # 0xb290
movq 0x89a3(%rip), %rax      # 0xb298
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x89b2(%rip), %rdi      # 0xb2b8
callq 0x6265
movq 0x89a6(%rip), %rdi      # 0xb2b8
xorl %esi, %esi
movq %r15, %rdx
callq 0x63cb
movq 0x899d(%rip), %r12      # 0xb2c0
cmpq 0x88ae(%rip), %r13      # 0xb1d8
jne 0x294b
movq 0x8995(%rip), %rdi      # 0xb2c8
callq 0x6265
movb $0x0, 0x899d(%rip)      # 0xb2dc
movq 0x8982(%rip), %rdi      # 0xb2c8
callq 0x6276
movq 0x10(%r12), %rbp
testq %rbp, %rbp
je 0x29ab
movq (%rbp), %rdi
callq 0x6265
movq (%rbp), %rdi
callq 0x65a7
cmpl $0x1, %eax
jne 0x2996
movq 0x18(%rbp), %r14
movq (%r14), %rdi
callq 0x6265
movq 0x8(%r14), %rax
movq %rax, 0x10(%rbp)
movq %rbp, 0x8(%r14)
movq (%r14), %rdi
movl $0x1, %edx
movl $0x1, %esi
callq 0x6394
movq (%rbp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x6394
movq 0x20(%r12), %rax
movq %rax, 0x8909(%rip)      # 0xb2c0
movq 0x88fa(%rip), %rdi      # 0xb2b8
testq %rax, %rax
je 0x29c8
movq (%rax), %rdx
jmp 0x29cf
movq $-0x1, %rdx
xorl %esi, %esi
callq 0x6394
cmpl $0x0, 0x8(%r12)
je 0x2a3e
movq 0x30(%r12), %rdi
testq %rdi, %rdi
jne 0x29f8
movq %r12, %rdi
callq 0x2aae
incq %r15
jmp 0x28ff
movslq 0x38(%r12), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x22c0
cmpb $0x0, 0x87b7(%rip)      # 0xb1c8
je 0x2a2b
movq 0x40(%r12), %rdi
movslq 0x48(%r12), %rdx
movl $0x1, %esi
movq (%rsp), %rcx
callq 0x22c0
incq %r15
movq %r12, %rdi
callq 0x2aae
incq %r13
jmp 0x28ff
movq %r12, %rdi
callq 0x2aae
movq 0x8893(%rip), %rdi      # 0xb2e0
callq 0x6265
movq 0x888f(%rip), %rax      # 0xb2e8
cmpl $0x0, 0x8(%rax)
jne 0x2aa4
movq 0x887a(%rip), %rdi      # 0xb2e0
callq 0x6276
movq 0x8846(%rip), %rdi      # 0xb2b8
callq 0x6265
cmpq $0x0, 0x8841(%rip)      # 0xb2c0
jne 0x2aa9
movq 0x8830(%rip), %rdi      # 0xb2b8
xorl %esi, %esi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6394
callq 0x2370
callq 0x2394
// File: /workspace/github_c_makefile_star2_O3/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 0x2b42
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x8742(%rip)      # 0xb204
je 0x2aef
movq 0x18(%rbx), %rdi
callq 0x6265
movq 0x18(%rbx), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x63cb
movq 0x18(%rbx), %rdi
callq 0x6276
movq 0x18(%rbx), %rdi
callq 0x6235
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2afd
callq 0x2040
cmpb $0x0, 0x86c4(%rip)      # 0xb1c8
je 0x2b14
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2b14
callq 0x2040
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2b22
callq 0x2040
cmpb $0x0, 0x869f(%rip)      # 0xb1c8
je 0x2b39
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2b39
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x874e(%rip), %rbx      # 0xb2a0
movq 0x874f(%rip), %r14      # 0xb2a8
xorl %r15d, %r15d
movq 0x878d(%rip), %rdi      # 0xb2f0
callq 0x6265
movq 0x8781(%rip), %rdi      # 0xb2f0
xorl %esi, %esi
movq %r15, %rdx
callq 0x63cb
movq 0x8778(%rip), %r12      # 0xb2f8
movq 0x28(%r12), %rax
movq %rax, 0x876c(%rip)      # 0xb2f8
movq 0x875d(%rip), %rdi      # 0xb2f0
testq %rax, %rax
je 0x2b9d
movq (%rax), %rdx
jmp 0x2ba4
movq $-0x1, %rdx
xorl %esi, %esi
callq 0x6394
cmpl $0x0, 0x8(%r12)
je 0x2c0d
movq 0x50(%r12), %rdi
movslq 0x58(%r12), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x22c0
cmpb $0x0, 0x85f7(%rip)      # 0xb1c8
je 0x2bea
movq 0x60(%r12), %rdi
movslq 0x68(%r12), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x22c0
movq 0x18(%r12), %rdi
callq 0x6265
movq 0x18(%r12), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x6394
incq %r15
jmp 0x2b5c
movq 0x18(%r12), %rdi
callq 0x6265
movq 0x18(%r12), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x6394
movq 0x86c1(%rip), %rdi      # 0xb2f0
callq 0x6265
cmpq $0x0, 0x86bc(%rip)      # 0xb2f8
jne 0x2c5e
movq 0x86ab(%rip), %rdi      # 0xb2f0
xorl %esi, %esi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6394
callq 0x23b8
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x70, %edi
callq 0x21c0
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movq %rax, 0x60(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rax, 0x30(%rbx)
cmpb $0x0, 0x82cf(%rip)      # 0xb204
je 0x2f42
xorl %edi, %edi
callq 0x61f0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8375(%rip), %rdi      # 0xb2c8
callq 0x6265
cmpl $0x0, 0x8379(%rip)      # 0xb2d8
jne 0x2f74
movq 0x8360(%rip), %rdi      # 0xb2c8
movl $0x1, %esi
xorl %edx, %edx
callq 0x63cb
movq 0x8355(%rip), %rbx      # 0xb2d0
testq %rbx, %rbx
je 0x2fc3
movq (%rbx), %rdi
callq 0x6265
movq 0x10(%rbx), %rax
movq %rax, 0x833d(%rip)      # 0xb2d0
movq 0x832e(%rip), %rdi      # 0xb2c8
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x6394
movq (%rbx), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x6394
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x830f(%rip), %eax      # 0xb2d8
testl %eax, %eax
jle 0x2fd5
decl %eax
movl %eax, 0x8303(%rip)      # 0xb2d8
leaq 0x82ec(%rip), %r14      # 0xb2c8
movq 0x82e5(%rip), %rdi      # 0xb2c8
callq 0x6276
movl $0x20, %edi
callq 0x21c0
movq %rax, %rbx
movl $0x1, %edi
callq 0x61f0
movq %rax, (%rbx)
movq %r14, 0x18(%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movl $0x18, %edi
callq 0x21c0
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl $0x1, %edi
movl $0x6e078, %esi          # imm = 0x6E078
callq 0x2140
movq %r15, 0x8(%r14)
movq %rax, 0x10(%r14)
movl $0x1, %edi
movl $0x1428, %esi           # imm = 0x1428
callq 0x2140
movq %rax, (%r14)
movq 0x81ca(%rip), %rdi      # 0xb218
cmpb $0x0, (%rdi)
je 0x3068
movl 0x81cf(%rip), %esi      # 0xb228
callq 0x6840
movq (%r14), %rcx
movq %rax, 0x1420(%rcx)
cmpb $0x0, 0x8159(%rip)      # 0xb1c8
je 0x2fba
movl $0x1, %edi
movl $0x1428, %esi           # imm = 0x1428
callq 0x2140
movq %rax, 0x8(%r14)
movq 0x8191(%rip), %rdi      # 0xb220
cmpb $0x0, (%rdi)
je 0x2fba
movl 0x818a(%rip), %esi      # 0xb228
callq 0x6840
movq 0x8(%r14), %rcx
movq %rax, 0x1420(%rcx)
jmp 0x2fba
// File: /workspace/github_c_makefile_star2_O3/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 0x31f2
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %r15
movq 0x81a7(%rip), %rdi      # 0xb280
leaq 0x1d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
incq 0x8111(%rip)            # 0xb208
movq 0x8182(%rip), %rdi      # 0xb280
leaq 0x41d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
movq 0x8161(%rip), %rdi      # 0xb280
leaq 0x81d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
movq 0x8140(%rip), %rdi      # 0xb280
addq $0xc1d, %r15            # imm = 0xC1D
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
cmpb $0x0, 0x8064(%rip)      # 0xb1c8
je 0x31ed
movq 0x8(%r14), %rax
movq 0x8(%rax), %r14
movq 0x810f(%rip), %rdi      # 0xb288
leaq 0x1d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
incq 0x807d(%rip)            # 0xb210
movq 0x80ee(%rip), %rdi      # 0xb288
leaq 0x41d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
movq 0x80d1(%rip), %rdi      # 0xb288
leaq 0x81d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
movq 0x80b4(%rip), %rdi      # 0xb288
addq $0xc1d, %r14            # imm = 0xC1D
movq %r14, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x31f2
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b23
movl $0x1, %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2140
movq %rax, 0x50(%rbx)
movq (%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x3b2f
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x3b2c
movb $0x0, (%rax)
movq 0x50(%rbx), %rdi
callq 0x20c0
movl %eax, 0x58(%rbx)
cmpb $0x0, 0x7661(%rip)      # 0xb1c8
je 0x3bc3
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x3b85
movl $0x1, %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2140
movq %rax, 0x60(%rbx)
movq 0x8(%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x3b92
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x3b8f
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_O3/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), %rcx
movq 0x10(%rdi), %rax
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x3c07
movl 0x761c(%rip), %esi      # 0xb1fc
movl 0x75fd(%rip), %r8d      # 0xb1e4
xorl %r9d, %r9d
movsbl 0xc1d(%rcx,%r9), %r10d
subl %esi, %r10d
cmpl %r8d, %r10d
jl 0x3bff
incq 0x40(%rax)
incq %r9
cmpq %r9, %rdx
jne 0x3bea
cmpb $0x0, 0x75ba(%rip)      # 0xb1c8
je 0x3c48
movq 0x8(%rdi), %rcx
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x3c48
movl 0x75da(%rip), %esi      # 0xb1fc
movl 0x75bc(%rip), %edi      # 0xb1e4
xorl %r8d, %r8d
movsbl 0xc1d(%rcx,%r8), %r9d
subl %esi, %r9d
cmpl %edi, %r9d
jl 0x3c40
incq 0x40(%rax)
incq %r8
cmpq %r8, %rdx
jne 0x3c2b
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x756b(%rip), %rax      # 0xb1d0
leaq (%r15,%rax), %rsi
addq $0x41d, %rsi            # imm = 0x41D
movslq 0x7555(%rip), %r14      # 0xb1cc
movq %r14, %rdx
callq 0x2170
movb $0xa, %bpl
movb %bpl, 0x41d(%r15,%r14)
movslq 0x753b(%rip), %rax      # 0xb1cc
xorl %r12d, %r12d
movb %r12b, 0x41e(%r15,%rax)
leaq 0xc1d(%r15), %rdi
movslq 0x7526(%rip), %rax      # 0xb1d0
leaq (%r15,%rax), %rsi
addq $0xc1d, %rsi            # imm = 0xC1D
movslq 0x7510(%rip), %r14      # 0xb1cc
movq %r14, %rdx
callq 0x2170
movb %bpl, 0xc1d(%r15,%r14)
movslq 0x74f9(%rip), %rax      # 0xb1cc
movb %r12b, 0xc1e(%r15,%rax)
cmpb %r12b, 0x74e6(%rip)     # 0xb1c8
je 0x3d24
movq 0x8(%rbx), %rax
movslq 0x74dd(%rip), %rcx      # 0xb1cc
movb %bpl, 0x41d(%rax,%rcx)
movslq 0x74ce(%rip), %rcx      # 0xb1cc
xorl %edx, %edx
movb %dl, 0x41e(%rax,%rcx)
movslq 0x74be(%rip), %rcx      # 0xb1cc
movb %bpl, 0xc1d(%rax,%rcx)
movslq 0x74af(%rip), %rcx      # 0xb1cc
movb %dl, 0xc1e(%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d5d
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x68a5
jmp 0x3d70
movq 0x74cc(%rip), %rdi      # 0xb230
addq $0x101d, %rsi           # imm = 0x101D
callq 0x67c9
movl %eax, %ebx
cmpb $0x0, 0x744f(%rip)      # 0xb1c8
je 0x3da5
movq 0x8(%r14), %rsi
movq 0x1420(%rsi), %rdi
testq %rdi, %rdi
je 0x3da9
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x68a5
jmp 0x3dbc
movb $0x1, %al
jmp 0x3dbc
movq 0x7488(%rip), %rdi      # 0xb238
addq $0x101d, %rsi           # imm = 0x101D
callq 0x67c9
mulb %bl
addq $0x8, %rsp
popq %rbx
popq %r14
retq