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

    if ((json = (json_object *)pjson_memory_alloc(sizeof(json_object), &mem->obj_mgr)) == NULL) {
        JsonErr("malloc failed!\n");
        return NULL;
    }
    memset(json, 0, sizeof(json_object));
    json->type_member = type;

    switch (type) {
    case JSON_NULL:
        break;
    case JSON_BOOL:   json->value.vnum.vbool = *(bool *)value;      break;
    case JSON_INT:    json->value.vnum.vint  = *(int32_t *)value;   break;
    case JSON_HEX:    json->value.vnum.vhex  = *(uint32_t *)value;  break;
    case JSON_LINT:   json->value.vnum.vlint = *(int64_t *)value;   break;
    case JSON_LHEX:   json->value.vnum.vlhex = *(uint64_t *)value;  break;
    case JSON_DOUBLE: json->value.vnum.vdbl  = *(double *)value;    break;
    case JSON_STRING:
        if (pjson_set_string_value(json, (json_string_t *)value, mem) < 0)
            return NULL;
        break;
    case JSON_ARRAY:
    case JSON_OBJECT:
        INIT_JSON_LIST_HEAD(&json->value.head);
        break;
    default:
        break;
    }

    return json;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
leaq 0x8(%rdx), %rsi
movl $0x28, %edi
callq 0x51a0
testq %rax, %rax
je 0x5300
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movl 0x8(%rax), %ecx
movl %r12d, %eax
andl $0xf, %eax
andl $-0x10, %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
decl %r12d
cmpl $0x8, %r12d
ja 0x5379
leaq 0x6e71(%rip), %rcx      # 0xc160
movslq (%rcx,%r12,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl (%r14), %eax
movl %eax, 0x18(%rbx)
jmp 0x5379
leaq 0x6f95(%rip), %rdi      # 0xc29c
leaq 0x6fec(%rip), %rsi      # 0xc2fa
xorl %ebx, %ebx
movl $0x46a, %edx            # imm = 0x46A
xorl %eax, %eax
callq 0x20f0
leaq 0x747d(%rip), %rdi      # 0xc7a0
callq 0x2090
jmp 0x5379
movq (%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x5379
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x5379
movb (%r14), %al
movb %al, 0x18(%rbx)
jmp 0x5379
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rbx)
jmp 0x5379
cmpl $0x7, %eax
jne 0x5377
movq %rbx, %rsi
addq $0x18, %rsi
addq $0x48, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x2200
testl %eax, %eax
jns 0x5379
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lengjingzju[P]json/json.c
// Function: pjson_create_item_array
json_object *pjson_create_item_array(json_type_t item_type, void *values, int count, json_mem_t *mem)
{
    int i = 0;
    void *value = NULL;
    json_object *json = NULL, *node = NULL;

    if ((json = pjson_create_array(mem)) == NULL) {
        JsonErr("create array failed!\n");
        return NULL;
    }

    for (i = 0; i < count; ++i) {
        switch (item_type) {
        case JSON_BOOL:   value = ((bool *)values) + i;         break;
        case JSON_INT:    value = ((int32_t *)values) + i;      break;
        case JSON_HEX:    value = ((uint32_t *)values) + i;     break;
        case JSON_LINT:   value = ((int64_t *)values) + i;      break;
        case JSON_LHEX:   value = ((uint64_t *)values) + i;     break;
        case JSON_DOUBLE: value = ((double *)values) + i;       break;
        case JSON_STRING: value = ((json_string_t *)values) + i;break;
        default: JsonErr("not support json type.\n");     return NULL;
        }

        if ((node = pjson_create_item(item_type, value, mem)) == NULL) {
            JsonErr("create item failed!\n");
            return NULL;
        }
        json_list_add_tail(&node->list, &json->value.head);
    }

    return json;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movl $0x8, %edi
movq %rcx, %rsi
callq 0x2040
testq %rax, %rax
je 0x544e
movq %rax, %rbx
testl %ebp, %ebp
jle 0x5495
movq 0x10(%rsp), %rax
leal -0x1(%rax), %r14d
cmpl $0x6, %r14d
ja 0x545c
movl %ebp, %ebp
xorl %r12d, %r12d
movq 0x8(%rsp), %r13
cmpl $0x5, %r14d
ja 0x541a
leaq 0x6d94(%rip), %rcx      # 0xc184
movslq (%rcx,%r14,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
leaq (%rax,%r12,8), %rsi
jmp 0x541d
movq 0x8(%rsp), %rax
leaq (%rax,%r12,4), %rsi
jmp 0x541d
movq 0x8(%rsp), %rax
leaq (%rax,%r12), %rsi
jmp 0x541d
movq %r13, %rsi
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x21a0
testq %rax, %rax
je 0x546a
movq 0x20(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%rbx)
incq %r12
addq $0x10, %r13
decq %rbp
jne 0x53e3
jmp 0x5495
leaq 0x728b(%rip), %r14      # 0xc6e0
movl $0x48f, %edx            # imm = 0x48F
jmp 0x5476
leaq 0x72c3(%rip), %r14      # 0xc726
movl $0x49c, %edx            # imm = 0x49C
jmp 0x5476
movl $0x4a0, %edx            # imm = 0x4A0
leaq 0x729c(%rip), %r14      # 0xc712
leaq 0x6e1f(%rip), %rdi      # 0xc29c
leaq 0x6e88(%rip), %rsi      # 0xc30c
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20f0
movq %r14, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lengjingzju[P]json/json.c
// Function: pjson_string_strdup
int pjson_string_strdup(json_string_t *src, json_string_t *dst, json_mem_mgr_t *mgr)
{
    json_string_info_update(src);
    json_string_info_update(dst);
    if (src->len) {
        if (dst->len < src->len) {
            if ((dst->str = (char *)pjson_memory_alloc(src->len + 1, mgr)) == NULL) {
                JsonErr("malloc failed!\n");
                dst->len = 0;
                return -1;
            }
        }
        dst->escaped = src->escaped;
        dst->len = src->len;
        memcpy(dst->str, src->str, src->len);
        dst->str[src->len] = '\0';
    } else {
        dst->escaped = 0;
        dst->len = 0;
        dst->str = NULL;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movl (%r14), %edi
movl (%rbx), %eax
cmpl $0x100, %edi            # imm = 0x100
jae 0x54e0
andl $0xef, %eax
movl %eax, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x553d
shrl $0x8, %edi
shrl $0x8, %eax
cmpl %edi, %eax
jae 0x54fe
incq %rdi
movq %r15, %rsi
callq 0x51a0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5545
movl (%r14), %eax
andl $0x10, %eax
movl (%rbx), %ecx
andl $-0x11, %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
andl (%r14), %eax
movzbl %cl, %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movl (%r14), %edx
shrl $0x8, %edx
callq 0x2190
movq 0x8(%rbx), %rax
movl (%r14), %ecx
shrl $0x8, %ecx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6d50(%rip), %rdi      # 0xc29c
leaq 0x6dd1(%rip), %rsi      # 0xc324
movl $0x4b0, %edx            # imm = 0x4B0
xorl %eax, %eax
callq 0x20f0
leaq 0x723a(%rip), %rdi      # 0xc7a0
callq 0x2090
movzbl (%rbx), %eax
movl %eax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x553f
// File: /workspace/github_c_makefile_star2_O1/lengjingzju[P]json/json.c
// Function: pjson_copy_item_to_array
int pjson_copy_item_to_array(json_object *array, json_object *item, json_mem_t *mem)
{
    json_object *node = NULL;

    if (array->type_member == JSON_ARRAY) {
        if ((node = pjson_deepcopy(item, mem)) == NULL) {
            JsonErr("copy failed!\n");
            return -1;
        }
        json_list_add_tail(&node->list, &array->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 $0x8, %eax
jne 0x5870
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2180
testq %rax, %rax
je 0x584a
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x5870
leaq 0x6a4b(%rip), %rdi      # 0xc29c
leaq 0x6aef(%rip), %rsi      # 0xc347
movl $0x512, %edx            # imm = 0x512
xorl %eax, %eax
callq 0x20f0
leaq 0x6e8a(%rip), %rdi      # 0xc6f5
callq 0x2090
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58dc
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2180
testq %rax, %rax
je 0x58b6
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
xorl %ebx, %ebx
jmp 0x58dc
leaq 0x69df(%rip), %rdi      # 0xc29c
leaq 0x6a9c(%rip), %rsi      # 0xc360
movl $0x522, %edx            # imm = 0x522
xorl %eax, %eax
callq 0x20f0
leaq 0x6e1e(%rip), %rdi      # 0xc6f5
callq 0x2090
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5925
cmpl $0x9, %esi
ja 0x5929
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x21a0
testq %rax, %rax
je 0x594e
movq %rax, %rbx
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x5976
xorl %ebx, %ebx
jmp 0x5976
leaq 0x696c(%rip), %rdi      # 0xc29c
leaq 0x6a43(%rip), %rsi      # 0xc37a
xorl %ebx, %ebx
movl $0x543, %edx            # imm = 0x543
xorl %eax, %eax
callq 0x20f0
leaq 0x6dda(%rip), %rdi      # 0xc726
jmp 0x5971
leaq 0x6947(%rip), %rdi      # 0xc29c
leaq 0x6a1e(%rip), %rsi      # 0xc37a
xorl %ebx, %ebx
movl $0x53d, %edx            # imm = 0x53D
xorl %eax, %eax
callq 0x20f0
leaq 0x6da1(%rip), %rdi      # 0xc712
callq 0x2090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59e1
cmpl $0x9, %esi
ja 0x59e5
movq %r8, %r15
movq %rdx, %r12
movq %rdi, %r14
movl %esi, %edi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x21a0
testq %rax, %rax
je 0x5a0a
movq %rax, %rbx
leaq 0x8(%rax), %rsi
addq $0x28, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x2200
testl %eax, %eax
js 0x5a2f
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, (%rax)
movq %rbx, 0x20(%r14)
jmp 0x5a57
xorl %ebx, %ebx
jmp 0x5a57
leaq 0x68b0(%rip), %rdi      # 0xc29c
leaq 0x69a3(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x566, %edx            # imm = 0x566
xorl %eax, %eax
callq 0x20f0
leaq 0x6d1e(%rip), %rdi      # 0xc726
jmp 0x5a52
leaq 0x688b(%rip), %rdi      # 0xc29c
leaq 0x697e(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x55c, %edx            # imm = 0x55C
xorl %eax, %eax
callq 0x20f0
leaq 0x6ce5(%rip), %rdi      # 0xc712
jmp 0x5a52
leaq 0x6866(%rip), %rdi      # 0xc29c
leaq 0x6959(%rip), %rsi      # 0xc396
xorl %ebx, %ebx
movl $0x560, %edx            # imm = 0x560
xorl %eax, %eax
callq 0x20f0
leaq 0x6cb0(%rip), %rdi      # 0xc702
callq 0x2090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x2e60(%rip), %r13      # 0x3fe0
movq (%r13), %rdi
callq 0x1060
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %eax, %edi
callq 0x1050
movq %rax, %r12
xorl %ebx, %ebx
testl %r12d, %r12d
je 0x11e5
leaq 0xe7b(%rip), %r14       # 0x2026
leaq 0xf(%rsp), %r15
cmpb $-0x1, 0xf(%rsp)
jne 0x11bf
movq %r14, %rdi
callq 0x1030
movslq %r12d, %rax
addq %rax, %rbx
movq (%r13), %rdi
callq 0x1060
movl $0x1, %edx
movl %eax, %edi
movq %r15, %rsi
callq 0x1050
movq %rax, %r12
testl %r12d, %r12d
jne 0x11b0
leaq 0xe18(%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_O1/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, %r15d
movq %rsi, %r14
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, %rbx
movq %r12, 0x10(%rsp)
leal 0x1(%rbp), %r12d
leaq 0x4(,%rbp,4), %rdx
movl %r15d, 0xc(%rsp)
movl 0x1c(%r14), %r15d
shll $0x10, %r15d
xorl 0x18(%r14), %r15d
movl %r15d, %eax
shrl $0x10, %eax
addl %r15d, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x1090
movl $0x13, %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r14, %rsi
rep  movsl (%rsi), %es:(%rdi)
movq %rbx, 0x50(%rax)
movl %r12d, (%rbx)
movl %ebp, 0x4(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
xorl %eax, %eax
cmpl $0x20, %r13d
jl 0x12bb
movl 0x8(%rbx), %ecx
movl $0x1, %edx
movl %ecx, %esi
shrl $0x1e, %esi
xorl %ecx, %esi
imull $0x6c078965, %esi, %ecx # imm = 0x6C078965
addl %edx, %ecx
xorl 0x8(%rbx,%rdx,4), %ecx
movl %ecx, 0x8(%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %r12
jne 0x1295
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_O1/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 0x714(%rip), %rsi       # 0x200c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x70e(%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 0x190c
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_O1/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 0x19a3
movl 0x10(%rdi), %eax
xorl %edx, %eax
testb $0x2, %dl
je 0x19ab
xorl 0x14(%rdi), %eax
testb $0x4, %dl
je 0x19b3
xorl 0x18(%rdi), %eax
testb $0x8, %dl
je 0x19bb
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 0x19f2
xorl 0x20(%rdi), %ecx
testb $0x2, %al
je 0x19f9
xorl 0x24(%rdi), %ecx
testb $0x4, %al
je 0x1a00
xorl 0x28(%rdi), %ecx
testb $0x8, %al
je 0x1a07
xorl 0x2c(%rdi), %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1940
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movd %eax, %xmm0
addss 0x590(%rip), %xmm0      # 0x2004
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b08
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x4, %ebp
leaq 0x584(%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 0x1940
movq %r15, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1080
addl %ebp, %r12d
jne 0x1ad7
movl $0xa, %edi
callq 0x1040
incl %ebx
decl %ebp
decl %r13d
jne 0x1aa1
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 0x1b08
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ba8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x4f4(%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 0x1940
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 0x1b78
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1b34
imull $0xcccccccd, 0x4(%rsp), %eax # imm = 0xCCCCCCCD
cmpl $0x33333334, %eax       # imm = 0x33333334
jb 0x1b9a
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_O1/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 0x1c5a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x44b(%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 0x1940
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movd %eax, %xmm0
addss 0x3f8(%rip), %xmm0      # 0x2004
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1c29
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1bdd
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 0x1c5a
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d0a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x3a2(%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 0x1940
shrl $0x9, %eax
orl $0x3f800000, %eax       # imm = 0x3F800000
movd %eax, %xmm0
movss 0x353(%rip), %xmm1      # 0x2008
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1cd9
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1c86
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 0x1d0a
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1db3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
movl $0x4, %r12d
leaq 0x2f2(%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 0x1940
shrl $0x9, %eax
orl $0x3f800001, %eax       # imm = 0x3F800001
movd %eax, %xmm0
addss 0x29f(%rip), %xmm0      # 0x2004
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
addl %r12d, %r13d
jne 0x1d82
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
decl %ebx
jne 0x1d36
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 0x1db3
movl $0xa, %edi
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd3f(%rip), %rdi       # 0x2004
movq %rbx, %rsi
callq 0x1040
testl %eax, %eax
jne 0x12f4
leaq 0x1fe(%rbx), %rsi
addq $0xff, %rbx
movq %rbx, %rdi
callq 0x1060
testl %eax, %eax
js 0x12fd
xorl %eax, %eax
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
leaq 0xd1d(%rip), %rdi       # 0x2018
jmp 0x1304
leaq 0xd05(%rip), %rdi       # 0x2009
callq 0x1050
jmp 0x12eb
// File: /workspace/github_c_makefile_star2_O1/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 0x164c
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 0x19ec
movq %r12, %rdi
movq %r13, %rsi
callq 0x10a0
movq %rax, 0x6e84(%rip)      # 0x8250
cmpl $0x0, 0x6e85(%rip)      # 0x8258
jle 0x1414
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x6e7f(%rip), %rdi      # 0x8260
cmpq $0x0, (%rdi,%rbx)
je 0x1401
addq %rbx, %rdi
movq 0x6e5e(%rip), %rcx      # 0x8250
movl $0x20, %esi
movl $0x1, %edx
callq 0x1150
incq %r14
movslq 0x6e4d(%rip), %rax      # 0x8258
addq $0x20, %rbx
cmpq %rax, %r14
jl 0x13da
movq 0x6e35(%rip), %rdi      # 0x8250
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_O1/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, 0x6dc0(%rip)      # 0x8268
xorl %r14d, %r14d
leaq 0x6dbe(%rip), %r15      # 0x8270
leaq 0x74c7(%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 0x14b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7ad2(%rip), %rsi      # 0x9088
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq 0x7acb(%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 0x6c72(%rip), %rsi      # 0x8258
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movl 0x10(%rsp), %esi
movq 0x6c67(%rip), %rax      # 0x8260
movslq %edx, %rcx
shlq $0x5, %rcx
cmpl 0x8(%rax,%rcx), %esi
jle 0x161c
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_O1/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 0x133d(%rip), %rdi      # 0x3146
movl $0x1e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x1343(%rip), %rdi      # 0x3165
movl $0x23, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x134e(%rip), %rdi      # 0x3189
movl $0x30, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x1366(%rip), %rdi      # 0x31ba
movl $0x2b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x1379(%rip), %rdi      # 0x31e6
movl $0x21, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x1382(%rip), %rdi      # 0x3208
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x1396(%rip), %rdi      # 0x3235
movl $0x25, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x13a3(%rip), %rdi      # 0x325b
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x13ab(%rip), %rdi      # 0x327c
movl $0x1e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x10f0
leaq 0x13b1(%rip), %rdi      # 0x329b
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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 0x2205
movl %eax, %ebp
movq %rsp, %r13
xorl %r15d, %r15d
movl %r12d, %edx
btcl %r15d, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2205
xorl %ebp, %eax
xorl %ecx, %ecx
btl %ecx, %eax
adcq $0x0, (%r13,%rcx,8)
incq %rcx
cmpq $0x10, %rcx
jne 0x1f4f
incq %r15
addq $0x100, %r13            # imm = 0x100
cmpq $0x10, %r15
jne 0x1f3a
incq %r12
cmpq $0x10000, %r12          # imm = 0x10000
jne 0x1f25
xorpd %xmm0, %xmm0
movq %rsp, %rax
xorl %ecx, %ecx
movq $-0x8000, %rdx          # imm = 0x8000
movsd 0x107b(%rip), %xmm1     # 0x3010
movsd 0x107b(%rip), %xmm2     # 0x3018
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 0x1f9f
incq %rcx
addq $0x100, %rax            # imm = 0x100
cmpq $0x10, %rcx
jne 0x1f9d
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1ff6
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 0x1100
// File: /workspace/github_c_makefile_star2_O1/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 0x22af
movl %esi, %esi
xorl %r8d, %r8d
leaq 0xe69(%rip), %r9        # 0x3084
leaq 0x2eae(%rip), %r10      # 0x50d0
movl (%rdi,%r8,8), %ecx
cmpq $0x9, %rcx
ja 0x22a0
movslq (%r9,%rcx,4), %rcx
addq %r9, %rcx
jmpq *%rcx
xorl 0x4(%rdi,%r8,8), %eax
jmp 0x22a0
notl %eax
jmp 0x22a0
movl %eax, %eax
movzwl (%r10,%rax,2), %eax
jmp 0x22a0
addl 0x4(%rdi,%r8,8), %eax
jmp 0x22a0
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 0x22a0
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
addl %edx, %eax
jmp 0x22a0
imull 0x4(%rdi,%r8,8), %eax
jmp 0x22a0
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
jmp 0x2291
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shrl %cl, %edx
xorl %edx, %eax
jmp 0x22a0
movb 0x4(%rdi,%r8,8), %cl
movl %eax, %edx
shll %cl, %edx
subl %edx, %eax
movzwl %ax, %eax
incq %r8
cmpq %r8, %rsi
jne 0x2222
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ecx
leaq 0xdf3(%rip), %rax       # 0x30ac
movslq (%rax,%rcx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movq (%rsi), %rax
movq %rax, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rax, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rax
xorl %eax, %edx
imull $0x60857ba9, %edx, %esi # imm = 0x60857BA9
movabsq $0x1111111111111112, %rdx # imm = 0x1111111111111112
movq %rsi, %rax
mulq %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rax,%rax,2), %rax
negq %rax
addq %rsi, %rax
incq %rax
jmp 0x2373
xorl %eax, %eax
jmp 0x2373
movq (%rsi), %rax
movq %rax, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rax, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rax
xorl %eax, %edx
imull $0x60857ba9, %edx, %eax # imm = 0x60857BA9
shrl $0x10, %eax
jmp 0x2373
movq (%rsi), %rax
movq %rax, %rdx
shrq $0x20, %rdx
movabsq $0x7c3c3267d015ceb5, %rdi # imm = 0x7C3C3267D015CEB5
imulq %rax, %rdi
incq %rdi
movq %rdi, (%rsi)
shrq $0x30, %rax
xorl %eax, %edx
imull $0x60857ba9, %edx, %eax # imm = 0x60857BA9
shrl $0x10, %eax
orq $0x1, %rax
shlq $0x20, %rax
orq %rax, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x40, %edi
callq 0x1060
movq %rax, %r14
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x2ee7(%rip)     # 0x40c0
leaq 0x2ee0(%rip), %r15      # 0x40c0
callq 0x1070
leaq 0x2e84(%rip), %rsi      # 0x4070
movl $0x8, %edx
movq %r14, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq $0x4
callq 0x10a0
addq $0x10, %rsp
leaq 0xdf1(%rip), %r15       # 0x2004
xorl %r12d, %r12d
movq (%r14,%r12,8), %rcx
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1030
incq %r12
cmpq $0x8, %r12
jne 0x1216
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_O1/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 0x89aa(%rip), %rbx      # 0xb288
movq 0x89ab(%rip), %rax      # 0xb290
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x89ba(%rip), %rdi      # 0xb2b0
callq 0x6275
movq 0x89ae(%rip), %rdi      # 0xb2b0
xorl %esi, %esi
movq %r15, %rdx
callq 0x63db
movq 0x89a5(%rip), %r12      # 0xb2b8
cmpq 0x88b6(%rip), %r13      # 0xb1d0
jne 0x293b
movq 0x899d(%rip), %rdi      # 0xb2c0
callq 0x6275
movb $0x0, 0x89a5(%rip)      # 0xb2d4
movq 0x898a(%rip), %rdi      # 0xb2c0
callq 0x6286
movq 0x10(%r12), %rbp
testq %rbp, %rbp
je 0x299b
movq (%rbp), %rdi
callq 0x6275
movq (%rbp), %rdi
callq 0x65a8
cmpl $0x1, %eax
jne 0x2986
movq 0x18(%rbp), %r14
movq (%r14), %rdi
callq 0x6275
movq 0x8(%r14), %rax
movq %rax, 0x10(%rbp)
movq %rbp, 0x8(%r14)
movq (%r14), %rdi
movl $0x1, %edx
movl $0x1, %esi
callq 0x63a4
movq (%rbp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x63a4
movq 0x20(%r12), %rax
movq %rax, 0x8911(%rip)      # 0xb2b8
movq 0x8902(%rip), %rdi      # 0xb2b0
testq %rax, %rax
je 0x29b8
movq (%rax), %rdx
jmp 0x29bf
movq $-0x1, %rdx
xorl %esi, %esi
callq 0x63a4
cmpl $0x0, 0x8(%r12)
je 0x2a2e
movq 0x30(%r12), %rdi
testq %rdi, %rdi
jne 0x29e8
movq %r12, %rdi
callq 0x2a9e
incq %r15
jmp 0x28ef
movslq 0x38(%r12), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x22b0
cmpb $0x0, 0x87bf(%rip)      # 0xb1c0
je 0x2a1b
movq 0x40(%r12), %rdi
movslq 0x48(%r12), %rdx
movl $0x1, %esi
movq (%rsp), %rcx
callq 0x22b0
incq %r15
movq %r12, %rdi
callq 0x2a9e
incq %r13
jmp 0x28ef
movq %r12, %rdi
callq 0x2a9e
movq 0x889b(%rip), %rdi      # 0xb2d8
callq 0x6275
movq 0x8897(%rip), %rax      # 0xb2e0
cmpl $0x0, 0x8(%rax)
jne 0x2a94
movq 0x8882(%rip), %rdi      # 0xb2d8
callq 0x6286
movq 0x884e(%rip), %rdi      # 0xb2b0
callq 0x6275
cmpq $0x0, 0x8849(%rip)      # 0xb2b8
jne 0x2a99
movq 0x8838(%rip), %rdi      # 0xb2b0
xorl %esi, %esi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63a4
callq 0x2360
callq 0x2384
// File: /workspace/github_c_makefile_star2_O1/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 0x2b32
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x874a(%rip)      # 0xb1fc
je 0x2adf
movq 0x18(%rbx), %rdi
callq 0x6275
movq 0x18(%rbx), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x63db
movq 0x18(%rbx), %rdi
callq 0x6286
movq 0x18(%rbx), %rdi
callq 0x6245
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2aed
callq 0x2040
cmpb $0x0, 0x86cc(%rip)      # 0xb1c0
je 0x2b04
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2b04
callq 0x2040
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2b12
callq 0x2040
cmpb $0x0, 0x86a7(%rip)      # 0xb1c0
je 0x2b29
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2b29
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8756(%rip), %rbx      # 0xb298
movq 0x8757(%rip), %r14      # 0xb2a0
xorl %r15d, %r15d
movq 0x8795(%rip), %rdi      # 0xb2e8
callq 0x6275
movq 0x8789(%rip), %rdi      # 0xb2e8
xorl %esi, %esi
movq %r15, %rdx
callq 0x63db
movq 0x8780(%rip), %r12      # 0xb2f0
movq 0x28(%r12), %rax
movq %rax, 0x8774(%rip)      # 0xb2f0
movq 0x8765(%rip), %rdi      # 0xb2e8
testq %rax, %rax
je 0x2b8d
movq (%rax), %rdx
jmp 0x2b94
movq $-0x1, %rdx
xorl %esi, %esi
callq 0x63a4
cmpl $0x0, 0x8(%r12)
je 0x2bfd
movq 0x50(%r12), %rdi
movslq 0x58(%r12), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x22b0
cmpb $0x0, 0x85ff(%rip)      # 0xb1c0
je 0x2bda
movq 0x60(%r12), %rdi
movslq 0x68(%r12), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x22b0
movq 0x18(%r12), %rdi
callq 0x6275
movq 0x18(%r12), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x63a4
incq %r15
jmp 0x2b4c
movq 0x18(%r12), %rdi
callq 0x6275
movq 0x18(%r12), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x63a4
movq 0x86c9(%rip), %rdi      # 0xb2e8
callq 0x6275
cmpq $0x0, 0x86c4(%rip)      # 0xb2f0
jne 0x2c4e
movq 0x86b3(%rip), %rdi      # 0xb2e8
xorl %esi, %esi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x63a4
callq 0x23a8
// File: /workspace/github_c_makefile_star2_O1/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 0x21b0
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, 0x82d7(%rip)      # 0xb1fc
je 0x2f32
xorl %edi, %edi
callq 0x6200
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq